@lvce-editor/shared-process 0.20.11 → 0.20.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.20.11",
+  "version": "0.20.13",
   "main": "index.js",
   "type": "module",
   "keywords": [
@@ -18,11 +18,12 @@
   },
   "dependencies": {
     "@babel/code-frame": "^7.23.5",
-    "@lvce-editor/extension-host": "0.20.11",
-    "@lvce-editor/extension-host-helper-process": "0.20.11",
+    "@lvce-editor/extension-host": "0.20.13",
+    "@lvce-editor/extension-host-helper-process": "0.20.13",
+    "@lvce-editor/json-rpc": "^0.4.0",
     "@lvce-editor/jsonc-parser": "^1.1.0",
     "@lvce-editor/pretty-error": "^1.2.2",
-    "@lvce-editor/pty-host": "0.20.11",
+    "@lvce-editor/pty-host": "0.20.13",
     "@lvce-editor/verror": "^1.1.2",
     "debug": "^4.3.4",
     "execa": "^8.0.1",

package/src/parts/Callback/Callback.js

@@ -1,26 +1 @@
-import * as Assert from '../Assert/Assert.js'
-import * as Id from '../Id/Id.js'
-import * as Logger from '../Logger/Logger.js'
-import * as Promises from '../Promises/Promises.js'
-
-export const state = {
-  callbacks: Object.create(null),
-}
-
-export const registerPromise = () => {
-  const id = Id.create()
-  const { resolve, promise } = Promises.withResolvers()
-  state.callbacks[id] = resolve
-  return { id, promise }
-}
-
-export const resolve = (id, args) => {
-  Assert.number(id)
-  if (!(id in state.callbacks)) {
-    console.log(args)
-    Logger.warn(`callback ${id} may already be disposed`)
-    return
-  }
-  state.callbacks[id](args)
-  delete state.callbacks[id]
-}
+export { resolve } from '@lvce-editor/json-rpc'

package/src/parts/GetResponse/GetResponse.js

@@ -2,13 +2,13 @@ import * as GetErrorResponse from '../GetErrorResponse/GetErrorResponse.js'
 import * as GetSuccessResponse from '../GetSuccessResponse/GetSuccessResponse.js'
 import * as RequiresSocket from '../RequiresSocket/RequiresSocket.js'
 
-export const getResponse = async (message, ipc, execute) => {
+export const getResponse = async (message, ipc, execute, preparePrettyError, logError) => {
   try {
     const result = RequiresSocket.requiresSocket(message.method)
       ? await execute(message.method, ipc, ...message.params)
       : await execute(message.method, ...message.params)
     return GetSuccessResponse.getSuccessResponse(message, result)
   } catch (error) {
-    return GetErrorResponse.getErrorResponse(message, error, ipc)
+    return GetErrorResponse.getErrorResponse(message, error, ipc, preparePrettyError, logError)
   }
 }

package/src/parts/HandleIpc/HandleIpc.js

@@ -1,10 +1,23 @@
 import * as Callback from '../Callback/Callback.js'
 import * as Command from '../Command/Command.js'
-import * as HandleJsonRpcMessage from '../HandleJsonRpcMessage/HandleJsonRpcMessage.js'
+import * as JsonRpc from '../JsonRpc/JsonRpc.js'
+import * as PrettyError from '../PrettyError/PrettyError.js'
+import * as PrintPrettyError from '../PrintPrettyError/PrintPrettyError.js'
+import * as RequiresSocket from '../RequiresSocket/RequiresSocket.js'
+import * as ShouldLogError from '../ShouldLogError/ShouldLogError.js'
+
+const preparePrettyError = PrettyError.prepare
+
+const logError = (error, prettyError) => {
+  if (ShouldLogError.shouldLogError(error)) {
+    PrintPrettyError.printPrettyError(prettyError, `[shared-process] `)
+  }
+}
 
 export const handleIpc = (ipc) => {
   const handleMessage = (message) => {
-    return HandleJsonRpcMessage.handleJsonRpcMessage(ipc, message, Command.execute, Callback.resolve)
+    // @ts-ignore
+    return JsonRpc.handleJsonRpcMessage(ipc, message, Command.execute, Callback.resolve, preparePrettyError, logError, RequiresSocket.requiresSocket)
   }
   ipc.on('message', handleMessage)
 }

package/src/parts/JsonRpc/JsonRpc.js

@@ -1,24 +1 @@
-import * as JsonRpcEvent from '../JsonRpcEvent/JsonRpcEvent.js'
-import * as JsonRpcRequest from '../JsonRpcRequest/JsonRpcRequest.js'
-import * as UnwrapJsonRpcResult from '../UnwrapJsonRpcResult/UnwrapJsonRpcResult.js'
-
-export const send = (transport, method, ...params) => {
-  const message = JsonRpcEvent.create(method, params)
-  transport.send(message)
-}
-
-export const invoke = async (ipc, method, ...params) => {
-  const { message, promise } = JsonRpcRequest.create(method, params)
-  ipc.send(message)
-  const responseMessage = await promise
-  const result = UnwrapJsonRpcResult.unwrapJsonRpcResult(responseMessage)
-  return result
-}
-
-export const invokeAndTransfer = async (ipc, handle, method, ...params) => {
-  const { message, promise } = JsonRpcRequest.create(method, params)
-  ipc.sendAndTransfer(message, handle)
-  const responseMessage = await promise
-  const result = UnwrapJsonRpcResult.unwrapJsonRpcResult(responseMessage)
-  return result
-}
+export * from '@lvce-editor/json-rpc'

package/src/parts/OutputChannel/OutputChannel.ipc.js

@@ -1,5 +1,5 @@
 import * as Assert from '../Assert/Assert.js'
-import * as JsonRpcEvent from '../JsonRpcEvent/JsonRpcEvent.js'
+import { JsonRpcEvent } from '../JsonRpc/JsonRpc.js'
 import * as OutputChannelState from '../OutputChannelState/OutputChannelState.js'
 import * as OutputChannel from './OutputChannel.js'
 

package/src/parts/Platform/Platform.js

@@ -51,11 +51,11 @@ export const getSetupName = () => {
   return 'Lvce-Setup'
 }
 
-export const version = '0.20.11'
+export const version = '0.20.13'
 
-export const commit = '49d995f'
+export const commit = '82b9796'
 
-export const date = '2023-12-02T12:20:42.000Z'
+export const date = '2023-12-04T22:27:58.000Z'
 
 export const getVersion = () => {
   return version

package/src/parts/Terminal/Terminal.js

@@ -1,5 +1,5 @@
 import * as Assert from '../Assert/Assert.js'
-import * as JsonRpcEvent from '../JsonRpcEvent/JsonRpcEvent.js'
+import { JsonRpcEvent } from '../JsonRpc/JsonRpc.js'
 import * as PtyHost from '../PtyHost/PtyHost.js'
 import * as TerminalState from '../TerminalState/TerminalState.js'
 import { VError } from '../VError/VError.js'

package/src/parts/GetErrorResponse/GetErrorResponse.js

@@ -1,48 +0,0 @@
-import { CommandNotFoundError } from '../CommandNotFoundError/CommandNotFoundError.js'
-import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
-import * as JsonRpcErrorCode from '../JsonRpcErrorCode/JsonRpcErrorCode.js'
-import * as JsonRpcErrorResponse from '../JsonRpcErrorResponse/JsonRpcErrorResponse.js'
-import * as PrettyError from '../PrettyError/PrettyError.js'
-import * as PrintPrettyError from '../PrintPrettyError/PrintPrettyError.js'
-import * as ShouldLogError from '../ShouldLogError/ShouldLogError.js'
-
-const getErrorProperty = (error, prettyError) => {
-  if (error && error instanceof CommandNotFoundError) {
-    return {
-      code: JsonRpcErrorCode.MethodNotFound,
-      message: error.message,
-      data: error.stack,
-    }
-  }
-  if (!ShouldLogError.shouldLogError(error)) {
-    return {
-      code: JsonRpcErrorCode.Custom,
-      message: `${error}`,
-      data: {
-        stack: prettyError.stack,
-        codeFrame: prettyError.codeFrame,
-        type: prettyError.type,
-        code: prettyError.code,
-      },
-    }
-  }
-  return {
-    code: JsonRpcErrorCode.Custom,
-    message: prettyError.message,
-    data: {
-      stack: prettyError.stack,
-      codeFrame: prettyError.codeFrame,
-      type: prettyError.type,
-      code: prettyError.code,
-    },
-  }
-}
-
-export const getErrorResponse = (message, error, ipc) => {
-  const prettyError = PrettyError.prepare(error)
-  if (ShouldLogError.shouldLogError(error)) {
-    PrintPrettyError.printPrettyError(prettyError, `[shared-process] `)
-  }
-  const errorProperty = getErrorProperty(error, prettyError)
-  return JsonRpcErrorResponse.create(message, errorProperty)
-}

package/src/parts/HandleJsonRpcMessage/HandleJsonRpcMessage.js

@@ -1,25 +0,0 @@
-import * as GetErrorResponse from '../GetErrorResponse/GetErrorResponse.js'
-import * as GetResponse from '../GetResponse/GetResponse.js'
-import { JsonRpcError } from '../JsonRpcError/JsonRpcError.js'
-
-export const handleJsonRpcMessage = async (ipc, message, execute, resolve) => {
-  if ('id' in message) {
-    if ('method' in message) {
-      const response = await GetResponse.getResponse(message, ipc, execute)
-      try {
-        ipc.send(response)
-      } catch (error) {
-        const errorResponse = GetErrorResponse.getErrorResponse(message, error)
-        ipc.send(errorResponse)
-      }
-      return
-    }
-    resolve(message.id, message)
-    return
-  }
-  if ('method' in message) {
-    await GetResponse.getResponse(message, ipc, execute)
-    return
-  }
-  throw new JsonRpcError('unexpected message')
-}

package/src/parts/JsonRpcError/JsonRpcError.js

@@ -1,6 +0,0 @@
-export class JsonRpcError extends Error {
-  constructor(message) {
-    super(message)
-    this.name = 'JsonRpcError'
-  }
-}

package/src/parts/JsonRpcErrorCode/JsonRpcErrorCode.js

@@ -1,2 +0,0 @@
-export const MethodNotFound = -32601
-export const Custom = -32001

package/src/parts/JsonRpcErrorResponse/JsonRpcErrorResponse.js

@@ -1,9 +0,0 @@
-import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
-
-export const create = (message, error) => {
-  return {
-    jsonrpc: JsonRpcVersion.Two,
-    id: message.id,
-    error,
-  }
-}

package/src/parts/JsonRpcEvent/JsonRpcEvent.js

@@ -1,9 +0,0 @@
-import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
-
-export const create = (method, params) => {
-  return {
-    jsonrpc: JsonRpcVersion.Two,
-    method,
-    params: params,
-  }
-}

package/src/parts/JsonRpcRequest/JsonRpcRequest.js

@@ -1,16 +0,0 @@
-import * as Callback from '../Callback/Callback.js'
-import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
-
-export const create = (method, params) => {
-  const { id, promise } = Callback.registerPromise()
-  const message = {
-    jsonrpc: JsonRpcVersion.Two,
-    method,
-    params,
-    id,
-  }
-  return {
-    message,
-    promise,
-  }
-}

package/src/parts/JsonRpcSuccessResponse/JsonSuccessResponse.js

@@ -1,9 +0,0 @@
-import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
-
-export const create = (message, result) => {
-  return {
-    jsonrpc: JsonRpcVersion.Two,
-    id: message.id,
-    result: result ?? null,
-  }
-}

package/src/parts/RestoreJsonRpcError/RestoreJsonRpcError.js

@@ -1,79 +0,0 @@
-import * as Character from '../Character/Character.js'
-import * as GetErrorConstructor from '../GetErrorConstructor/GetErrorConstructor.js'
-import * as JoinLines from '../JoinLines/JoinLines.js'
-import { JsonRpcError } from '../JsonRpcError/JsonRpcError.js'
-import * as JsonRpcErrorCode from '../JsonRpcErrorCode/JsonRpcErrorCode.js'
-import * as SplitLines from '../SplitLines/SplitLines.js'
-
-const constructError = (message, type, name) => {
-  const ErrorConstructor = GetErrorConstructor.getErrorConstructor(message, type)
-  // @ts-ignore
-  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 recreateStack = (message, stack) => {
-  if (message && !stack.includes(message)) {
-    return message + Character.NewLine + stack
-  }
-  return stack
-}
-
-const getErrorType = (error) => {
-  if (error && error.type) {
-    return error.type
-  }
-  if (error && error.data && error.data.type) {
-    return error.data.type
-  }
-  return ''
-}
-
-export const restoreJsonRpcError = (error) => {
-  if (error && error instanceof Error) {
-    return error
-  }
-  if (error && error.code && error.code === JsonRpcErrorCode.MethodNotFound) {
-    const restoredError = new JsonRpcError(error.message)
-    restoredError.stack = error.stack || error.data || ''
-    return restoredError
-  }
-  if (error && error.message) {
-    const type = getErrorType(error)
-    const restoredError = constructError(error.message, type, error.name)
-    const currentStack = JoinLines.joinLines(SplitLines.splitLines(new Error().stack).slice(1))
-    if (error.data) {
-      if (error.data.stack && type && error.message) {
-        restoredError.stack = type + ': ' + error.message + Character.NewLine + error.data.stack + Character.NewLine + currentStack
-      } else if (error.data.stack) {
-        restoredError.stack = recreateStack(error.message, error.data.stack) + Character.NewLine + currentStack
-      }
-      if (error.data.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.data.codeFrame
-      }
-      if (error.data.code) {
-        // @ts-ignore
-        restoredError.code = error.data.code
-      }
-    } else if (error.stack) {
-      // @ts-ignore
-      restoredError.stack = recreateStack(error.message, error.stack) + Character.NewLine + currentStack
-    }
-    return restoredError
-  }
-  if (typeof error === 'string') {
-    return new Error(`JsonRpc Error: ${error}`)
-  }
-  console.log({ error })
-  return new Error(`JsonRpc Error: Unknown Error`)
-}

package/src/parts/UnwrapJsonRpcResult/UnwrapJsonRpcResult.js

@@ -1,13 +0,0 @@
-import { JsonRpcError } from '../JsonRpcError/JsonRpcError.js'
-import * as RestoreJsonRpcError from '../RestoreJsonRpcError/RestoreJsonRpcError.js'
-
-export const unwrapJsonRpcResult = (responseMessage) => {
-  if ('error' in responseMessage) {
-    const restoredError = RestoreJsonRpcError.restoreJsonRpcError(responseMessage.error)
-    throw restoredError
-  }
-  if ('result' in responseMessage) {
-    return responseMessage.result
-  }
-  throw new JsonRpcError('unexpected response message')
-}