@lvce-editor/server 0.0.26 → 0.0.29

package/static/0895dce/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/0895dce/packages/renderer-worker/src/parts/EditorCommand/EditorCommandReplaceSelection.js

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

package/static/0895dce/packages/renderer-worker/src/parts/EditorCommand/EditorCommandSelectAll.js

@@ -1,16 +0,0 @@
-import * as Editor from '../Editor/Editor.js'
-
-export const editorSelectAll = (editor) => {
-  const selection = {
-    start: {
-      rowIndex: 0,
-      columnIndex: 0,
-    },
-    end: {
-      rowIndex: editor.lines.length,
-      columnIndex: editor.lines.at(-1).length,
-    },
-  }
-  const selectionEdits = [selection]
-  return Editor.scheduleSelections(editor, selectionEdits)
-}

package/static/0895dce/packages/renderer-worker/src/parts/EditorCommand/EditorCommandSelectAllOccurrences.js

@@ -1,146 +0,0 @@
-import * as Editor from '../Editor/Editor.js'
-
-// TODO handle virtual space
-
-const getSelectionEditsSingleLineWord = (lines, word) => {
-  const occurrences = []
-  for (const [rowIndex, line] of lines.entries()) {
-    let columnIndex = -word.length
-    while (
-      (columnIndex = line.indexOf(word, columnIndex + word.length)) !== -1
-    ) {
-      occurrences.push({
-        start: {
-          rowIndex,
-          columnIndex,
-        },
-        end: {
-          rowIndex,
-          columnIndex: columnIndex + word.length,
-        },
-      })
-    }
-  }
-  return occurrences
-}
-
-// selectAllOccurrencesSingleLine(['sample text, sample text'], 'sample') //?
-
-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 occurrences = []
-  for (
-    let rowIndex = 0;
-    rowIndex < lines.length - wordParts.length + 1;
-    rowIndex
-  ) {
-    lines
-    rowIndex
-    if (isMultiLineMatch(lines, rowIndex, wordParts)) {
-      occurrences.push({
-        start: {
-          rowIndex,
-          columnIndex: lines[rowIndex].length - wordParts[0].length,
-        },
-        end: {
-          rowIndex: rowIndex + wordParts.length - 1,
-          columnIndex: wordParts.at(-1).length,
-        },
-      })
-      rowIndex += wordParts.length - 1
-    } else {
-      rowIndex++
-    }
-  }
-  return occurrences
-}
-
-// 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, 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,
-  }
-}
-
-export const editorSelectAllOccurrences = (editor) => {
-  // when there are no selections -> first selection is word -> find all selection that include word
-  const lines = editor.lines
-  if (Editor.hasSelection(editor)) {
-    const lastSelection = editor.selections.at(-1)
-    const startRowIndex = lastSelection.start.rowIndex
-    const startColumnIndex = lastSelection.start.columnIndex
-    const endRowIndex = lastSelection.end.rowIndex
-    const endColumnIndex = lastSelection.end.columnIndex
-    if (startRowIndex === endRowIndex) {
-      const word = lines[startRowIndex].slice(startColumnIndex, endColumnIndex)
-      const selectionEdits = getSelectionEditsSingleLineWord(lines, word)
-      return Editor.scheduleSelections(editor, selectionEdits)
-    }
-    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 selectionEdits = getAllOccurrencesMultiLine(lines, wordParts)
-    return Editor.scheduleSelections(editor, selectionEdits)
-  }
-  const wordMatch = getWordMatchAtPosition(editor.lines, editor.cursor)
-  if (wordMatch.start === wordMatch.end) {
-    return editor
-  }
-  const selectionEdits = getSelectionEditsSingleLineWord(lines, wordMatch.word)
-  return Editor.scheduleSelections(editor, selectionEdits)
-}

package/static/0895dce/packages/renderer-worker/src/parts/EditorCommand/EditorCommandSelectHorizontalLeft.js

@@ -1,31 +0,0 @@
-import * as Editor from '../Editor/Editor.js'
-import * as EditorGetPositionLeft from './EditorCommandGetPositionLeft.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 getNewSelection = (selection, lines, getDelta) => {
-  const positionLeft = EditorGetPositionLeft.editorGetPositionLeft(
-    selection.start,
-    lines,
-    getDelta
-  )
-  return {
-    start: positionLeft,
-    end: selection.end,
-  }
-}
-
-export const editorSelectHorizontalLeft = (editor, getDelta) => {
-  const selectionEdits = []
-  const lines = editor.lines
-  for (const selection of editor.selections) {
-    const newSelection = getNewSelection(selection, lines, getDelta)
-    selectionEdits.push(newSelection)
-  }
-  return Editor.scheduleSelections(editor, selectionEdits)
-}

package/static/0895dce/packages/renderer-worker/src/parts/EditorCommand/EditorCommandSelectHorizontalRight.js

@@ -1,24 +0,0 @@
-import * as Editor from '../Editor/Editor.js'
-import * as EditorGetPositionRight from './EditorCommandGetPositionRight.js'
-
-const getNewSelection = (selection, lines, getDelta) => {
-  const positionRight = EditorGetPositionRight.editorGetPositionRight(
-    selection.end,
-    lines,
-    getDelta
-  )
-  return {
-    start: selection.start,
-    end: positionRight,
-  }
-}
-
-export const editorSelectHorizontalRight = (editor, getDelta) => {
-  const selectionEdits = []
-  const lines = editor.lines
-  for (const selection of editor.selections) {
-    const newSelection = getNewSelection(selection, lines, getDelta)
-    selectionEdits.push(newSelection)
-  }
-  return Editor.scheduleSelections(editor, selectionEdits)
-}

package/static/0895dce/packages/renderer-worker/src/parts/EditorCommand/EditorCommandSelectInsideString.js

@@ -1,39 +0,0 @@
-import * as Editor from '../Editor/Editor.js'
-
-const findStringRange = (lines, range) => {
-  if (range.start !== range.end) {
-    return range
-  }
-  const rowIndex = range.start.rowIndex
-  let startColumnIndex = range.start.columnIndex
-  let endColumnIndex = range.end.columnIndex
-  const line = lines[rowIndex]
-  const quoteFound = false
-  while (startColumnIndex > 0 && line[startColumnIndex] !== '"') {
-    startColumnIndex--
-  }
-  startColumnIndex++
-  while (endColumnIndex < line.length && line[endColumnIndex] !== '"') {
-    endColumnIndex++
-  }
-  return {
-    start: {
-      rowIndex,
-      columnIndex: startColumnIndex,
-    },
-    end: {
-      rowIndex,
-      columnIndex: endColumnIndex,
-    },
-  }
-}
-
-export const editorSelectInsideString = (editor) => {
-  const newSelections = []
-  for (const selection of editor.selections) {
-    // TODO find string range, possibly use tokenizer
-    const newSelection = findStringRange(editor.lines, selection)
-    newSelections.push(newSelection)
-  }
-  return Editor.scheduleSelections(editor, newSelections)
-}

package/static/0895dce/packages/renderer-worker/src/parts/EditorCommand/EditorCommandSelectLine.js

@@ -1,25 +0,0 @@
-import * as Editor from '../Editor/Editor.js'
-import * as TextDocument from '../TextDocument/TextDocument.js'
-
-const getLineSelection = (line, rowIndex) => {
-  const selection = {
-    start: {
-      rowIndex,
-      columnIndex: 0,
-    },
-    end: {
-      rowIndex,
-      // TODO handle virtual space when columnIndex is greater than line length
-      columnIndex: line.length,
-    },
-  }
-  return selection
-}
-
-export const editorSelectLine = (editor) => {
-  const rowIndex = editor.cursor.rowIndex
-  const line = TextDocument.getLine(editor, rowIndex)
-  const selection = getLineSelection(line, rowIndex)
-  const selectionEdits = [selection]
-  return Editor.scheduleSelections(editor, selectionEdits)
-}

package/static/0895dce/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/0895dce/packages/renderer-worker/src/parts/EditorCommand/EditorCommandSelectWord.js

@@ -1,33 +0,0 @@
-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 getWordSelection = (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 selection = {
-    start: {
-      rowIndex,
-      columnIndex: columnStart,
-    },
-    end: {
-      rowIndex,
-      columnIndex: columnEnd,
-    },
-  }
-  return selection
-}
-
-export const editorSelectWord = (editor, rowIndex, columnIndex) => {
-  const line = TextDocument.getLine(editor, rowIndex)
-  const selection = getWordSelection(line, rowIndex, columnIndex)
-  const selectionEdits = [selection]
-  return Editor.scheduleSelections(editor, selectionEdits)
-}

package/static/0895dce/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/0895dce/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
-}