@lvce-editor/ipc 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Lvce Editor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,20 @@
+# Lvce Editor Ipc
+
+Inter Process Communiction for use in Lvce Editor.
+
+### Usage
+
+```js
+import { IpcParent, IpcParentType } from '@lvce-editor/ipc'
+
+const ipc = await IpcParent.create({
+  method: IpcParentType.NodeWorker,
+  path: '/test/worker.js',
+})
+
+ipc.send({
+  jsonrpc: '2.0',
+  method: 'readFile',
+  params: ['/test/file.txt'],
+})
+```

package/dist/index.js

@@ -0,0 +1,4 @@
+export * as IpcChild from './parts/IpcChild/IpcChild.js'
+export * as IpcChildType from './parts/IpcChildType/IpcChildType.js'
+export * as IpcParent from './parts/IpcParent/IpcParent.js'
+export * as IpcParentType from './parts/IpcParentType/IpcParentType.js'

package/dist/parts/Assert/Assert.js

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

package/dist/parts/CamelCase/CamelCase.js

@@ -0,0 +1,11 @@
+import * as Character from '../Character/Character.js'
+
+const firstLetterLowerCase = (string) => {
+  return string[0].toLowerCase() + string.slice(1)
+}
+
+export const camelCase = (string) => {
+  const parts = string.split(Character.Space)
+  const lowerParts = parts.map(firstLetterLowerCase)
+  return lowerParts.join(Character.Dash)
+}

package/dist/parts/Character/Character.js

@@ -0,0 +1,12 @@
+export const Backslash = '\\'
+export const Dash = '-'
+export const Dot = '.'
+export const EmptyString = ''
+export const NewLine = '\n'
+export const OpenAngleBracket = '<'
+export const Slash = '/'
+export const Space = ' '
+export const Tab = '\t'
+export const Underline = '_'
+export const T = 't'
+export const SemiColon = ';'

package/dist/parts/ErrorCodes/ErrorCodes.js

@@ -0,0 +1,22 @@
+export const E_COLOR_THEME_NOT_FOUND = 'E_COLOR_THEME_NOT_FOUND'
+export const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND'
+export const E_ICON_THEME_NOT_FOUND = 'E_ICON_THEME_NOT_FOUND'
+export const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE'
+export const E_MANIFEST_NOT_FOUND = 'E_MANIFEST_NOT_FOUND'
+export const E_MODULES_NOT_SUPPORTED_IN_ELECTRON = 'E_MODULES_NOT_SUPPORTED_IN_ELECTRON'
+export const E_JSON_PARSE = 'E_JSON_PARSE'
+export const EACCES = 'EACCES'
+export const ECONNRESET = 'ECONNRESET'
+export const EEXIST = 'EEXIST'
+export const EISDIR = 'EISDIR'
+export const ELOOP = 'ELOOP'
+export const ENOENT = 'ENOENT'
+export const ENOTDIR = 'ENOTDIR'
+export const EPERM = 'EPERM'
+export const EPIPE = 'EPIPE'
+export const ERR_IPC_CHANNEL_CLOSED = 'ERR_IPC_CHANNEL_CLOSED'
+export const ERR_MODULE_NOT_FOUND = 'ERR_MODULE_NOT_FOUND'
+export const EXDEV = 'EXDEV'
+export const ERR_DLOPEN_FAILED = 'ERR_DLOPEN_FAILED'
+export const ESRCH = 'ESRCH'
+export const E_RIP_GREP_NOT_FOUND = 'E_RIP_GREP_NOT_FOUND'

package/dist/parts/FirstNodeWorkerEventType/FirstNodeWorkerEventType.js

@@ -0,0 +1,3 @@
+export const Exit = 1
+export const Error = 2
+export const Message = 3

package/dist/parts/FirstWebSocketEventType/FirstWebSocketEventType.js

@@ -0,0 +1,2 @@
+export const Open = 1
+export const Close = 2

package/dist/parts/FormatUtilityProcessName/FormatUtilityProcessName.js

@@ -0,0 +1,5 @@
+import * as CamelCase from '../CamelCase/CamelCase.js'
+
+export const formatUtilityProcessName = (name) => {
+  return CamelCase.camelCase(name)
+}

package/dist/parts/GetFirstEvent/GetFirstEvent.js

@@ -0,0 +1,23 @@
+import * as Promises from '../Promises/Promises.js'
+
+export const getFirstEvent = (eventEmitter, eventMap) => {
+  const { resolve, promise } = Promises.withResolvers()
+  const listenerMap = Object.create(null)
+  const cleanup = (value) => {
+    for (const event of Object.keys(eventMap)) {
+      eventEmitter.off(event, listenerMap[event])
+    }
+    resolve(value)
+  }
+  for (const [event, type] of Object.entries(eventMap)) {
+    const listener = (event) => {
+      cleanup({
+        type,
+        event,
+      })
+    }
+    eventEmitter.on(event, listener)
+    listenerMap[event] = listener
+  }
+  return promise
+}

package/dist/parts/GetFirstNodeChildProcessEvent/GetFirstNodeChildProcessEvent.js

@@ -0,0 +1,41 @@
+import * as FirstNodeWorkerEventType from '../FirstNodeWorkerEventType/FirstNodeWorkerEventType.js'
+
+export const getFirstNodeChildProcessEvent = async (childProcess) => {
+  const { type, event, stdout, stderr } = await new Promise((resolve, reject) => {
+    let stderr = ''
+    let stdout = ''
+    const cleanup = (value) => {
+      if (childProcess.stdout && childProcess.stderr) {
+        childProcess.stderr.off('data', handleStdErrData)
+        childProcess.stdout.off('data', handleStdoutData)
+      }
+      childProcess.off('message', handleMessage)
+      childProcess.off('exit', handleExit)
+      childProcess.off('error', handleError)
+      resolve(value)
+    }
+    const handleStdErrData = (data) => {
+      stderr += data
+    }
+    const handleStdoutData = (data) => {
+      stdout += data
+    }
+    const handleMessage = (event) => {
+      cleanup({ type: FirstNodeWorkerEventType.Message, event, stdout, stderr })
+    }
+    const handleExit = (event) => {
+      cleanup({ type: FirstNodeWorkerEventType.Exit, event, stdout, stderr })
+    }
+    const handleError = (event) => {
+      cleanup({ type: FirstNodeWorkerEventType.Error, event, stdout, stderr })
+    }
+    if (childProcess.stdout && childProcess.stderr) {
+      childProcess.stderr.on('data', handleStdErrData)
+      childProcess.stdout.on('data', handleStdoutData)
+    }
+    childProcess.on('message', handleMessage)
+    childProcess.on('exit', handleExit)
+    childProcess.on('error', handleError)
+  })
+  return { type, event, stdout, stderr }
+}

package/dist/parts/GetFirstNodeWorkerEvent/GetFirstNodeWorkerEvent.js

@@ -0,0 +1,9 @@
+import * as FirstNodeWorkerEventType from '../FirstNodeWorkerEventType/FirstNodeWorkerEventType.js'
+import * as GetFirstEvent from '../GetFirstEvent/GetFirstEvent.js'
+
+export const getFirstNodeWorkerEvent = (worker) => {
+  return GetFirstEvent.getFirstEvent(worker, {
+    exit: FirstNodeWorkerEventType.Exit,
+    error: FirstNodeWorkerEventType.Error,
+  })
+}

package/dist/parts/GetFirstUtilityProcessEvent/GetFirstUtilityProcessEvent.js

@@ -0,0 +1,42 @@
+import * as FirstNodeWorkerEventType from '../FirstNodeWorkerEventType/FirstNodeWorkerEventType.js'
+import * as Promises from '../Promises/Promises.js'
+
+/**
+ *
+ * @param {import('electron').UtilityProcess} utilityProcess
+ * @returns
+ */
+export const getFirstUtilityProcessEvent = async (utilityProcess) => {
+  const { resolve, promise } = Promises.withResolvers()
+  let stdout = ''
+  let stderr = ''
+  const cleanup = (value) => {
+    // @ts-ignore
+    utilityProcess.stderr.off('data', handleStdErrData)
+    // @ts-ignore
+    utilityProcess.stdout.off('data', handleStdoutData)
+    utilityProcess.off('message', handleMessage)
+    utilityProcess.off('exit', handleExit)
+    resolve(value)
+  }
+  const handleStdErrData = (data) => {
+    stderr += data
+  }
+  const handleStdoutData = (data) => {
+    stdout += data
+  }
+  const handleMessage = (event) => {
+    cleanup({ type: FirstNodeWorkerEventType.Message, event, stdout, stderr })
+  }
+  const handleExit = (event) => {
+    cleanup({ type: FirstNodeWorkerEventType.Exit, event, stdout, stderr })
+  }
+  // @ts-ignore
+  utilityProcess.stderr.on('data', handleStdErrData)
+  // @ts-ignore
+  utilityProcess.stdout.on('data', handleStdoutData)
+  utilityProcess.on('message', handleMessage)
+  utilityProcess.on('exit', handleExit)
+  const { type, event } = await promise
+  return { type, event, stdout, stderr }
+}

package/dist/parts/GetFirstWebSocketEvent/GetFirstWebSocketEvent.js

@@ -0,0 +1,25 @@
+import * as FirstWebSocketEventType from '../FirstWebSocketEventType/FirstWebSocketEventType.js'
+import * as GetFirstEvent from '../GetFirstEvent/GetFirstEvent.js'
+import * as WebSocketReadyState from '../WebSocketReadyState/WebSocketReadyState.js'
+
+export const getFirstWebSocketEvent = async (webSocket) => {
+  switch (webSocket.readyState) {
+    case WebSocketReadyState.Open:
+      return {
+        type: FirstWebSocketEventType.Open,
+        event: undefined,
+      }
+    case WebSocketReadyState.Closed:
+      return {
+        type: FirstWebSocketEventType.Close,
+        event: undefined,
+      }
+    default:
+      break
+  }
+  const { type, event } = await GetFirstEvent.getFirstEvent(webSocket, {
+    open: FirstWebSocketEventType.Open,
+    close: FirstWebSocketEventType.Close,
+  })
+  return { type, event }
+}

package/dist/parts/GetHelpfulChildProcessError/GetHelpfulChildProcessError.js

@@ -0,0 +1,119 @@
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+import * as SplitLines from '../SplitLines/SplitLines.js'
+import * as JoinLines from '../JoinLines/JoinLines.js'
+
+const RE_NATIVE_MODULE_ERROR = /^innerError Error: Cannot find module '.*.node'/
+const RE_NATIVE_MODULE_ERROR_2 = /was compiled against a different Node.js version/
+
+const RE_MESSAGE_CODE_BLOCK_START = /^Error: The module '.*'$/
+const RE_MESSAGE_CODE_BLOCK_END = /^\s* at/
+
+const RE_AT = /^\s+at/
+const RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/
+
+const isUnhelpfulNativeModuleError = (stderr) => {
+  return RE_NATIVE_MODULE_ERROR.test(stderr) && RE_NATIVE_MODULE_ERROR_2.test(stderr)
+}
+
+const isMessageCodeBlockStartIndex = (line) => {
+  return RE_MESSAGE_CODE_BLOCK_START.test(line)
+}
+
+const isMessageCodeBlockEndIndex = (line) => {
+  return RE_MESSAGE_CODE_BLOCK_END.test(line)
+}
+
+const getMessageCodeBlock = (stderr) => {
+  const lines = SplitLines.splitLines(stderr)
+  const startIndex = lines.findIndex(isMessageCodeBlockStartIndex)
+  const endIndex = startIndex + lines.slice(startIndex).findIndex(isMessageCodeBlockEndIndex, startIndex)
+  const relevantLines = lines.slice(startIndex, endIndex)
+  const relevantMessage = relevantLines.join(' ').slice('Error: '.length)
+  return relevantMessage
+}
+
+const getNativeModuleErrorMessage = (stderr) => {
+  const message = getMessageCodeBlock(stderr)
+  return {
+    message: `Incompatible native node module: ${message}`,
+    code: ErrorCodes.E_INCOMPATIBLE_NATIVE_MODULE,
+  }
+}
+
+const isModulesSyntaxError = (stderr) => {
+  if (!stderr) {
+    return false
+  }
+  return stderr.includes('SyntaxError: Cannot use import statement outside a module')
+}
+
+const getModuleSyntaxError = (stderr) => {
+  return {
+    message: `ES Modules are not supported in electron`,
+    code: ErrorCodes.E_MODULES_NOT_SUPPORTED_IN_ELECTRON,
+  }
+}
+
+const isModuleNotFoundError = (stderr) => {
+  if (!stderr) {
+    return false
+  }
+  return stderr.includes('ERR_MODULE_NOT_FOUND')
+}
+
+const isModuleNotFoundMessage = (line) => {
+  return line.includes('ERR_MODULE_NOT_FOUND')
+}
+
+const getModuleNotFoundError = (stderr) => {
+  const lines = SplitLines.splitLines(stderr)
+  const messageIndex = lines.findIndex(isModuleNotFoundMessage)
+  const message = lines[messageIndex]
+  return {
+    message,
+    code: ErrorCodes.ERR_MODULE_NOT_FOUND,
+  }
+}
+
+const isNormalStackLine = (line) => {
+  return RE_AT.test(line) && !RE_AT_PROMISE_INDEX.test(line)
+}
+
+const getDetails = (lines) => {
+  const index = lines.findIndex(isNormalStackLine)
+  if (index === -1) {
+    return {
+      actualMessage: JoinLines.joinLines(lines),
+      rest: [],
+    }
+  }
+  let lastIndex = index - 1
+  while (++lastIndex < lines.length) {
+    if (!isNormalStackLine(lines[lastIndex])) {
+      break
+    }
+  }
+  return {
+    actualMessage: lines[index - 1],
+    rest: lines.slice(index, lastIndex),
+  }
+}
+
+export const getHelpfulChildProcessError = (stdout, stderr) => {
+  if (isUnhelpfulNativeModuleError(stderr)) {
+    return getNativeModuleErrorMessage(stderr)
+  }
+  if (isModulesSyntaxError(stderr)) {
+    return getModuleSyntaxError(stderr)
+  }
+  if (isModuleNotFoundError(stderr)) {
+    return getModuleNotFoundError(stderr)
+  }
+  const lines = SplitLines.splitLines(stderr)
+  const { actualMessage, rest } = getDetails(lines)
+  return {
+    message: `${actualMessage}`,
+    code: '',
+    stack: rest,
+  }
+}

package/dist/parts/IpcChild/IpcChild.js

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

package/dist/parts/IpcChildModule/IpcChildModule.js

@@ -0,0 +1,10 @@
+import * as IpcChildType from '../IpcChildType/IpcChildType.js'
+
+export const getModule = (method) => {
+  switch (method) {
+    case IpcChildType.ElectronMessagePort:
+      return import('../IpcChildWithElectronMessagePort/IpcChildWithElectronMessagePort.js')
+    default:
+      throw new Error('unexpected ipc type')
+  }
+}

package/dist/parts/IpcChildType/IpcChildType.js

@@ -0,0 +1,5 @@
+export const NodeWorker = 1
+export const NodeForkedProcess = 2
+export const WebSocket = 3
+export const ElectronUtilityProcess = 4
+export const ElectronMessagePort = 5

package/dist/parts/IpcChildWithElectronMessagePort/IpcChildWithElectronMessagePort.js

@@ -0,0 +1,51 @@
+import { IpcError } from '../IpcError/IpcError.js'
+import * as IsMessagePortMain from '../IsMessagePortMain/IsMessagePortMain.js'
+
+export const listen = ({ messagePort }) => {
+  if (!IsMessagePortMain.isMessagePortMain(messagePort)) {
+    throw new IpcError('port must be of type MessagePortMain')
+  }
+  return messagePort
+}
+
+const getActualData = (event) => {
+  const { data, ports } = event
+  if (ports.length === 0) {
+    return data
+  }
+  return {
+    ...data,
+    params: [...ports, ...data.params],
+  }
+}
+
+export const wrap = (messagePort) => {
+  return {
+    messagePort,
+    on(event, listener) {
+      if (event === 'message') {
+        const wrappedListener = (event) => {
+          const actualData = getActualData(event)
+          listener(actualData)
+        }
+        this.messagePort.on(event, wrappedListener)
+      } else if (event === 'close') {
+        this.messagePort.on('close', listener)
+      } else {
+        throw new Error('unsupported event type')
+      }
+    },
+    off(event, listener) {
+      this.messagePort.off(event, listener)
+    },
+    send(message) {
+      this.messagePort.postMessage(message)
+    },
+    dispose() {
+      this.messagePort.close()
+    },
+    start() {
+      this.messagePort.start()
+    },
+  }
+}

package/dist/parts/IpcChildWithElectronUtilityProcess/IpcChildWithElectronUtilityProcess.js

@@ -0,0 +1,45 @@
+import * as GetUtilityProcessPortData from '../GetUtilityProcessPortData/GetUtilityProcessPortData.js'
+
+export const listen = () => {
+  // @ts-ignore
+  const { parentPort } = process
+  if (!parentPort) {
+    throw new Error('parent port must be defined')
+  }
+  return parentPort
+}
+
+export const signal = (parentPort) => {
+  parentPort.postMessage('ready')
+}
+
+export const wrap = (parentPort) => {
+  return {
+    parentPort,
+    on(event, listener) {
+      if (event === 'message') {
+        const wrappedListener = (event) => {
+          const actualData = GetUtilityProcessPortData.getUtilityProcessPortData(event)
+          listener(actualData)
+        }
+        this.parentPort.on(event, wrappedListener)
+      } else if (event === 'close') {
+        this.parentPort.on('close', listener)
+      } else {
+        throw new Error('unsupported event type')
+      }
+    },
+    off(event, listener) {
+      this.parentPort.off(event, listener)
+    },
+    send(message) {
+      this.parentPort.postMessage(message)
+    },
+    sendAndTransfer(message, transfer) {
+      this.parentPort.postMessage(message, transfer)
+    },
+    dispose() {
+      this.parentPort.close()
+    },
+  }
+}

package/dist/parts/IpcChildWithNodeForkedProcess/IpcChildWithNodeForkedProcess.js

@@ -0,0 +1,46 @@
+export const listen = async () => {
+  if (!process.send) {
+    throw new Error('process.send must be defined')
+  }
+  return process
+}
+
+export const signal = (process) => {
+  process.send('ready')
+}
+
+const getActualData = (message, handle) => {
+  if (handle) {
+    return {
+      ...message,
+      params: [...message.params, handle],
+    }
+  }
+  return message
+}
+
+export const wrap = (process) => {
+  return {
+    process,
+    on(event, listener) {
+      if (event === 'message') {
+        const wrappedListener = (event, handle) => {
+          const actualData = getActualData(event, handle)
+          listener(actualData)
+        }
+        this.process.on(event, wrappedListener)
+      } else if (event === 'close') {
+        this.process.on('close', listener)
+      } else {
+        throw new Error('unsupported event type')
+      }
+    },
+    off(event, listener) {
+      this.process.off(event, listener)
+    },
+    send(message) {
+      this.process.send(message)
+    },
+    dispose() {},
+  }
+}

package/dist/parts/IpcChildWithWebSocket/IpcChildWithWebSocket.js

@@ -0,0 +1,59 @@
+import * as GetFirstWebSocketEvent from '../GetFirstWebSocketEvent/GetFirstWebSocketEvent.js'
+import { IpcError } from '../IpcError/IpcError.js'
+import * as IsWebSocketOpen from '../IsWebSocketOpen/IsWebSocketOpen.js'
+import * as WebSocketSerialization from '../WebSocketSerialization/WebSocketSerialization.js'
+import * as WebSocketServer from '../WebSocketServer/WebSocketServer.js'
+
+export const listen = async ({ request, handle }) => {
+  if (!request) {
+    throw new IpcError('request must be defined')
+  }
+  if (!handle) {
+    throw new IpcError('handle must be defined')
+  }
+  const webSocket = await WebSocketServer.handleUpgrade(request, handle)
+  webSocket.pause()
+  if (!IsWebSocketOpen.isWebSocketOpen(webSocket)) {
+    const { type, event } = await GetFirstWebSocketEvent.getFirstWebSocketEvent(webSocket)
+  }
+  return webSocket
+}
+
+export const wrap = (webSocket) => {
+  return {
+    webSocket,
+    /**
+     * @type {any}
+     */
+    wrappedListener: undefined,
+    on(event, listener) {
+      switch (event) {
+        case 'message':
+          const wrappedListener = (message) => {
+            const data = WebSocketSerialization.deserialize(message)
+            listener(data)
+          }
+          webSocket.on('message', wrappedListener)
+          break
+        case 'close':
+          webSocket.on('close', listener)
+          break
+        default:
+          throw new Error('unknown event listener type')
+      }
+    },
+    off(event, listener) {
+      this.webSocket.off(event, listener)
+    },
+    send(message) {
+      const stringifiedMessage = WebSocketSerialization.serialize(message)
+      this.webSocket.send(stringifiedMessage)
+    },
+    dispose() {
+      this.webSocket.close()
+    },
+    start() {
+      this.webSocket.resume()
+    },
+  }
+}

package/dist/parts/IpcError/IpcError.js

@@ -0,0 +1,16 @@
+import * as GetHelpfulChildProcessError from '../GetHelpfulChildProcessError/GetHelpfulChildProcessError.js'
+import { VError } from '../VError/VError.js'
+
+export class IpcError extends VError {
+  constructor(message, stdout = '', stderr = '') {
+    if (stdout || stderr) {
+      const cause = GetHelpfulChildProcessError.getHelpfulChildProcessError(message, stdout, stderr)
+      super(cause, message)
+    } else {
+      super(message)
+    }
+    this.name = 'IpcError'
+    this.stdout = stdout
+    this.stderr = stderr
+  }
+}

package/dist/parts/IpcParent/IpcParent.js

@@ -0,0 +1,25 @@
+import * as IpcParentModule from '../IpcParentModule/IpcParentModule.js'
+
+/**
+ *
+ * @param {*} param0
+ * @returns {Promise<any>}
+ */
+export const create = async ({ method, ...options }) => {
+  const module = await IpcParentModule.getModule(method)
+  // @ts-ignore
+  const rawIpc = await module.create(options)
+  // @ts-ignore
+  if (module.effects) {
+    // @ts-ignore
+    module.effects({
+      rawIpc,
+      ...options,
+    })
+  }
+  if (options.noReturn) {
+    return undefined
+  }
+  const ipc = module.wrap(rawIpc)
+  return ipc
+}

package/dist/parts/IpcParentModule/IpcParentModule.js

@@ -0,0 +1,14 @@
+import * as IpcParentType from '../IpcParentType/IpcParentType.js'
+
+export const getModule = (method) => {
+  switch (method) {
+    case IpcParentType.NodeWorker:
+      return import('../IpcParentWithNodeWorker/IpcParentWithNodeWorker.js')
+    case IpcParentType.NodeForkedProcess:
+      return import('../IpcParentWithNodeForkedProcess/IpcParentWithNodeForkedProcess.js')
+    case IpcParentType.ElectronUtilityProcess:
+      return import('../IpcParentWithElectronUtilityProcess/IpcParentWithElectronUtilityProcess.js')
+    default:
+      throw new Error(`unexpected ipc type ${method}`)
+  }
+}

package/dist/parts/IpcParentType/IpcParentType.js

@@ -0,0 +1,3 @@
+export const NodeWorker = 1
+export const NodeForkedProcess = 2
+export const ElectronUtilityProcess = 3

package/dist/parts/IpcParentWithElectronUtilityProcess/IpcParentWithElectronUtilityProcess.js

@@ -0,0 +1,43 @@
+import { utilityProcess } from 'electron'
+import * as Assert from '../Assert/Assert.js'
+import * as FirstNodeWorkerEventType from '../FirstNodeWorkerEventType/FirstNodeWorkerEventType.js'
+import * as GetFirstUtilityProcessEvent from '../GetFirstUtilityProcessEvent/GetFirstUtilityProcessEvent.js'
+import { IpcError } from '../IpcError/IpcError.js'
+
+export const create = async ({ path, argv = [], execArgv = [], name }) => {
+  Assert.string(path)
+  const actualArgv = ['--ipc-type=electron-utility-process', ...argv]
+  const childProcess = utilityProcess.fork(path, actualArgv, {
+    execArgv,
+    stdio: 'pipe',
+    serviceName: name,
+  })
+  // @ts-ignore
+  childProcess.stdout.pipe(process.stdout)
+  const { type, event, stdout, stderr } = await GetFirstUtilityProcessEvent.getFirstUtilityProcessEvent(childProcess)
+  if (type === FirstNodeWorkerEventType.Exit) {
+    throw new IpcError(`Utility process exited before ipc connection was established`, stdout, stderr)
+  }
+  // @ts-ignore
+  childProcess.stderr.pipe(process.stderr)
+  return childProcess
+}
+
+export const wrap = (process) => {
+  return {
+    process,
+    on(event, listener) {
+      this.process.on(event, listener)
+    },
+    send(message) {
+      this.process.postMessage(message)
+    },
+    sendAndTransfer(message, transfer) {
+      Assert.array(transfer)
+      this.process.postMessage(message, transfer)
+    },
+    dispose() {
+      this.process.kill()
+    },
+  }
+}

package/dist/parts/IpcParentWithNodeForkedProcess/IpcParentWithNodeForkedProcess.js

@@ -0,0 +1,37 @@
+import { fork } from 'node:child_process'
+import * as Assert from '../Assert/Assert.js'
+
+/**
+ *
+ * @param {{path:string, argv?:string[], env?:any, execArgv?:string[], stdio?:'inherit'}} param0
+ * @returns
+ */
+export const create = async ({ path, argv = [], env = process.env, execArgv = [], stdio = 'inherit' }) => {
+  Assert.string(path)
+  const actualArgv = ['--ipc-type=node-forked-process', ...argv]
+  const childProcess = fork(path, actualArgv, {
+    env,
+    execArgv,
+    stdio,
+  })
+  return childProcess
+}
+
+export const wrap = (childProcess) => {
+  return {
+    childProcess,
+    on(event, listener) {
+      this.childProcess.on(event, listener)
+    },
+    send(message) {
+      this.childProcess.send(message)
+    },
+    sendAndTransfer(message, transfer) {
+      throw new Error('transfer is not supported')
+    },
+    dispose() {
+      this.childProcess.kill()
+    },
+    pid: childProcess.pid,
+  }
+}

package/dist/parts/IpcParentWithNodeWorker/IpcParentWithNodeWorker.js

@@ -0,0 +1,49 @@
+import { Worker } from 'node:worker_threads'
+import * as Assert from '../Assert/Assert.js'
+import * as FirstNodeWorkerEventType from '../FirstNodeWorkerEventType/FirstNodeWorkerEventType.js'
+import * as GetFirstNodeWorkerEvent from '../GetFirstNodeWorkerEvent/GetFirstNodeWorkerEvent.js'
+import { IpcError } from '../IpcError/IpcError.js'
+
+export const create = async ({ path, argv = [], env = process.env, execArgv = [] }) => {
+  Assert.string(path)
+  const actualArgv = ['--ipc-type=node-worker', ...argv]
+  const actualEnv = {
+    ...env,
+    ELECTRON_RUN_AS_NODE: '1',
+  }
+  const worker = new Worker(path, {
+    argv: actualArgv,
+    env: actualEnv,
+    execArgv,
+  })
+  const { type, event } = await GetFirstNodeWorkerEvent.getFirstNodeWorkerEvent(worker)
+  if (type === FirstNodeWorkerEventType.Exit) {
+    throw new IpcError(`Worker exited before ipc connection was established`)
+  }
+  if (type === FirstNodeWorkerEventType.Error) {
+    throw new IpcError(`Worker threw an error before ipc connection was established: ${event}`)
+  }
+  if (event !== 'ready') {
+    throw new IpcError('unexpected first message from worker')
+  }
+  return worker
+}
+
+export const wrap = (worker) => {
+  return {
+    worker,
+    on(event, listener) {
+      this.worker.on(event, listener)
+    },
+    send(message) {
+      this.worker.postMessage(message)
+    },
+    sendAndTransfer(message, transfer) {
+      Assert.array(transfer)
+      this.worker.postMessage(message, transfer)
+    },
+    dispose() {
+      this.worker.terminate()
+    },
+  }
+}

package/dist/parts/IsMessagePortMain/IsMessagePortMain.js

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

package/dist/parts/IsWebSocketOpen/IsWebSocketOpen.js

@@ -0,0 +1,5 @@
+import { WebSocket } from 'ws'
+
+export const isWebSocketOpen = (webSocket) => {
+  return webSocket.readyState === WebSocket.OPEN
+}

package/dist/parts/JoinLines/JoinLines.js

@@ -0,0 +1,5 @@
+import * as Character from '../Character/Character.js'
+
+export const joinLines = (lines) => {
+  return lines.join(Character.NewLine)
+}

package/dist/parts/Promises/Promises.js

@@ -0,0 +1,19 @@
+export const withResolvers = () => {
+  /**
+   * @type {any}
+   */
+  let _resolve
+  /**
+   * @type {any}
+   */
+  let _reject
+  const promise = new Promise((resolve, reject) => {
+    _resolve = resolve
+    _reject = reject
+  })
+  return {
+    resolve: _resolve,
+    reject: _reject,
+    promise,
+  }
+}

package/dist/parts/SplitLines/SplitLines.js

@@ -0,0 +1,5 @@
+import * as Character from '../Character/Character.js'
+
+export const splitLines = (lines) => {
+  return lines.split(Character.NewLine)
+}

package/dist/parts/VError/VError.js

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

package/dist/parts/WebSocketReadyState/WebSocketReadyState.js

@@ -0,0 +1,5 @@
+import { WebSocket } from 'ws'
+
+export const Open = WebSocket.OPEN
+
+export const Closed = WebSocket.CLOSED

package/dist/parts/WebSocketSerialization/WebSocketSerialization.js

@@ -0,0 +1,7 @@
+export const serialize = (message) => {
+  return JSON.stringify(message)
+}
+
+export const deserialize = (message) => {
+  return JSON.parse(message.toString())
+}

package/dist/parts/WebSocketServer/WebSocketServer.js

@@ -0,0 +1 @@
+export * from '@lvce-editor/web-socket-server'

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@lvce-editor/ipc",
+  "version": "1.0.0",
+  "description": "Inter Process Communication for Lvce Editor",
+  "main": "dist/index.js",
+  "type": "module",
+  "keywords": [
+    "ipc"
+  ],
+  "author": "Lvce Editor",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lvce-editor/ipc.git"
+  },
+  "dependencies": {
+    "@lvce-editor/assert": "^1.2.0",
+    "@lvce-editor/verror": "^1.1.2",
+    "@lvce-editor/web-socket-server": "^1.1.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}