@lvce-editor/server 0.0.28 → 0.0.31

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

@@ -0,0 +1,81 @@
+import * as Assert from '../Assert/Assert.js'
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+import * as EditorPosition from './EditorCommandPosition.js'
+
+export const state = {
+  timeout: -1,
+}
+
+/**
+ *
+ * @param {any} editor
+ * @param {number} rowIndex
+ * @param {number} columnIndex
+ * @param {string} message
+ * @param {boolean} isError
+ * @returns
+ */
+export const editorShowMessage = async (
+  editor,
+  rowIndex,
+  columnIndex,
+  message,
+  isError
+) => {
+  Assert.object(editor)
+  Assert.number(rowIndex)
+  Assert.number(columnIndex)
+  Assert.string(message)
+  const x = EditorPosition.x(editor, rowIndex, columnIndex)
+  const y = EditorPosition.y(editor, rowIndex, columnIndex)
+  const displayErrorMessage = message
+  await RendererProcess.invoke(
+    /* Viewlet.send */ 'Viewlet.send',
+    /* id */ 'EditorText',
+    /* method */ 'showOverlayMessage',
+    /* x */ x,
+    /* y */ y,
+    /* content */ displayErrorMessage
+  )
+
+  if (!isError) {
+    const handleTimeout = () => {
+      console.log('ran timeout fn')
+      editorHideMessage(editor)
+    }
+
+    // TODO use wrapper timing module instead of this
+    // @ts-ignore
+    state.timeout = setTimeout(handleTimeout, 3_000)
+  }
+  return editor
+}
+
+/**
+ *
+ * @param {any} editor
+ * @param {number} rowIndex
+ * @param {number} columnIndex
+ * @param {string} message
+ * @returns
+ */
+export const showErrorMessage = (editor, rowIndex, columnIndex, message) => {
+  return editorShowMessage(
+    editor,
+    rowIndex,
+    columnIndex,
+    message,
+    /* isError */ true
+  )
+}
+
+export const editorHideMessage = async (editor) => {
+  clearTimeout(state.timeout)
+  state.timeout = -1
+  await RendererProcess.invoke(
+    /* Viewlet.send */ 'Viewlet.send',
+    /* id */ 'EditorText',
+    /* method */ 'hideOverlayMessage'
+  )
+  return editor
+}

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

@@ -0,0 +1,61 @@
+import * as Editor from '../Editor/Editor.js'
+import * as TextDocument from '../TextDocument/TextDocument.js'
+
+const getChanges = (lines, selections, snippet) => {
+  // TODO verify that deleted fits in the line
+  const insertedLines = snippet.inserted.split('\n')
+  const changes = []
+  for (let i = 0; i < selections.length; i += 4) {
+    const selectionStartRow = selections[i]
+    const selectionStartColumn = selections[i + 1]
+    const selectionEndRow = selections[i + 2]
+    const selectionEndColumn = selections[i + 3]
+    if (insertedLines.length > 1) {
+      const line = TextDocument.getLine({ lines }, selectionStartRow)
+      const indent = TextDocument.getIndent(line)
+      const insertedLinesHere = [
+        insertedLines[0],
+        ...insertedLines.slice(1).map((line) => indent + line),
+      ]
+      changes.push({
+        start: {
+          rowIndex: selectionStartRow,
+          columnIndex: selectionStartColumn - snippet.deleted,
+        },
+        end: {
+          rowIndex: selectionEndRow,
+          columnIndex: selectionEndColumn,
+        },
+        inserted: insertedLinesHere,
+        deleted: [''],
+        origin: 'editorSnippet',
+      })
+    } else {
+      changes.push({
+        start: {
+          rowIndex: selectionStartRow,
+          columnIndex: selectionStartColumn - snippet.deleted,
+        },
+        end: {
+          rowIndex: selectionEndRow,
+          columnIndex: selectionEndColumn,
+        },
+        inserted: insertedLines,
+        deleted: [''],
+        origin: 'editorSnippet',
+      })
+    }
+  }
+  return changes
+}
+
+// const getIndent =
+// TODO rename to insertSnippet
+// TODO handle snippet tabstops and cursors $0 -> becomes cursor
+export const editorSnippet = (editor, snippet) => {
+  // TODO verify that deleted fits in the line
+  const lines = editor.lines
+  const selections = editor.selections
+  const changes = getChanges(lines, selections, snippet)
+  return Editor.scheduleDocumentAndCursorsSelections(editor, changes)
+}

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

@@ -0,0 +1,45 @@
+import * as ExtensionHostTabCompletion from '../ExtensionHost/ExtensionHostTabCompletion.js'
+import * as TextDocument from '../TextDocument/TextDocument.js'
+import * as EditorShowMessage from './EditorCommandShowMessage.js'
+import * as EditorSnippet from './EditorCommandSnippet.js'
+import * as ErrorHandling from '../ErrorHandling/ErrorHandling.js'
+
+const getTabCompletion = async (editor) => {
+  const rowIndex = editor.selections[0]
+  const columnIndex = editor.selections[1]
+  const offset = TextDocument.offsetAt(editor, rowIndex, columnIndex)
+  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) {
+    ErrorHandling.printError(error)
+    // TODO cursor should always be of type object
+    const rowIndex = editor.selections[0]
+    const columnIndex = editor.selections[1]
+    return EditorShowMessage.showErrorMessage(
+      editor,
+      rowIndex,
+      columnIndex,
+      getErrorMessage(error)
+    )
+  }
+}

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

@@ -0,0 +1,5 @@
+import * as EditorDiagnostics from './EditorDiagnostics.js'
+
+export const Commands = {
+  'EditorDiagnostics.hydrate': EditorDiagnostics.hydrate,
+}

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

@@ -0,0 +1,5 @@
+import * as EditorError from './EditorError.js'
+
+export const Commands = {
+  3900: EditorError.show,
+}

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

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

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

@@ -0,0 +1,7 @@
+import * as EditorRename from './EditorRename.js'
+
+export const Commands = {
+  'EditorRename.open': EditorRename.open,
+  'EditorRename.finish': EditorRename.finish,
+  'EditorRename.abort': EditorRename.abort,
+}

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

@@ -0,0 +1,107 @@
+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'
+import * as Assert from '../Assert/Assert.js'
+
+// TODO memory leak
+export const state = {
+  editor: undefined,
+}
+
+const prepareRename = async (editor, rowIndex, columnIndex) => {
+  const offset = TextDocument.offsetAt(editor, rowIndex, columnIndex)
+  return ExtensionHostRename.executePrepareRenameProvider(editor, offset)
+}
+
+const rename = (editor, rowIndex, columnIndex, newName) => {
+  const offset = TextDocument.offsetAt(editor, rowIndex, columnIndex)
+  return ExtensionHostRename.executeRenameProvider(editor, offset)
+}
+
+export const open = async (editor) => {
+  const rowIndex = editor.selections[0]
+  const columnIndex = editor.selections[1]
+  Assert.number(rowIndex)
+  Assert.number(columnIndex)
+
+  // TODO handle error and add tests for handled error
+  const prepareRenameResult = await prepareRename(editor, rowIndex, columnIndex)
+
+  // TODO race condition, what is when editor is closed before promise resolves
+
+  if (prepareRenameResult.canRename) {
+    const x = EditorPosition.x(editor, rowIndex, columnIndex)
+    const y = EditorPosition.y(editor, rowIndex, columnIndex)
+    // 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',
+      /* rowIndex */ rowIndex,
+      /* columnIndex */ columnIndex
+    )
+  }
+}
+
+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) => {
+  // TODO what if cursor position changes while rename is in progress?
+  // TODO what happens if file content changes while rename is in progress?
+  // TODO what happens when file is closed while rename is in progress?
+  const rowIndex = editor.selections[0]
+  const columnIndex = editor.selections[1]
+  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, rowIndex, columnIndex, 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/0e4d46a/packages/renderer-worker/src/parts/EditorSelection/EditorSelection.js

@@ -0,0 +1,147 @@
+export const fromRange = (
+  startRowIndex,
+  startColumnIndex,
+  endRowIndex,
+  endColumnIndex
+) => {
+  return new Uint32Array([
+    startRowIndex,
+    startColumnIndex,
+    endRowIndex,
+    endColumnIndex,
+  ])
+}
+
+export const fromRanges = (...items) => {
+  return new Uint32Array(items.flat(1))
+}
+
+export const fromPosition = (rowIndex, columnIndex) => {
+  return fromRange(rowIndex, columnIndex, rowIndex, columnIndex)
+}
+
+export const alloc = (length) => {
+  return new Uint32Array(length)
+}
+
+export const clone = (selections) => {
+  return alloc(selections.length)
+}
+
+export const map = (selections, fn) => {
+  const newSelections = clone(selections)
+  for (let i = 0; i < newSelections.length; i += 4) {
+    const selectionStartRow = selections[i]
+    const selectionStartColumn = selections[i + 1]
+    const selectionEndRow = selections[i + 2]
+    const selectionEndColumn = selections[i + 3]
+    fn(
+      newSelections,
+      i,
+      selectionStartRow,
+      selectionStartColumn,
+      selectionEndRow,
+      selectionEndColumn
+    )
+  }
+  return newSelections
+}
+
+export const forEach = (selections, fn) => {
+  for (let i = 0; i < selections.length; i += 4) {
+    const selectionStartRow = selections[i]
+    const selectionStartColumn = selections[i + 1]
+    const selectionEndRow = selections[i + 2]
+    const selectionEndColumn = selections[i + 3]
+    fn(
+      selectionStartRow,
+      selectionStartColumn,
+      selectionEndRow,
+      selectionEndColumn
+    )
+  }
+}
+
+export const moveRangeToPosition = (selections, i, rowIndex, columnIndex) => {
+  selections[i] = selections[i + 2] = rowIndex
+  selections[i + 1] = selections[i + 3] = columnIndex
+}
+
+export const isEmpty = (
+  selectionStartRow,
+  selectionStartColumn,
+  selectionEndRow,
+  selectionEndColumn
+) => {
+  return (
+    selectionStartRow === selectionEndRow &&
+    selectionStartColumn === selectionEndColumn
+  )
+}
+
+const isSelectionSingleLine = (
+  selectionStartRow,
+  selectionStartColumn,
+  selectionEndRow,
+  selectionEndColumn
+) => {
+  return selectionStartRow === selectionEndRow
+}
+
+export const isEverySelection = (selections, fn) => {
+  for (let i = 0; i < selections.length; i += 4) {
+    const selectionStartRow = selections[i]
+    const selectionStartColumn = selections[i + 1]
+    const selectionEndRow = selections[i + 2]
+    const selectionEndColumn = selections[i + 3]
+    if (
+      !fn(
+        selectionStartRow,
+        selectionStartColumn,
+        selectionEndRow,
+        selectionEndColumn
+      )
+    ) {
+      return false
+    }
+  }
+  return true
+}
+
+export const isEverySelectionEmpty = (selections) => {
+  return isEverySelection(selections, isEmpty)
+}
+
+export const isEverySelectionSingleLine = (selections) => {
+  return isEverySelection(selections, isSelectionSingleLine)
+}
+
+export const from = (array, getSelection) => {
+  const newSelections = alloc(array.length * 4)
+  let i = 0
+  for (const item of array) {
+    const { start, end } = getSelection(item)
+    newSelections[i++] = start.rowIndex
+    newSelections[i++] = start.columnIndex
+    newSelections[i++] = end.rowIndex
+    newSelections[i++] = end.columnIndex
+  }
+  return newSelections
+}
+
+export const push = (
+  selections,
+  startRowIndex,
+  startColumnIndex,
+  endRowIndex,
+  endColumnIndex
+) => {
+  const oldLength = selections.length
+  const newSelections = alloc(oldLength + 4)
+  newSelections.set(selections)
+  newSelections[oldLength + 1] = startRowIndex
+  newSelections[oldLength + 2] = startColumnIndex
+  newSelections[oldLength + 3] = endRowIndex
+  newSelections[oldLength + 4] = endColumnIndex
+  return newSelections
+}

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

@@ -0,0 +1,5 @@
+import * as ErrorHandling from './ErrorHandling.js'
+
+export const Commands = {
+  'ErrorHandling.handleError': ErrorHandling.handleError,
+}

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

@@ -0,0 +1,103 @@
+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)
+// }
+
+export const printError = (error) => {
+  if (error && error.message && error.codeFrame) {
+    console.error(`${error.message}\n\n${error.codeFrame}\n\n${error.stack}`)
+  } else {
+    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/0e4d46a/packages/renderer-worker/src/parts/ExtensionHost/ExtensionHostCore.ipc.js

@@ -0,0 +1,8 @@
+import * as ExtensionHostCore from './ExtensionHostCore.js'
+
+// prettier-ignore
+export const Commands={
+
+  'ExtensionHost.startWebExtensionHost': ExtensionHostCore.startWebExtensionHost,
+  'ExtensionHost.loadWebExtension': ExtensionHostCore.loadWebExtension,
+}