npm - @lvce-editor/shared-process - Versions diffs - 0.11.6 → 0.11.8 - Mend

@lvce-editor/shared-process 0.11.6 → 0.11.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (40) hide show

package/src/parts/ExportStatic/ExportStatic.js CHANGED Viewed

@@ -637,11 +637,76 @@ const addExtension = async ({
   })
 }
+const generateTestOverviewHtml = (dirents) => {
+  const pre = `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Tests</title>
+  </head>
+  <body>
+    <h1>Tests</h1>
+    <p>Available Tests</p>
+    <ul>
+`
+  let middle = ``
+  // TODO properly escape name
+  for (const dirent of dirents) {
+    const name = dirent
+    middle += `      <li><a href="./${name}.html">${name}</a></li>
+`
+  }
+  const post = `    </ul>
+  </body>
+</html>
+`
+  return pre + middle + post
+}
+const getName = (name) => {
+  return name.slice(0, -'.js'.length)
+}
+const isTestFile = (file) => {
+  return file !== '_all.js'
+}
+const getTestFiles = (testFilesRaw) => {
+  return testFilesRaw.map(getName).filter(isTestFile)
+}
+const addTestFiles = async ({ testPath, commitHash, root, pathPrefix }) => {
+  await FileSystem.copy(
+    `${root}/${testPath}/src`,
+    `${root}/dist/${commitHash}/packages/extension-host-worker-tests/src`
+  )
+  const testFilesRaw = await FileSystem.readDir(`${root}/${testPath}/src`)
+  const testFiles = getTestFiles(testFilesRaw)
+  await FileSystem.mkdir(`${root}/dist/${commitHash}/tests`)
+  await FileSystem.mkdir(`${root}/dist/tests`)
+  console.log({ testFiles })
+  for (const testFile of testFiles) {
+    await FileSystem.copyFile(
+      `${root}/dist/index.html`,
+      `${root}/dist/tests/${testFile}.html`
+    )
+  }
+  const testOverviewHtml = generateTestOverviewHtml(testFiles)
+  await FileSystem.writeFile(`${root}/dist/tests/index.html`, testOverviewHtml)
+}
 /**
  *
- * @param {{root:string, pathPrefix:string , extensionPath:string  }} param0
+ * @param {{root:string, pathPrefix:string , extensionPath:string, testPath:string   }} param0
  */
-export const exportStatic = async ({ root, pathPrefix, extensionPath }) => {
+export const exportStatic = async ({
+  root,
+  pathPrefix,
+  extensionPath,
+  testPath,
+}) => {
   if (pathPrefix === 'auto') {
     const extensionJson = await readExtensionManifest(
       Path.join(extensionPath, 'extension.json')
@@ -679,4 +744,15 @@ export const exportStatic = async ({ root, pathPrefix, extensionPath }) => {
     root,
   })
   console.timeEnd('addExtension')
+  if (testPath) {
+    console.time('addTestFiles')
+    await addTestFiles({
+      testPath,
+      commitHash,
+      pathPrefix,
+      root,
+    })
+    console.timeEnd('addTestFiles')
+  }
 }

package/src/parts/ExtensionLink/ExtensionLink.js CHANGED Viewed

@@ -1,11 +1,11 @@
-import VError from 'verror'
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
 import * as ExtensionManifest from '../ExtensionManifest/ExtensionManifest.js'
 import * as ExtensionManifestStatus from '../ExtensionManifestStatus/ExtensionManifestStatus.js'
 import * as FileSystem from '../FileSystem/FileSystem.js'
-import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
 import * as Path from '../Path/Path.js'
 import * as Platform from '../Platform/Platform.js'
 import * as SymLink from '../SymLink/SymLink.js'
+import { VError } from '../VError/VError.js'
 const linkFallBack = async (path) => {
   try {
@@ -19,7 +19,6 @@ const linkFallBack = async (path) => {
     await FileSystem.remove(to)
     await SymLink.createSymLink(path, to)
   } catch (error) {
-    console.log({ error })
     throw new VError(error, `Failed to link extension`)
   }
 }

package/src/parts/ExtensionManagement/ExtensionManagement.js CHANGED Viewed

@@ -1,5 +1,5 @@
 import { mkdir, rename, rm } from 'node:fs/promises'
-import VError from 'verror'
+import { VError } from '../VError/VError.js'
 import * as Debug from '../Debug/Debug.js'
 import * as ExtensionManifestInputType from '../ExtensionManifestInputType/ExtensionManifestInputType.js'
 import * as ExtensionManifests from '../ExtensionManifests/ExtensionManifests.js'

package/src/parts/ExtensionManifest/ExtensionManifest.js CHANGED Viewed

@@ -1,9 +1,9 @@
 import isObject from 'is-object'
-import VError from 'verror'
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
 import * as ExtensionManifestStatus from '../ExtensionManifestStatus/ExtensionManifestStatus.js'
 import * as ReadJson from '../JsonFile/JsonFile.js'
 import * as Path from '../Path/Path.js'
-import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+import { VError } from '../VError/VError.js'
 const RE_EXTENSION_FRAGMENT = /.+(\/|\\)(.+)$/

package/src/parts/GetResponse/GetResponse.js CHANGED Viewed

@@ -7,8 +7,8 @@ import { requiresSocket } from '../RequiresSocket/RequiresSocket.js'
 export const getResponse = async (message, handle) => {
   try {
     const result = requiresSocket(message.method)
-      ? await Command.invoke(message.method, handle, ...message.params)
-      : await Command.invoke(message.method, ...message.params)
+      ? await Command.execute(message.method, handle, ...message.params)
+      : await Command.execute(message.method, ...message.params)
     return {
       jsonrpc: JsonRpc.Version,

package/src/parts/Module/Module.js CHANGED Viewed

@@ -28,14 +28,14 @@ export const load = (moduleId) => {
       return import('../Preferences/Preferences.ipc.js')
     case ModuleId.RecentlyOpened:
       return import('../RecentlyOpened/RecentlyOpened.ipc.js')
-    case ModuleId.Search:
-      return import('../Search/Search.ipc.js')
     case ModuleId.SearchFile:
       return import('../SearchFile/SearchFile.ipc.js')
     case ModuleId.Terminal:
       return import('../Terminal/Terminal.ipc.js')
     case ModuleId.TextDocument:
       return import('../TextDocument/TextDocument.ipc.js')
+    case ModuleId.Search:
+      return import('../TextSearch/TextSearch.ipc.js')
     case ModuleId.WebSocketServer:
       return import('../WebSocketServer/WebSocketServer.ipc.js')
     case ModuleId.Workspace:

package/src/parts/ModuleMap/ModuleMap.js CHANGED Viewed

@@ -120,7 +120,7 @@ export const getModuleId = (commandId) => {
       return ModuleId.Preferences
     case 'RecentlyOpened.addPath':
       return ModuleId.RecentlyOpened
-    case 'Search.search':
+    case 'TextSearch.search':
       return ModuleId.Search
     case 'SearchFile.searchFile':
       return ModuleId.SearchFile

package/src/parts/PrettyError/PrettyError.js CHANGED Viewed

@@ -3,6 +3,8 @@ import cleanStack from 'clean-stack'
 import { LinesAndColumns } from 'lines-and-columns'
 import { readFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+import * as Json from '../Json/Json.js'
 import * as SplitLines from '../SplitLines/SplitLines.js'
 const getActualPath = (fileUri) => {
@@ -12,7 +14,59 @@ const getActualPath = (fileUri) => {
   return fileUri
 }
+const RE_MODULE_NOT_FOUND_STACK =
+  /Cannot find package '([^']+)' imported from (.+)$/
+const prepareModuleNotFoundError = (error) => {
+  const message = error.message
+  const match = message.match(RE_MODULE_NOT_FOUND_STACK)
+  if (!match) {
+    return {
+      message,
+      stack: error.stack,
+      codeFrame: '',
+    }
+  }
+  const notFoundModule = match[1]
+  const importedFrom = match[2]
+  const rawLines = readFileSync(importedFrom, 'utf-8')
+  let line = 0
+  let column = 0
+  const splittedLines = rawLines.split('\n')
+  for (let i = 0; i < splittedLines.length; i++) {
+    const splittedLine = splittedLines[i]
+    const index = splittedLine.indexOf(notFoundModule)
+    if (index !== -1) {
+      line = i + 1
+      column = index
+      break
+    }
+  }
+  const location = {
+    start: {
+      line,
+      column,
+    },
+  }
+  const codeFrame = codeFrameColumns(rawLines, location)
+  const stackLines = SplitLines.splitLines(error.stack)
+  const newStackLines = [
+    stackLines[0],
+    `    at ${importedFrom}:${line}:${column}`,
+    ...stackLines.slice(1),
+  ]
+  const newStack = newStackLines.join('\n')
+  return {
+    message,
+    stack: newStack,
+    codeFrame,
+  }
+}
 export const prepare = (error) => {
+  if (error && error.code === ErrorCodes.ERR_MODULE_NOT_FOUND) {
+    return prepareModuleNotFoundError(error)
+  }
   const message = error.message
   if (error && error.cause) {
     const cause = error.cause()
@@ -57,12 +111,8 @@ const fixBackslashes = (string) => {
   return string.replaceAll('\\\\', '\\')
 }
-const stringifyJson = (json) => {
-  return JSON.stringify(json, null, 2) + '\n'
-}
 export const prepareJsonError = (json, property, message) => {
-  const string = fixBackslashes(stringifyJson(json))
+  const string = fixBackslashes(Json.stringify(json))
   const stringifiedPropertyName = `"${property}"`
   const index = string.indexOf(stringifiedPropertyName) // TODO this could be wrong in some cases, find a better way
   console.log({ string, index })

package/src/parts/RipGrep/RipGrep.js ADDED Viewed

@@ -0,0 +1,30 @@
+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'
+export const ripGrepPath = process.env.RIP_GREP_PATH || RgPath.rgPath
+export const spawn = (args, options) => {
+  const childProcess = NodeChildProcess.spawn(RgPath.rgPath, args, options)
+  return {
+    on(event, listener) {
+      childProcess.on(event, listener)
+    },
+    once(event, listener) {
+      childProcess.once(event, listener)
+    },
+    stdout: childProcess.stdout,
+    stderr: childProcess.stderr,
+    kill() {
+      childProcess.kill()
+    },
+  }
+}
+export const exec = async (args, options) => {
+  Assert.array(args)
+  Assert.object(options)
+  const { stdout, stderr } = await Exec.exec(ripGrepPath, args, options)
+  return { stdout, stderr }
+}

package/src/parts/SearchFile/SearchFile.js CHANGED Viewed

@@ -1,10 +1,8 @@
 import * as Assert from '../Assert/Assert.js'
 import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
-import * as Exec from '../Exec/Exec.js'
 import * as LimitString from '../LimitString/LimitString.js'
-import * as RgPath from '../RgPath/RgPath.js'
-const ripGrepPath = process.env.RIP_GREP_PATH || RgPath.rgPath
+import * as RipGrep from '../RipGrep/RipGrep.js'
+import * as Logger from '../Logger/Logger.js'
 const isEnoentErrorLinux = (error) => {
   return error.code === ErrorCodes.ENOENT
@@ -32,25 +30,23 @@ export const searchFile = async (path, searchTerm, limit) => {
     Assert.string(path)
     Assert.string(searchTerm)
     Assert.number(limit)
-    const { stdout, stderr } = await Exec.exec(
-      ripGrepPath,
-      ['--files', '--sort-files'],
-      {
-        cwd: path,
-      }
-    )
+    const { stdout, stderr } = await RipGrep.exec(['--files', '--sort-files'], {
+      cwd: path,
+    })
     return LimitString.limitString(stdout, limit)
   } catch (error) {
     // @ts-ignore
     if (isEnoentError(error)) {
-      console.info(`[info] ripgrep could not be found at "${ripGrepPath}"`)
-      return []
+      Logger.info(
+        `[shared-process] ripgrep could not be found at "${RipGrep.ripGrepPath}"`
+      )
+      return ``
     }
     // @ts-ignore
     if (error && error.stderr === '') {
-      return []
+      return ``
     }
-    console.error(error)
-    return []
+    Logger.error(error)
+    return ``
   }
 }

package/src/parts/TextSearch/TextSearch.ipc.js ADDED Viewed

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

package/src/parts/TextSearch/TextSearch.js ADDED Viewed

@@ -0,0 +1,138 @@
+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
+}
+// 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 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 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
+      }
+    }
+    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)
+      if (numberOfResults > MAX_SEARCH_RESULTS) {
+        limitHit = true
+        childProcess.kill()
+      }
+    }
+    const handleClose = () => {
+      const results = Object.values(allSearchResults).flat(1)
+      resolve({
+        results,
+        stats,
+        limitHit,
+      })
+    }
+    const handleError = (error) => {
+      // TODO check type of error
+      console.error(error)
+      resolve({
+        results: [],
+        stats,
+        limitHit,
+      })
+    }
+    childProcess.stdout.setEncoding('utf8')
+    childProcess.stdout.on('data', handleData)
+    childProcess.once('close', handleClose)
+    childProcess.once('error', handleError)
+  })
+}

package/src/parts/TextSearchResultType/TextSearchResultType.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export const File = 1
2	+ export const Match = 2

package/src/parts/VError/VError.js ADDED Viewed

@@ -0,0 +1,44 @@
+const getCombinedMessage = (error, message) => {
+  let stringifiedError = `${error}`
+  if (stringifiedError.startsWith('Error: ')) {
+    stringifiedError = stringifiedError.slice(`Error: `.length)
+  } else if (stringifiedError.startsWith('VError: ')) {
+    stringifiedError = stringifiedError.slice(`VError: `.length)
+  }
+  if (message) {
+    return `${message}: ${stringifiedError}`
+  }
+  return stringifiedError
+}
+const mergeStacks = (parent, child) => {
+  if (!child) {
+    return parent
+  }
+  const parentNewLineIndex = parent.indexOf('\n')
+  const childNewLineIndex = child.indexOf('\n')
+  const parentFirstLine = parent.slice(0, parentNewLineIndex)
+  const childRest = child.slice(childNewLineIndex)
+  const childFirstLine = child.slice(0, childNewLineIndex)
+  if (parentFirstLine.includes(childFirstLine)) {
+    return parentFirstLine + childRest
+  }
+  return child
+}
+export class VError extends Error {
+  constructor(error, message) {
+    const combinedMessage = getCombinedMessage(error, message)
+    super(combinedMessage)
+    this.name = 'VError'
+    if (error instanceof Error) {
+      this.stack = mergeStacks(this.stack, error.stack)
+    }
+    if (error.codeFrame) {
+      this.codeFrame = error.codeFrame
+    }
+    if (error.code) {
+      this.code = error.code
+    }
+  }
+}

package/src/parts/Search/Search.ipc.js DELETED Viewed

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

package/src/parts/Search/Search.js DELETED Viewed

@@ -1,107 +0,0 @@
-import { spawn } from 'node:child_process'
-import * as Platform from '../Platform/Platform.js'
-import * as RgPath from '../RgPath/RgPath.js'
-import * as RipGrepParsedLineType from '../RipGrepParsedLineType/RipGrepParsedLineType.js'
-import * as SplitLines from '../SplitLines/SplitLines.js'
-const MAX_SEARCH_RESULTS = 300
-const toSearchResult = (parsedLine) => {
-  return {
-    preview: parsedLine.data.lines.text,
-    absoluteOffset: parsedLine.data.absolute_offset,
-    lineNumber: parsedLine.data.line_number - 1,
-  }
-}
-// 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 no function call at toplevel!
-const useNice = !Platform.isWindows
-// TODO stats flag might not be necessary
-// TODO update client
-// TODO not always run nice, maybe configure nice via flag/options
-export const search = async (searchDir, searchString) => {
-  // TODO reject promise when ripgrep search fails
-  return new Promise((resolve, reject) => {
-    const ripGrepArgs = [
-      '--smart-case',
-      '--stats',
-      '--json',
-      '--fixed-strings',
-      searchString,
-      '.',
-    ]
-    const childProcess = useNice
-      ? spawn('nice', ['-20', RgPath.rgPath, ...ripGrepArgs], {
-          cwd: searchDir,
-        })
-      : spawn(RgPath.rgPath, 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 handleData = (chunk) => {
-      buffer += chunk
-      const lines = SplitLines.splitLines(buffer)
-      // @ts-ignore
-      buffer = lines.pop()
-      for (const line of lines) {
-        const parsedLine = JSON.parse(line)
-        console.log(parsedLine)
-        switch (parsedLine.type) {
-          case RipGrepParsedLineType.Begin: {
-            allSearchResults[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
-        }
-      }
-      if (numberOfResults > MAX_SEARCH_RESULTS) {
-        limitHit = true
-        childProcess.kill()
-      }
-    }
-    const handleClose = () => {
-      resolve({
-        results: Object.entries(allSearchResults),
-        stats,
-        limitHit,
-      })
-    }
-    const handleError = (error) => {
-      // TODO check type of error
-      console.error(error)
-      resolve({
-        results: [],
-        stats,
-        limitHit,
-      })
-    }
-    childProcess.stdout.on('data', handleData)
-    childProcess.once('close', handleClose)
-    childProcess.once('error', handleError)
-  })
-}