@lvce-editor/shared-process 0.13.0 → 0.14.1

package/src/parts/Jsonc/Jsonc.js

@@ -0,0 +1,304 @@
+import * as CharCode from '../JsoncCharCode/JsoncCharCode.js'
+import * as TokenType from '../JsoncTokenType/JsoncTokenType.js'
+
+const createScanner = (text) => {
+  let offset = 0
+  const length = text.length
+
+  const scanValue = () => {
+    while (offset < length) {
+      const code = text.charCodeAt(offset)
+      switch (code) {
+        case CharCode.CurlyOpen:
+          offset++
+          return TokenType.CurlyOpen
+        case CharCode.CurlyClose:
+          offset++
+          return TokenType.CurlyClose
+        case CharCode.SquareOpen:
+          offset++
+          return TokenType.SquareOpen
+        case CharCode.SquareClose:
+          offset++
+          return TokenType.SquareClose
+        case CharCode.DoubleQuote:
+          offset++
+          return TokenType.DoubleQuote
+        case CharCode.Comma:
+          text.slice(offset) //?
+          offset++
+          return TokenType.Comma
+        case CharCode.Zero:
+        case CharCode.One:
+        case CharCode.Two:
+        case CharCode.Three:
+        case CharCode.Four:
+        case CharCode.Five:
+        case CharCode.Six:
+        case CharCode.Seven:
+        case CharCode.Eight:
+        case CharCode.Nine:
+        case CharCode.Dot:
+          offset++
+          return TokenType.Numeric
+        case CharCode.CarriageReturn:
+        case CharCode.LineFeed:
+        case CharCode.Tab:
+        case CharCode.Space:
+          offset++
+          break
+        case CharCode.Slash:
+          return TokenType.Slash
+        default:
+          return TokenType.Literal
+      }
+    }
+    return TokenType.Eof
+  }
+
+  const scanString = () => {
+    while (offset < length) {
+      const code = text.charCodeAt(offset)
+      if (code === CharCode.DoubleQuote) {
+        break
+      }
+      offset++
+    }
+    offset++
+    const start = offset
+    while (offset < length) {
+      const code = text.charCodeAt(offset)
+      if (code === CharCode.DoubleQuote) {
+        break
+      }
+      offset++
+    }
+    const result = text.slice(start, offset)
+    offset++
+    return result
+  }
+
+  const scanPropertyName = () => {
+    return scanString()
+  }
+
+  const scanPropertyColon = () => {
+    const code = text.charCodeAt(offset)
+    offset++
+  }
+
+  const goBack = (delta) => {
+    offset -= delta
+  }
+
+  const scanNumber = () => {
+    const start = offset
+    outer: while (offset < length) {
+      const code = text.charCodeAt(offset)
+      switch (code) {
+        case CharCode.Zero:
+        case CharCode.One:
+        case CharCode.Two:
+        case CharCode.Three:
+        case CharCode.Four:
+        case CharCode.Five:
+        case CharCode.Six:
+        case CharCode.Seven:
+        case CharCode.Eight:
+        case CharCode.Nine:
+        case CharCode.Dot:
+          break
+        default:
+          break outer
+      }
+      offset++
+    }
+    const result = text.slice(start, offset)
+    result
+    return result
+  }
+
+  const scanLiteral = () => {
+    const start = offset
+    outer: while (offset < length) {
+      const code = text.charCodeAt(offset)
+      switch (code) {
+        case CharCode.LineFeed:
+        case CharCode.CarriageReturn:
+        case CharCode.Tab:
+        case CharCode.Space:
+        case CharCode.Comma:
+          break outer
+        default:
+          break
+      }
+      offset++
+    }
+    const result = text.slice(start, offset)
+    return result
+  }
+
+  const scanBlockComment = () => {
+    while (offset < length) {
+      if (text.charCodeAt(offset) === CharCode.Star && text.charCodeAt(offset + 1) === CharCode.Slash) {
+        break
+      }
+      offset++
+    }
+  }
+
+  const scanLineComment = () => {
+    while (offset < length) {
+      const code = text.charCodeAt(offset)
+      if (code === CharCode.LineFeed) {
+        break
+      }
+      offset++
+    }
+  }
+
+  const scanComment = () => {
+    const code = text.charCodeAt(offset)
+    switch (code) {
+      case CharCode.Star:
+        return scanBlockComment()
+      case CharCode.Slash:
+        return scanLineComment()
+      default:
+        break
+    }
+  }
+
+  return {
+    scanValue,
+    scanPropertyName,
+    scanPropertyColon,
+    scanString,
+    scanNumber,
+    goBack,
+    scanLiteral,
+    scanComment,
+    getOffset() {
+      return offset
+    },
+  }
+}
+
+const parsePropertyName = (scanner) => {
+  const propertyName = scanner.scanPropertyName()
+  return propertyName
+}
+
+const parsePropertyColon = (scanner) => {
+  scanner.scanPropertyColon()
+}
+
+const parseNumber = (scanner) => {
+  scanner.goBack(1)
+  const rawValue = scanner.scanNumber()
+  const value = parseFloat(rawValue)
+  return value
+}
+
+const parseObject = (scanner) => {
+  const object = {}
+  outer: while (true) {
+    const token = scanner.scanValue()
+    switch (token) {
+      case TokenType.Eof:
+      case TokenType.None:
+      case TokenType.CurlyClose:
+        break outer
+      case TokenType.DoubleQuote:
+        scanner.goBack(1)
+        const propertyName = parsePropertyName(scanner)
+        parsePropertyColon(scanner)
+        const value = parseValue(scanner)
+        object[propertyName] = value
+      case TokenType.Comma:
+        break
+      case TokenType.Slash:
+        parseComment(scanner)
+        break
+      default:
+        break
+    }
+  }
+  return object
+}
+
+const parseString = (scanner) => {
+  scanner.goBack(1)
+  const value = scanner.scanString()
+  return value
+}
+
+const parseArray = (scanner) => {
+  const array = []
+  outer: while (true) {
+    const token = scanner.scanValue()
+    switch (token) {
+      case TokenType.Eof:
+      case TokenType.None:
+      case TokenType.SquareClose:
+        break outer
+      case TokenType.Slash:
+        scanner.scanComment()
+        break
+      default:
+        scanner.goBack(1)
+        const value = parseValue(scanner)
+        array.push(value)
+        break
+      case TokenType.Comma:
+        break
+    }
+  }
+  return array
+}
+
+const parseLiteral = (scanner) => {
+  const rawValue = scanner.scanLiteral()
+  switch (rawValue) {
+    case 'true':
+      return true
+    case 'false':
+      return false
+    case 'null':
+      return null
+    default:
+      return undefined
+  }
+}
+
+const parseComment = (scanner) => {
+  scanner.scanComment()
+}
+
+const parseValue = (scanner) => {
+  const token = scanner.scanValue()
+  switch (token) {
+    case TokenType.CurlyOpen:
+      return parseObject(scanner)
+    case TokenType.DoubleQuote:
+      return parseString(scanner)
+    case TokenType.Numeric:
+      return parseNumber(scanner)
+    case TokenType.SquareOpen:
+      return parseArray(scanner)
+    case TokenType.Literal:
+      return parseLiteral(scanner)
+    case TokenType.Slash:
+      parseComment(scanner)
+      return parseValue(scanner)
+    default:
+      token
+      return undefined
+  }
+}
+
+export const parse = (text) => {
+  const scanner = createScanner(text)
+  const result = parseValue(scanner)
+  return result
+}

package/src/parts/JsoncCharCode/JsoncCharCode.js

@@ -0,0 +1,23 @@
+export const CurlyOpen = '{'.charCodeAt(0)
+export const CurlyClose = '}'.charCodeAt(0)
+export const SquareOpen = '['.charCodeAt(0)
+export const SquareClose = ']'.charCodeAt(0)
+export const DoubleQuote = '"'.charCodeAt(0)
+export const Comma = ','.charCodeAt(0)
+export const Zero = '0'.charCodeAt(0)
+export const One = '1'.charCodeAt(0)
+export const Two = '2'.charCodeAt(0)
+export const Three = '3'.charCodeAt(0)
+export const Four = '4'.charCodeAt(0)
+export const Five = '5'.charCodeAt(0)
+export const Six = '6'.charCodeAt(0)
+export const Seven = '7'.charCodeAt(0)
+export const Eight = '8'.charCodeAt(0)
+export const Nine = '9'.charCodeAt(0)
+export const Dot = '.'.charCodeAt(0)
+export const CarriageReturn = '\r'.charCodeAt(0)
+export const LineFeed = '\n'.charCodeAt(0)
+export const Space = ' '.charCodeAt(0)
+export const Tab = '\t'.charCodeAt(0)
+export const Slash = '/'.charCodeAt(0)
+export const Star = '*'.charCodeAt(0)

package/src/parts/JsoncFile/JsoncFile.js

@@ -0,0 +1,8 @@
+import * as FileSystem from '../FileSystem/FileSystem.js'
+import * as Jsonc from '../Jsonc/Jsonc.js'
+
+export const readJsonc = async (absolutePath) => {
+  const content = await FileSystem.readFile(absolutePath)
+  const json = await Jsonc.parse(content)
+  return json
+}

package/src/parts/JsoncTokenType/JsoncTokenType.js

@@ -0,0 +1,11 @@
+export const None = 0
+export const CurlyOpen = 1
+export const CurlyClose = 2
+export const Eof = 3
+export const SquareOpen = 4
+export const SquareClose = 5
+export const DoubleQuote = 6
+export const Comma = 7
+export const Numeric = 8
+export const Slash = 9
+export const Literal = 10

package/src/parts/LimitString/LimitString.js

@@ -1,8 +1,10 @@
+import * as GetNewLineIndex from '../GetNewLineIndex/GetNewLineIndex.js'
+
 export const limitString = (string, limit) => {
   let lines = 0
   let i = 0
   while (i !== -1 && lines < limit) {
-    i = string.indexOf('\n', i + 1)
+    i = GetNewLineIndex.getNewLineIndex(string, i + 1)
     if (i === -1) {
       break
     }

package/src/parts/MergeStacks/MergeStacks.js

@@ -1,11 +1,12 @@
+import * as GetNewLineIndex from '../GetNewLineIndex/GetNewLineIndex.js'
 import * as NormalizeErrorLine from '../NormalizeErrorLine/NormalizeErrorLine.js'
 
 export const mergeStacks = (parent, child) => {
   if (!child) {
     return parent
   }
-  const parentNewLineIndex = parent.indexOf('\n')
-  const childNewLineIndex = child.indexOf('\n')
+  const parentNewLineIndex = GetNewLineIndex.getNewLineIndex(parent)
+  const childNewLineIndex = GetNewLineIndex.getNewLineIndex(child)
   if (childNewLineIndex === -1) {
     return parent
   }

package/src/parts/Module/Module.js

@@ -2,6 +2,8 @@ import * as ModuleId from '../ModuleId/ModuleId.js'
 
 export const load = (moduleId) => {
   switch (moduleId) {
+    case ModuleId.BulkReplacement:
+      return import('../BulkReplacement/BulkReplacement.ipc.js')
     case ModuleId.ChromeExtension:
       return import('../ChromeExtension/ChromeExtension.ipc.js')
     case ModuleId.ClipBoard:
@@ -40,6 +42,8 @@ export const load = (moduleId) => {
       return import('../WebSocketServer/WebSocketServer.ipc.js')
     case ModuleId.Workspace:
       return import('../Workspace/Workspace.ipc.js')
+    case ModuleId.InstallExtension:
+      return import('../InstallExtension/InstallExtension.ipc.js')
     default:
       throw new Error(`module ${moduleId} not found`)
   }

package/src/parts/ModuleId/ModuleId.js

@@ -17,3 +17,5 @@ export const Workspace = 16
 export const ChromeExtension = 17
 export const Download = 18
 export const GitLsFiles = 19
+export const BulkReplacement = 20
+export const InstallExtension = 21

package/src/parts/ModuleMap/ModuleMap.js

@@ -3,6 +3,8 @@ import * as ModuleId from '../ModuleId/ModuleId.js'
 
 export const getModuleId = (commandId) => {
   switch (commandId) {
+    case 'BulkReplacement.applyBulkReplacement':
+      return ModuleId.BulkReplacement
     case 'ChromeExtension.install':
     case 'ChromeExtension.uninstall':
       return ModuleId.ChromeExtension
@@ -139,6 +141,8 @@ export const getModuleId = (commandId) => {
     case 'Workspace.getHomeDir':
     case 'Workspace.resolveRoot':
       return ModuleId.Workspace
+    case 'InstallExtension.installExtension':
+      return ModuleId.InstallExtension
     default:
       throw new CommandNotFoundError(commandId)
   }

package/src/parts/Native/Native.js

@@ -1,5 +1,5 @@
 import open from 'open'
-import VError from 'verror'
+import { VError } from '../VError/VError.js'
 
 export const openFolder = async (path) => {
   try {

package/src/parts/ParentIpc/ParentIpc.js

@@ -1,5 +1,4 @@
 import { MessagePort, parentPort } from 'node:worker_threads'
-import VError from 'verror'
 import * as Callback from '../Callback/Callback.js'
 import * as Command from '../Command/Command.js'
 import * as Debug from '../Debug/Debug.js'
@@ -9,6 +8,7 @@ import * as ExtensionHostIpc from '../ExtensionHostIpc/ExtensionHostIpc.js'
 import * as ExtensionHostRpc from '../ExtensionHostRpc/ExtensionHostRpc.js'
 import * as GetResponse from '../GetResponse/GetResponse.js'
 import * as ProtocolType from '../ProtocolType/ProtocolType.js'
+import { VError } from '../VError/VError.js'
 // TODO add tests for this
 
 // TODO handle structure: one shared process multiple extension hosts
@@ -143,6 +143,7 @@ const electronInitialize = (initializeMessage) => {
         const response = await GetResponse.getResponse(message, fakeSocket)
         port.postMessage(response)
       } else {
+        console.warn(`[shared process] sending messages without id is deprecated: ${message.method}`)
         Command.execute(message.method, fakeSocket, ...message.params)
       }
     } else {

package/src/parts/Platform/Platform.js

@@ -2,7 +2,6 @@ import { homedir, tmpdir } from 'node:os'
 import { join, resolve, sep } from 'node:path'
 import { pathToFileURL } from 'node:url'
 import { xdgCache, xdgConfig, xdgData, xdgState } from 'xdg-basedir'
-import * as DesktopType from '../DesktopType/DesktopType.js'
 import * as Path from '../Path/Path.js'
 import * as Process from '../Process/Process.js'
 import * as Root from '../Root/Root.js'
@@ -57,26 +56,6 @@ export const getMarketplaceUrl = () => {
   return env.LVCE_MARKETPLACE_URL || 'https://marketplace.22e924c84de072d4b25b.com'
 }
 
-export const getDesktop = () => {
-  const { ORIGINAL_XDG_CURRENT_DESKTOP, XDG_CURRENT_DESKTOP } = env
-  if (ORIGINAL_XDG_CURRENT_DESKTOP && ORIGINAL_XDG_CURRENT_DESKTOP !== 'undefined') {
-    if (ORIGINAL_XDG_CURRENT_DESKTOP === 'ubuntu:GNOME') {
-      return DesktopType.Gnome
-    }
-    return ORIGINAL_XDG_CURRENT_DESKTOP
-  }
-  if (XDG_CURRENT_DESKTOP) {
-    if (XDG_CURRENT_DESKTOP === 'ubuntu:GNOME') {
-      return DesktopType.Gnome
-    }
-    return XDG_CURRENT_DESKTOP
-  }
-  if (isWindows) {
-    return DesktopType.Windows
-  }
-  return DesktopType.Unknown
-}
-
 export const getPathSeparator = () => {
   return sep
 }

package/src/parts/Preferences/Preferences.js

@@ -1,8 +1,8 @@
-import VError from 'verror'
-import * as JsonFile from '../JsonFile/JsonFile.js'
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+import * as JsoncFile from '../JsoncFile/JsoncFile.js'
 import * as Platform from '../Platform/Platform.js'
 import * as Process from '../Process/Process.js'
-
+import { VError } from '../VError/VError.js'
 // TODO need jsonc parser for settings with comments
 
 export const getUserPreferences = async () => {
@@ -10,16 +10,15 @@ export const getUserPreferences = async () => {
     const userSettingsPath = Platform.getUserSettingsPath()
     let json
     try {
-      json = await JsonFile.readJson(userSettingsPath)
+      json = await JsoncFile.readJsonc(userSettingsPath)
     } catch (error) {
-      if (error && error.message.includes('File not found')) {
+      if (error && error.code === ErrorCodes.ENOENT) {
         return {}
       }
       throw error
     }
     return json
   } catch (error) {
-    // @ts-ignore
     throw new VError(error, 'failed to get user preferences')
   }
 }
@@ -28,9 +27,8 @@ export const getUserPreferences = async () => {
 export const getDefaultPreferences = async () => {
   try {
     const defaultSettingsPath = Platform.getDefaultSettingsPath()
-    return await JsonFile.readJson(defaultSettingsPath)
+    return await JsoncFile.readJsonc(defaultSettingsPath)
   } catch (error) {
-    // @ts-ignore
     throw new VError(error, 'Failed to load default preferences')
   }
 }

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