@lvce-editor/server 0.0.27 → 0.0.28

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

@@ -1,119 +0,0 @@
-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 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, position) => {
-  const offset = TextDocument.offsetAt(editor, position)
-  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) => {
-  if (
-    error &&
-    error.message &&
-    error.message.startsWith('Failed to execute type definition provider: ')
-  ) {
-    return error.message.replace(
-      'Failed to execute type definition provider: ',
-      ''
-    )
-  }
-  return `${error}`
-}
-
-export const editorGoToTypeDefinition = async (
-  editor,
-  position = editor.cursor,
-  explicit = true
-) => {
-  try {
-    const typeDefinition = await getTypeDefinition(editor, position)
-    // 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,
-        position,
-        'No type definition found'
-      )
-    }
-
-    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 &&
-      error.message &&
-      error.message.startsWith(
-        'Failed to execute type definition provider: No type definition provider found'
-      )
-    ) {
-      const displayErrorMessage = getTypeDefinitionErrorMessage(error)
-      await EditorShowMessage.editorShowMessage(
-        /* editor */ editor,
-        /* position */ position,
-        /* message */ displayErrorMessage
-      )
-      return editor
-    }
-
-    console.error(error)
-
-    const displayErrorMessage = getTypeDefinitionErrorMessage(error)
-    await EditorShowMessage.editorShowMessage(
-      /* editor */ editor,
-      /* position */ position,
-      /* message */ displayErrorMessage
-    )
-    return editor
-  }
-}

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

@@ -1,10 +0,0 @@
-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'
-  )
-}

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

@@ -1,33 +0,0 @@
-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/eb65b4e/packages/renderer-worker/src/parts/EditorCommand/EditorCommandHandleSingleClick.js

@@ -1,38 +0,0 @@
-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/eb65b4e/packages/renderer-worker/src/parts/EditorCommand/EditorCommandMoveSelectionPx.js

@@ -1,12 +0,0 @@
-import * as EditorMoveSelection from './EditorCommandMoveSelection.js'
-import * as EditorPosition from './EditorCommandPosition.js'
-import * as Assert from '../Assert/Assert.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/eb65b4e/packages/renderer-worker/src/parts/EditorCommand/EditorCommandPaste.js

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

package/static/eb65b4e/packages/renderer-worker/src/parts/EditorCommand/EditorCommandPosition.js

@@ -1,34 +0,0 @@
-import * as Assert from '../Assert/Assert.js'
-
-export const at = (editor, x, y, offset) => {
-  Assert.object(editor)
-  Assert.number(x)
-  Assert.number(y)
-  Assert.number(offset)
-  const rowIndex = Math.floor(
-    (y - editor.top + editor.deltaY) / editor.rowHeight
-  )
-  const columnIndex = offset
-  return {
-    rowIndex,
-    columnIndex,
-  }
-}
-
-/**
- * @deprecated this doesn't work for variable width characters (unicode/emoji).
- * Use position computation in renderer process instead
- *
- * @param {object} editor
- * @param {object} position
- * @returns
- */
-export const x = (editor, position) => {
-  const x = position.columnIndex * editor.columnWidth + editor.left
-  return x
-}
-
-export const y = (editor, position) => {
-  const y = (position.rowIndex + 1) * editor.rowHeight + editor.top
-  return y
-}

package/static/eb65b4e/packages/renderer-worker/src/parts/EditorCommand/EditorCommandSelectNextOccurrence.js

@@ -1,235 +0,0 @@
-import * as Editor from '../Editor/Editor.js'
-import * as TextDocument from '../TextDocument/TextDocument.js'
-
-// TODO handle virtual space
-
-// TODO editors behave differently when selecting next occurrence, for example:
-
-// aaa
-// bbb 1
-// ccc
-// bbb 2
-// bbb 3
-// aaa
-// bbb 4
-// ccc
-
-// when clicking first at position 4 and then position 2,
-// - vscode selects next position 3 and refuses to select position 1
-// - atom also selects next position 3 and refuses to select position 1
-// - WebStorm also selects next position 3 and refuses to select position 1
-// - brackets (codemirror) selects position 3 and then selects position 1
-// - sublime selects next position 1, then next position 3
-
-const isBetween = (value, min, max) => {
-  return min <= value && value <= max
-}
-
-const getSelectionEditsSingleLineWord = (lines, selections) => {
-  const lastSelection = selections.at(-1)
-  const rowIndex = lastSelection.start.rowIndex
-  const word = lines[rowIndex].slice(
-    lastSelection.start.columnIndex,
-    lastSelection.end.columnIndex
-  )
-  const columnIndexAfter = lines[rowIndex].indexOf(
-    word,
-    lastSelection.end.columnIndex
-  )
-  if (columnIndexAfter !== -1) {
-    const revealRange = {
-      start: {
-        rowIndex,
-        columnIndex: columnIndexAfter,
-      },
-      end: {
-        rowIndex,
-        columnIndex: columnIndexAfter + word.length,
-      },
-    }
-    return {
-      revealRange,
-      selectionEdits: [...selections, revealRange],
-    }
-  }
-  for (let i = rowIndex + 1; i < lines.length; i++) {
-    const columnIndex = lines[i].indexOf(word)
-    if (columnIndex !== -1) {
-      const revealRange = {
-        start: {
-          rowIndex: i,
-          columnIndex,
-        },
-        end: {
-          rowIndex: i,
-          columnIndex: columnIndex + word.length,
-        },
-      }
-      return {
-        revealRange,
-        selectionEdits: [...selections, revealRange],
-      }
-    }
-  }
-  let selectionIndex = 0
-  let selection = selections[selectionIndex]
-  for (let i = 0; i <= rowIndex; i++) {
-    const line = lines[i]
-    let columnIndex = -word.length
-    while (
-      (columnIndex = line.indexOf(word, columnIndex + word.length)) !== -1
-    ) {
-      while (
-        selection.start.rowIndex < i &&
-        selectionIndex < selections.length
-      ) {
-        selection = selections[selectionIndex++]
-      }
-      if (selection.start.rowIndex === i) {
-        while (
-          selection.end.columnIndex < columnIndex &&
-          selectionIndex < selections.length
-        ) {
-          selection = selections[selectionIndex++]
-        }
-      }
-      if (
-        selection.start.rowIndex === i &&
-        selection.start.columnIndex <= columnIndex &&
-        columnIndex <= selection.end.columnIndex
-      ) {
-        continue
-      }
-      if (selection.start.rowIndex > i) {
-        selectionIndex--
-      }
-      const revealRange = {
-        start: {
-          rowIndex: i,
-          columnIndex,
-        },
-        end: {
-          rowIndex: i,
-          columnIndex: columnIndex + word.length,
-        },
-      }
-      return {
-        revealRange,
-        selectionEdits: [
-          ...selections.slice(0, selectionIndex),
-          revealRange,
-          ...selections.slice(selectionIndex),
-        ],
-      }
-    }
-  }
-  return undefined
-}
-
-const RE_ALPHA_NUMERIC = /[a-zA-Z\d]/
-
-const isAlphaNumeric = (char) => {
-  return RE_ALPHA_NUMERIC.test(char)
-}
-
-const getWordStartIndex = (line, index) => {
-  for (let i = index - 1; i >= 0; i--) {
-    if (!isAlphaNumeric(line[i])) {
-      return i + 1
-    }
-  }
-  return 0
-}
-
-const getWordEndIndex = (line, index) => {
-  for (let i = index; i < line.length; i++) {
-    if (!isAlphaNumeric(line[i])) {
-      return i
-    }
-  }
-  return line.length - 1
-}
-
-const getWordMatchAtPosition = (lines, position) => {
-  const line = lines[position.rowIndex]
-  const index = position.columnIndex
-  const start = getWordStartIndex(line, index)
-  const end = getWordEndIndex(line, index)
-  const word = line.slice(start, end)
-  return {
-    start,
-    end,
-    word,
-  }
-}
-
-// const
-
-const isEmpty = (selection) => {
-  return selection.start === selection.end
-}
-
-const getNextMatch = () => {}
-
-const isSingleLine = (selection) => {
-  return selection.start.rowIndex === selection.end.rowIndex
-}
-
-const getSelectNextOccurrenceResult = (editor) => {
-  if (editor.selections.every(isEmpty)) {
-    const selectionEdits = []
-    for (const selection of editor.selections) {
-      const wordMatch = getWordMatchAtPosition(editor.lines, selection.start)
-      if (wordMatch.start === wordMatch.end) {
-        selectionEdits.push(selection)
-      } else {
-        selectionEdits.push({
-          start: {
-            rowIndex: selection.start.rowIndex,
-            columnIndex: wordMatch.start,
-          },
-          end: {
-            rowIndex: selection.start.rowIndex,
-            columnIndex: wordMatch.end,
-          },
-        })
-      }
-    }
-    return {
-      selectionEdits,
-      revealRange: selectionEdits.at(-1), // TODO should be primary selection
-    }
-  }
-
-  if (editor.selections.every(isSingleLine)) {
-    return getSelectionEditsSingleLineWord(editor.lines, editor.selections)
-  }
-  return undefined
-}
-
-const isRangeInViewPort = (editor, range) => {
-  return (
-    range.start.rowIndex >= editor.minLineY &&
-    range.end.rowIndex <= editor.maxLineY
-  )
-}
-
-// TODO handle virtual space
-export const editorSelectNextOccurrence = (editor) => {
-  const result = getSelectNextOccurrenceResult(editor)
-  if (!result) {
-    return editor
-  }
-  const revealRange = result.revealRange
-  const selectionEdits = result.selectionEdits
-  if (isRangeInViewPort(editor, revealRange)) {
-    return Editor.scheduleSelections(editor, selectionEdits)
-  } else {
-    const deltaY = (revealRange.start.rowIndex - 5) * editor.rowHeight
-    return Editor.scheduleSelectionsAndScrollPosition(
-      editor,
-      selectionEdits,
-      deltaY
-    )
-  }
-}

package/static/eb65b4e/packages/renderer-worker/src/parts/EditorCommand/EditorCommandSetLanguageId.js

@@ -1,23 +0,0 @@
-import * as Tokenizer from '../Tokenizer/Tokenizer.js'
-import * as Viewlet from '../Viewlet/Viewlet.js'
-
-export const setLanguageId = async (editor, languageId) => {
-  // TODO only load tokenizer if not already loaded
-  // if already loaded just set tokenizer and rerender text
-  await Tokenizer.loadTokenizer(languageId)
-  const tokenizer = Tokenizer.getTokenizer(languageId)
-  if (tokenizer === editor.tokenizer) {
-    return Viewlet.state.instances['EditorText'].state
-  }
-  // TODO update syntax highlighting
-  // TODO get edits
-
-  const latestEditor = Viewlet.state.instances['EditorText'].state
-
-  return {
-    ...latestEditor,
-    languageId,
-    invalidStartIndex: 0,
-    tokenizer,
-  }
-}

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

@@ -1,44 +0,0 @@
-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,
-}
-
-export const editorShowMessage = async (editor, position, message) => {
-  Assert.object(editor)
-  Assert.object(position)
-  Assert.string(message)
-  const x = EditorPosition.x(editor, position)
-  const y = EditorPosition.y(editor, position)
-  const displayErrorMessage = message
-  await RendererProcess.invoke(
-    /* Viewlet.send */ 'Viewlet.send',
-    /* id */ 'EditorText',
-    /* method */ 'showOverlayMessage',
-    /* x */ x,
-    /* y */ y,
-    /* content */ displayErrorMessage
-  )
-  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
-}
-
-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/eb65b4e/packages/renderer-worker/src/parts/EditorCommand/EditorCommandTabCompletion.js

@@ -1,23 +0,0 @@
-import * as ExtensionHostTabCompletion from '../ExtensionHost/ExtensionHostTabCompletion.js'
-import * as TextDocument from '../TextDocument/TextDocument.js'
-import * as EditorSnippet from './EditorCommandSnippet.js'
-
-const getTabCompletion = async (editor) => {
-  const offset = TextDocument.offsetAt(editor, editor.cursor)
-  const tabCompletion =
-    await ExtensionHostTabCompletion.executeTabCompletionProvider(
-      editor,
-      offset
-    )
-  return tabCompletion
-}
-
-export const editorTabCompletion = async (editor) => {
-  // TODO race condition
-  // TODO get tab completion for each cursor
-  const tabCompletion = await getTabCompletion(editor)
-  if (!tabCompletion) {
-    return editor
-  }
-  return EditorSnippet.editorSnippet(editor, tabCompletion)
-}