@lvce-editor/server 0.0.2

package/static/1914fad/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, position) => {
+  const offset = TextDocument.offsetAt(editor, position)
+  const hover = await ExtensionHostHover.executeHoverProvider(editor, offset)
+  return hover
+}
+
+const showHover = async (editor, position) => {
+  const hover = await getHover(editor, position)
+  if (!hover) {
+    console.log('no hover')
+    return
+  }
+
+  RendererProcess.send([
+    /* 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/1914fad/packages/renderer-worker/src/parts/EditorCommand/EditorCommandHandleMouseMoveWithAltKey.js

@@ -0,0 +1,89 @@
+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)
+  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 */ 3024,
+      /* 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/1914fad/packages/renderer-worker/src/parts/EditorCommand/EditorCommandHandleNativeBeforeInputFromContentEditable.js

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

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

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

package/static/1914fad/packages/renderer-worker/src/parts/EditorCommand/EditorCommandHandleScrollBarClick.js

@@ -0,0 +1,52 @@
+import * as Editor from '../Editor/Editor.js'
+
+export const state = {
+  /**
+   * Offset at which scrollbar thumb has been clicked
+   */
+  handleOffset: 0,
+}
+
+// TODO scrollbar position can be in interval [0, editor.height - editor.scrollBarHeight]
+// when clicked at y <= editor.scrollbarHeight/2, position is set to zero
+// when clicked at y >= editor.height - editor.scrollBarHeight/2, position is set to (editor.height - scrollBarHeight/2)
+// when clicked at y > editor.height - editor.scrollBarHeight/2, position scrollbar at (y - scrollbarHeight/2)
+// additionally, when clicked on scrollbar, scrollbar position shouldn't move
+
+const getNewDeltaPercent = (editor, relativeY) => {
+  if (relativeY <= editor.scrollBarHeight / 2) {
+    // clicked at top
+    return 0
+  }
+  if (relativeY <= editor.height - editor.scrollBarHeight / 2) {
+    // clicked in middle
+    return (
+      (relativeY - editor.scrollBarHeight / 2) /
+      (editor.height - editor.scrollBarHeight)
+    )
+  }
+  // clicked at bottom
+  return 1
+}
+
+export const editorHandleScrollBarClick = (editor, y) => {
+  const relativeY = y - editor.top
+  const currentScrollBarY =
+    (editor.deltaY / editor.finalDeltaY) *
+    (editor.height - editor.scrollBarHeight)
+  console.log({ scrollBarY: currentScrollBarY, relativeY })
+  const diff = relativeY - currentScrollBarY
+  console.log({ diff })
+  if (diff >= 0 && diff < editor.scrollBarHeight) {
+    state.handleOffset = diff
+    console.log({ handleOffset: diff })
+    return editor
+  }
+  const newPercent = getNewDeltaPercent(editor, relativeY)
+  console.log({ newPercent })
+  // TODO
+  state.handleOffset = editor.scrollBarHeight / 2
+  // TODO when diff is greater, position scrollbar in the middle around cursor
+  const newDeltaY = newPercent * editor.finalDeltaY
+  return Editor.setDeltaYFixedValue(editor, newDeltaY)
+}

package/static/1914fad/packages/renderer-worker/src/parts/EditorCommand/EditorCommandHandleScrollBarMove.js

@@ -0,0 +1,26 @@
+import * as Editor from '../Editor/Editor.js'
+import * as EditorHandleScrollBarClick from './EditorCommandHandleScrollBarClick.js'
+
+const getNewPercent = (editor, relativeY) => {
+  console.log({ editor, relativeY })
+  // if (relativeY <= editor.scrollBarHeight / 2) {
+  //   console.log('clicked at top')
+  //   // clicked at top
+  //   return 0
+  // }
+  if (relativeY <= editor.height - editor.scrollBarHeight / 2) {
+    // clicked in middle
+    return relativeY / (editor.height - editor.scrollBarHeight)
+  }
+  // clicked at bottom
+  return 1
+}
+
+export const editorHandleScrollBarMove = (editor, y) => {
+  const relativeY =
+    y - editor.top - EditorHandleScrollBarClick.state.handleOffset
+  console.log('handle offset', EditorHandleScrollBarClick.state.handleOffset)
+  const newPercent = getNewPercent(editor, relativeY)
+  const newDeltaY = newPercent * editor.finalDeltaY
+  return Editor.setDeltaYFixedValue(editor, newDeltaY)
+}

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

@@ -0,0 +1,38 @@
+import * as EditorCursorSet from './EditorCommandCursorSet.js'
+import * as EditorPosition from './EditorCommandPosition.js'
+import * as EditorMoveSelection from './EditorCommandMoveSelection.js'
+import * as Assert from '../Assert/Assert.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
+    }
+  }
+  EditorMoveSelection.state.position = position
+  return EditorCursorSet.editorCursorSet(
+    editor,
+    EditorMoveSelection.state.position
+  )
+}

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

@@ -0,0 +1,49 @@
+import * as EditorTabCompletion from './EditorCommandTabCompletion.js'
+import * as EditorType from './EditorCommandType.js'
+import * as EditorIndent from './EditorCommandIndentMore.js'
+
+const isStartEndSame = (selection) => {
+  return selection.start.rowIndex === selection.end.rowIndex
+}
+
+// TODO tab doesn't work well with configurable keybindings
+export const editorHandleTab = async (editor) => {
+  if (editor.selections.every(isStartEndSame)) {
+    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/1914fad/packages/renderer-worker/src/parts/EditorCommand/EditorCommandHandleTouchEnd.js

@@ -0,0 +1,31 @@
+import * as EditorPosition from './EditorCommandPosition.js'
+import * as EditorHandleTouchStart from './EditorCommandHandleTouchStart.js'
+import * as EditorSelectWord from './EditorCommandSelectWord.js'
+import * as EditorCursorSet from './EditorCommandCursorSet.js'
+import * as EditorMoveSelection from './EditorCommandMoveSelection.js'
+
+const LONG_TOUCH_THRESHOLD = 150
+
+export const editorHandleTouchEnd = (editor, touchEvent) => {
+  if (touchEvent.changedTouches.length === 0) {
+    return
+  }
+  const firstTouch = touchEvent.changedTouches[0]
+  const position = EditorPosition.at(editor, firstTouch.x, firstTouch.y)
+  if (
+    EditorMoveSelection.state.position.rowIndex === position.rowIndex &&
+    EditorMoveSelection.state.position.columnIndex === position.columnIndex
+  ) {
+    if (Date.now() - EditorHandleTouchStart.state.date > LONG_TOUCH_THRESHOLD) {
+      EditorSelectWord.editorSelectWord(
+        editor,
+        position.rowIndex,
+        position.columnIndex
+      )
+    } else {
+      EditorCursorSet.editorCursorSet(editor, position)
+    }
+  } else {
+    console.log('different position')
+  }
+}

package/static/1914fad/packages/renderer-worker/src/parts/EditorCommand/EditorCommandHandleTouchMove.js

@@ -0,0 +1,13 @@
+import * as EditorHandleTouchStart from './EditorCommandHandleTouchStart.js'
+import * as EditorSetDeltaY from './EditorCommandSetDeltaY.js'
+
+export const editorHandleTouchMove = (editor, touchEvent) => {
+  if (touchEvent.touches.length === 0) {
+    return
+  }
+  const firstTouch = touchEvent.touches[0]
+  const offsetY =
+    EditorHandleTouchStart.state.deltaY +
+    (EditorHandleTouchStart.state.touchOffsetY - firstTouch.y)
+  EditorSetDeltaY.setDeltaYFixedValue(editor, offsetY)
+}

package/static/1914fad/packages/renderer-worker/src/parts/EditorCommand/EditorCommandHandleTouchStart.js

@@ -0,0 +1,17 @@
+export const state = {
+  touchOffsetY: 0,
+  deltaY: 0,
+}
+
+export const editorHandleTouchStart = (editor, touchEvent) => {
+  if (touchEvent.touches.length === 0) {
+    return
+  }
+  console.log('touch start')
+  const firstTouch = touchEvent.touches[0]
+  state.touchOffsetY = firstTouch.y
+  state.deltaY = editor.deltaY
+  // const position = EditorPosition.at(editor, firstTouch.x, firstTouch.y)
+  // EditorMoveSelection.state.position = position
+  // state.date = Date.now()
+}

package/static/1914fad/packages/renderer-worker/src/parts/EditorCommand/EditorCommandHandleTripleClick.js

@@ -0,0 +1,11 @@
+import * as Assert from '../Assert/Assert.js'
+import * as EditorSelectLine from './EditorCommandSelectLine.js'
+
+// TODO rowIndex and columnIndex should already be set because of singleClick which occurred before triple click
+export const editorHandleTripleClick = (editor, x, y, offset) => {
+  Assert.object(editor)
+  Assert.number(x)
+  Assert.number(y)
+  Assert.number(offset)
+  return EditorSelectLine.editorSelectLine(editor)
+}

package/static/1914fad/packages/renderer-worker/src/parts/EditorCommand/EditorCommandHandleWheel.js

@@ -0,0 +1,20 @@
+export const editorHandleWheel = (editor, y) => {
+  const newDeltaY = clamp(editor.deltaY + y, 0, editor.finalDeltaY)
+  if (editor.deltaY === newDeltaY) {
+    return
+  }
+  editor.deltaY = newDeltaY
+  const newLineY = Math.floor(newDeltaY / 20)
+  if (editor.minLineY === newLineY) {
+    return
+  }
+  editor.minLineY = newLineY
+  editor.maxLineY = Math.min(
+    editor.minLineY + editor.numberOfVisibleLines,
+    editor.lines.length
+  )
+
+  // TODO
+  //
+  // renderTextAndCursorAndSelections(editor)
+}

package/static/1914fad/packages/renderer-worker/src/parts/EditorCommand/EditorCommandIndent.js

@@ -0,0 +1,3 @@
+export const indentSelection = (editor, fn) => {
+  for (const selection of editor.selections) {}
+}

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

@@ -0,0 +1,27 @@
+import * as Editor from '../Editor/Editor.js'
+
+export const editorIndentLess = (editor) => {
+  const changes = []
+  const rowsToIndentLess = []
+  for (const selection of editor.selections) {
+    for (let i = selection.start.rowIndex; i <= selection.end.rowIndex; 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 Editor.scheduleDocumentAndCursorsSelections(editor, changes)
+}

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

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

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

@@ -0,0 +1,32 @@
+import * as Editor from '../Editor/Editor.js'
+import * as TextDocument from '../TextDocument/TextDocument.js'
+
+export const editorInsertLineBreak = (editor) => {
+  const changes = []
+  const lines = editor.lines
+  for (const selection of editor.selections) {
+    if (selection.start === selection.end) {
+      const line = lines[selection.start.rowIndex].slice(
+        0,
+        selection.start.columnIndex
+      )
+      const indent = TextDocument.getIndent(line)
+      changes.push({
+        start: selection.start,
+        end: selection.end,
+        inserted: ['', indent],
+        deleted: TextDocument.getSelectionText(editor, selection),
+        origin: 'insertLineBreak',
+      })
+    } else {
+      changes.push({
+        start: selection.start,
+        end: selection.end,
+        inserted: ['', ''],
+        deleted: TextDocument.getSelectionText(editor, selection),
+        origin: 'insertLineBreak',
+      })
+    }
+  }
+  return Editor.scheduleDocumentAndCursorsSelections(editor, changes)
+}

package/static/1914fad/packages/renderer-worker/src/parts/EditorCommand/EditorCommandMoveLineDown.js

@@ -0,0 +1,30 @@
+import * as TextDocument from '../TextDocument/TextDocument.js'
+import * as Editor from '../Editor/Editor.js'
+
+// TODO move cursor
+// TODO multiple cursors -> vscode removes multiple cursors
+// TODO with selection -> vscode moves whole selection
+export const editorMoveLineDown = (editor) => {
+  const rowIndex = editor.cursor.rowIndex
+  if (rowIndex === editor.lines.length - 1) {
+    return
+  }
+  const documentEdits = [
+    {
+      type: /* splice */ 2,
+      rowIndex: rowIndex,
+      count: 2,
+      newLines: [
+        TextDocument.getLine(editor.textDocument, rowIndex + 1),
+        TextDocument.getLine(editor.textDocument, rowIndex),
+      ],
+    },
+  ]
+  const cursorEdits = Editor.moveCursors(editor, (editor, cursor) => {
+    return {
+      rowIndex: cursor.rowIndex + 1,
+      columnIndex: cursor.columnIndex,
+    }
+  })
+  Editor.scheduleDocumentAndCursors(editor, documentEdits, cursorEdits)
+}

package/static/1914fad/packages/renderer-worker/src/parts/EditorCommand/EditorCommandMoveLineUp.js

@@ -0,0 +1,29 @@
+import * as TextDocument from '../TextDocument/TextDocument.js'
+import * as Editor from '../Editor/Editor.js'
+
+// TODO handle multiple cursors
+export const editorMoveLineUp = (editor) => {
+  const rowIndex = editor.cursor.rowIndex
+  if (rowIndex === 0) {
+    return
+  }
+  const documentEdits = [
+    {
+      type: /* splice */ 2,
+      rowIndex: rowIndex - 1,
+      count: 2,
+      newLines: [
+        TextDocument.getLine(editor.textDocument, rowIndex),
+        TextDocument.getLine(editor.textDocument, rowIndex - 1),
+      ],
+    },
+  ]
+  const cursorEdits = Editor.moveCursors(editor, (editor, cursor) => {
+    return {
+      // TODO handle bottom 0
+      rowIndex: cursor.rowIndex - 1,
+      columnIndex: cursor.columnIndex,
+    }
+  })
+  Editor.scheduleDocumentAndCursors(editor, documentEdits, cursorEdits)
+}

package/static/1914fad/packages/renderer-worker/src/parts/EditorCommand/EditorCommandMoveRectangleSelection.js

@@ -0,0 +1,26 @@
+import * as Editor from '../Editor/Editor.js'
+import * as EditorHandleClick from './EditorCommandHandleSingleClick.js'
+import * as EditorMoveSelection from './EditorCommandMoveSelection.js'
+
+export const editorMoveRectangleSelection = (editor, position) => {
+  const anchor = EditorMoveSelection.state.position
+  const startRowIndex = anchor.rowIndex
+  const startColumnIndex = anchor.columnIndex
+  const endRowIndex = position.rowIndex
+  const endColumnIndex = position.columnIndex
+  const selectionEdits = []
+  for (let i = startRowIndex; i <= endRowIndex; i++) {
+    selectionEdits.push({
+      start: {
+        rowIndex: i,
+        columnIndex: startColumnIndex,
+      },
+      end: {
+        rowIndex: i,
+        columnIndex: endColumnIndex,
+      },
+    })
+  }
+  const cursorEdits = [selectionEdits.at(-1).end]
+  Editor.scheduleCursorsAndSelections(editor, cursorEdits, selectionEdits)
+}

package/static/1914fad/packages/renderer-worker/src/parts/EditorCommand/EditorCommandMoveRectangleSelectionPx.js

@@ -0,0 +1,7 @@
+import * as EditorMoveRectangleSelection from './EditorCommandMoveRectangleSelection.js'
+import * as EditorPosition from './EditorCommandPosition.js'
+
+export const editorMoveRectangleSelectionPx = (editor, x, y) => {
+  const position = EditorPosition.at(editor, x, y)
+  EditorMoveRectangleSelection.editorMoveRectangleSelection(editor, position)
+}