@lvce-editor/server 0.0.28 → 0.0.31

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

@@ -0,0 +1,32 @@
+import * as TextDocument from '../TextDocument/TextDocument.js'
+
+export const editorReplaceSelections = (editor, replacement, origin) => {
+  const changes = []
+  const selections = editor.selections
+  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 selection = {
+      start,
+      end,
+    }
+    changes.push({
+      start: start,
+      end: end,
+      inserted: replacement,
+      deleted: TextDocument.getSelectionText(editor, selection),
+      origin,
+    })
+  }
+  return changes
+}

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

@@ -0,0 +1,17 @@
+import * as Editor from '../Editor/Editor.js'
+import * as EditorSelection from '../EditorSelection/EditorSelection.js'
+
+export const editorSelectAll = (editor) => {
+  const lines = editor.lines
+  const startRowIndex = 0
+  const startColumnIndex = 0
+  const endRowIndex = lines.length
+  const endColumnIndex = lines.at(-1).length
+  const newSelections = EditorSelection.fromRange(
+    startRowIndex,
+    startColumnIndex,
+    endRowIndex,
+    endColumnIndex
+  )
+  return Editor.scheduleSelections(editor, newSelections)
+}

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

@@ -0,0 +1,159 @@
+import * as Editor from '../Editor/Editor.js'
+
+// TODO handle virtual space
+
+const getNewSelectionsSingleLineWord = (lines, word) => {
+  if (word.length === 0) {
+    throw new Error('word length must be greater than zero')
+  }
+  const newSelections = []
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+    let columnIndex = -word.length
+    while (
+      (columnIndex = line.indexOf(word, columnIndex + word.length)) !== -1
+    ) {
+      newSelections.push(i, columnIndex, i, columnIndex + word.length)
+    }
+  }
+  return new Uint32Array(newSelections)
+}
+
+const isMultiLineMatch = (lines, rowIndex, wordParts) => {
+  let j = 0
+  if (!lines[rowIndex + j].endsWith(wordParts[j])) {
+    return false
+  }
+  while (++j < wordParts.length - 1) {
+    if (lines[rowIndex + j] !== wordParts[j]) {
+      return false
+    }
+  }
+  // j--
+  if (!lines[rowIndex + j].startsWith(wordParts[j])) {
+    lines[rowIndex + j] // ?
+    rowIndex + j // ?
+
+    return false
+  }
+  return true
+}
+
+// TODO this is very expensive, there might be a better algorithm for this
+// TODO if this matches the given selections, don't schedule selections/rerender
+const getAllOccurrencesMultiLine = (lines, wordParts) => {
+  const newSelections = []
+  for (
+    let rowIndex = 0;
+    rowIndex < lines.length - wordParts.length + 1;
+    rowIndex
+  ) {
+    lines
+    rowIndex
+    if (isMultiLineMatch(lines, rowIndex, wordParts)) {
+      newSelections.push(
+        rowIndex,
+        lines[rowIndex].length - wordParts[0].length,
+        rowIndex + wordParts.length - 1,
+        wordParts.at(-1).length
+      )
+      rowIndex += wordParts.length - 1
+    } else {
+      rowIndex++
+    }
+  }
+  return new Uint32Array(newSelections)
+}
+
+// TODO duplicate code with EditorSelectNextOccurrence
+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, rowIndex, columnIndex) => {
+  const line = lines[rowIndex]
+  const start = getWordStartIndex(line, columnIndex)
+  const end = getWordEndIndex(line, columnIndex)
+  const word = line.slice(start, end)
+  return {
+    start,
+    end,
+    word,
+  }
+}
+
+const getNewSelections = (lines, selections) => {
+  if (selections.length < 4) {
+    throw new Error('selections must have at least one entry')
+  }
+  const firstSelectionIndex = 0
+  const startRowIndex = selections[firstSelectionIndex]
+  const startColumnIndex = selections[firstSelectionIndex + 1]
+  const endRowIndex = selections[firstSelectionIndex + 2]
+  const endColumnIndex = selections[firstSelectionIndex + 3]
+  if (startRowIndex === endRowIndex) {
+    if (startColumnIndex === endColumnIndex) {
+      const wordMatch = getWordMatchAtPosition(
+        lines,
+        endRowIndex,
+        endColumnIndex
+      )
+      if (wordMatch.start === wordMatch.end) {
+        return selections
+      }
+      const newSelections = getNewSelectionsSingleLineWord(
+        lines,
+        wordMatch.word
+      )
+      return newSelections
+    }
+    const line = lines[startRowIndex]
+    const word = line.slice(startColumnIndex, endColumnIndex)
+    const newSelections = getNewSelectionsSingleLineWord(lines, word)
+    return newSelections
+  }
+  const wordParts = []
+  wordParts.push(lines[startRowIndex].slice(startColumnIndex))
+  for (let i = startRowIndex + 1; i < endRowIndex - 1; i++) {
+    wordParts.push(lines[i])
+  }
+  wordParts.push(lines[endRowIndex].slice(0, endColumnIndex))
+  const newSelections = getAllOccurrencesMultiLine(lines, wordParts)
+  return newSelections
+}
+
+export const editorSelectAllOccurrences = (editor) => {
+  // when there are no selections -> first selection is word -> find all selection that include word
+  const lines = editor.lines
+  const selections = editor.selections
+  const newSelections = getNewSelections(lines, selections)
+  return Editor.scheduleSelections(editor, newSelections)
+}
+
+const editor = {
+  lines: ['sample text, sample text'],
+  primarySelectionIndex: 0,
+  selections: new Uint32Array([0, 6, 0, 6]),
+}
+
+editorSelectAllOccurrences(editor)

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

@@ -0,0 +1,46 @@
+import * as Editor from '../Editor/Editor.js'
+import * as EditorGetPositionLeft from './EditorCommandGetPositionLeft.js'
+import * as EditorSelection from '../EditorSelection/EditorSelection.js'
+// TODO interleave cursors and selection
+// then loop over selections
+// apply edit
+// if new range is empty -> add cursor
+// else if new range is overlapping -> merge ranges
+// else add cursor and selection
+
+const getNewSelections = (selections, lines, getDelta) => {
+  const newSelections = EditorSelection.clone(selections)
+  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 (
+      selectionStartRow === selectionEndRow &&
+      selectionStartColumn === selectionEndColumn
+    ) {
+      EditorGetPositionLeft.moveToPositionLeft(
+        newSelections,
+        i,
+        selectionStartRow,
+        selectionStartColumn,
+        lines,
+        getDelta
+      )
+      EditorGetPositionLeft.moveToPositionEqual(
+        newSelections,
+        i + 2,
+        selectionEndRow,
+        selectionEndColumn
+      )
+    }
+  }
+  return newSelections
+}
+
+export const editorSelectHorizontalLeft = (editor, getDelta) => {
+  const lines = editor.lines
+  const selections = editor.selections
+  const newSelections = getNewSelections(selections, lines, getDelta)
+  return Editor.scheduleSelections(editor, newSelections)
+}

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

@@ -0,0 +1,30 @@
+import * as Editor from '../Editor/Editor.js'
+
+const getNewSelections = (selections, lines, getDelta) => {
+  const newSelections = new Uint32Array(selections.length)
+  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 line = lines[selectionEndRow]
+    newSelections[i] = selectionStartRow
+    newSelections[i + 1] = selectionStartColumn
+    if (selectionEndColumn >= line.length) {
+      newSelections[i + 2] = selectionEndRow + 1
+      newSelections[i + 3] = 0
+    } else {
+      const delta = getDelta(line, selectionEndColumn)
+      newSelections[i + 2] = selectionEndRow
+      newSelections[i + 3] = selectionEndColumn + delta
+    }
+  }
+  return newSelections
+}
+
+export const editorSelectHorizontalRight = (editor, getDelta) => {
+  const lines = editor.lines
+  const selections = editor.selections
+  const newSelections = getNewSelections(selections, lines, getDelta)
+  return Editor.scheduleSelections(editor, newSelections)
+}

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

@@ -0,0 +1,45 @@
+import * as Editor from '../Editor/Editor.js'
+
+const getNewSelections = (lines, selections) => {
+  const newSelections = new Uint32Array(selections.length)
+  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 (
+      selectionStartRow === selectionEndRow &&
+      selectionStartColumn === selectionEndColumn
+    ) {
+      const rowIndex = selectionStartRow
+      let startColumnIndex = selectionStartColumn
+      let endColumnIndex = selectionEndColumn
+      const line = lines[rowIndex]
+      const quoteFound = false
+      while (startColumnIndex > 0 && line[startColumnIndex] !== '"') {
+        startColumnIndex--
+      }
+      startColumnIndex++
+      while (endColumnIndex < line.length && line[endColumnIndex] !== '"') {
+        endColumnIndex++
+      }
+      newSelections[i] = rowIndex
+      newSelections[i + 1] = startColumnIndex
+      newSelections[i + 2] = rowIndex
+      newSelections[i + 3] = endColumnIndex
+    } else {
+      newSelections[i] = selectionStartRow
+      newSelections[i + 1] = selectionStartColumn
+      newSelections[i + 2] = selectionEndRow
+      newSelections[i + 3] = selectionEndColumn
+    }
+  }
+  return newSelections
+}
+
+export const editorSelectInsideString = (editor) => {
+  const selections = editor.selections
+  const lines = editor.lines
+  const newSelections = getNewSelections(lines, selections)
+  return Editor.scheduleSelections(editor, newSelections)
+}

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

@@ -0,0 +1,15 @@
+import * as Editor from '../Editor/Editor.js'
+import * as TextDocument from '../TextDocument/TextDocument.js'
+
+const getNewSelections = (line, rowIndex) => {
+  // TODO handle virtual space when columnIndex is greater than line length
+  return new Uint32Array([rowIndex, 0, rowIndex, line.length])
+}
+
+export const editorSelectLine = (editor) => {
+  const selections = editor.selections
+  const rowIndex = selections[editor.primarySelectionIndex]
+  const line = TextDocument.getLine(editor, rowIndex)
+  const newSelections = getNewSelections(line, rowIndex)
+  return Editor.scheduleSelections(editor, newSelections)
+}

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

@@ -0,0 +1,254 @@
+import * as Editor from '../Editor/Editor.js'
+import * as TextDocument from '../TextDocument/TextDocument.js'
+import * as EditorSelection from '../EditorSelection/EditorSelection.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 lastSelectionIndex = selections.length - 4
+  const rowIndex = selections[lastSelectionIndex]
+  const lastSelectionStartColumnIndex = selections[lastSelectionIndex + 1]
+  const lastSelectionEndColumnIndex = selections[lastSelectionIndex + 3]
+  const line = lines[rowIndex]
+  const word = line.slice(
+    lastSelectionStartColumnIndex,
+    lastSelectionEndColumnIndex
+  )
+  const columnIndexAfter = line.indexOf(word, lastSelectionEndColumnIndex)
+  if (columnIndexAfter !== -1) {
+    const columnIndexAfterEnd = columnIndexAfter + word.length
+    const revealRange = {
+      start: {
+        rowIndex,
+        columnIndex: columnIndexAfter,
+      },
+      end: {
+        rowIndex,
+        columnIndex: columnIndexAfterEnd,
+      },
+    }
+    const newSelections = EditorSelection.push(
+      selections,
+      rowIndex,
+      columnIndexAfter,
+      rowIndex,
+      columnIndexAfterEnd
+    )
+    return {
+      revealRange: newSelections.length - 4,
+      selectionEdits: newSelections,
+    }
+  }
+  for (let i = rowIndex + 1; i < lines.length; i++) {
+    const line = lines[i]
+    const columnIndex = line.indexOf(word)
+    if (columnIndex !== -1) {
+      const columnIndexEnd = columnIndex + word.length
+      const newSelections = new Uint32Array(selections.length + 4)
+      newSelections.set(selections, 0)
+      const insertIndex = selections.length
+      newSelections[insertIndex] = i
+      newSelections[insertIndex + 1] = columnIndex
+      newSelections[insertIndex + 2] = i
+      newSelections[insertIndex + 3] = columnIndexEnd
+      return {
+        revealRange: newSelections.length - 4,
+        selectionEdits: newSelections,
+      }
+    }
+  }
+  let selectionIndex = 0
+  for (let i = 0; i <= rowIndex; i++) {
+    const line = lines[i]
+    let columnIndex = -word.length
+    while (
+      (columnIndex = line.indexOf(word, columnIndex + word.length)) !== -1
+    ) {
+      let startRowIndex = selections[selectionIndex]
+      while (startRowIndex < i && selectionIndex < selections.length) {
+        selectionIndex += 4
+        startRowIndex = selections[selectionIndex]
+      }
+      if (startRowIndex === i) {
+        let endColumnIndex = selections[selectionIndex + 3]
+        while (
+          endColumnIndex < columnIndex &&
+          selectionIndex < selections.length
+        ) {
+          selectionIndex += 4
+          endColumnIndex = selections[endColumnIndex + 3]
+        }
+      }
+      startRowIndex = selections[selectionIndex]
+      let startColumnIndex = selections[selectionIndex + 1]
+      let endColumnIndex = selections[selectionIndex + 3]
+      if (
+        startRowIndex === i &&
+        startColumnIndex <= columnIndex &&
+        columnIndex <= endColumnIndex
+      ) {
+        continue
+      }
+      if (startRowIndex > i) {
+        selectionIndex -= 4
+      }
+      const columnEndIndex = columnIndex + word.length
+      const revealRange = {
+        start: {
+          rowIndex: i,
+          columnIndex,
+        },
+        end: {
+          rowIndex: i,
+          columnIndex: columnEndIndex,
+        },
+      }
+      selectionIndex += 4
+      const newSelections = new Uint32Array(selections.length + 4)
+      newSelections.set(selections.subarray(0, selectionIndex), 0)
+      newSelections[selectionIndex] = i
+      newSelections[selectionIndex + 1] = columnIndex
+      newSelections[selectionIndex + 2] = i
+      newSelections[selectionIndex + 3] = columnEndIndex
+      newSelections.set(selections.subarray(selectionIndex), selectionIndex + 4)
+      return {
+        revealRange,
+        selectionEdits: newSelections,
+      }
+    }
+  }
+  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, rowIndex, columnIndex) => {
+  const line = lines[rowIndex]
+  const index = columnIndex
+  const start = getWordStartIndex(line, index)
+  const end = getWordEndIndex(line, index)
+  const word = line.slice(start, end)
+  return {
+    start,
+    end,
+    word,
+  }
+}
+
+const getSelectNextOccurrenceResult = (editor) => {
+  const lines = editor.lines
+  const selections = editor.selections
+  if (EditorSelection.isEverySelectionEmpty(selections)) {
+    const newSelections = new Uint32Array(selections.length)
+    for (let i = 0; i < selections.length; i += 4) {
+      const startRowIndex = selections[i]
+      const startColumnIndex = selections[i + 1]
+      const endRowIndex = selections[i + 2]
+      const endColumnIndex = selections[i + 3]
+
+      const wordMatch = getWordMatchAtPosition(
+        lines,
+        startRowIndex,
+        startColumnIndex
+      )
+      wordMatch //?
+      if (wordMatch.start === wordMatch.end) {
+        newSelections[i] = startRowIndex
+        newSelections[i + 1] = startColumnIndex
+        newSelections[i + 2] = endRowIndex
+        newSelections[i + 3] = endColumnIndex
+      } else {
+        newSelections[i] = startRowIndex
+        newSelections[i + 1] = wordMatch.start
+        newSelections[i + 2] = startRowIndex
+        newSelections[i + 3] = wordMatch.end
+      }
+    }
+
+    return {
+      selectionEdits: newSelections,
+      revealRange: newSelections.length - 4, // TODO should be primary selection
+    }
+  }
+
+  if (EditorSelection.isEverySelectionSingleLine(editor.selections)) {
+    return getSelectionEditsSingleLineWord(editor.lines, editor.selections)
+  }
+  return undefined
+}
+
+const isRangeInViewPort = (minLineY, maxLineY, startRowIndex, endRowIndex) => {
+  return startRowIndex >= minLineY && endRowIndex <= 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
+  const revealRangeStartRowIndex = selectionEdits[revealRange]
+  const revealRangeEndRowIndex = selectionEdits[revealRange + 2]
+  if (
+    isRangeInViewPort(
+      editor.minLineY,
+      editor.maxLineY,
+      revealRangeStartRowIndex,
+      revealRangeEndRowIndex
+    )
+  ) {
+    return Editor.scheduleSelections(editor, selectionEdits)
+  }
+  // TODO what is this magic number 5?
+  const deltaY = (revealRangeStartRowIndex - 5) * editor.rowHeight
+  return Editor.scheduleSelectionsAndScrollPosition(
+    editor,
+    selectionEdits,
+    deltaY
+  )
+}

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

@@ -0,0 +1,28 @@
+import * as Editor from '../Editor/Editor.js'
+import * as TextDocument from '../TextDocument/TextDocument.js'
+
+// match all words, including umlauts, see https://stackoverflow.com/questions/5436824/matching-accented-characters-with-javascript-regexes/#answer-11550799
+const RE_WORD_START = /^[a-z\u00C0-\u017F\d]+/i
+const RE_WORD_END = /[a-z\u00C0-\u017F\d]+$/i
+
+const getNewSelections = (line, rowIndex, columnIndex) => {
+  const before = line.slice(0, columnIndex)
+  const after = line.slice(columnIndex)
+  const beforeMatch = before.match(RE_WORD_END)
+  const afterMatch = after.match(RE_WORD_START)
+  const columnStart = columnIndex - (beforeMatch ? beforeMatch[0].length : 0)
+  const columnEnd = columnIndex + (afterMatch ? afterMatch[0].length : 0)
+  const newSelections = new Uint32Array([
+    rowIndex,
+    columnStart,
+    rowIndex,
+    columnEnd,
+  ])
+  return newSelections
+}
+
+export const editorSelectWord = (editor, rowIndex, columnIndex) => {
+  const line = TextDocument.getLine(editor, rowIndex)
+  const newSelections = getNewSelections(line, rowIndex, columnIndex)
+  return Editor.scheduleSelections(editor, newSelections)
+}

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

@@ -0,0 +1,23 @@
+import * as Tokenizer from '../Tokenizer/Tokenizer.js'
+import * as ViewletState from '../ViewletStates/ViewletStates.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 ViewletState.getState('EditorText')
+  }
+  // TODO update syntax highlighting
+  // TODO get edits
+
+  const latestEditor = ViewletState.getState('EditorText')
+
+  return {
+    ...latestEditor,
+    languageId,
+    invalidStartIndex: 0,
+    tokenizer,
+  }
+}