@lvce-editor/shared-process 0.7.2 → 0.7.4

package/config/defaultKeyBindings.json

@@ -697,5 +697,45 @@
   {
     "key": "ctrl+-",
     "command": "Window.zoomOut"
+  },
+  {
+    "key": "ArrowDown",
+    "command": "TitleBarMenuBar.handleKeyArrowDown",
+    "when": "focus.TitleBarMenuBar"
+  },
+  {
+    "key": "ArrowUp",
+    "command": "TitleBarMenuBar.handleKeyArrowUp",
+    "when": "focus.TitleBarMenuBar"
+  },
+  {
+    "key": "ArrowRight",
+    "command": "TitleBarMenuBar.handleKeyArrowRight",
+    "when": "focus.TitleBarMenuBar"
+  },
+  {
+    "key": "ArrowLeft",
+    "command": "TitleBarMenuBar.handleKeyArrowLeft",
+    "when": "focus.TitleBarMenuBar"
+  },
+  {
+    "key": "Space",
+    "command": "TitleBarMenuBar.handleKeySpace",
+    "when": "focus.TitleBarMenuBar"
+  },
+  {
+    "key": "Home",
+    "command": "TitleBarMenuBar.handleKeyHome",
+    "when": "focus.TitleBarMenuBar"
+  },
+  {
+    "key": "End",
+    "command": "TitleBarMenuBar.handleKeyEnd",
+    "when": "focus.TitleBarMenuBar"
+  },
+  {
+    "key": "Escape",
+    "command": "TitleBarMenuBar.handleKeyEscape",
+    "when": "focus.TitleBarMenuBar"
   }
 ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "description": "",
   "main": "index.js",
   "type": "module",
@@ -20,8 +20,8 @@
     "node": ">=16"
   },
   "dependencies": {
-    "@lvce-editor/extension-host": "0.7.2",
-    "@lvce-editor/pty-host": "0.7.2",
+    "@lvce-editor/extension-host": "0.7.4",
+    "@lvce-editor/pty-host": "0.7.4",
     "chokidar": "^3.5.3",
     "debug": "^4.3.4",
     "execa": "^6.1.0",

package/src/parts/Cli/Cli.js

@@ -6,6 +6,8 @@ const getModule = (argv0) => {
       return import('../CliList/CliList.js')
     case 'link':
       return import('../CliLink/CliLink.js')
+    case 'unlink':
+      return import('../CliUnlink/CliUnlink.js')
     default:
       throw new Error('command not found')
   }

package/src/parts/CliUnlink/CliUnlink.js

@@ -0,0 +1,6 @@
+import * as ExtensionUnlink from '../ExtensionUnlink/ExtensionUnlink.js'
+
+export const handleCliArgs = async (argv, console, process) => {
+  const path = argv.length > 1 ? argv[1] : process.cwd()
+  await ExtensionUnlink.unlink(path)
+}

package/src/parts/Error/FileNotFoundError.js

@@ -1,8 +1,10 @@
 import VError from 'verror'
+import * as FileSystemErrorCodes from '../FileSystemErrorCodes/FileSystemErrorCodes.js'
 
 export class FileNotFoundError extends VError {
   constructor(path) {
     super(`File not found '${path}'`)
     this.name = 'FileNotFoundError'
+    this.code = FileSystemErrorCodes.ENOENT
   }
 }

package/src/parts/ExtensionHostRpc/ExtensionHostRpc.js

@@ -4,7 +4,7 @@ import * as Timeout from '../Timeout/Timeout.js'
 
 // TODO maybe rename to extension host management for clarity
 
-const CONNECTION_TIMEOUT = 1000
+const CONNECTION_TIMEOUT = 3000
 
 export const create = async (ipc, socket) => {
   Assert.object(socket)

package/src/parts/ExtensionLink/ExtensionLink.js

@@ -1,4 +1,6 @@
 import VError from 'verror'
+import * as ExtensionManifest from '../ExtensionManifest/ExtensionManifest.js'
+import * as ExtensionManifestStatus from '../ExtensionManifestStatus/ExtensionManifestStatus.js'
 import * as FileSystem from '../FileSystem/FileSystem.js'
 import * as FileSystemErrorCodes from '../FileSystemErrorCodes/FileSystemErrorCodes.js'
 import * as Path from '../Path/Path.js'
@@ -7,29 +9,30 @@ import * as SymLink from '../SymLink/SymLink.js'
 
 const linkFallBack = async (path) => {
   try {
-    const manifestPath = Path.join(path, 'extension.json')
-    if (!(await FileSystem.exists(manifestPath))) {
-      throw new Error('no extension manifest found')
+    const manifest = await ExtensionManifest.get(path)
+    if (manifest.status === ExtensionManifestStatus.Rejected) {
+      throw manifest.reason
     }
-    const extensionsPath = Platform.getExtensionsPath()
-    const baseName = Path.basename(path)
-    const to = Path.join(extensionsPath, baseName)
+    const linkedExtensionsPath = Platform.getLinkedExtensionsPath()
+    // @ts-ignore
+    const to = Path.join(linkedExtensionsPath, manifest.id)
     await FileSystem.remove(to)
     await SymLink.createSymLink(path, to)
   } catch (error) {
+    console.log({ error })
     throw new VError(error, `Failed to link extension`)
   }
 }
 
 export const link = async (path) => {
   try {
-    const manifestPath = Path.join(path, 'extension.json')
-    if (!(await FileSystem.exists(manifestPath))) {
-      throw new Error('no extension manifest found')
+    const manifest = await ExtensionManifest.get(path)
+    if (manifest.status === ExtensionManifestStatus.Rejected) {
+      throw manifest.reason
     }
-    const extensionsPath = Platform.getExtensionsPath()
-    const baseName = Path.basename(path)
-    const to = Path.join(extensionsPath, baseName)
+    const linkedExtensionsPath = Platform.getLinkedExtensionsPath()
+    // @ts-ignore
+    const to = Path.join(linkedExtensionsPath, manifest.id)
     await SymLink.createSymLink(path, to)
   } catch (error) {
     if (error && error.code === FileSystemErrorCodes.EEXIST) {

package/src/parts/ExtensionList/ExtensionList.js

@@ -1,14 +1,9 @@
-import { readdir, readFile } from 'node:fs/promises'
-import { basename, dirname, join } from 'node:path'
+import { basename } from 'node:path'
 import VError from 'verror'
+import * as ExtensionManifestInputType from '../ExtensionManifestInputType/ExtensionManifestInputType.js'
+import * as ExtensionManifests from '../ExtensionManifests/ExtensionManifests.js'
 import * as Platform from '../Platform/Platform.js'
-import * as JsonFile from '../JsonFile/JsonFile.js'
-
-const extensionPath = Platform.getExtensionsPath()
-
-const getAbsolutePath = (dirent) => {
-  return join(extensionPath, dirent)
-}
+import * as ExtensionManifestStatus from '../ExtensionManifestStatus/ExtensionManifestStatus.js'
 
 const getManifestVersion = (json) => {
   if (json && json.version && typeof json.version === 'string') {
@@ -17,17 +12,15 @@ const getManifestVersion = (json) => {
   return 'n/a'
 }
 
-const getManifestId = (json, jsonPath) => {
+const getManifestId = (json) => {
   if (json && json.id && typeof json.id === 'string') {
     return json.id
   }
-  return basename(jsonPath)
+  return basename(json.path)
 }
 
-const getManifestInfo = async (extensionPath) => {
-  const manifestPath = join(extensionPath, 'extension.json')
-  const json = await JsonFile.readJson(manifestPath)
-  const id = getManifestId(json, extensionPath)
+const getManifestInfo = (json) => {
+  const id = getManifestId(json)
   const version = getManifestVersion(json)
   return {
     id,
@@ -36,31 +29,33 @@ const getManifestInfo = async (extensionPath) => {
 }
 
 const isFulfilled = (result) => {
-  return result.status === 'fulfilled'
-}
-
-const getValue = (result) => {
-  return result.value
+  return result.status === ExtensionManifestStatus.Resolved
 }
 
-const getManifestInfos = async (manifestPaths) => {
-  const manifestInfos = await Promise.allSettled(
-    manifestPaths.map(getManifestInfo)
-  )
-  const results = manifestInfos.filter(isFulfilled).map(getValue)
+const getManifestInfos = (manifests) => {
+  const results = manifests.filter(isFulfilled).map(getManifestInfo)
   return results
 }
 
 export const list = async () => {
   try {
-    const dirents = await readdir(extensionPath)
-    const extensionPaths = dirents.map(getAbsolutePath)
-    const infos = await getManifestInfos(extensionPaths)
+    const manifests = await ExtensionManifests.getAll([
+      {
+        type: ExtensionManifestInputType.Folder,
+        path: Platform.getLinkedExtensionsPath(),
+      },
+      {
+        type: ExtensionManifestInputType.Folder,
+        path: Platform.getExtensionsPath(),
+      },
+      {
+        type: ExtensionManifestInputType.Folder,
+        path: Platform.getBuiltinExtensionsPath(),
+      },
+    ])
+    const infos = getManifestInfos(manifests)
     return infos
   } catch (error) {
-    if (error && error.code === 'ENOENT') {
-      return []
-    }
     throw new VError(error, `Failed to list extensions`)
   }
 }

package/src/parts/ExtensionManagement/ExtensionManagement.js

@@ -1,14 +1,12 @@
-import isObject from 'is-object'
 import { mkdir, readdir, rename, rm } from 'node:fs/promises'
-import path from 'node:path'
 import { performance } from 'node:perf_hooks'
 import VError from 'verror'
 import * as Debug from '../Debug/Debug.js'
-import * as ReadJson from '../JsonFile/JsonFile.js'
+import * as ExtensionManifestInputType from '../ExtensionManifestInputType/ExtensionManifestInputType.js'
+import * as ExtensionManifests from '../ExtensionManifests/ExtensionManifests.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) {
@@ -183,121 +181,63 @@ const getInstalledExtensionPaths = async () => {
   }
 }
 
-const RE_EXTENSION_FRAGMENT = /.+(\/|\\)(.+)$/
-
-const inferExtensionId = (absolutePath) => {
-  const match = absolutePath.match(RE_EXTENSION_FRAGMENT)
-  if (match) {
-    return match[2]
-  }
-  return ''
-}
-
-// TODO json parsing and error handling should happen in renderer process
-const getExtensionManifest = async (path) => {
-  try {
-    const absolutePath = Path.join(path, 'extension.json')
-    const json = await ReadJson.readJson(absolutePath)
-    if (!isObject(json)) {
-      // TODO should include stack of extension json file here
-      throw new VError('Invalid manifest file: Not an JSON object.')
-    }
-    return {
-      ...json,
-      path,
-      status: ExtensionManifestStatus.Resolved,
-    }
-  } catch (error) {
-    const id = inferExtensionId(path)
-    return {
-      path,
-      status: ExtensionManifestStatus.Rejected,
-      reason: new VError(
-        error,
-        `Failed to load extension "${id}": Failed to load extension manifest`
-      ),
-    }
-  }
-}
-
-/**
- * @param {string[]} paths
- */
-const getExtensionManifests = async (paths) => {
-  const allResults = await Promise.all(paths.map(getExtensionManifest))
-  return allResults
-}
-
 export const getBuiltinExtensions = async () => {
-  const builtinExtensionPaths = await getBuiltinExtensionPaths()
-  const builtinExtensions = await getExtensionManifests(builtinExtensionPaths)
-  return builtinExtensions
+  return ExtensionManifests.getAll([
+    {
+      type: ExtensionManifestInputType.Folder,
+      path: Platform.getBuiltinExtensionsPath(),
+    },
+  ])
 }
 
-export const getInstalledExtensions = async () => {
-  const installedExtensionPaths = await getInstalledExtensionPaths()
-  const installedExtensions = await getExtensionManifests(
-    installedExtensionPaths
-  )
-  return installedExtensions
+export const getInstalledExtensions = () => {
+  return ExtensionManifests.getAll([
+    {
+      type: ExtensionManifestInputType.Folder,
+      path: Platform.getExtensionsPath(),
+    },
+  ])
 }
 
 export const getExtensions = async () => {
-  // TODO only read from env once
-  const builtinExtensions = await getBuiltinExtensions()
-  const onlyExtensionPath = Platform.getOnlyExtensionPath()
-  if (onlyExtensionPath) {
-    const absolutePath = path.resolve(onlyExtensionPath)
-    const [onlyExtension] = await getExtensionManifests([absolutePath])
-    const enabledExtensions = getEnabledExtensionWithOnlyExtension(
-      builtinExtensions,
-      onlyExtension
-    )
-    return enabledExtensions
-  }
-  const installedExtensions = await getInstalledExtensions()
-  return [...builtinExtensions, ...installedExtensions]
-}
-
-const RE_THEME = /theme-[a-z\d\-]+$/
-const isTheme = (extensionId) => {
-  return RE_THEME.test(extensionId)
-}
-
-const getThemeExtensionsBuiltin = async () => {
-  const builtinExtensionsPath = Platform.getBuiltinExtensionsPath()
-  const dirents = await readdir(builtinExtensionsPath)
-  const filteredDirents = dirents.filter(isTheme)
-  const paths = filteredDirents.map(getAbsoluteBuiltinExtensionPath)
-}
-
-export const getThemeExtensions = async () => {
-  const builtinExtensionsPath = Platform.getBuiltinExtensionsPath()
-  const dirents = await readdir(builtinExtensionsPath)
-  const paths = []
-  for (const dirent of dirents) {
-    if (isTheme(dirent)) {
-      paths.push(getAbsoluteBuiltinExtensionPath(dirent))
-    }
-  }
-  const onlyExtensionPath = Platform.getOnlyExtensionPath()
-  if (onlyExtensionPath && isTheme(onlyExtensionPath)) {
-    paths.push(onlyExtensionPath)
-  }
-  const builtinExtensions = await getExtensionManifests(paths)
-  return builtinExtensions
+  return ExtensionManifests.getAll([
+    {
+      type: ExtensionManifestInputType.OnlyExtension,
+      path: Platform.getOnlyExtensionPath(),
+    },
+    {
+      type: ExtensionManifestInputType.Folder,
+      path: Platform.getLinkedExtensionsPath(),
+    },
+    {
+      type: ExtensionManifestInputType.Folder,
+      path: Platform.getExtensionsPath(),
+    },
+    {
+      type: ExtensionManifestInputType.Folder,
+      path: Platform.getBuiltinExtensionsPath(),
+    },
+  ])
 }
 
 export const getDisabledExtensions = async () => {
-  const disabledExtensionPaths = await getDisabledExtensionPaths()
-  const disabledExtensions = await getExtensionManifests(disabledExtensionPaths)
-  return disabledExtensions
+  return ExtensionManifests.getAll([
+    {
+      type: ExtensionManifestInputType.Folder,
+      path: Platform.getDisabledExtensionsPath(),
+    },
+  ])
 }
 
 export const getAllExtensions = async () => {
   const onlyExtensionPath = Platform.getOnlyExtensionPath()
   if (onlyExtensionPath) {
-    return getExtensionManifests([onlyExtensionPath])
+    return ExtensionManifests.getAll([
+      {
+        type: ExtensionManifestInputType.OnlyExtension,
+        path: onlyExtensionPath,
+      },
+    ])
   }
   const t1 = performance.now()
   const [builtinExtensions, installedExtensions, disabledExtensions] =

package/src/parts/ExtensionManagement/ExtensionManagementColorTheme.js

@@ -7,7 +7,7 @@ import * as ExtensionManagement from './ExtensionManagement.js'
 // TODO test this function
 // TODO very similar with getIconTheme
 export const getColorThemeJson = async (colorThemeId) => {
-  const extensions = await ExtensionManagement.getThemeExtensions()
+  const extensions = await ExtensionManagement.getExtensions()
   for (const extension of extensions) {
     if (!extension.colorThemes) {
       continue

package/src/parts/ExtensionManifest/ExtensionManifest.js

@@ -0,0 +1,51 @@
+import isObject from 'is-object'
+import VError from 'verror'
+import * as ExtensionManifestStatus from '../ExtensionManifestStatus/ExtensionManifestStatus.js'
+import * as ReadJson from '../JsonFile/JsonFile.js'
+import * as Path from '../Path/Path.js'
+import * as FileSystemErrorCodes from '../FileSystemErrorCodes/FileSystemErrorCodes.js'
+
+const RE_EXTENSION_FRAGMENT = /.+(\/|\\)(.+)$/
+
+const inferExtensionId = (absolutePath) => {
+  const match = absolutePath.match(RE_EXTENSION_FRAGMENT)
+  if (match) {
+    return match[2]
+  }
+  return ''
+}
+
+// TODO json parsing and error handling should happen in renderer process
+export const get = async (path) => {
+  try {
+    const absolutePath = Path.join(path, 'extension.json')
+    const json = await ReadJson.readJson(absolutePath)
+    if (!isObject(json)) {
+      // TODO should include stack of extension json file here
+      throw new VError('Invalid manifest file: Not an JSON object.')
+    }
+    return {
+      ...json,
+      path,
+      status: ExtensionManifestStatus.Resolved,
+    }
+  } catch (error) {
+    const id = inferExtensionId(path)
+    const enhancedError = new VError(
+      error,
+      `Failed to load extension manifest for ${id}`
+    )
+    if (error.code === FileSystemErrorCodes.ENOENT) {
+      // @ts-ignore
+      enhancedError.code = FileSystemErrorCodes.E_MANIFEST_NOT_FOUND
+    } else {
+      // @ts-ignore
+      enhancedError.code = error.code
+    }
+    return {
+      path,
+      status: ExtensionManifestStatus.Rejected,
+      reason: enhancedError,
+    }
+  }
+}

package/src/parts/ExtensionManifestInputType/ExtensionManifestInputType.js

@@ -0,0 +1,3 @@
+export const Folder = 1
+
+export const OnlyExtension = 2

package/src/parts/ExtensionManifests/ExtensionManifests.js

@@ -0,0 +1,39 @@
+import * as ExtensionManifestInputType from '../ExtensionManifestInputType/ExtensionManifestInputType.js'
+import * as ExtensionManifestsGetFromFolder from './ExtensionManifestsFromFolder.js'
+import * as ExtensionManifestsGetFromOnlyExtension from './ExtensionManifestsFromOnlyExtension.js'
+
+const getModule = (type) => {
+  switch (type) {
+    case ExtensionManifestInputType.Folder:
+      return ExtensionManifestsGetFromFolder
+    case ExtensionManifestInputType.OnlyExtension:
+      return ExtensionManifestsGetFromOnlyExtension
+    default:
+      throw new Error('unsupported input type')
+  }
+}
+
+const get = (input) => {
+  const module = getModule(input.type)
+  return module.getExtensionManifests(input.path)
+}
+
+const deduplicateExtensions = (extensions) => {
+  const seen = Object.create(null)
+  const uniqueExtensions = []
+  for (const extension of extensions) {
+    if (extension.id in seen) {
+      continue
+    }
+    seen[extension.id] = true
+    uniqueExtensions.push(extension)
+  }
+  return uniqueExtensions
+}
+
+export const getAll = async (inputs) => {
+  const manifests = await Promise.all(inputs.map(get))
+  const flatManifests = manifests.flat(1)
+  const uniqueExtensions = deduplicateExtensions(flatManifests)
+  return uniqueExtensions
+}

package/src/parts/ExtensionManifests/ExtensionManifestsFromFolder.js

@@ -0,0 +1,34 @@
+import VError from 'verror'
+import * as ExtensionManifest from '../ExtensionManifest/ExtensionManifest.js'
+import * as FileSystem from '../FileSystem/FileSystem.js'
+import * as Path from '../Path/Path.js'
+import * as FileSystemErrorCodes from '../FileSystemErrorCodes/FileSystemErrorCodes.js'
+
+const toAbsolutePaths = (path, dirents) => {
+  const absolutePaths = []
+  for (const dirent of dirents) {
+    absolutePaths.push(Path.join(path, dirent))
+  }
+  return absolutePaths
+}
+
+export const getExtensionManifests = async (path) => {
+  try {
+    if (!path) {
+      return []
+    }
+    const dirents = await FileSystem.readDir(path)
+    const absolutePaths = toAbsolutePaths(path, dirents)
+    const manifests = await Promise.all(
+      absolutePaths.map(ExtensionManifest.get)
+    )
+    return manifests
+  } catch (error) {
+    // TODO how to make typescript happy?
+    // @ts-ignore
+    if (error.code === FileSystemErrorCodes.ENOENT) {
+      return []
+    }
+    throw new VError(error, 'Failed to get extension manifests')
+  }
+}

package/src/parts/ExtensionManifests/ExtensionManifestsFromOnlyExtension.js

@@ -0,0 +1,9 @@
+import * as ExtensionManifest from '../ExtensionManifest/ExtensionManifest.js'
+
+export const getExtensionManifests = async (path) => {
+  if (path) {
+    const manifest = await ExtensionManifest.get(path)
+    return [manifest]
+  }
+  return []
+}

package/src/parts/ExtensionUnlink/ExtensionUnlink.js

@@ -0,0 +1,19 @@
+import VError from 'verror'
+import * as FileSystem from '../FileSystem/FileSystem.js'
+import * as Path from '../Path/Path.js'
+import * as Platform from '../Platform/Platform.js'
+
+export const unlink = async (path) => {
+  try {
+    const manifestPath = Path.join(path, 'extension.json')
+    if (!(await FileSystem.exists(manifestPath))) {
+      throw new Error('no extension manifest found')
+    }
+    const linkedExtensionsPath = Platform.getLinkedExtensionsPath()
+    const baseName = Path.basename(path)
+    const to = Path.join(linkedExtensionsPath, baseName)
+    await FileSystem.remove(to)
+  } catch (error) {
+    throw new VError(error, `Failed to unlink extension`)
+  }
+}

package/src/parts/FileSystem/FileSystem.js

@@ -177,6 +177,18 @@ export const readDirWithFileTypes = async (path) => {
   }
 }
 
+export const readDir = async (path) => {
+  try {
+    const dirents = await fs.readdir(path)
+    return dirents
+  } catch (error) {
+    if (error && error.code === FileSystemErrorCodes.ENOENT) {
+      throw new FileNotFoundError(path)
+    }
+    throw new VError(error, `Failed to read directory "${path}"`)
+  }
+}
+
 export const mkdir = async (path) => {
   try {
     await fs.mkdir(path, { recursive: true })

package/src/parts/FileSystemErrorCodes/FileSystemErrorCodes.js

@@ -3,3 +3,7 @@ export const ENOENT = 'ENOENT'
 export const EXDEV = 'EXDEV'
 
 export const EEXIST = 'EEXIST'
+
+export const ENOTDIR = 'ENOTDIR'
+
+export const E_MANIFEST_NOT_FOUND = 'E_MANIFEST_NOT_FOUND'

package/src/parts/Platform/Platform.js

@@ -38,6 +38,10 @@ export const getCachedExtensionsPath = () => {
   return Path.join(cacheDir, 'cached-extensions')
 }
 
+export const getLinkedExtensionsPath = () => {
+  return Path.join(dataDir, 'linked-extensions')
+}
+
 export const getMarketplaceUrl = () => {
   return (
     process.env.LVCE_MARKETPLACE_URL ||

package/src/parts/SymLink/SymLink.js

@@ -1,10 +1,12 @@
-import { symlink } from 'node:fs/promises'
+import { mkdir, symlink } from 'node:fs/promises'
+import { dirname } from 'node:path'
 import { FileSystemError } from '../Error/FileSystemError.js'
 
 // TODO maybe move this to FileSystem module
 
 export const createSymLink = async (target, path) => {
   try {
+    await mkdir(dirname(path), { recursive: true })
     await symlink(target, path)
   } catch (error) {
     throw new FileSystemError(

package/src/sharedProcessMain.js

@@ -45,7 +45,7 @@ const handleSigTerm = () => {
   console.info('[shared-process] sigterm')
 }
 
-const knownCliArgs = ['install', 'list', 'link']
+const knownCliArgs = ['install', 'list', 'link', 'unlink']
 
 const main = async () => {
   const argv = process.argv.slice(2)