@lvce-editor/server 0.0.28 → 0.0.31

package/static/0e4d46a/packages/renderer-worker/src/parts/ExtensionHostIpc/ExtensionHostIpc.js

@@ -0,0 +1,84 @@
+import * as Callback from '../Callback/Callback.js'
+import { JsonRpcError } from '../Errors/Errors.js'
+import * as JsonRpc from '../JsonRpc/JsonRpc.js'
+
+export const Methods = {
+  SharedProcess: 1,
+  ModuleWebWorker: 2,
+  WebSocket: 3,
+  Messageport: 4,
+  ReferencePort: 5,
+}
+
+const getModule = (method) => {
+  switch (method) {
+    case Methods.SharedProcess:
+      return import('./ExtensionHostIpcWithSharedProcess.js')
+    case Methods.ModuleWebWorker:
+      return import('./ExtensionHostIpcWithModuleWorker.js')
+    case Methods.WebSocket:
+      return import('./ExtensionHostIpcWithWebSocket.js')
+    case Methods.ReferencePort:
+      return import('./ExtensionHostIpcWithReferencePort.js')
+    case Methods.Messageport:
+      return import('./ExtensionHostIpcWithMessagePort.js')
+    default:
+      throw new Error(`unexpected extension host type: ${method}`)
+  }
+}
+
+const isResultMessage = (message) => {
+  return 'result' in message
+}
+
+const isErrorMessage = (message) => {
+  return 'error' in message
+}
+
+const restoreError = (error) => {
+  if (error instanceof Error) {
+    return error
+  }
+  if (error.code && error.code === -32601) {
+    console.log('create json rpc error')
+    const restoredError = new JsonRpcError(error.message)
+    restoredError.stack = error.stack
+    return restoredError
+  }
+  const restoredError = new Error(error.message)
+  if (error.data.stack) {
+    restoredError.stack = error.data.stack
+  }
+  if (error.data.codeFrame) {
+    // @ts-ignore
+    restoredError.codeFrame = error.data.codeFrame
+  }
+  return restoredError
+}
+
+const handleMessage = (message) => {
+  if (message.id) {
+    if (isResultMessage(message)) {
+      Callback.resolve(message.id, message.result)
+    } else if (isErrorMessage(message)) {
+      const restoredError = restoreError(message.error)
+      Callback.reject(message.id, restoredError)
+    } else {
+      throw new JsonRpcError('unexpected message type')
+    }
+  } else {
+    throw new JsonRpcError('unexpected message type')
+  }
+}
+
+export const listen = async (method) => {
+  const module = await getModule(method)
+  const ipc = await module.create()
+  // TODO maybe pass handleMessage as paramter to make code more functional
+  ipc.onmessage = handleMessage
+  return {
+    invoke(method, ...params) {
+      return JsonRpc.invoke(ipc, method, ...params)
+    },
+  }
+}

package/static/0e4d46a/packages/renderer-worker/src/parts/ExtensionHostManagement/ExtensionHostManagement.js

@@ -0,0 +1,183 @@
+import * as Assert from '../Assert/Assert.js'
+import * as Command from '../Command/Command.js'
+import * as ExtensionMeta from '../ExtensionMeta/ExtensionMeta.js'
+import * as Languages from '../Languages/Languages.js'
+import * as Platform from '../Platform/Platform.js'
+import * as Viewlet from '../Viewlet/Viewlet.js'
+import * as TextDocument from '../TextDocument/TextDocument.js'
+import * as GlobalEventBus from '../GlobalEventBus/GlobalEventBus.js'
+import * as ExtensionHostManagementBrowser from './ExtensionHostManagementBrowser.js'
+import * as ExtensionHostManagementNode from './ExtensionHostManagementNode.js'
+import * as ExtensionHostManagementShared from './ExtensionHostManagementShared.js'
+import * as ViewletStates from '../ViewletStates/ViewletStates.js'
+
+export const state = {
+  /**
+   * @type {any[]}
+   */
+  extensionHosts: [],
+}
+
+const getExtensionHostManagementTypes = () => {
+  const platform = Platform.getPlatform()
+  switch (platform) {
+    case 'web':
+      return [ExtensionHostManagementBrowser]
+    case 'remote':
+    case 'electron':
+      return [ExtensionHostManagementBrowser, ExtensionHostManagementNode]
+    default:
+      throw new Error('unsupported platform')
+  }
+}
+
+const getExtensionsToActivate = (extensions, event) => {
+  const extensionsToActivate = []
+  for (const extension of extensions) {
+    if (extension.activation && extension.activation.includes(event)) {
+      extensionsToActivate.push(extension)
+    }
+  }
+  return extensionsToActivate
+}
+
+const getExtensionsWithError = (extensions) => {
+  const extensionsWithError = []
+  for (const extension of extensions) {
+    if (extension.status === 'rejected') {
+      extensionsWithError.push(extension)
+    }
+  }
+  return extensionsWithError
+}
+
+const handleExtensionActivationError = async (extension) => {
+  const message = extension.reason.message
+  if (message.includes(`Failed to load extension manifest: ENOENT`)) {
+    return
+  }
+  const codeFrame = extension.reason.jse_cause.codeFrame
+  const stack = extension.reason.originalStack
+  await Command.execute(
+    /* Dialog.showMessage */ 'Dialog.showMessage',
+    /* error */ { message, codeFrame, stack }
+  )
+}
+
+const getManagersWithExtensionsToActivate = (
+  extensionHostManagers,
+  extensions
+) => {
+  const managersToActivate = []
+  for (const manager of extensionHostManagers) {
+    const toActivate = []
+    for (const extension of extensions) {
+      if (manager.canActivate(extension)) {
+        toActivate.push(extension)
+      }
+    }
+    if (toActivate.length > 0) {
+      managersToActivate.push({ manager, toActivate })
+    }
+  }
+  return managersToActivate
+}
+
+const startTextDocumentSyncing = async (extensionHost) => {
+  const handleEditorCreate = (editor) => {
+    const text = TextDocument.getText(editor)
+    return extensionHost.ipc.invoke(
+      'ExtensionHostTextDocument.syncFull',
+      editor.uri,
+      editor.id,
+      editor.languageId,
+      text
+    )
+  }
+  GlobalEventBus.addListener('editor.create', handleEditorCreate)
+
+  const handleEditorChange = (editor, changes) => {
+    return extensionHost.ipc.invoke(
+      'ExtensionHostTextDocument.syncIncremental',
+      editor.id,
+      changes
+    )
+  }
+  GlobalEventBus.addListener('editor.change', handleEditorChange)
+
+  const handleEditorLanguageChange = (editor) => {
+    return extensionHost.ipc.invoke(
+      'ExtensionHostTextDocument.setLanguageId',
+      editor.id,
+      editor.languageId
+    )
+  }
+
+  GlobalEventBus.addListener(
+    'editor.languageChange',
+    handleEditorLanguageChange
+  )
+
+  const instances = ViewletStates.getAllInstances()
+  const editorInstance = instances.EditorText
+  if (editorInstance) {
+    await handleEditorCreate(editorInstance.state)
+  }
+  console.log('finish text document synching')
+}
+
+// TODO add tests for this
+export const activateByEvent = async (event) => {
+  Assert.string(event)
+  if (!Languages.hasLoaded()) {
+    await Languages.waitForLoad()
+  }
+  // TODO should not query extensions multiple times
+  const extensions = await ExtensionMeta.getExtensions()
+
+  // TODO if many (more than two?) extensions cannot be loaded,
+  // it shouldn't should that many error messages
+  const extensionsWithError = getExtensionsWithError(extensions)
+  for (const extension of extensionsWithError) {
+    await handleExtensionActivationError(extension)
+  }
+  const extensionsToActivate = getExtensionsToActivate(extensions, event)
+  // TODO how to handle when multiple reference providers are registered for nodejs and webworker extension host?
+  // what happens when all of them / some of them throw error?
+  // what happens when some of them take very long to activate?
+
+  const extensionHostManagerTypes = getExtensionHostManagementTypes()
+  const extensionHostsWithExtensions = getManagersWithExtensionsToActivate(
+    extensionHostManagerTypes,
+    extensionsToActivate
+  )
+  const extensionHosts = []
+  for (const managerWithExtensions of extensionHostsWithExtensions) {
+    const extensionHost =
+      await ExtensionHostManagementShared.startExtensionHost(
+        managerWithExtensions.manager.name,
+        managerWithExtensions.manager.ipc
+      )
+    Assert.object(extensionHost)
+    for (const extension of managerWithExtensions.toActivate) {
+      // TODO tell extension host to activate extension
+      await extensionHost.ipc.invoke(
+        'ExtensionHostExtension.enableExtension',
+        extension
+      )
+      // TODO register text document change listener and sync text documents
+      await startTextDocumentSyncing(extensionHost)
+    }
+    extensionHosts.push(extensionHost)
+  }
+
+  state.extensionHosts = extensionHosts
+
+  // TODO support querying completion items from multiple extension hosts
+  // e.g. completion items from node extension host and word based completions from web worker extension host
+  return extensionHosts
+}
+
+export const getExtensionHosts = () => {
+  return state.extensionHosts
+}

package/static/0e4d46a/packages/renderer-worker/src/parts/ExtensionHostManagement/ExtensionHostManagementShared.js

@@ -0,0 +1,76 @@
+import * as Command from '../Command/Command.js'
+import * as ExtensionMeta from '../ExtensionMeta/ExtensionMeta.js'
+import * as Languages from '../Languages/Languages.js'
+import * as ExtensionHostIpc from '../ExtensionHostIpc/ExtensionHostIpc.js'
+
+/**
+ * @enum
+ */
+const ExtensionHostState = {
+  Off: 0,
+  Loading: 1,
+  Running: 2,
+  Error: 3,
+}
+
+export const state = {
+  extensionPromiseCache: Object.create(null),
+  extensionHosts: Object.create(null),
+  pendingIpcs: Object.create(null),
+}
+
+const toActivatableExtension = (extension) => {
+  return {
+    path: extension.path,
+    id: extension.id,
+    main: extension.main,
+  }
+}
+
+// const startExtensionHost = async (type) => {
+//   return ExtensionHostIpc.listen(ExtensionHostIpc.Methods.SharedProcess)
+// }
+
+export const startExtensionHost = async (name, ipcType) => {
+  const exisingIpcPromise = state.pendingIpcs[name]
+  if (exisingIpcPromise) {
+    const ipc = await exisingIpcPromise
+    return {
+      name: ipcType,
+      ipc,
+    }
+  }
+  if (state.extensionHosts[name]) {
+    return state.extensionHosts[name]
+  }
+  const promise = ExtensionHostIpc.listen(ipcType)
+  state.pendingIpcs[name] = promise
+  const ipc = await promise
+  delete state.pendingIpcs[name]
+  state.extensionHosts[name] = {
+    state: ExtensionHostState.Running,
+    ipc,
+    name: ipcType,
+  }
+  return state.extensionHosts[name]
+}
+
+export const stopExtensionHost = async (key) => {
+  const existingExtensionHost = state.extensionHosts[key]
+  if (existingExtensionHost) {
+    switch (existingExtensionHost.state) {
+      case ExtensionHostState.Off:
+        throw new Error('extension host cannot be off')
+      case ExtensionHostState.Loading:
+      case ExtensionHostState.Error:
+        existingExtensionHost.ipc.dispose()
+        break
+      default:
+        throw new Error('invalid extension host state')
+    }
+  }
+}
+
+export const canActivate = (manager, extensions) => {
+  return extensions.some(manager.canActivate)
+}

package/static/0e4d46a/packages/renderer-worker/src/parts/ExtensionMeta/ExtensionMeta.ipc.js

@@ -0,0 +1,7 @@
+import * as ExtensionMeta from './ExtensionMeta.js'
+
+// prettier-ignore
+export const Commands = {
+  // Command.register('ExtensionMeta.addExtension', ExtensionMeta.addExtension)
+  'ExtensionMeta.addWebExtension': ExtensionMeta.addWebExtension
+}

package/static/0e4d46a/packages/renderer-worker/src/parts/Extensions/Extensions.ipc.js

@@ -0,0 +1,8 @@
+import * as Command from '../Command/Command.js'
+import * as Extensions from './Extensions.js'
+
+// prettier-ignore
+export const Commands = {
+  'Extensions.openExtensionsFolder': Extensions.openExtensionsFolder,
+  'Extensions.openCachedExtensionsFolder': Extensions.openCachedExtensionsFolder,
+}

package/static/0e4d46a/packages/renderer-worker/src/parts/FileSystem/FileSystem.ipc.js

@@ -0,0 +1,15 @@
+import * as FileSystem from './FileSystem.js'
+
+// TODO who calls this?
+// TODO how to return value?
+
+// prettier-ignore
+export const Commands = {
+  'FileSystem.readFile': FileSystem.readFile,
+  'FileSystem.remove': FileSystem.remove,
+  'FileSystem.readDirWithFileTypes': FileSystem.readDirWithFileTypes,
+  'FileSystem.writeFile': FileSystem.writeFile,
+  'FileSystem.mkdir': FileSystem.mkdir,
+}
+
+// TODO maybe no ipc needed for this module

package/static/0e4d46a/packages/renderer-worker/src/parts/FileSystem/FileSystem.js

@@ -0,0 +1,135 @@
+// TODO file system providers should be lazy loaded (maybe)
+
+import * as FileSystemExtensionHost from '../ExtensionHost/ExtensionHostFileSystem.js'
+import * as FileSystemApp from './FileSystemApp.js'
+import * as FileSystemDisk from './FileSystemDisk.js'
+import * as FileSystemGitHub from './FileSystemGitHub.js'
+import * as FileSystemWeb from './FileSystemWeb.js'
+import * as FileSystemData from './FileSystemData.js'
+import * as FileSystemMemory from './FileSystemMemory.js'
+// TODO when it rejects, it should throw a custom error,
+// FileSystemError
+
+// TODO lazyload different file system providers
+
+const RE_PROTOCOL = /^([a-z]+):\/\//
+
+const getProtocol = (uri) => {
+  const protocolMatch = uri.match(RE_PROTOCOL)
+  if (protocolMatch) {
+    return protocolMatch[1]
+  }
+  return ''
+}
+
+export const state = {
+  fileSystems: Object.create(null),
+}
+
+// TODO extension host should be able to register arbitrary protocols (except app, http, https, file, )
+state.fileSystems['extension-host'] = FileSystemExtensionHost
+state.fileSystems.app = FileSystemApp
+state.fileSystems.github = FileSystemGitHub
+state.fileSystems.web = FileSystemWeb
+state.fileSystems.data = FileSystemData
+state.fileSystems.memfs = FileSystemMemory
+
+const getFileSystem = (protocol) => {
+  return state.fileSystems[protocol] || FileSystemDisk
+}
+
+const PROTOCOL_POST_FIX_LENGTH = 3
+
+const getPath = (protocol, uri) => {
+  if (protocol === '') {
+    return uri
+  }
+  return uri.slice(protocol.length + PROTOCOL_POST_FIX_LENGTH)
+}
+
+export const readFile = (uri) => {
+  const protocol = getProtocol(uri)
+  const path = getPath(protocol, uri)
+  const fileSystem = getFileSystem(protocol)
+  return fileSystem.readFile(path)
+}
+
+export const remove = async (uri) => {
+  const protocol = getProtocol(uri)
+  const path = getPath(protocol, uri)
+  const fileSystem = getFileSystem(protocol)
+  await fileSystem.remove(path)
+}
+
+export const rename = async (oldUri, newUri) => {
+  const protocol = getProtocol(oldUri)
+  const oldPath = getPath(protocol, oldUri)
+  const newPath = getPath(protocol, newUri)
+  const fileSystem = getFileSystem(protocol)
+  await fileSystem.rename(oldPath, newPath)
+}
+
+export const mkdir = async (uri) => {
+  const protocol = getProtocol(uri)
+  const path = getPath(protocol, uri)
+  const fileSystem = getFileSystem(protocol)
+  await fileSystem.mkdir(path)
+}
+
+export const writeFile = async (uri, content) => {
+  const protocol = getProtocol(uri)
+  const path = getPath(protocol, uri)
+  const fileSystem = getFileSystem(protocol)
+  await fileSystem.writeFile(path, content)
+}
+
+export const readDirWithFileTypes = (uri) => {
+  const protocol = getProtocol(uri)
+  const path = getPath(protocol, uri)
+  const fileSystem = getFileSystem(protocol)
+  return fileSystem.readDirWithFileTypes(path)
+}
+
+export const unwatch = (id) => {
+  throw new Error('not implemented')
+}
+
+export const unwatchAll = () => {
+  throw new Error('not implemented')
+}
+
+export const getBlobUrl = (uri) => {
+  const protocol = getProtocol(uri)
+  const path = getPath(protocol, uri)
+  const fileSystem = getFileSystem(protocol)
+  return fileSystem.getBlobUrl(path)
+}
+
+export const copy = (sourceUri, targetUri) => {
+  // TODO what if it is not the same file system?
+  const protocol = getProtocol(sourceUri)
+  const fileSystem = getFileSystem(protocol)
+  const sourcePath = getPath(protocol, sourceUri)
+  const targetPath = getPath(protocol, targetUri)
+  return fileSystem.copy(sourcePath, targetPath)
+}
+
+export const getPathSeparator = (uri) => {
+  const protocol = getProtocol(uri)
+  const fileSystem = getFileSystem(protocol)
+  return fileSystem.getPathSeparator(protocol)
+}
+
+export const getRealPath = (uri) => {
+  const protocol = getProtocol(uri)
+  const path = getPath(protocol, uri)
+  const fileSystem = getFileSystem(protocol)
+  return fileSystem.getRealPath(path)
+}
+
+export const stat = (uri) => {
+  const protocol = getProtocol(uri)
+  const path = getPath(protocol, uri)
+  const fileSystem = getFileSystem(protocol)
+  return fileSystem.stat(path)
+}

package/static/0e4d46a/packages/renderer-worker/src/parts/FileSystem/FileSystemDisk.js

@@ -0,0 +1,85 @@
+import * as Platform from '../Platform/Platform.js'
+import * as SharedProcess from '../SharedProcess/SharedProcess.js'
+
+export const name = 'Disk'
+
+export const copy = (source, target) => {
+  return SharedProcess.invoke(
+    /* FileSystem.copy */ 'FileSystem.copy',
+    /* source */ source,
+    /* target */ target
+  )
+}
+
+export const readFile = (path) => {
+  return SharedProcess.invoke(
+    /* FileSystem.readFile */ 'FileSystem.readFile',
+    /* path */ path
+  )
+}
+
+export const remove = (path) => {
+  return SharedProcess.invoke(
+    /* FileSystem.remove */ 'FileSystem.remove',
+    /* path */ path
+  )
+}
+
+export const rename = (oldUri, newUri) => {
+  return SharedProcess.invoke(
+    /* FileSystem.rename */ 'FileSystem.rename',
+    /* oldPath */ oldUri,
+    /* newPath */ newUri
+  )
+}
+
+export const mkdir = (path) => {
+  return SharedProcess.invoke(
+    /* FileSystem.mkdir */ 'FileSystem.mkdir',
+    /* path */ path
+  )
+}
+
+export const writeFile = async (path, content) => {
+  await SharedProcess.invoke(
+    /* FileSystem.writeFile */ 'FileSystem.writeFile',
+    /* path */ path,
+    /* content */ content
+  )
+}
+
+export const ensureFile = async () => {}
+
+export const readDirWithFileTypes = (path) => {
+  return SharedProcess.invoke(
+    /* FileSystem.readDirWithFileTypes */ 'FileSystem.readDirWithFileTypes',
+    /* path */ path
+  )
+}
+
+export const getBlobUrl = (path) => {
+  return `/remote/${path}`
+}
+
+export const getPathSeparator = () => {
+  if (Platform.getPlatform() === 'web') {
+    return '/'
+  }
+  return SharedProcess.invoke(
+    /* FileSystem.getPathSeparator */ 'FileSystem.getPathSeparator'
+  )
+}
+
+export const getRealPath = (path) => {
+  return SharedProcess.invoke(
+    /* FileSystem.getRealPath */ 'FileSystem.getRealPath',
+    /* path */ path
+  )
+}
+
+export const stat = (path) => {
+  return SharedProcess.invoke(
+    /* FileSystem.stat */ 'FileSystem.stat',
+    /* path */ path
+  )
+}

package/static/0e4d46a/packages/renderer-worker/src/parts/FindInWorkspace/FindInWorkspace.ipc.js

@@ -0,0 +1,6 @@
+import * as FindInWorkspace from './FindInWorkspace.js'
+
+// prettier-ignore
+export const Commands = {
+  'FindInWorkspace.findInWorkspace': FindInWorkspace.findInWorkspace
+}

package/static/0e4d46a/packages/renderer-worker/src/parts/FindWidget/FindWidget.ipc.js

@@ -0,0 +1,7 @@
+import * as FindWidget from './FindWidget.js'
+
+export const Commands = {
+  'FindWidget.create': FindWidget.create,
+  'FindWidget.dispose': FindWidget.dispose,
+  'FindWidget.setValue': FindWidget.setValue,
+}