@lvce-editor/shared-process 0.22.7 → 0.23.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.22.7",
+  "version": "0.23.0",
   "main": "index.js",
   "type": "module",
   "keywords": [
@@ -18,11 +18,12 @@
   },
   "dependencies": {
     "@lvce-editor/assert": "^1.2.0",
-    "@lvce-editor/extension-host-helper-process": "0.22.7",
+    "@lvce-editor/extension-host-helper-process": "0.23.0",
+    "@lvce-editor/ipc": "^2.1.0",
     "@lvce-editor/json-rpc": "^1.0.0",
     "@lvce-editor/jsonc-parser": "^1.1.0",
     "@lvce-editor/pretty-error": "^1.4.1",
-    "@lvce-editor/pty-host": "0.22.7",
+    "@lvce-editor/pty-host": "0.23.0",
     "@lvce-editor/verror": "^1.1.2",
     "@lvce-editor/web-socket-server": "^1.1.0",
     "debug": "^4.3.4",

package/src/parts/IpcChildWithElectronUtilityProcess/IpcChildWithElectronUtilityProcess.js

@@ -1,45 +1 @@
-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()
-    },
-  }
-}
+export * from '@lvce-editor/ipc/dist/parts/IpcChildWithElectronUtilityProcess/IpcChildWithElectronUtilityProcess.js'

package/src/parts/IpcChildWithWebSocket/IpcChildWithWebSocket.js

@@ -1,59 +1 @@
-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()
-    },
-  }
-}
+export * from '@lvce-editor/ipc/dist/parts/IpcChildWithWebSocket/IpcChildWithWebSocket.js'

package/src/parts/IpcParentWithNodeForkedProcess/IpcParentWithNodeForkedProcess.js

@@ -1,53 +1 @@
-import { fork } from 'node:child_process'
-import * as Assert from '../Assert/Assert.js'
-import { ChildProcessError } from '../ChildProcessError/ChildProcessError.js'
-import * as FirstNodeWorkerEventType from '../FirstNodeWorkerEventType/FirstNodeWorkerEventType.js'
-import * as GetFirstNodeChildProcessEvent from '../GetFirstNodeChildProcessEvent/GetFirstNodeChildProcessEvent.js'
-import { VError } from '../VError/VError.js'
-
-export const create = async ({ path, argv = [], env, execArgv = [], stdio = 'inherit', name = 'child process' }) => {
-  try {
-    Assert.string(path)
-    const actualArgv = ['--ipc-type=node-forked-process', ...argv]
-    const childProcess = fork(path, actualArgv, {
-      env,
-      execArgv,
-      stdio: 'pipe',
-    })
-    const { type, event, stdout, stderr } = await GetFirstNodeChildProcessEvent.getFirstNodeChildProcessEvent(childProcess)
-    if (type === FirstNodeWorkerEventType.Exit) {
-      throw new ChildProcessError(stderr)
-    }
-    if (type === FirstNodeWorkerEventType.Error) {
-      throw new Error(`child process had an error ${event}`)
-    }
-    if (stdio === 'inherit' && childProcess.stdout && childProcess.stderr) {
-      childProcess.stdout.pipe(process.stdout)
-      childProcess.stderr.pipe(process.stderr)
-    }
-    return childProcess
-  } catch (error) {
-    throw new VError(error, `Failed to launch ${name}`)
-  }
-}
-
-export const wrap = (childProcess) => {
-  return {
-    childProcess,
-    on(event, listener) {
-      this.childProcess.on(event, listener)
-    },
-    off(event, listener) {
-      this.childProcess.off(event, listener)
-    },
-    send(message) {
-      this.childProcess.send(message)
-    },
-    sendAndTransfer(message, handle) {
-      this.childProcess.send(message, handle)
-    },
-    dispose() {
-      this.childProcess.kill()
-    },
-  }
-}
+export * from '@lvce-editor/ipc/dist/parts/IpcParentWithNodeForkedProcess/IpcParentWithNodeForkedProcess.js'

package/src/parts/Platform/Platform.js

@@ -61,11 +61,11 @@ export const getSetupName = () => {
   return 'Lvce-Setup'
 }
 
-export const version = '0.22.7'
+export const version = '0.23.0'
 
-export const commit = '5861e23'
+export const commit = 'c25a55a'
 
-export const date = '2024-01-28T15:06:28.000Z'
+export const date = '2024-02-01T19:16:57.000Z'
 
 export const getVersion = () => {
   return version

package/src/parts/AppWindowStates/AppWindowStates.js

@@ -1,62 +0,0 @@
-export const state = {
-  /**
-   * @type {any[]}
-   */
-  windowStates: [],
-}
-
-export const findByWindowId = (windowId) => {
-  const { windowStates } = state
-  for (const windowState of windowStates) {
-    if (windowState.windowId === windowId) {
-      return windowState
-    }
-  }
-  return undefined
-}
-
-export const findByWebContentsId = (webContentsId) => {
-  const { windowStates } = state
-  for (const windowState of windowStates) {
-    if (windowState.webContentsId === webContentsId) {
-      return windowState
-    }
-  }
-  return undefined
-}
-
-export const findIndexById = (id) => {
-  const { windowStates } = state
-  for (let i = 0; i < windowStates.length; i++) {
-    const windowState = windowStates[i]
-    if (windowState.windowId === id) {
-      return i
-    }
-  }
-  return -1
-}
-
-export const remove = (windowId) => {
-  const index = findIndexById(windowId)
-  if (index === -1) {
-    throw new Error(`expected window ${windowId} to be in windows array`)
-  }
-  state.windowStates.splice(index, 1)
-}
-
-export const getAll = () => {
-  return state.windowStates
-}
-
-export const add = (config) => {
-  state.windowStates.push(config)
-}
-
-export const findByPort = (port) => {
-  for (const config of state.windowStates) {
-    if (config.port === port) {
-      return config
-    }
-  }
-  return undefined
-}

package/src/parts/ChildProcess/ChildProcessWithFork.js

@@ -1,19 +0,0 @@
-import { fork } from 'node:child_process'
-
-export const create = (path) => {
-  const childProcess = fork(path)
-  let _listener
-  return {
-    get onmessage() {
-      return _listener
-    },
-    set onmessage(listener) {
-      if (listener) {
-        childProcess.on('message', listener)
-      } else {
-        childProcess.off('message', listener)
-      }
-      _listener = listener
-    },
-  }
-}

package/src/parts/ChildProcessError/ChildProcessError.js

@@ -1,21 +0,0 @@
-import * as GetHelpfulChildProcessError from '../GetHelpfulChildProcessError/GetHelpfulChildProcessError.js'
-import * as JoinLines from '../JoinLines/JoinLines.js'
-import * as SplitLines from '../SplitLines/SplitLines.js'
-
-export class ChildProcessError extends Error {
-  constructor(stderr) {
-    const { message, code, stack } = GetHelpfulChildProcessError.getHelpfulChildProcessError('', stderr)
-    super(message || 'child process error')
-    this.name = 'ChildProcessError'
-    if (code) {
-      this.code = code
-    }
-    if (stack) {
-      const lines = SplitLines.splitLines(this.stack)
-      const [firstLine, ...stackLines] = lines
-      const newStackLines = [firstLine, ...stack, ...stackLines]
-      const newStack = JoinLines.joinLines(newStackLines)
-      this.stack = newStack
-    }
-  }
-}

package/src/parts/Configuration/Configuration.ipc.js

@@ -1,6 +0,0 @@
-import * as Configuration from './Configuration.js'
-
-export const Commands = {
-  '-1': Configuration.get,
-  '-2': Configuration.set,
-}

package/src/parts/Configuration/Configuration.js

@@ -1,36 +0,0 @@
-import * as Character from '../Character/Character.js'
-import { writeFile } from '../FileSystem/FileSystem.js'
-import * as JsonFile from '../JsonFile/JsonFile.js'
-
-let settings
-let settingsPromise
-
-const readSettings = async () => {
-  // TODO allow jsonc
-  if (!settings) {
-    if (!settingsPromise) {
-      settingsPromise = JsonFile.readJson('/tmp/settings.json')
-    }
-    await settingsPromise
-  }
-  return settings
-}
-
-const writeSettings = async () => {
-  // TODO jsonc
-  await writeFile('/tmp/settings.json', JSON.stringify(settings, null, 2) + Character.NewLine)
-}
-
-export const get = async (key) => {
-  await readSettings()
-  // TODO allow nested object get
-  return settings[key]
-}
-
-export const set = async (key, value) => {
-  await readSettings()
-  // TODO allow nested object set?
-  // how does vscode do it?
-  settings[key] = value
-  await writeSettings()
-}

package/src/parts/CreateCpuProfile/CreateCpuProfile.js

@@ -1,59 +0,0 @@
-import { writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import got from 'got'
-import { WebSocket } from 'ws'
-import * as DevtoolsProtocolRpc from '../DevtoolsProtocolRpc/DevtoolsProtocolRpc.js'
-
-const createConnection = (webSocketDebuggerUrl) => {
-  const webSocket = new WebSocket(webSocketDebuggerUrl)
-  // console.log({ webSocket })
-  return {
-    on(event, listener) {
-      if (event === 'message') {
-        const wrappedListener = (string) => {
-          listener(JSON.parse(string))
-        }
-        webSocket.on(event, wrappedListener)
-      } else {
-        webSocket.on(event, listener)
-      }
-    },
-    send(message) {
-      webSocket.send(JSON.stringify(message))
-    },
-  }
-}
-
-export const createCpuProfile = async (pid) => {
-  // AttachDebugger.attachDebugger(pid)
-  const response = await got('http://localhost:9229/json/list').json()
-  const first = response[0]
-  const { webSocketDebuggerUrl } = first
-  const ipc = createConnection(webSocketDebuggerUrl)
-
-  await new Promise((r) => {
-    ipc.on('open', r)
-  })
-  const rpc = DevtoolsProtocolRpc.create(ipc)
-  const result = await rpc.invoke('Debugger.enable')
-  const { debuggerId } = result.result
-  console.log({ debuggerId })
-  const p = await rpc.invoke('Profiler.enable')
-  await rpc.invoke('Profiler.start')
-  await new Promise((r) => {
-    setTimeout(r, 10000)
-  })
-  const profileResult = await rpc.invoke('Profiler.stop')
-  console.log({ profileResult })
-  const { profile } = profileResult.result
-  const profilePath = join(tmpdir(), 'node-profile.cpuprofile')
-  const profileString = JSON.stringify(profile)
-  await writeFile(profilePath, profileString)
-  console.log('finished')
-  // const value = await rpc.invoke('Runtime.evaluate', {
-  //   expression: '1+1',
-  // })
-  // await rpc.invoke('Debugger.pause')
-  // console.log({ value })
-}

package/src/parts/Credentials/Credentials.ipc.js

@@ -1,9 +0,0 @@
-import * as Credentials from './Credentials.js'
-
-export const Commands = {
-  deletePassword: Credentials.deletePassword,
-  findCredentials: Credentials.findCredentials,
-  findPassword: Credentials.findPassword,
-  getPassword: Credentials.getPassword,
-  setPassword: Credentials.setPassword,
-}

package/src/parts/Credentials/Credentials.js

@@ -1,61 +0,0 @@
-import keytar from 'keytar'
-import { VError } from '../VError/VError.js'
-
-/**
- * @param {string} service
- * @param {string} account
- */
-export const deletePassword = async (service, account) => {
-  try {
-    return await keytar.deletePassword(service, account)
-  } catch (error) {
-    throw new VError(error, `Failed to delete password from service ${service}`)
-  }
-}
-
-/**
- * @param {string} service
- */
-export const findCredentials = async (service) => {
-  try {
-    return keytar.findCredentials(service)
-  } catch (error) {
-    throw new VError(error, `Failed to find credentials from service ${service}`)
-  }
-}
-
-/**
- * @param {string} service
- */
-export const findPassword = async (service) => {
-  try {
-    return await keytar.findPassword(service)
-  } catch (error) {
-    throw new VError(error, `Failed to find password from service ${service}`)
-  }
-}
-
-/**
- * @param {string} service
- * @param {string} account
- */
-export const getPassword = async (service, account) => {
-  try {
-    return await keytar.getPassword(service, account)
-  } catch (error) {
-    throw new VError(error, `Failed to get password from service ${service}`)
-  }
-}
-
-/**
- * @param {string} service
- * @param {string} account
- * @param {string} password
- */
-export const setPassword = async (service, account, password) => {
-  try {
-    return await keytar.setPassword(service, account, password)
-  } catch (error) {
-    throw new VError(error, `Failed to set password for service ${service}`)
-  }
-}

package/src/parts/DevtoolsProtocolRpc/DevtoolsProtocolRpc.js

@@ -1,32 +0,0 @@
-const Id = {
-  id: 1,
-  create() {
-    return this.id++
-  },
-}
-
-export const create = (ipc) => {
-  const callbacks = Object.create(null)
-  const handleMessage = (message) => {
-    if ('result' in message) {
-      const callback = callbacks[message.id]
-      callback(message)
-      delete callbacks[message.id]
-    }
-  }
-  ipc.on('message', handleMessage)
-  return {
-    invoke(method, params = {}) {
-      const id = Id.create()
-      const promise = new Promise((resolve, reject) => {
-        callbacks[id] = resolve
-      })
-      ipc.send({
-        method,
-        id,
-        params,
-      })
-      return promise
-    },
-  }
-}

package/src/parts/ErrorType/ErrorType.js

@@ -1,4 +0,0 @@
-export const DomException = 'DOMException'
-export const ReferenceError = 'ReferenceError'
-export const SyntaxError = 'SyntaxError'
-export const TypeError = 'TypeError'

package/src/parts/ExtensionHostIpcWithWorker/ExtensionHostIpcWithWorker.js

@@ -1,34 +0,0 @@
-import { Worker } from 'node:worker_threads'
-import * as Platform from '../Platform/Platform.js'
-
-export const create = async () => {
-  const extensionHostPath = await Platform.getExtensionHostPath()
-  const child = new Worker(extensionHostPath, {
-    execArgv: ['--experimental-json-modules', '--max-old-space-size=60', '--enable-source-maps'],
-    env: {
-      ...process.env,
-      LOGS_DIR: Platform.getLogsDir(),
-      CONFIG_DIR: Platform.getConfigDir(),
-    },
-  })
-  return {
-    on(event, listener) {
-      switch (event) {
-        case 'message':
-          child.on('message', listener)
-          break
-        case 'error':
-          child.on('error', listener)
-          break
-        default:
-          break
-      }
-    },
-    send(message) {
-      child.postMessage(message)
-    },
-    dispose() {
-      child.terminate()
-    },
-  }
-}

package/src/parts/FirstWebSocketEventType/FirstWebSocketEventType.js

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

package/src/parts/GetActualPath/GetActualPath.js

@@ -1,8 +0,0 @@
-import { fileURLToPath } from 'node:url'
-
-export const getActualPath = (fileUri) => {
-  if (fileUri.startsWith('file://')) {
-    return fileURLToPath(fileUri)
-  }
-  return fileUri
-}

package/src/parts/GetErrorConstructor/GetErrorConstructor.js

@@ -1,28 +0,0 @@
-import * as ErrorType from '../ErrorType/ErrorType.js'
-
-export const getErrorConstructor = (message, type) => {
-  if (type) {
-    switch (type) {
-      case ErrorType.DomException:
-        return DOMException
-      case ErrorType.TypeError:
-        return TypeError
-      case ErrorType.SyntaxError:
-        return SyntaxError
-      case ErrorType.ReferenceError:
-        return ReferenceError
-      default:
-        return Error
-    }
-  }
-  if (message.startsWith('TypeError: ')) {
-    return TypeError
-  }
-  if (message.startsWith('SyntaxError: ')) {
-    return SyntaxError
-  }
-  if (message.startsWith('ReferenceError: ')) {
-    return ReferenceError
-  }
-  return Error
-}

package/src/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/src/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/src/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/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/Header/Header.js

@@ -1 +0,0 @@
-export const ContentType = 'Content-Type'

package/src/parts/IsSocket/IsSocket.js

@@ -1,5 +0,0 @@
-import { Socket } from 'node:net'
-
-export const isSocket = (value) => {
-  return value instanceof Socket
-}

package/src/parts/IsWebSocketOpen/IsWebSocketOpen.js

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

package/src/parts/JsonParsingError/JsonParsingError.js

@@ -1,19 +0,0 @@
-import * as JoinLines from '../JoinLines/JoinLines.js'
-import * as SplitLines from '../SplitLines/SplitLines.js'
-import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
-
-export class JsonParsingError extends Error {
-  constructor(message, codeFrame, stack) {
-    super(message)
-    this.name = 'JsonParsingError'
-    this.code = ErrorCodes.E_JSON_PARSE
-    if (codeFrame) {
-      this.codeFrame = codeFrame
-    }
-
-    if (stack) {
-      const parentStack = JoinLines.joinLines(SplitLines.splitLines(this.stack).slice(1))
-      this.stack = this.name + ': ' + this.message + '\n' + stack + '\n' + parentStack
-    }
-  }
-}

package/src/parts/MergeStacks/MergeStacks.js

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

@@ -1,9 +0,0 @@
-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/PassThroughElectronMessageForTerminalProcess/PassThroughElectronMessageForTerminalProcess.js

@@ -1,29 +0,0 @@
-import * as Assert from '../Assert/Assert.js'
-import * as GetTerminalProcessPath from '../GetTerminalProcessPath/GetTerminalProcessPath.js'
-import * as IpcParent from '../IpcParent/IpcParent.js'
-import * as IpcParentType from '../IpcParentType/IpcParentType.js'
-
-/**
- *
- * @returns
- */
-export const handlePort = async (browserWindowPort, type, name) => {
-  Assert.object(browserWindowPort)
-  Assert.string(type)
-  Assert.string(name)
-  const ptyHostPath = GetTerminalProcessPath.getTerminalProcessPath()
-  const ipc = await IpcParent.create({
-    method: IpcParentType.ElectronUtilityProcess,
-    path: ptyHostPath,
-    name,
-  })
-  // TODO use connectIpc for better error handling
-  ipc.sendAndTransfer(
-    {
-      jsonrpc: '2.0',
-      method: 'HandleElectronMessagePort.handleElectronMessagePort',
-      params: [],
-    },
-    [browserWindowPort]
-  )
-}

package/src/parts/PassThroughElectronMessagePort/PassThroughElectronMessagePort.ipc.js

@@ -1,7 +0,0 @@
-import * as PassThroughElectronMessagePort from './PassThroughElectronMessagePort.js'
-
-export const name = 'PassThroughElectronMessagePort'
-
-export const Commands = {
-  passThroughElectronMessagePort: PassThroughElectronMessagePort.passThroughElectronMessagePort,
-}

package/src/parts/PassThroughElectronMessagePort/PassThroughElectronMessagePort.js

@@ -1,4 +0,0 @@
-import * as Path from '../Path/Path.js'
-import * as Root from '../Root/Root.js'
-
-export const passThroughElectronMessagePort = () => {}

package/src/parts/PassThroughElectronMessagePortModule/PassThroughElectronMessagePortModule.js

@@ -1,8 +0,0 @@
-export const getModule = (type) => {
-  switch (type) {
-    case 'terminal-process':
-      return import('../PassThroughElectronMessageForTerminalProcess/PassThroughElectronMessageForTerminalProcess.js')
-    default:
-      return undefined
-  }
-}

package/src/parts/WebSocketReadyState/WebSocketReadyState.js

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

package/src/parts/WebSocketSerialization/WebSocketSerialization.js

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