@lvce-editor/ipc 2.0.0 → 3.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/ipc",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "description": "Inter Process Communication for Lvce Editor",
   "main": "dist/index.js",
   "type": "module",
@@ -15,7 +15,7 @@
   },
   "dependencies": {
     "@lvce-editor/assert": "^1.2.0",
-    "@lvce-editor/verror": "^1.1.2",
+    "@lvce-editor/verror": "^1.2.0",
     "@lvce-editor/web-socket-server": "^1.1.0"
   },
   "engines": {

package/dist/parts/Assert/Assert.js

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

package/dist/parts/CamelCase/CamelCase.js

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

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

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

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

package/dist/parts/FirstWebSocketEventType/FirstWebSocketEventType.js

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

package/dist/parts/FormatUtilityProcessName/FormatUtilityProcessName.js

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

package/dist/parts/GetFirstEvent/GetFirstEvent.js

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

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

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

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

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

@@ -1,119 +0,0 @@
-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/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/dist/parts/IpcChildWithElectronMessagePort/IpcChildWithElectronMessagePort.js

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

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

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

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

@@ -1,20 +0,0 @@
-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 { message, code, stack } = GetHelpfulChildProcessError.getHelpfulChildProcessError(stdout, stderr)
-      const cause = new Error(message)
-      // @ts-ignore
-      cause.code = code
-      cause.stack = stack
-      super(cause, message)
-    } else {
-      super(message)
-    }
-    this.name = 'IpcError'
-    this.stdout = stdout
-    this.stderr = stderr
-  }
-}

package/dist/parts/IpcParentWithElectronUtilityProcess/IpcParentWithElectronUtilityProcess.js

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

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