@lvce-editor/extension-host-helper-process 0.53.4 → 0.53.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/extension-host-helper-process",
-  "version": "0.53.4",
+  "version": "0.53.5",
   "description": "",
   "main": "index.js",
   "type": "module",
@@ -19,6 +19,7 @@
     "@lvce-editor/assert": "^1.3.0",
     "@lvce-editor/ipc": "^14.2.0",
     "@lvce-editor/json-rpc": "^6.2.0",
+    "@lvce-editor/rpc": "^4.1.0",
     "@lvce-editor/verror": "^1.7.0",
     "execa": "^9.5.3",
     "got": "^14.4.7",

package/src/parts/Exit/Exit.js

@@ -0,0 +1,3 @@
+export const exit = () => {
+  process.exit(0)
+}

package/src/parts/HandleElectronMessagePort/HandleElectronMessagePort.js

@@ -1,22 +1,15 @@
 import * as Assert from '../Assert/Assert.js'
-import * as HandleIpc from '../HandleIpc/HandleIpc.js'
 import * as IpcChild from '../IpcChild/IpcChild.js'
+import * as HandleIpcClosed from '../HandleIpcClosed/HandleIpcClosed.js'
 import * as IpcChildType from '../IpcChildType/IpcChildType.js'
-import * as IpcId from '../IpcId/IpcId.js'
 
-const handleClose = () => {
-  process.exit(0)
-}
-
-export const handleElectronMessagePort = async (messagePort, ipcId) => {
+export const handleElectronMessagePort = async (messagePort) => {
+  // TODO make it so when messageport closes, the process exits
   Assert.object(messagePort)
-  const ipc = await IpcChild.listen({
+  const rpc = await IpcChild.listen({
     method: IpcChildType.ElectronMessagePort,
     messagePort,
   })
-  HandleIpc.handleIpc(ipc)
-  if (ipcId === IpcId.ExtensionHostWorker) {
-    // @ts-ignore
-    ipc.addEventListener('close', handleClose)
-  }
+  // @ts-ignore
+  rpc.ipc.addEventListener('close', HandleIpcClosed.handleIpcClosed)
 }

package/src/parts/HandleIpcClosed/HandleIpcClosed.js

@@ -0,0 +1,5 @@
+import * as Exit from '../Exit/Exit.js'
+
+export const handleIpcClosed = () => {
+  Exit.exit()
+}

package/src/parts/HandleWebSocket/HandleWebSocket.js

@@ -1,15 +1,16 @@
 import * as Assert from '../Assert/Assert.js'
-import * as HandleIpc from '../HandleIpc/HandleIpc.js'
 import * as IpcChild from '../IpcChild/IpcChild.js'
 import * as IpcChildType from '../IpcChildType/IpcChildType.js'
+import * as HandleIpcClosed from '../HandleIpcClosed/HandleIpcClosed.js'
 
 export const handleWebSocket = async (handle, request) => {
+  // TODO make it so when websocket closes, the process exits
   Assert.object(handle)
   Assert.object(request)
-  const ipc = await IpcChild.listen({
+  handle.on('close', HandleIpcClosed.handleIpcClosed)
+  await IpcChild.listen({
     method: IpcChildType.WebSocket,
     request,
     handle,
   })
-  HandleIpc.handleIpc(ipc)
 }

package/src/parts/IpcChild/IpcChild.js

@@ -1,13 +1,8 @@
 import * as IpcChildModule from '../IpcChildModule/IpcChildModule.js'
 
 export const listen = async ({ method, ...params }) => {
-  const module = await IpcChildModule.getModule(method)
-  const rawIpc = await module.listen(params)
+  const create = IpcChildModule.getModule(method)
   // @ts-ignore
-  if (module.signal) {
-    // @ts-ignore
-    module.signal(rawIpc)
-  }
-  const ipc = module.wrap(rawIpc)
-  return ipc
+  const rpc = await create(params)
+  return rpc
 }

package/src/parts/IpcChildModule/IpcChildModule.js

@@ -1,21 +1,24 @@
 import {
-  IpcChildWithElectronMessagePort,
-  IpcChildWithElectronUtilityProcess,
-  IpcChildWithNodeForkedProcess,
-  IpcChildWithWebSocket,
-} from '@lvce-editor/ipc'
+  ElectronMessagePortRpcClient,
+  ElectronUtilityProcessRpcClient,
+  NodeForkedProcessRpcClient,
+  NodeWebSocketRpcClient,
+  NodeWorkerRpcClient,
+} from '@lvce-editor/rpc'
 import * as IpcChildType from '../IpcChildType/IpcChildType.js'
 
 export const getModule = (method) => {
   switch (method) {
-    case IpcChildType.WebSocket:
-      return IpcChildWithWebSocket
     case IpcChildType.NodeForkedProcess:
-      return IpcChildWithNodeForkedProcess
-    case IpcChildType.ElectronMessagePort:
-      return IpcChildWithElectronMessagePort
+      return NodeForkedProcessRpcClient.create
+    case IpcChildType.NodeWorker:
+      return NodeWorkerRpcClient.create
     case IpcChildType.ElectronUtilityProcess:
-      return IpcChildWithElectronUtilityProcess
+      return ElectronUtilityProcessRpcClient.create
+    case IpcChildType.ElectronMessagePort:
+      return ElectronMessagePortRpcClient.create
+    case IpcChildType.WebSocket:
+      return NodeWebSocketRpcClient.create
     default:
       throw new Error('unexpected ipc type')
   }

package/src/parts/IpcChildType/IpcChildType.js

@@ -1,38 +1,18 @@
-import * as ParseCliArgs from '../ParseCliArgs/ParseCliArgs.js'
-
-export const WebSocket = 1
-export const MessagePort = 2
-export const Parent = 3
+export const NodeWorker = 1
+export const NodeForkedProcess = 2
+export const ElectronUtilityProcess = 3
 export const ElectronMessagePort = 4
-export const ElectronUtilityProcess = 5
-export const ElectronUtilityProcessMessagePort = 6
-export const NodeForkedProcess = 7
-
-const getRawIpcType = () => {
-  const { argv } = process
-  const parsedArgs = ParseCliArgs.parseCliArgs(argv.slice(2))
-  const ipcType = parsedArgs['ipc-type']
-  return ipcType
-}
+export const WebSocket = 6
 
-export const Auto = () => {
-  const ipcType = getRawIpcType()
-  switch (ipcType) {
-    case 'websocket':
-      return WebSocket
-    case 'message-port':
-      return MessagePort
-    case 'parent':
-      return Parent
-    case 'electron-message-port':
-      return ElectronMessagePort
-    case 'electron-utility-process':
-      return ElectronUtilityProcess
-    case 'electron-utility-process-message-port':
-      return ElectronUtilityProcessMessagePort
-    case 'node-forked-process':
-      return NodeForkedProcess
-    default:
-      throw new Error(`[extension-host-helper-process] unknown ipc type ${ipcType}`)
+export const Auto = (argv) => {
+  if (argv.includes('--ipc-type=node-worker')) {
+    return NodeWorker
+  }
+  if (argv.includes('--ipc-type=node-forked-process')) {
+    return NodeForkedProcess
+  }
+  if (argv.includes('--ipc-type=electron-utility-process')) {
+    return ElectronUtilityProcess
   }
+  throw new Error(`[file-system-process] unknown ipc type`)
 }

package/src/parts/Listen/Listen.js

@@ -0,0 +1,10 @@
+import * as CommandMap from '../CommandMap/CommandMap.js'
+import * as IpcChild from '../IpcChild/IpcChild.js'
+import * as IpcChildType from '../IpcChildType/IpcChildType.js'
+
+export const listen = async (argv) => {
+  await IpcChild.listen({
+    method: IpcChildType.Auto(argv),
+    commandMap: CommandMap.commandMap,
+  })
+}

package/src/parts/Main/Main.js

@@ -1,13 +1,7 @@
-import * as CommandMap from '../CommandMap/CommandMap.js'
-import * as CommandState from '../CommandState/CommandState.js'
-import * as HandleIpc from '../HandleIpc/HandleIpc.js'
-import * as IpcChild from '../IpcChild/IpcChild.js'
-import * as IpcChildType from '../IpcChildType/IpcChildType.js'
 import * as ProcessListeners from '../ProcessListeners/ProcessListeners.js'
+import * as Listen from '../Listen/Listen.js'
 
 export const main = async () => {
   process.on('disconnect', ProcessListeners.handleDisconnect)
-  CommandState.registerCommands(CommandMap.commandMap)
-  const ipc = await IpcChild.listen({ method: IpcChildType.Auto() })
-  HandleIpc.handleIpc(ipc)
+  await Listen.listen(process.argv)
 }