@lvce-editor/shared-process 0.12.1 → 0.14.0

package/src/parts/PrettyError/PrettyError.js

@@ -2,7 +2,9 @@ import { codeFrameColumns } from '@babel/code-frame'
 import { LinesAndColumns } from 'lines-and-columns'
 import { readFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
+import { AssertionError } from '../AssertionError/AssertionError.js'
 import * as CleanStack from '../CleanStack/CleanStack.js'
+import * as EncodingType from '../EncodingType/EncodingType.js'
 import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
 import * as JoinLines from '../JoinLines/JoinLines.js'
 import * as Json from '../Json/Json.js'
@@ -29,7 +31,7 @@ const prepareModuleNotFoundError = (error) => {
   }
   const notFoundModule = match[1]
   const importedFrom = match[2]
-  const rawLines = readFileSync(importedFrom, 'utf-8')
+  const rawLines = readFileSync(importedFrom, EncodingType.Utf8)
   let line = 0
   let column = 0
   const splittedLines = SplitLines.splitLines(rawLines)
@@ -59,6 +61,13 @@ const prepareModuleNotFoundError = (error) => {
   }
 }
 
+const getStackLinesToCut = (error) => {
+  if (error instanceof AssertionError) {
+    return 1
+  }
+  return 0
+}
+
 export const prepare = (error) => {
   if (error && error.code === ErrorCodes.ERR_MODULE_NOT_FOUND) {
     return prepareModuleNotFoundError(error)
@@ -70,9 +79,9 @@ export const prepare = (error) => {
       error = cause
     }
   }
-  const cleanedStack = CleanStack.cleanStack(error.stack)
-  const lines = SplitLines.splitLines(cleanedStack)
-  const file = lines[1]
+  const linesToCut = getStackLinesToCut(error)
+  const lines = CleanStack.cleanStack(error.stack).slice(linesToCut)
+  const file = lines[0]
   let codeFrame = ''
   if (error.codeFrame) {
     codeFrame = error.codeFrame
@@ -84,22 +93,22 @@ export const prepare = (error) => {
     if (match) {
       const [_, path, line, column] = match
       const actualPath = getActualPath(path)
-      const rawLines = readFileSync(actualPath, 'utf-8')
+      const rawLines = readFileSync(actualPath, EncodingType.Utf8)
       const location = {
         start: {
           line: Number.parseInt(line),
           column: Number.parseInt(column),
         },
       }
-
       codeFrame = codeFrameColumns(rawLines, location)
     }
   }
-  const relevantStack = JoinLines.joinLines(lines.slice(1))
+  const relevantStack = JoinLines.joinLines(lines)
   return {
     message,
     stack: relevantStack,
     codeFrame,
+    type: error.constructor.name,
   }
 }
 

package/src/parts/PrintPrettyError/PrintPrettyError.js

@@ -1,3 +1,5 @@
+import * as Logger from '../Logger/Logger.js'
+
 export const printPrettyError = (prettyError, prefix = '') => {
-  console.error(`${prefix}Error: ${prettyError.message}\n\n${prettyError.codeFrame}\n\n${prettyError.stack}`)
+  Logger.error(`${prefix}${prettyError.type}: ${prettyError.message}\n\n${prettyError.codeFrame}\n\n${prettyError.stack}\n`)
 }

package/src/parts/RecentlyOpened/RecentlyOpened.js

@@ -1,11 +1,11 @@
 import { dirname } from 'node:path'
-import VError from 'verror'
 import * as Assert from '../Assert/Assert.js'
-import { FileNotFoundError } from '../Error/FileNotFoundError.js'
+import { FileNotFoundError } from '../FileNotFoundError/FileNotFoundError.js'
 import * as FileSystem from '../FileSystem/FileSystem.js'
 import * as Json from '../Json/Json.js'
 import * as JsonFile from '../JsonFile/JsonFile.js'
 import * as Platform from '../Platform/Platform.js'
+import { VError } from '../VError/VError.js'
 
 const isValid = (recentlyOpened) => {
   return recentlyOpened && Array.isArray(recentlyOpened)
@@ -16,11 +16,7 @@ const addToArrayUnique = (recentlyOpened, path) => {
   if (index === -1) {
     return [path, ...recentlyOpened]
   }
-  return [
-    path,
-    ...recentlyOpened.slice(0, index),
-    ...recentlyOpened.slice(index + 1),
-  ]
+  return [path, ...recentlyOpened.slice(0, index), ...recentlyOpened.slice(index + 1)]
 }
 
 const getRecentlyOpened = async (recentlyOpenedPath) => {

package/src/parts/RequiresSocket/RequiresSocket.js

@@ -6,6 +6,7 @@ const METHODS_THAT_REQUIRE_SOCKET = new Set([
   'ExtensionHost.start',
   'ExtensionHost.send',
   'ExtensionHost.watchColorTheme',
+  'Terminal.create',
 ])
 
 export const requiresSocket = (method) => {

package/src/parts/RipGrep/RipGrep.js

@@ -1,7 +1,7 @@
 import * as NodeChildProcess from 'node:child_process'
 import * as Assert from '../Assert/Assert.js'
 import * as Exec from '../Exec/Exec.js'
-import * as RgPath from '../RgPath/RgPath.js'
+import * as RgPath from '../RipGrepPath/RipGrepPath.js'
 
 export const ripGrepPath = process.env.RIP_GREP_PATH || RgPath.rgPath
 

package/src/parts/SearchFile/SearchFile.js

@@ -1,22 +1,19 @@
 import * as Assert from '../Assert/Assert.js'
 import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+import * as IsEnoentErrorWindows from '../IsEnoentErrorWindows/IsEnoentErrorWindows.js'
 import * as LimitString from '../LimitString/LimitString.js'
-import * as RipGrep from '../RipGrep/RipGrep.js'
 import * as Logger from '../Logger/Logger.js'
+import * as RipGrep from '../RipGrep/RipGrep.js'
 
 const isEnoentErrorLinux = (error) => {
   return error.code === ErrorCodes.ENOENT
 }
 
-const isEnoentErrorWindows = (error) => {
-  return error.message.includes('The system cannot find the path specified.')
-}
-
 const isEnoentError = (error) => {
   if (!error) {
     return false
   }
-  return isEnoentErrorLinux(error) || isEnoentErrorWindows(error)
+  return isEnoentErrorLinux(error) || IsEnoentErrorWindows.isEnoentErrorWindows(error)
 }
 
 // TODO don't necessarily need ripgrep to list all the files,
@@ -37,9 +34,7 @@ export const searchFile = async (path, searchTerm, limit) => {
   } catch (error) {
     // @ts-ignore
     if (isEnoentError(error)) {
-      Logger.info(
-        `[shared-process] ripgrep could not be found at "${RipGrep.ripGrepPath}"`
-      )
+      Logger.info(`[shared-process] ripgrep could not be found at "${RipGrep.ripGrepPath}"`)
       return ``
     }
     // @ts-ignore

package/src/parts/Socket/Socket.js

@@ -1,6 +1,6 @@
-import VError from 'verror'
 import * as Command from '../Command/Command.js'
 import * as GetResponse from '../GetResponse/GetResponse.js'
+import { VError } from '../VError/VError.js'
 
 export const state = {
   /**
@@ -21,12 +21,7 @@ const handleMessage = async (event) => {
   const object = JSON.parse(event.data)
   if (object.id) {
     if (!object.params) {
-      console.warn(
-        '[shared-process] invalid message 1',
-        typeof object,
-        object.params,
-        object
-      )
+      console.warn('[shared-process] invalid message 1', typeof object, object.params, object)
       return
     }
     const response = await GetResponse.getResponse(object, state.socket)

package/src/parts/Terminal/Terminal.ipc.js

@@ -1,47 +1,10 @@
-import * as Command from '../Command/Command.js'
-import * as Assert from '../Assert/Assert.js'
 import * as Terminal from './Terminal.js'
 
-const create = (socket, id, cwd) => {
-  Assert.object(socket)
-  if (!socket) {
-    console.log({ socket, id, cwd })
-    console.warn('socket not available')
-    return
-  }
-  // terminalMap[id] = Terminal.create({
-  //   handleData(data) {
-  //     socket.send(
-  //       JSON.stringify({
-  //         jsonrpc: '2.0',
-  //         method: 2133,
-  //         params: ['Terminal', 'handleData', data],
-  //       })
-  //     )
-  //   },
-  //   cwd,
-  // })
-  Terminal.create(socket, id, cwd)
-}
-
-const write = (id, input) => {
-  console.log({ id, input })
-  Terminal.write(id, input)
-}
-
-const resize = (socket, id, columns, rows) => {
-  Terminal.resize(id, columns, rows)
-}
-
-const dispose = (socket, id) => {
-  Terminal.dispose(id)
-}
-
 export const name = 'Terminal'
 
 export const Commands = {
-  create: create,
-  dispose: dispose,
-  resize: resize,
-  write: write,
+  create: Terminal.create,
+  dispose: Terminal.dispose,
+  resize: Terminal.resize,
+  write: Terminal.write,
 }

package/src/parts/Terminal/Terminal.js

@@ -1,13 +1,14 @@
 import exitHook from 'exit-hook'
-import { ChildProcess, fork } from 'node:child_process'
 import * as Assert from '../Assert/Assert.js'
 import * as Debug from '../Debug/Debug.js'
-import * as PtyHostPath from '../PtyHostPath/PtyHostPath.js'
+import * as IpcParent from '../IpcParent/IpcParent.js'
+import * as IpcParentType from '../IpcParentType/IpcParentType.js'
 import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
+import * as PtyHostPath from '../PtyHostPath/PtyHostPath.js'
 
 export const state = {
   /**
-   * @type {ChildProcess|undefined}
+   * @type {any}
    */
   ptyHost: undefined,
   ptyHostState: /* None */ 0,
@@ -47,7 +48,13 @@ const handleProcessExit = () => {
 const createPtyHost = async () => {
   exitHook(handleProcessExit)
   const ptyHostPath = await PtyHostPath.getPtyHostPath()
-  const ptyHost = fork(ptyHostPath, { stdio: 'inherit' })
+  const ptyHost = await IpcParent.create({
+    method: IpcParentType.NodeForkedProcess,
+    path: ptyHostPath,
+    argv: ['--ipc-type=node-forked-process'],
+    stdio: 'inherit',
+    name: 'Terminal Process',
+  })
   return ptyHost
 }
 
@@ -70,26 +77,24 @@ export const create = async (socket, id, cwd) => {
     case /* None */ 0: {
       state.ptyHostState = /* Creating */ 1
       const ptyHost = await createPtyHost()
-      const handleFirstMessage = () => {
-        Debug.debug('pty host ready')
-        state.ptyHostState = /* Ready */ 2
-        const handleMessage = (message) => {
-          const data = message.params[1]
-          socket.send({
-            jsonrpc: JsonRpcVersion.Two,
-            method: 'Viewlet.send',
-            params: ['Terminal', 'handleData', data],
-          })
-        }
-        ptyHost.on('message', handleMessage)
-        state.send = (message) => {
-          ptyHost.send(message)
-        }
-        while (state.pendingMessages.length > 0) {
-          state.send(state.pendingMessages.shift())
-        }
+
+      Debug.debug('pty host ready')
+      state.ptyHostState = /* Ready */ 2
+      const handleMessage = (message) => {
+        const data = message.params[1]
+        socket.send({
+          jsonrpc: JsonRpcVersion.Two,
+          method: 'Viewlet.send',
+          params: ['Terminal', 'handleData', data],
+        })
+      }
+      ptyHost.on('message', handleMessage)
+      state.send = (message) => {
+        ptyHost.send(message)
+      }
+      while (state.pendingMessages.length > 0) {
+        state.send(state.pendingMessages.shift())
       }
-      ptyHost.once('message', handleFirstMessage)
       state.ptyHost = ptyHost
       break
     }
@@ -109,8 +114,7 @@ export const create = async (socket, id, cwd) => {
   })
   const handleClose = () => {
     if (state.ptyHost) {
-      state.ptyHost.removeAllListeners()
-      state.ptyHost.kill()
+      state.ptyHost.dispose()
       state.ptyHost = undefined
       state.ptyHostState = /* None */ 0
       state.send = (message) => {

package/src/parts/TextSearch/TextSearch.js

@@ -1,31 +1,12 @@
+import { Writable } from 'node:stream'
+import { pipeline } from 'node:stream/promises'
+import * as EncodingType from '../EncodingType/EncodingType.js'
+import * as GetNewLineIndex from '../GetNewLineIndex/GetNewLineIndex.js'
+import * as GetTextSearchRipGrepArgs from '../GetTextSearchRipGrepArgs/GetTextSearchRipGrepArgs.js'
 import * as RipGrep from '../RipGrep/RipGrep.js'
 import * as RipGrepParsedLineType from '../RipGrepParsedLineType/RipGrepParsedLineType.js'
 import * as TextSearchResultType from '../TextSearchResultType/TextSearchResultType.js'
-
-const MAX_SEARCH_RESULTS = 300
-
-const CHARS_BEFORE = 20
-const CHARS_AFTER = 50
-
-const toSearchResult = (parsedLine) => {
-  const results = []
-  const lines = parsedLine.data.lines.text
-  const lineNumber = parsedLine.data.line_number
-  for (const submatch of parsedLine.data.submatches) {
-    const previewStart = Math.max(submatch.start - CHARS_BEFORE, 0)
-    const previewEnd = Math.min(submatch.end + CHARS_AFTER, lines.length)
-    const previewText = lines.slice(previewStart, previewEnd)
-    results.push({
-      type: TextSearchResultType.Match,
-      start: submatch.start - previewStart,
-      end: submatch.end - previewStart,
-      lineNumber,
-      text: previewText,
-    })
-  }
-  return results
-}
-
+import * as ToTextSearchResult from '../ToTextSearchResult/ToTextSearchResult.js'
 // TODO update vscode-ripgrep when https://github.com/mhinz/vim-grepper/issues/244, https://github.com/BurntSushi/ripgrep/issues/1892 is fixed
 
 // need to use '.' as last argument for ripgrep
@@ -37,102 +18,115 @@ const toSearchResult = (parsedLine) => {
 // TODO update client
 // TODO not always run nice, maybe configure nice via flag/options
 
-export const search = async (searchDir, searchString, { threads = 1 } = {}) => {
-  // TODO reject promise when ripgrep search fails
-  return new Promise((resolve, reject) => {
-    const ripGrepArgs = [
-      '--smart-case',
-      '--stats',
-      '--json',
-      '--threads',
-      `${threads}`,
-      '--fixed-strings',
-      searchString,
-      '.',
-    ]
-    const childProcess = RipGrep.spawn(ripGrepArgs, {
-      cwd: searchDir,
-    })
-    const allSearchResults = Object.create(null)
-    let buffer = ''
-    let stats = {}
-    let limitHit = false
-    let numberOfResults = 0
-    // TODO use pipeline / transform stream maybe
+const collectStdout = async (childProcess, maxSearchResults) => {
+  const allSearchResults = Object.create(null)
+  let buffer = ''
+  let stats = {}
+  let limitHit = false
+  let numberOfResults = 0
 
-    const handleLine = (line) => {
-      const parsedLine = JSON.parse(line)
-      switch (parsedLine.type) {
-        case RipGrepParsedLineType.Begin:
-          allSearchResults[parsedLine.data.path.text] = [
-            {
-              type: TextSearchResultType.File,
-              start: 0,
-              end: 0,
-              lineNumber: 0,
-              text: parsedLine.data.path.text,
-            },
-          ]
-          break
-        case RipGrepParsedLineType.Match:
-          numberOfResults++
-          allSearchResults[parsedLine.data.path.text].push(
-            ...toSearchResult(parsedLine)
-          )
-          break
-        case RipGrepParsedLineType.Summary:
-          stats = parsedLine.data
-          break
-        default:
-          break
-      }
+  childProcess.stdout.setEncoding(EncodingType.Utf8)
+
+  const handleLine = (line) => {
+    const parsedLine = JSON.parse(line)
+    switch (parsedLine.type) {
+      case RipGrepParsedLineType.Begin:
+        allSearchResults[parsedLine.data.path.text] = [
+          {
+            type: TextSearchResultType.File,
+            start: 0,
+            end: 0,
+            lineNumber: 0,
+            text: parsedLine.data.path.text,
+          },
+        ]
+        break
+      case RipGrepParsedLineType.Match:
+        const remaining = maxSearchResults - numberOfResults
+        const matches = ToTextSearchResult.toTextSearchResult(parsedLine, remaining)
+        numberOfResults += matches.length
+        allSearchResults[parsedLine.data.path.text].push(...matches)
+        break
+      case RipGrepParsedLineType.Summary:
+        stats = parsedLine.data
+        break
+      default:
+        break
     }
+  }
 
-    let total = 0
-    const handleData = (chunk) => {
-      let newLineIndex = chunk.indexOf('\n')
-      const dataString = buffer + chunk
-      if (newLineIndex === -1) {
-        buffer = dataString
-        return
-      }
-      total += chunk.length
-      newLineIndex += buffer.length
-      let previousIndex = 0
-      while (newLineIndex >= 0) {
-        const line = dataString.slice(previousIndex, newLineIndex)
-        handleLine(line)
-        previousIndex = newLineIndex + 1
-        newLineIndex = dataString.indexOf('\n', previousIndex)
-      }
-      buffer = dataString.slice(previousIndex)
+  const handleData = (chunk) => {
+    let newLineIndex = GetNewLineIndex.getNewLineIndex(chunk)
+    const dataString = buffer + chunk
+    if (newLineIndex === -1) {
+      buffer = dataString
+      return
+    }
+    newLineIndex += buffer.length
+    let previousIndex = 0
+    while (newLineIndex >= 0) {
+      const line = dataString.slice(previousIndex, newLineIndex)
+      handleLine(line)
+      previousIndex = newLineIndex + 1
+      newLineIndex = GetNewLineIndex.getNewLineIndex(dataString, previousIndex)
+    }
+    buffer = dataString.slice(previousIndex)
 
-      if (numberOfResults > MAX_SEARCH_RESULTS) {
-        limitHit = true
-        childProcess.kill()
-      }
+    if (numberOfResults > maxSearchResults) {
+      limitHit = true
+      childProcess.kill()
     }
+  }
 
+  await pipeline(
+    childProcess.stdout,
+    new Writable({
+      decodeStrings: false,
+      construct(callback) {
+        callback()
+      },
+      write(chunk, encoding, callback) {
+        try {
+          handleData(chunk)
+          callback()
+        } catch (error) {
+          callback(error)
+        }
+      },
+    })
+  )
+  const results = Object.values(allSearchResults).flat(1)
+  return {
+    results,
+    stats,
+    limitHit,
+  }
+}
+
+export const search = async (searchDir, searchString, { threads = 1, maxSearchResults = 20_000, isCaseSensitive = false } = {}) => {
+  const ripGrepArgs = GetTextSearchRipGrepArgs.getRipGrepArgs({
+    threads,
+    isCaseSensitive,
+    searchString,
+  })
+  const childProcess = RipGrep.spawn(ripGrepArgs, {
+    cwd: searchDir,
+  })
+  const pipeLinePromise = collectStdout(childProcess, maxSearchResults)
+  const closePromise = new Promise((resolve, reject) => {
+    // TODO use pipeline / transform stream maybe
     const handleClose = () => {
-      const results = Object.values(allSearchResults).flat(1)
-      resolve({
-        results,
-        stats,
-        limitHit,
-      })
+      resolve(undefined)
     }
     const handleError = (error) => {
       // TODO check type of error
       console.error(error)
-      resolve({
-        results: [],
-        stats,
-        limitHit,
-      })
+      resolve(undefined)
     }
-    childProcess.stdout.setEncoding('utf8')
-    childProcess.stdout.on('data', handleData)
+
     childProcess.once('close', handleClose)
     childProcess.once('error', handleError)
   })
+  await Promise.all([pipeLinePromise, closePromise])
+  return await pipeLinePromise
 }

package/src/parts/ToAbsolutePaths/ToAbsolutePaths.js

@@ -0,0 +1,9 @@
+import * as Path from '../Path/Path.js'
+
+export const toAbsolutePaths = (path, dirents) => {
+  const absolutePaths = []
+  for (const dirent of dirents) {
+    absolutePaths.push(Path.join(path, dirent))
+  }
+  return absolutePaths
+}

package/src/parts/ToTextSearchResult/ToTextSearchResult.js

@@ -0,0 +1,42 @@
+import * as TextSearchResultType from '../TextSearchResultType/TextSearchResultType.js'
+
+const CHARS_BEFORE = 20
+const CHARS_AFTER = 50
+
+const getLines = (parsedLineData) => {
+  if (parsedLineData.lines.text) {
+    return parsedLineData.lines.text
+  }
+  if (parsedLineData.lines.bytes) {
+    return Buffer.from(parsedLineData.lines.bytes, 'base64').toString()
+  }
+  throw new Error(`unable to parse line data`)
+}
+
+const getRemainingSubMatches = (submatches, remaining) => {
+  if (submatches.length < remaining) {
+    return submatches
+  }
+  return submatches.slice(0, remaining)
+}
+
+export const toTextSearchResult = (parsedLine, remaining) => {
+  const results = []
+  const parsedLineData = parsedLine.data
+  const lines = getLines(parsedLineData)
+  const lineNumber = parsedLineData.line_number
+  const submatches = parsedLineData.submatches
+  for (const submatch of submatches) {
+    const previewStart = Math.max(submatch.start - CHARS_BEFORE, 0)
+    const previewEnd = Math.min(submatch.end + CHARS_AFTER, lines.length)
+    const previewText = lines.slice(previewStart, previewEnd)
+    results.push({
+      type: TextSearchResultType.Match,
+      start: submatch.start - previewStart,
+      end: submatch.end - previewStart,
+      lineNumber,
+      text: previewText,
+    })
+  }
+  return results
+}

package/src/parts/Trash/Trash.js

@@ -1,11 +1,10 @@
 import { default as _trash } from 'trash'
-import VError from 'verror'
+import { VError } from '../VError/VError.js'
 
 export const trash = async (path) => {
   try {
     await _trash(path)
   } catch (error) {
-    // @ts-ignore
     throw new VError(error, 'Failed to move item to trash')
   }
 }