@lvce-editor/server 0.8.0 → 0.8.2

package/static/4ed83c7/packages/extension-host-worker/src/parts/ExtensionHostTextDocument/ExtensionHostTextDocument.js

@@ -0,0 +1,351 @@
+import * as Assert from '../Assert/Assert.js'
+
+// TODO when using textDocument.create sync with renderer worker only if necessary
+// e.g. when is virtual file system -> need to get from renderer worker
+// else just create it
+
+export const state = {
+  /** @type{any[]} */
+  onDidOpenEditorListeners: [],
+  /** @type{any[]} */
+  onWillChangeEditorListeners: [],
+  /** @type{any[]} */
+  onDidChangeTextDocumentListeners: [],
+  /** @type{any[]} */
+  onDidSaveTextDocumentListeners: [],
+  textDocuments: Object.create(null),
+}
+
+export const onWillChangeTextDocument = (listener) => {
+  state.onWillChangeEditorListeners.push(listener)
+}
+
+export const onDidChangeTextDocument = (listener) => {
+  state.onDidChangeTextDocumentListeners.push(listener)
+  // SharedProcess.send({
+  //   jsonrpc: '2.0',
+  //   method: 'onChangeDocumentListener',
+  //   params: [],
+  // })
+}
+
+export const onDidSaveTextDocument = (listener) => {
+  state.onDidSaveTextDocumentListeners.push(listener)
+}
+
+const applyEdits = (state, edits) => {
+  console.assert(state !== undefined)
+  console.assert(Array.isArray(edits))
+  for (const edit of edits) {
+    switch (edit.type) {
+      case /* singleLineEdit */ 1:
+        state.lines[edit.rowIndex] =
+          state.lines[edit.rowIndex].slice(0, edit.columnIndex - edit.deleted) +
+          edit.inserted +
+          state.lines[edit.rowIndex].slice(edit.columnIndex)
+        break
+      case /* splice */ 2:
+        state.lines.splice(edit.rowIndex, edit.count, ...edit.newLines)
+        break
+      default:
+        console.warn('unknown edit', edit)
+        break
+    }
+    // const rowIndex = lineAt(edit.offset)
+    // if (edit.text.includes('\n')) {
+    //   // TODO splice lines
+    // }
+    // state.lines[rowIndex]
+  }
+
+  // for (const listener of state.listeners) {
+  //   listener(state, edits)
+  // }
+  // TODO
+}
+
+export const getOffset = (textDocument, position) => {
+  let offset = 0
+  let rowIndex = 0
+  while (rowIndex++ < position.rowIndex) {
+    const newLineIndex = textDocument.text.indexOf('\n', offset)
+    offset = newLineIndex + 1
+  }
+  offset += position.columnIndex
+  return offset
+}
+
+// const toOffsetBasedEdit = (textDocument, documentEdit) => {
+//   switch (documentEdit.type) {
+//     case /* singleLineEdit */ 1: {
+//       const offset = getOffset(textDocument, documentEdit)
+//       return {
+//         offset,
+//         inserted: documentEdit.inserted,
+//         deleted: documentEdit.deleted,
+//         // type: /* singleLineEdit */ 1
+//       }
+//     }
+//     case /* splice */ 2:
+//       const offset = getOffset(textDocument, {
+//         rowIndex: documentEdit.rowIndex,
+//         columnIndex: textDocument.lines[documentEdit.rowIndex - 1].length,
+//       })
+//       const inserted = '\n' + documentEdit.newLines.join('\n')
+//       return {
+//         offset,
+//         inserted,
+//         deleted: 0 /* TODO */,
+//       }
+//   }
+// }
+
+// TODO incremental edits, don't send full text
+// export const applyEdit = (id, text, edits) => {
+//   const textDocument = get(id)
+//   textDocument.lines = text.split('\n')
+//   const offsetBasedEdits = edits.map((edit) =>
+//     toOffsetBasedEdit(textDocument, edit)
+//   )
+//   for (const listener of state.onDidChangeTextDocumentListeners) {
+//     // TODO avoid extra object allocation
+//     listener(textDocument, offsetBasedEdits)
+//   }
+// }
+
+// TODO data oriented vs object oriented
+// data -> simpler, exposes internals, sometimes weird/long (vscode.TextDocument.getText(textDocument))
+// object oriented -> hides internals, banana problem (textDocument.getText())
+
+// TODO send to shared process, which sends it to renderer worker
+// renderer worker sends back the edit
+// export const applyEdit2 = (textDocument, edit) => {
+//   if (VALIDATION_ENABLED) {
+//     assert(typeof textDocument === 'object')
+//     assert(textDocument !== null)
+//     assert(typeof textDocument.id === 'number')
+//     assert(textDocument.id > 0)
+//     assert(typeof textDocument.getText === 'function')
+//     assert(typeof edit === 'object')
+//     assert(typeof edit.offset === 'number')
+//     assert(typeof edit.inserted === 'string')
+//     assert(typeof edit.deleted === 'number')
+//   }
+
+//   let rowIndex = 0
+//   let offset = 0
+//   const lines = textDocument.getText().split('\n')
+//   while (offset < edit.offset) {
+//     offset += lines[rowIndex++].length + 1
+//   }
+//   rowIndex--
+//   offset -= lines[rowIndex].length + 1
+//   const edit2 = {
+//     rowIndex,
+//     inserted: edit.inserted,
+//     deleted: edit.deleted,
+//     columnIndex: edit.offset - offset + edit.deleted,
+//     type: 1,
+//   }
+
+//   // // TODO should be invoke and return boolean whether edit was applied or not
+//   SharedProcess.send({
+//     event: 'TextDocument.applyEdit',
+//     args: [/* id */ textDocument.id, /* edits */ edit2],
+//   })
+// }
+
+// export const create = (textDocumentId, languageId, content) => {
+//   const textDocument = {
+//     languageId,
+//     lines: content.split('\n'),
+//   }
+//   state.textDocuments[textDocumentId] = textDocument
+// }
+
+// const createTextDocument = (uri, languageId, text) => {
+//   if (VALIDATION_ENABLED) {
+//     assert(typeof uri === 'string')
+//     assert(typeof languageId === 'string')
+//     assert(typeof text === 'string')
+//   }
+//   const state = {
+//     /** @internal */
+//     lines: text.split('\n'),
+//     uri,
+//     languageId,
+//     getText() {
+//       return state.lines.join('\n')
+//     },
+//   }
+//   return state
+// }
+
+// export const sync = (documentId, languageId, text) => {
+//   const textDocument = get(documentId)
+//   if (!textDocument) {
+//     console.warn(`textDocument is undefined ${languageId}`)
+//     return
+//   }
+//   textDocument.languageId = languageId
+//   textDocument.lines = text.split('\n')
+//   // console.log('sync', JSON.stringify(text))
+// }
+
+const runListenerSafe = async (listener, ...args) => {
+  try {
+    await listener(...args)
+  } catch (error) {
+    // @ts-ignore
+    if (error && error.message) {
+      // @ts-ignore
+      error.message = 'Failed to run open listener: ' + error.message
+    }
+    console.error(error)
+  }
+}
+
+const runListenersSafe = (listeners, ...args) => {
+  for (const listener of listeners) {
+    runListenerSafe(listener, ...args)
+  }
+}
+
+export const syncFull = (uri, textDocumentId, languageId, text) => {
+  const textDocument = {
+    uri,
+    documentId: textDocumentId,
+    languageId,
+    text,
+  }
+  state.textDocuments[textDocumentId] = textDocument
+  runListenersSafe(state.onDidOpenEditorListeners, textDocument)
+}
+
+const getSyntheticChanges = (textDocument, changes) => {
+  // console.log({ textDocument, changes })
+  Assert.object(textDocument)
+  Assert.array(changes)
+  const change = changes[0]
+  const startOffset = getOffset(textDocument, change.start)
+  const endOffset = getOffset(textDocument, change.end)
+  const inserted = change.inserted.join('\n')
+  const syntheticChanges = [
+    {
+      startOffset,
+      endOffset,
+      inserted,
+    },
+  ]
+  return syntheticChanges
+}
+
+export const syncIncremental = (textDocumentId, changes) => {
+  Assert.number(textDocumentId)
+  Assert.array(changes)
+  const textDocument = state.textDocuments[textDocumentId]
+  if (!textDocument) {
+    console.warn(
+      `sync not possible, no matching textDocument with id ${textDocumentId}`
+    )
+    return
+  }
+  const syntheticChanges = getSyntheticChanges(textDocument, changes)
+  runListenersSafe(
+    state.onWillChangeEditorListeners,
+    textDocument,
+    syntheticChanges
+  )
+  const syntheticChange = syntheticChanges[0]
+  const oldText = textDocument.text
+  const before = oldText.slice(0, syntheticChange.startOffset)
+  const after = oldText.slice(syntheticChange.endOffset)
+  textDocument.text = before + syntheticChange.inserted + after
+  runListenersSafe(
+    state.onDidChangeTextDocumentListeners,
+    textDocument,
+    syntheticChanges
+  )
+}
+
+export const get = (textDocumentId) => {
+  const textDocument = state.textDocuments[textDocumentId]
+  return textDocument
+}
+
+export const getText = (textDocument) => {
+  return textDocument.text
+}
+
+export const getPosition = (textDocument, offset) => {
+  let index = 0
+  let rowIndex = 0
+  let newLineIndex = 0
+  const text = textDocument.text
+  while (index < offset) {
+    newLineIndex = text.indexOf('\n', index)
+    if (newLineIndex === -1) {
+      break
+    }
+    const newIndex = newLineIndex + 1
+    if (newIndex > offset) {
+      break
+    }
+    index = newIndex
+    rowIndex++
+  }
+  const columnIndex = offset - index
+  return {
+    rowIndex,
+    columnIndex,
+  }
+}
+
+const getSyntheticChange = (textDocument, edit) => {
+  const start = getPosition(textDocument, edit.offset - edit.deleted)
+  const end = getPosition(textDocument, edit.offset)
+  return {
+    start,
+    end,
+    inserted: edit.inserted.split('\n'),
+    deleted: [],
+  }
+}
+
+export const applyEdit = async (textDocument, edit) => {
+  throw new Error('not implemented')
+}
+
+export const onDidOpenTextDocument = (listener) => {
+  state.onDidOpenEditorListeners.push(listener)
+  for (const textDocument of Object.values(state.textDocuments)) {
+    runListenerSafe(listener, textDocument)
+  }
+}
+
+export const onWillChangeEditor = (listener) => {
+  state.onWillChangeEditorListeners.push(listener)
+}
+
+export const setLanguageId = (textDocumentId, languageId) => {
+  const newTextDocument = {
+    ...state.textDocuments[textDocumentId],
+    languageId,
+  }
+  state.textDocuments[textDocumentId] = newTextDocument
+  runListenersSafe(state.onDidOpenEditorListeners, newTextDocument)
+}
+
+export const getTextDocuments = () => {
+  return Object.values(state.textDocuments)
+}
+
+export const setFiles = (files) => {
+  for (const file of files) {
+    state.textDocuments[file.id] = file
+  }
+}
+
+export const getAll = () => {
+  return Object.values(state.textDocuments)
+}

package/static/4ed83c7/packages/extension-host-worker/src/parts/ExtensionHostTextSearch/ExtensionHostTextSearch.js

@@ -0,0 +1,36 @@
+import { VError } from '../VError/VError.js'
+
+export const state = {
+  textSearchProviders: Object.create(null),
+}
+
+export const registerTextSearchProvider = (textSearchProvider) => {
+  try {
+    if (!textSearchProvider) {
+      throw new Error('textSearchProvider is not defined')
+    }
+    if (!textSearchProvider.scheme) {
+      throw new Error('textSearchProvider is missing scheme')
+    }
+    state.textSearchProviders[textSearchProvider.scheme] = textSearchProvider
+  } catch (error) {
+    throw new VError(error, `Failed to register text search provider`)
+  }
+}
+
+export const executeTextSearchProvider = async (scheme, query) => {
+  try {
+    const textSearchProvider = state.textSearchProviders[scheme]
+    if (!textSearchProvider) {
+      throw new Error(`no text search provider for ${scheme} found`)
+    }
+    const results = await textSearchProvider.provideTextSearchResults(query)
+    return results
+  } catch (error) {
+    throw new VError(error, `Failed to execute text search provider`)
+  }
+}
+
+export const reset = () => {
+  state.textSearchProviders = Object.create(null)
+}

package/static/4ed83c7/packages/extension-host-worker/src/parts/ExtensionHostTypeDefinition/ExtensionHostTypeDefinition.js

@@ -0,0 +1,23 @@
+import * as Registry from '../Registry/Registry.js'
+
+const { registerTypeDefinitionProvider, executeTypeDefinitionProvider, reset } =
+  Registry.create({
+    name: 'TypeDefinition',
+    resultShape: {
+      allowUndefined: true,
+      type: 'object',
+      properties: {
+        uri: {
+          type: 'string',
+        },
+        startOffset: {
+          type: 'number',
+        },
+        endOffset: {
+          type: 'number',
+        },
+      },
+    },
+  })
+
+export { registerTypeDefinitionProvider, executeTypeDefinitionProvider, reset }

package/static/4ed83c7/packages/extension-host-worker/src/parts/ExtensionHostWorkspace/ExtensionHostWorkspace.js

@@ -0,0 +1,7 @@
+export const state = {
+  workspacePath: '',
+}
+
+export const setWorkspacePath = (path) => {
+  state.workspacePath = path
+}

package/static/4ed83c7/packages/extension-host-worker/src/parts/Registry/Registry.js

@@ -0,0 +1,102 @@
+import * as Validation from '../Validation/Validation.js'
+import { VError } from '../VError/VError.js'
+import * as TextDocument from '../ExtensionHostTextDocument/ExtensionHostTextDocument.js'
+
+const RE_UPPERCASE_LETTER = /[A-Z]/g
+
+const spaceOut = (camelCaseWord) => {
+  return camelCaseWord.replaceAll(RE_UPPERCASE_LETTER, (character, index) => {
+    if (index === 0) {
+      return character.toLowerCase()
+    }
+    return ' ' + character.toLowerCase()
+  })
+}
+
+const toCamelCase = (string) => {
+  return string[0].toLowerCase() + string.slice(1)
+}
+
+const improveValidationError = (name, validationError) => {
+  const camelCaseName = toCamelCase(name)
+  const spacedOutName = spaceOut(name)
+  const pre = `invalid ${spacedOutName} result`
+  const post = validationError
+    .replace('item', camelCaseName)
+    .replace(`result`, `${camelCaseName} item`)
+  return pre + ': ' + post
+}
+
+class NonError extends Error {
+  name = 'NonError'
+
+  constructor(message) {
+    super(message)
+  }
+}
+
+// ensureError based on https://github.com/sindresorhus/ensure-error/blob/main/index.js (License MIT)
+const ensureError = (input) => {
+  if (!(input instanceof Error)) {
+    return new NonError(input)
+  }
+  return input
+}
+
+export const create = ({ name, resultShape }) => {
+  const providers = Object.create(null)
+  const multipleResults = resultShape.type === 'array'
+  const methodName = multipleResults ? `provide${name}s` : `provide${name}`
+  return {
+    [`register${name}Provider`](provider) {
+      providers[provider.languageId] = provider
+    },
+    reset() {
+      for (const key in providers) {
+        delete providers[key]
+      }
+    },
+    async [`execute${name}Provider`](textDocumentId, ...params) {
+      try {
+        const textDocument = TextDocument.get(textDocumentId)
+        if (!textDocument) {
+          throw new Error(`textDocument with id ${textDocumentId} not found`)
+        }
+        const provider = providers[textDocument.languageId]
+        if (!provider) {
+          const spacedOutName = spaceOut(name)
+          throw new VError(
+            `No ${spacedOutName} provider found for ${textDocument.languageId}`
+          )
+        }
+        const result = await provider[methodName](textDocument, ...params)
+        const error = Validation.validate(result, resultShape)
+        if (error) {
+          const improvedError = improveValidationError(name, error)
+          throw new VError(improvedError)
+        }
+        return result
+      } catch (error) {
+        const actualError = ensureError(error)
+        const spacedOutName = spaceOut(name)
+        if (actualError && actualError.message) {
+          if (
+            actualError.message === 'provider[methodName] is not a function'
+          ) {
+            const camelCaseName = toCamelCase(name)
+
+            throw new VError(
+              `Failed to execute ${spacedOutName} provider: VError: ${camelCaseName}Provider.${methodName} is not a function`
+            )
+          }
+          const message =
+            actualError.name === 'Error'
+              ? `${actualError.message}`
+              : `${actualError.name}: ${actualError.message}`
+          actualError.message = `Failed to execute ${spacedOutName} provider: ${message}`
+        }
+        throw actualError
+      }
+    },
+  }
+}

package/static/4ed83c7/packages/extension-host-worker/src/parts/Rpc/Rpc.js

@@ -0,0 +1,45 @@
+import * as Command from '../Command/Command.js'
+
+export const listen = (ipc) => {
+  const handleMessage = async (event) => {
+    const message = event.data
+    if (message.method) {
+      try {
+        const result = await Command.execute(message.method, ...message.params)
+        ipc.send({
+          jsonrpc: '2.0',
+          id: message.id,
+          result,
+        })
+      } catch (error) {
+        console.error(error)
+        if (error && error instanceof Error && error.cause) {
+          console.error(error.cause)
+        }
+        if (
+          error &&
+          error instanceof Error &&
+          error.message &&
+          error.message.startsWith('method not found')
+        ) {
+          ipc.send({
+            jsonrpc: '2.0',
+            id: message.id,
+            error: {
+              code: -32601,
+              message: error.message,
+              data: error.stack,
+            },
+          })
+        } else {
+          ipc.send({
+            jsonrpc: '2.0',
+            id: message.id,
+            error,
+          })
+        }
+      }
+    }
+  }
+  ipc.onmessage = handleMessage
+}

package/static/4ed83c7/packages/extension-host-worker/src/parts/VError/VError.js

@@ -0,0 +1,14 @@
+const combineMessages = (error, message) => {
+  if (error && error.message) {
+    return `${message}: ${error.message}`
+  }
+  return `${error}`
+}
+
+export class VError extends Error {
+  constructor(error, message) {
+    const combinedMessage = combineMessages(error, message)
+    super(combinedMessage)
+    this.name = 'VError'
+  }
+}

package/static/4ed83c7/packages/extension-host-worker/src/parts/Validation/Validation.js

@@ -0,0 +1,92 @@
+const getType = (value) => {
+  switch (typeof value) {
+    case 'number':
+      return 'number'
+    case 'function':
+      return 'function'
+    case 'string':
+      return 'string'
+    case 'object':
+      if (value === null) {
+        return 'null'
+      }
+      if (Array.isArray(value)) {
+        return 'array'
+      }
+      return 'object'
+    case 'boolean':
+      return 'boolean'
+    case 'undefined':
+      return 'undefined'
+    default:
+      return 'unknown'
+  }
+}
+
+const validateResultObject = (result, resultShape) => {
+  if (!resultShape.properties) {
+    return undefined
+  }
+  for (const [key, value] of Object.entries(resultShape.properties)) {
+    const expectedType = value.type
+    const actualType = getType(result[key])
+    if (expectedType !== actualType) {
+      return `item.${key} must be of type ${expectedType}`
+    }
+  }
+  return undefined
+}
+
+const validateResultArray = (result, resultShape) => {
+  for (const item of result) {
+    const actualType = getType(item)
+    const expectedType = resultShape.items.type
+    if (actualType !== expectedType) {
+      return `expected result to be of type ${expectedType} but was of type ${actualType}`
+    }
+  }
+  return undefined
+}
+
+const getPreviewObject = (item) => {
+  return 'object'
+}
+
+const getPreviewArray = (item) => {
+  if (item.length === 0) {
+    return '[]'
+  }
+  return 'array'
+}
+
+const getPreview = (item) => {
+  const type = getType(item)
+  switch (type) {
+    case 'object':
+      return getPreviewObject(item)
+    case 'array':
+      return getPreviewArray(item)
+    default:
+      return `${item}`
+  }
+}
+
+export const validate = (item, schema) => {
+  const actualType = getType(item)
+  const expectedType = schema.type
+  if (actualType !== expectedType) {
+    if (schema.allowUndefined && item === undefined) {
+      return undefined
+    }
+    const preview = getPreview(item)
+    return `item must be of type ${expectedType} but is ${preview}`
+  }
+  switch (actualType) {
+    case 'object':
+      return validateResultObject(item, schema)
+    case 'array':
+      return validateResultArray(item, schema)
+  }
+  // TODO use json schema to validate result
+  return undefined
+}