@lvce-editor/server 0.0.26 → 0.0.29

package/static/bf7d47a/packages/renderer-worker/src/parts/EditorCommand/EditorCommandGoToTypeDefinition.js

@@ -0,0 +1,123 @@
+import * as Command from '../Command/Command.js'
+import * as Editor from '../Editor/Editor.js'
+import * as ExtensionHostTypeDefinition from '../ExtensionHost/ExtensionHostTypeDefinition.js'
+import * as TextDocument from '../TextDocument/TextDocument.js'
+import * as Assert from '../Assert/Assert.js'
+import * as EditorShowMessage from './EditorCommandShowMessage.js'
+// TODO duplicate code with editorCommandGoToDefinition
+// TODO race condition, check that editor hasn't been closed in the meantime
+
+// TODO in case of error should show message "Definition Error: Cannot ready Property x of undefined"
+
+// TODO show some kind of message maybe ("No Definition found")
+
+// TODO possible to do this with events/state machine instead of promises -> enables canceling operations / concurrent calls
+const getTypeDefinition = async (editor, rowIndex, columnIndex) => {
+  const offset = TextDocument.offsetAt(editor, rowIndex, columnIndex)
+  const definition =
+    await ExtensionHostTypeDefinition.executeTypeDefinitionProvider(
+      editor,
+      offset
+    )
+  return definition
+}
+
+// TODO there are still race conditions in this function:
+// - when open is called twice, previous dom nodes can either be reused or the previous dom nodes must be disposed
+
+const getTypeDefinitionErrorMessage = (error) => {
+  return `${error}`
+}
+
+export const editorGoToTypeDefinition = async (editor, explicit = true) => {
+  const rowIndex = editor.selections[0]
+  const columnIndex = editor.selections[1]
+  try {
+    Assert.object(editor)
+    Assert.number(rowIndex)
+    Assert.number(columnIndex)
+    Assert.boolean(explicit)
+    const typeDefinition = await getTypeDefinition(
+      editor,
+      rowIndex,
+      columnIndex
+    )
+    // TODO if editor is already disposed at this point, do nothing
+    if (!typeDefinition) {
+      // TODO show popup that no definition was found
+      // TODO if there was an error, show popup that go to definition resulted in an error
+      return EditorShowMessage.editorShowMessage(
+        editor,
+        rowIndex,
+        columnIndex,
+        'No type definition found',
+        /* isError */ false
+      )
+    }
+
+    if (
+      typeof typeDefinition.uri !== 'string' ||
+      typeof typeDefinition.startOffset !== 'number' ||
+      typeof typeDefinition.endOffset !== 'number'
+    ) {
+      console.warn('invalid type definition result', typeDefinition)
+      return editor
+    }
+
+    if (typeDefinition.uri === editor.uri) {
+      // TODO set cursor to the definition position
+      const position = TextDocument.positionAt(
+        editor,
+        typeDefinition.startOffset
+      )
+      const selectionEdits = [
+        {
+          start: position,
+          end: position,
+        },
+      ]
+      return Editor.scheduleSelections(editor, selectionEdits)
+    }
+    // TODO if definition.file is not of type string, show a popup that definition.file must be of type string
+    // TODO open file and scroll to that position and set cursor to that position
+
+    await Command.execute(
+      /* Main.openUri */ 'Main.openUri',
+      /* uri */ typeDefinition.file
+    )
+    return editor
+  } catch (error) {
+    // TODO if editor is already disposed at this point, do nothing
+    if (
+      error &&
+      // @ts-ignore
+      error.message &&
+      // @ts-ignore
+      error.message.startsWith(
+        'Failed to execute type definition provider: No type definition provider found'
+      )
+    ) {
+      const displayErrorMessage = getTypeDefinitionErrorMessage(error)
+      await EditorShowMessage.editorShowMessage(
+        /* editor */ editor,
+        /* rowIndex */ rowIndex,
+        /* columnIndex */ columnIndex,
+        /* message */ displayErrorMessage,
+        /* isError */ false
+      )
+      return editor
+    }
+
+    console.error(error)
+
+    const displayErrorMessage = getTypeDefinitionErrorMessage(error)
+    await EditorShowMessage.editorShowMessage(
+      /* editor */ editor,
+      /* rowIndex */ rowIndex,
+      /* columnIndex */ columnIndex,
+      /* message */ displayErrorMessage,
+      /* isError */ true
+    )
+    return editor
+  }
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/EditorCommand/EditorCommandHandleContextMenu.js

@@ -0,0 +1,11 @@
+import * as Command from '../Command/Command.js'
+
+export const editorHandleContextMenu = async (editor, x, y) => {
+  await Command.execute(
+    /* ContextMenu.show */ 'ContextMenu.show',
+    /* x */ x,
+    /* y */ y,
+    /* id */ 'editor'
+  )
+  return editor
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/EditorCommand/EditorCommandHandleMouseMove.js

@@ -0,0 +1,33 @@
+import * as ExtensionHostHover from '../ExtensionHost/ExtensionHostHover.js'
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+import * as TextDocument from '../TextDocument/TextDocument.js'
+import * as EditorPosition from './EditorCommandPosition.js'
+
+const getHover = async (editor, rowIndex, columnIndex) => {
+  const offset = TextDocument.offsetAt(editor, rowIndex, columnIndex)
+  const hover = await ExtensionHostHover.executeHoverProvider(editor, offset)
+  return hover
+}
+
+const showHover = async (editor, position) => {
+  const hover = await getHover(editor, position.rowIndex, position.columnIndex)
+  if (!hover) {
+    console.log('no hover')
+    return
+  }
+
+  RendererProcess.invoke(
+    /* EditorHover.show */ 6216,
+    /* x */ editor.left + position.columnIndex * editor.columnWidth,
+    /* y */ editor.top + position.rowIndex * editor.rowHeight,
+    /* hover */ hover
+  )
+  console.log({ hover })
+}
+
+export const editorHandleMouseMove = (editor, x, y) => {
+  const position = EditorPosition.at(editor, x, y)
+  // console.log(position)
+  // showHover(editor, position)
+  return editor
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/EditorCommand/EditorCommandHandleMouseMoveWithAltKey.js

@@ -0,0 +1,93 @@
+import * as EditorPosition from './EditorCommandPosition.js'
+import * as Assert from '../Assert/Assert.js'
+import * as ExtensionHostDefinition from '../ExtensionHost/ExtensionHostDefinition.js'
+import * as TextDocument from '../TextDocument/TextDocument.js'
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+
+const getTokenIndex = (tokens, offset) => {
+  let currentOffset = 0
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i]
+    currentOffset += token.length
+    if (currentOffset >= offset) {
+      return i
+    }
+  }
+  return -1
+}
+
+export const editorHandleMouseMoveWithAltKey = async (editor, x, y, offset) => {
+  Assert.object(editor)
+  Assert.number(x)
+  Assert.number(y)
+  Assert.number(offset)
+  const position = EditorPosition.at(editor, x, y, offset)
+  const documentOffset = TextDocument.offsetAt(
+    editor,
+    position.rowIndex,
+    position.columnIndex
+  )
+  try {
+    const definition = await ExtensionHostDefinition.executeDefinitionProvider(
+      editor,
+      documentOffset
+    )
+    if (!definition) {
+      return editor
+    }
+
+    // TODO make sure that editor is not disposed
+
+    const definitionStartPosition = TextDocument.positionAt(
+      editor,
+      definition.startOffset
+    )
+    const definitionEndPosition = TextDocument.positionAt(
+      editor,
+      definition.endOffset
+    )
+    const definitionRelativeStartX = definitionStartPosition.columnIndex
+    const definitionRelativeEndX = definitionEndPosition.columnIndex
+    const definitionRelativeY =
+      definitionStartPosition.rowIndex - editor.minLineY
+
+    const lineTokenMap = editor.lineCache[definitionStartPosition.rowIndex + 1]
+    console.log({ tokenMap: lineTokenMap })
+    console.log({
+      lineCache: editor.lineCache,
+      rowIndex: definitionStartPosition.rowIndex,
+    })
+    if (!lineTokenMap) {
+      return editor
+    }
+    const tokenIndex = getTokenIndex(
+      lineTokenMap.tokens,
+      definitionStartPosition.columnIndex
+    )
+    if (tokenIndex === -1) {
+      return editor
+    }
+    console.log({ token: tokenIndex })
+    // .tokens
+    // console.log({ editor })
+    await RendererProcess.invoke(
+      /* Viewlet.invoke */ 'Viewlet.send',
+      /* id */ 'EditorText',
+      /* method */ 'highlightAsLink',
+      /* relativeY */ definitionRelativeY,
+      /* tokenIndex */ tokenIndex
+    )
+    console.log({ definition })
+    return editor
+  } catch (error) {
+    if (
+      error &&
+      error.message.startsWith(
+        'Failed to execute definition provider: No definition provider found'
+      )
+    ) {
+      return editor
+    }
+    throw error
+  }
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/EditorCommand/EditorCommandHandleNativeBeforeInputFromContentEditable.js

@@ -0,0 +1,33 @@
+import * as Editor from '../Editor/Editor.js'
+import * as TextDocument from '../TextDocument/TextDocument.js'
+import * as EditorGetSelectionFromNativeRange from './EditorCommandGetSelectionFromNativeRange.js'
+
+const getChanges = (editor, data, range) => {
+  const selection =
+    EditorGetSelectionFromNativeRange.getSelectionFromNativeRange(editor, range)
+  const selectionRange = {
+    start: {
+      rowIndex: selection[0],
+      columnIndex: selection[1],
+    },
+    end: {
+      rowIndex: selection[2],
+      columnIndex: selection[3],
+    },
+  }
+  const changes = [
+    {
+      start: selectionRange.start,
+      end: selectionRange.end,
+      inserted: [data],
+      deleted: TextDocument.getSelectionText(editor, selectionRange),
+      origin: 'contentEditableInput',
+    },
+  ]
+  return changes
+}
+
+export const handleBeforeInputFromContentEditable = (editor, data, range) => {
+  const changes = getChanges(editor, data, range)
+  return Editor.scheduleDocumentAndCursorsSelections(editor, changes)
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/EditorCommand/EditorCommandHandleNativeSelectionChange.js

@@ -0,0 +1,8 @@
+import * as Editor from '../Editor/Editor.js'
+import * as EditorGetSelectionFromNativeRange from './EditorCommandGetSelectionFromNativeRange.js'
+
+export const editorHandleNativeSelectionChange = (editor, range) => {
+  const selections =
+    EditorGetSelectionFromNativeRange.getSelectionFromNativeRange(editor, range)
+  return Editor.scheduleSelections(editor, selections)
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/EditorCommand/EditorCommandHandleSingleClick.js

@@ -0,0 +1,43 @@
+import * as Assert from '../Assert/Assert.js'
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+import * as EditorCursorSet from './EditorCommandCursorSet.js'
+import * as EditorPosition from './EditorCommandPosition.js'
+import * as EditorMoveSelection from './EditorCommandMoveSelection.js'
+import * as EditorGoToDefinition from './EditorCommandGoToDefinition.js'
+
+export const editorHandleSingleClick = async (
+  editor,
+  modifier,
+  x,
+  y,
+  offset
+) => {
+  Assert.object(editor)
+  Assert.string(modifier)
+  Assert.number(x)
+  Assert.number(y)
+  Assert.number(offset)
+  const position = EditorPosition.at(editor, x, y, offset)
+  if (modifier === 'alt') {
+    // TODO rectangular selection with alt click,
+    // but also go to definition with alt click
+    console.log('alt key pressed')
+    const newEditor = await EditorGoToDefinition.editorGoToDefinition(
+      editor,
+      position,
+      /* explicit */ false
+    )
+    if (editor !== newEditor) {
+      return newEditor
+    }
+  }
+  console.log({ position })
+  EditorMoveSelection.state.position = position
+  // TODO also focus editor input
+  await RendererProcess.invoke('Viewlet.invoke', 'EditorText', 'focus')
+  return EditorCursorSet.editorCursorSet(
+    editor,
+    position.rowIndex,
+    position.columnIndex
+  )
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/EditorCommand/EditorCommandHandleTab.js

@@ -0,0 +1,46 @@
+import * as EditorTabCompletion from './EditorCommandTabCompletion.js'
+import * as EditorType from './EditorCommandType.js'
+import * as EditorIndent from './EditorCommandIndentMore.js'
+import * as EditorSelection from '../EditorSelection/EditorSelection.js'
+
+// TODO tab doesn't work well with configurable keybindings
+export const editorHandleTab = async (editor) => {
+  if (EditorSelection.isEverySelectionEmpty(editor.selections)) {
+    console.log('call tab completion')
+    const applied = await EditorTabCompletion.editorTabCompletion(editor)
+    if (applied !== editor) {
+      return applied
+    }
+    // TODO have setting what should be inserted on tab
+    return EditorType.editorType(editor, '  ')
+  }
+  return EditorIndent.editorIndentMore(editor)
+}
+
+// const editor = {
+//   textDocument: {
+//     lines: ['line 1', 'line 2', 'line 3', 'line 4'],
+//   },
+//   cursor: {
+//     rowIndex: 0,
+//     columnIndex: 1,
+//   },
+//   selections: [
+//     {
+//       start: {
+//         rowIndex: 1,
+//         columnIndex: 1,
+//       },
+//       end: {
+//         rowIndex: 2,
+//         columnIndex: 2,
+//       },
+//     },
+//   ],
+// }
+// const main = async () => {
+//   await editorHandleTab(editor)
+//   editor.lines //?
+// }
+
+// main()

package/static/bf7d47a/packages/renderer-worker/src/parts/EditorCommand/EditorCommandIndentLess.js

@@ -0,0 +1,35 @@
+import * as Editor from '../Editor/Editor.js'
+
+const getChanges = (selections) => {
+  const changes = []
+  const rowsToIndentLess = []
+  for (let i = 0; i < selections.length; i += 4) {
+    const selectionStartRow = selections[i]
+    const selectionEndRow = selections[i + 2]
+    for (let i = selectionStartRow; i <= selectionEndRow; i++) {
+      rowsToIndentLess.push(i)
+    }
+  }
+  for (const rowToIndent of rowsToIndentLess) {
+    changes.push({
+      start: {
+        rowIndex: rowToIndent,
+        columnIndex: 0,
+      },
+      end: {
+        rowIndex: rowToIndent,
+        columnIndex: 2,
+      },
+      inserted: [''],
+      deleted: ['  '],
+      origin: 'indentLess',
+    })
+  }
+  return changes
+}
+
+export const editorIndentLess = (editor) => {
+  const selections = editor.selections
+  const changes = getChanges(selections)
+  return Editor.scheduleDocumentAndCursorsSelections(editor, changes)
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/EditorCommand/EditorCommandIndentMore.js

@@ -0,0 +1,35 @@
+import * as Editor from '../Editor/Editor.js'
+
+const getChanges = (selections) => {
+  const rowsToIndent = []
+  for (let i = 0; i < selections.length; i += 4) {
+    const selectionStartRow = selections[i]
+    const selectionEndRow = selections[i + 2]
+    for (let i = selectionStartRow; i <= selectionEndRow; i++) {
+      rowsToIndent.push(i)
+    }
+  }
+  const changes = []
+  for (const rowToIndent of rowsToIndent) {
+    changes.push({
+      start: {
+        rowIndex: rowToIndent,
+        columnIndex: 0,
+      },
+      end: {
+        rowIndex: rowToIndent,
+        columnIndex: 0,
+      },
+      inserted: ['  '],
+      deleted: [''],
+      origin: 'indentMore',
+    })
+  }
+  return changes
+}
+
+export const editorIndentMore = (editor) => {
+  const selections = editor.selections
+  const changes = getChanges(selections)
+  return Editor.scheduleDocumentAndCursorsSelections(editor, changes)
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/EditorCommand/EditorCommandInsertLineBreak.js

@@ -0,0 +1,54 @@
+import * as Editor from '../Editor/Editor.js'
+import * as TextDocument from '../TextDocument/TextDocument.js'
+
+const getChanges = (lines, selections) => {
+  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]
+    const start = {
+      rowIndex: selectionStartRow,
+      columnIndex: selectionStartColumn,
+    }
+    const end = {
+      rowIndex: selectionEndRow,
+      columnIndex: selectionEndColumn,
+    }
+    const range = {
+      start,
+      end,
+    }
+    if (
+      selectionStartRow === selectionEndRow &&
+      selectionStartColumn === selectionEndColumn
+    ) {
+      const line = lines[selectionStartRow].slice(0, selectionStartColumn)
+      const indent = TextDocument.getIndent(line)
+      changes.push({
+        start: start,
+        end: end,
+        inserted: ['', indent],
+        deleted: TextDocument.getSelectionText({ lines }, range),
+        origin: 'insertLineBreak',
+      })
+    } else {
+      changes.push({
+        start: start,
+        end: end,
+        inserted: ['', ''],
+        deleted: TextDocument.getSelectionText({ lines }, range),
+        origin: 'insertLineBreak',
+      })
+    }
+  }
+  return changes
+}
+
+export const editorInsertLineBreak = (editor) => {
+  const lines = editor.lines
+  const selections = editor.selections
+  const changes = getChanges(lines, selections)
+  return Editor.scheduleDocumentAndCursorsSelections(editor, changes)
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/EditorCommand/EditorCommandMoveSelection.js

@@ -0,0 +1,73 @@
+import * as Editor from '../Editor/Editor.js'
+
+// TODO not sure where this state should be
+// TODO maybe rename to selection anchor
+export const state = {
+  position: {
+    rowIndex: 0,
+    columnIndex: 0,
+  },
+}
+
+const compare = (positionA, positionB) => {
+  if (positionA.rowIndex > positionB.rowIndex) {
+    return 1
+  }
+  if (positionA.rowIndex === positionB.rowIndex) {
+    if (positionA.columnIndex > positionB.columnIndex) {
+      return 1
+    }
+    if (positionA.columnIndex < positionB.columnIndex) {
+      return -1
+    }
+    return 0
+  }
+  return -1
+}
+
+const editorMoveSelectionBackwards = (anchor, position) => {
+  return new Uint32Array([
+    position.rowIndex,
+    position.columnIndex,
+    anchor.rowIndex,
+    anchor.columnIndex,
+  ])
+}
+
+const editorMoveSelectionEqual = (anchor, position) => {
+  return new Uint32Array([
+    position.rowIndex,
+    position.columnIndex,
+    position.rowIndex,
+    position.columnIndex,
+  ])
+}
+
+const editorMoveSelectionForwards = (anchor, position) => {
+  return new Uint32Array([
+    anchor.rowIndex,
+    anchor.columnIndex,
+    position.rowIndex,
+    position.columnIndex,
+  ])
+}
+
+const getNewSelections = (anchor, position) => {
+  switch (compare(position, anchor)) {
+    case -1:
+      return editorMoveSelectionBackwards(anchor, position)
+    case 0:
+      return editorMoveSelectionEqual(anchor, position)
+    case 1:
+      return editorMoveSelectionForwards(anchor, position)
+    default:
+      throw new Error('unexpected comparison result')
+  }
+}
+
+export const editorMoveSelection = (editor, position) => {
+  const anchor = state.position
+  const newSelections = getNewSelections(anchor, position)
+  // TODO if selection equals previous selection -> do nothing
+  return Editor.scheduleSelections(editor, newSelections)
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/EditorCommand/EditorCommandMoveSelectionPx.js

@@ -0,0 +1,12 @@
+import * as Assert from '../Assert/Assert.js'
+import * as EditorMoveSelection from './EditorCommandMoveSelection.js'
+import * as EditorPosition from './EditorCommandPosition.js'
+
+export const editorMoveSelectionPx = (editor, x, y, offset) => {
+  Assert.object(editor)
+  Assert.number(x)
+  Assert.number(y)
+  Assert.number(offset)
+  const position = EditorPosition.at(editor, x, y, offset)
+  return EditorMoveSelection.editorMoveSelection(editor, position)
+}

package/static/bf7d47a/packages/renderer-worker/src/parts/EditorCommand/EditorCommandPaste.js

@@ -0,0 +1,11 @@
+import * as Command from '../Command/Command.js'
+import * as Assert from '../Assert/Assert.js'
+import * as EditorPasteText from './EditorCommandPasteText.js'
+
+export const editorPaste = async (editor) => {
+  const text = await Command.execute(
+    /* ClipBoard.readText */ 'ClipBoard.readText'
+  )
+  Assert.string(text)
+  return EditorPasteText.editorPasteText(editor, text)
+}