@lvce-editor/server 0.0.28 → 0.0.31

package/static/f9b8874/packages/renderer-worker/src/parts/EditorCommand/EditorCommandTabCompletion.js

@@ -1,43 +0,0 @@
-import * as ExtensionHostTabCompletion from '../ExtensionHost/ExtensionHostTabCompletion.js'
-import * as TextDocument from '../TextDocument/TextDocument.js'
-import * as EditorSnippet from './EditorCommandSnippet.js'
-import * as Assert from '../Assert/Assert.js'
-import * as EditorShowMessage from './EditorCommandShowMessage.js'
-
-const getTabCompletion = async (editor) => {
-  const offset = TextDocument.offsetAt(editor, editor.cursor)
-  const tabCompletion =
-    await ExtensionHostTabCompletion.executeTabCompletionProvider(
-      editor,
-      offset
-    )
-  return tabCompletion
-}
-
-const getErrorMessage = (error) => {
-  return `${error}`
-}
-
-export const editorTabCompletion = async (editor) => {
-  try {
-    // TODO race condition
-    // TODO get tab completion for each cursor
-    const tabCompletion = await getTabCompletion(editor)
-    if (!tabCompletion) {
-      console.log({ tabCompletion })
-      return editor
-    }
-    return EditorSnippet.editorSnippet(editor, tabCompletion)
-  } catch (error) {
-    console.error(error)
-    // TODO cursor should always be of type object
-    const position = Array.isArray(editor.cursor)
-      ? editor.cursor[0]
-      : editor.cursor
-    return EditorShowMessage.showErrorMessage(
-      editor,
-      position,
-      getErrorMessage(error)
-    )
-  }
-}

package/static/f9b8874/packages/renderer-worker/src/parts/EditorDiagnostics/EditorDiagnostics.ipc.js

@@ -1,6 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as EditorDiagnostics from './EditorDiagnostics.js'
-
-export const __initialize__ = () => {
-  Command.register('EditorDiagnostics.hydrate', EditorDiagnostics.hydrate)
-}

package/static/f9b8874/packages/renderer-worker/src/parts/EditorError/EditorError.ipc.js

@@ -1,6 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as EditorError from './EditorError.js'
-
-export const __initialize__ = () => {
-  Command.register(3900, EditorError.show)
-}

package/static/f9b8874/packages/renderer-worker/src/parts/EditorError/EditorError.js

@@ -1,13 +0,0 @@
-import * as EditorPosition from '../EditorCommand/EditorCommandPosition.js'
-import * as RendererProcess from '../RendererProcess/RendererProcess.js'
-
-export const show = async (editor, message, position) => {
-  const x = EditorPosition.x(editor, position)
-  const y = EditorPosition.y(editor, position)
-  await RendererProcess.invoke(
-    /* EditorError.show */ 'EditorError.show',
-    /* message */ message,
-    /* x */ x,
-    /* y */ y
-  )
-}

package/static/f9b8874/packages/renderer-worker/src/parts/EditorRename/EditorRename.ipc.js

@@ -1,8 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as EditorRename from './EditorRename.js'
-
-export const __initialize__ = () => {
-  Command.register('EditorRename.open', EditorRename.open)
-  Command.register('EditorRename.finish', EditorRename.finish)
-  Command.register('EditorRename.abort', EditorRename.abort)
-}

package/static/f9b8874/packages/renderer-worker/src/parts/EditorRename/EditorRename.js

@@ -1,94 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as Editor from '../Editor/Editor.js'
-import * as EditorPosition from '../EditorCommand/EditorCommandPosition.js'
-import * as ExtensionHostRename from '../ExtensionHost/ExtensionHostRename.js'
-import * as RendererProcess from '../RendererProcess/RendererProcess.js'
-import * as TextDocument from '../TextDocument/TextDocument.js'
-
-export const state = {
-  editor: undefined,
-}
-
-const prepareRename = async (editor) => {
-  const offset = TextDocument.offsetAt(editor, editor.cursor)
-  return ExtensionHostRename.executePrepareRenameProvider(editor, offset)
-}
-
-const rename = (editor, newName) => {
-  const offset = TextDocument.offsetAt(editor, editor.cursor)
-  return ExtensionHostRename.executeRenameProvider(editor, offset)
-}
-
-export const open = async (editor) => {
-  // TODO handle error and add tests for handled error
-  const prepareRenameResult = await prepareRename(editor)
-
-  // TODO race condition, what is when editor is closed before promise resolves
-
-  if (prepareRenameResult.canRename) {
-    const x = EditorPosition.x(editor, editor.cursor)
-    const y = EditorPosition.y(editor, editor.cursor)
-    // const prepareRenameResult = await prepareRename(editor)
-    // console.log({ prepareRenameResult })
-    await RendererProcess.invoke(
-      /* EditorRename.openWidget */ 4512,
-      /* x */ x,
-      /* y */ y
-    )
-  } else {
-    // TODO also show error when promise rejects
-    await Command.execute(
-      /* EditorError.show */ 3900,
-      /* editor */ editor,
-      /* message */ 'You cannot rename this element',
-      /* position */ editor.cursor
-    )
-  }
-}
-
-const toPositionBasedEdits = (textDocument, edits) => {
-  const positionBasedEdits = []
-  for (const edit of edits) {
-    const start = TextDocument.positionAt(textDocument, edit.offset)
-    const end = TextDocument.positionAt(
-      textDocument,
-      edit.offset + edit.inserted.length - edit.deleted
-    )
-    positionBasedEdits.push({
-      start,
-      end,
-      inserted: edit.inserted.split('\n'),
-      deleted: [''],
-    })
-    console.log(edit)
-  }
-  return positionBasedEdits
-}
-
-// TODO how to best apply workspace edit?
-const applyWorkspaceEdits = async (editor, workspaceEdits) => {
-  if (workspaceEdits.length === 0) {
-    return
-  }
-  const workspaceEdit = workspaceEdits[0]
-  const positionBasedEdits = toPositionBasedEdits(
-    editor.textDocument,
-    workspaceEdit.edits
-  )
-  Editor.scheduleDocumentAndCursorsSelections(editor, positionBasedEdits)
-}
-
-export const finish = async (editor) => {
-  const newName = await RendererProcess.invoke(/* EditorRename.finish */ 4513)
-  console.log('do actual rename', { value: newName })
-  // TODO support canceling rename (e.g. when user presses escape)
-  const workspaceEdits = await rename(editor, newName)
-  await applyWorkspaceEdits(editor, workspaceEdits)
-  // console.log({ workspaceEdits })
-  // Editor.scheduleDocumentAndSelections(editor)
-  // console.log({ workspaceEdits })
-}
-
-export const abort = async () => {
-  await RendererProcess.invoke(/* EditorRename.closeWidget */ 4514)
-}

package/static/f9b8874/packages/renderer-worker/src/parts/Env/Env.js

@@ -1 +0,0 @@
-export const isWorker = typeof WorkerGlobalScope !== 'undefined'

package/static/f9b8874/packages/renderer-worker/src/parts/ErrorHandling/ErrorHandling.ipc.js

@@ -1,6 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as ErrorHandling from './ErrorHandling.js'
-
-export const __initialize__ = () => {
-  Command.register('ErrorHandling.handleError', ErrorHandling.handleError)
-}

package/static/f9b8874/packages/renderer-worker/src/parts/ErrorHandling/ErrorHandling.js

@@ -1,99 +0,0 @@
-import * as Command from '../Command/Command.js'
-
-// TODO use https://github.com/stack-tools-js/stack-tools to print error
-
-const enhanceErrorMessage = (error) => {
-  if (!error) {
-    return {
-      message: `Error: ${error}`,
-      stack: undefined,
-      codeFrame: undefined,
-    }
-  }
-  let message = `${error}`
-  while (error.cause) {
-    error = error.cause
-    message += `: ${error}`
-  }
-  console.log({ error })
-  return {
-    message,
-    stack: error.originalStack,
-    codeFrame: error.originalCodeFrame,
-    category: error.category,
-    stderr: error.stderr,
-  }
-}
-
-// const getErrorMessage = (error) => {
-//   let message = ``
-//   if (error && error.message) {
-//     message += error.message
-//   }
-//   if (error && error.stack) {
-//     message += `\n${error.stack}`
-//   }
-//   if (error && error.cause) {
-//     message += getErrorMessage(error.cause)
-//   }
-//   return message
-// }
-
-// const printError = (error) => {
-//   const message = getErrorMessage(error)
-//   console.error(message)
-// }
-
-const printError = (error) => {
-  console.error(error)
-  if (error && error.cause) {
-    console.error('caused by')
-    printError(error.cause)
-  }
-}
-
-// TODO state is not needed here but because jest doesn't support mocking for esm yet this is a workaround
-export const state = {
-  async handleError(error) {
-    printError(error)
-    const enhancedErrorMessage = enhanceErrorMessage(error)
-    await Command.execute(
-      /* Notification.create */ 'Notification.create',
-      /* type */ 'error',
-      /* text */ enhancedErrorMessage.message
-    )
-  },
-  async showErrorDialog(error) {
-    const enhancedErrorMessage = enhanceErrorMessage(error)
-    await Command.execute(
-      /* Dialog.showMessage */ 'Dialog.showMessage',
-      /* message */ enhancedErrorMessage
-    )
-  },
-  seenWarnings: [],
-}
-
-export const handleError = async (error) => {
-  try {
-    await state.handleError(error)
-  } catch {
-    // ignore
-  }
-}
-
-export const showErrorDialog = async (error) => {
-  try {
-    await state.showErrorDialog(error)
-  } catch {
-    // ignore
-  }
-}
-
-export const warn = (...args) => {
-  const stringified = JSON.stringify(args)
-  if (state.seenWarnings.includes(stringified)) {
-    return
-  }
-  state.seenWarnings.push(stringified)
-  console.warn(...args)
-}

package/static/f9b8874/packages/renderer-worker/src/parts/ExtensionHost/ExtensionHostCore.ipc.js

@@ -1,8 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as ExtensionHostCore from './ExtensionHostCore.js'
-
-// prettier-ignore
-export const __initialize__ = () => {
-  Command.register('ExtensionHost.startWebExtensionHost', ExtensionHostCore.startWebExtensionHost)
-  Command.register('ExtensionHost.loadWebExtension', ExtensionHostCore.loadWebExtension)
-}

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

@@ -1,79 +0,0 @@
-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)
-  restoredError.stack = error.stack
-  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)
-      console.log({ restoredError })
-      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/f9b8874/packages/renderer-worker/src/parts/ExtensionHostManagement/ExtensionHostManagement.js

@@ -1,178 +0,0 @@
-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'
-
-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
-  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.invoke(
-      'ExtensionHostTextDocument.syncIncremental',
-      editor.id,
-      changes
-    )
-  }
-  GlobalEventBus.addListener('editor.change', handleEditorChange)
-
-  const handleEditorLanguageChange = (editor) => {
-    return extensionHost.invoke(
-      'ExtensionHostTextDocument.setLanguageId',
-      editor.id,
-      editor.languageId
-    )
-  }
-
-  GlobalEventBus.addListener(
-    'editor.languageChange',
-    handleEditorLanguageChange
-  )
-
-  const instances = Viewlet.state.instances
-  const editorInstance = instances.EditorText
-  if (editorInstance) {
-    await handleEditorCreate(editorInstance.state)
-  }
-  console.log('finish text document synching')
-}
-
-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
-}