@lvce-editor/extension-host-helper-process 0.22.0 → 0.22.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/extension-host-helper-process",
-  "version": "0.22.0",
+  "version": "0.22.2",
   "description": "",
   "main": "index.js",
   "type": "module",
@@ -16,13 +16,13 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@babel/code-frame": "^7.23.5",
+    "@lvce-editor/assert": "^1.1.0",
+    "@lvce-editor/json-rpc": "^1.0.0",
+    "@lvce-editor/pretty-error": "^1.4.0",
     "@lvce-editor/verror": "^1.1.2",
-    "clean-stack": "^5.2.0",
+    "@lvce-editor/web-socket-server": "^1.1.0",
     "execa": "^8.0.1",
     "got": "^13.0.0",
-    "lines-and-columns": "^2.0.4",
-    "minimist": "^1.2.8",
-    "ws": "^8.16.0"
+    "minimist": "^1.2.8"
   }
 }

package/src/parts/Assert/Assert.js

@@ -1,71 +1 @@
-class AssertionError extends Error {
-  constructor(message) {
-    super(message)
-    this.name = 'AssertionError'
-  }
-}
-
-const getType = (value) => {
-  switch (typeof value) {
-    case 'number':
-      return 'number'
-    case 'function':
-      return 'function'
-    case 'string':
-      return 'string'
-    case 'object':
-      if (value === null) {
-        return 'null'
-      }
-      if (Array.isArray(value)) {
-        return 'array'
-      }
-      return 'object'
-    case 'boolean':
-      return 'boolean'
-    default:
-      return 'unknown'
-  }
-}
-
-export const object = (value) => {
-  const type = getType(value)
-  if (type !== 'object') {
-    throw new AssertionError('expected value to be of type object')
-  }
-}
-
-export const number = (value) => {
-  const type = getType(value)
-  if (type !== 'number') {
-    throw new AssertionError('expected value to be of type number')
-  }
-}
-
-export const array = (value) => {
-  const type = getType(value)
-  if (type !== 'array') {
-    throw new AssertionError('expected value to be of type array')
-  }
-}
-
-export const string = (value) => {
-  const type = getType(value)
-  if (type !== 'string') {
-    throw new AssertionError('expected value to be of type string')
-  }
-}
-
-export const boolean = (value) => {
-  const type = getType(value)
-  if (type !== 'boolean') {
-    throw new AssertionError('expected value to be of type boolean')
-  }
-}
-
-export const fn = (value) => {
-  const type = getType(value)
-  if (type !== 'function') {
-    throw new AssertionError('expected value to be of type function')
-  }
-}
+export * from '@lvce-editor/assert'

package/src/parts/Callback/Callback.js

@@ -1,42 +1 @@
-import * as Assert from '../Assert/Assert.js'
-import * as Id from '../Id/Id.js'
-
-export const state = {
-  callbacks: Object.create(null),
-}
-
-export const registerPromise = () => {
-  const id = Id.create()
-  const promise = new Promise((resolve, reject) => {
-    state.callbacks[id] = {
-      resolve,
-      reject,
-    }
-  })
-  return { id, promise }
-}
-
-export const unregister = (id) => {
-  delete state.callbacks[id]
-}
-
-export const resolve = (id, args) => {
-  Assert.number(id)
-  if (!(id in state.callbacks)) {
-    console.log(args)
-    console.warn(`callback ${id} may already be disposed`)
-    return
-  }
-  state.callbacks[id].resolve(args)
-  delete state.callbacks[id]
-}
-
-export const reject = (id, error) => {
-  Assert.number(id)
-  if (!(id in state.callbacks)) {
-    console.warn(`callback ${id} may already be disposed`)
-    return
-  }
-  state.callbacks[id].reject(error)
-  delete state.callbacks[id]
-}
+export { resolve } from '@lvce-editor/json-rpc'

package/src/parts/CommandMap/CommandMap.js

@@ -1,5 +1,6 @@
 import * as Ajax from '../Ajax/Ajax.js'
 import * as Exec from '../Exec/Exec.js'
+import * as HandleElectronMessagePort from '../HandleElectronMessagePort/HandleElectronMessagePort.js'
 import * as HandleWebSocket from '../HandleWebSocket/HandleWebSocket.js'
 import * as LoadFile from '../LoadFile/LoadFile.js'
 
@@ -8,4 +9,5 @@ export const commandMap = {
   'Ajax.getJson': Ajax.getJson,
   'HandleWebSocket.handleWebSocket': HandleWebSocket.handleWebSocket,
   'LoadFile.loadFile': LoadFile.loadFile,
+  'HandleElectronMessagePort.handleElectronMessagePort': HandleElectronMessagePort.handleElectronMessagePort,
 }

package/src/parts/GetData/GetData.js

@@ -0,0 +1,3 @@
+export const getData = (event) => {
+  return event.data
+}

package/src/parts/GetUtilityProcessPortData/GetUtilityProcessPortData.js

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

package/src/parts/HandleElectronMessagePort/HandleElectronMessagePort.js

@@ -10,5 +10,4 @@ export const handleElectronMessagePort = async (messagePort) => {
     messagePort,
   })
   HandleIpc.handleIpc(ipc)
-  messagePort.start()
 }

package/src/parts/HandleIpc/HandleIpc.js

@@ -1,12 +1,25 @@
-import * as Assert from '../Assert/Assert.js'
-import * as Command from '../Command/Command.js'
 import * as Callback from '../Callback/Callback.js'
-import * as HandleJsonRpcMessage from '../HandleJsonRpcMessage/HandleJsonRpcMessage.js'
+import * as Command from '../Command/Command.js'
+import * as JsonRpc from '../JsonRpc/JsonRpc.js'
+import * as PrettyError from '../PrettyError/PrettyError.js'
+import * as PrintPrettyError from '../PrintPrettyError/PrintPrettyError.js'
+
+const preparePrettyError = PrettyError.prepare
+
+const logError = (error, prettyError) => {
+  PrintPrettyError.printPrettyError(prettyError, `[extension-host-helper-process] `)
+}
+
+const requiresSocket = () => {
+  return false
+}
 
 export const handleIpc = (ipc) => {
-  Assert.object(ipc)
-  const handleMessage = async (message) => {
-    return HandleJsonRpcMessage.handleJsonRpcMessage(ipc, message, Command.execute, Callback.resolve)
+  const handleMessage = (message) => {
+    return JsonRpc.handleJsonRpcMessage(ipc, message, Command.execute, Callback.resolve, preparePrettyError, logError, requiresSocket)
   }
   ipc.on('message', handleMessage)
+  if (ipc.start) {
+    ipc.start()
+  }
 }

package/src/parts/HandleWebSocket/HandleWebSocket.js

@@ -2,17 +2,14 @@ import * as Assert from '../Assert/Assert.js'
 import * as HandleIpc from '../HandleIpc/HandleIpc.js'
 import * as IpcChild from '../IpcChild/IpcChild.js'
 import * as IpcChildType from '../IpcChildType/IpcChildType.js'
-import * as WebSocketServer from '../WebSocketServer/WebSocketServer.js'
 
 export const handleWebSocket = async (request, handle) => {
   Assert.object(request)
   Assert.object(handle)
-  const webSocket = await WebSocketServer.handleUpgrade(request, handle)
-  webSocket.pause()
   const ipc = await IpcChild.listen({
     method: IpcChildType.WebSocket,
-    webSocket,
+    request,
+    handle,
   })
   HandleIpc.handleIpc(ipc)
-  webSocket.resume()
 }

package/src/parts/IpcChildWithElectronMessagePort/IpcChildWithElectronMessagePort.js

@@ -1,3 +1,4 @@
+import * as GetUtilityProcessPortData from '../GetUtilityProcessPortData/GetUtilityProcessPortData.js'
 import { IpcError } from '../IpcError/IpcError.js'
 import * as IsMessagePortMain from '../IsMessagePortMain/IsMessagePortMain.js'
 
@@ -8,17 +9,13 @@ export const listen = ({ messagePort }) => {
   return messagePort
 }
 
-const getActualData = (event) => {
-  return event.data
-}
-
 export const wrap = (messagePort) => {
   return {
     messagePort,
     on(event, listener) {
       if (event === 'message') {
         const wrappedListener = (event) => {
-          const actualData = getActualData(event)
+          const actualData = GetUtilityProcessPortData.getUtilityProcessPortData(event)
           listener(actualData)
         }
         this.messagePort.on(event, wrappedListener)
@@ -35,5 +32,8 @@ export const wrap = (messagePort) => {
     dispose() {
       this.messagePort.close()
     },
+    start() {
+      this.messagePort.start()
+    },
   }
 }

package/src/parts/IpcChildWithElectronUtilityProcess/IpcChildWithElectronUtilityProcess.js

@@ -1,3 +1,4 @@
+import * as GetUtilityProcessPortData from '../GetUtilityProcessPortData/GetUtilityProcessPortData.js'
 import { IpcError } from '../IpcError/IpcError.js'
 
 export const listen = () => {
@@ -14,7 +15,17 @@ export const wrap = (parentPort) => {
   return {
     parentPort,
     on(event, listener) {
-      this.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)
@@ -22,6 +33,9 @@ export const wrap = (parentPort) => {
     send(message) {
       this.parentPort.postMessage(message)
     },
+    sendAndTransfer(message, transfer) {
+      this.parentPort.postMessage(message, transfer)
+    },
     dispose() {
       this.parentPort.close()
     },

package/src/parts/IpcChildWithWebSocket/IpcChildWithWebSocket.js

@@ -1,16 +1,18 @@
 import * as GetFirstWebSocketEvent from '../GetFirstWebSocketEvent/GetFirstWebSocketEvent.js'
 import { IpcError } from '../IpcError/IpcError.js'
-import * as IsWebSocket from '../IsWebSocket/IsWebSocket.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 ({ webSocket }) => {
-  if (!webSocket) {
-    throw new IpcError('webSocket must be defined')
+export const listen = async ({ request, handle }) => {
+  if (!request) {
+    throw new IpcError('request must be defined')
   }
-  if (!IsWebSocket.isWebSocket(webSocket)) {
-    throw new IpcError(`webSocket must be of type WebSocket`)
+  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)
     console.log({ type, event })
@@ -48,5 +50,8 @@ export const wrap = (webSocket) => {
     dispose() {
       this.webSocket.close()
     },
+    start() {
+      this.webSocket.resume()
+    },
   }
 }

package/src/parts/JsonRpc/JsonRpc.js

@@ -1 +1 @@
-export const ErrorMethodNotFound = -32601
+export * from '@lvce-editor/json-rpc'

package/src/parts/PrettyError/PrettyError.js

@@ -1,55 +1 @@
-import { codeFrameColumns } from '@babel/code-frame'
-import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-import * as CleanStack from '../CleanStack/CleanStack.js'
-
-const getActualPath = (fileUri) => {
-  if (fileUri.startsWith('file://')) {
-    return fileURLToPath(fileUri)
-  }
-  return fileUri
-}
-
-export const prepare = (error) => {
-  const message = error.message
-  if (error && error.cause) {
-    const cause = error.cause()
-    if (cause) {
-      error = cause
-    }
-  }
-  const lines = CleanStack.cleanStack(error.stack)
-  const file = lines[0]
-  let codeFrame = ''
-  if (error.codeFrame) {
-    codeFrame = error.codeFrame
-  } else if (file) {
-    let match = file.match(/\((.*):(\d+):(\d+)\)$/)
-    if (!match) {
-      match = file.match(/at (.*):(\d+):(\d+)$/)
-    }
-    if (match) {
-      const [_, path, line, column] = match
-      const actualPath = getActualPath(path)
-      const rawLines = readFileSync(actualPath, 'utf-8')
-      const location = {
-        start: {
-          line: Number.parseInt(line),
-          column: Number.parseInt(column),
-        },
-      }
-
-      codeFrame = codeFrameColumns(rawLines, location)
-    }
-  }
-  const relevantStack = lines.slice(1).join('\n')
-  return {
-    message,
-    stack: relevantStack,
-    codeFrame,
-    code: error.code,
-    type: error.constructor.name,
-    stderr: error.stderr,
-    stdout: error.stdout,
-  }
-}
+export { prepare, prepareJsonError } from '@lvce-editor/pretty-error'

package/src/parts/WebSocketServer/WebSocketServer.js

@@ -1,21 +1 @@
-import { Buffer } from 'node:buffer'
-import * as _ws from 'ws'
-
-// workaround for jest or node bug
-const WebSocketServer = _ws.WebSocketServer
-  ? _ws.WebSocketServer
-  : // @ts-ignore
-    _ws.default.WebSocketServer
-
-const webSocketServer = new WebSocketServer({
-  noServer: true,
-})
-
-export const handleUpgrade = (request, socket) => {
-  return new Promise((resolve, reject) => {
-    const upgradeCallback = (ws) => {
-      resolve(ws)
-    }
-    webSocketServer.handleUpgrade(request, socket, Buffer.alloc(0), upgradeCallback)
-  })
-}
+export * from '@lvce-editor/web-socket-server'

package/src/parts/CleanStack/CleanStack.js

@@ -1,97 +0,0 @@
-import * as SplitLines from '../SplitLines/SplitLines.js'
-
-const RE_AT = /^\s+at/
-const RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/
-const RE_OBJECT_AS = /^\s*at (async )?Object\.\w+ \[as ([\w\.]+)\]/
-const RE_GET_RESPONSE = /^\s*at async getResponse/
-const RE_WEBSOCKET_HANDLE_MESSAGE = /^\s*at async WebSocket.handleMessage/
-const RE_EXECUTE_COMMAND_ASYNC = /^\s*at executeCommandAsync/
-const RE_HANDLE_OTHER_MESSAGES_FROM_MESSAGE_PORT = /^\s*at async MessagePort\.handleOtherMessagesFromMessagePort/
-const RE_ASSERT = /^\s*at .*\/Assert\.js/
-
-const isInternalLine = (line) => {
-  return line.includes('node:') || RE_AT_PROMISE_INDEX.test(line) || line.includes('node_modules/ws')
-}
-
-const isRelevantLine = (line) => {
-  return !isInternalLine(line)
-}
-
-const isApplicationUsefulLine = (line, index) => {
-  if (index === 0) {
-    if (RE_ASSERT.test(line)) {
-      return false
-    }
-    return true
-  }
-  if (RE_GET_RESPONSE.test(line)) {
-    return false
-  }
-  if (RE_WEBSOCKET_HANDLE_MESSAGE.test(line)) {
-    return false
-  }
-  if (RE_EXECUTE_COMMAND_ASYNC.test(line)) {
-    return false
-  }
-  if (RE_HANDLE_OTHER_MESSAGES_FROM_MESSAGE_PORT.test(line)) {
-    return false
-  }
-  return true
-}
-
-const isNormalStackLine = (line) => {
-  return RE_AT.test(line) && !RE_AT_PROMISE_INDEX.test(line)
-}
-
-const cleanLine = (line) => {
-  if (line.startsWith('    at exports.')) {
-    return '    at ' + line.slice('    at exports.'.length)
-  }
-  if (line.startsWith('    at async exports.')) {
-    return '    at async ' + line.slice('    at async exports.'.length)
-  }
-  if (line.startsWith('    at async Module.')) {
-    return '    at async ' + line.slice('    at async Module.'.length)
-  }
-  if (line.startsWith('    at Module.')) {
-    return '    at ' + line.slice('    at Module.'.length)
-  }
-  const objectMatch = line.match(RE_OBJECT_AS)
-  if (objectMatch) {
-    const rest = line.slice(objectMatch[0].length)
-    if (objectMatch[1]) {
-      return '    at ' + objectMatch[1] + objectMatch[2] + rest
-    }
-    return '    at ' + objectMatch[2] + rest
-  }
-  return line
-}
-
-const getDetails = (lines) => {
-  const index = lines.findIndex(isNormalStackLine)
-  return {
-    custom: lines.slice(0, index),
-    actualStack: lines.slice(index).map(cleanLine),
-  }
-}
-
-const RE_PATH_1 = /^\/(.*)(\d+)$/
-
-const mergeCustom = (custom, relevantStack) => {
-  if (custom.length === 0) {
-    return relevantStack
-  }
-  const firstLine = custom[0]
-  if (RE_PATH_1.test(firstLine)) {
-    return [`    at ${firstLine}`, ...relevantStack]
-  }
-  return relevantStack
-}
-
-export const cleanStack = (stack) => {
-  const lines = SplitLines.splitLines(stack)
-  const { custom, actualStack } = getDetails(lines)
-  const relevantStack = actualStack.filter(isRelevantLine).filter(isApplicationUsefulLine)
-  const merged = mergeCustom(custom, relevantStack)
-  return merged
-}

package/src/parts/GetErrorResponse/GetErrorResponse.js

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

@@ -1,11 +0,0 @@
-import * as GetErrorResponse from '../GetErrorResponse/GetErrorResponse.js'
-import * as GetSuccessResponse from '../GetSuccessResponse/GetSuccessResponse.js'
-
-export const getResponse = async (message, execute) => {
-  try {
-    const result = await execute(message.method, ...message.params)
-    return GetSuccessResponse.getSuccessResponse(message, result)
-  } catch (error) {
-    return GetErrorResponse.getErrorResponse(message, error)
-  }
-}

package/src/parts/GetSuccessResponse/GetSuccessResponse.js

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

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

package/src/parts/JsonRpcVersion/JsonRpcVersion.js

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