@lvce-editor/json-rpc 1.0.0 → 1.2.0

package/dist/index.js

@@ -4,14 +4,14 @@ const create$4 = (method, params) => {
   return {
     jsonrpc: Two,
     method,
-    params,
-  }
+    params
+  };
 };
 
-var JsonRpcEvent = /*#__PURE__*/Object.freeze({
+const JsonRpcEvent = {
   __proto__: null,
   create: create$4
-});
+};
 
 class AssertionError extends Error {
   constructor(message) {
@@ -19,43 +19,53 @@ class AssertionError extends Error {
     this.name = 'AssertionError';
   }
 }
-
-const getType = (value) => {
+const getType = value => {
   switch (typeof value) {
     case 'number':
-      return 'number'
+      return 'number';
     case 'function':
-      return 'function'
+      return 'function';
     case 'string':
-      return 'string'
+      return 'string';
     case 'object':
       if (value === null) {
-        return 'null'
+        return 'null';
       }
       if (Array.isArray(value)) {
-        return 'array'
+        return 'array';
       }
-      return 'object'
+      return 'object';
     case 'boolean':
-      return 'boolean'
+      return 'boolean';
     default:
-      return 'unknown'
+      return 'unknown';
   }
 };
-
-const number = (value) => {
+const number = value => {
   const type = getType(value);
   if (type !== 'number') {
-    throw new AssertionError('expected value to be of type number')
+    throw new AssertionError('expected value to be of type number');
   }
 };
 
 const state$1 = {
-  id: 0,
+  callbacks: Object.create(null)
+};
+const set = (id, fn) => {
+  state$1.callbacks[id] = fn;
+};
+const get = id => {
+  return state$1.callbacks[id];
+};
+const remove = id => {
+  delete state$1.callbacks[id];
 };
 
+const state = {
+  id: 0
+};
 const create$3 = () => {
-  return ++state$1.id
+  return ++state.id;
 };
 
 const warn = (...args) => {
@@ -67,61 +77,60 @@ const withResolvers = () => {
    * @type {any}
    */
   let _resolve;
-  /**
-   * @type {any}
-   */
-  let _reject;
-  const promise = new Promise((resolve, reject) => {
+  const promise = new Promise(resolve => {
     _resolve = resolve;
-    _reject = reject;
   });
   return {
     resolve: _resolve,
-    reject: _reject,
-    promise,
-  }
-};
-
-const state = {
-  callbacks: Object.create(null),
+    promise
+  };
 };
 
 const registerPromise = () => {
   const id = create$3();
-  const { resolve, promise } = withResolvers();
-  state.callbacks[id] = resolve;
-  return { id, promise }
+  const {
+    resolve,
+    promise
+  } = withResolvers();
+  set(id, resolve);
+  return {
+    id,
+    promise
+  };
 };
-
 const resolve = (id, args) => {
   number(id);
-  if (!(id in state.callbacks)) {
+  const fn = get(id);
+  if (!fn) {
     console.log(args);
     warn(`callback ${id} may already be disposed`);
-    return
+    return;
   }
-  state.callbacks[id](args);
-  delete state.callbacks[id];
+  fn(args);
+  remove(id);
 };
 
 const create$2 = (method, params) => {
-  const { id, promise } = registerPromise();
+  const {
+    id,
+    promise
+  } = registerPromise();
   const message = {
     jsonrpc: Two,
     method,
     params,
-    id,
+    id
   };
   return {
     message,
-    promise,
-  }
+    promise
+  };
 };
 
-var JsonRpcRequest = /*#__PURE__*/Object.freeze({
+const JsonRpcRequest = {
   __proto__: null,
   create: create$2
-});
+};
 
 class JsonRpcError extends Error {
   constructor(message) {
@@ -130,6 +139,8 @@ class JsonRpcError extends Error {
   }
 }
 
+const NewLine = '\n';
+
 const DomException = 'DOMException';
 const ReferenceError$1 = 'ReferenceError';
 const SyntaxError$1 = 'SyntaxError';
@@ -139,85 +150,78 @@ const getErrorConstructor = (message, type) => {
   if (type) {
     switch (type) {
       case DomException:
-        return DOMException
+        // @ts-ignore
+        return DOMException;
       case TypeError$1:
-        return TypeError
+        return TypeError;
       case SyntaxError$1:
-        return SyntaxError
+        return SyntaxError;
       case ReferenceError$1:
-        return ReferenceError
+        return ReferenceError;
       default:
-        return Error
+        return Error;
     }
   }
   if (message.startsWith('TypeError: ')) {
-    return TypeError
+    return TypeError;
   }
   if (message.startsWith('SyntaxError: ')) {
-    return SyntaxError
+    return SyntaxError;
   }
   if (message.startsWith('ReferenceError: ')) {
-    return ReferenceError
+    return ReferenceError;
   }
-  return Error
-};
-
-const NewLine = '\n';
-
-/**
- *
- * @param {string} string
- * @param {number|undefined} startIndex
- * @returns
- */
-const getNewLineIndex = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine, startIndex)
-};
-
-const joinLines = (lines) => {
-  return lines.join(NewLine)
-};
-
-const MethodNotFound = -32601;
-const Custom = -32001;
-
-const splitLines = (lines) => {
-  return lines.split(NewLine)
+  return Error;
 };
 
 const constructError = (message, type, name) => {
   const ErrorConstructor = getErrorConstructor(message, type);
+  // @ts-ignore
   if (ErrorConstructor === DOMException && name) {
-    return new ErrorConstructor(message, name)
+    return new ErrorConstructor(message, name);
   }
   if (ErrorConstructor === Error) {
     const error = new Error(message);
     if (name && name !== 'VError') {
       error.name = name;
     }
-    return error
+    return error;
   }
-  return new ErrorConstructor(message)
+  return new ErrorConstructor(message);
 };
 
-const getParentStack = (error) => {
+const getNewLineIndex = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine, startIndex);
+};
+
+const joinLines = lines => {
+  return lines.join(NewLine);
+};
+
+const MethodNotFound = -32601;
+const Custom = -32001;
+
+const splitLines = lines => {
+  return lines.split(NewLine);
+};
+
+const getParentStack = error => {
   let parentStack = error.stack || error.data || error.message || '';
   if (parentStack.startsWith('    at')) {
     parentStack = error.message + NewLine + parentStack;
   }
-  return parentStack
+  return parentStack;
 };
-
-const restoreJsonRpcError = (error) => {
+const restoreJsonRpcError = error => {
   if (error && error instanceof Error) {
-    return error
+    return error;
   }
   const currentStack = joinLines(splitLines(new Error().stack).slice(1));
   if (error && error.code && error.code === MethodNotFound) {
     const restoredError = new JsonRpcError(error.message);
     const parentStack = getParentStack(error);
     restoredError.stack = parentStack + NewLine + currentStack;
-    return restoredError
+    return restoredError;
   }
   if (error && error.message) {
     const restoredError = constructError(error.message, error.type, error.name);
@@ -254,31 +258,31 @@ const restoreJsonRpcError = (error) => {
         restoredError.codeFrame = error.codeFrame;
       }
     }
-    return restoredError
+    return restoredError;
   }
   if (typeof error === 'string') {
-    return new Error(`JsonRpc Error: ${error}`)
+    return new Error(`JsonRpc Error: ${error}`);
   }
-  return new Error(`JsonRpc Error: ${error}`)
+  return new Error(`JsonRpc Error: ${error}`);
 };
 
-const unwrapJsonRpcResult = (responseMessage) => {
+const unwrapJsonRpcResult = responseMessage => {
   if ('error' in responseMessage) {
     const restoredError = restoreJsonRpcError(responseMessage.error);
-    throw restoredError
+    throw restoredError;
   }
   if ('result' in responseMessage) {
-    return responseMessage.result
+    return responseMessage.result;
   }
-  throw new JsonRpcError('unexpected response message')
+  throw new JsonRpcError('unexpected response message');
 };
 
 const create$1 = (message, error) => {
   return {
     jsonrpc: Two,
     id: message.id,
-    error,
-  }
+    error
+  };
 };
 
 const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
@@ -288,8 +292,8 @@ const getErrorProperty = (error, prettyError) => {
     return {
       code: MethodNotFound,
       message: error.message,
-      data: error.stack,
-    }
+      data: error.stack
+    };
   }
   return {
     code: Custom,
@@ -298,130 +302,84 @@ const getErrorProperty = (error, prettyError) => {
       stack: prettyError.stack,
       codeFrame: prettyError.codeFrame,
       type: prettyError.type,
-      code: prettyError.code,
-    },
-  }
+      code: prettyError.code
+    }
+  };
 };
-
-const getErrorResponse = (
-  message,
-  error,
-  ipc,
-  preparePrettyError,
-  logError,
-) => {
+const getErrorResponse = (message, error, ipc, preparePrettyError, logError) => {
   const prettyError = preparePrettyError(error);
   logError(error, prettyError);
   const errorProperty = getErrorProperty(error, prettyError);
-  return create$1(message, errorProperty)
+  return create$1(message, errorProperty);
 };
 
 const create = (message, result) => {
   return {
     jsonrpc: Two,
     id: message.id,
-    result: result ?? null,
-  }
+    result: result ?? null
+  };
 };
 
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create(message, resultProperty)
+  return create(message, resultProperty);
 };
 
-const getResponse = async (
-  message,
-  ipc,
-  execute,
-  preparePrettyError,
-  logError,
-  requiresSocket,
-) => {
+const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
   try {
-    const result = requiresSocket(message.method)
-      ? await execute(message.method, ipc, ...message.params)
-      : await execute(message.method, ...message.params);
-    return getSuccessResponse(message, result)
+    const result = requiresSocket(message.method) ? await execute(message.method, ipc, ...message.params) : await execute(message.method, ...message.params);
+    return getSuccessResponse(message, result);
   } catch (error) {
-    return getErrorResponse(
-      message,
-      error,
-      ipc,
-      preparePrettyError,
-      logError,
-    )
+    return getErrorResponse(message, error, ipc, preparePrettyError, logError);
   }
 };
 
-const handleJsonRpcMessage = async (
-  ipc,
-  message,
-  execute,
-  resolve,
-  preparePrettyError,
-  logError,
-  requiresSocket,
-) => {
+const handleJsonRpcMessage = async (ipc, message, execute, resolve, preparePrettyError, logError, requiresSocket) => {
   if ('id' in message) {
     if ('method' in message) {
-      const response = await getResponse(
-        message,
-        ipc,
-        execute,
-        preparePrettyError,
-        logError,
-        requiresSocket,
-      );
+      const response = await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
       try {
         ipc.send(response);
       } catch (error) {
-        const errorResponse = getErrorResponse(
-          message,
-          error,
-          ipc,
-          preparePrettyError,
-          logError,
-        );
+        const errorResponse = getErrorResponse(message, error, ipc, preparePrettyError, logError);
         ipc.send(errorResponse);
       }
-      return
+      return;
     }
     resolve(message.id, message);
-    return
+    return;
   }
   if ('method' in message) {
-    await getResponse(
-      message,
-      ipc,
-      execute,
-      preparePrettyError,
-      logError,
-      requiresSocket,
-    );
-    return
+    await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
+    return;
   }
-  throw new JsonRpcError('unexpected message')
+  throw new JsonRpcError('unexpected message');
 };
 
 const send = (transport, method, ...params) => {
   const message = create$4(method, params);
   transport.send(message);
 };
-
 const invoke = async (ipc, method, ...params) => {
-  const { message, promise } = create$2(method, params);
+  const {
+    message,
+    promise
+  } = create$2(method, params);
   ipc.send(message);
   const responseMessage = await promise;
   const result = unwrapJsonRpcResult(responseMessage);
-  return result
+  return result;
 };
-
 const invokeAndTransfer = async (ipc, handle, method, ...params) => {
-  const { message, promise } = create$2(method, params);
+  const {
+    message,
+    promise
+  } = create$2(method, params);
   ipc.sendAndTransfer(message, handle);
   const responseMessage = await promise;
   const result = unwrapJsonRpcResult(responseMessage);
-  return result
+  return result;
 };
 
 export { JsonRpcEvent, JsonRpcRequest, getErrorResponse, getSuccessResponse, handleJsonRpcMessage, invoke, invokeAndTransfer, resolve, send };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/json-rpc",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "JsonRpc implementation",
   "main": "dist/index.js",
   "type": "module",
@@ -11,6 +11,6 @@
   "author": "Lvce Editor",
   "license": "MIT",
   "dependencies": {
-    "@lvce-editor/assert": "^1.0.1"
+    "@lvce-editor/assert": "^1.2.0"
   }
 }