@lvce-editor/shared-process 0.16.3 → 0.16.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.16.3",
+  "version": "0.16.4",
   "description": "Utility package for @lvce-editor/server",
   "main": "index.js",
   "type": "module",
@@ -17,9 +17,9 @@
   },
   "dependencies": {
     "@babel/code-frame": "^7.22.5",
-    "@lvce-editor/extension-host": "0.16.3",
-    "@lvce-editor/extension-host-helper-process": "0.16.3",
-    "@lvce-editor/pty-host": "0.16.3",
+    "@lvce-editor/extension-host": "0.16.4",
+    "@lvce-editor/extension-host-helper-process": "0.16.4",
+    "@lvce-editor/pty-host": "0.16.4",
     "debug": "^4.3.4",
     "execa": "^7.1.1",
     "exit-hook": "^3.2.0",

package/src/parts/CollectTextSearchStdout/CollectTextSearchStdout.js

@@ -0,0 +1,103 @@
+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 RipGrepParsedLineType from '../RipGrepParsedLineType/RipGrepParsedLineType.js'
+import * as TextSearchResultType from '../TextSearchResultType/TextSearchResultType.js'
+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
+// issue 1 https://github.com/nvim-telescope/telescope.nvim/pull/908/files
+// issue 2 https://github.com/BurntSushi/ripgrep/issues/1892
+// remove workaround when ripgrep is fixed
+
+// TODO stats flag might not be necessary
+// TODO update client
+// TODO not always run nice, maybe configure nice via flag/options
+
+export const collectStdout = async (childProcess, maxSearchResults, charsBefore, charsAfter) => {
+  const allSearchResults = Object.create(null)
+  let buffer = ''
+  let stats = {}
+  let limitHit = false
+  let numberOfResults = 0
+
+  childProcess.stdout.setEncoding(EncodingType.Utf8)
+
+  const handleLine = (line) => {
+    const parsedLine = JSON.parse(line)
+    const { type, data } = parsedLine
+    switch (type) {
+      case RipGrepParsedLineType.Begin:
+        allSearchResults[data.path.text] = [
+          {
+            type: TextSearchResultType.File,
+            start: 0,
+            end: 0,
+            lineNumber: 0,
+            text: data.path.text,
+          },
+        ]
+        break
+      case RipGrepParsedLineType.Match:
+        const remaining = maxSearchResults - numberOfResults
+        const matches = ToTextSearchResult.toTextSearchResult(parsedLine, remaining, charsBefore, charsAfter)
+        numberOfResults += matches.length
+        allSearchResults[data.path.text].push(...matches)
+        break
+      case RipGrepParsedLineType.Summary:
+        stats = data
+        break
+      default:
+        break
+    }
+  }
+
+  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 > 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,
+  }
+}

package/src/parts/IncrementalTextSearch/IncrementalTextSearch.js

@@ -0,0 +1,49 @@
+import * as RipGrep from '../RipGrep/RipGrep.js'
+
+const connectProcess = (ipc, id, childProcess) => {
+  let count = 0
+  const cleanup = () => {
+    childProcess.kill()
+  }
+  childProcess.stdout.on('data', (data) => {
+    count++
+    if (count > 20) {
+      cleanup()
+      return
+    }
+    // console.log({ data: data.toString() })
+    ipc.send({
+      jsonrpc: '2.0',
+      method: 'IncrementalTextSearch.handleData',
+      params: [id, data.toString()],
+    })
+    // emitter.dispatchEvent(new Event('data', x))
+  })
+
+  childProcess.on('exit', () => {
+    ipc.send({
+      jsonrpc: '2.0',
+      method: 'IncrementalTextSearch.handleExit',
+      params: [id],
+    })
+    // emitter.dispatchEvent(new Event('exit'))
+  })
+  childProcess.on('error', () => {
+    ipc.send({
+      jsonrpc: '2.0',
+      method: 'IncrementalTextSearch.handleError',
+      params: [id],
+    })
+    // emitter.dispatchEvent(new Event('error'))
+  })
+}
+
+export const start = async (ipc, id, { searchDir = '', maxSearchResults = 20_000, ripGrepArgs = [] } = {}) => {
+  console.log({ ipc })
+  const emitter = new EventTarget()
+  const childProcess = RipGrep.spawn(ripGrepArgs, {
+    cwd: searchDir,
+  })
+  console.log('start', { searchDir, ripGrepArgs, id })
+  connectProcess(ipc, id, childProcess)
+}

package/src/parts/IncrementalTextSearch/IncremetalTextSearch.ipc.js

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

package/src/parts/LeftCut/LeftCut.js

@@ -0,0 +1,20 @@
+const RE_WORD = /\b/g
+
+export const leftCut = (text, final, charsBefore) => {
+  if (text.length < charsBefore) {
+    return text.length
+  }
+  let i = 0
+  while (RE_WORD.test(text)) {
+    if (final - RE_WORD.lastIndex < charsBefore) {
+      break
+    }
+    i = RE_WORD.lastIndex
+    RE_WORD.lastIndex++
+  }
+  RE_WORD.lastIndex = 0
+  if (final - i > charsBefore + 10) {
+    return final - charsBefore
+  }
+  return i
+}

package/src/parts/Module/Module.js

@@ -72,6 +72,8 @@ export const load = (moduleId) => {
       return import('../HandleCliArgs/HandleCliArgs.ipc.js')
     case ModuleId.ListProcessesWithMemoryUsage:
       return import('../ListProcessesWithMemoryUsage/ListProcessesWithMemoryUsage.ipc.js')
+    case ModuleId.IncrementalTextSearch:
+      return import('../IncrementalTextSearch/IncremetalTextSearch.ipc.js')
     default:
       throw new Error(`module ${moduleId} not found`)
   }

package/src/parts/ModuleId/ModuleId.js

@@ -33,3 +33,4 @@ export const HandleNodeMessagePort = 32
 export const GetTerminalSpawnOptions = 33
 export const HandleCliArgs = 34
 export const ListProcessesWithMemoryUsage = 35
+export const IncrementalTextSearch = 36

package/src/parts/ModuleMap/ModuleMap.js

@@ -185,6 +185,8 @@ export const getModuleId = (commandId) => {
       return ModuleId.HandleCliArgs
     case 'ListProcessesWithMemoryUsage.listProcessesWithMemoryUsage':
       return ModuleId.ListProcessesWithMemoryUsage
+    case 'IncrementalTextSearch.start':
+      return ModuleId.IncrementalTextSearch
     default:
       throw new CommandNotFoundError(commandId)
   }

package/src/parts/ParseRipGrepLines/ParseRipGrepLines.js

@@ -0,0 +1,11 @@
+import * as EncodingType from '../EncodingType/EncodingType.js'
+
+export const parseRipGrepLines = (parsedLineData) => {
+  if (parsedLineData.lines.text) {
+    return parsedLineData.lines.text
+  }
+  if (parsedLineData.lines.bytes) {
+    return Buffer.from(parsedLineData.lines.bytes, EncodingType.Base64).toString()
+  }
+  throw new Error(`unable to parse line data`)
+}

package/src/parts/Platform/Platform.js

@@ -165,11 +165,11 @@ export const getSetupName = () => {
   return 'Lvce-Setup'
 }
 
-export const version = '0.16.3'
+export const version = '0.16.4'
 
-export const commit = '6fbd9fc'
+export const commit = '4ec07e5'
 
-export const date = '2023-07-04T07:58:24.000Z'
+export const date = '2023-07-04T18:03:04.000Z'
 
 export const getVersion = () => {
   return version

package/src/parts/RequiresSocket/RequiresSocket.js

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

package/src/parts/TextSearch/TextSearch.js

@@ -1,14 +1,9 @@
-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 CollectTextSearchStdout from '../CollectTextSearchStdout/CollectTextSearchStdout.js'
 import * as ProcessExitEventType from '../ProcessExitEventType/ProcessExitEventType.js'
 import * as RipGrep from '../RipGrep/RipGrep.js'
-import * as RipGrepParsedLineType from '../RipGrepParsedLineType/RipGrepParsedLineType.js'
 import { TextSearchError } from '../TextSearchError/TextSearchError.js'
-import * as TextSearchResultType from '../TextSearchResultType/TextSearchResultType.js'
-import * as ToTextSearchResult from '../ToTextSearchResult/ToTextSearchResult.js'
 import * as WaitForProcessToExit from '../WaitForProcessToExit/WaitForProcessToExit.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
@@ -20,98 +15,13 @@ import * as WaitForProcessToExit from '../WaitForProcessToExit/WaitForProcessToE
 // TODO update client
 // TODO not always run nice, maybe configure nice via flag/options
 
-const collectStdout = async (childProcess, maxSearchResults, charsBefore, charsAfter) => {
-  const allSearchResults = Object.create(null)
-  let buffer = ''
-  let stats = {}
-  let limitHit = false
-  let numberOfResults = 0
-
-  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, charsBefore, charsAfter)
-        numberOfResults += matches.length
-        allSearchResults[parsedLine.data.path.text].push(...matches)
-        break
-      case RipGrepParsedLineType.Summary:
-        stats = parsedLine.data
-        break
-      default:
-        break
-    }
-  }
-
-  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 > 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 = '', maxSearchResults = 20_000, ripGrepArgs = [] } = {}) => {
   const charsBefore = 26
   const charsAfter = 50
   const childProcess = RipGrep.spawn(ripGrepArgs, {
     cwd: searchDir,
   })
-  const pipeLinePromise = collectStdout(childProcess, maxSearchResults, charsBefore, charsAfter)
+  const pipeLinePromise = CollectTextSearchStdout.collectStdout(childProcess, maxSearchResults, charsBefore, charsAfter)
   const closePromise = WaitForProcessToExit.waitForProcessToExit(childProcess)
   const [pipeLineResult, exitResult] = await Promise.all([pipeLinePromise, closePromise])
   if (exitResult.type === ProcessExitEventType.Error) {

package/src/parts/ToTextSearchResult/ToTextSearchResult.js

@@ -1,57 +1,16 @@
-import * as EncodingType from '../EncodingType/EncodingType.js'
+import * as ParseRipGrepLines from '../ParseRipGrepLines/ParseRipGrepLines.js'
 import * as TextSearchResultType from '../TextSearchResultType/TextSearchResultType.js'
 
-const getLines = (parsedLineData) => {
-  if (parsedLineData.lines.text) {
-    return parsedLineData.lines.text
-  }
-  if (parsedLineData.lines.bytes) {
-    return Buffer.from(parsedLineData.lines.bytes, EncodingType.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)
-}
-
-const RE_WORD = /\b/g
-
-const leftCut = (text, final, charsBefore) => {
-  if (text.length < charsBefore) {
-    return text.length
-  }
-  let i = 0
-  while (RE_WORD.test(text)) {
-    if (final - RE_WORD.lastIndex < charsBefore) {
-      break
-    }
-    i = RE_WORD.lastIndex
-    RE_WORD.lastIndex++
-  }
-  RE_WORD.lastIndex = 0
-  if (final - i > charsBefore + 10) {
-    return final - charsBefore
-  }
-  return i
-}
-
 export const toTextSearchResult = (parsedLine, remaining, charsBefore, charsAfter) => {
   const results = []
   const parsedLineData = parsedLine.data
-  const lines = getLines(parsedLineData)
+  const lines = ParseRipGrepLines.parseRipGrepLines(parsedLineData)
   const lineNumber = parsedLineData.line_number
   const submatches = parsedLineData.submatches
   const linesLength = lines.length
   for (const submatch of submatches) {
     const previewStart = Math.max(submatch.start - charsBefore, 0)
     let actualStart = previewStart
-    if (actualStart > 0) {
-      actualStart = leftCut(lines, submatch.start, charsBefore)
-    }
     const previewEnd = Math.min(submatch.end + charsAfter, linesLength)
     const previewText = lines.slice(actualStart, previewEnd)
     results.push({