@x-oasis/async-call-rpc 0.1.38

package/dist/async-call-rpc.cjs.development.js

@@ -0,0 +1,1275 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
+
+var disposable = require('@x-oasis/disposable');
+var emitter = require('@x-oasis/emitter');
+var id = require('@x-oasis/id');
+var deferred = require('@x-oasis/deferred');
+var isAscii = require('@x-oasis/is-ascii');
+var isPromise = _interopDefault(require('@x-oasis/is-promise'));
+
+var ProxyRPCClient = /*#__PURE__*/function () {
+  function ProxyRPCClient(requestPath, options) {
+    var _ref = options || {},
+      channel = _ref.channel;
+    this.requestPath = requestPath;
+    if (channel) {
+      this.setChannel(channel);
+    }
+  }
+  var _proto = ProxyRPCClient.prototype;
+  _proto.setChannel = function setChannel(channel) {
+    this.channel = channel;
+  };
+  _proto.handleMessage = function handleMessage() {
+    var _this$channel;
+    (_this$channel = this.channel).onMessage.apply(_this$channel, arguments);
+  };
+  _proto.createProxy = function createProxy() {
+    var _this = this;
+    var getTrap = function getTrap(_, methodName) {
+      return function () {
+        if (!_this.channel) {
+          throw new Error("[ProxyRPCClient error] `this.channel` is null, when invoke function " + methodName);
+        }
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+        return _this.channel.makeRequest({
+          requestPath: _this.requestPath,
+          methodName: methodName,
+          args: args
+        }).promise;
+      };
+    };
+    return new Proxy({}, {
+      get: getTrap
+    });
+  };
+  return ProxyRPCClient;
+}();
+
+var RPCClientHost = /*#__PURE__*/function () {
+  function RPCClientHost() {
+    this.hostMap = new Map();
+  }
+  var _proto = RPCClientHost.prototype;
+  _proto.registerClient = function registerClient(requestPath, options) {
+    var client = new ProxyRPCClient(requestPath, options);
+    this.hostMap.set(requestPath, client);
+    return client;
+  };
+  return RPCClientHost;
+}();
+var RPCClientHost$1 = /*#__PURE__*/new RPCClientHost();
+
+var RPCService = /*#__PURE__*/function () {
+  function RPCService(servicePath, options) {
+    this.handlersMap = new Map();
+    var _ref = options || {},
+      channel = _ref.channel,
+      handlers = _ref.handlers,
+      serviceHost = _ref.serviceHost;
+    this.servicePath = servicePath;
+    this.serviceHost = serviceHost;
+    if (channel) {
+      this.setChannel(channel);
+    }
+    this.registerHandlers(handlers);
+  }
+  var _proto = RPCService.prototype;
+  _proto.setChannel = function setChannel(channel) {
+    this.channel = channel;
+    this.channel.setService(this);
+    this.channel.on(this.handleMessage.bind(this));
+  };
+  _proto.registerHandlers = function registerHandlers(handlers) {
+    if (!handlers) return;
+    for (var _i = 0, _Object$entries = Object.entries(handlers); _i < _Object$entries.length; _i++) {
+      var _Object$entries$_i = _Object$entries[_i],
+        methodName = _Object$entries$_i[0],
+        handler = _Object$entries$_i[1];
+      this.registerHandler(methodName, handler);
+    }
+  };
+  _proto.handleMessage = function handleMessage() {
+    var _this$channel;
+    (_this$channel = this.channel).onMessage.apply(_this$channel, arguments);
+  };
+  _proto.registerHandler = function registerHandler(methodName, handler) {
+    this.handlersMap.set(methodName, handler);
+  };
+  _proto.getHandler = function getHandler(methodName) {
+    return this.handlersMap.get(methodName);
+  };
+  return RPCService;
+}();
+
+var RPCServiceHost = /*#__PURE__*/function () {
+  function RPCServiceHost() {
+    this.hostMap = new Map();
+  }
+  var _proto = RPCServiceHost.prototype;
+  _proto.registerService = function registerService(servicePath, serviceHandlers) {
+    var service = new RPCService(servicePath, {
+      handlers: serviceHandlers
+    });
+    this.hostMap.set(servicePath, service);
+    return service;
+  };
+  return RPCServiceHost;
+}();
+var RPCServiceHost$1 = /*#__PURE__*/new RPCServiceHost();
+
+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, _toPropertyKey(descriptor.key), descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+  _setPrototypeOf(subClass, superClass);
+}
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+  return _setPrototypeOf(o, p);
+}
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+  return target;
+}
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+  return self;
+}
+function _toPrimitive(input, hint) {
+  if (typeof input !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (typeof res !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return typeof key === "symbol" ? key : String(key);
+}
+
+var RequestType;
+(function (RequestType) {
+  RequestType["PromiseRequest"] = "pr";
+  RequestType["PromiseAbort"] = "pa";
+  RequestType["SignalRequest"] = "sr";
+  RequestType["SignalAbort"] = "sa";
+})(RequestType || (RequestType = {}));
+var ResponseType;
+(function (ResponseType) {
+  ResponseType["ReturnSuccess"] = "rs";
+  ResponseType["ReturnFail"] = "rf";
+  ResponseType["PortSuccess"] = "ps";
+  ResponseType["PortFail"] = "pf";
+})(ResponseType || (ResponseType = {}));
+
+var SendMiddlewareLifecycle;
+(function (SendMiddlewareLifecycle) {
+  SendMiddlewareLifecycle[SendMiddlewareLifecycle["Initial"] = 0] = "Initial";
+  SendMiddlewareLifecycle[SendMiddlewareLifecycle["Prepare"] = 10] = "Prepare";
+  SendMiddlewareLifecycle[SendMiddlewareLifecycle["Transform"] = 20] = "Transform";
+  SendMiddlewareLifecycle[SendMiddlewareLifecycle["DataOperation"] = 30] = "DataOperation";
+  SendMiddlewareLifecycle[SendMiddlewareLifecycle["Send"] = 40] = "Send";
+  SendMiddlewareLifecycle[SendMiddlewareLifecycle["Aborted"] = 100] = "Aborted";
+})(SendMiddlewareLifecycle || (SendMiddlewareLifecycle = {}));
+
+var serialize = function serialize(channel) {
+  var fn = function fn(value) {
+    return _extends({}, value, {
+      data: channel.writeBuffer.encode(value.data)
+    });
+  };
+  fn.lifecycle = SendMiddlewareLifecycle.DataOperation;
+  return fn;
+};
+var deserialize = function deserialize(channel) {
+  return function (value) {
+    var data = value.data;
+    var decoded = data;
+    try {
+      decoded = channel.readBuffer.decode(data);
+    } catch (err) {
+      console.error('[decode error]', data, err);
+    }
+    return _extends({}, value, {
+      data: decoded
+    });
+  };
+};
+
+var normalizeMessageChannelRawMessage = function normalizeMessageChannelRawMessage() {
+  return function (event) {
+    return {
+      event: event,
+      data: event.data,
+      ports: event.ports || []
+    };
+  };
+};
+function isBufferAvailable() {
+  return typeof Buffer !== 'undefined' && Buffer.isBuffer !== undefined;
+}
+function isBuffer(value) {
+  if (!isBufferAvailable()) {
+    return false;
+  }
+  return Buffer.isBuffer(value);
+}
+function arrayBufferToString(buffer) {
+  if (isBufferAvailable()) {
+    return Buffer.from(buffer).toString('utf8');
+  } else {
+    try {
+      return new TextDecoder('utf-8').decode(buffer);
+    } catch (e) {
+      var uint8Array = new Uint8Array(buffer);
+      return String.fromCharCode.apply(null, Array.from(uint8Array));
+    }
+  }
+}
+function bufferToString(buffer) {
+  if (isBufferAvailable() && Buffer.isBuffer(buffer)) {
+    return buffer.toString('utf8');
+  }
+  return String(buffer);
+}
+var normalizeWebSocketRawMessage = function normalizeWebSocketRawMessage() {
+  return function (eventOrData) {
+    if (eventOrData === undefined || eventOrData === null) {
+      console.warn('[normalizeWebSocketRawMessage] Received undefined or null data');
+      return {
+        event: null,
+        data: '',
+        ports: []
+      };
+    }
+    var normalizedData = '';
+    var event = null;
+    var ports = [];
+    if (eventOrData && typeof eventOrData === 'object' && 'data' in eventOrData) {
+      event = eventOrData;
+      var data = event.data;
+      ports = event.ports ? [].concat(event.ports) : [];
+      if (data === undefined || data === null) {
+        normalizedData = '';
+      } else if (typeof data === 'string') {
+        normalizedData = data;
+      } else if (isBuffer(data)) {
+        normalizedData = bufferToString(data);
+      } else if (data instanceof ArrayBuffer) {
+        normalizedData = arrayBufferToString(data);
+      } else if (data instanceof Blob) {
+        normalizedData = '';
+      } else {
+        normalizedData = String(data);
+      }
+    } else {
+      var actualData = eventOrData;
+      if ((arguments.length <= 1 ? 0 : arguments.length - 1) > 0 && (typeof eventOrData === 'string' || isBuffer(eventOrData))) {
+        actualData = eventOrData;
+      }
+      if (isBuffer(actualData)) {
+        normalizedData = bufferToString(actualData);
+      } else if (typeof actualData === 'string') {
+        normalizedData = actualData;
+      } else if (actualData instanceof ArrayBuffer) {
+        normalizedData = arrayBufferToString(actualData);
+      } else {
+        normalizedData = String(actualData);
+      }
+    }
+    if (normalizedData === undefined || normalizedData === null) {
+      normalizedData = '';
+    }
+    return {
+      event: event,
+      data: normalizedData,
+      ports: ports
+    };
+  };
+};
+
+var handleResponse = function handleResponse(protocol) {
+  return function (message) {
+    if (!message) return message;
+    var data = message.data;
+    var header = data[0];
+    var body = data[1];
+    var type = header[0];
+    if (Object.values(RequestType).includes(type)) {
+      return message;
+    }
+    var seqId = header[1];
+    var findDefer = protocol.ongoingRequests.get("" + seqId);
+    if (findDefer) {
+      protocol.ongoingRequests["delete"]("" + seqId);
+      if (type === ResponseType.PortSuccess) {
+        findDefer.resolve(message.ports[0]);
+      } else if (type === ResponseType.ReturnFail) {
+        findDefer.reject(body[0]);
+      } else findDefer.resolve(body[0]);
+    } else {
+      var findListener = protocol.requestEvents.get("" + seqId);
+      if (findListener) {
+        findListener.apply(void 0, body);
+      }
+    }
+    return null;
+  };
+};
+
+var prepareNormalData = function prepareNormalData(channel) {
+  var fn = function fn(props) {
+    var requestPath = '';
+    var methodName = '';
+    var params = [];
+    var seqId = channel.seqId;
+    var isOptionsRequest = false;
+    if (typeof props === 'string') {
+      requestPath = props;
+      for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+        args[_key3 - 1] = arguments[_key3];
+      }
+      methodName = args[0];
+      params = args.slice(1);
+    } else {
+      requestPath = props.requestPath;
+      methodName = props.methodName;
+      isOptionsRequest = props.isOptionsRequest;
+      params = [].concat(props.args);
+    }
+    var header = [RequestType.PromiseRequest, seqId, requestPath, methodName];
+    var body = params;
+    return {
+      seqId: seqId,
+      isOptionsRequest: isOptionsRequest,
+      data: [header, body]
+    };
+  };
+  fn.lifecycle = SendMiddlewareLifecycle.Prepare;
+  return fn;
+};
+
+var isEventMethod = function isEventMethod(name) {
+  if (typeof name !== 'string') return false;
+  return name[0] === 'o' && name[1] === 'n' && isAscii.isUpperAsciiLetter(name.charCodeAt(2));
+};
+
+var updateSeqInfo = function updateSeqInfo(channelProtocol) {
+  var fn = function fn(value) {
+    var data = value.data,
+      seqId = value.seqId;
+    var header = data[0];
+    var body = data[1];
+    var methodName = header[3];
+    if (methodName && isEventMethod(methodName)) {
+      channelProtocol.requestEvents.set("" + seqId, body[0]);
+      data[1] = [];
+    } else {
+      var returnValue = deferred.createDeferred();
+      channelProtocol.ongoingRequests.set("" + seqId, returnValue);
+      value.returnValue = returnValue;
+    }
+    return value;
+  };
+  fn.lifecycle = SendMiddlewareLifecycle.Transform;
+  return fn;
+};
+
+var sendRequest = function sendRequest(channelProtocol) {
+  var fn = function fn(value) {
+    var data = value.data,
+      transfer = value.transfer;
+    if (transfer) channelProtocol.send(data, transfer);else channelProtocol.send(data);
+    return value;
+  };
+  fn.lifecycle = SendMiddlewareLifecycle.Send;
+  return fn;
+};
+
+var resumeMiddlewares = function resumeMiddlewares(middlewares, entry) {
+  var start = false;
+  return middlewares.reduce(function (a, b) {
+    var _a$middlewareContext;
+    if (!b.lifecycle) return a;
+    if (a.lifecycle >= b.lifecycle && b.displayName === a.methodName) {
+      start = true;
+    }
+    if (!start) return a;
+    var targetLifecycle = a == null ? void 0 : (_a$middlewareContext = a.middlewareContext) == null ? void 0 : _a$middlewareContext.minLifecycle;
+    var currentLifecycle = b == null ? void 0 : b.lifecycle;
+    if (targetLifecycle && currentLifecycle && currentLifecycle < targetLifecycle) {
+      return a;
+    }
+    return b(a);
+  }, entry);
+};
+var runMiddlewares = function runMiddlewares(middlewares, args, _context) {
+  var context = _extends({
+    isResumed: false,
+    startLifecycle: SendMiddlewareLifecycle.Initial,
+    minLifecycle: SendMiddlewareLifecycle.Initial
+  }, _context || {});
+  return middlewares.reduce(function (a, b, index) {
+    var _a$middlewareContext2;
+    if (!index) return b.apply(void 0, a);
+    if (index === 1) {
+      a.middlewareContext = context;
+    }
+    var targetLifecycle = a == null ? void 0 : (_a$middlewareContext2 = a.middlewareContext) == null ? void 0 : _a$middlewareContext2.minLifecycle;
+    var currentLifecycle = b == null ? void 0 : b.lifecycle;
+    if (targetLifecycle && currentLifecycle && currentLifecycle < targetLifecycle) {
+      return a;
+    }
+    return b(a);
+  }, args);
+};
+
+var ReadBaseBuffer = function ReadBaseBuffer() {};
+
+var DataType;
+(function (DataType) {
+  DataType[DataType["Undefined"] = 0] = "Undefined";
+  DataType[DataType["String"] = 1] = "String";
+  DataType[DataType["Buffer"] = 2] = "Buffer";
+  DataType[DataType["VSBuffer"] = 3] = "VSBuffer";
+  DataType[DataType["Array"] = 4] = "Array";
+  DataType[DataType["Object"] = 5] = "Object";
+  DataType[DataType["Int"] = 6] = "Int";
+})(DataType || (DataType = {}));
+var ReadBuffer = /*#__PURE__*/function (_ReadBaseBuffer) {
+  _inheritsLoose(ReadBuffer, _ReadBaseBuffer);
+  function ReadBuffer() {
+    return _ReadBaseBuffer.apply(this, arguments) || this;
+  }
+  var _proto = ReadBuffer.prototype;
+  _proto.decode = function decode(data) {
+    if (data instanceof ArrayBuffer || data instanceof Uint8Array) {
+      var decoder = new TextDecoder();
+      var text = decoder.decode(data);
+      return JSON.parse(text);
+    }
+    return JSON.parse(data);
+  };
+  _proto.getFormat = function getFormat() {
+    return 'json';
+  };
+  return ReadBuffer;
+}(ReadBaseBuffer);
+
+var WriteBaseBuffer = function WriteBaseBuffer() {};
+
+var WriteBuffer = /*#__PURE__*/function (_WriteBaseBuffer) {
+  _inheritsLoose(WriteBuffer, _WriteBaseBuffer);
+  function WriteBuffer() {
+    return _WriteBaseBuffer.apply(this, arguments) || this;
+  }
+  var _proto = WriteBuffer.prototype;
+  _proto.encode = function encode(data) {
+    return JSON.stringify(data);
+  };
+  _proto.getFormat = function getFormat() {
+    return 'json';
+  };
+  return WriteBuffer;
+}(WriteBaseBuffer);
+
+var _FORMAT_INFO;
+var SerializationFormat;
+(function (SerializationFormat) {
+  SerializationFormat["JSON"] = "json";
+  SerializationFormat["MESSAGEPACK"] = "msgpack";
+  SerializationFormat["CBOR"] = "cbor";
+  SerializationFormat["PROTOBUF"] = "protobuf";
+  SerializationFormat["CUSTOM"] = "custom";
+})(SerializationFormat || (SerializationFormat = {}));
+var FORMAT_INFO = (_FORMAT_INFO = {}, _FORMAT_INFO[SerializationFormat.JSON] = {
+  format: SerializationFormat.JSON,
+  name: 'JSON',
+  description: 'JavaScript Object Notation - Human-readable text format',
+  mimeType: 'application/json',
+  isBinary: false,
+  isText: true
+}, _FORMAT_INFO[SerializationFormat.MESSAGEPACK] = {
+  format: SerializationFormat.MESSAGEPACK,
+  name: 'MessagePack',
+  description: 'Binary serialization format - High performance, compact size',
+  mimeType: 'application/x-msgpack',
+  isBinary: true,
+  isText: false
+}, _FORMAT_INFO[SerializationFormat.CBOR] = {
+  format: SerializationFormat.CBOR,
+  name: 'CBOR',
+  description: 'Concise Binary Object Representation (RFC 7049)',
+  mimeType: 'application/cbor',
+  isBinary: true,
+  isText: false
+}, _FORMAT_INFO[SerializationFormat.PROTOBUF] = {
+  format: SerializationFormat.PROTOBUF,
+  name: 'Protocol Buffers',
+  description: 'Google Protocol Buffers - Schema-based binary format',
+  mimeType: 'application/x-protobuf',
+  isBinary: true,
+  isText: false
+}, _FORMAT_INFO[SerializationFormat.CUSTOM] = {
+  format: SerializationFormat.CUSTOM,
+  name: 'Custom',
+  description: 'User-defined custom serialization format',
+  mimeType: 'application/octet-stream',
+  isBinary: true,
+  isText: false
+}, _FORMAT_INFO);
+
+var BufferFactory = /*#__PURE__*/function () {
+  function BufferFactory() {}
+  BufferFactory.registerReadBuffer = function registerReadBuffer(format, factory) {
+    this.readBufferRegistry.set(format, factory);
+  };
+  BufferFactory.registerWriteBuffer = function registerWriteBuffer(format, factory) {
+    this.writeBufferRegistry.set(format, factory);
+  };
+  BufferFactory.createReadBuffer = function createReadBuffer(format) {
+    if (format === void 0) {
+      format = SerializationFormat.JSON;
+    }
+    var factory = this.readBufferRegistry.get(format);
+    if (factory) {
+      return factory();
+    }
+    switch (format) {
+      case SerializationFormat.JSON:
+        return new ReadBuffer();
+      case SerializationFormat.MESSAGEPACK:
+        try {
+          throw new Error('MessagePack not available. Install @msgpack/msgpack and register it.');
+        } catch (e) {
+          throw new Error("Unsupported read buffer format: " + format + ". Register a custom implementation.");
+        }
+      default:
+        throw new Error("Unsupported read buffer format: " + format);
+    }
+  };
+  BufferFactory.createWriteBuffer = function createWriteBuffer(format) {
+    if (format === void 0) {
+      format = SerializationFormat.JSON;
+    }
+    var factory = this.writeBufferRegistry.get(format);
+    if (factory) {
+      return factory();
+    }
+    switch (format) {
+      case SerializationFormat.JSON:
+        return new WriteBuffer();
+      case SerializationFormat.MESSAGEPACK:
+        try {
+          throw new Error('MessagePack not available. Install @msgpack/msgpack and register it.');
+        } catch (e) {
+          throw new Error("Unsupported write buffer format: " + format + ". Register a custom implementation.");
+        }
+      default:
+        throw new Error("Unsupported write buffer format: " + format);
+    }
+  };
+  BufferFactory.getRegisteredFormats = function getRegisteredFormats() {
+    var formats = new Set();
+    this.readBufferRegistry.forEach(function (_, format) {
+      return formats.add(format);
+    });
+    this.writeBufferRegistry.forEach(function (_, format) {
+      return formats.add(format);
+    });
+    return Array.from(formats);
+  };
+  return BufferFactory;
+}();
+BufferFactory.readBufferRegistry = /*#__PURE__*/new Map();
+BufferFactory.writeBufferRegistry = /*#__PURE__*/new Map();
+BufferFactory.registerReadBuffer(SerializationFormat.JSON, function () {
+  return new ReadBuffer();
+});
+BufferFactory.registerWriteBuffer(SerializationFormat.JSON, function () {
+  return new WriteBuffer();
+});
+
+var ERROR = 'Error';
+var isArray = Array.isArray;
+var isObject = function isObject(val) {
+  return val !== null && typeof val === 'object' && !isArray(val);
+};
+var isFunction = function isFunction(val) {
+  return typeof val === 'function';
+};
+var UNDEFINED = void 0;
+
+var jsonrpc = '2.0';
+var makeRequest = function makeRequest(id, method, params, remoteStack) {
+  var x = {
+    jsonrpc: jsonrpc,
+    id: id,
+    method: method,
+    params: params,
+    remoteStack: remoteStack
+  };
+  deleteUndefined(x, 'id');
+  deleteFalsy(x, 'remoteStack');
+  return x;
+};
+var makeSuccessResponse = function makeSuccessResponse(id, result) {
+  var x = {
+    jsonrpc: jsonrpc,
+    id: id,
+    result: result
+  };
+  deleteUndefined(x, 'id');
+  return x;
+};
+var makeErrorResponse = function makeErrorResponse(id, code, message, data) {
+  if (id === UNDEFINED) id = null;
+  code = Math.floor(code);
+  if (Number.isNaN(code)) code = -1;
+  var x = {
+    jsonrpc: jsonrpc,
+    id: id,
+    error: {
+      code: code,
+      message: message,
+      data: data
+    }
+  };
+  deleteUndefined(x.error, 'data');
+  return x;
+};
+var ErrorResponseParseError = function ErrorResponseParseError(e, mapper) {
+  var obj = ErrorResponseMapped({}, e, mapper);
+  var o = obj.error;
+  o.code = -32700;
+  o.message = 'Parse error';
+  return obj;
+};
+var ErrorResponseInvalidRequest = function ErrorResponseInvalidRequest(id) {
+  return makeErrorResponse(id, -32600, 'Invalid Request');
+};
+var ErrorResponseMethodNotFound = function ErrorResponseMethodNotFound(id) {
+  return makeErrorResponse(id, -32601, 'Method not found');
+};
+var ErrorResponseInvalidParams = function ErrorResponseInvalidParams(id) {
+  return makeErrorResponse(id, -32602, 'Invalid params');
+};
+var ErrorResponseInternalError = function ErrorResponseInternalError(id) {
+  return makeErrorResponse(id, -32603, 'Internal error');
+};
+var ErrorResponseMapped = function ErrorResponseMapped(request, e, mapper) {
+  var id = request.id;
+  var _mapper = mapper(e, request),
+    code = _mapper.code,
+    message = _mapper.message,
+    data = _mapper.data;
+  return makeErrorResponse(id, code, message, data);
+};
+var defaultErrorMapper = function defaultErrorMapper(stack, code) {
+  if (stack === void 0) {
+    stack = '';
+  }
+  if (code === void 0) {
+    code = -1;
+  }
+  return function (e) {
+    var message = toString('', function () {
+      return e.message;
+    });
+    var type = toString(ERROR, function (ctor) {
+      if (ctor === void 0) {
+        ctor = e.constructor;
+      }
+      return isFunction(ctor) && ctor.name;
+    });
+    var E = globalThis.DOMException;
+    if (E && e instanceof E) {
+      type = "DOMException:" + e.name;
+    }
+    var eType = typeof e;
+    if (eType === 'string' || eType === 'number' || eType === 'boolean' || eType === 'bigint') {
+      type = ERROR;
+      message = String(e);
+    }
+    var data = stack ? {
+      stack: stack,
+      type: type
+    } : {
+      type: type
+    };
+    return {
+      code: code,
+      message: message,
+      data: data
+    };
+  };
+};
+var isJSONRPCObject = function isJSONRPCObject(data) {
+  if (!isObject(data)) return false;
+  if (!('jsonrpc' in data)) return false;
+  var obj = data;
+  if (obj.jsonrpc !== jsonrpc) return false;
+  if ('params' in obj) {
+    var params = obj.params;
+    if (!isArray(params) && !isObject(params)) return false;
+  }
+  return true;
+};
+var toString = function toString(_default, val) {
+  try {
+    var v = val();
+    if (v === UNDEFINED) return _default;
+    return String(v);
+  } catch (_unused) {
+    return _default;
+  }
+};
+var deleteUndefined = function deleteUndefined(x, key) {
+  if (x[key] === UNDEFINED) delete x[key];
+};
+var deleteFalsy = function deleteFalsy(x, key) {
+  if (!x[key]) delete x[key];
+};
+
+(function (JSONRPCErrorCode) {
+  JSONRPCErrorCode[JSONRPCErrorCode["ParseError"] = -32700] = "ParseError";
+  JSONRPCErrorCode[JSONRPCErrorCode["InvalidRequest"] = -32600] = "InvalidRequest";
+  JSONRPCErrorCode[JSONRPCErrorCode["MethodNotFound"] = -32601] = "MethodNotFound";
+  JSONRPCErrorCode[JSONRPCErrorCode["InvalidParams"] = -32602] = "InvalidParams";
+  JSONRPCErrorCode[JSONRPCErrorCode["InternalError"] = -32603] = "InternalError";
+  JSONRPCErrorCode[JSONRPCErrorCode["ServerErrorStart"] = -32000] = "ServerErrorStart";
+  JSONRPCErrorCode[JSONRPCErrorCode["ServerErrorEnd"] = -32099] = "ServerErrorEnd";
+})(exports.JSONRPCErrorCode || (exports.JSONRPCErrorCode = {}));
+
+var createErrorResponseBody = function createErrorResponseBody(error, request) {
+  var mapper = defaultErrorMapper(error instanceof Error ? error.stack : '', exports.JSONRPCErrorCode.InternalError);
+  if (request) {
+    var errorResponse = ErrorResponseMapped(request, error, mapper);
+    return errorResponse.error;
+  }
+  var _mapper = mapper(error, {}),
+    code = _mapper.code,
+    message = _mapper.message,
+    data = _mapper.data;
+  return {
+    code: code,
+    message: message,
+    data: data
+  };
+};
+var handleRequest = function handleRequest(protocol) {
+  return function (message) {
+    var service = protocol.service;
+    var data = message.data;
+    var header = data[0];
+    var body = data[1];
+    var type = header[0];
+    if (Object.values(ResponseType).includes(type)) {
+      return message;
+    }
+    var seqId = header[1];
+    var requestPath = header[2];
+    var methodName = header[3];
+    var args = body[0];
+    var jsonrpcRequest = makeRequest(seqId, methodName, args);
+    var handler = service.getHandler(methodName);
+    if (!handler) {
+      var errorResponse = ErrorResponseMethodNotFound(seqId);
+      var responseHeader = [ResponseType.ReturnFail, seqId];
+      var responseBody = [errorResponse.error];
+      protocol.sendReply(protocol.writeBuffer.encode([responseHeader, responseBody]));
+      return message;
+    }
+    var _result = handler(args);
+    var result = Promise.resolve(_result);
+    if (isPromise(result)) {
+      result.then(function (response) {
+        var responseHeader = [ResponseType.ReturnSuccess, seqId];
+        var responseBody = [];
+        var sendData = null;
+        try {
+          responseBody = [response];
+          sendData = protocol.writeBuffer.encode([responseHeader, responseBody]);
+        } catch (err) {
+          var errorBody = createErrorResponseBody(err, jsonrpcRequest);
+          responseBody = [errorBody];
+          sendData = protocol.writeBuffer.encode([responseHeader, responseBody]);
+          console.error("[handleRequest sendReply encode error ] " + requestPath + " " + methodName, err);
+        }
+        protocol.sendReply(sendData);
+      }, function (err) {
+        var errorBody = createErrorResponseBody(err, jsonrpcRequest);
+        var responseHeader = [ResponseType.ReturnFail, seqId];
+        var responseBody = [errorBody];
+        protocol.sendReply(protocol.writeBuffer.encode([responseHeader, responseBody]));
+      });
+    }
+    return message;
+  };
+};
+
+var AbstractChannelProtocol = /*#__PURE__*/function (_Disposable) {
+  _inheritsLoose(AbstractChannelProtocol, _Disposable);
+  function AbstractChannelProtocol(props) {
+    var _this;
+    _this = _Disposable.call(this) || this;
+    _this._seqId = -1;
+    _this._onMessageMiddleware = [normalizeMessageChannelRawMessage, deserialize, handleRequest, handleResponse];
+    _this._senderMiddleware = [prepareNormalData, updateSeqInfo, serialize, sendRequest];
+    _this._readBuffer = null;
+    _this._writeBuffer = null;
+    _this._isConnected = true;
+    _this.ongoingRequests = new Map();
+    _this.pendingSendEntries = new Set();
+    _this.requestEvents = new Map();
+    _this.onDidConnectedEvent = new emitter.Event({
+      name: 'on-did-connected'
+    });
+    _this.onDidConnected = _this.onDidConnectedEvent.subscribe;
+    _this.onDidDisconnectedEvent = new emitter.Event({
+      name: 'on-did-disconnect'
+    });
+    _this.onDidDisconnected = _this.onDidDisconnectedEvent.subscribe;
+    var _ref = props || {},
+      description = _ref.description,
+      masterProcessName = _ref.masterProcessName,
+      _ref$connected = _ref.connected,
+      connected = _ref$connected === void 0 ? true : _ref$connected,
+      _ref$serializationFor = _ref.serializationFormat,
+      serializationFormat = _ref$serializationFor === void 0 ? SerializationFormat.JSON : _ref$serializationFor,
+      readBuffer = _ref.readBuffer,
+      writeBuffer = _ref.writeBuffer;
+    _this._description = description;
+    _this._isConnected = connected;
+    _this._masterProcessName = masterProcessName;
+    _this._serializationFormat = serializationFormat;
+    if (readBuffer) {
+      _this._readBuffer = readBuffer;
+    }
+    if (writeBuffer) {
+      _this._writeBuffer = writeBuffer;
+    }
+    _this._key = id.generateRandomKey();
+    _this.registerDisposable(_this.onDidConnected(_this.didConnected.bind(_assertThisInitialized(_this))));
+    _this._onMessageMiddleware = _this.decorateOnMessageMiddleware(_this._onMessageMiddleware);
+    _this._senderMiddleware = _this.decorateSendMiddleware(_this._senderMiddleware);
+    _this.applyOnMessageMiddleware(_this._onMessageMiddleware);
+    _this.applySendMiddleware(_this._senderMiddleware);
+    return _this;
+  }
+  var _proto = AbstractChannelProtocol.prototype;
+  _proto.setService = function setService(service) {
+    this._service = service;
+  };
+  _proto.setSerializationFormat = function setSerializationFormat(format) {
+    if (this._serializationFormat !== format) {
+      this._serializationFormat = format;
+      this._readBuffer = null;
+      this._writeBuffer = null;
+    }
+  };
+  _proto.addPendingSendEntry = function addPendingSendEntry(entry) {
+    this.pendingSendEntries.add(entry);
+  };
+  _proto.decorateSendMiddleware = function decorateSendMiddleware(middlewares) {
+    return middlewares;
+  };
+  _proto.decorateOnMessageMiddleware = function decorateOnMessageMiddleware(middlewares) {
+    return middlewares;
+  };
+  _proto.applyOnMessageMiddleware = function applyOnMessageMiddleware(fns) {
+    var _this2 = this;
+    var copy = [].concat(fns);
+    this._onMessageMiddleware = [];
+    copy.forEach(function (fn) {
+      if (typeof fn === 'function') {
+        _this2._onMessageMiddleware.push(fn(_this2));
+      }
+    });
+  };
+  _proto.applySendMiddleware = function applySendMiddleware(fns) {
+    var _this3 = this;
+    var copy = [].concat(fns);
+    this._senderMiddleware = [];
+    copy.forEach(function (fn) {
+      if (typeof fn === 'function') {
+        _this3._senderMiddleware.push(fn(_this3));
+      }
+    });
+  };
+  _proto.isConnected = function isConnected() {
+    return this._isConnected;
+  };
+  _proto.send = function send() {
+    throw new Error('send method is not implemented');
+  };
+  _proto.on = function on() {
+    throw new Error('onMessage method is not implemented');
+  };
+  _proto.resumePendingEntry = function resumePendingEntry() {
+    var _this4 = this;
+    this.pendingSendEntries.forEach(function (entry) {
+      _this4.pendingSendEntries["delete"](entry);
+      resumeMiddlewares(_this4.senderMiddleware, entry);
+    });
+  };
+  _proto.didConnected = function didConnected() {
+    this.resumePendingEntry();
+  };
+  _proto.connect = function connect() {
+    this.onDidConnectedEvent.fire();
+  };
+  _proto.activate = function activate() {
+    this._isConnected = true;
+    this.onDidConnectedEvent.fire();
+  };
+  _proto.disconnect = function disconnect() {
+    this._isConnected = false;
+    this.onDidDisconnectedEvent.fire();
+  };
+  _proto.makeRequest = function makeRequest() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    var _runMiddlewares = runMiddlewares(this.senderMiddleware, args),
+      returnValue = _runMiddlewares.returnValue;
+    if (returnValue) return returnValue;
+  };
+  _proto.sendReply = function sendReply() {
+    this.send.apply(this, arguments);
+  };
+  _proto.onMessage = function onMessage() {
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+    runMiddlewares(this._onMessageMiddleware, args);
+  };
+  _createClass(AbstractChannelProtocol, [{
+    key: "service",
+    get: function get() {
+      return this._service;
+    }
+  }, {
+    key: "senderMiddleware",
+    get: function get() {
+      return this._senderMiddleware;
+    }
+  }, {
+    key: "readBuffer",
+    get: function get() {
+      if (this._readBuffer) {
+        return this._readBuffer;
+      }
+      try {
+        this._readBuffer = BufferFactory.createReadBuffer(this._serializationFormat);
+      } catch (error) {
+        console.warn("[AbstractChannelProtocol] Failed to create read buffer with format \"" + this._serializationFormat + "\", falling back to JSON.", error);
+        this._readBuffer = BufferFactory.createReadBuffer(SerializationFormat.JSON);
+      }
+      return this._readBuffer;
+    }
+  }, {
+    key: "writeBuffer",
+    get: function get() {
+      if (this._writeBuffer) {
+        return this._writeBuffer;
+      }
+      try {
+        this._writeBuffer = BufferFactory.createWriteBuffer(this._serializationFormat);
+      } catch (error) {
+        console.warn("[AbstractChannelProtocol] Failed to create write buffer with format \"" + this._serializationFormat + "\", falling back to JSON.", error);
+        this._writeBuffer = BufferFactory.createWriteBuffer(SerializationFormat.JSON);
+      }
+      return this._writeBuffer;
+    }
+  }, {
+    key: "serializationFormat",
+    get: function get() {
+      return this._serializationFormat;
+    }
+  }, {
+    key: "seqId",
+    get: function get() {
+      this._seqId += 1;
+      return this._key + "_" + this._seqId;
+    }
+  }, {
+    key: "description",
+    get: function get() {
+      return this._description;
+    }
+  }, {
+    key: "masterProcessName",
+    get: function get() {
+      return this._masterProcessName;
+    }
+  }]);
+  return AbstractChannelProtocol;
+}(disposable.Disposable);
+
+var _excluded = ["port", "sender", "targetOrigin"];
+var RPCMessageChannel = /*#__PURE__*/function (_AbstractChannelProto) {
+  _inheritsLoose(RPCMessageChannel, _AbstractChannelProto);
+  function RPCMessageChannel(options) {
+    var _this;
+    var port = options.port,
+      _options$sender = options.sender,
+      sender = _options$sender === void 0 ? window : _options$sender,
+      _options$targetOrigin = options.targetOrigin,
+      targetOrigin = _options$targetOrigin === void 0 ? '*' : _options$targetOrigin,
+      protocolOptions = _objectWithoutPropertiesLoose(options, _excluded);
+    _this = _AbstractChannelProto.call(this, protocolOptions) || this;
+    _this.port = port;
+    _this.targetOrigin = targetOrigin;
+    _this.sender = sender;
+    if (_this.port.start) {
+      _this.port.start();
+    }
+    return _this;
+  }
+  var _proto = RPCMessageChannel.prototype;
+  _proto.on = function on(listener) {
+    var _this2 = this;
+    var f = function f(ev) {
+      listener(ev);
+    };
+    this.port.addEventListener('message', f);
+    return function () {
+      return _this2.port.removeEventListener('message', f);
+    };
+  };
+  _proto.send = function send(message, transfer) {
+    if (transfer && transfer.length > 0) {
+      this.port.postMessage(message, transfer);
+    } else {
+      this.port.postMessage(message);
+    }
+  };
+  _proto.decorateSendMiddleware = function decorateSendMiddleware(middlewares) {
+    return middlewares;
+  };
+  _proto.decorateOnMessageMiddleware = function decorateOnMessageMiddleware(middlewares) {
+    return middlewares;
+  };
+  _proto.disconnect = function disconnect() {
+    if (this.port) {
+      this.port.close();
+    }
+  };
+  return RPCMessageChannel;
+}(AbstractChannelProtocol);
+
+var _excluded$1 = ["name"];
+var WorkerChannel = /*#__PURE__*/function (_AbstractChannelProto) {
+  _inheritsLoose(WorkerChannel, _AbstractChannelProto);
+  function WorkerChannel(worker, options) {
+    var _this;
+    var _ref = options || {},
+      name = _ref.name,
+      protocolOptions = _objectWithoutPropertiesLoose(_ref, _excluded$1);
+    _this = _AbstractChannelProto.call(this, protocolOptions) || this;
+    _this.worker = worker;
+    _this.name = name || 'worker';
+    return _this;
+  }
+  var _proto = WorkerChannel.prototype;
+  _proto.on = function on(listener) {
+    var _this2 = this;
+    var f = function f(ev) {
+      listener(ev);
+    };
+    this.worker.addEventListener('message', f);
+    return function () {
+      return _this2.worker.removeEventListener('message', f);
+    };
+  };
+  _proto.send = function send(data) {
+    this.worker.postMessage(data);
+  };
+  return WorkerChannel;
+}(AbstractChannelProtocol);
+
+var _excluded$2 = ["name", "maxReconnectAttempts", "reconnectDelay", "connected"];
+var WebSocketChannel = /*#__PURE__*/function (_AbstractChannelProto) {
+  _inheritsLoose(WebSocketChannel, _AbstractChannelProto);
+  function WebSocketChannel(socket, options) {
+    var _this;
+    var opts = options || {};
+    var name = opts.name,
+      maxReconnectAttempts = opts.maxReconnectAttempts,
+      reconnectDelay = opts.reconnectDelay,
+      connected = opts.connected,
+      protocolOptions = _objectWithoutPropertiesLoose(opts, _excluded$2);
+    _this = _AbstractChannelProto.call(this, _extends({
+      connected: connected != null ? connected : false
+    }, protocolOptions)) || this;
+    _this.socket = socket;
+    _this.name = name || 'websocket';
+    _this.reconnectAttempts = 0;
+    _this.maxReconnectAttempts = maxReconnectAttempts != null ? maxReconnectAttempts : 5;
+    _this.reconnectDelay = reconnectDelay != null ? reconnectDelay : 1000;
+    _this.setupSocketHandlers();
+    return _this;
+  }
+  var _proto = WebSocketChannel.prototype;
+  _proto.setupSocketHandlers = function setupSocketHandlers() {
+    var _this2 = this;
+    this.socket.addEventListener('open', function () {
+      _this2.activate();
+    });
+    this.socket.addEventListener('close', function () {
+      _AbstractChannelProto.prototype.disconnect.call(_this2);
+    });
+    this.socket.addEventListener('error', function (error) {
+      console.error("[WebSocketChannel " + _this2.name + "] Error:", error);
+    });
+  };
+  _proto.on = function on(listener) {
+    var _this3 = this;
+    var f = function f(ev) {
+      if (ev === undefined || ev === null) {
+        console.warn("[WebSocketChannel " + _this3.name + "] Received undefined/null message event");
+        return;
+      }
+      listener(ev);
+    };
+    if (typeof this.socket.addEventListener === 'function') {
+      this.socket.addEventListener('message', f);
+      return function () {
+        if (typeof _this3.socket.removeEventListener === 'function') {
+          _this3.socket.removeEventListener('message', f);
+        }
+      };
+    } else {
+      var wsSocket = this.socket;
+      if (typeof wsSocket.on === 'function') {
+        wsSocket.on('message', f);
+        return function () {
+          if (typeof wsSocket.off === 'function') {
+            wsSocket.off('message', f);
+          } else if (typeof wsSocket.removeListener === 'function') {
+            wsSocket.removeListener('message', f);
+          }
+        };
+      }
+    }
+    return function () {};
+  };
+  _proto.send = function send(data) {
+    if (this.socket.readyState === WebSocket.OPEN) {
+      if (typeof data === 'string') {
+        this.socket.send(data);
+      } else if (data instanceof ArrayBuffer || data instanceof Blob) {
+        this.socket.send(data);
+      } else {
+        this.socket.send(JSON.stringify(data));
+      }
+    } else {
+      console.warn("[WebSocketChannel " + this.name + "] Cannot send: WebSocket is not open. State: " + this.socket.readyState);
+    }
+  };
+  _proto.decorateSendMiddleware = function decorateSendMiddleware(middlewares) {
+    return middlewares;
+  };
+  _proto.decorateOnMessageMiddleware = function decorateOnMessageMiddleware(middlewares) {
+    if (middlewares.length > 0) {
+      return [normalizeWebSocketRawMessage].concat(middlewares.slice(1));
+    }
+    return middlewares;
+  };
+  _proto.disconnect = function disconnect() {
+    if (this.socket) {
+      this.socket.close();
+    }
+    _AbstractChannelProto.prototype.disconnect.call(this);
+  };
+  _proto.isOpen = function isOpen() {
+    return this.socket.readyState === WebSocket.OPEN;
+  };
+  _createClass(WebSocketChannel, [{
+    key: "readyState",
+    get: function get() {
+      return this.socket.readyState;
+    }
+  }]);
+  return WebSocketChannel;
+}(AbstractChannelProtocol);
+
+exports.ERROR = ERROR;
+exports.ErrorResponseInternalError = ErrorResponseInternalError;
+exports.ErrorResponseInvalidParams = ErrorResponseInvalidParams;
+exports.ErrorResponseInvalidRequest = ErrorResponseInvalidRequest;
+exports.ErrorResponseMapped = ErrorResponseMapped;
+exports.ErrorResponseMethodNotFound = ErrorResponseMethodNotFound;
+exports.ErrorResponseParseError = ErrorResponseParseError;
+exports.MessageChannel = RPCMessageChannel;
+exports.ProxyRPCClient = ProxyRPCClient;
+exports.RPCService = RPCService;
+exports.UNDEFINED = UNDEFINED;
+exports.WebSocketChannel = WebSocketChannel;
+exports.WorkerChannel = WorkerChannel;
+exports.clientHost = RPCClientHost$1;
+exports.defaultErrorMapper = defaultErrorMapper;
+exports.isArray = isArray;
+exports.isFunction = isFunction;
+exports.isJSONRPCObject = isJSONRPCObject;
+exports.isObject = isObject;
+exports.jsonrpc = jsonrpc;
+exports.makeErrorResponse = makeErrorResponse;
+exports.makeRequest = makeRequest;
+exports.makeSuccessResponse = makeSuccessResponse;
+exports.serviceHost = RPCServiceHost$1;
+//# sourceMappingURL=async-call-rpc.cjs.development.js.map