@lvce-editor/server 0.0.26 → 0.0.29

package/static/bf7d47a/packages/renderer-worker/src/parts/ExtensionHost/ExtensionHostFormatting.js

@@ -0,0 +1,10 @@
+import * as ExtensionHostShared from './ExtensionHostShared.js'
+
+export const executeFormattingProvider = (editor) => {
+  return ExtensionHostShared.executeProvider({
+    event: `onFormatting:${editor.languageId}`,
+    method: 'ExtensionHostFormatting.executeFormattingProvider',
+    params: [editor.id],
+    noProviderFoundMessage: 'No formatting provider found',
+  })
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/ExtensionHost/ExtensionHostHover.js

@@ -0,0 +1,15 @@
+import * as ExtensionHostShared from './ExtensionHostShared.js'
+
+const combineResults = (results) => {
+  return results[0]
+}
+
+export const executeHoverProvider = (editor, offset) => {
+  return ExtensionHostShared.executeProviders({
+    event: `onHover:${editor.languageId}`,
+    method: 'ExtensionHostHover.execute',
+    params: [editor.id, offset],
+    noProviderFoundMessage: 'No hover provider found',
+    combineResults,
+  })
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/ExtensionHost/ExtensionHostImplementation.js

@@ -0,0 +1,15 @@
+import * as ExtensionHostShared from './ExtensionHostShared.js'
+
+const combineResults = (results) => {
+  return results[0]
+}
+
+export const executeImplementationProvider = (editor, offset) => {
+  return ExtensionHostShared.executeProviders({
+    event: `onImplementation:${editor.languageId}`,
+    method: 'ExtensionHostImplementation.executeImplementationProvider',
+    params: [editor.id, offset],
+    noProviderFoundMessage: 'No implementation provider found',
+    combineResults,
+  })
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/ExtensionHost/ExtensionHostReference.js

@@ -0,0 +1,20 @@
+import * as Assert from '../Assert/Assert.js'
+import * as ExtensionHostShared from './ExtensionHostShared.js'
+
+const combineResults = (results) => {
+  return results[0]
+}
+
+export const executeReferenceProvider = async (editor, offset) => {
+  const result = await ExtensionHostShared.executeProviders({
+    event: `onReferences:${editor.languageId}`,
+    method: 'ExtensionHostReferences.executeReferenceProvider',
+    params: [editor.id, offset],
+    noProviderFoundMessage: 'no reference providers found',
+    noProviderFoundResult: [],
+    combineResults,
+  })
+  Assert.array(result)
+  console.log({ result })
+  return result
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/ExtensionHost/ExtensionHostRename.js

@@ -0,0 +1,29 @@
+import * as ExtensionHostShared from './ExtensionHostShared.js'
+
+const combineResultsPrepareRename = (results) => {
+  return results[0]
+}
+
+export const executePrepareRenameProvider = (editor, offset) => {
+  return ExtensionHostShared.executeProviders({
+    event: `onRename:${editor.languageId}`,
+    method: 'ExtensionHostRename.executePrepareRename',
+    params: [editor.id, offset],
+    noProviderFoundMessage: 'No rename provider found',
+    combineResults: combineResultsPrepareRename,
+  })
+}
+
+const combineResultsRename = (results) => {
+  return results[0]
+}
+
+export const executeRenameProvider = (editor, offset, newName) => {
+  return ExtensionHostShared.executeProviders({
+    event: `onRename:${editor.languageId}`,
+    method: 'ExtensionHostRename.executeRename',
+    params: [editor.id, offset, newName],
+    noProviderFoundMessage: 'No rename provider found',
+    combineResults: combineResultsPrepareRename,
+  })
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/ExtensionHost/ExtensionHostSemanticTokens.js

@@ -0,0 +1,16 @@
+import * as ExtensionHostShared from './ExtensionHostShared.js'
+
+const combineResults = (results) => {
+  return results[0]
+}
+
+export const executeSemanticTokenProvider = (editor) => {
+  return ExtensionHostShared.executeProviders({
+    event: `onSemanticTokens:${editor.languageId}`,
+    method: 'ExtensionHostSemanticTokens.executeSemanticTokenProvider',
+    params: [editor.id],
+    noProviderFoundMessage: 'No Semantic Token Provider found',
+    noProviderFoundResult: [],
+    combineResults,
+  })
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/ExtensionHost/ExtensionHostShared.js

@@ -0,0 +1,49 @@
+import * as ExtensionHostManagement from '../ExtensionHostManagement/ExtensionHostManagement.js'
+
+export const executeProviders = async ({
+  event,
+  method,
+  params,
+  noProviderFoundMessage = 'No provider found',
+  noProviderFoundResult,
+  combineResults,
+}) => {
+  const extensionHosts = await ExtensionHostManagement.activateByEvent(event)
+  if (extensionHosts.length === 0) {
+    return noProviderFoundResult ?? undefined
+  }
+  const promises = []
+  for (const extensionHost of extensionHosts) {
+    promises.push(extensionHost.ipc.invoke(method, ...params))
+  }
+  const results = await Promise.all(promises)
+  console.log({ results })
+  const combinedResult = combineResults(results)
+  console.log({ combinedResult })
+  return combinedResult
+}
+
+export const executeProvider = async ({
+  event,
+  method,
+  params,
+  noProviderFoundMessage,
+}) => {
+  const extensionHosts = await ExtensionHostManagement.activateByEvent(event)
+  if (extensionHosts.length === 0) {
+    throw new Error(noProviderFoundMessage)
+  }
+  const promises = []
+  for (const extensionHost of extensionHosts) {
+    promises.push(extensionHost.ipc.invoke(method, ...params))
+  }
+  const results = await Promise.all(promises)
+  return results[0]
+}
+
+export const execute = async ({ method, params }) => {
+  const extensionHosts = ExtensionHostManagement.getExtensionHosts()
+  for (const extensionHost of extensionHosts) {
+    await extensionHost.ipc.invoke(method, ...params)
+  }
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/ExtensionHost/ExtensionHostSourceControl.js

@@ -0,0 +1,28 @@
+import * as ExtensionHostShared from './ExtensionHostShared.js'
+
+export const acceptInput = async (text) => {
+  return ExtensionHostShared.executeProvider({
+    event: 'onSourceControl',
+    method: 'ExtensionHost.sourceControlAcceptInput',
+    params: [text],
+    noProviderFoundMessage: 'No source control provider found',
+  })
+}
+
+export const getChangedFiles = async () => {
+  return ExtensionHostShared.executeProvider({
+    event: 'onSourceControl',
+    method: 'ExtensionHost.sourceControlGetChangedFiles',
+    params: [],
+    noProviderFoundMessage: 'No source control provider found',
+  })
+}
+
+export const getFileBefore = (path) => {
+  return ExtensionHostShared.executeProvider({
+    event: 'onSourceControl',
+    method: 'ExtensionHost.sourceControlGetFileBefore',
+    params: [path],
+    noProviderFoundMessage: 'No source control provider found',
+  })
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/ExtensionHost/ExtensionHostStatusBarItems.js

@@ -0,0 +1,41 @@
+import * as Listener from '../Listener/Listener.js'
+import * as ExtensionHostShared from './ExtensionHostShared.js'
+
+export const state = {
+  changeListeners: [],
+}
+
+const getStatusBarItemsFromExtension = (extension) => {
+  if (!extension.statusBarItems) {
+    return []
+  }
+  return extension.statusBarItems
+}
+
+const getStatusBarItemsFromExtensions = (extensions) => {
+  return extensions.flatMap(getStatusBarItemsFromExtension)
+}
+
+const combineResults = (results) => {
+  return []
+}
+
+export const getStatusBarItems = () => {
+  return ExtensionHostShared.executeProviders({
+    event: 'onStatusBarItem',
+    method: 'ExtensionHost.getStatusBarItems',
+    params: [],
+    noProviderFoundMessage: 'No status bar item provider found',
+    noProviderFoundResult: [],
+    combineResults,
+  })
+}
+
+// TODO add function to dispose listener
+export const onChange = (listener) => {
+  const id = Listener.register(listener)
+  return ExtensionHostShared.execute({
+    method: 'ExtensionHostStatusBar.registerChangeListener',
+    params: [id],
+  })
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/ExtensionHost/ExtensionHostTabCompletion.js

@@ -0,0 +1,16 @@
+import * as ExtensionHostShared from './ExtensionHostShared.js'
+
+const combineResults = (results) => {
+  return results[0]
+}
+
+export const executeTabCompletionProvider = (editor, offset) => {
+  return ExtensionHostShared.executeProviders({
+    event: `onTabCompletion:${editor.languageId}`,
+    method: 'ExtensionHost.executeTabCompletionProvider',
+    params: [editor.id, offset],
+    noProviderFoundMessage: 'No tab completion provider found',
+    noProviderFoundResult: undefined,
+    combineResults,
+  })
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/ExtensionHost/ExtensionHostTextDocument.js

@@ -0,0 +1,29 @@
+import * as TextDocument from '../TextDocument/TextDocument.js'
+import * as ExtensionHostShared from './ExtensionHostShared.js'
+
+// TODO instead of sending full document from
+// shared process to renderer-worker to shared process
+// to extension host, extension host could just read file directly
+// or shared process could send extension host file to open
+// after sending file to renderer process
+export const handleEditorCreate = (editor) => {
+  const text = TextDocument.getText(editor)
+  return ExtensionHostShared.execute({
+    method: 'ExtensionHostTextDocument.syncFull',
+    params: [editor.uri, editor.id, editor.languageId, text],
+  })
+}
+
+export const handleEditorChange = (editor, changes) => {
+  return ExtensionHostShared.execute({
+    method: 'ExtensionHostTextDocument.syncIncremental',
+    params: [editor.id, changes],
+  })
+}
+
+export const handleEditorLanguageChange = (editor) => {
+  return ExtensionHostShared.execute({
+    method: 'ExtensionHostTextDocument.setLanguageId',
+    params: [editor.id, editor.languageId],
+  })
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/ExtensionHost/ExtensionHostTypeDefinition.js

@@ -0,0 +1,16 @@
+import * as ExtensionHostShared from './ExtensionHostShared.js'
+
+const combineResults = (results) => {
+  return results[0]
+}
+
+export const executeTypeDefinitionProvider = (editor, offset) => {
+  return ExtensionHostShared.executeProviders({
+    event: `onTypeDefinition:${editor.languageId}`,
+    method: 'ExtensionHostTypeDefinition.executeTypeDefinitionProvider',
+    params: [editor.id, offset],
+    noProviderFoundMessage: 'No type definition provider found',
+    noProviderFoundResult: undefined,
+    combineResults,
+  })
+}

package/static/bf7d47a/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/bf7d47a/packages/renderer-worker/src/parts/ExtensionHostIpc/ExtensionHostIpcWithMessagePort.js

@@ -0,0 +1,11 @@
+import * as Platform from '../Platform/Platform.js'
+import * as IpcParent from '../IpcParent/IpcParent.js'
+
+export const create = async () => {
+  const extensionHostWorkerUrl = Platform.getExtensionHostWorkerUrl()
+  return IpcParent.create({
+    method: IpcParent.Methods.MessagePort,
+    url: extensionHostWorkerUrl,
+    name: 'Extension Host',
+  })
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/ExtensionHostIpc/ExtensionHostIpcWithModuleWorker.js

@@ -0,0 +1,11 @@
+import * as Platform from '../Platform/Platform.js'
+import * as IpcParent from '../IpcParent/IpcParent.js'
+
+export const create = async () => {
+  const extensionHostWorkerUrl = Platform.getExtensionHostWorkerUrl()
+  return IpcParent.create({
+    method: IpcParent.Methods.ModuleWorker,
+    url: extensionHostWorkerUrl,
+    name: 'Extension Host',
+  })
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/ExtensionHostIpc/ExtensionHostIpcWithReferencePort.js

@@ -0,0 +1,11 @@
+import * as Platform from '../Platform/Platform.js'
+import * as IpcParent from '../IpcParent/IpcParent.js'
+
+export const create = async () => {
+  const extensionHostWorkerUrl = Platform.getExtensionHostWorkerUrl()
+  return IpcParent.create({
+    method: IpcParent.Methods.ReferencePort,
+    url: extensionHostWorkerUrl,
+    name: 'Extension Host',
+  })
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/ExtensionHostIpc/ExtensionHostIpcWithSharedProcess.js

@@ -0,0 +1,37 @@
+import * as SharedProcess from '../SharedProcess/SharedProcess.js'
+
+export const create = async () => {
+  // TODO maybe use direct websocket connection
+  // overhead would be that there is another websocket connection
+  // but benefit would be that messages aren't routed through shared process
+  // and that messages can be easier debugged:
+  // extension messages go throught extension websocket,
+  // shared process messages go through shared process websocket
+  const id = await SharedProcess.invoke(
+    /* ExtensionHost.start */ 'ExtensionHost.start'
+  )
+  console.log({ id })
+  let _onmessage
+  return {
+    get onmessage() {
+      return _onmessage
+    },
+    set onmessage(listener) {
+      _onmessage = listener
+      // TODO actually set listener
+    },
+    dispose() {
+      return SharedProcess.invoke(
+        /* ExtensionHost.send */ 'ExtensionHost.dispose',
+        /* id */ id
+      )
+    },
+    send(message) {
+      return SharedProcess.invoke(
+        /* ExtensionHost.send */ 'ExtensionHost.send',
+        /* id */ id,
+        /* message */ message
+      )
+    },
+  }
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/ExtensionHostIpc/ExtensionHostIpcWithWebSocket.js

@@ -0,0 +1,9 @@
+/* istanbul ignore file */
+import * as IpcParent from '../IpcParent/IpcParent.js'
+
+export const create = () => {
+  return IpcParent.create({
+    method: IpcParent.Methods.WebSocket,
+    protocol: 'lvce.extension-host',
+  })
+}

package/static/bf7d47a/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
+}