@lvce-editor/shared-process 0.0.40 → 0.1.1

package/src/parts/ExtensionManagement/ExtensionManagement.js

@@ -1,14 +1,14 @@
+import isObject from 'is-object'
 import { mkdir, readdir, rename, rm } from 'node:fs/promises'
-import { performance } from 'node:perf_hooks'
 import path from 'node:path'
-import isObject from 'is-object'
+import { performance } from 'node:perf_hooks'
 import VError from 'verror'
 import * as Debug from '../Debug/Debug.js'
-import * as Error from '../Error/Error.js'
 import * as ReadJson from '../JsonFile/JsonFile.js'
 import * as Path from '../Path/Path.js'
 import * as Platform from '../Platform/Platform.js'
 import * as Queue from '../Queue/Queue.js'
+import * as ExtensionManifestStatus from '../ExtensionManifestStatus/ExtensionManifestStatus.js'
 
 const isLanguageBasics = (extension) => {
   if (extension && extension.id) {
@@ -61,11 +61,7 @@ export const install = async (id) => {
     //   type: 'marketplace',
     // })
   } catch (error) {
-    throw new Error.OperationalError({
-      cause: error,
-      code: 'E_EXT_INSTALL_FAILED',
-      message: `Failed to install extension "${id}"`,
-    })
+    throw new VError(error, `Failed to install extension "${id}"`)
   }
 }
 
@@ -78,11 +74,7 @@ export const uninstall = async (id) => {
     // if (error.code === 'ENOENT') {
     //   return
     // }
-    throw new Error.OperationalError({
-      cause: error,
-      code: 'E_EXT_UNINSTALL_FAILED',
-      message: `Failed to uninstall extension "${id}"`,
-    })
+    throw new VError(error, `Failed to uninstall extension "${id}"`)
   }
 }
 
@@ -97,11 +89,7 @@ export const enable = async (id) => {
       Path.join(extensionsPath, id)
     )
   } catch (error) {
-    throw new Error.OperationalError({
-      cause: error,
-      message: `Failed to enable extension "${id}"`,
-      code: 'E_EXTENSION_ENABLING_FAILED',
-    })
+    throw new VError(error, `Failed to enable extension "${id}"`)
   }
 }
 
@@ -116,11 +104,7 @@ export const disable = async (id) => {
       Path.join(disabledExtensionsPath, id)
     )
   } catch (error) {
-    throw new Error.OperationalError({
-      cause: error,
-      code: 'E_EXTENSION_DISABLING_FAILED',
-      message: `Failed to disable extension ${id}`,
-    })
+    throw new VError(error, `Failed to disable extension ${id}`)
   }
 }
 
@@ -160,6 +144,8 @@ const isIncludedBuiltinExtension = (dirent) => {
   return !SKIPPED.includes(dirent)
 }
 
+// TODO pass builtin extensions path from renderer-worker
+// only negative: more messages sent between renderer-worker and shared process on startup
 const getBuiltinExtensionPaths = async () => {
   try {
     const builtinExtensionsPath = Platform.getBuiltinExtensionsPath()
@@ -192,11 +178,7 @@ const getInstalledExtensionPaths = async () => {
       await mkdir(Platform.getExtensionsPath(), { recursive: true })
       return []
     }
-    throw new Error.OperationalError({
-      cause: error,
-      code: 'E_FAILED_TO_LOAD_INSTALLED_EXTENSIONS',
-      message: 'Failed to get installed extensions',
-    })
+    throw new VError(error, 'Failed to get installed extensions')
   }
 }
 
@@ -222,28 +204,21 @@ const getExtensionManifest = async (path) => {
     return {
       ...json,
       path,
-      status: 'fulfilled',
+      status: ExtensionManifestStatus.Resolved,
     }
   } catch (error) {
     const id = inferExtensionId(path)
     return {
       path,
-      status: 'rejected',
-      reason: new Error.OperationalError({
-        cause: error,
-        code: 'E_LOADING_EXTENSION_MANIFEST_FAilED',
-        message: `Failed to load extension "${id}": Failed to load extension manifest`,
-        // @ts-ignore
-        stack: error.stack,
-      }),
+      status: ExtensionManifestStatus.Rejected,
+      reason: new VError(
+        error,
+        `Failed to load extension "${id}": Failed to load extension manifest`
+      ),
     }
   }
 }
 
-const isRejected = (promise) => {
-  return promise.status === 'rejected'
-}
-
 /**
  * @param {string[]} paths
  */

package/src/parts/ExtensionManagement/ExtensionManagementColorTheme.js

@@ -1,5 +1,7 @@
+import VError from 'verror'
 import * as Error from '../Error/Error.js'
 import * as ReadJson from '../JsonFile/JsonFile.js'
+import * as Path from '../Path/Path.js'
 import * as ExtensionManagement from './ExtensionManagement.js'
 
 // TODO test this function
@@ -14,16 +16,12 @@ export const getColorThemeJson = async (colorThemeId) => {
       if (colorTheme.id !== colorThemeId) {
         continue
       }
-      const absolutePath = `${extension.path}/${colorTheme.path}`
+      const absolutePath = Path.join(extension.path, colorTheme.path)
       try {
         const json = await ReadJson.readJson(absolutePath)
         return json
       } catch (error) {
-        throw new Error.OperationalError({
-          cause: error,
-          code: 'E_COLOR_THEME_COULD_NOT_BE_LOADED',
-          message: `Failed to load color theme "${colorThemeId}"`,
-        })
+        throw new VError(error, `Failed to load color theme "${colorThemeId}"`)
       }
     }
   }

package/src/parts/ExtensionManagement/ExtensionManagementIconTheme.js

@@ -1,5 +1,7 @@
+import VError from 'verror'
 import * as Error from '../Error/Error.js'
 import * as ReadJson from '../JsonFile/JsonFile.js'
+import * as Path from '../Path/Path.js'
 import * as ExtensionManagement from './ExtensionManagement.js'
 
 export const getIconTheme = async (iconThemeId) => {
@@ -12,7 +14,7 @@ export const getIconTheme = async (iconThemeId) => {
       if (iconTheme.id !== iconThemeId) {
         continue
       }
-      const absolutePath = `${extension.path}/${iconTheme.path}`
+      const absolutePath = Path.join(extension.path, iconTheme.path)
       try {
         const json = await ReadJson.readJson(absolutePath)
         return {
@@ -20,11 +22,7 @@ export const getIconTheme = async (iconThemeId) => {
           json,
         }
       } catch (error) {
-        throw new Error.OperationalError({
-          cause: error,
-          code: 'E_ICON_THEME_COULD_NOT_BE_LOADED',
-          message: `Failed to load icon theme "${iconThemeId}"`,
-        })
+        throw new VError(error, `Failed to load icon theme "${iconThemeId}"`)
       }
     }
   }

package/src/parts/ExtensionManifestStatus/ExtensionManifestStatus.js

@@ -0,0 +1,3 @@
+export const Resolved = 'resolved'
+
+export const Rejected = 'rejected'

package/src/parts/FileSystem/FileSystem.js

@@ -1,12 +1,11 @@
 // TODO lazyload chokidar and trash (but doesn't work currently because of bug with jest)
 import * as fs from 'node:fs/promises'
 import * as os from 'node:os'
-import chokidar from 'chokidar'
-import * as Error from '../Error/Error.js'
+import VError from 'verror'
+import * as DirentType from '../DirentType/DirentType.js'
 import * as Path from '../Path/Path.js'
-import * as Trash from '../Trash/Trash.js'
 import * as Platform from '../Platform/Platform.js'
-import VError from 'verror'
+import * as Trash from '../Trash/Trash.js'
 
 export const state = {
   watcherMap: Object.create(null),
@@ -27,26 +26,26 @@ export const copy = async (source, target) => {
         `Failed to copy "${source}" to "${target}": src and dest cannot be the same`
       )
     }
-    throw new Error.OperationalError({
-      cause: error,
-      code: 'E_FILE_SYSTEM_ERROR',
-      message: `Failed to copy "${source}" to "${target}"`,
-      category: 'File System Error',
-    })
+    throw new VError(error, `Failed to copy "${source}" to "${target}"`)
   }
 }
 
+// TODO extensions should only be accessed once on startup
 export const readFile = async (path) => {
+  // console.info('[shared-process] read file', path)
   try {
+    // const start = performance.now()
+    // console.time(`read ${path}`)
     const content = await fs.readFile(path, 'utf8')
+    // const end = performance.now()
+    // console.log('read', path, 'took', (end - start).toFixed(2), 'ms')
+    // console.timeEnd(`read ${path}`)
     return content
   } catch (error) {
-    throw new Error.OperationalError({
-      cause: error,
-      code: 'E_FILE_SYSTEM_ERROR',
-      message: `Failed to read file "${path}"`,
-      category: 'File System Error',
-    })
+    if (error && error.code === 'ENOENT') {
+      throw new VError(`File not found '${path}'`)
+    }
+    throw new VError(error, `Failed to read file "${path}"`)
   }
 }
 
@@ -56,12 +55,7 @@ export const writeFile = async (path, content) => {
     // Queue.add(`writeFile/${path}`, () =>
     await fs.writeFile(path, content)
   } catch (error) {
-    throw new Error.OperationalError({
-      cause: error,
-      code: 'E_FILE_SYSTEM_ERROR',
-      message: `Failed to write to file "${path}"`,
-      category: 'File System Error',
-    })
+    throw new VError(error, `Failed to write to file "${path}"`)
   }
 }
 
@@ -70,12 +64,7 @@ export const ensureFile = async (path, content) => {
     await fs.mkdir(Path.dirname(path), { recursive: true })
     await fs.writeFile(path, content)
   } catch (error) {
-    throw new Error.OperationalError({
-      cause: error,
-      code: 'E_FILE_SYSTEM_ERROR',
-      message: `Failed to write to file "${path}"`,
-      category: 'File System Error',
-    })
+    throw new VError(error, `Failed to write to file "${path}"`)
   }
 }
 
@@ -83,12 +72,7 @@ export const createFile = async (path) => {
   try {
     await fs.writeFile(path, '', { flag: 'wx' })
   } catch (error) {
-    throw new Error.OperationalError({
-      cause: error,
-      code: 'E_FILE_SYSTEM_ERROR',
-      message: `Failed to create file "${path}"`,
-      category: 'File System Error',
-    })
+    throw new VError(error, `Failed to create file "${path}"`)
   }
 }
 
@@ -96,12 +80,7 @@ export const createFolder = async (path, options) => {
   try {
     await fs.mkdir(path, options)
   } catch (error) {
-    throw new Error.OperationalError({
-      cause: error,
-      code: 'E_FILE_SYSTEM_ERROR',
-      message: `Failed to create folder "${path}"`,
-      category: 'File System Error',
-    })
+    throw new VError(error, `Failed to create folder "${path}"`)
   }
 }
 
@@ -129,12 +108,7 @@ export const remove = async (path) => {
   try {
     await Trash.trash(path)
   } catch (error) {
-    throw new Error.OperationalError({
-      cause: error,
-      code: 'E_FILE_REMOVE_SYSTEM_ERROR',
-      message: `Failed to remove "${path}"`,
-      category: 'File System Error',
-    })
+    throw new VError(error, `Failed to remove "${path}"`)
   }
 }
 
@@ -152,24 +126,24 @@ export const exists = async (path) => {
  */
 const getType = (dirent) => {
   if (dirent.isFile()) {
-    return 'file'
+    return DirentType.File
   }
   if (dirent.isDirectory()) {
-    return 'directory'
+    return DirentType.Direcory
   }
   if (dirent.isSymbolicLink()) {
-    return 'symlink'
+    return DirentType.Symlink
   }
   if (dirent.isSocket()) {
-    return 'socket'
+    return DirentType.Socket
   }
   if (dirent.isBlockDevice()) {
-    return 'block-device'
+    return DirentType.BlockDevice
   }
   if (dirent.isCharacterDevice()) {
-    return 'character-device'
+    return DirentType.CharacterDevice
   }
-  return 'unknown'
+  return DirentType.Unknown
 }
 
 /**
@@ -188,25 +162,15 @@ export const readDirWithFileTypes = async (path) => {
     const prettyDirents = dirents.map(toPrettyDirent)
     return prettyDirents
   } catch (error) {
-    throw new Error.OperationalError({
-      cause: error,
-      code: 'E_FILE_READ_DIR_SYSTEM_ERROR',
-      message: `Failed to read directory "${path}"`,
-      category: 'File System Error',
-    })
+    throw new VError(error, `Failed to read directory "${path}"`)
   }
 }
 
 export const mkdir = async (path) => {
   try {
-    await fs.mkdir(path)
+    await fs.mkdir(path, { recursive: true })
   } catch (error) {
-    throw new Error.OperationalError({
-      cause: error,
-      code: 'E_CREATE_DIRECTORY_FAILED',
-      message: `Failed to create directory "${path}"`,
-      category: 'File System Error',
-    })
+    throw new VError(error, `Failed to create directory "${path}"`)
   }
 }
 
@@ -214,18 +178,13 @@ export const rename = async (oldPath, newPath) => {
   try {
     await fs.rename(oldPath, newPath)
   } catch (error) {
-    throw new Error.OperationalError({
-      cause: error,
-      code: 'E_RENAME_FAILED',
-      message: `Failed to rename "${oldPath}" to "${newPath}"`,
-      category: 'File System Error',
-    })
+    throw new VError(error, `Failed to rename "${oldPath}" to "${newPath}"`)
   }
 }
 
-export const watch = (path, options) => {
+export const watch = async (path, options) => {
   // let state = 'loading'
-
+  const chokidar = await import('chokidar')
   const watcher = chokidar.watch(`${path}`, {
     ignoreInitial: true,
   })

package/src/parts/Json/Json.js

@@ -1,65 +1,17 @@
-import fallback from 'json-parse-even-better-errors'
-import { codeFrameColumns } from '@babel/code-frame'
-import { LinesAndColumns } from 'lines-and-columns'
-
 // parsing error handling based on https://github.com/sindresorhus/parse-json/blob/main/index.js
 
 export const parse = async (string, filePath) => {
   try {
-    try {
-      return JSON.parse(string)
-    } catch (error) {
-      fallback(string)
-      throw error
-    }
+    return JSON.parse(string)
   } catch (error) {
-    error.message = error.message.replace(/\n/g, '')
-    const indexMatch = error.message.match(
-      /in JSON at position (\d+) while parsing/
-    )
-    let topMessage = error.message
-    let bottomMessage = error.message
-    if (topMessage.startsWith('Unexpected token')) {
-      topMessage = 'JSON parsing error:'
-    }
-    if (bottomMessage.includes('while parsing "{')) {
-      bottomMessage = bottomMessage.slice(
-        0,
-        bottomMessage.indexOf('while parsing "{')
-      )
-    }
-    if (bottomMessage.includes(' (0x7D) ')) {
-      bottomMessage = bottomMessage.replace(' (0x7D) ', ' ')
-    }
-    bottomMessage = bottomMessage.trim()
-    const jsonError = new Error(topMessage)
-    if (indexMatch && indexMatch.length > 0) {
-      const lines = new LinesAndColumns(string)
-      const index = Number(indexMatch[1])
-      const location = lines.locationForIndex(index)
-      const codeFrame = codeFrameColumns(
-        string,
-        { start: { line: location.line + 1, column: location.column + 1 } },
-        { highlightCode: true }
-      )
-      jsonError.codeFrame = codeFrame
-    }
-    // console.log({ bottomMessage, message: error.message })
-    jsonError.stack = `${bottomMessage}\n    at ${filePath}`
+    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
   }
-
-  // try {
-  //   return JSON.parse(json)
-  // } catch (error) {
-  //   const parseJsonBetterErrors = await import('parse-json')
-  //   try {
-  //     return parseJsonBetterErrors.default(json, filePath)
-  //   } catch (error) {
-  //     console.log({ frame: error.codeFrame })
-  //     throw error
-  //   }
-  // }
 }
 
 export const stringify = (value) => {

package/src/parts/JsonError/JsonError.js

@@ -0,0 +1,70 @@
+import { codeFrameColumns } from '@babel/code-frame'
+import { LinesAndColumns } from 'lines-and-columns'
+
+// parsing error handling based on https://github.com/sindresorhus/parse-json/blob/main/index.js
+
+const emptyError = {
+  message: '',
+  stack: '',
+  codeFrame: '',
+}
+
+export const getErrorPropsFromError = (error, string, filePath) => {
+  const indexMatch = error.message.match(/in JSON at position (\d+)/)
+  if (indexMatch && indexMatch.length > 0) {
+    const lines = new LinesAndColumns(string)
+    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 }
+      )
+      return {
+        codeFrame,
+        message: 'Json Parsing Error',
+        stack: `at ${filePath}`,
+      }
+    }
+  }
+  if (string.length === 0) {
+    return {
+      codeFrame: ``,
+      message: 'Json Parsing Error: Cannot parse empty string',
+      stack: `at ${filePath}`,
+    }
+  }
+
+  if (error.message === 'Unexpected end of JSON input') {
+    const lines = new LinesAndColumns(string)
+    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 }
+      )
+      return {
+        codeFrame,
+        message: 'Json Parsing Error',
+        stack: `at ${filePath}`,
+      }
+    }
+  }
+  return {
+    codeFrame: ``,
+    message: 'Json Parsing Error',
+    stack: `at ${filePath}`,
+  }
+}
+
+export const getErrorProps = (string, filePath) => {
+  try {
+    JSON.parse(string)
+    return emptyError
+  } catch (error) {
+    return getErrorPropsFromError(error, string, filePath)
+  }
+}

package/src/parts/JsonFile/JsonFile.js

@@ -1,14 +1,14 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises'
-import * as Path from '../Path/Path.js'
+import * as FileSystem from '../FileSystem/FileSystem.js'
 import * as Json from '../Json/Json.js'
+import * as Path from '../Path/Path.js'
 
 export const readJson = async (absolutePath) => {
-  const content = await readFile(absolutePath, 'utf-8')
+  const content = await FileSystem.readFile(absolutePath)
   const json = await Json.parse(content, absolutePath)
   return json
 }
 
 export const writeJson = async (absolutePath, value) => {
-  await mkdir(Path.dirname(absolutePath), { recursive: true })
-  await writeFile(absolutePath, Json.stringify(value))
+  await FileSystem.mkdir(Path.dirname(absolutePath))
+  await FileSystem.writeFile(absolutePath, Json.stringify(value))
 }

package/src/parts/Native/Native.js

@@ -1,14 +1,10 @@
 import open from 'open'
-import * as Error from '../Error/Error.js'
+import VError from 'verror'
 
 export const openFolder = async (path) => {
   try {
     await open(path)
   } catch (error) {
-    throw new Error.OperationalError({
-      cause: error,
-      code: 'E_OPEN_SYSTEM_ERROR',
-      message: `Failed to open ${path}`,
-    })
+    throw new VError(error, `Failed to open ${path}`)
   }
 }

package/src/parts/Preferences/Preferences.js

@@ -11,7 +11,7 @@ export const getUserPreferences = async () => {
     try {
       json = await JsonFile.readJson(userSettingsPath)
     } catch (error) {
-      if (error && error.code === 'ENOENT') {
+      if (error && error.message.includes('File not found')) {
         return {}
       }
       throw error

package/src/parts/RecentlyOpened/RecentlyOpened.ipc.js

@@ -0,0 +1,5 @@
+import * as RecentlyOpened from './RecentlyOpened.js'
+
+export const Commands = {
+  'RecentlyOpened.addPath': RecentlyOpened.addPath,
+}

package/src/parts/RecentlyOpened/RecentlyOpened.js

@@ -0,0 +1,52 @@
+import VError from 'verror'
+import * as Assert from '../Assert/Assert.js'
+import * as FileSystem from '../FileSystem/FileSystem.js'
+import * as Json from '../Json/Json.js'
+import * as Platform from '../Platform/Platform.js'
+
+const isValid = (recentlyOpened) => {
+  return recentlyOpened && Array.isArray(recentlyOpened)
+}
+
+const addToArrayUnique = (recentlyOpened, path) => {
+  const index = recentlyOpened.indexOf(path)
+  if (index === -1) {
+    return [path, ...recentlyOpened]
+  }
+  return [
+    path,
+    ...recentlyOpened.slice(0, index),
+    ...recentlyOpened.slice(index + 1),
+  ]
+}
+
+const getRecentlyOpened = async (recentlyOpenedPath) => {
+  try {
+    const content = await FileSystem.readFile(recentlyOpenedPath)
+    const parsed = await Json.parse(content, recentlyOpenedPath)
+    return parsed
+  } catch (error) {
+    // TODO should check for error.code
+    if (error.message.includes('File not found')) {
+      // ignore
+    } else if (error.message.includes('Json Parsing Error')) {
+      // ignore
+    } else {
+      throw new VError(error, `Failed to read recently opened`)
+    }
+    return []
+  }
+}
+
+const setRecentlyOpened = async (recentlyOpenedPath, newRecentlyOpened) => {
+  const stringified = Json.stringify(newRecentlyOpened)
+  await FileSystem.writeFile(recentlyOpenedPath, stringified)
+}
+
+export const addPath = async (path) => {
+  Assert.string(path)
+  const recentlyOpenedPath = Platform.getRecentlyOpenedPath()
+  const parsed = await getRecentlyOpened(recentlyOpenedPath)
+  const newRecentlyOpened = addToArrayUnique(parsed, path)
+  await setRecentlyOpened(recentlyOpenedPath, newRecentlyOpened)
+}

package/src/parts/Search/Search.js

@@ -22,6 +22,12 @@ const useNice = !Platform.isWindows()
 // TODO update client
 // TODO not always run nice, maybe configure nice via flag/options
 
+const ParsedLineType = {
+  Begin: 'begin',
+  Match: 'match',
+  Summary: 'summary',
+}
+
 export const search = async (searchDir, searchString) => {
   // TODO reject promise when ripgrep search fails
   return new Promise((resolve, reject) => {
@@ -61,18 +67,18 @@ export const search = async (searchDir, searchString) => {
       for (const line of lines) {
         const parsedLine = JSON.parse(line)
         switch (parsedLine.type) {
-          case 'begin': {
+          case ParsedLineType.Begin: {
             allSearchResults[parsedLine.data.path.text] = []
             break
           }
-          case 'match': {
+          case ParsedLineType.Match: {
             numberOfResults++
             allSearchResults[parsedLine.data.path.text].push(
               toSearchResult(parsedLine)
             )
             break
           }
-          case 'summary':
+          case ParsedLineType.Summary:
             stats = parsedLine.data
             break
           default: