@lvce-editor/extension-host-helper-process 0.14.15 → 0.15.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/extension-host-helper-process",
-  "version": "0.14.15",
+  "version": "0.15.1",
   "description": "",
   "main": "index.js",
   "type": "module",
@@ -21,6 +21,8 @@
     "execa": "^6.1.0",
     "got": "^12.5.3",
     "lines-and-columns": "^2.0.3",
+    "minimist": "^1.2.8",
+    "verror": "^1.10.1",
     "ws": "^8.11.0"
   }
 }

package/src/extensionHostHelperProcessMain.cjs

@@ -0,0 +1,5 @@
+const main = async () => {
+  await import('./extensionHostHelperProcessMain.js')
+}
+
+main()

package/src/extensionHostHelperProcessMain.js

@@ -1,10 +1,42 @@
+import * as GetErrorResponse from './parts/GetErrorResponse/GetErrorResponse.js'
+import * as GetSuccessResponse from './parts/GetSuccessResponse/GetSuccessResponse.js'
+import * as ImportScript from './parts/ImportScript/ImportScript.js'
 import * as IpcChild from './parts/IpcChild/IpcChild.js'
 import * as IpcChildType from './parts/IpcChildType/IpcChildType.js'
 import * as Rpc from './parts/Rpc/Rpc.js'
+import * as GetResponse from './parts/GetResponse/GetResponse.js'
+
+const waitForFirstMessage = async (ipc) => {
+  const { message } = await new Promise((resolve) => {
+    const cleanup = (value) => {
+      ipc.off('message', handleMessage)
+      resolve(value)
+    }
+    const handleMessage = (message) => {
+      cleanup({ message })
+    }
+    ipc.on('message', handleMessage)
+  })
+  return message
+}
 
 const main = async () => {
   const ipc = await IpcChild.listen({ method: IpcChildType.Auto() })
-  Rpc.listen(ipc)
+  const firstMessage = await waitForFirstMessage(ipc)
+  let module
+  try {
+    module = await ImportScript.importScript(firstMessage.params[0])
+    if (!module || !module.execute) {
+      throw new Error(`missing export const execute function`)
+    }
+    const response = GetSuccessResponse.getSuccessResponse(firstMessage, null)
+    ipc.send(response)
+  } catch (error) {
+    const response = await GetErrorResponse.getErrorResponse(firstMessage, error)
+    ipc.send(response)
+    return
+  }
+  Rpc.listen(ipc, module.execute)
 }
 
 main()

package/src/parts/CleanImportError/CleanImportError.js

@@ -0,0 +1,20 @@
+import * as GetModulesErrorStack from '../GetModulesErrorStack/GetModulesErrorStack.js'
+import * as JoinLines from '../JoinLines/JoinLines.js'
+import * as SplitLines from '../SplitLines/SplitLines.js'
+
+const cleanImportSyntaxError = (error) => {
+  const cleanStackLines = GetModulesErrorStack.getModulesErrorStack(error.stack)
+  const cleanError = new SyntaxError(error.message)
+  const currentStack = JoinLines.joinLines(SplitLines.splitLines(new Error().stack).slice(3))
+  const cleanStack = JoinLines.joinLines(cleanStackLines)
+  const mergedStack = cleanStack + '\n' + currentStack
+  cleanError.stack = mergedStack
+  return cleanError
+}
+
+export const cleanImportError = (error) => {
+  if (error && error instanceof SyntaxError) {
+    return cleanImportSyntaxError(error)
+  }
+  return error
+}

package/src/parts/GetErrorResponse/GetErrorResponse.js

@@ -0,0 +1,33 @@
+import * as JsonRpcErrorCode from '../JsonRpcErrorCode/JsonRpcErrorCode.js'
+import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
+import * as PrettyError from '../PrettyError/PrettyError.js'
+import * as PrintPrettyError from '../PrintPrettyError/PrintPrettyError.js'
+
+export const getErrorResponse = (message, error) => {
+  if (error && error instanceof Error && error.message && error.message.startsWith('method not found')) {
+    return {
+      jsonrpc: JsonRpcVersion.Two,
+      id: message.id,
+      error: {
+        code: JsonRpcErrorCode.MethodNotFound,
+        message: error.message,
+        data: error.stack,
+      },
+    }
+  }
+  const prettyError = PrettyError.prepare(error)
+  PrintPrettyError.printPrettyError(prettyError, `[extension-host-helper-process] `)
+  return {
+    jsonrpc: JsonRpcVersion.Two,
+    id: message.id,
+    error: {
+      code: JsonRpcErrorCode.Custom,
+      message: prettyError.message,
+      data: {
+        stack: prettyError.stack,
+        codeFrame: prettyError.codeFrame,
+        type: prettyError.type,
+      },
+    },
+  }
+}

package/src/parts/GetModulesErrorStack/GetModulesErrorStack.js

@@ -0,0 +1,49 @@
+import * as SplitLines from '../SplitLines/SplitLines.js'
+
+const RE_AT = /^    at /
+const RE_JUST_PATH = /^(?:\/|\\).*\:\d+$/
+
+const isStackLine = (line) => {
+  return RE_AT.test(line)
+}
+
+const isJustPath = (line) => {
+  return RE_JUST_PATH.test(line)
+}
+
+export const getModulesErrorStack = (stderr) => {
+  const lines = SplitLines.splitLines(stderr)
+  let startIndex = -1
+  const extraLines = []
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+    if (isJustPath(line)) {
+      extraLines.push(`    at ${line}`)
+      break
+    }
+  }
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+    if (isStackLine(line)) {
+      startIndex = i
+      break
+    }
+  }
+  if (startIndex === -1) {
+    return []
+  }
+  let endIndex = -1
+  for (let i = startIndex + 1; i < lines.length; i++) {
+    const line = lines[i]
+    if (!isStackLine(line)) {
+      endIndex = i
+      break
+    }
+  }
+  if (endIndex === -1) {
+    endIndex = lines.length - 1
+  }
+  const stackLines = lines.slice(startIndex, endIndex)
+  const stack = [lines[startIndex - 1], ...extraLines, ...stackLines]
+  return stack
+}

package/src/parts/GetNewLineIndex/GetNewLineIndex.js

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param {string} string
+ * @param {number|undefined} startIndex
+ * @returns
+ */
+export const getNewLineIndex = (string, startIndex = undefined) => {
+  return string.indexOf('\n', startIndex)
+}

package/src/parts/GetResponse/GetResponse.js

@@ -1,40 +1,11 @@
-import * as Command from '../Command/Command.js'
-import * as JsonRpc from '../JsonRpc/JsonRpc.js'
-import * as PrettyError from '../PrettyError/PrettyError.js'
+import * as GetErrorResponse from '../GetErrorResponse/GetErrorResponse.js'
+import * as GetSuccessResponse from '../GetSuccessResponse/GetSuccessResponse.js'
 
-export const getResponse = async (message) => {
+export const getResponse = async (message, execute) => {
   try {
-    const result = await Command.invoke(message.method, ...message.params)
-    return {
-      jsonrpc: JsonRpc.Version,
-      id: message.id,
-      result,
-    }
+    const result = await execute(message.method, ...message.params)
+    return GetSuccessResponse.getSuccessResponse(message, result)
   } catch (error) {
-    if (error && error instanceof Error && error.message && error.message.startsWith('method not found')) {
-      return {
-        jsonrpc: JsonRpc.Version,
-        id: message.id,
-        error: {
-          code: JsonRpc.ErrorMethodNotFound,
-          message: error.message,
-          data: error.stack,
-        },
-      }
-    }
-    const prettyError = PrettyError.prepare(error)
-    return {
-      jsonrpc: JsonRpc.Version,
-      id: message.id,
-      error: {
-        code: -32001,
-        message: prettyError.message,
-        data: {
-          stack: prettyError.stack,
-          codeFrame: prettyError.codeFrame,
-          code: prettyError.code,
-        },
-      },
-    }
+    return GetErrorResponse.getErrorResponse(message, error)
   }
 }

package/src/parts/GetSuccessResponse/GetSuccessResponse.js

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

package/src/parts/ImportScript/ImportScript.js

@@ -0,0 +1,12 @@
+import { VError } from '../VError/VError.js'
+import * as CleanImportError from '../CleanImportError/CleanImportError.js'
+
+export const importScript = async (path) => {
+  try {
+    const module = await import(path)
+    return module
+  } catch (error) {
+    const cleanError = CleanImportError.cleanImportError(error)
+    throw new VError(cleanError, `Failed to load ${path}`)
+  }
+}

package/src/parts/IpcChild/IpcChild.js

@@ -1,21 +1,8 @@
-import * as IpcChildType from '../IpcChildType/IpcChildType.js'
-
-const getModule = (method) => {
-  switch (method) {
-    case IpcChildType.MessagePort:
-      return import('./IpcChildWithMessagePort.js')
-    case IpcChildType.WebSocket:
-      return import('./IpcChildWithWebSocket.js')
-    case IpcChildType.Parent:
-      return import('./IpcChildWithParent.js')
-    case IpcChildType.ElectronMessagePort:
-      return import('./IpcChildWithElectronMessagePort.js')
-    default:
-      throw new Error('unexpected ipc type')
-  }
-}
+import * as IpcChildModule from '../IpcChildModule/IpcChildModule.js'
 
 export const listen = async ({ method }) => {
-  const module = await getModule(method)
-  return module.listen()
+  const module = await IpcChildModule.getModule(method)
+  const rawIpc = await module.listen()
+  const ipc = module.wrap(rawIpc)
+  return ipc
 }

package/src/parts/IpcChildModule/IpcChildModule.js

@@ -0,0 +1,20 @@
+import * as IpcChildType from '../IpcChildType/IpcChildType.js'
+
+export const getModule = (method) => {
+  switch (method) {
+    case IpcChildType.MessagePort:
+      return import('../IpcChildWithMessagePort/IpcChildWithMessagePort.js')
+    case IpcChildType.WebSocket:
+      return import('../IpcChildWithWebSocket/IpcChildWithWebSocket.js')
+    case IpcChildType.Parent:
+      return import('../IpcChildWithParent/IpcChildWithParent.js')
+    case IpcChildType.ElectronMessagePort:
+      return import('../IpcChildWithElectronMessagePort/IpcChildWithElectronMessagePort.js')
+    case IpcChildType.ElectronUtilityProcess:
+      return import('../IpcChildWithElectronUtilityProcess/IpcChildWithElectronUtilityProcess.js')
+    case IpcChildType.ElectronUtilityProcessMessagePort:
+      return import('../IpcChildWithElectronUtilityProcessMessagePort/IpcChildWithElectronUtilityProcessMessagePort.js')
+    default:
+      throw new Error('unexpected ipc type')
+  }
+}

package/src/parts/IpcChildType/IpcChildType.js

@@ -1,21 +1,35 @@
+import * as ParseCliArgs from '../ParseCliArgs/ParseCliArgs.js'
+
 export const WebSocket = 1
 export const MessagePort = 2
 export const Parent = 3
 export const ElectronMessagePort = 4
+export const ElectronUtilityProcess = 5
+export const ElectronUtilityProcessMessagePort = 6
 
-export const Auto = () => {
+const getRawIpcType = () => {
   const { argv } = process
-  if (argv.includes('--ipc-type=websocket')) {
-    return WebSocket
-  }
-  if (argv.includes('--ipc-type=message-port')) {
-    return MessagePort
-  }
-  if (argv.includes('--ipc-type=parent')) {
-    return Parent
-  }
-  if (argv.includes('--ipc-type=electron-message-port')) {
-    return ElectronMessagePort
+  const parsedArgs = ParseCliArgs.parseCliArgs(argv.slice(2))
+  const ipcType = parsedArgs['ipc-type']
+  return ipcType
+}
+
+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
+    default:
+      throw new Error(`[extension-host-helper-process] unknown ipc type ${ipcType}`)
   }
-  throw new Error('[extension-host-helper-process] unknown ipc type')
 }

package/src/parts/{IpcChild → IpcChildWithElectronMessagePort}/IpcChildWithElectronMessagePort.js

@@ -2,10 +2,14 @@ import { once } from 'events'
 
 export const listen = async () => {
   // const [message, handle] = await once(process, 'message')
-  // console.log({ message, handle })
   // if (process.send) {
   //   process.send('ready')
   // }
   // return {
   // }
 }
+
+export const wrap = () => {
+  // TODO
+  return {}
+}

package/src/parts/IpcChildWithElectronUtilityProcess/IpcChildWithElectronUtilityProcess.js

@@ -0,0 +1,27 @@
+export const listen = () => {
+  // @ts-ignore
+  const parentPort = process.parentPort
+  if (!parentPort) {
+    throw new Error('parent port must be defined')
+  }
+  parentPort.postMessage('ready')
+  return parentPort
+}
+
+export const wrap = (parentPort) => {
+  return {
+    parentPort,
+    on(event, listener) {
+      this.parentPort.on(event, listener)
+    },
+    off(event, listener) {
+      this.parentPort.off(event, listener)
+    },
+    send(message) {
+      this.parentPort.postMessage(message)
+    },
+    dispose() {
+      this.parentPort.close()
+    },
+  }
+}

package/src/parts/IpcChildWithElectronUtilityProcessMessagePort/IpcChildWithElectronUtilityProcessMessagePort.js

@@ -0,0 +1,63 @@
+import * as IpcChildWithElectronUtilityProcess from '../IpcChildWithElectronUtilityProcess/IpcChildWithElectronUtilityProcess.js'
+import * as IpcChildType from '../IpcChildType/IpcChildType.js'
+
+const waitForFirstMessage = async (parentPort) => {
+  const { type, event } = await new Promise((resolve) => {
+    const cleanup = (value) => {
+      parentPort.off('message', handleMessage)
+      resolve(value)
+    }
+    const handleMessage = (event) => {
+      cleanup({ type: 'message', event })
+    }
+    parentPort.on('message', handleMessage)
+  })
+  return {
+    type,
+    event,
+  }
+}
+
+export const listen = async () => {
+  const parentPort = IpcChildWithElectronUtilityProcess.listen()
+  const { type, event } = await waitForFirstMessage(parentPort)
+  if (type !== 'message') {
+    throw new Error('expected message event')
+  }
+  const { ports } = event
+  if (ports.length === 0) {
+    throw new Error(`expected message port to be passed`)
+  }
+  const port = ports[0]
+  port.start()
+  return port
+}
+
+export const wrap = (port) => {
+  return {
+    type: IpcChildType.ElectronUtilityProcessMessagePort,
+    port,
+    on(event, listener) {
+      switch (event) {
+        case 'message':
+          const wrappedListener = (event) => {
+            listener(event.data)
+          }
+          this.port.on(event, wrappedListener)
+          break
+        default:
+          this.port.on(event, listener)
+          break
+      }
+    },
+    off(event, listener) {
+      this.port.off(event, listener)
+    },
+    send(message) {
+      this.port.postMessage(message)
+    },
+    dispose() {
+      this.port.close()
+    },
+  }
+}

package/src/parts/{IpcChild → IpcChildWithMessagePort}/IpcChildWithMessagePort.js

@@ -2,3 +2,8 @@ export const listen = () => {
   // TODO wait for electron message port to be passed in
   return {}
 }
+
+export const wrap = () => {
+  // TODO
+  return {}
+}

package/src/parts/{CreateProcessIpc/CreateProcessIpc.js → IpcChildWithParent/IpcChildWithParent.js}

@@ -1,12 +1,17 @@
-export const createProcessIpc = (process) => {
+export const listen = () => {
+  return process
+}
+
+export const wrap = (process) => {
   return {
+    process,
     send(message) {
-      process.send(message)
+      this.process.send(message)
     },
     on(event, listener) {
       switch (event) {
         case 'message':
-          process.on('message', listener)
+          this.process.on('message', listener)
           break
         default:
           throw new Error('unknown event listener type')

package/src/parts/IpcChildWithWebSocket/IpcChildWithWebSocket.js

@@ -0,0 +1,45 @@
+import { once } from 'events'
+import * as GetWebSocket from '../GetWebSocket/GetWebSocket.js'
+import * as Json from '../Json/Json.js'
+
+export const listen = async () => {
+  const [message, handle] = await once(process, 'message')
+  const webSocket = await GetWebSocket.getWebSocket(message, handle)
+  return webSocket
+}
+
+export const wrap = (webSocket) => {
+  return {
+    webSocket,
+    /**
+     * @type {any}
+     */
+    wrappedListener: undefined,
+    send(message) {
+      const stringifiedMessage = Json.stringify(message)
+      this.webSocket.send(stringifiedMessage)
+    },
+    on(event, listener) {
+      switch (event) {
+        case 'message':
+          this.wrappedListener = (message) => {
+            const parsed = Json.parse(message.toString())
+            listener(parsed)
+          }
+          this.webSocket.on('message', this.wrappedListener)
+          break
+        default:
+          throw new Error('unknown event listener type')
+      }
+    },
+    off(event, listener) {
+      switch (event) {
+        case 'message':
+          this.webSocket.off('message', this.wrappedListener)
+          break
+        default:
+          throw new Error('unknown event listener type')
+      }
+    },
+  }
+}

package/src/parts/JoinLines/JoinLines.js

@@ -0,0 +1,3 @@
+export const joinLines = (lines) => {
+  return lines.join('\n')
+}

package/src/parts/JsonRpc/JsonRpc.js

@@ -1,3 +1 @@
-export const Version = '2.0'
-
 export const ErrorMethodNotFound = -32601

package/src/parts/JsonRpcErrorCode/JsonRpcErrorCode.js

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

package/src/parts/JsonRpcVersion/JsonRpcVersion.js

@@ -0,0 +1 @@
+export const Two = '2.0'

package/src/parts/Logger/Logger.js

@@ -0,0 +1,50 @@
+import { Console } from 'node:console'
+import { createWriteStream } from 'node:fs'
+import { tmpdir } from 'node:os'
+
+// TODO mock this module when used in unit tests
+
+const state = {
+  /**
+   * @type {Console|undefined}
+   */
+  console: undefined,
+}
+
+const createConsole = () => {
+  const logFile = `${tmpdir()}/log-extension-host-helper-process.txt`
+  const writeStream = createWriteStream(logFile)
+  const logger = new Console(writeStream)
+  return logger
+}
+
+const getOrCreateLogger = () => {
+  if (!state.console) {
+    state.console = createConsole()
+  }
+  return state.console
+}
+
+export const log = (...args) => {
+  const logger = getOrCreateLogger()
+  logger.log(...args)
+  console.log(...args)
+}
+
+export const info = (...args) => {
+  const logger = getOrCreateLogger()
+  logger.info(...args)
+  console.info(...args)
+}
+
+export const warn = (...args) => {
+  const logger = getOrCreateLogger()
+  logger.warn(...args)
+  console.warn(...args)
+}
+
+export const error = (...args) => {
+  const logger = getOrCreateLogger()
+  logger.error(...args)
+  console.error(...args)
+}

package/src/parts/MergeStacks/MergeStacks.js

@@ -0,0 +1,20 @@
+import * as GetNewLineIndex from '../GetNewLineIndex/GetNewLineIndex.js'
+import * as NormalizeErrorLine from '../NormalizeErrorLine/NormalizeErrorLine.js'
+
+export const mergeStacks = (parent, child) => {
+  if (!child) {
+    return parent
+  }
+  const parentNewLineIndex = GetNewLineIndex.getNewLineIndex(parent)
+  const childNewLineIndex = GetNewLineIndex.getNewLineIndex(child)
+  if (childNewLineIndex === -1) {
+    return parent
+  }
+  const parentFirstLine = parent.slice(0, parentNewLineIndex)
+  const childRest = child.slice(childNewLineIndex)
+  const childFirstLine = NormalizeErrorLine.normalizeLine(child.slice(0, childNewLineIndex))
+  if (parentFirstLine.includes(childFirstLine)) {
+    return parentFirstLine + childRest
+  }
+  return child
+}

package/src/parts/NormalizeErrorLine/NormalizeErrorLine.js

@@ -0,0 +1,9 @@
+export const normalizeLine = (line) => {
+  if (line.startsWith('Error: ')) {
+    return line.slice(`Error: `.length)
+  }
+  if (line.startsWith('VError: ')) {
+    return line.slice(`VError: `.length)
+  }
+  return line
+}

package/src/parts/ParseCliArgs/ParseCliArgs.js

@@ -0,0 +1,7 @@
+import minimist from 'minimist'
+
+export const parseCliArgs = (args) => {
+  const CLI_OPTIONS = {}
+  const parsedArgs = minimist(args, CLI_OPTIONS)
+  return parsedArgs
+}

package/src/parts/PrettyError/PrettyError.js

@@ -50,5 +50,6 @@ export const prepare = (error) => {
     stack: relevantStack,
     codeFrame,
     code: error.code,
+    type: error.constructor.name,
   }
 }

package/src/parts/PrintPrettyError/PrintPrettyError.js

@@ -0,0 +1,5 @@
+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`)
+}

package/src/parts/Rpc/Rpc.js

@@ -1,14 +1,13 @@
 import * as GetResponse from '../GetResponse/GetResponse.js'
 
-export const listen = (ipc) => {
+export const listen = (ipc, execute) => {
   const handleMessage = async (message) => {
     if ('method' in message) {
-      const response = await GetResponse.getResponse(message)
+      const response = await GetResponse.getResponse(message, execute)
       ipc.send(response)
+    } else {
+      console.log({ message })
     }
   }
   ipc.on('message', handleMessage)
-  if (process.send) {
-    process.send('ready')
-  }
 }

package/src/parts/SplitLines/SplitLines.js

@@ -1,3 +1,11 @@
+/**
+ *
+ * @param {string|undefined} lines
+ * @returns string[]
+ */
 export const splitLines = (lines) => {
+  if (!lines) {
+    return []
+  }
   return lines.split('\n')
 }

package/src/parts/VError/VError.js

@@ -0,0 +1,27 @@
+import * as MergeStacks from '../MergeStacks/MergeStacks.js'
+import * as NormalizeErrorLine from '../NormalizeErrorLine/NormalizeErrorLine.js'
+
+const getCombinedMessage = (error, message) => {
+  const stringifiedError = NormalizeErrorLine.normalizeLine(`${error}`)
+  if (message) {
+    return `${message}: ${stringifiedError}`
+  }
+  return stringifiedError
+}
+
+export class VError extends Error {
+  constructor(error, message) {
+    const combinedMessage = getCombinedMessage(error, message)
+    super(combinedMessage)
+    this.name = 'VError'
+    if (error instanceof Error) {
+      this.stack = MergeStacks.mergeStacks(this.stack, error.stack)
+    }
+    if (error.codeFrame) {
+      this.codeFrame = error.codeFrame
+    }
+    if (error.code) {
+      this.code = error.code
+    }
+  }
+}

package/src/parts/CreateWebSocketIpc/CreateWebSocketIpc.js

@@ -1,23 +0,0 @@
-import * as Json from '../Json/Json.js'
-
-export const createWebSocketIpc = (webSocket) => {
-  return {
-    send(message) {
-      const stringifiedMessage = Json.stringify(message)
-      webSocket.send(stringifiedMessage)
-    },
-    on(event, listener) {
-      switch (event) {
-        case 'message':
-          const wrappedListener = (message) => {
-            const parsed = Json.parse(message.toString())
-            listener(parsed)
-          }
-          webSocket.on('message', wrappedListener)
-          break
-        default:
-          throw new Error('unknown event listener type')
-      }
-    },
-  }
-}

package/src/parts/IpcChild/IpcChildWithParent.js

@@ -1,5 +0,0 @@
-import * as CreateProcessIpc from '../CreateProcessIpc/CreateProcessIpc.js'
-
-export const listen = () => {
-  return CreateProcessIpc.createProcessIpc(process)
-}

package/src/parts/IpcChild/IpcChildWithWebSocket.js

@@ -1,10 +0,0 @@
-import { once } from 'events'
-import * as CreateWebSocketIpc from '../CreateWebSocketIpc/CreateWebSocketIpc.js'
-import * as GetWebSocket from '../GetWebSocket/GetWebSocket.js'
-
-export const listen = async () => {
-  const [message, handle] = await once(process, 'message')
-  const webSocket = await GetWebSocket.getWebSocket(message, handle)
-  const ipc = CreateWebSocketIpc.createWebSocketIpc(webSocket)
-  return ipc
-}