New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

@dwmt/comlink

Package Overview
Dependencies
Maintainers
2
Versions
35
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@dwmt/comlink - npm Package Compare versions

Comparing version 1.1.3 to 1.1.4

1293

dist/Comlink.esm.js

@@ -64,7 +64,7 @@ import { inherits } from 'util';

var LocalStorage = typeof window !== 'undefined' ? window.localStorage : Storage;
var SessionStorage = typeof window !== 'undefined' ? window.sessionStorage : Storage;
const LocalStorage = typeof window !== 'undefined' ? window.localStorage : Storage;
const SessionStorage = typeof window !== 'undefined' ? window.sessionStorage : Storage;
var Storage$1 = {
LocalStorage: LocalStorage,
SessionStorage: SessionStorage,
LocalStorage,
SessionStorage,
CookieStorage: new CookieStorage(),

@@ -74,40 +74,2 @@ NodeStorage: new NodeStorage()

function _typeof(obj) {
"@babel/helpers - typeof";
if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
_typeof = function (obj) {
return typeof obj;
};
} else {
_typeof = function (obj) {
return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
};
}
return _typeof(obj);
}
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
function _defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function _createClass(Constructor, protoProps, staticProps) {
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
if (staticProps) _defineProperties(Constructor, staticProps);
return Constructor;
}
function generateUUID() {

@@ -121,71 +83,8 @@ return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {

function _await(value, then, direct) {
if (direct) {
return then ? then(value) : value;
}
const WebSocket = require('isomorphic-ws');
if (!value || !value.then) {
value = Promise.resolve(value);
}
const Loader = require('@dwmt/loader/lib/Loader');
return then ? value.then(then) : value;
}
var WebSocket = require('isomorphic-ws');
function _catch(body, recover) {
try {
var result = body();
} catch (e) {
return recover(e);
}
if (result && result.then) {
return result.then(void 0, recover);
}
return result;
}
var Loader = require('@dwmt/loader/lib/Loader');
function _rethrow(thrown, value) {
if (thrown) throw value;
return value;
}
function _finallyRethrows(body, finalizer) {
try {
var result = body();
} catch (e) {
return finalizer(true, e);
}
if (result && result.then) {
return result.then(finalizer.bind(null, false), finalizer.bind(null, true));
}
return finalizer(false, result);
}
function _empty() {}
function _awaitIgnored(value, direct) {
if (!direct) {
return value && value.then ? value.then(_empty) : Promise.resolve();
}
}
function _invoke(body, then) {
var result = body();
if (result && result.then) {
return result.then(then);
}
return then(result);
}
function getLoader(channel, options) {
var loader = new Loader();
let loader = new Loader();

@@ -200,3 +99,3 @@ if (typeof options.loader === 'boolean' && !options.loader) {

if (_typeof(options.loader) === 'object' && options.loader.work && options.loader.terminate) {
if (typeof options.loader === 'object' && options.loader.work && options.loader.terminate) {
loader = options.loader;

@@ -214,3 +113,3 @@ }

uri: options.uri,
"default": options["default"] || false,
default: options.default || false,
rpc: options.rpc || undefined,

@@ -220,4 +119,4 @@ onError: options.onError || function (err) {

},
headerHandler: options.headerHandler || function (headers) {
return _await(true);
headerHandler: options.headerHandler || async function (headers) {
return true;
},

@@ -231,4 +130,4 @@ loader: options.loader || new Loader(),

function wsStrategy(options) {
var self = this;
var channel = {
const self = this;
const channel = {
type: 'ws',

@@ -238,3 +137,3 @@ name: options.name,

uri: options.uri,
"default": options["default"] || false,
default: options.default || false,
auth: options.auth,

@@ -258,8 +157,9 @@ authHeader: options.authHeader,

callbacks: {
onConnectionOpen: function onConnectionOpen() {},
onConnectionClose: function onConnectionClose() {},
onConnectionError: function onConnectionError() {},
onConnectionTermination: function onConnectionTermination() {}
onConnectionOpen: function () {},
onConnectionClose: function () {},
onConnectionError: function () {},
onConnectionTermination: function () {}
},
terminate: function terminate() {
terminate() {
self._channels[options.name].connection.close();

@@ -275,4 +175,5 @@

},
connect: function connect() {
return new Promise(function (resolve, reject) {
connect() {
return new Promise((resolve, reject) => {
if (self._channels[options.name].connection !== null) {

@@ -282,12 +183,12 @@ return resolve(true);

var opts = [];
const opts = [];
if (options.auth) {
var headerObject = self.getHeader(options.authHeader);
const headerObject = self.getHeader(options.authHeader);
opts.push(headerObject.value);
}
var ws = new WebSocket(channel.protocol + channel.uri, opts);
const ws = new WebSocket(channel.protocol + channel.uri, opts);
self._channels[options.name].connection = ws;
ws.addEventListener('open', function () {
ws.addEventListener('open', () => {
self._channels[options.name].alive = true;

@@ -301,3 +202,3 @@

});
ws.addEventListener('close', function () {
ws.addEventListener('close', () => {
self._channels[options.name].alive = false;

@@ -309,3 +210,3 @@

});
ws.addEventListener('error', function (err) {
ws.addEventListener('error', err => {
self._channels[options.name].alive = false;

@@ -323,3 +224,3 @@

try {
var tr = JSON.parse(msg.data);
const tr = JSON.parse(msg.data);

@@ -341,27 +242,7 @@ if (options.rpc && options.rpc.headerHandler) {

if (tr._type === 'event') {
var eventSubscribers = self._channels[options.name].listeners[tr.event];
let eventSubscribers = self._channels[options.name].listeners[tr.event];
if (eventSubscribers.length) {
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = eventSubscribers[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var subscriber = _step.value;
subscriber(tr.message);
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator["return"] != null) {
_iterator["return"]();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
for (let subscriber of eventSubscribers) {
subscriber(tr.message);
}

@@ -377,2 +258,3 @@ }

}
};

@@ -382,8 +264,4 @@ return channel;

var Client =
/*#__PURE__*/
function () {
function Client() {
_classCallCheck(this, Client);
class Client {
constructor() {
this._axios = axios;

@@ -400,551 +278,391 @@ this._ws = WebSocket;

_createClass(Client, [{
key: "connect",
value: function connect() {
try {
var _this2 = this;
get channels() {
let channels = Object.keys(this._channels);
return channels || [];
}
var connecting = [];
async connect() {
let connecting = [];
for (var _i = 0, _Object$keys = Object.keys(_this2._channels); _i < _Object$keys.length; _i++) {
var channelName = _Object$keys[_i];
var channel = _this2._channels[channelName];
for (let channelName of Object.keys(this._channels)) {
let channel = this._channels[channelName];
if (channel.type === 'ws' && !channel.alive) {
connecting.push(channel.connect());
}
}
return Promise.all(connecting);
} catch (e) {
return Promise.reject(e);
if (channel.type === 'ws' && !channel.alive) {
connecting.push(channel.connect());
}
}
}, {
key: "channel",
value: function channel(channelName) {
if (!this._channels[channelName]) {
throw new Error("No channel registered with ".concat(channelName));
}
var self = this;
var channel = {};
channel.name = this._channels[channelName].name;
channel.alive = this._channels[channelName].alive;
return Promise.all(connecting);
}
if (this._channels[channelName].connectable) {
channel.connection = this._channels[channelName].connection;
channel.connect = this._channels[channelName].connect;
channel.terminate = this._channels[channelName].terminate;
}
channel(channelName) {
if (!this._channels[channelName]) {
throw new Error(`No channel registered with ${channelName}`);
}
channel.registerCallback = function (callbackName, cb) {
self._channels[channelName].callbacks[callbackName] = cb;
};
let self = this;
const channel = {};
channel.name = this._channels[channelName].name;
channel.alive = this._channels[channelName].alive;
return channel;
if (this._channels[channelName].connectable) {
channel.connection = this._channels[channelName].connection;
channel.connect = this._channels[channelName].connect;
channel.terminate = this._channels[channelName].terminate;
}
}, {
key: "registerDialect",
value: function registerDialect(_dialect) {
var dialect = Object.assign({}, _dialect);
dialect.router = dialect.router || function (route) {
return {
path: route
};
};
channel.registerCallback = function (callbackName, cb) {
self._channels[channelName].callbacks[callbackName] = cb;
};
dialect.parameter = dialect.parameter || function (data) {
return {
parameters: data
};
return channel;
}
registerDialect(_dialect) {
const dialect = Object.assign({}, _dialect);
dialect.router = dialect.router || function (route) {
return {
path: route
};
};
dialect.optioner = dialect.optioner || function () {
return {};
dialect.parameter = dialect.parameter || function (data) {
return {
parameters: data
};
};
this._dialects[dialect.name] = dialect;
dialect.optioner = dialect.optioner || function () {
return {};
};
if (dialect["default"] || this._defaultDialect === null) {
this._defaultDialect = dialect.name;
}
this._dialects[dialect.name] = dialect;
if (dialect.default || this._defaultDialect === null) {
this._defaultDialect = dialect.name;
}
}, {
key: "registerHeader",
value: function registerHeader(header) {
this._headers[header.name] = header;
}
}, {
key: "registerChannel",
value: function registerChannel(channel) {
var availableChannelTypes = ['http', 'ws'];
}
if (!channel.type in availableChannelTypes) {
throw new Error("[Comlink] Channel type \"".concat(channel.type, "\" is not supported!"));
}
registerHeader(header) {
this._headers[header.name] = header;
}
if (channel.type === 'http') {
var chn = httpStrategy.call(this, channel);
registerChannel(channel) {
let availableChannelTypes = ['http', 'ws'];
if (chn["default"]) {
this._deafultHTTPChannel = chn.name;
}
if (!channel.type in availableChannelTypes) {
throw new Error(`[Comlink] Channel type "${channel.type}" is not supported!`);
}
if (chn["default"] && chn.rpc) {
this._deafultRPCChannel = chn.name;
}
if (channel.type === 'http') {
const chn = httpStrategy.call(this, channel);
this._channels[chn.name] = chn;
if (chn.default) {
this._deafultHTTPChannel = chn.name;
}
if (channel.type === 'ws') {
var _chn = wsStrategy.call(this, channel);
if (chn.default && chn.rpc) {
this._deafultRPCChannel = chn.name;
}
if (_chn["default"]) {
this._deafultWSChannel = _chn.name;
}
this._channels[chn.name] = chn;
}
if (_chn["default"] && _chn.rpc) {
this._deafultRPCChannel = _chn.name;
}
if (channel.type === 'ws') {
const chn = wsStrategy.call(this, channel);
this._channels[_chn.name] = _chn;
if (chn.default) {
this._deafultWSChannel = chn.name;
}
if (chn.default && chn.rpc) {
this._deafultRPCChannel = chn.name;
}
this._channels[chn.name] = chn;
}
}, {
key: "checkHeaders",
value: function checkHeaders() {
var _this3 = this;
}
var headers = Object.keys(this._headers);
headers.forEach(function (headerKey) {
var header = _this3._headers[headerKey];
get headers() {
return Object.keys(this._headers);
}
if (header.type === 'automatic') {
var val = header.storage.getItem(header.key);
checkHeaders() {
const headers = Object.keys(this._headers);
headers.forEach(headerKey => {
const header = this._headers[headerKey];
if (val) {
header.value = val;
}
if (header.type === 'automatic') {
const val = header.storage.getItem(header.key);
if (val) {
header.value = val;
}
});
}
}, {
key: "getHeader",
value: function getHeader(name) {
if (!this._headers[name]) {
throw new Error("No registered header with name ".concat(name));
}
});
}
return {
key: this._headers[name].key,
value: this._headers[name].value
};
getHeader(name) {
if (!this._headers[name]) {
throw new Error(`No registered header with name ${name}`);
}
}, {
key: "setHeader",
value: function setHeader(name, value) {
if (!this._headers[name]) {
throw new Error("No registered header with name ".concat(name));
}
this._headers[name].value = value;
return {
key: this._headers[name].key,
value: this._headers[name].value
};
}
if (this._headers[name].type === 'automatic') {
this._headers[name].storage.setItem(this._headers[name].key, value);
}
setHeader(name, value) {
if (!this._headers[name]) {
throw new Error(`No registered header with name ${name}`);
}
}, {
key: "get",
value: function get(URI) {
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
try {
var _this5 = this;
this._headers[name].value = value;
_this5.checkDefaultHTTPChannel();
if (this._headers[name].type === 'automatic') {
this._headers[name].storage.setItem(this._headers[name].key, value);
}
}
var channelName = options.channel || _this5._deafultHTTPChannel;
var channel = _this5._channels[channelName];
var loader = getLoader(channel, options);
var errorHandler = options.onError || channel.onError;
var loaderID = loader.work();
return _finallyRethrows(function () {
return _catch(function () {
var url = channel.protocol + channel.uri + '/' + URI;
var pat = /^https?:\/\//i;
async get(URI, options = {}) {
this.checkDefaultHTTPChannel();
const channelName = options.channel || this._deafultHTTPChannel;
const channel = this._channels[channelName];
const loader = getLoader(channel, options);
const errorHandler = options.onError || channel.onError;
const loaderID = loader.work();
if (pat.test(URI)) {
url = URI;
}
try {
let url = channel.protocol + channel.uri + '/' + URI;
var pat = /^https?:\/\//i;
return _await(axios.get(url, options.axios || {}), function (resp) {
return _await(channel.headerHandler(resp.headers), function () {
return resp;
});
});
}, function (err) {
return _await(channel.headerHandler(err.response.headers), function () {
return _await(errorHandler(err), function () {
throw err;
});
});
});
}, function (_wasThrown, _result) {
loader.terminate(loaderID);
return _rethrow(_wasThrown, _result);
});
} catch (e) {
return Promise.reject(e);
if (pat.test(URI)) {
url = URI;
}
const resp = await axios.get(url, options.axios || {});
await channel.headerHandler(resp.headers);
return resp;
} catch (err) {
await channel.headerHandler(err.response.headers);
await errorHandler(err);
throw err;
} finally {
loader.terminate(loaderID);
}
}, {
key: "checkDefaultHTTPChannel",
value: function checkDefaultHTTPChannel() {
if (!this._deafultHTTPChannel) {
throw new Error('[Comlink] No default HTTP channel');
}
}
checkDefaultHTTPChannel() {
if (!this._deafultHTTPChannel) {
throw new Error('[Comlink] No default HTTP channel');
}
}, {
key: "post",
value: function post(URI, data) {
var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
}
try {
var _this7 = this;
async post(URI, data, options = {}) {
this.checkDefaultHTTPChannel();
const channelName = options.channel || this._deafultHTTPChannel;
const channel = this._channels[channelName];
const loader = getLoader(channel, options);
const errorHandler = options.onError || channel.onError;
const loaderID = loader.work();
_this7.checkDefaultHTTPChannel();
try {
let url = channel.protocol + channel.uri + '/' + URI;
var pat = /^https?:\/\//i;
var channelName = options.channel || _this7._deafultHTTPChannel;
var channel = _this7._channels[channelName];
var loader = getLoader(channel, options);
var errorHandler = options.onError || channel.onError;
var loaderID = loader.work();
return _finallyRethrows(function () {
return _catch(function () {
var url = channel.protocol + channel.uri + '/' + URI;
var pat = /^https?:\/\//i;
if (pat.test(URI)) {
url = URI;
}
if (pat.test(URI)) {
url = URI;
}
return _await(axios.post(url, data, options.axios || {}), function (resp) {
return _await(channel.headerHandler(resp.headers), function () {
return resp;
});
});
}, function (err) {
return _await(channel.headerHandler(err.response.headers), function () {
return _await(errorHandler(err), function () {
throw err;
});
});
});
}, function (_wasThrown2, _result2) {
loader.terminate(loaderID);
return _rethrow(_wasThrown2, _result2);
});
} catch (e) {
return Promise.reject(e);
}
const resp = await axios.post(url, data, options.axios || {});
await channel.headerHandler(resp.headers);
return resp;
} catch (err) {
await channel.headerHandler(err.response.headers);
await errorHandler(err);
throw err;
} finally {
loader.terminate(loaderID);
}
}, {
key: "put",
value: function put(URI, data) {
var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
}
try {
var _this9 = this;
async put(URI, data, options = {}) {
this.checkDefaultHTTPChannel();
const channelName = options.channel || this._deafultHTTPChannel;
const channel = this._channels[channelName];
const loader = getLoader(channel, options);
const errorHandler = options.onError || channel.onError;
const loaderID = loader.work();
_this9.checkDefaultHTTPChannel();
try {
let url = channel.protocol + channel.uri + '/' + URI;
var pat = /^https?:\/\//i;
var channelName = options.channel || _this9._deafultHTTPChannel;
var channel = _this9._channels[channelName];
var loader = getLoader(channel, options);
var errorHandler = options.onError || channel.onError;
var loaderID = loader.work();
return _finallyRethrows(function () {
return _catch(function () {
var url = channel.protocol + channel.uri + '/' + URI;
var pat = /^https?:\/\//i;
if (pat.test(URI)) {
url = URI;
}
if (pat.test(URI)) {
url = URI;
}
return _await(axios.put(url, data, options.axios || {}), function (resp) {
return _await(channel.headerHandler(resp.headers), function () {
return resp;
});
});
}, function (err) {
return _await(channel.headerHandler(err.response.headers), function () {
return _await(errorHandler(err), function () {
throw err;
});
});
});
}, function (_wasThrown3, _result3) {
loader.terminate(loaderID);
return _rethrow(_wasThrown3, _result3);
});
} catch (e) {
return Promise.reject(e);
}
const resp = await axios.put(url, data, options.axios || {});
await channel.headerHandler(resp.headers);
return resp;
} catch (err) {
await channel.headerHandler(err.response.headers);
await errorHandler(err);
throw err;
} finally {
loader.terminate(loaderID);
}
}, {
key: "delete",
value: function _delete(URI) {
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
}
try {
var _this11 = this;
async delete(URI, options = {}) {
this.checkDefaultHTTPChannel();
const channelName = options.channel || this._deafultHTTPChannel;
const channel = this._channels[channelName];
const loader = getLoader(channel, options);
const errorHandler = options.onError || channel.onError;
const loaderID = loader.work();
_this11.checkDefaultHTTPChannel();
try {
let url = channel.protocol + channel.uri + '/' + URI;
var pat = /^https?:\/\//i;
var channelName = options.channel || _this11._deafultHTTPChannel;
var channel = _this11._channels[channelName];
var loader = getLoader(channel, options);
var errorHandler = options.onError || channel.onError;
var loaderID = loader.work();
return _finallyRethrows(function () {
return _catch(function () {
var url = channel.protocol + channel.uri + '/' + URI;
var pat = /^https?:\/\//i;
if (pat.test(URI)) {
url = URI;
}
if (pat.test(URI)) {
url = URI;
}
return _await(axios["delete"](url, options.axios || {}), function (resp) {
return _await(channel.headerHandler(resp.headers), function () {
return resp;
});
});
}, function (err) {
return _await(channel.headerHandler(err.response.headers), function () {
return _await(errorHandler(err), function () {
throw err;
});
});
});
}, function (_wasThrown4, _result4) {
loader.terminate(loaderID);
return _rethrow(_wasThrown4, _result4);
});
} catch (e) {
return Promise.reject(e);
}
const resp = await axios.delete(url, options.axios || {});
await channel.headerHandler(resp.headers);
return resp;
} catch (err) {
await channel.headerHandler(err.response.headers);
await errorHandler(err);
throw err;
} finally {
loader.terminate(loaderID);
}
}, {
key: "subscribeToEvent",
value: function subscribeToEvent(event, callback) {
var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
var channelName = options.channel || this._deafultRPCChannel;
var channel = this._channels[channelName];
}
if (!channel.listeners[event]) {
channel.listeners[event] = [];
}
subscribeToEvent(event, callback, options = {}) {
const channelName = options.channel || this._deafultRPCChannel;
const channel = this._channels[channelName];
channel.listeners[event].push(callback);
if (!channel.listeners[event]) {
channel.listeners[event] = [];
}
}, {
key: "unsubscribeFromEvent",
value: function unsubscribeFromEvent(event, callback) {
var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
var channelName = options.channel || this._deafultRPCChannel;
var channel = this._channels[channelName];
if (!channel.listeners[event]) {
return;
}
channel.listeners[event].push(callback);
}
channel.listeners[event] = channel.listeners[event].filter(function (fn) {
return fn !== callback;
});
unsubscribeFromEvent(event, callback, options = {}) {
const channelName = options.channel || this._deafultRPCChannel;
const channel = this._channels[channelName];
if (!channel.listeners[event]) {
return;
}
}, {
key: "sendMessage",
value: function sendMessage() {
throw new Error('Not implemented yet!');
}
}, {
key: "_rpc",
value: function _rpc() {
var type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'request';
var path = arguments.length > 1 ? arguments[1] : undefined;
var data = arguments.length > 2 ? arguments[2] : undefined;
var options = arguments.length > 3 ? arguments[3] : undefined;
var _dialect = arguments.length > 4 ? arguments[4] : undefined;
channel.listeners[event] = channel.listeners[event].filter(fn => fn !== callback);
}
try {
var _this13 = this;
sendMessage() {
throw new Error('Not implemented yet!');
}
var channel = _this13._channels[options.channel || _this13._deafultRPCChannel];
var dialect = _this13._dialects[_dialect || _this13._defaultDialect];
var rpcConfig = channel.rpc;
async _rpc(type = 'request', path, data, options, _dialect) {
const channel = this._channels[options.channel || this._deafultRPCChannel];
const dialect = this._dialects[_dialect || this._defaultDialect];
const rpcConfig = channel.rpc;
if (!rpcConfig.dialects.includes(dialect.name)) {
throw new Error("The channel ".concat(channel.name, " not supports the ").concat(dialect.name, " dialect"));
}
var channelDialectConfig = rpcConfig[dialect.name] || {};
var idGenerator = channelDialectConfig.idGenerator || rpcConfig.idGenerator || generateUUID;
var ID = idGenerator();
var message = {
id: ID,
_dialect: dialect.name,
_type: type
};
var router = dialect.router(path);
var parameter = dialect.parameter(data);
var optioner = dialect.optioner(options);
message = Object.assign({}, message, dialect["interface"], router, parameter, optioner);
return _invoke(function () {
if (channel.connection === null) {
return _awaitIgnored(channel.connect());
}
}, function () {
channel.connection.send(JSON.stringify(message));
var answerPromise = new Promise(function (resolve, reject) {
channel.answers[ID] = {
resolve: resolve,
reject: reject
};
});
var timeoutPromise = new Promise(function (resolve, reject) {
setTimeout(function () {
reject("[Comlink] Maximum retries exceeded for message: ".concat(ID));
}, rpcConfig.retryInterval * rpcConfig.maxRetries);
});
return Promise.race([answerPromise, timeoutPromise]);
});
} catch (e) {
return Promise.reject(e);
}
if (!rpcConfig.dialects.includes(dialect.name)) {
throw new Error(`The channel ${channel.name} not supports the ${dialect.name} dialect`);
}
}, {
key: "request",
value: function request(path, data) {
var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
var _dialect = arguments.length > 3 ? arguments[3] : undefined;
const channelDialectConfig = rpcConfig[dialect.name] || {};
const idGenerator = channelDialectConfig.idGenerator || rpcConfig.idGenerator || generateUUID;
const ID = idGenerator();
let message = {
id: ID,
_dialect: dialect.name,
_type: type
};
const router = dialect.router(path);
const parameter = dialect.parameter(data);
const optioner = dialect.optioner(options);
message = Object.assign({}, message, dialect.interface, router, parameter, optioner);
try {
var _this15 = this;
var channelName = options.channel || _this15._deafultRPCChannel;
var channel = _this15._channels[channelName];
var loader = getLoader(channel, options);
var errorHandler = options.onError || channel.onError;
var loaderID = loader.work();
return _finallyRethrows(function () {
return _catch(function () {
if (channel.type === 'http') {
var url = channel.protocol + channel.uri + '/';
return _await(axios.post(url, options.axios || {}));
} else {
return _this15._rpc('request', path, data, options, _dialect);
}
}, function (err) {
return _await(errorHandler(err), function () {
throw err;
});
});
}, function (_wasThrown5, _result5) {
loader.terminate(loaderID);
return _rethrow(_wasThrown5, _result5);
});
} catch (e) {
return Promise.reject(e);
}
if (channel.connection === null) {
await channel.connect();
}
}, {
key: "inform",
value: function inform(path, data) {
var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
var _dialect = arguments.length > 3 ? arguments[3] : undefined;
channel.connection.send(JSON.stringify(message));
const answerPromise = new Promise((resolve, reject) => {
channel.answers[ID] = {
resolve,
reject
};
});
const timeoutPromise = new Promise((resolve, reject) => {
setTimeout(() => {
reject(`[Comlink] Maximum retries exceeded for message: ${ID}`);
}, rpcConfig.retryInterval * rpcConfig.maxRetries);
});
return Promise.race([answerPromise, timeoutPromise]);
}
try {
var _this17 = this;
async request(path, data, options = {}, _dialect) {
const channelName = options.channel || this._deafultRPCChannel;
const channel = this._channels[channelName];
const loader = getLoader(channel, options);
const errorHandler = options.onError || channel.onError;
const loaderID = loader.work();
var channelName = options.channel || _this17._deafultRPCChannel;
var channel = _this17._channels[channelName];
var loader = getLoader(channel, options);
var errorHandler = options.onError || channel.onError;
var loaderID = loader.work();
return _finallyRethrows(function () {
return _catch(function () {
if (channel.type === 'http') {
var url = channel.protocol + channel.uri + '/';
return _await(axios.post(url, options.axios || {}));
} else {
return _this17._rpc('inform', path, data, options, _dialect);
}
}, function (err) {
return _await(errorHandler(err), function () {
throw err;
});
});
}, function (_wasThrown6, _result6) {
loader.terminate(loaderID);
return _rethrow(_wasThrown6, _result6);
});
} catch (e) {
return Promise.reject(e);
try {
if (channel.type === 'http') {
const url = channel.protocol + channel.uri + '/';
const req = await axios.post(url, options.axios || {});
return req;
} else {
return this._rpc('request', path, data, options, _dialect);
}
} catch (err) {
await errorHandler(err, options);
throw err;
} finally {
loader.terminate(loaderID);
}
}, {
key: "channels",
get: function get() {
var channels = Object.keys(this._channels);
return channels || [];
}
}, {
key: "headers",
get: function get() {
return Object.keys(this._headers);
}
}]);
return Client;
}();
function _await$1(value, then, direct) {
if (direct) {
return then ? then(value) : value;
}
if (!value || !value.then) {
value = Promise.resolve(value);
}
async inform(path, data, options = {}, _dialect) {
const channelName = options.channel || this._deafultRPCChannel;
const channel = this._channels[channelName];
const loader = getLoader(channel, options);
const errorHandler = options.onError || channel.onError;
const loaderID = loader.work();
return then ? value.then(then) : value;
}
var _require = require('events'),
EventEmitter = _require.EventEmitter;
function _invoke$1(body, then) {
var result = body();
if (result && result.then) {
return result.then(then);
try {
if (channel.type === 'http') {
const url = channel.protocol + channel.uri + '/';
const req = await axios.post(url, options.axios || {});
return req;
} else {
return this._rpc('inform', path, data, options, _dialect);
}
} catch (err) {
await errorHandler(err);
throw err;
} finally {
loader.terminate(loaderID);
}
}
return then(result);
}
var Server =
/*#__PURE__*/
function () {
function Server(logger) {
_classCallCheck(this, Server);
const {
EventEmitter
} = require('events');
class Server {
constructor(logger) {
this._dialects = {};

@@ -958,243 +676,182 @@ this._channels = {};

_createClass(Server, [{
key: "registerDialect",
value: function registerDialect(_dialect) {
this._dialects[_dialect.name] = _dialect;
registerDialect(_dialect) {
this._dialects[_dialect.name] = _dialect;
}
registerChannel(_channel) {
if (_channel.auth && !_channel.tokenValidator) {
throw new Error('For authentication you need a token validator');
}
}, {
key: "registerChannel",
value: function registerChannel(_channel) {
if (_channel.auth && !_channel.tokenValidator) {
throw new Error('For authentication you need a token validator');
}
if (_channel.type !== 'ws') {
throw new Error('Only websocket listeners implemented yet!');
}
this._channels[_channel.name] = _channel;
this.session[_channel.name] = {
clients: {},
tokens: {}
};
if (_channel.type !== 'ws') {
throw new Error('Only websocket listeners implemented yet!');
}
}, {
key: "sendMessageToClient",
value: function sendMessageToClient(channelName, clientID, event, message) {
if (!this.session[channelName].clients[clientID]) {
throw new Error('No user with given clientID');
}
this.eventEmitter.emit("sendEventTo:".concat(clientID), {
_type: 'event',
event: event,
message: message
});
this._channels[_channel.name] = _channel;
this.session[_channel.name] = {
clients: {},
tokens: {}
};
}
sendMessageToClient(channelName, clientID, event, message) {
if (!this.session[channelName].clients[clientID]) {
throw new Error('No user with given clientID');
}
}, {
key: "getClientIDByToken",
value: function getClientIDByToken(channelName, token) {
var clientID = this.session[channelName].tokens[token].client;
if (!clientID) {
throw new Error('No user with given token');
}
this.eventEmitter.emit(`sendEventTo:${clientID}`, {
_type: 'event',
event,
message
});
}
return clientID;
getClientIDByToken(channelName, token) {
let clientID = this.session[channelName].tokens[token].client;
if (!clientID) {
throw new Error('No user with given token');
}
}, {
key: "getTokenByClientID",
value: function getTokenByClientID(channelName, clientID) {
var token = this.session[channelName].clients[clientID].token;
if (!token) {
throw new Error('No user with given clientID');
}
return clientID;
}
return token;
getTokenByClientID(channelName, clientID) {
let token = this.session[channelName].clients[clientID].token;
if (!token) {
throw new Error('No user with given clientID');
}
}, {
key: "isTokenActive",
value: function isTokenActive(channelName, token) {
var clientID = this.session[channelName].tokens[token].client;
return !!clientID;
}
}, {
key: "isClientActive",
value: function isClientActive(channelName, clientID) {
var token = this.session[channelName].clients[clientID].token;
return !!token;
}
}, {
key: "applyChannel",
value: function applyChannel(channelName, wss) {
var _this = this;
var channel = this._channels[channelName];
return token;
}
if (!channel) {
throw new Error("Channel with name ".concat(channelName, " is not registered!"));
}
isTokenActive(channelName, token) {
let clientID = this.session[channelName].tokens[token].client;
return !!clientID;
}
wss.on('connection', _async(function (ws, req) {
var _exit = false;
var clientID = generateUUID();
_this.session[channelName].clients[clientID] = {};
return _invoke$1(function () {
if (channel.auth) {
var token = req.headers['sec-websocket-protocol'];
isClientActive(channelName, clientID) {
let token = this.session[channelName].clients[clientID].token;
return !!token;
}
if (!token || token.length === 0) {
_exit = true;
return ws.close();
}
applyChannel(channelName, wss) {
const channel = this._channels[channelName];
return _await$1(channel.tokenValidator(token), function (check) {
if (!check) {
_exit = true;
return ws.close();
}
if (!channel) {
throw new Error(`Channel with name ${channelName} is not registered!`);
}
_this.session[channelName].clients[clientID].token = token;
_this.session[channelName].tokens[token] = {
client: clientID
};
ws.id = clientID;
});
}
}, function (_result) {
if (_exit) return _result;
wss.on('connection', async (ws, req) => {
let clientID = generateUUID();
this.session[channelName].clients[clientID] = {};
_this.eventEmitter.on("sendEventTo:".concat(clientID), function (msg) {
ws.send(JSON.stringify(msg));
});
if (channel.auth) {
const token = req.headers['sec-websocket-protocol'];
ws.on('close', _async(function () {
var token = _this.session[channelName].clients[ws.id].token;
delete _this.session[channelName].clients[ws.id];
delete _this.session[channelName].tokens[token];
return _await$1();
}));
ws.on('message', _async(function (message) {
var _exit2 = false;
var parsed = JSON.parse(message);
var dialect = parsed._dialect;
if (!token || token.length === 0) {
return ws.close();
}
if (!dialect) {
return;
}
let check = await channel.tokenValidator(token);
var id = parsed.id;
if (!check) {
return ws.close();
}
var channelDialect = _this._channels[channelName].dialects.includes(dialect);
this.session[channelName].clients[clientID].token = token;
this.session[channelName].tokens[token] = {
client: clientID
};
ws.id = clientID;
}
if (!channelDialect) {
ws.send(JSON.stringify({
_type: 'rpcError',
id: id,
error: "The used dialect ".concat(dialect, " is not supported on this channel")
}));
}
this.eventEmitter.on(`sendEventTo:${clientID}`, msg => {
ws.send(JSON.stringify(msg));
});
ws.on('close', async () => {
let token = this.session[channelName].clients[ws.id].token;
delete this.session[channelName].clients[ws.id];
delete this.session[channelName].tokens[token];
});
ws.on('message', async message => {
const parsed = JSON.parse(message);
const dialect = parsed._dialect;
var headers = {};
return _invoke$1(function () {
if (channel.headerInjector) {
return _catch$1(function () {
return _await$1(channel.headerInjector(_this.session[channelName].clients[ws.id].token), function (h) {
headers = Object.assign({}, h);
});
}, function (err) {
_exit2 = true;
return ws.send(JSON.stringify({
_type: 'rpcError',
id: id,
error: err.message,
headers: Object.assign({}, headers, {
serverTime: Date.now()
})
}));
});
}
}, function (_result3) {
if (_exit2) return _result3;
parsed._token = _this.session[channelName].clients[ws.id].token;
parsed._clientID = ws.id;
return _continueIgnored(_catch$1(function () {
return _await$1(_this._dialects[dialect].onRequest(parsed), function (returnValue) {
if (parsed._type === 'request') {
ws.send(JSON.stringify({
_type: 'rpcResponse',
id: id,
result: returnValue,
headers: Object.assign({}, headers, {
serverTime: Date.now()
})
}));
}
});
}, function (err) {
ws.send(JSON.stringify({
_type: 'rpcError',
id: id,
error: err.message,
headers: Object.assign({}, headers, {
serverTime: Date.now()
})
}));
}));
});
}));
});
}));
}
}]);
if (!dialect) {
return;
}
return Server;
}();
const id = parsed.id;
function _async(f) {
return function () {
for (var args = [], i = 0; i < arguments.length; i++) {
args[i] = arguments[i];
}
const channelDialect = this._channels[channelName].dialects.includes(dialect);
try {
return Promise.resolve(f.apply(this, args));
} catch (e) {
return Promise.reject(e);
}
};
}
if (!channelDialect) {
ws.send(JSON.stringify({
_type: 'rpcError',
id,
error: `The used dialect ${dialect} is not supported on this channel`
}));
}
function _catch$1(body, recover) {
try {
var result = body();
} catch (e) {
return recover(e);
}
let headers = {};
if (result && result.then) {
return result.then(void 0, recover);
}
if (channel.headerInjector) {
try {
let h = await channel.headerInjector(this.session[channelName].clients[ws.id].token);
headers = Object.assign({}, h);
} catch (err) {
return ws.send(JSON.stringify({
_type: 'rpcError',
id,
error: err.message,
headers: Object.assign({}, headers, {
serverTime: Date.now()
})
}));
}
}
return result;
}
parsed._token = this.session[channelName].clients[ws.id].token;
parsed._clientID = ws.id;
function _empty$1() {}
try {
const returnValue = await this._dialects[dialect].onRequest(parsed);
function _continueIgnored(value) {
if (value && value.then) {
return value.then(_empty$1);
if (parsed._type === 'request') {
ws.send(JSON.stringify({
_type: 'rpcResponse',
id,
result: returnValue,
headers: Object.assign({}, headers, {
serverTime: Date.now()
})
}));
}
} catch (err) {
ws.send(JSON.stringify({
_type: 'rpcError',
id,
error: err.message,
headers: Object.assign({}, headers, {
serverTime: Date.now()
})
}));
}
});
});
}
}
var version = "1.1.3";
var version = "1.1.4";
var Comlink = {
Client: Client,
Server: Server,
Client,
Server,
Storage: Storage$1,
version: version
version
};
export default Comlink;

1293

dist/Comlink.js

@@ -68,7 +68,7 @@ 'use strict';

var LocalStorage = typeof window !== 'undefined' ? window.localStorage : Storage;
var SessionStorage = typeof window !== 'undefined' ? window.sessionStorage : Storage;
const LocalStorage = typeof window !== 'undefined' ? window.localStorage : Storage;
const SessionStorage = typeof window !== 'undefined' ? window.sessionStorage : Storage;
var Storage$1 = {
LocalStorage: LocalStorage,
SessionStorage: SessionStorage,
LocalStorage,
SessionStorage,
CookieStorage: new CookieStorage(),

@@ -78,40 +78,2 @@ NodeStorage: new NodeStorage()

function _typeof(obj) {
"@babel/helpers - typeof";
if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
_typeof = function (obj) {
return typeof obj;
};
} else {
_typeof = function (obj) {
return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
};
}
return _typeof(obj);
}
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
function _defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function _createClass(Constructor, protoProps, staticProps) {
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
if (staticProps) _defineProperties(Constructor, staticProps);
return Constructor;
}
function generateUUID() {

@@ -125,71 +87,8 @@ return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {

function _await(value, then, direct) {
if (direct) {
return then ? then(value) : value;
}
const WebSocket = require('isomorphic-ws');
if (!value || !value.then) {
value = Promise.resolve(value);
}
const Loader = require('@dwmt/loader/lib/Loader');
return then ? value.then(then) : value;
}
var WebSocket = require('isomorphic-ws');
function _catch(body, recover) {
try {
var result = body();
} catch (e) {
return recover(e);
}
if (result && result.then) {
return result.then(void 0, recover);
}
return result;
}
var Loader = require('@dwmt/loader/lib/Loader');
function _rethrow(thrown, value) {
if (thrown) throw value;
return value;
}
function _finallyRethrows(body, finalizer) {
try {
var result = body();
} catch (e) {
return finalizer(true, e);
}
if (result && result.then) {
return result.then(finalizer.bind(null, false), finalizer.bind(null, true));
}
return finalizer(false, result);
}
function _empty() {}
function _awaitIgnored(value, direct) {
if (!direct) {
return value && value.then ? value.then(_empty) : Promise.resolve();
}
}
function _invoke(body, then) {
var result = body();
if (result && result.then) {
return result.then(then);
}
return then(result);
}
function getLoader(channel, options) {
var loader = new Loader();
let loader = new Loader();

@@ -204,3 +103,3 @@ if (typeof options.loader === 'boolean' && !options.loader) {

if (_typeof(options.loader) === 'object' && options.loader.work && options.loader.terminate) {
if (typeof options.loader === 'object' && options.loader.work && options.loader.terminate) {
loader = options.loader;

@@ -218,3 +117,3 @@ }

uri: options.uri,
"default": options["default"] || false,
default: options.default || false,
rpc: options.rpc || undefined,

@@ -224,4 +123,4 @@ onError: options.onError || function (err) {

},
headerHandler: options.headerHandler || function (headers) {
return _await(true);
headerHandler: options.headerHandler || async function (headers) {
return true;
},

@@ -235,4 +134,4 @@ loader: options.loader || new Loader(),

function wsStrategy(options) {
var self = this;
var channel = {
const self = this;
const channel = {
type: 'ws',

@@ -242,3 +141,3 @@ name: options.name,

uri: options.uri,
"default": options["default"] || false,
default: options.default || false,
auth: options.auth,

@@ -262,8 +161,9 @@ authHeader: options.authHeader,

callbacks: {
onConnectionOpen: function onConnectionOpen() {},
onConnectionClose: function onConnectionClose() {},
onConnectionError: function onConnectionError() {},
onConnectionTermination: function onConnectionTermination() {}
onConnectionOpen: function () {},
onConnectionClose: function () {},
onConnectionError: function () {},
onConnectionTermination: function () {}
},
terminate: function terminate() {
terminate() {
self._channels[options.name].connection.close();

@@ -279,4 +179,5 @@

},
connect: function connect() {
return new Promise(function (resolve, reject) {
connect() {
return new Promise((resolve, reject) => {
if (self._channels[options.name].connection !== null) {

@@ -286,12 +187,12 @@ return resolve(true);

var opts = [];
const opts = [];
if (options.auth) {
var headerObject = self.getHeader(options.authHeader);
const headerObject = self.getHeader(options.authHeader);
opts.push(headerObject.value);
}
var ws = new WebSocket(channel.protocol + channel.uri, opts);
const ws = new WebSocket(channel.protocol + channel.uri, opts);
self._channels[options.name].connection = ws;
ws.addEventListener('open', function () {
ws.addEventListener('open', () => {
self._channels[options.name].alive = true;

@@ -305,3 +206,3 @@

});
ws.addEventListener('close', function () {
ws.addEventListener('close', () => {
self._channels[options.name].alive = false;

@@ -313,3 +214,3 @@

});
ws.addEventListener('error', function (err) {
ws.addEventListener('error', err => {
self._channels[options.name].alive = false;

@@ -327,3 +228,3 @@

try {
var tr = JSON.parse(msg.data);
const tr = JSON.parse(msg.data);

@@ -345,27 +246,7 @@ if (options.rpc && options.rpc.headerHandler) {

if (tr._type === 'event') {
var eventSubscribers = self._channels[options.name].listeners[tr.event];
let eventSubscribers = self._channels[options.name].listeners[tr.event];
if (eventSubscribers.length) {
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = eventSubscribers[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var subscriber = _step.value;
subscriber(tr.message);
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator["return"] != null) {
_iterator["return"]();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
for (let subscriber of eventSubscribers) {
subscriber(tr.message);
}

@@ -381,2 +262,3 @@ }

}
};

@@ -386,8 +268,4 @@ return channel;

var Client =
/*#__PURE__*/
function () {
function Client() {
_classCallCheck(this, Client);
class Client {
constructor() {
this._axios = axios;

@@ -404,551 +282,391 @@ this._ws = WebSocket;

_createClass(Client, [{
key: "connect",
value: function connect() {
try {
var _this2 = this;
get channels() {
let channels = Object.keys(this._channels);
return channels || [];
}
var connecting = [];
async connect() {
let connecting = [];
for (var _i = 0, _Object$keys = Object.keys(_this2._channels); _i < _Object$keys.length; _i++) {
var channelName = _Object$keys[_i];
var channel = _this2._channels[channelName];
for (let channelName of Object.keys(this._channels)) {
let channel = this._channels[channelName];
if (channel.type === 'ws' && !channel.alive) {
connecting.push(channel.connect());
}
}
return Promise.all(connecting);
} catch (e) {
return Promise.reject(e);
if (channel.type === 'ws' && !channel.alive) {
connecting.push(channel.connect());
}
}
}, {
key: "channel",
value: function channel(channelName) {
if (!this._channels[channelName]) {
throw new Error("No channel registered with ".concat(channelName));
}
var self = this;
var channel = {};
channel.name = this._channels[channelName].name;
channel.alive = this._channels[channelName].alive;
return Promise.all(connecting);
}
if (this._channels[channelName].connectable) {
channel.connection = this._channels[channelName].connection;
channel.connect = this._channels[channelName].connect;
channel.terminate = this._channels[channelName].terminate;
}
channel(channelName) {
if (!this._channels[channelName]) {
throw new Error(`No channel registered with ${channelName}`);
}
channel.registerCallback = function (callbackName, cb) {
self._channels[channelName].callbacks[callbackName] = cb;
};
let self = this;
const channel = {};
channel.name = this._channels[channelName].name;
channel.alive = this._channels[channelName].alive;
return channel;
if (this._channels[channelName].connectable) {
channel.connection = this._channels[channelName].connection;
channel.connect = this._channels[channelName].connect;
channel.terminate = this._channels[channelName].terminate;
}
}, {
key: "registerDialect",
value: function registerDialect(_dialect) {
var dialect = Object.assign({}, _dialect);
dialect.router = dialect.router || function (route) {
return {
path: route
};
};
channel.registerCallback = function (callbackName, cb) {
self._channels[channelName].callbacks[callbackName] = cb;
};
dialect.parameter = dialect.parameter || function (data) {
return {
parameters: data
};
return channel;
}
registerDialect(_dialect) {
const dialect = Object.assign({}, _dialect);
dialect.router = dialect.router || function (route) {
return {
path: route
};
};
dialect.optioner = dialect.optioner || function () {
return {};
dialect.parameter = dialect.parameter || function (data) {
return {
parameters: data
};
};
this._dialects[dialect.name] = dialect;
dialect.optioner = dialect.optioner || function () {
return {};
};
if (dialect["default"] || this._defaultDialect === null) {
this._defaultDialect = dialect.name;
}
this._dialects[dialect.name] = dialect;
if (dialect.default || this._defaultDialect === null) {
this._defaultDialect = dialect.name;
}
}, {
key: "registerHeader",
value: function registerHeader(header) {
this._headers[header.name] = header;
}
}, {
key: "registerChannel",
value: function registerChannel(channel) {
var availableChannelTypes = ['http', 'ws'];
}
if (!channel.type in availableChannelTypes) {
throw new Error("[Comlink] Channel type \"".concat(channel.type, "\" is not supported!"));
}
registerHeader(header) {
this._headers[header.name] = header;
}
if (channel.type === 'http') {
var chn = httpStrategy.call(this, channel);
registerChannel(channel) {
let availableChannelTypes = ['http', 'ws'];
if (chn["default"]) {
this._deafultHTTPChannel = chn.name;
}
if (!channel.type in availableChannelTypes) {
throw new Error(`[Comlink] Channel type "${channel.type}" is not supported!`);
}
if (chn["default"] && chn.rpc) {
this._deafultRPCChannel = chn.name;
}
if (channel.type === 'http') {
const chn = httpStrategy.call(this, channel);
this._channels[chn.name] = chn;
if (chn.default) {
this._deafultHTTPChannel = chn.name;
}
if (channel.type === 'ws') {
var _chn = wsStrategy.call(this, channel);
if (chn.default && chn.rpc) {
this._deafultRPCChannel = chn.name;
}
if (_chn["default"]) {
this._deafultWSChannel = _chn.name;
}
this._channels[chn.name] = chn;
}
if (_chn["default"] && _chn.rpc) {
this._deafultRPCChannel = _chn.name;
}
if (channel.type === 'ws') {
const chn = wsStrategy.call(this, channel);
this._channels[_chn.name] = _chn;
if (chn.default) {
this._deafultWSChannel = chn.name;
}
if (chn.default && chn.rpc) {
this._deafultRPCChannel = chn.name;
}
this._channels[chn.name] = chn;
}
}, {
key: "checkHeaders",
value: function checkHeaders() {
var _this3 = this;
}
var headers = Object.keys(this._headers);
headers.forEach(function (headerKey) {
var header = _this3._headers[headerKey];
get headers() {
return Object.keys(this._headers);
}
if (header.type === 'automatic') {
var val = header.storage.getItem(header.key);
checkHeaders() {
const headers = Object.keys(this._headers);
headers.forEach(headerKey => {
const header = this._headers[headerKey];
if (val) {
header.value = val;
}
if (header.type === 'automatic') {
const val = header.storage.getItem(header.key);
if (val) {
header.value = val;
}
});
}
}, {
key: "getHeader",
value: function getHeader(name) {
if (!this._headers[name]) {
throw new Error("No registered header with name ".concat(name));
}
});
}
return {
key: this._headers[name].key,
value: this._headers[name].value
};
getHeader(name) {
if (!this._headers[name]) {
throw new Error(`No registered header with name ${name}`);
}
}, {
key: "setHeader",
value: function setHeader(name, value) {
if (!this._headers[name]) {
throw new Error("No registered header with name ".concat(name));
}
this._headers[name].value = value;
return {
key: this._headers[name].key,
value: this._headers[name].value
};
}
if (this._headers[name].type === 'automatic') {
this._headers[name].storage.setItem(this._headers[name].key, value);
}
setHeader(name, value) {
if (!this._headers[name]) {
throw new Error(`No registered header with name ${name}`);
}
}, {
key: "get",
value: function get(URI) {
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
try {
var _this5 = this;
this._headers[name].value = value;
_this5.checkDefaultHTTPChannel();
if (this._headers[name].type === 'automatic') {
this._headers[name].storage.setItem(this._headers[name].key, value);
}
}
var channelName = options.channel || _this5._deafultHTTPChannel;
var channel = _this5._channels[channelName];
var loader = getLoader(channel, options);
var errorHandler = options.onError || channel.onError;
var loaderID = loader.work();
return _finallyRethrows(function () {
return _catch(function () {
var url = channel.protocol + channel.uri + '/' + URI;
var pat = /^https?:\/\//i;
async get(URI, options = {}) {
this.checkDefaultHTTPChannel();
const channelName = options.channel || this._deafultHTTPChannel;
const channel = this._channels[channelName];
const loader = getLoader(channel, options);
const errorHandler = options.onError || channel.onError;
const loaderID = loader.work();
if (pat.test(URI)) {
url = URI;
}
try {
let url = channel.protocol + channel.uri + '/' + URI;
var pat = /^https?:\/\//i;
return _await(axios.get(url, options.axios || {}), function (resp) {
return _await(channel.headerHandler(resp.headers), function () {
return resp;
});
});
}, function (err) {
return _await(channel.headerHandler(err.response.headers), function () {
return _await(errorHandler(err), function () {
throw err;
});
});
});
}, function (_wasThrown, _result) {
loader.terminate(loaderID);
return _rethrow(_wasThrown, _result);
});
} catch (e) {
return Promise.reject(e);
if (pat.test(URI)) {
url = URI;
}
const resp = await axios.get(url, options.axios || {});
await channel.headerHandler(resp.headers);
return resp;
} catch (err) {
await channel.headerHandler(err.response.headers);
await errorHandler(err);
throw err;
} finally {
loader.terminate(loaderID);
}
}, {
key: "checkDefaultHTTPChannel",
value: function checkDefaultHTTPChannel() {
if (!this._deafultHTTPChannel) {
throw new Error('[Comlink] No default HTTP channel');
}
}
checkDefaultHTTPChannel() {
if (!this._deafultHTTPChannel) {
throw new Error('[Comlink] No default HTTP channel');
}
}, {
key: "post",
value: function post(URI, data) {
var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
}
try {
var _this7 = this;
async post(URI, data, options = {}) {
this.checkDefaultHTTPChannel();
const channelName = options.channel || this._deafultHTTPChannel;
const channel = this._channels[channelName];
const loader = getLoader(channel, options);
const errorHandler = options.onError || channel.onError;
const loaderID = loader.work();
_this7.checkDefaultHTTPChannel();
try {
let url = channel.protocol + channel.uri + '/' + URI;
var pat = /^https?:\/\//i;
var channelName = options.channel || _this7._deafultHTTPChannel;
var channel = _this7._channels[channelName];
var loader = getLoader(channel, options);
var errorHandler = options.onError || channel.onError;
var loaderID = loader.work();
return _finallyRethrows(function () {
return _catch(function () {
var url = channel.protocol + channel.uri + '/' + URI;
var pat = /^https?:\/\//i;
if (pat.test(URI)) {
url = URI;
}
if (pat.test(URI)) {
url = URI;
}
return _await(axios.post(url, data, options.axios || {}), function (resp) {
return _await(channel.headerHandler(resp.headers), function () {
return resp;
});
});
}, function (err) {
return _await(channel.headerHandler(err.response.headers), function () {
return _await(errorHandler(err), function () {
throw err;
});
});
});
}, function (_wasThrown2, _result2) {
loader.terminate(loaderID);
return _rethrow(_wasThrown2, _result2);
});
} catch (e) {
return Promise.reject(e);
}
const resp = await axios.post(url, data, options.axios || {});
await channel.headerHandler(resp.headers);
return resp;
} catch (err) {
await channel.headerHandler(err.response.headers);
await errorHandler(err);
throw err;
} finally {
loader.terminate(loaderID);
}
}, {
key: "put",
value: function put(URI, data) {
var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
}
try {
var _this9 = this;
async put(URI, data, options = {}) {
this.checkDefaultHTTPChannel();
const channelName = options.channel || this._deafultHTTPChannel;
const channel = this._channels[channelName];
const loader = getLoader(channel, options);
const errorHandler = options.onError || channel.onError;
const loaderID = loader.work();
_this9.checkDefaultHTTPChannel();
try {
let url = channel.protocol + channel.uri + '/' + URI;
var pat = /^https?:\/\//i;
var channelName = options.channel || _this9._deafultHTTPChannel;
var channel = _this9._channels[channelName];
var loader = getLoader(channel, options);
var errorHandler = options.onError || channel.onError;
var loaderID = loader.work();
return _finallyRethrows(function () {
return _catch(function () {
var url = channel.protocol + channel.uri + '/' + URI;
var pat = /^https?:\/\//i;
if (pat.test(URI)) {
url = URI;
}
if (pat.test(URI)) {
url = URI;
}
return _await(axios.put(url, data, options.axios || {}), function (resp) {
return _await(channel.headerHandler(resp.headers), function () {
return resp;
});
});
}, function (err) {
return _await(channel.headerHandler(err.response.headers), function () {
return _await(errorHandler(err), function () {
throw err;
});
});
});
}, function (_wasThrown3, _result3) {
loader.terminate(loaderID);
return _rethrow(_wasThrown3, _result3);
});
} catch (e) {
return Promise.reject(e);
}
const resp = await axios.put(url, data, options.axios || {});
await channel.headerHandler(resp.headers);
return resp;
} catch (err) {
await channel.headerHandler(err.response.headers);
await errorHandler(err);
throw err;
} finally {
loader.terminate(loaderID);
}
}, {
key: "delete",
value: function _delete(URI) {
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
}
try {
var _this11 = this;
async delete(URI, options = {}) {
this.checkDefaultHTTPChannel();
const channelName = options.channel || this._deafultHTTPChannel;
const channel = this._channels[channelName];
const loader = getLoader(channel, options);
const errorHandler = options.onError || channel.onError;
const loaderID = loader.work();
_this11.checkDefaultHTTPChannel();
try {
let url = channel.protocol + channel.uri + '/' + URI;
var pat = /^https?:\/\//i;
var channelName = options.channel || _this11._deafultHTTPChannel;
var channel = _this11._channels[channelName];
var loader = getLoader(channel, options);
var errorHandler = options.onError || channel.onError;
var loaderID = loader.work();
return _finallyRethrows(function () {
return _catch(function () {
var url = channel.protocol + channel.uri + '/' + URI;
var pat = /^https?:\/\//i;
if (pat.test(URI)) {
url = URI;
}
if (pat.test(URI)) {
url = URI;
}
return _await(axios["delete"](url, options.axios || {}), function (resp) {
return _await(channel.headerHandler(resp.headers), function () {
return resp;
});
});
}, function (err) {
return _await(channel.headerHandler(err.response.headers), function () {
return _await(errorHandler(err), function () {
throw err;
});
});
});
}, function (_wasThrown4, _result4) {
loader.terminate(loaderID);
return _rethrow(_wasThrown4, _result4);
});
} catch (e) {
return Promise.reject(e);
}
const resp = await axios.delete(url, options.axios || {});
await channel.headerHandler(resp.headers);
return resp;
} catch (err) {
await channel.headerHandler(err.response.headers);
await errorHandler(err);
throw err;
} finally {
loader.terminate(loaderID);
}
}, {
key: "subscribeToEvent",
value: function subscribeToEvent(event, callback) {
var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
var channelName = options.channel || this._deafultRPCChannel;
var channel = this._channels[channelName];
}
if (!channel.listeners[event]) {
channel.listeners[event] = [];
}
subscribeToEvent(event, callback, options = {}) {
const channelName = options.channel || this._deafultRPCChannel;
const channel = this._channels[channelName];
channel.listeners[event].push(callback);
if (!channel.listeners[event]) {
channel.listeners[event] = [];
}
}, {
key: "unsubscribeFromEvent",
value: function unsubscribeFromEvent(event, callback) {
var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
var channelName = options.channel || this._deafultRPCChannel;
var channel = this._channels[channelName];
if (!channel.listeners[event]) {
return;
}
channel.listeners[event].push(callback);
}
channel.listeners[event] = channel.listeners[event].filter(function (fn) {
return fn !== callback;
});
unsubscribeFromEvent(event, callback, options = {}) {
const channelName = options.channel || this._deafultRPCChannel;
const channel = this._channels[channelName];
if (!channel.listeners[event]) {
return;
}
}, {
key: "sendMessage",
value: function sendMessage() {
throw new Error('Not implemented yet!');
}
}, {
key: "_rpc",
value: function _rpc() {
var type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'request';
var path = arguments.length > 1 ? arguments[1] : undefined;
var data = arguments.length > 2 ? arguments[2] : undefined;
var options = arguments.length > 3 ? arguments[3] : undefined;
var _dialect = arguments.length > 4 ? arguments[4] : undefined;
channel.listeners[event] = channel.listeners[event].filter(fn => fn !== callback);
}
try {
var _this13 = this;
sendMessage() {
throw new Error('Not implemented yet!');
}
var channel = _this13._channels[options.channel || _this13._deafultRPCChannel];
var dialect = _this13._dialects[_dialect || _this13._defaultDialect];
var rpcConfig = channel.rpc;
async _rpc(type = 'request', path, data, options, _dialect) {
const channel = this._channels[options.channel || this._deafultRPCChannel];
const dialect = this._dialects[_dialect || this._defaultDialect];
const rpcConfig = channel.rpc;
if (!rpcConfig.dialects.includes(dialect.name)) {
throw new Error("The channel ".concat(channel.name, " not supports the ").concat(dialect.name, " dialect"));
}
var channelDialectConfig = rpcConfig[dialect.name] || {};
var idGenerator = channelDialectConfig.idGenerator || rpcConfig.idGenerator || generateUUID;
var ID = idGenerator();
var message = {
id: ID,
_dialect: dialect.name,
_type: type
};
var router = dialect.router(path);
var parameter = dialect.parameter(data);
var optioner = dialect.optioner(options);
message = Object.assign({}, message, dialect["interface"], router, parameter, optioner);
return _invoke(function () {
if (channel.connection === null) {
return _awaitIgnored(channel.connect());
}
}, function () {
channel.connection.send(JSON.stringify(message));
var answerPromise = new Promise(function (resolve, reject) {
channel.answers[ID] = {
resolve: resolve,
reject: reject
};
});
var timeoutPromise = new Promise(function (resolve, reject) {
setTimeout(function () {
reject("[Comlink] Maximum retries exceeded for message: ".concat(ID));
}, rpcConfig.retryInterval * rpcConfig.maxRetries);
});
return Promise.race([answerPromise, timeoutPromise]);
});
} catch (e) {
return Promise.reject(e);
}
if (!rpcConfig.dialects.includes(dialect.name)) {
throw new Error(`The channel ${channel.name} not supports the ${dialect.name} dialect`);
}
}, {
key: "request",
value: function request(path, data) {
var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
var _dialect = arguments.length > 3 ? arguments[3] : undefined;
const channelDialectConfig = rpcConfig[dialect.name] || {};
const idGenerator = channelDialectConfig.idGenerator || rpcConfig.idGenerator || generateUUID;
const ID = idGenerator();
let message = {
id: ID,
_dialect: dialect.name,
_type: type
};
const router = dialect.router(path);
const parameter = dialect.parameter(data);
const optioner = dialect.optioner(options);
message = Object.assign({}, message, dialect.interface, router, parameter, optioner);
try {
var _this15 = this;
var channelName = options.channel || _this15._deafultRPCChannel;
var channel = _this15._channels[channelName];
var loader = getLoader(channel, options);
var errorHandler = options.onError || channel.onError;
var loaderID = loader.work();
return _finallyRethrows(function () {
return _catch(function () {
if (channel.type === 'http') {
var url = channel.protocol + channel.uri + '/';
return _await(axios.post(url, options.axios || {}));
} else {
return _this15._rpc('request', path, data, options, _dialect);
}
}, function (err) {
return _await(errorHandler(err), function () {
throw err;
});
});
}, function (_wasThrown5, _result5) {
loader.terminate(loaderID);
return _rethrow(_wasThrown5, _result5);
});
} catch (e) {
return Promise.reject(e);
}
if (channel.connection === null) {
await channel.connect();
}
}, {
key: "inform",
value: function inform(path, data) {
var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
var _dialect = arguments.length > 3 ? arguments[3] : undefined;
channel.connection.send(JSON.stringify(message));
const answerPromise = new Promise((resolve, reject) => {
channel.answers[ID] = {
resolve,
reject
};
});
const timeoutPromise = new Promise((resolve, reject) => {
setTimeout(() => {
reject(`[Comlink] Maximum retries exceeded for message: ${ID}`);
}, rpcConfig.retryInterval * rpcConfig.maxRetries);
});
return Promise.race([answerPromise, timeoutPromise]);
}
try {
var _this17 = this;
async request(path, data, options = {}, _dialect) {
const channelName = options.channel || this._deafultRPCChannel;
const channel = this._channels[channelName];
const loader = getLoader(channel, options);
const errorHandler = options.onError || channel.onError;
const loaderID = loader.work();
var channelName = options.channel || _this17._deafultRPCChannel;
var channel = _this17._channels[channelName];
var loader = getLoader(channel, options);
var errorHandler = options.onError || channel.onError;
var loaderID = loader.work();
return _finallyRethrows(function () {
return _catch(function () {
if (channel.type === 'http') {
var url = channel.protocol + channel.uri + '/';
return _await(axios.post(url, options.axios || {}));
} else {
return _this17._rpc('inform', path, data, options, _dialect);
}
}, function (err) {
return _await(errorHandler(err), function () {
throw err;
});
});
}, function (_wasThrown6, _result6) {
loader.terminate(loaderID);
return _rethrow(_wasThrown6, _result6);
});
} catch (e) {
return Promise.reject(e);
try {
if (channel.type === 'http') {
const url = channel.protocol + channel.uri + '/';
const req = await axios.post(url, options.axios || {});
return req;
} else {
return this._rpc('request', path, data, options, _dialect);
}
} catch (err) {
await errorHandler(err, options);
throw err;
} finally {
loader.terminate(loaderID);
}
}, {
key: "channels",
get: function get() {
var channels = Object.keys(this._channels);
return channels || [];
}
}, {
key: "headers",
get: function get() {
return Object.keys(this._headers);
}
}]);
return Client;
}();
function _await$1(value, then, direct) {
if (direct) {
return then ? then(value) : value;
}
if (!value || !value.then) {
value = Promise.resolve(value);
}
async inform(path, data, options = {}, _dialect) {
const channelName = options.channel || this._deafultRPCChannel;
const channel = this._channels[channelName];
const loader = getLoader(channel, options);
const errorHandler = options.onError || channel.onError;
const loaderID = loader.work();
return then ? value.then(then) : value;
}
var _require = require('events'),
EventEmitter = _require.EventEmitter;
function _invoke$1(body, then) {
var result = body();
if (result && result.then) {
return result.then(then);
try {
if (channel.type === 'http') {
const url = channel.protocol + channel.uri + '/';
const req = await axios.post(url, options.axios || {});
return req;
} else {
return this._rpc('inform', path, data, options, _dialect);
}
} catch (err) {
await errorHandler(err);
throw err;
} finally {
loader.terminate(loaderID);
}
}
return then(result);
}
var Server =
/*#__PURE__*/
function () {
function Server(logger) {
_classCallCheck(this, Server);
const {
EventEmitter
} = require('events');
class Server {
constructor(logger) {
this._dialects = {};

@@ -962,243 +680,182 @@ this._channels = {};

_createClass(Server, [{
key: "registerDialect",
value: function registerDialect(_dialect) {
this._dialects[_dialect.name] = _dialect;
registerDialect(_dialect) {
this._dialects[_dialect.name] = _dialect;
}
registerChannel(_channel) {
if (_channel.auth && !_channel.tokenValidator) {
throw new Error('For authentication you need a token validator');
}
}, {
key: "registerChannel",
value: function registerChannel(_channel) {
if (_channel.auth && !_channel.tokenValidator) {
throw new Error('For authentication you need a token validator');
}
if (_channel.type !== 'ws') {
throw new Error('Only websocket listeners implemented yet!');
}
this._channels[_channel.name] = _channel;
this.session[_channel.name] = {
clients: {},
tokens: {}
};
if (_channel.type !== 'ws') {
throw new Error('Only websocket listeners implemented yet!');
}
}, {
key: "sendMessageToClient",
value: function sendMessageToClient(channelName, clientID, event, message) {
if (!this.session[channelName].clients[clientID]) {
throw new Error('No user with given clientID');
}
this.eventEmitter.emit("sendEventTo:".concat(clientID), {
_type: 'event',
event: event,
message: message
});
this._channels[_channel.name] = _channel;
this.session[_channel.name] = {
clients: {},
tokens: {}
};
}
sendMessageToClient(channelName, clientID, event, message) {
if (!this.session[channelName].clients[clientID]) {
throw new Error('No user with given clientID');
}
}, {
key: "getClientIDByToken",
value: function getClientIDByToken(channelName, token) {
var clientID = this.session[channelName].tokens[token].client;
if (!clientID) {
throw new Error('No user with given token');
}
this.eventEmitter.emit(`sendEventTo:${clientID}`, {
_type: 'event',
event,
message
});
}
return clientID;
getClientIDByToken(channelName, token) {
let clientID = this.session[channelName].tokens[token].client;
if (!clientID) {
throw new Error('No user with given token');
}
}, {
key: "getTokenByClientID",
value: function getTokenByClientID(channelName, clientID) {
var token = this.session[channelName].clients[clientID].token;
if (!token) {
throw new Error('No user with given clientID');
}
return clientID;
}
return token;
getTokenByClientID(channelName, clientID) {
let token = this.session[channelName].clients[clientID].token;
if (!token) {
throw new Error('No user with given clientID');
}
}, {
key: "isTokenActive",
value: function isTokenActive(channelName, token) {
var clientID = this.session[channelName].tokens[token].client;
return !!clientID;
}
}, {
key: "isClientActive",
value: function isClientActive(channelName, clientID) {
var token = this.session[channelName].clients[clientID].token;
return !!token;
}
}, {
key: "applyChannel",
value: function applyChannel(channelName, wss) {
var _this = this;
var channel = this._channels[channelName];
return token;
}
if (!channel) {
throw new Error("Channel with name ".concat(channelName, " is not registered!"));
}
isTokenActive(channelName, token) {
let clientID = this.session[channelName].tokens[token].client;
return !!clientID;
}
wss.on('connection', _async(function (ws, req) {
var _exit = false;
var clientID = generateUUID();
_this.session[channelName].clients[clientID] = {};
return _invoke$1(function () {
if (channel.auth) {
var token = req.headers['sec-websocket-protocol'];
isClientActive(channelName, clientID) {
let token = this.session[channelName].clients[clientID].token;
return !!token;
}
if (!token || token.length === 0) {
_exit = true;
return ws.close();
}
applyChannel(channelName, wss) {
const channel = this._channels[channelName];
return _await$1(channel.tokenValidator(token), function (check) {
if (!check) {
_exit = true;
return ws.close();
}
if (!channel) {
throw new Error(`Channel with name ${channelName} is not registered!`);
}
_this.session[channelName].clients[clientID].token = token;
_this.session[channelName].tokens[token] = {
client: clientID
};
ws.id = clientID;
});
}
}, function (_result) {
if (_exit) return _result;
wss.on('connection', async (ws, req) => {
let clientID = generateUUID();
this.session[channelName].clients[clientID] = {};
_this.eventEmitter.on("sendEventTo:".concat(clientID), function (msg) {
ws.send(JSON.stringify(msg));
});
if (channel.auth) {
const token = req.headers['sec-websocket-protocol'];
ws.on('close', _async(function () {
var token = _this.session[channelName].clients[ws.id].token;
delete _this.session[channelName].clients[ws.id];
delete _this.session[channelName].tokens[token];
return _await$1();
}));
ws.on('message', _async(function (message) {
var _exit2 = false;
var parsed = JSON.parse(message);
var dialect = parsed._dialect;
if (!token || token.length === 0) {
return ws.close();
}
if (!dialect) {
return;
}
let check = await channel.tokenValidator(token);
var id = parsed.id;
if (!check) {
return ws.close();
}
var channelDialect = _this._channels[channelName].dialects.includes(dialect);
this.session[channelName].clients[clientID].token = token;
this.session[channelName].tokens[token] = {
client: clientID
};
ws.id = clientID;
}
if (!channelDialect) {
ws.send(JSON.stringify({
_type: 'rpcError',
id: id,
error: "The used dialect ".concat(dialect, " is not supported on this channel")
}));
}
this.eventEmitter.on(`sendEventTo:${clientID}`, msg => {
ws.send(JSON.stringify(msg));
});
ws.on('close', async () => {
let token = this.session[channelName].clients[ws.id].token;
delete this.session[channelName].clients[ws.id];
delete this.session[channelName].tokens[token];
});
ws.on('message', async message => {
const parsed = JSON.parse(message);
const dialect = parsed._dialect;
var headers = {};
return _invoke$1(function () {
if (channel.headerInjector) {
return _catch$1(function () {
return _await$1(channel.headerInjector(_this.session[channelName].clients[ws.id].token), function (h) {
headers = Object.assign({}, h);
});
}, function (err) {
_exit2 = true;
return ws.send(JSON.stringify({
_type: 'rpcError',
id: id,
error: err.message,
headers: Object.assign({}, headers, {
serverTime: Date.now()
})
}));
});
}
}, function (_result3) {
if (_exit2) return _result3;
parsed._token = _this.session[channelName].clients[ws.id].token;
parsed._clientID = ws.id;
return _continueIgnored(_catch$1(function () {
return _await$1(_this._dialects[dialect].onRequest(parsed), function (returnValue) {
if (parsed._type === 'request') {
ws.send(JSON.stringify({
_type: 'rpcResponse',
id: id,
result: returnValue,
headers: Object.assign({}, headers, {
serverTime: Date.now()
})
}));
}
});
}, function (err) {
ws.send(JSON.stringify({
_type: 'rpcError',
id: id,
error: err.message,
headers: Object.assign({}, headers, {
serverTime: Date.now()
})
}));
}));
});
}));
});
}));
}
}]);
if (!dialect) {
return;
}
return Server;
}();
const id = parsed.id;
function _async(f) {
return function () {
for (var args = [], i = 0; i < arguments.length; i++) {
args[i] = arguments[i];
}
const channelDialect = this._channels[channelName].dialects.includes(dialect);
try {
return Promise.resolve(f.apply(this, args));
} catch (e) {
return Promise.reject(e);
}
};
}
if (!channelDialect) {
ws.send(JSON.stringify({
_type: 'rpcError',
id,
error: `The used dialect ${dialect} is not supported on this channel`
}));
}
function _catch$1(body, recover) {
try {
var result = body();
} catch (e) {
return recover(e);
}
let headers = {};
if (result && result.then) {
return result.then(void 0, recover);
}
if (channel.headerInjector) {
try {
let h = await channel.headerInjector(this.session[channelName].clients[ws.id].token);
headers = Object.assign({}, h);
} catch (err) {
return ws.send(JSON.stringify({
_type: 'rpcError',
id,
error: err.message,
headers: Object.assign({}, headers, {
serverTime: Date.now()
})
}));
}
}
return result;
}
parsed._token = this.session[channelName].clients[ws.id].token;
parsed._clientID = ws.id;
function _empty$1() {}
try {
const returnValue = await this._dialects[dialect].onRequest(parsed);
function _continueIgnored(value) {
if (value && value.then) {
return value.then(_empty$1);
if (parsed._type === 'request') {
ws.send(JSON.stringify({
_type: 'rpcResponse',
id,
result: returnValue,
headers: Object.assign({}, headers, {
serverTime: Date.now()
})
}));
}
} catch (err) {
ws.send(JSON.stringify({
_type: 'rpcError',
id,
error: err.message,
headers: Object.assign({}, headers, {
serverTime: Date.now()
})
}));
}
});
});
}
}
var version = "1.1.3";
var version = "1.1.4";
var Comlink = {
Client: Client,
Server: Server,
Client,
Server,
Storage: Storage$1,
version: version
version
};
module.exports = Comlink;

56

package.json
{
"name": "@dwmt/comlink",
"version": "1.1.3",
"version": "1.1.4",
"description": "Communication library for lazy enthusiasts",

@@ -10,6 +10,6 @@ "main": "dist/Comlink.js",

"dev": "npx bili --watch --format esm --format cjs",
"test": "npx mocha test/**/*.test.js",
"test:watch": "npx mocha test/**/*.test.js --watch",
"test": "npx mocha --require @babel/register test/**/*.test.js",
"test:watch": "npx mocha --require @babel/register test/**/*.test.js --watch",
"coverage": "npx nyc npm run test",
"report-coverage": " npx nyc --reporter=lcov npm run test"
"report-coverage": "npx nyc --reporter=lcov npm run test"
},

@@ -49,23 +49,43 @@ "repository": {

"@dwmt/loader": "^1.0.0",
"@rollup/plugin-json": "^4.0.2",
"axios": "^0.19.0",
"@rollup/plugin-json": "^4.0.3",
"axios": "^0.19.2",
"isomorphic-ws": "^4.0.1",
"js-cookie": "^2.2.1",
"ws": "^7.2.1"
"ws": "^7.3.0"
},
"devDependencies": {
"bili": "^4.8.1",
"@babel/core": "^7.10.1",
"@babel/preset-env": "^7.10.1",
"@babel/register": "^7.10.1",
"babel-plugin-dynamic-import-node": "^2.3.3",
"bili": "^4.10.0",
"chai": "^4.2.0",
"codacy-coverage": "^3.4.0",
"codecov": "^3.6.1",
"eslint": "^6.5.1",
"eslint-config-standard": "^14.1.0",
"eslint-plugin-import": "^2.18.2",
"eslint-plugin-node": "^10.0.0",
"codecov": "^3.7.0",
"eslint": "^7.1.0",
"eslint-config-standard": "^14.1.1",
"eslint-plugin-import": "^2.20.2",
"eslint-plugin-node": "^11.1.0",
"eslint-plugin-promise": "^4.2.1",
"eslint-plugin-standard": "^4.0.1",
"mocha": "^6.2.1",
"nyc": "^15.0.0",
"sinon": "^7.5.0"
}
"mocha": "^7.2.0",
"nyc": "^15.0.1",
"sinon": "^9.0.2"
},
"babel": {
"plugins": [
[
"dynamic-import-node"
]
],
"presets": [
[
"@babel/preset-env",
{
"targets": {
"node": "current"
}
}
]
]
}
}
SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc