@lvce-editor/json-rpc 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023, Lvce Editor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,27 @@
+# @lvce-editor/json-rpc
+
+JsonRpc implementation.
+
+## Install
+
+```sh
+npm install @lvce-editor/json-rpc
+```
+
+## Usage
+
+```js
+import * as JsonRpc from '@lvce-editor/json-rpc'
+
+const ipc = {
+  send(message) {
+    JsonRpc.resolve(message.id, message.params[0], message.params[1])
+  },
+}
+
+await JsonRpc.invoke(ipc, 'add', 1, 2) // returns 3
+```
+
+## Gitpod
+
+[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/lvce-editor/json-rpc)

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export const invoke: (method: string, ...params: any[]) => Promise<any>
+
+export const resolve: (id: number, message: any) => void

package/dist/index.js

@@ -0,0 +1,234 @@
+const Two = '2.0';
+
+const create$2 = (method, params) => {
+  return {
+    jsonrpc: Two,
+    method,
+    params: params,
+  }
+};
+
+const state$1 = {
+  id: 0,
+};
+
+const create$1 = () => {
+  return ++state$1.id
+};
+
+const withResolvers = () => {
+  /**
+   * @type {any}
+   */
+  let _resolve;
+  /**
+   * @type {any}
+   */
+  let _reject;
+  const promise = new Promise((resolve, reject) => {
+    _resolve = resolve;
+    _reject = reject;
+  });
+  return {
+    resolve: _resolve,
+    reject: _reject,
+    promise,
+  }
+};
+
+const state = {
+  callbacks: Object.create(null),
+};
+
+const registerPromise = () => {
+  const id = create$1();
+  const { resolve, promise } = withResolvers();
+  state.callbacks[id] = resolve;
+  return { id, promise }
+};
+
+const create = (method, params) => {
+  const { id, promise } = registerPromise();
+  const message = {
+    jsonrpc: Two,
+    method,
+    params,
+    id,
+  };
+  return {
+    message,
+    promise,
+  }
+};
+
+class JsonRpcError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'JsonRpcError';
+  }
+}
+
+const DomException = 'DOMException';
+const ReferenceError$1 = 'ReferenceError';
+const SyntaxError$1 = 'SyntaxError';
+const TypeError$1 = 'TypeError';
+
+const getErrorConstructor = (message, type) => {
+  if (type) {
+    switch (type) {
+      case DomException:
+        return DOMException
+      case TypeError$1:
+        return TypeError
+      case SyntaxError$1:
+        return SyntaxError
+      case ReferenceError$1:
+        return ReferenceError
+      default:
+        return Error
+    }
+  }
+  if (message.startsWith('TypeError: ')) {
+    return TypeError
+  }
+  if (message.startsWith('SyntaxError: ')) {
+    return SyntaxError
+  }
+  if (message.startsWith('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 splitLines = (lines) => {
+  return lines.split(NewLine)
+};
+
+const constructError = (message, type, name) => {
+  const ErrorConstructor = getErrorConstructor(message, type);
+  if (ErrorConstructor === DOMException && name) {
+    return new ErrorConstructor(message, name)
+  }
+  if (ErrorConstructor === Error) {
+    const error = new Error(message);
+    if (name && name !== 'VError') {
+      error.name = name;
+    }
+    return error
+  }
+  return new ErrorConstructor(message)
+};
+
+const getParentStack = (error) => {
+  let parentStack = error.stack || error.data || error.message || '';
+  if (parentStack.startsWith('    at')) {
+    parentStack = error.message + NewLine + parentStack;
+  }
+  return parentStack
+};
+
+const restoreJsonRpcError = (error) => {
+  if (error && error instanceof 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
+  }
+  if (error && error.message) {
+    const restoredError = constructError(error.message, error.type, error.name);
+    if (error.data) {
+      if (error.data.stack && error.data.type && error.message) {
+        restoredError.stack = error.data.type + ': ' + error.message + NewLine + error.data.stack + NewLine + currentStack;
+      } else if (error.data.stack) {
+        restoredError.stack = error.data.stack;
+      }
+      if (error.data.codeFrame) {
+        // @ts-ignore
+        restoredError.codeFrame = error.data.codeFrame;
+      }
+      if (error.data.code) {
+        // @ts-ignore
+        restoredError.code = error.data.code;
+      }
+      if (error.data.type) {
+        // @ts-ignore
+        restoredError.name = error.data.type;
+      }
+    } else {
+      if (error.stack) {
+        // TODO accessing stack might be slow
+        const lowerStack = restoredError.stack || '';
+        // @ts-ignore
+        const indexNewLine = getNewLineIndex(lowerStack);
+        const parentStack = getParentStack(error);
+        // @ts-ignore
+        restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
+      }
+      if (error.codeFrame) {
+        // @ts-ignore
+        restoredError.codeFrame = error.codeFrame;
+      }
+    }
+    return restoredError
+  }
+  if (typeof error === 'string') {
+    return new Error(`JsonRpc Error: ${error}`)
+  }
+  return new Error(`JsonRpc Error: ${error}`)
+};
+
+const unwrapJsonRpcResult = (responseMessage) => {
+  if ('error' in responseMessage) {
+    const restoredError = restoreJsonRpcError(responseMessage.error);
+    throw restoredError
+  }
+  if ('result' in responseMessage) {
+    return responseMessage.result
+  }
+  throw new JsonRpcError('unexpected response message')
+};
+
+const send = (transport, method, ...params) => {
+  const message = create$2(method, params);
+  transport.send(message);
+};
+
+const invoke = async (ipc, method, ...params) => {
+  const { message, promise } = create(method, params);
+  ipc.send(message);
+  const responseMessage = await promise;
+  const result = unwrapJsonRpcResult(responseMessage);
+  return result
+};
+
+const invokeAndTransfer = async (ipc, handle, method, ...params) => {
+  const { message, promise } = create(method, params);
+  ipc.sendAndTransfer(message, handle);
+  const responseMessage = await promise;
+  const result = unwrapJsonRpcResult(responseMessage);
+  return result
+};
+
+export { invoke, invokeAndTransfer, send };

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@lvce-editor/json-rpc",
+  "version": "0.1.0",
+  "description": "JsonRpc implementation",
+  "main": "dist/index.js",
+  "type": "module",
+  "types": "dist/index.d.ts",
+  "keywords": [
+    "json-rpc"
+  ],
+  "author": "Lvce Editor",
+  "license": "MIT",
+  "dependencies": {
+    "@lvce-editor/assert": "^1.0.1"
+  }
+}