@lvce-editor/shared-process 0.0.2

package/src/parts/Electron/Electron.js

@@ -0,0 +1,99 @@
+import * as Callback from '../Callback/Callback.js'
+import * as ParentIpc from '../ParentIpc/ParentIpc.js'
+
+export const state = {
+  send(message) {
+    ParentIpc.electronSend(message)
+  },
+}
+
+const send = (method, ...params) => {
+  state.send({
+    jsonrpc: '2.0',
+    method,
+    params,
+  })
+}
+
+const invoke = async (method, ...params) => {
+  return new Promise((resolve, reject) => {
+    // TODO use one map instead of two
+    const callbackId = Callback.register(resolve, reject)
+    state.send({
+      jsonrpc: '2.0',
+      method,
+      params,
+      id: callbackId,
+    })
+  })
+}
+
+export const toggleDevtools = () => {
+  send(/* Window.toggleDevtools */ 6523)
+}
+
+export const windowMinimize = () => {
+  send(/* Window.minimize */ 6521)
+}
+
+export const windowMaximize = () => {
+  send(/* Window.maximize */ 6522)
+}
+
+export const windowUnmaximize = () => {
+  send(/* Window.unmaximize */ 6524)
+}
+
+export const windowClose = () => {
+  send(/* Window.close */ 6525)
+}
+
+export const windowReload = () => {
+  send(/* Window.reload */ 6526)
+}
+
+// TODO move these into separate files like done extension host
+
+export const windowOpenNew = () => {
+  send(/* AppWindow.openNew */ 8527)
+}
+
+export const about = () => {
+  send(/* About.open */ 20001)
+}
+
+export const showOpenDialog = async () => {
+  const result = await invoke(/* Dialog.showOpenDialog */ 20100)
+  return result
+}
+
+export const showMessageBox = async (message, buttons) => {
+  const result = await invoke(
+    /* Dialog.showMessageBox */ 20101,
+    message,
+    buttons
+  )
+  return result
+}
+
+export const crashMainProcess = () => {
+  send(/* Developer.crashMainProcess */ 7723)
+}
+
+export const getPerformanceEntries = async () => {
+  const result = await invoke(/* Developer.getPerformanceEntries */ 7722)
+  return result
+}
+
+export const beep = async () => {
+  // TODO when is remote should send to renderer worker
+  await invoke(/* Beep.beep */ 50000)
+}
+
+export const exit = async () => {
+  await invoke(/* App.exit */ 2211)
+}
+
+export const openProcessExplorer = async () => {
+  await invoke(/* ProcessExplorer.openProcessExplorer */ 8822)
+}

package/src/parts/Env/Env.js

@@ -0,0 +1,3 @@
+export const getFolder = () => {
+  return process.env.FOLDER
+}

package/src/parts/Error/Error.js

@@ -0,0 +1,30 @@
+import VError from 'verror'
+
+/**
+ *
+ * @param {unknown} cause
+ * @returns {cause is Error}
+ */
+const isError = (cause) => {
+  // @ts-ignore
+  return cause && cause.stack && cause.message
+}
+
+export class OperationalError extends VError {
+  /**
+   *
+   * @param {{cause?:unknown, message:string, code:string, stack?:any, codeFrame?:any, category?:string, stderr?:string   }} param0
+   */
+  constructor({ cause, message, code, stack, codeFrame, category, stderr }) {
+    if (isError(cause)) {
+      super(cause, message)
+    } else {
+      super(message)
+    }
+    this.code = code
+    this.originalStack = stack
+    this.originalCodeFrame = codeFrame
+    this.category = category
+    this.stderr = stderr
+  }
+}

package/src/parts/ErrorHandling/ErrorHandling.js

@@ -0,0 +1,40 @@
+import * as Socket from '../Socket/Socket.js'
+
+export const state = {
+  seenErrors: [],
+}
+
+const preparePrettyError = (error) => {
+  const cause = error.cause()
+  return {
+    message: error.message,
+    codeFrame: cause.codeFrame,
+    stack: cause.stack,
+  }
+}
+
+const printPrettyError = (prettyError) => {
+  console.error(
+    `${prettyError.message}\n${prettyError.codeFrame}\n${prettyError.stack}`
+  )
+}
+
+export const handleError = (error) => {
+  if (state.seenErrors.includes(error.message)) {
+    return
+  }
+  state.seenErrors.push(error.message)
+  const prettyError = preparePrettyError(error)
+  Socket.send({
+    jsonrpc: '2.0',
+    method: /* Dialog.showErrorDialogWithOptions */ 1494,
+    params: [
+      {
+        message: prettyError.message,
+        codeFrame: prettyError.codeFrame,
+        stack: prettyError.stack,
+      },
+    ],
+  })
+  printPrettyError(prettyError)
+}

package/src/parts/Exec/Exec.js

@@ -0,0 +1,16 @@
+import { execa } from 'execa'
+
+/**
+ *
+ * @param {string} command
+ * @param {string[]} args
+ * @param {import('execa').Options} options
+ * @returns
+ */
+export const exec = async (command, args, options) => {
+  const { stdout, stderr } = await execa(command, args, options)
+  return {
+    stdout,
+    stderr,
+  }
+}

package/src/parts/Extension/Extension.js

@@ -0,0 +1,7 @@
+export const install = (id) => {}
+
+export const uninstall = (id) => {}
+
+export const enable = (id) => {}
+
+export const disable = (id) => {}

package/src/parts/ExtensionHost/ExtensionHost.ipc.js

@@ -0,0 +1,80 @@
+import * as Command from '../Command/Command.js'
+import * as ExtensionHost from './ExtensionHost.js'
+import * as ExtensionHostCommand from './ExtensionHostCommand.js'
+import * as ExtensionHostCompletion from './ExtensionHostCompletion.js'
+import * as ExtensionHostSourceControl from './ExtensionHostSourceControl.js'
+import * as ExtensionHostTabCompletion from './ExtensionHostTabCompletion.js'
+import * as ExtensionHostStats from './ExtensionHostStats.js'
+import * as ExtensionHostFormatting from './ExtensionHostFormatting.js'
+import * as ExtensionHostTextDocument from './ExtensionHostTextDocument.js'
+import * as ExtensionHostHover from './ExtensionHostHover.js'
+import * as ExtensionHostDiagnostic from './ExtensionHostDiagnostic.js'
+import * as ExtensionHostRename from './ExtensionHostRename.js'
+import * as ExtensionHostDefinition from './ExtensionHostDefinition.js'
+import * as ExtensionHostFileSystem from './ExtensionHostFileSystem.js'
+import * as ExtensionHostManagement from './ExtensionHostManagement.js'
+import * as ExtensionHostWorkspace from './ExtensionHostWorkspace.js'
+import * as ExtensionHostOutput from './ExtensionHostOutput.js'
+import * as ExtensionHostLanguages from './ExtensionHostLanguages.js'
+import * as ExtensionHostColorTheme from './ExtensionHostColorTheme.js'
+import * as ExtensionHostKeyBindings from './ExtensionHostKeyBindings.js'
+import * as ExtensionHostIconTheme from './ExtensionHostIconTheme.js'
+import * as ExtensionHostStatusBar from './ExtensionHostStatusBar.js'
+import * as ExtensionHostQuickPick from './ExtensionHostQuickPick.js'
+import * as ExtensionHostBraceCompletion from './ExtensionHostBraceCompletion.js'
+import * as ExtensionHostReferences from './ExtensionHostReference.js'
+import * as ExtensionHostImplementation from './ExtensionHostImplementation.js'
+import * as ExtensionHostTypeDefinition from './ExtensionHostTypeDefinition.js'
+import * as ExtensionHostClosingTag from './ExtensionHostClosingTag.js'
+import * as ExtensionHostSemanticTokens from './ExtensionHostSemanticTokens.js'
+
+export const __initialize__ = () => {
+  Command.register('ExtensionHost.getCommands', ExtensionHostCommand.getCommandsIpc)
+  Command.register('ExtensionHostCompletion.execute', ExtensionHost.wrapExtensionHostCommand(ExtensionHostCompletion.executeCompletionProvider))
+  // Command.register(385, ExtensionHost.textDocumentSync)
+  Command.register('ExtensionHost.executeTabCompletionProvider', ExtensionHost.wrapExtensionHostCommand(ExtensionHostTabCompletion.executeTabCompletionProvider))
+  Command.register('ExtensionHost.getLanguages', ExtensionHostLanguages.getLanguages)
+  Command.register('ExtensionHost.getIconThemeJson', ExtensionHostIconTheme.getIconTheme)
+  Command.register('ExtensionHostKeyBindings.getKeyBindings', ExtensionHostKeyBindings.getKeyBindings)
+  Command.register('ExtensionHost.executeCommand', ExtensionHost.wrapExtensionHostCommand(ExtensionHostCommand.executeCommand))
+  Command.register('ExtensionHost.getColorThemeJson', ExtensionHostColorTheme.getColorThemeJson)
+  Command.register('ExtensionHost.getColorThemeNames', ExtensionHostColorTheme.getColorThemeNames)
+  Command.register('ExtensionHost.getMemoryUsage', ExtensionHost.wrapExtensionHostCommand(ExtensionHostStats.getMemoryUsage))
+  Command.register('ExtensionHost.getSourceControlBadgeCount', ExtensionHost.wrapExtensionHostCommand(ExtensionHostSourceControl.getSourceControlBadgeCount))
+  Command.register('ExtensionHost.format', ExtensionHost.wrapExtensionHostCommand(ExtensionHostFormatting.format))
+  Command.register('ExtensionHost.executeCommand', ExtensionHost.wrapExtensionHostCommand(ExtensionHostCommand.executeCommand))
+
+  Command.register('ExtensionHost.sourceControlGetChangedFiles', ExtensionHost.wrapExtensionHostCommand(ExtensionHostSourceControl.getSourceControlChangedFiles))
+  Command.register('ExtensionHost.getLanguageConfiguration', ExtensionHostLanguages.getLanguageConfiguration)
+  Command.register('ExtensionHost.getColorThemes', ExtensionHostColorTheme.getColorThemes)
+  Command.register('ExtensionHostTextDocument.syncFull', ExtensionHost.wrapExtensionHostCommand(ExtensionHostTextDocument.textDocumentSyncInitial))
+  Command.register('ExtensionHostHover.execute', ExtensionHost.wrapExtensionHostCommand(ExtensionHostHover.executeHoverProvider))
+  Command.register('ExtensionHostDiagnostic.execute', ExtensionHost.wrapExtensionHostCommand(ExtensionHostDiagnostic.executeDiagnosticProvider))
+  Command.register('ExtensionHostTextDocument.syncIncremental', ExtensionHost.wrapExtensionHostCommand(ExtensionHostTextDocument.textDocumentSyncIncremental))
+  Command.register('ExtensionHostRename.executePrepareRename', ExtensionHost.wrapExtensionHostCommand(ExtensionHostRename.executePrepareRename))
+  Command.register('ExtensionHostRename.executeRename', ExtensionHost.wrapExtensionHostCommand(ExtensionHostRename.executeRename))
+  Command.register('ExtensionHostDefinition.executeDefinitionProvider', ExtensionHost.wrapExtensionHostCommand(ExtensionHostDefinition.executeDefinitionProvider))
+  Command.register('ExtensionHostFileSystem.readFile', ExtensionHost.wrapExtensionHostCommand(ExtensionHostFileSystem.readFile))
+  Command.register('ExtensionHostFileSystem.writeFile', ExtensionHost.wrapExtensionHostCommand(ExtensionHostFileSystem.writeFile))
+  Command.register('ExtensionHostFileSystem.readDirWithFileTypes', ExtensionHost.wrapExtensionHostCommand(ExtensionHostFileSystem.readDirWithFileTypes))
+  Command.register('ExtensionHostFileSystem.remove', ExtensionHost.wrapExtensionHostCommand(ExtensionHostFileSystem.remove))
+  Command.register('ExtensionHostFileSystem.rename', ExtensionHost.wrapExtensionHostCommand(ExtensionHostFileSystem.rename))
+  Command.register('ExtensionHostSourceControl.acceptInput', ExtensionHost.wrapExtensionHostCommand(ExtensionHostSourceControl.sourceControlAcceptInput))
+  Command.register('ExtensionHost.start', ExtensionHost.start)
+  Command.register('ExtensionHost.activateAll', ExtensionHost.wrapExtensionHostCommand(ExtensionHostManagement.activateAll))
+  Command.register('ExtensionHost.enableExtension', ExtensionHost.wrapExtensionHostCommand(ExtensionHostManagement.enableExtension))
+  Command.register('ExtensionHostFileSystem.getPathSeparator', ExtensionHost.wrapExtensionHostCommand(ExtensionHostFileSystem.getPathSeparator))
+  Command.register('ExtensionHost.setWorkspacePath', ExtensionHost.wrapExtensionHostCommand(ExtensionHostWorkspace.setWorkspacePath))
+  Command.register('ExtensionHost.setWorkspaceRoot', ExtensionHost.wrapExtensionHostCommand(ExtensionHostWorkspace.setWorkspacePath))
+  Command.register('ExtensionHostOutput.getOutputChannels', ExtensionHost.wrapExtensionHostCommand(ExtensionHostOutput.getOutputChannels))
+  Command.register('ExtensionHost.getStatusBarItems', ExtensionHost.wrapExtensionHostCommand(ExtensionHostStatusBar.getStatusBarItems))
+  Command.register('ExtensionHostStatusBar.registerChangeListener', ExtensionHost.wrapExtensionHostCommand(ExtensionHostStatusBar.registerChangeListener))
+  Command.register('ExtensionHostTextDocument.setLanguageId', ExtensionHost.wrapExtensionHostCommand(ExtensionHostTextDocument.setLanguageId))
+  Command.register('ExtensionHostQuickPick.handleQuickPickResult', ExtensionHost.wrapExtensionHostCommand(ExtensionHostQuickPick.handleQuickPickResult))
+  Command.register('ExtensionHostBraceCompletion.executeBraceCompletionProvider', ExtensionHost.wrapExtensionHostCommand(ExtensionHostBraceCompletion.executeBraceCompletionProvider))
+  Command.register('ExtensionHostReferences.executeReferenceProvider', ExtensionHost.wrapExtensionHostCommand(ExtensionHostReferences.executeReferenceProvider))
+  Command.register('ExtensionHostImplementation.executeImplementationProvider', ExtensionHost.wrapExtensionHostCommand(ExtensionHostImplementation.executeImplementationProvider))
+  Command.register('ExtensionHostClosingTag.executeTypeDefinitionProvider', ExtensionHost.wrapExtensionHostCommand(ExtensionHostTypeDefinition.executeTypeDefinitionProvider))
+  Command.register('ExtensionHostClosingTag.executeClosingTagProvider', ExtensionHost.wrapExtensionHostCommand(ExtensionHostClosingTag.executeClosingTagProvider))
+  Command.register('ExtensionHostSemanticTokens.executeSemanticTokenProvider', ExtensionHost.wrapExtensionHostCommand(ExtensionHostSemanticTokens.executeSemanticTokenProvider))
+}

package/src/parts/ExtensionHost/ExtensionHost.js

@@ -0,0 +1,163 @@
+import VError from 'verror'
+import * as Callback from '../Callback/Callback.js'
+import * as ChildProcess from '../ChildProcess/ChildProcess.js'
+import * as Error from '../Error/Error.js'
+import * as JsonRpc from '../JsonRpc/JsonRpc.js'
+import * as Platform from '../Platform/Platform.js'
+import * as Socket from '../Socket/Socket.js'
+import * as Assert from '../Assert/Assert.js'
+// TODO maybe rename to extension host management for clarity
+
+// TODO needed? probably not
+const NULL_EXTENSION_HOST = {
+  dispose() {
+    throw new VError('not implemented')
+  },
+  send(message) {
+    throw new VError(
+      'extension host must be started before commands can be invoked'
+    )
+  },
+  async invoke(commandId, ...args) {
+    throw new VError(
+      'extension host must be started before commands can be invoked'
+    )
+  },
+}
+
+/**
+ * @type{{
+ *   extensionHost: {dispose:()=>void, invoke:(commandId, ...args)=>Promise<any>},
+ * }}
+ */
+export const state = {
+  extensionHost: NULL_EXTENSION_HOST,
+}
+
+const onMessage = (message) => {
+  if (message.id) {
+    if ('result' in message) {
+      Callback.resolve(message.id, message.result)
+    } else if ('error' in message) {
+      Callback.reject(
+        message.id,
+        new Error.OperationalError({
+          code: 'E_CALLBACK_REJECTED',
+          message: message.error.message,
+          stack: message.error.data.stack,
+          codeFrame: message.error.data.codeFrame,
+          // @ts-ignore
+          stderr: message.error.data.stderr,
+        })
+      )
+    } else {
+      Socket.send(message)
+    }
+  } else {
+    Socket.send(message)
+  }
+}
+
+// TODO this function is very ugly and has probably memory leaks
+export const start = async (socket) => {
+  try {
+    Assert.object(socket)
+    const extensionHostPath = Platform.getExtensionHostPath()
+    const childProcess = ChildProcess.fork(extensionHostPath, {
+      execArgv: [
+        '--experimental-json-modules',
+        '--max-old-space-size=60',
+        '--enable-source-maps',
+      ],
+      env: {
+        ...process.env,
+        LOGS_DIR: Platform.getLogsDir(),
+        CONFIG_DIR: Platform.getConfigDir(),
+      },
+    })
+
+    const handleChildProcessError = (error) => {
+      console.error(`[Extension Host] ${error}`)
+    }
+
+    const handleChildProcessExit = (exitCode) => {
+      console.info(
+        `[SharedProcess] Extension Host exited with code ${exitCode}`
+      )
+      state.extensionHost = NULL_EXTENSION_HOST
+    }
+
+    const handleSocketClose = () => {
+      console.info('[shared process] disposing extension host')
+      childProcess.kill()
+    }
+
+    socket.on('close', handleSocketClose)
+
+    childProcess.on('error', handleChildProcessError)
+
+    childProcess.on('exit', handleChildProcessExit)
+
+    state.extensionHost = {
+      invoke(...args) {
+        return JsonRpc.invoke(childProcess, ...args)
+      },
+      dispose() {
+        childProcess.kill()
+      },
+    }
+
+    await new Promise((resolve, reject) => {
+      const handleFirstError = (error) => {
+        cleanup()
+        reject(error)
+      }
+      const handleFirstExit = (exitCode) => {
+        cleanup()
+        reject(
+          new globalThis.Error(`Extension Host exited with code ${exitCode}`)
+        )
+      }
+      const handleFirstMessage = () => {
+        cleanup()
+        childProcess.on('message', onMessage)
+        resolve(undefined)
+      }
+      const handleSocketClose = () => {
+        cleanup()
+        childProcess.off('error', handleChildProcessError)
+        childProcess.off('exit', handleChildProcessExit)
+        resolve(undefined)
+      }
+      const cleanup = () => {
+        childProcess.off('error', handleFirstError)
+        childProcess.off('exit', handleFirstExit)
+        childProcess.off('message', handleFirstMessage)
+      }
+      childProcess.on('error', handleFirstError)
+      childProcess.on('exit', handleFirstExit)
+      childProcess.on('message', handleFirstMessage)
+      socket.on('close', handleSocketClose)
+    })
+  } catch (error) {
+    // @ts-ignore
+    throw new VError(error, 'Failed to start extension host')
+  }
+}
+
+export const stop = () => {
+  state.extensionHost.dispose()
+  state.extensionHost = NULL_EXTENSION_HOST
+}
+
+export const restart = () => {
+  stop()
+  start()
+}
+
+export const wrapExtensionHostCommand = (fn) => {
+  const wrappedExtensionHostCommand = (...args) => {
+    return fn(state.extensionHost, ...args)
+  }
+  return wrappedExtensionHostCommand
+}

package/src/parts/ExtensionHost/ExtensionHostBraceCompletion.js

@@ -0,0 +1,14 @@
+export const executeBraceCompletionProvider = async (
+  extensionHost,
+  documentId,
+  offset,
+  openingBrace
+) => {
+  const completions = await extensionHost.invoke(
+    'BraceCompletion.execute',
+    documentId,
+    offset,
+    openingBrace
+  )
+  return completions
+}

package/src/parts/ExtensionHost/ExtensionHostClosingTag.js

@@ -0,0 +1,14 @@
+export const executeClosingTagProvider = async (
+  extensionHost,
+  documentId,
+  offset,
+  openingBrace
+) => {
+  const completions = await extensionHost.invoke(
+    'ClosingTag.execute',
+    documentId,
+    offset,
+    openingBrace
+  )
+  return completions
+}

package/src/parts/ExtensionHost/ExtensionHostColorTheme.js

@@ -0,0 +1,60 @@
+import * as Error from '../Error/Error.js'
+import * as ExtensionManagement from '../ExtensionManagement/ExtensionManagement.js'
+import * as ReadJson from '../JsonFile/JsonFile.js'
+
+// TODO test this function
+// TODO very similar with getIconTheme
+export const getColorThemeJson = async (colorThemeId) => {
+  const extensions = await ExtensionManagement.getThemeExtensions()
+  for (const extension of extensions) {
+    if (!extension.colorThemes) {
+      continue
+    }
+    for (const colorTheme of extension.colorThemes) {
+      if (colorTheme.id !== colorThemeId) {
+        continue
+      }
+      const absolutePath = `${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 Error.OperationalError({
+    code: 'E_COLOR_THEME_NOT_FOUND',
+    message: `Color theme "${colorThemeId}" not found in extensions folder`,
+  })
+}
+
+const getColorThemeInfo = (extension) => {
+  return extension.colorThemes || []
+}
+
+const getExtensionColorThemeNames = (extension) => {
+  return extension.colorThemes || []
+}
+
+const getColorThemeId = (colorTheme) => {
+  return colorTheme.id
+}
+
+// TODO should send names to renderer worker or names with ids?
+export const getColorThemeNames = async () => {
+  const extensions = await ExtensionManagement.getExtensions()
+  const colorThemes = extensions.flatMap(getExtensionColorThemeNames)
+  const colorThemeNames = colorThemes.map(getColorThemeId)
+  return colorThemeNames
+}
+
+export const getColorThemes = async () => {
+  const extensions = await ExtensionManagement.getExtensions()
+  const colorThemes = extensions.flatMap(getColorThemeInfo)
+  return colorThemes
+}

package/src/parts/ExtensionHost/ExtensionHostCommand.js

@@ -0,0 +1,19 @@
+import * as ExtensionManagement from '../ExtensionManagement/ExtensionManagement.js'
+
+export const executeCommand = async (extensionHost, commandId, ...args) => {
+  return extensionHost.invoke('executeCommand', commandId, ...args)
+}
+
+const getExtensionCommands = (extension) => {
+  return extension.commands || []
+}
+
+export const getCommands = async () => {
+  const extensions = await ExtensionManagement.getExtensions()
+  return extensions.flatMap(getExtensionCommands)
+}
+
+export const getCommandsIpc = async () => {
+  const commands = await getCommands()
+  return commands
+}

package/src/parts/ExtensionHost/ExtensionHostCompletion.js

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

package/src/parts/ExtensionHost/ExtensionHostDefinition.js

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

package/src/parts/ExtensionHost/ExtensionHostDiagnostic.js

@@ -0,0 +1,7 @@
+export const executeDiagnosticProvider = async (extensionHost, documentId) => {
+  const diagnostics = await extensionHost.invoke(
+    'Diagnostic.execute',
+    documentId
+  )
+  return diagnostics
+}

package/src/parts/ExtensionHost/ExtensionHostFileSystem.js

@@ -0,0 +1,23 @@
+export const readFile = (extensionHost, protocol, uri) => {
+  return extensionHost.invoke('FileSystem.readFile', protocol, uri)
+}
+
+export const writeFile = (extensionHost, protocol, uri, content) => {
+  return extensionHost.invoke('FileSystem.writeFile', protocol, uri, content)
+}
+
+export const readDirWithFileTypes = (extensionHost, protocol, uri) => {
+  return extensionHost.invoke('FileSystem.readDirWithFileTypes', protocol, uri)
+}
+
+export const remove = (extensionHost, protocol, uri) => {
+  return extensionHost.invoke('FileSystem.remove', protocol, uri)
+}
+
+export const rename = (extensionHost, protocol, oldUri, newUri) => {
+  return extensionHost.invoke('FileSystem.rename', protocol, oldUri, newUri)
+}
+
+export const getPathSeparator = (extensionHost, protocol) => {
+  return extensionHost.invoke('FileSystem.getPathSeparator', protocol)
+}

package/src/parts/ExtensionHost/ExtensionHostFormatting.js

@@ -0,0 +1,4 @@
+export const format = async (extensionHost, path, content) => {
+  const formattedContent = await extensionHost.invoke('format', path, content)
+  return formattedContent
+}

package/src/parts/ExtensionHost/ExtensionHostHover.js

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

package/src/parts/ExtensionHost/ExtensionHostIconTheme.js

@@ -0,0 +1,35 @@
+import * as Error from '../Error/Error.js'
+import * as ExtensionManagement from '../ExtensionManagement/ExtensionManagement.js'
+import * as ReadJson from '../JsonFile/JsonFile.js'
+
+export const getIconTheme = async (iconThemeId) => {
+  const extensions = await ExtensionManagement.getExtensions()
+  for (const extension of extensions) {
+    if (!extension.iconThemes) {
+      continue
+    }
+    for (const iconTheme of extension.iconThemes) {
+      if (iconTheme.id !== iconThemeId) {
+        continue
+      }
+      const absolutePath = `${extension.path}/${iconTheme.path}`
+      try {
+        const json = await ReadJson.readJson(absolutePath)
+        return {
+          extensionPath: extension.path,
+          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 Error.OperationalError({
+    code: 'E_ICON_THEME_NOT_FOUND',
+    message: `Icon theme "${iconThemeId}" not found in extensions folder`,
+  })
+}