@lvce-editor/shared-process 0.13.0 → 0.14.1

package/src/parts/{Error → FileNotFoundError}/FileNotFoundError.js

@@ -1,9 +1,16 @@
-import VError from 'verror'
 import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+import { VError } from '../VError/VError.js'
+
+const getDisplayPath = (path) => {
+  if (path === '') {
+    return '<empty string>'
+  }
+  return path
+}
 
 export class FileNotFoundError extends VError {
   constructor(path) {
-    super(`File not found '${path}'`)
+    super(`File not found: '${getDisplayPath(path)}'`)
     this.name = 'FileNotFoundError'
     this.code = ErrorCodes.ENOENT
   }

package/src/parts/FileSystem/FileSystem.js

@@ -1,14 +1,14 @@
 // TODO lazyload chokidar and trash (but doesn't work currently because of bug with jest)
 import * as fs from 'node:fs/promises'
 import * as os from 'node:os'
-import VError from 'verror'
-import * as DirentType from '../DirentType/DirentType.js'
-import { FileNotFoundError } from '../Error/FileNotFoundError.js'
+import * as EncodingType from '../EncodingType/EncodingType.js'
+import { FileNotFoundError } from '../FileNotFoundError/FileNotFoundError.js'
 import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+import * as GetDirentType from '../GetDirentType/GetDirentType.js'
 import * as Path from '../Path/Path.js'
 import * as Platform from '../Platform/Platform.js'
 import * as Trash from '../Trash/Trash.js'
-import * as EncodingType from '../EncodingType/EncodingType.js'
+import { VError } from '../VError/VError.js'
 
 export const state = {
   watcherMap: Object.create(null),
@@ -132,39 +132,13 @@ export const exists = async (path) => {
   }
 }
 
-/**
- * @param {import('fs').Dirent|import('fs').StatsBase} dirent
- */
-const getType = (dirent) => {
-  if (dirent.isFile()) {
-    return DirentType.File
-  }
-  if (dirent.isDirectory()) {
-    return DirentType.Directory
-  }
-  if (dirent.isSymbolicLink()) {
-    return DirentType.Symlink
-  }
-  if (dirent.isSocket()) {
-    return DirentType.Socket
-  }
-  if (dirent.isBlockDevice()) {
-    return DirentType.BlockDevice
-  }
-  if (dirent.isCharacterDevice()) {
-    return DirentType.CharacterDevice
-  }
-  console.log({ dirent })
-  return DirentType.Unknown
-}
-
 /**
  * @param {import('fs').Dirent} dirent
  */
 const toPrettyDirent = (dirent) => {
   return {
     name: dirent.name,
-    type: getType(dirent),
+    type: GetDirentType.getDirentType(dirent),
   }
 }
 
@@ -264,7 +238,7 @@ export const getRealPath = async (path) => {
 // TODO handle error
 export const stat = async (path) => {
   const stats = await fs.stat(path)
-  const type = getType(stats)
+  const type = GetDirentType.getDirentType(stats)
   return type
 }
 

package/src/parts/FirstNodeWorkerEventType/FirstNodeWorkerEventType.js

@@ -0,0 +1,5 @@
+export const Exit = 'exit'
+
+export const Error = 'error'
+
+export const Message = 'message'

package/src/parts/GetDirentType/GetDirentType.js

@@ -0,0 +1,27 @@
+import * as DirentType from '../DirentType/DirentType.js'
+
+/**
+ * @param {import('fs').Dirent|import('fs').StatsBase} dirent
+ */
+export const getDirentType = (dirent) => {
+  if (dirent.isFile()) {
+    return DirentType.File
+  }
+  if (dirent.isDirectory()) {
+    return DirentType.Directory
+  }
+  if (dirent.isSymbolicLink()) {
+    return DirentType.Symlink
+  }
+  if (dirent.isSocket()) {
+    return DirentType.Socket
+  }
+  if (dirent.isBlockDevice()) {
+    return DirentType.BlockDevice
+  }
+  if (dirent.isCharacterDevice()) {
+    return DirentType.CharacterDevice
+  }
+  console.log({ dirent })
+  return DirentType.Unknown
+}

package/src/parts/GetFirstNodeChildProcessEvent/GetFirstNodeChildProcessEvent.js

@@ -0,0 +1,39 @@
+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 = () => {
+      childProcess.stderr.off('data', handleStdErrData)
+      childProcess.stdout.off('data', handleStdoutData)
+      childProcess.off('message', handleMessage)
+      childProcess.off('exit', handleExit)
+      childProcess.off('error', handleError)
+    }
+    const handleStdErrData = (data) => {
+      stderr += data
+    }
+    const handleStdoutData = (data) => {
+      stdout += data
+    }
+    const handleMessage = (event) => {
+      cleanup()
+      resolve({ type: FirstNodeWorkerEventType.Message, event, stdout, stderr })
+    }
+    const handleExit = (event) => {
+      cleanup()
+      resolve({ type: FirstNodeWorkerEventType.Exit, event, stdout, stderr })
+    }
+    const handleError = (event) => {
+      cleanup()
+      resolve({ type: FirstNodeWorkerEventType.Error, event, stdout, 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/GetFirstNodeWorkerEvent/GetFirstNodeWorkerEvent.js

@@ -0,0 +1,21 @@
+import * as FirstNodeWorkerEventType from '../FirstNodeWorkerEventType/FirstNodeWorkerEventType.js'
+
+export const getFirstNodeWorkerEvent = async (worker) => {
+  const { type, event } = await new Promise((resolve, reject) => {
+    const cleanup = () => {
+      worker.off('exit', handleExit)
+      worker.off('error', handleError)
+    }
+    const handleExit = (event) => {
+      cleanup()
+      resolve({ type: FirstNodeWorkerEventType.Exit, event })
+    }
+    const handleError = (event) => {
+      cleanup()
+      resolve({ type: FirstNodeWorkerEventType.Error, event })
+    }
+    worker.on('exit', handleExit)
+    worker.on('error', handleError)
+  })
+  return { type, event }
+}

package/src/parts/GetNewLineIndex/GetNewLineIndex.js

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

package/src/parts/GetResponse/GetResponse.js

@@ -1,24 +1,31 @@
 import * as Command from '../Command/Command.js'
+import { CommandNotFoundError } from '../CommandNotFoundError/CommandNotFoundError.js'
 import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
 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'
-import { requiresSocket } from '../RequiresSocket/RequiresSocket.js'
+import * as RequiresSocket from '../RequiresSocket/RequiresSocket.js'
+
+const shouldLogError = (error) => {
+  if (error && error.code === ErrorCodes.ENOENT) {
+    return false
+  }
+  return true
+}
 
 export const getResponse = async (message, handle) => {
   try {
-    const result = requiresSocket(message.method)
+    const result = RequiresSocket.requiresSocket(message.method)
       ? await Command.execute(message.method, handle, ...message.params)
       : await Command.execute(message.method, ...message.params)
-
     return {
       jsonrpc: JsonRpcVersion.Two,
       id: message.id,
       result: result ?? null,
     }
   } catch (error) {
-    if (error && error instanceof Error && error.message && error.message.startsWith('method not found')) {
+    if (error && error instanceof CommandNotFoundError) {
       return {
         jsonrpc: JsonRpcVersion.Two,
         id: message.id,
@@ -29,14 +36,16 @@ export const getResponse = async (message, handle) => {
         },
       }
     }
-    // @ts-ignore
-    if (error && error instanceof Error && error.code === ErrorCodes.ENOENT) {
+    if (!shouldLogError(error)) {
       return {
         jsonrpc: JsonRpcVersion.Two,
         id: message.id,
         error: {
           code: JsonRpcErrorCode.Custom,
           message: `${error}`,
+          data: {
+            code: error.code,
+          },
         },
       }
     }
@@ -51,6 +60,7 @@ export const getResponse = async (message, handle) => {
         data: {
           stack: prettyError.stack,
           codeFrame: prettyError.codeFrame,
+          type: prettyError.type,
         },
       },
     }

package/src/parts/GetTextSearchRipGrepArgs/GetTextSearchRipGrepArgs.js

@@ -0,0 +1,14 @@
+export const getRipGrepArgs = ({ threads, isCaseSensitive, searchString }) => {
+  const ripGrepArgs = ['--smart-case', '--stats', '--json']
+  ripGrepArgs.push('--threads', `${threads}`)
+  if (isCaseSensitive) {
+    ripGrepArgs.push('--case-sensitive')
+  } else {
+    ripGrepArgs.push('--ignore-case')
+  }
+  ripGrepArgs.push('--fixed-strings')
+  ripGrepArgs.push('--')
+  ripGrepArgs.push(searchString)
+  ripGrepArgs.push('.')
+  return ripGrepArgs
+}

package/src/parts/InstallExtension/InstallExtension.ipc.js

@@ -0,0 +1,6 @@
+import * as InstallExtension from './InstallExtension.js'
+
+// prettier-ignore
+export const Commands = {
+  'InstallExtension.installExtension': InstallExtension.installExtension,
+}

package/src/parts/InstallExtension/InstallExtension.js

@@ -0,0 +1,33 @@
+import * as Debug from '../Debug/Debug.js'
+import * as Download from '../Download/Download.js'
+import * as Extract from '../Extract/Extract.js'
+import * as Path from '../Path/Path.js'
+import * as Platform from '../Platform/Platform.js'
+import * as Queue from '../Queue/Queue.js'
+import { VError } from '../VError/VError.js'
+
+export const installExtension = async (id) => {
+  // TODO this should be a stateless function, renderer-worker should have info on marketplace url
+  // TODO use command.execute
+  try {
+    const marketplaceUrl = Platform.getMarketplaceUrl()
+    Debug.debug(`ExtensionManagement#install ${id}`)
+    const cachedExtensionsPath = Platform.getCachedExtensionsPath()
+    const extensionsPath = Platform.getExtensionsPath()
+    // TODO maybe a queue is over engineering here
+    await Queue.add('download', async () => {
+      Debug.debug(`ExtensionManagement#download ${id}`)
+      // TODO use command.execute
+      await Download.download(`${marketplaceUrl}/download/${id}`, Path.join(cachedExtensionsPath, `${id}.tar.br`))
+      Debug.debug(`ExtensionManagement#extract ${id}`)
+      await Extract.extractTarBr(Path.join(cachedExtensionsPath, `${id}.tar.br`), Path.join(extensionsPath, id))
+    })
+    // TODO should this be here? (probably not)
+    // await ExtensionHost.enableExtension({
+    //   id,
+    //   type: 'marketplace',
+    // })
+  } catch (error) {
+    throw new VError(error, `Failed to install extension "${id}"`)
+  }
+}

package/src/parts/IpcParent/IpcParent.js

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

package/src/parts/IpcParentModule/IpcParentModule.js

@@ -0,0 +1,12 @@
+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')
+    default:
+      throw new Error('unexpected ipc type')
+  }
+}

package/src/parts/IpcParentType/IpcParentType.js

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

package/src/parts/IpcParentWithNodeForkedProcess/IpcParentWithNodeForkedProcess.js

@@ -0,0 +1,49 @@
+import * as Assert from '../Assert/Assert.js'
+import { fork } from 'node:child_process'
+import * as GetFirstNodeChildProcessEvent from '../GetFirstNodeChildProcessEvent/GetFirstNodeChildProcessEvent.js'
+import * as FirstNodeWorkerEventType from '../FirstNodeWorkerEventType/FirstNodeWorkerEventType.js'
+import { ChildProcessError } from '../ChildProcessError/ChildProcessError.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 childProcess = fork(path, argv, {
+      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)
+    },
+    send(message) {
+      this.childProcess.send(message)
+    },
+    sendAndTransfer(message, transfer) {
+      throw new Error('transfer is not supported')
+    },
+    dispose() {
+      this.childProcess.kill()
+    },
+  }
+}

package/src/parts/IpcParentWithNodeWorker/IpcParentWithNodeWorker.js

@@ -0,0 +1,36 @@
+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'
+
+export const create = async ({ path, argv, env, execArgv }) => {
+  Assert.string(path)
+  const worker = new Worker(path, {
+    argv,
+    env,
+    execArgv,
+  })
+  const { type, event } = await GetFirstNodeWorkerEvent.getFirstNodeWorkerEvent(worker)
+  if (type === FirstNodeWorkerEventType.Error) {
+    throw event
+  }
+  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) {
+      this.worker.postMessage(message, transfer)
+    },
+    dispose() {
+      this.worker.terminate()
+    },
+  }
+}

package/src/parts/IsEnoentErrorWindows/IsEnoentErrorWindows.js

@@ -0,0 +1,3 @@
+export const isEnoentErrorWindows = (error) => {
+  return error && error.message && error.message.includes('The system cannot find the path specified.')
+}

package/src/parts/IsIgnoredError/IsIgnoredError.js

@@ -0,0 +1,14 @@
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+import * as Process from '../Process/Process.js'
+
+export const isIgnoredError = (error) => {
+  if (error && error.code === ErrorCodes.EPIPE && !process.connected) {
+    // parent process is disposed, ignore
+    return true
+  }
+  if (error && error.code === ErrorCodes.ERR_IPC_CHANNEL_CLOSED && !Process.isConnected()) {
+    // parent process is disposed, ignore
+    return true
+  }
+  return false
+}

package/src/parts/Json/Json.js

@@ -1,16 +1,14 @@
 // parsing error handling based on https://github.com/sindresorhus/parse-json/blob/main/index.js
 
+import { JsonParsingError } from '../JsonParsingError/JsonParsingError.js'
+
 export const parse = async (string, filePath) => {
   try {
     return JSON.parse(string)
   } catch (error) {
     const JsonError = await import('../JsonError/JsonError.js')
     const errorProps = JsonError.getErrorPropsFromError(error, string, filePath)
-    const jsonError = new Error(errorProps.message)
-    jsonError.stack = errorProps.stack
-    // @ts-ignore
-    jsonError.codeFrame = errorProps.codeFrame
-    throw jsonError
+    throw new JsonParsingError(errorProps.message, errorProps.codeFrame, errorProps.stack)
   }
 }
 

package/src/parts/JsonError/JsonError.js

@@ -16,15 +16,13 @@ export const getErrorPropsFromError = (error, string, filePath) => {
     const index = Number(indexMatch[1])
     const location = lines.locationForIndex(index)
     if (location) {
-      const codeFrame = codeFrameColumns(
-        string,
-        { start: { line: location.line + 1, column: location.column + 1 } },
-        { highlightCode: false }
-      )
+      const line = location.line + 1
+      const column = location.column + 1
+      const codeFrame = codeFrameColumns(string, { start: { line, column } }, { highlightCode: false })
       return {
         codeFrame,
         message: 'Json Parsing Error',
-        stack: `at ${filePath}`,
+        stack: `    at ${filePath}:${line}:${column}`,
       }
     }
   }
@@ -32,7 +30,7 @@ export const getErrorPropsFromError = (error, string, filePath) => {
     return {
       codeFrame: ``,
       message: 'Json Parsing Error: Cannot parse empty string',
-      stack: `at ${filePath}`,
+      stack: `    at ${filePath}`,
     }
   }
 
@@ -41,22 +39,18 @@ export const getErrorPropsFromError = (error, string, filePath) => {
     const index = string.length - 1
     const location = lines.locationForIndex(index)
     if (location) {
-      const codeFrame = codeFrameColumns(
-        string,
-        { start: { line: location.line + 1, column: location.column + 1 } },
-        { highlightCode: false }
-      )
+      const codeFrame = codeFrameColumns(string, { start: { line: location.line + 1, column: location.column + 1 } }, { highlightCode: false })
       return {
         codeFrame,
         message: 'Json Parsing Error',
-        stack: `at ${filePath}`,
+        stack: `    at ${filePath}`,
       }
     }
   }
   return {
     codeFrame: ``,
     message: 'Json Parsing Error',
-    stack: `at ${filePath}`,
+    stack: `    at ${filePath}`,
   }
 }
 

package/src/parts/JsonParsingError/JsonParsingError.js

@@ -0,0 +1,17 @@
+import * as JoinLines from '../JoinLines/JoinLines.js'
+import * as SplitLines from '../SplitLines/SplitLines.js'
+
+export class JsonParsingError extends Error {
+  constructor(message, codeFrame, stack) {
+    super(message)
+    this.name = 'JsonParsingError'
+    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
+    }
+  }
+}