@lvce-editor/shared-process 0.0.2

package/src/parts/ExtensionHost/ExtensionHostImplementation.js

@@ -0,0 +1,12 @@
+export const executeImplementationProvider = async (
+  extensionHost,
+  documentId,
+  offset
+) => {
+  const implementations = await extensionHost.invoke(
+    'Implementation.execute',
+    documentId,
+    offset
+  )
+  return implementations
+}

package/src/parts/ExtensionHost/ExtensionHostKeyBindings.js

@@ -0,0 +1,23 @@
+import VError from 'verror'
+import * as Callback from '../Callback/Callback.js'
+import * as ChildProcess from '../ChildProcess/ChildProcess.js'
+import * as Debug from '../Debug/Debug.js'
+import * as Error from '../Error/Error.js'
+import * as ExtensionManagement from '../ExtensionManagement/ExtensionManagement.js'
+import * as ReadJson from '../JsonFile/JsonFile.js'
+import * as JsonRpc from '../JsonRpc/JsonRpc.js'
+import * as Path from '../Path/Path.js'
+import * as Root from '../Root/Root.js'
+import * as Socket from '../Socket/Socket.js'
+import * as TextDocument from '../TextDocument/TextDocument.js'
+import * as Platform from '../Platform/Platform.js'
+
+const getExtensionKeyBindings = (extension) => {
+  return extension.keyBindings || []
+}
+
+export const getKeyBindings = async () => {
+  const extensions = await ExtensionManagement.getExtensions()
+  const keyBindings = extensions.flatMap(getExtensionKeyBindings)
+  return keyBindings
+}

package/src/parts/ExtensionHost/ExtensionHostLanguages.js

@@ -0,0 +1,84 @@
+import { join } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import VError from 'verror'
+import * as Error from '../Error/Error.js'
+import * as ExtensionManagement from '../ExtensionManagement/ExtensionManagement.js'
+import * as ReadJson from '../JsonFile/JsonFile.js'
+import * as Path from '../Path/Path.js'
+
+const getExtensionLanguages = (extension) => {
+  if (!extension.languages) {
+    return []
+  }
+  return extension.languages.map((language) => ({}))
+}
+
+const toRemoteUrl = (path) => {
+  const url = pathToFileURL(path).toString().slice(8)
+  return `/remote/${url}`
+}
+
+const getLanguagesFromExtension = (extension) => {
+  // TODO what if extension is null? should not crash process, handle error gracefully
+  if (!extension.languages) {
+    return []
+  }
+  const getLanguageFromExtension = (language) => {
+    if (language.tokenize) {
+      if (typeof language.tokenize !== 'string') {
+        console.warn(
+          `[info] ${
+            language.id
+          }: language.tokenize must be of type string but was of type ${typeof language.tokenize}`
+        )
+        return {
+          ...language,
+          tokenize: '',
+        }
+      }
+      return {
+        ...language,
+        tokenize: toRemoteUrl(join(extension.path, language.tokenize)),
+      }
+    }
+    return language
+  }
+  return extension.languages.map(getLanguageFromExtension)
+}
+
+const getLanguagesFromExtensions = (extensions) => {
+  return extensions.flatMap(getLanguagesFromExtension)
+}
+
+export const getLanguages = async () => {
+  const extensions = await ExtensionManagement.getExtensions()
+  const languages = getLanguagesFromExtensions(extensions)
+  return languages
+}
+
+const getLanguageConfigurationPathFromExtensions = (extensions, languageId) => {
+  for (const extension of extensions) {
+    if (extension.languages && extension.languages) {
+      for (const language of extension.languages) {
+        if (language.id === languageId && language.configuration) {
+          return join(extension.path, language.configuration)
+        }
+      }
+    }
+  }
+  return ''
+}
+
+export const getLanguageConfiguration = async (languageId) => {
+  try {
+    const extensions = await ExtensionManagement.getExtensions()
+    const languageConfigurationPath =
+      getLanguageConfigurationPathFromExtensions(extensions, languageId)
+    return await ReadJson.readJson(languageConfigurationPath)
+  } catch (error) {
+    throw new VError(
+      error,
+      `Failed to load language configuration for ${languageId}`
+    )
+  }
+}

package/src/parts/ExtensionHost/ExtensionHostManagement.js

@@ -0,0 +1,26 @@
+import * as Debug from '../Debug/Debug.js'
+
+export const didInstallExtension = (extensionHost, extension) => {
+  return extensionHost.invoke('didInstallExtension', extension)
+}
+
+export const didUninstallExtension = (extensionHost, extension) => {
+  return extensionHost.invoke('didUninstallExtension', extension)
+}
+
+export const disableExtension = (extensionHost, extension) => {
+  return extensionHost.invoke('disableExtension', extension)
+}
+
+// TODO have enableExtensionsCommand to avoid sending too many messages via ipc -> only send one ipc message to enable multiple extensions
+export const enableExtension = async (extensionHost, extension) => {
+  Debug.debug(`ExtensionHost#enableExtension ${extension.id}`)
+  await extensionHost.invoke('enableExtension', extension)
+}
+
+export const activateAll = async (extensions) => {
+  // console.log({ extensions })
+  const results = await Promise.allSettled(extensions.map(enableExtension))
+  // console.log({ results })
+  return results
+}

package/src/parts/ExtensionHost/ExtensionHostOutput.js

@@ -0,0 +1,3 @@
+export const getOutputChannels = (extensionHost) => {
+  return extensionHost.invoke('OutputChannel.getOutputChannels')
+}

package/src/parts/ExtensionHost/ExtensionHostQuickPick.js

@@ -0,0 +1,6 @@
+export const handleQuickPickResult = (extensionHost, index) => {
+  return extensionHost.invoke(
+    'ExtensionHostQuickPick.handleQuickPickResult',
+    index
+  )
+}

package/src/parts/ExtensionHost/ExtensionHostReference.js

@@ -0,0 +1,12 @@
+export const executeReferenceProvider = async (
+  extensionHost,
+  documentId,
+  offset
+) => {
+  const references = await extensionHost.invoke(
+    'References.execute',
+    documentId,
+    offset
+  )
+  return references
+}

package/src/parts/ExtensionHost/ExtensionHostRename.js

@@ -0,0 +1,27 @@
+export const executePrepareRename = async (
+  extensionHost,
+  documentId,
+  offset
+) => {
+  const result = await extensionHost.invoke(
+    'Rename.executePrepareRename',
+    documentId,
+    offset
+  )
+  return result
+}
+
+export const executeRename = async (
+  extensionHost,
+  documentId,
+  offset,
+  newName
+) => {
+  const result = await extensionHost.invoke(
+    'Rename.executeRename',
+    documentId,
+    offset,
+    newName
+  )
+  return result
+}

package/src/parts/ExtensionHost/ExtensionHostSemanticTokens.js

@@ -0,0 +1,10 @@
+export const executeSemanticTokenProvider = async (
+  extensionHost,
+  documentId
+) => {
+  const semanticTokens = await extensionHost.invoke(
+    'SemanticTokens.execute',
+    documentId
+  )
+  return semanticTokens
+}

package/src/parts/ExtensionHost/ExtensionHostSourceControl.js

@@ -0,0 +1,15 @@
+export const sourceControlAcceptInput = (extensionHost, text) => {
+  return extensionHost.invoke('SourceControl.acceptInput', text)
+}
+
+export const getSourceControlChangedFiles = async (extensionHost) => {
+  const changedFiles = await extensionHost.invoke(
+    'getSourceControlChangedFiles'
+  )
+  return changedFiles
+}
+
+export const getSourceControlBadgeCount = async (extensionHost) => {
+  const count = await extensionHost.invoke('getSourceControlBadgeCount')
+  return count
+}

package/src/parts/ExtensionHost/ExtensionHostStats.js

@@ -0,0 +1,3 @@
+export const getMemoryUsage = (extensionHost) => {
+  return extensionHost.invoke('getMemoryUsage')
+}

package/src/parts/ExtensionHost/ExtensionHostStatusBar.js

@@ -0,0 +1,7 @@
+export const getStatusBarItems = (extensionHost) => {
+  return extensionHost.invoke('StatusBar.getStatusBarItems')
+}
+
+export const registerChangeListener = (extensionHost, id) => {
+  return extensionHost.invoke('StatusBar.registerChangeListener', id)
+}

package/src/parts/ExtensionHost/ExtensionHostTabCompletion.js

@@ -0,0 +1,12 @@
+export const executeTabCompletionProvider = async (
+  extensionHost,
+  documentId,
+  offset
+) => {
+  const tabCompletion = await extensionHost.invoke(
+    'executeTabCompletionProvider',
+    documentId,
+    offset
+  )
+  return tabCompletion
+}

package/src/parts/ExtensionHost/ExtensionHostTextDocument.js

@@ -0,0 +1,35 @@
+export const textDocumentSyncInitial = (
+  extensionHost,
+  uri,
+  textDocumentId,
+  languageId,
+  text
+) => {
+  return extensionHost.invoke(
+    'TextDocument.syncInitial',
+    uri,
+    textDocumentId,
+    languageId,
+    text
+  )
+}
+
+export const textDocumentSyncIncremental = (
+  extensionHost,
+  textDocumentId,
+  changes
+) => {
+  return extensionHost.invoke(
+    'TextDocument.syncIncremental',
+    textDocumentId,
+    changes
+  )
+}
+
+export const setLanguageId = (extensionHost, textDocumentId, languageId) => {
+  return extensionHost.invoke(
+    'TextDocument.setLanguageId',
+    textDocumentId,
+    languageId
+  )
+}

package/src/parts/ExtensionHost/ExtensionHostTypeDefinition.js

@@ -0,0 +1,12 @@
+export const executeTypeDefinitionProvider = async (
+  extensionHost,
+  textDocumentId,
+  offset
+) => {
+  const result = await extensionHost.invoke(
+    'TypeDefinition.execute',
+    textDocumentId,
+    offset
+  )
+  return result
+}

package/src/parts/ExtensionHost/ExtensionHostWorkspace.js

@@ -0,0 +1,3 @@
+export const setWorkspacePath = (extensionHost, path) => {
+  return extensionHost.invoke('Workspace.setWorkspacePath', path)
+}

package/src/parts/ExtensionManagement/ExtensionManagement.ipc.js

@@ -0,0 +1,11 @@
+import * as Command from '../Command/Command.js'
+import * as ExtensionManagement from './ExtensionManagement.js'
+
+export const __initialize__ = () => {
+  Command.register('ExtensionManagement.install', ExtensionManagement.install)
+  Command.register('ExtensionManagement.uninstall', ExtensionManagement.uninstall)
+  Command.register('ExtensionManagement.enable', ExtensionManagement.enable)
+  Command.register('ExtensionManagement.disable', ExtensionManagement.disable)
+  Command.register('ExtensionManagement.getAllExtensions', ExtensionManagement.getAllExtensions)
+  Command.register('ExtensionManagement.getExtensions', ExtensionManagement.getExtensions)
+}

package/src/parts/ExtensionManagement/ExtensionManagement.js

@@ -0,0 +1,319 @@
+import { mkdir, readdir, rename, rm } from 'node:fs/promises'
+import { performance } from 'node:perf_hooks'
+import isObject from 'is-object'
+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'
+
+export const state = {
+  async getExtensions() {
+    if (process.env.ONLY_EXTENSION) {
+      return getExtensionManifests([process.env.ONLY_EXTENSION])
+    }
+    const builtinExtensions = await getBuiltinExtensions()
+    const installedExtensions = await getInstalledExtensions()
+    return [...builtinExtensions, ...installedExtensions]
+  },
+  async getThemeExtensions() {
+    const builtinExtensionsPath = Platform.getBuiltinExtensionsPath()
+    const dirents = await readdir(builtinExtensionsPath)
+    const paths = []
+    for (const dirent of dirents) {
+      if (isTheme(dirent)) {
+        paths.push(getAbsoluteBuiltinExtensionPath(dirent))
+      }
+    }
+    if (process.env.ONLY_EXTENSION && isTheme(process.env.ONLY_EXTENSION)) {
+      paths.push(process.env.ONLY_EXTENSION)
+    }
+    const builtinExtensions = await getExtensionManifests(paths)
+    return builtinExtensions
+  },
+}
+
+export const install = async (id) => {
+  // TODO this should be a stateless function, renderer-worker should have info on marketplace url
+  // TODO use command.execute
+  try {
+    const { download, extract } = await import('../Download/Download.js')
+    const marketplaceUrl = Platform.getMarketplaceUrl()
+    Debug.debug(`ExtensionManagement#install ${id}`)
+    const cachedExtensionsPath = Platform.getCachedExtensionsPath()
+    const extensionsPath = Platform.getExtensionsPath()
+    // TODO maybe a queue is over engineering here
+    await Queue.add('download', async () => {
+      Debug.debug(`ExtensionManagement#download ${id}`)
+      // TODO use command.execute
+      await download(
+        `${marketplaceUrl}/download/${id}`,
+        Path.join(cachedExtensionsPath, `${id}.tar.br`)
+      )
+      Debug.debug(`ExtensionManagement#extract ${id}`)
+      await extract(
+        Path.join(cachedExtensionsPath, `${id}.tar.br`),
+        Path.join(extensionsPath, id)
+      )
+    })
+    // TODO should this be here? (probably not)
+    // await ExtensionHost.enableExtension({
+    //   id,
+    //   type: 'marketplace',
+    // })
+  } catch (error) {
+    throw new Error.OperationalError({
+      cause: error,
+      code: 'E_EXT_INSTALL_FAILED',
+      message: `Failed to install extension "${id}"`,
+    })
+  }
+}
+
+export const uninstall = async (id) => {
+  try {
+    Debug.debug(`ExtensionManagement#uninstall ${id}`)
+    const extensionsPath = Platform.getExtensionsPath()
+    await rm(Path.join(extensionsPath, id), { recursive: true })
+  } catch (error) {
+    // if (error.code === 'ENOENT') {
+    //   return
+    // }
+    throw new Error.OperationalError({
+      cause: error,
+      code: 'E_EXT_UNINSTALL_FAILED',
+      message: `Failed to uninstall extension "${id}"`,
+    })
+  }
+}
+
+export const enable = async (id) => {
+  try {
+    Debug.debug(`ExtensionManagement#enable ${id}`)
+    const extensionsPath = Platform.getExtensionsPath()
+    const disabledExtensionsPath = Platform.getDisabledExtensionsPath()
+    await mkdir(extensionsPath, { recursive: true })
+    await rename(
+      Path.join(disabledExtensionsPath, id),
+      Path.join(extensionsPath, id)
+    )
+  } catch (error) {
+    throw new Error.OperationalError({
+      cause: error,
+      message: `Failed to enable extension "${id}"`,
+      code: 'E_EXTENSION_ENABLING_FAILED',
+    })
+  }
+}
+
+export const disable = async (id) => {
+  try {
+    Debug.debug(`ExtensionManagement#disable ${id}`)
+    const disabledExtensionsPath = Platform.getDisabledExtensionsPath()
+    const extensionsPath = Platform.getExtensionsPath()
+    await mkdir(disabledExtensionsPath, { recursive: true })
+    await rename(
+      Path.join(extensionsPath, id),
+      Path.join(disabledExtensionsPath, id)
+    )
+  } catch (error) {
+    throw new Error.OperationalError({
+      cause: error,
+      code: 'E_EXTENSION_DISABLING_FAILED',
+      message: `Failed to disable extension ${id}`,
+    })
+  }
+}
+
+const getAbsoluteDisabledPath = (dirent) => {
+  const disabledExtensionsPath = Platform.getDisabledExtensionsPath()
+  return Path.join(disabledExtensionsPath, dirent)
+}
+
+const getDisabledExtensionPaths = async () => {
+  try {
+    const disabledExtensionsPaths = Platform.getDisabledExtensionsPath()
+    const dirents = await readdir(disabledExtensionsPaths)
+    const paths = dirents.map(getAbsoluteDisabledPath)
+    return paths
+  } catch {
+    // TODO handle error
+    return []
+  }
+}
+
+const getAbsoluteBuiltinExtensionPath = (dirent) => {
+  const builtinExtensionsPath = Platform.getBuiltinExtensionsPath()
+  return Path.join(builtinExtensionsPath, dirent)
+}
+
+const isIncludedBuiltinExtension = (dirent) => {
+  const SKIPPED = [
+    'hello-world',
+    'vite',
+    'soundcloud',
+    'npm',
+    // 'builtin.git', ~40MB memory usage (too many file watchers)
+    // 'builtin.prettier',  ~20MB memory usage (maybe lazyload prettier)
+    // 'language-features-typescript',
+    // 'builtin.vscode-icons',
+  ]
+  return !SKIPPED.includes(dirent)
+}
+
+const getBuiltinExtensionPaths = async () => {
+  try {
+    const builtinExtensionsPath = Platform.getBuiltinExtensionsPath()
+    const dirents = await readdir(builtinExtensionsPath)
+    const filteredDirents = dirents.filter(isIncludedBuiltinExtension)
+    const paths = filteredDirents.map(getAbsoluteBuiltinExtensionPath)
+    return paths
+  } catch {
+    console.info('no builtin extension paths found')
+    return []
+  }
+}
+
+const getAbsoluteInstalledExtensionPath = (dirent) => {
+  const extensionsPath = Platform.getExtensionsPath()
+  return Path.join(extensionsPath, dirent)
+}
+
+const getInstalledExtensionPaths = async () => {
+  try {
+    const extensionsPath = Platform.getExtensionsPath()
+    const dirents = await readdir(extensionsPath)
+    const paths = dirents.map(getAbsoluteInstalledExtensionPath)
+    return paths
+  } catch (error) {
+    // TODO how to make typescript happy?
+    // @ts-ignore
+    if (error.code === 'ENOENT') {
+      // TODO what if mkdir fails?
+      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',
+    })
+  }
+}
+
+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: 'fulfilled',
+    }
+  } 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,
+      }),
+    }
+  }
+}
+
+const isRejected = (promise) => {
+  return promise.status === 'rejected'
+}
+
+/**
+ * @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
+}
+
+export const getInstalledExtensions = async () => {
+  const installedExtensionPaths = await getInstalledExtensionPaths()
+  const installedExtensions = await getExtensionManifests(
+    installedExtensionPaths
+  )
+  return installedExtensions
+}
+
+export const getExtensions = async () => {
+  return state.getExtensions()
+}
+
+const RE_THEME = /[a-z]+\.[a-z\-]*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 () => {
+  return state.getThemeExtensions()
+}
+
+export const getDisabledExtensions = async () => {
+  const disabledExtensionPaths = await getDisabledExtensionPaths()
+  const disabledExtensions = await getExtensionManifests(disabledExtensionPaths)
+  return disabledExtensions
+}
+
+export const getAllExtensions = async () => {
+  if (process.env.ONLY_EXTENSION) {
+    return getExtensionManifests([process.env.ONLY_EXTENSION])
+  }
+  const t1 = performance.now()
+  const [builtinExtensions, installedExtensions, disabledExtensions] =
+    // TODO handle error when one of them fails
+    await Promise.all([
+      getBuiltinExtensions(),
+      getInstalledExtensions(),
+      getDisabledExtensions(),
+    ])
+  const t4 = performance.now()
+  // TODO can optimize this by loading extension manifest while loading paths (though 2ms isn't a bottleneck right now)
+  // e.g.
+  // await Promise.all([getBuiltinExtensionPaths.then(getExtensionManifests), getInstalledExtensionPaths.then(getExtensionManifests)])
+  const timings = {
+    total: t4 - t1,
+  }
+  // console.log(timings)
+  return [...builtinExtensions, ...installedExtensions, ...disabledExtensions]
+}

package/src/parts/FileSystem/FileSystem.ipc.js

@@ -0,0 +1,32 @@
+import * as Command from '../Command/Command.js'
+import * as FileSystem from './FileSystem.js'
+
+// TODO ugly code here -> should be inside FileSystem.js
+const fileSystemWatch = (socket, id, path) => {
+  // const watcher = FileSystem.watch(path, {
+  //   onAll(...args) {
+  //     socket.send(JSON.stringify([/* callback */ id, /* event */ args]))
+
+  //   }
+  // }
+  // )
+  // socket.on('close', () => {
+  //   watcher.close()
+  // })
+}
+
+// TODO separate ipc from code like in renderer worker
+export const __initialize__ = () => {
+  Command.register('FileSystem.readFile', FileSystem.readFile)
+  Command.register('FileSystem.writeFile', FileSystem.writeFile)
+  Command.register('FileSystem.readDirWithFileTypes', FileSystem.readDirWithFileTypes)
+  Command.register('FileSystem.remove', FileSystem.remove)
+  Command.register('FileSystem.mkdir', FileSystem.mkdir)
+  // Command.register(106, fileSystemWatch) // TODO
+  Command.register('FileSystem.createFile', FileSystem.createFile)
+  Command.register('FileSystem.createFolder', FileSystem.createFolder)
+  Command.register('FileSystem.rename', FileSystem.rename)
+  Command.register('FileSystem.ensureFile', FileSystem.ensureFile)
+  Command.register('FileSystem.copy', FileSystem.copy)
+  Command.register('FileSystem.getPathSeparator', FileSystem.getPathSeparator)
+}