@lvce-editor/shared-process 0.13.0 → 0.14.0

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
+    }
+  }
+}

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')
   }
 }