@lvce-editor/shared-process 0.15.28 → 0.15.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.15.28",
+  "version": "0.15.30",
   "description": "Utility package for @lvce-editor/server",
   "main": "index.js",
   "type": "module",
@@ -17,9 +17,9 @@
   },
   "dependencies": {
     "@babel/code-frame": "^7.22.5",
-    "@lvce-editor/extension-host": "0.15.28",
-    "@lvce-editor/extension-host-helper-process": "0.15.28",
-    "@lvce-editor/pty-host": "0.15.28",
+    "@lvce-editor/extension-host": "0.15.30",
+    "@lvce-editor/extension-host-helper-process": "0.15.30",
+    "@lvce-editor/pty-host": "0.15.30",
     "debug": "^4.3.4",
     "execa": "^7.1.1",
     "exit-hook": "^3.2.0",

package/src/parts/GetResponse/GetResponse.js

@@ -1,13 +1,12 @@
-import * as Command from '../Command/Command.js'
 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) => {
+export const getResponse = async (message, ipc, execute) => {
   try {
     const result = RequiresSocket.requiresSocket(message.method)
-      ? await Command.execute(message.method, ipc, ...message.params)
-      : await Command.execute(message.method, ...message.params)
+      ? 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)

package/src/parts/HandleJsonRpcMessage/HandleJsonRpcMessage.js

@@ -5,7 +5,7 @@ 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, execute)
+      const response = await GetResponse.getResponse(message, ipc, execute)
       try {
         ipc.send(response)
       } catch (error) {
@@ -18,7 +18,7 @@ export const handleJsonRpcMessage = async (ipc, message, execute, resolve) => {
     return
   }
   if ('method' in message) {
-    await GetResponse.getResponse(message, execute)
+    await GetResponse.getResponse(message, ipc, execute)
     return
   }
   throw new JsonRpcError('unexpected message')

package/src/parts/JsonRpc/JsonRpc.js

@@ -1,39 +1,23 @@
-import * as Callback from '../Callback/Callback.js'
-import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
+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) => {
-  transport.send({
-    jsonrpc: JsonRpcVersion.Two,
-    method,
-    params,
-  })
+  const message = JsonRpcEvent.create(method, params)
+  transport.send(message)
 }
 
 export const invoke = async (ipc, method, ...params) => {
-  const { id, promise } = Callback.registerPromise()
-  ipc.send({
-    jsonrpc: JsonRpcVersion.Two,
-    method,
-    params,
-    id,
-  })
+  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 { id, promise } = Callback.registerPromise()
-  ipc.sendAndTransfer(
-    {
-      jsonrpc: JsonRpcVersion.Two,
-      method,
-      params,
-      id,
-    },
-    handle
-  )
+  const { message, promise } = JsonRpcRequest.create(method, params)
+  ipc.sendAndTransfer(message, handle)
   const responseMessage = await promise
   const result = UnwrapJsonRpcResult.unwrapJsonRpcResult(responseMessage)
   return result

package/src/parts/JsonRpcEvent/JsonRpcEvent.js

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,16 @@
+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/OutputChannel/OutputChannel.ipc.js

@@ -1,5 +1,5 @@
 import * as Assert from '../Assert/Assert.js'
-import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
+import * as JsonRpcEvent from '../JsonRpcEvent/JsonRpcEvent.js'
 import * as OutputChannelState from '../OutputChannelState/OutputChannelState.js'
 import * as OutputChannel from './OutputChannel.js'
 
@@ -17,19 +17,13 @@ const open = (socket, id, path) => {
   }
   const onData = (data) => {
     console.log('send data', data)
-    socket.send({
-      jsonrpc: JsonRpcVersion.Two,
-      method: 'Output.handleData',
-      params: [data],
-    })
+    const message = JsonRpcEvent.create('Output.handleData', [data])
+    socket.send(message)
   }
   const onError = (error) => {
     console.info(`[shared process] output channel error: ${error}`)
-    socket.send({
-      jsonrpc: JsonRpcVersion.Two,
-      method: 'Output.handleError',
-      params: [error],
-    })
+    const message = JsonRpcEvent.create('Output.handleError', [error])
+    socket.send(message)
   }
   const outputChannel = OutputChannel.open(path, onData, onError)
   OutputChannelState.set(id, outputChannel)

package/src/parts/Terminal/Terminal.js

@@ -1,5 +1,5 @@
 import * as Assert from '../Assert/Assert.js'
-import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
+import * as JsonRpcEvent from '../JsonRpcEvent/JsonRpcEvent.js'
 import * as PtyHost from '../PtyHost/PtyHost.js'
 import * as TerminalState from '../TerminalState/TerminalState.js'
 import { VError } from '../VError/VError.js'
@@ -28,21 +28,18 @@ const createTerminal = (ptyHost, socket) => {
   }
 }
 
-export const create = async (socket, id, cwd, command, args) => {
+export const create = async (ipc, id, cwd, command, args) => {
   try {
-    Assert.object(socket)
+    Assert.object(ipc)
     Assert.number(id)
     Assert.string(cwd)
     // TODO race condition because of await
     const ptyHost = await PtyHost.getOrCreate()
-    const terminal = createTerminal(ptyHost, socket)
+    const terminal = createTerminal(ptyHost, ipc)
     TerminalState.add(id, terminal)
     // TODO use invoke
-    ptyHost.send({
-      jsonrpc: JsonRpcVersion.Two,
-      method: 'Terminal.create',
-      params: [id, cwd, command, args],
-    })
+    const message = JsonRpcEvent.create('Terminal.create', [id, cwd, command, args])
+    ptyHost.send(message)
   } catch (error) {
     throw new VError(error, `Failed to create terminal`)
   }
@@ -57,11 +54,8 @@ export const write = (id, data) => {
     return
   }
   // TODO should use invoke
-  ptyHost.send({
-    jsonrpc: JsonRpcVersion.Two,
-    method: 'Terminal.write',
-    params: [id, data],
-  })
+  const message = JsonRpcEvent.create('Terminal.write', [id, data])
+  ptyHost.send(message)
 }
 
 export const resize = (state, columns, rows) => {
@@ -73,12 +67,9 @@ export const dispose = async (id) => {
   terminal.dispose()
   TerminalState.remove(id)
   const ptyHost = await PtyHost.getOrCreate()
+  const message = JsonRpcEvent.create('Terminal.dispose', [id])
   // TODO use invoke
-  ptyHost.send({
-    jsonrpc: JsonRpcVersion.Two,
-    method: 'Terminal.dispose',
-    params: [id],
-  })
+  ptyHost.send(message)
 }
 
 export const disposeAll = () => {