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

package/package.json

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

package/src/parts/CommandMapRef/CommandMapRef.js

@@ -0,0 +1 @@
+export const commandMapRef = {}

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,12 @@
+import * as CommandMap from '../CommandMap/CommandMap.js'
+import * as IpcChild from '../IpcChild/IpcChild.js'
+import * as IpcChildType from '../IpcChildType/IpcChildType.js'
+import * as CommandMapRef from '../CommandMapRef/CommandMapRef.js'
+
+export const listen = async (argv) => {
+  Object.assign(CommandMapRef.commandMapRef, CommandMap.commandMap)
+  await IpcChild.listen({
+    method: IpcChildType.Auto(argv),
+    commandMap: CommandMapRef.commandMapRef,
+  })
+}

package/src/parts/LoadFile/LoadFile.js

@@ -1,7 +1,7 @@
-import { VError } from '../VError/VError.js'
-import * as CommandState from '../CommandState/CommandState.js'
-import * as ImportScript from '../ImportScript/ImportScript.js'
+import * as Command from '@lvce-editor/command'
 import * as Assert from '../Assert/Assert.js'
+import * as ImportScript from '../ImportScript/ImportScript.js'
+import { VError } from '../VError/VError.js'
 
 export const loadFile = async (path) => {
   try {
@@ -9,9 +9,9 @@ export const loadFile = async (path) => {
     const module = await ImportScript.importScript(path)
     if (module && module.commandMap) {
       const commandMap = module.commandMap
-      CommandState.registerCommands(commandMap)
+      Command.register(commandMap)
     } else if (module && module.execute) {
-      CommandState.setExecute(module.execute)
+      throw new Error(`execute function is not supported anymore. Use commandMap instead`)
     } else {
       throw new Error(`missing export const execute function`)
     }

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)
 }

package/src/parts/Command/Command.js

@@ -1,10 +0,0 @@
-import { CommandNotFoundError } from '../CommandNotFoundError/CommandNotFoundError.js'
-import * as CommandState from '../CommandState/CommandState.js'
-
-export const execute = (command, ...args) => {
-  const fn = CommandState.getCommand(command)
-  if (!fn) {
-    throw new CommandNotFoundError(command)
-  }
-  return fn(...args)
-}

package/src/parts/CommandNotFoundError/CommandNotFoundError.js

@@ -1,9 +0,0 @@
-import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
-
-export class CommandNotFoundError extends Error {
-  constructor(id) {
-    super(`command ${id} not found`)
-    this.name = 'CommandNotFoundError'
-    this.code = ErrorCodes.E_COMMAND_NOT_FOUND
-  }
-}

package/src/parts/CommandState/CommandState.js

@@ -1,43 +0,0 @@
-import * as Assert from '../Assert/Assert.js'
-import { VError } from '../VError/VError.js'
-
-export const state = {
-  commands: Object.create(null),
-  /**
-   * @type {any}
-   */
-  execute: undefined,
-}
-
-export const registerCommand = (key, fn) => {
-  try {
-    Assert.string(key)
-    Assert.fn(fn)
-    state.commands[key] = fn
-  } catch (error) {
-    throw new VError(error, `Failed to register command ${key}`)
-  }
-}
-
-export const registerCommands = (commandMap) => {
-  for (const [key, value] of Object.entries(commandMap)) {
-    registerCommand(key, value)
-  }
-}
-
-export const getCommand = (key) => {
-  const { commands, execute } = state
-  if (key in commands) {
-    return commands[key]
-  }
-  if (execute) {
-    return (...args) => {
-      return execute(key, ...args)
-    }
-  }
-  return undefined
-}
-
-export const setExecute = (fn) => {
-  state.execute = fn
-}

package/src/parts/FirstUtilityProcessEventType/FirstUtilityProcessEventType.js

@@ -1 +0,0 @@
-export const Message = 1

package/src/parts/GetFirstUtilityProcessEvent/GetFirstUtilityProcessEvent.js

@@ -1,21 +0,0 @@
-import * as FirstUtilityProcessEventType from '../FirstUtilityProcessEventType/FirstUtilityProcessEventType.js'
-
-export const getFirstUtilityProcessEvent = async (parentPort) => {
-  const { type, event } = await new Promise((resolve) => {
-    const cleanup = (value) => {
-      parentPort.off('message', handleMessage)
-      resolve(value)
-    }
-    const handleMessage = (event) => {
-      cleanup({
-        type: FirstUtilityProcessEventType.Message,
-        event,
-      })
-    }
-    parentPort.on('message', handleMessage)
-  })
-  return {
-    type,
-    event,
-  }
-}

package/src/parts/GetUtilityProcessPortData/GetUtilityProcessPortData.js

@@ -1,10 +0,0 @@
-export const getUtilityProcessPortData = (event) => {
-  const { data, ports } = event
-  if (ports.length === 0) {
-    return data
-  }
-  return {
-    ...data,
-    params: [...ports, ...data.params],
-  }
-}

package/src/parts/HandleIpc/HandleIpc.js

@@ -1,10 +0,0 @@
-import * as HandleMessage from '../HandleMessage/HandleMessage.js'
-
-export const handleIpc = (ipc) => {
-  if ('addEventListener' in ipc) {
-    ipc.addEventListener('message', HandleMessage.handleMessage)
-  } else {
-    // deprecated
-    ipc.on('message', HandleMessage.handleMessage)
-  }
-}

package/src/parts/HandleMessage/HandleMessage.js

@@ -1,19 +0,0 @@
-import * as Callback from '../Callback/Callback.js'
-import * as Command from '../Command/Command.js'
-import * as JsonRpc from '../JsonRpc/JsonRpc.js'
-
-const preparePrettyError = (error) => {
-  return error
-}
-
-const logError = (error, prettyError) => {
-  // this is handled by shared process
-}
-
-const requiresSocket = () => {
-  return false
-}
-
-export const handleMessage = (event) => {
-  return JsonRpc.handleJsonRpcMessage(event.target, event.data, Command.execute, Callback.resolve, preparePrettyError, logError, requiresSocket)
-}

package/src/parts/IsMessagePortMain/IsMessagePortMain.js

@@ -1,3 +0,0 @@
-export const isMessagePortMain = (value) => {
-  return value && value.constructor && value.constructor.name === 'MessagePortMain'
-}

package/src/parts/JsonRpc/JsonRpc.js

@@ -1 +0,0 @@
-export * from '@lvce-editor/json-rpc'

package/src/parts/PrintPrettyError/PrintPrettyError.js

@@ -1,5 +0,0 @@
-import * as Logger from '../Logger/Logger.js'
-
-export const printPrettyError = (prettyError, prefix = '') => {
-  Logger.error(`${prefix}${prettyError.type}: ${prettyError.message}\n\n${prettyError.codeFrame}\n\n${prettyError.stack}\n`)
-}