@lvce-editor/server 0.13.0 → 0.14.0

package/static/5a94137/packages/renderer-worker/src/parts/Editor/EditorText.js

@@ -0,0 +1,213 @@
+import * as GetDecorationClassName from '../GetDecorationClassName/GetDecorationClassName.js'
+import * as GetTokensViewport from '../GetTokensViewport/GetTokensViewport.js'
+import * as NormalizeText from '../NormalizeText/NormalizeText.js'
+import * as TextDocument from '../TextDocument/TextDocument.js'
+import * as Tokenizer from '../Tokenizer/Tokenizer.js'
+
+// const getTokens = (editor) => {
+//   const tokens = []
+//   const lines = editor.lines
+//   let lineState = editor.tokenizer.initialLineState
+//   // TODO lineCache should probably only store endOfLineState
+//   // because storing tokens could maybe result in high
+//   // memory usage (e.g. 10000 lines * 10 tokens per line = 100 000 objects stored)
+//   // on the other hand, scrolling should be really fast, and needlessly
+//   // recomputing tokens would be a waste of cpu time and cause lots of garbage collection
+//   const lineCache = editor.lineCache
+//   // TODO only compute tokens in viewport
+//   // console.log('minmax', editor.minLineY, editor.maxLineY)
+//   // const cachedLineStates = Object.create(null)
+//   // if(cachedLineStates[i])
+//   const tokenizeLine = editor.tokenizer.tokenizeLine
+//   for (let i = 0; i < lines.length; i++) {
+//     if (lineCache[i]) {
+//       // console.log('cached line')
+//       tokens.push(lineCache[i].tokens)
+//       continue
+//     }
+//     // TODO use TextDocument.getLine so that text document buffer implementation
+//     // can be changed (e.g. vscode has piece tree, codemirror has something like chunked arrays / string[][])
+//     const line = lines[i]
+//     lineState = safeTokenizeLine(tokenizeLine, line, lineState)
+//     const newTokens = lineState.tokens
+//     lineCache[i] = lineState
+//     tokens.push(newTokens)
+//   }
+//   return tokens
+// }
+
+// TODO vscode has an interesting approach for tokenizing:
+// first, the viewport is tokenized from startLine to endLine
+// the first iteration might not be accurate because for example
+// there can be a open multiline comment at the start of the file
+// which is not taken into account for this first tokenization
+// but after some time (onIdle), the background tokenizer is invoked
+// that gives accurate results (but can take much longer since it
+// might need to parse from the start of the file)
+//
+// another approach would be to show plain text (non-highlighted)
+// when scrolling fast and the tokenizer is too slow to parse from
+// the start of the file
+//
+// the approach implemented below for tokenizing the viewport
+// is just to parse from the start of the file if necessary
+// that doesn't scale well for large files but it is simpler
+// to implement for now
+
+// TODO only send changed lines to renderer process instead of all lines in viewport
+
+export const loadTokenizers = async (languageIds) => {
+  for (const languageId of languageIds) {
+    await Tokenizer.loadTokenizer(languageId)
+  }
+}
+
+const invalidateLine = (editor, index) => {
+  editor.validLines[index] = false
+  if (index < editor.invalidStartIndex) {
+    editor.invalidStartIndex = index
+  }
+}
+
+const applyChangesToSyntaxHighlighting = (editor, changes) => {
+  // TODO invalidate lines that are affected
+}
+
+// const getTokensIncremental = (editor, min, max) => {
+//   const currentLength = editor.lineStateCache.length
+//   const tokens = []
+//   const lines = editor.lines
+//   let lineState = editor.tokenizer.initialLineState
+//   for (let i = currentLength; i < max; i++) {
+//     const line = lines[i]
+//     try {
+//       lineState = editor.tokenizer.tokenizeLine(line, lineState)
+//       if (!lineState || !lineState.tokens || !lineState.state) {
+//         throw new Error('invalid tokenization result')
+//       }
+//     } catch (error) {
+//       tokens.push([{ length: line.length, type: 0 }])
+//       console.error(error)
+//       // renderWithoutSyntaxHighlighting(state, firstRow, lastRow)
+//       continue
+//     }
+//     const newTokens = lineState.tokens
+//     tokens.push(newTokens)
+//   }
+//   return tokens
+// }
+
+// const getLineInfosIncremental = (editor, tokens, minLineY, maxLineY) => {
+//   const result = []
+//   const lines = editor.lines
+//   const TokenMap = editor.tokenizer.TokenMap
+//   for (let i = minLineY; i < maxLineY; i++) {
+//     result.push(getLineInfo(lines[i], tokens[i], TokenMap))
+//   }
+//   return result
+// }
+
+const getLineInfoEmbeddedFull = (embeddedResults, tokenResults, line, normalize, tabSize) => {
+  let start = 0
+  let end = 0
+  const lineInfo = []
+  const embeddedResult = embeddedResults[tokenResults.embeddedResultIndex]
+  const embeddedTokens = embeddedResult.result.tokens
+  const embeddedTokenMap = embeddedResult.TokenMap
+  for (let i = 0; i < embeddedTokens.length; i += 2) {
+    const tokenType = embeddedTokens[i]
+    const tokenLength = embeddedTokens[i + 1]
+    let extraClassName = ''
+    end += tokenLength
+    const className = `Token ${extraClassName || embeddedTokenMap[tokenType] || 'Unknown'}`
+    const text = line.slice(start, end)
+    const normalizedText = NormalizeText.normalizeText(text, normalize, tabSize)
+    lineInfo.push(normalizedText, className)
+    start = end
+  }
+  return lineInfo
+}
+
+const getLineInfoDefault = (line, tokenResults, embeddedResults, decorations, TokenMap, lineOffset, normalize, tabSize) => {
+  let start = 0
+  let end = 0
+  const lineInfo = []
+  let decorationIndex = 0
+  for (; decorationIndex < decorations.length; decorationIndex += 3) {
+    const decorationOffset = decorations[decorationIndex]
+    if (decorationOffset >= lineOffset) {
+      break
+    }
+  }
+  const tokens = tokenResults.tokens
+  // console.log({ tokens, decorations })
+  for (let i = 0; i < tokens.length; i += 2) {
+    const tokenType = tokens[i]
+    const tokenLength = tokens[i + 1]
+    const decorationOffset = decorations[decorationIndex]
+    let extraClassName = ''
+    if (decorationOffset !== undefined && decorationOffset - lineOffset === start) {
+      const decorationLength = decorations[++decorationIndex]
+      const decorationType = decorations[++decorationIndex]
+      const decorationModifiers = decorations[++decorationIndex]
+      // console.log('MATCHING DECORATION', {
+      //   decorationIndex,
+      //   decorationLength,
+      //   decorationType,
+      //   decorationModifiers,
+      // })
+      extraClassName = GetDecorationClassName.getDecorationClassName(decorationType)
+    }
+
+    end += tokenLength
+    const text = line.slice(start, end)
+    const className = `Token ${extraClassName || TokenMap[tokenType] || 'Unknown'}`
+    const normalizedText = NormalizeText.normalizeText(text, normalize, tabSize)
+    lineInfo.push(normalizedText, className)
+    start = end
+  }
+  return lineInfo
+}
+
+const getLineInfo = (line, tokenResults, embeddedResults, decorations, TokenMap, lineOffset, normalize, tabSize) => {
+  if (embeddedResults.length > 0 && tokenResults.embeddedResultIndex !== undefined) {
+    const embeddedResult = embeddedResults[tokenResults.embeddedResultIndex]
+    if (embeddedResult && embeddedResult.isFull) {
+      return getLineInfoEmbeddedFull(embeddedResults, tokenResults, line, normalize, tabSize)
+    }
+  }
+  return getLineInfoDefault(line, tokenResults, embeddedResults, decorations, TokenMap, lineOffset, normalize, tabSize)
+}
+
+// TODO need lots of tests for this
+const getLineInfosViewport = (editor, tokens, embeddedResults, minLineY, maxLineY, minLineOffset) => {
+  const result = []
+  const { lines, tokenizer, decorations } = editor
+  const { TokenMap } = tokenizer
+  let offset = minLineOffset
+  const tabSize = 2
+  for (let i = minLineY; i < maxLineY; i++) {
+    const line = lines[i]
+    const normalize = NormalizeText.shouldNormalizeText(line)
+    result.push(getLineInfo(line, tokens[i - minLineY], embeddedResults, decorations, TokenMap, offset, normalize, tabSize))
+    offset += line.length + 1
+  }
+  return result
+}
+
+export const getVisible = (editor) => {
+  // console.log({ editor })
+  // TODO should separate rendering from business logic somehow
+  // currently hard to test because need to mock editor height, top, left,
+  // invalidStartIndex, lineCache, etc. just for testing editorType
+  // editor.invalidStartIndex = changes[0].start.rowIndex
+  const { minLineY, numberOfVisibleLines, lines } = editor
+  const maxLineY = Math.min(minLineY + numberOfVisibleLines, lines.length)
+  const { tokens, tokenizersToLoad, embeddedResults } = GetTokensViewport.getTokensViewport(editor, minLineY, maxLineY)
+  const minLineOffset = TextDocument.offsetAt(editor, minLineY, 0)
+  const textInfos = getLineInfosViewport(editor, tokens, embeddedResults, minLineY, maxLineY, minLineOffset)
+  if (tokenizersToLoad.length > 0) {
+    loadTokenizers(tokenizersToLoad)
+  }
+  return textInfos
+}

package/static/5a94137/packages/renderer-worker/src/parts/EditorCommand/EditorCommandDeleteCharacterLeft.js

@@ -0,0 +1,8 @@
+import * as EditorDeleteHorizontalLeft from './EditorCommandDeleteHorizontalLeft.js'
+import * as EditorDelta from './EditorCommandDelta.js'
+
+export const deleteCharacterLeft = (editor) => {
+  return EditorDeleteHorizontalLeft.editorDeleteHorizontalLeft(editor, EditorDelta.characterLeft)
+}
+
+export const deleteLeft = deleteCharacterLeft

package/static/5a94137/packages/renderer-worker/src/parts/EditorCommand/EditorCommandDeleteHorizontalLeft.js

@@ -0,0 +1,58 @@
+import * as Editor from '../Editor/Editor.js'
+import * as EditOrigin from '../EditOrigin/EditOrigin.js'
+import * as EditorSelection from '../EditorSelection/EditorSelection.js'
+import * as IsAllAutoClosingPairDelete from '../IsAllAutoClosingPairDelete/IsAllAutoClosingPairDelete.js'
+import * as TextDocument from '../TextDocument/TextDocument.js'
+import * as EditorDelta from './EditorCommandDelta.js'
+import * as EditorGetPositionLeft from './EditorCommandGetPositionLeft.js'
+import { editorReplaceSelections } from './EditorCommandReplaceSelection.js'
+
+// TODO optimize this function by profiling and not allocating too many objects
+const getChanges = (lines, selections, getDelta) => {
+  const changes = []
+  const deleteSelection = (selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn) => {
+    const positionLeft = EditorGetPositionLeft.editorGetPositionLeft(selectionStartRow, selectionStartColumn, lines, getDelta)
+    const selectionEnd = {
+      rowIndex: selectionEndRow,
+      columnIndex: selectionEndColumn,
+    }
+    changes.push({
+      start: positionLeft,
+      end: selectionEnd,
+      inserted: [''],
+      deleted: TextDocument.getSelectionText(
+        { lines },
+        {
+          start: positionLeft,
+          end: selectionEnd,
+        }
+      ),
+      origin: EditOrigin.Delete,
+    })
+  }
+  EditorSelection.forEach(selections, deleteSelection)
+  return changes
+}
+
+const deleteLeftWithAutoClose = (editor) => {
+  const { selections, lines } = editor
+  for (let i = 0; i < selections.length; i += 4) {
+    selections[i + 1]++
+    selections[i + 3]++
+  }
+  const changes = getChanges(lines, selections, EditorDelta.twoCharactersLeft)
+  return Editor.scheduleDocumentAndCursorsSelections(editor, changes)
+}
+
+export const editorDeleteHorizontalLeft = (editor, getDelta) => {
+  const { autoClosingRanges = [], selections, lines } = editor
+  if (IsAllAutoClosingPairDelete.isAllAutoClosingPairDelete(autoClosingRanges, selections)) {
+    return deleteLeftWithAutoClose(editor)
+  }
+  if (EditorSelection.isEverySelectionEmpty(selections)) {
+    const changes = getChanges(lines, selections, getDelta)
+    return Editor.scheduleDocumentAndCursorsSelections(editor, changes)
+  }
+  const changes = editorReplaceSelections(editor, [''], EditOrigin.Delete)
+  return Editor.scheduleDocumentAndCursorsSelections(editor, changes)
+}

package/static/5a94137/packages/renderer-worker/src/parts/EditorCommand/EditorCommandDeleteWordRight.js

@@ -0,0 +1,6 @@
+import * as EditorDeleteHorizontalRight from './EditorCommandDeleteHorizontalRight.js'
+import * as EditorDelta from './EditorCommandDelta.js'
+
+export const deleteWordRight = (editor) => {
+  return EditorDeleteHorizontalRight.editorDeleteHorizontalRight(editor, EditorDelta.wordRight)
+}

package/static/5a94137/packages/renderer-worker/src/parts/EditorCommand/EditorCommandDelta.js

@@ -0,0 +1,144 @@
+import * as TextSegmenter from '../TextSegmenter/TextSegmenter.js'
+
+export const characterLeft = (line, columnIndex) => {
+  if (!TextSegmenter.supported()) {
+    return 1
+  }
+  const segmenter = TextSegmenter.create()
+  const last = segmenter.at(line, columnIndex - 1)
+  return columnIndex - last.index
+}
+
+export const twoCharactersLeft = () => {
+  return 2
+}
+
+export const characterRight = (line, columnIndex) => {
+  if (!TextSegmenter.supported()) {
+    return 1
+  }
+  const segmenter = TextSegmenter.create()
+  const next = segmenter.at(line, columnIndex)
+  return next.segment.length
+}
+
+const isWhitespace = (char) => {
+  return char === ' ' || char === '\t'
+}
+
+export const lineCharacterStart = (line, columnIndex) => {
+  if (line.length === 0) {
+    return 0
+  }
+  for (let i = 0; i < columnIndex; i++) {
+    if (!isWhitespace(line[i])) {
+      return columnIndex - i
+    }
+  }
+  return columnIndex
+}
+
+export const lineEnd = (line, columnIndex) => {
+  return line.length - columnIndex
+}
+
+const tryRegexArray = (partialLine, regexArray) => {
+  for (const regex of regexArray) {
+    const match = partialLine.match(regex)
+    if (match) {
+      return match[0].length
+    }
+  }
+  return 1
+}
+
+const RE_WORD_LEFT_1 = /(?<![A-Z])[A-Z]+\s*$/
+const RE_WORD_LEFT_2 = /[\u00C0-\u017F\w\-]+>?\s*$/
+const RE_WORD_LEFT_3 = /[a-zA-Z]+[^a-zA-Z\d]+\s*$/
+const RE_WORD_LEFT_4 = /\s+$/
+const RE_WORD_LEFT_5 = /[^a-zA-Z\d]+\s*$/
+const RE_WORD_LEFT = [RE_WORD_LEFT_1, RE_WORD_LEFT_2, RE_WORD_LEFT_3, RE_WORD_LEFT_4, RE_WORD_LEFT_5]
+
+export const wordLeft = (line, columnIndex) => {
+  const partialLine = line.slice(0, columnIndex)
+  return tryRegexArray(partialLine, RE_WORD_LEFT)
+}
+
+const RE_WORD_RIGHT_1 = /^\s*[\u00C0-\u017F\w]+/i
+const RE_WORD_RIGHT_2 = /^[^a-zA-Z\d]+\w*/
+const RE_WORD_RIGHT = [RE_WORD_RIGHT_1, RE_WORD_RIGHT_2]
+
+export const wordRight = (line, columnIndex) => {
+  const partialLine = line.slice(columnIndex)
+  return tryRegexArray(partialLine, RE_WORD_RIGHT)
+}
+
+const RE_PARTIAL_WORD_LEFT_1 = /(?<![A-Z])[A-Z]{2}[a-z]+$/
+const RE_PARTIAL_WORD_LEFT_2 = /(?=[A-Z]+)[A-Z][a-z]+$/
+const RE_PARTIAL_WORD_LEFT_3 = /[A-Z]+[a-z]+\d?\s*$/
+const RE_PARTIAL_WORD_LEFT_4 = /[A-Z]+\d*\s*$/
+const RE_PARTIAL_WORD_LEFT_5 = /[a-z]+\d*\s*$/
+const RE_PARTIAL_WORD_LEFT_6 = /[A-Z]*[a-z]+_+\s*$/
+const RE_PARTIAL_WORD_LEFT_7 = /(?<![A-Z])[A-Z]_+\s*$/
+const RE_PARTIAL_WORD_LEFT_8 = /[a-z]+\s*$/
+const RE_PARTIAL_WORD_LEFT_9 = /[^a-zA-Z\d\s]+\s*$/
+const RE_PARTIAL_WORD_LEFT = [
+  RE_PARTIAL_WORD_LEFT_1,
+  RE_PARTIAL_WORD_LEFT_2,
+  RE_PARTIAL_WORD_LEFT_3,
+  RE_PARTIAL_WORD_LEFT_4,
+  RE_PARTIAL_WORD_LEFT_5,
+  RE_PARTIAL_WORD_LEFT_6,
+  RE_PARTIAL_WORD_LEFT_7,
+  RE_PARTIAL_WORD_LEFT_8,
+  RE_PARTIAL_WORD_LEFT_9,
+]
+
+export const wordPartLeft = (line, columnIndex) => {
+  const partialLine = line.slice(0, columnIndex)
+  return tryRegexArray(partialLine, RE_PARTIAL_WORD_LEFT)
+}
+
+const RE_PARTIAL_WORD_RIGHT_1 = /^\s*[a-z]+\d?/
+const RE_PARTIAL_WORD_RIGHT_2 = /^\s*[A-Z]{2}[a-z\d]+/
+const RE_PARTIAL_WORD_RIGHT_3 = /^\s*[A-Z]+(?=[A-Z][a-z]+)/
+const RE_PARTIAL_WORD_RIGHT_4 = /^\s*[A-Z]+[a-z]*\d*/
+const RE_PARTIAL_WORD_RIGHT_5 = /^\s*_+[a-z]*\d?/
+const RE_PARTIAL_WORD_RIGHT_6 = /^\s*[^\da-zA-Z\s]+/
+// const RE_PARTIAL_WORD_RIGHT_6 = /^\s*[A-Z][A-Z](?![A-Z])*/
+// const RE_PARTIAL_WORD_RIGHT_7 = /^\s*[A-Z][A-Z][a-z]*/
+
+const ARRAY_PARTIAL_WORD_RIGHT_1 = [
+  RE_PARTIAL_WORD_RIGHT_1,
+  // RE_PARTIAL_WORD_RIGHT_2,
+  RE_PARTIAL_WORD_RIGHT_3,
+  RE_PARTIAL_WORD_RIGHT_4,
+  RE_PARTIAL_WORD_RIGHT_5,
+  RE_PARTIAL_WORD_RIGHT_6,
+]
+const ARRAY_PARTIAL_WORD_RIGHT_2 = [
+  RE_PARTIAL_WORD_RIGHT_1,
+  RE_PARTIAL_WORD_RIGHT_2,
+  RE_PARTIAL_WORD_RIGHT_3,
+  RE_PARTIAL_WORD_RIGHT_4,
+  RE_PARTIAL_WORD_RIGHT_5,
+  RE_PARTIAL_WORD_RIGHT_6,
+]
+
+const RE_UPPERCASE = /[A-Z]/
+
+export const wordPartRight = (line, columnIndex) => {
+  const partialLine = line.slice(columnIndex)
+  // line[columnIndex]//?
+  if (RE_UPPERCASE.test(line[columnIndex - 1])) {
+    return tryRegexArray(partialLine, ARRAY_PARTIAL_WORD_RIGHT_1)
+  }
+  return tryRegexArray(partialLine, ARRAY_PARTIAL_WORD_RIGHT_2)
+}
+
+// wordPartRight('"command": "actions.find"', 8) //?
+// 'DDa'.match(RE_PARTIAL_WORD_RIGHT_1) //?
+// wordPartRight('DDa', 0) //?
+// wordPartRight('DEBUGEntry', 3) //?
+
+export const line = (line) => {}

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

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

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

@@ -0,0 +1,91 @@
+import * as Editor from '../Editor/Editor.js'
+import * as EditOrigin from '../EditOrigin/EditOrigin.js'
+import * as EditorSelection from '../EditorSelection/EditorSelection.js'
+import * as Languages from '../Languages/Languages.js'
+import * as TextDocument from '../TextDocument/TextDocument.js'
+
+const getIncreaseIndentRegex = (languageConfiguration) => {
+  if (
+    languageConfiguration &&
+    languageConfiguration.indentationRules &&
+    languageConfiguration.indentationRules.increaseIndentPattern &&
+    typeof languageConfiguration.indentationRules.increaseIndentPattern === 'string'
+  ) {
+    const regex = new RegExp(languageConfiguration.indentationRules.increaseIndentPattern)
+    return regex
+  }
+  return undefined
+}
+
+const shouldIncreaseIndent = (before, increaseIndentRegex) => {
+  if (!increaseIndentRegex) {
+    return false
+  }
+  return increaseIndentRegex.test(before)
+}
+
+const getChanges = (lines, selections, languageConfiguration) => {
+  const changes = []
+  const selectionChanges = []
+  const increaseIndentRegex = getIncreaseIndentRegex(languageConfiguration)
+  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 (EditorSelection.isEmpty(selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn)) {
+      const line = lines[selectionStartRow]
+      const before = line.slice(0, selectionStartColumn)
+      const indent = TextDocument.getIndent(before)
+      if (shouldIncreaseIndent(before, increaseIndentRegex)) {
+        changes.push({
+          start: start,
+          end: end,
+          inserted: ['', indent + '  ', indent],
+          deleted: TextDocument.getSelectionText({ lines }, range),
+          origin: EditOrigin.InsertLineBreak,
+        })
+        selectionChanges.push(selectionStartRow + 1, indent.length + 2, selectionStartRow + 1, indent.length + 2)
+      } else {
+        changes.push({
+          start: start,
+          end: end,
+          inserted: ['', indent],
+          deleted: TextDocument.getSelectionText({ lines }, range),
+          origin: EditOrigin.InsertLineBreak,
+        })
+        selectionChanges.push(selectionStartRow + 1, indent.length, selectionStartRow + 1, indent.length)
+      }
+    } else {
+      changes.push({
+        start: start,
+        end: end,
+        inserted: ['', ''],
+        deleted: TextDocument.getSelectionText({ lines }, range),
+        origin: EditOrigin.InsertLineBreak,
+      })
+      selectionChanges.push(selectionStartRow + 1, 0, selectionStartRow + 1, 0)
+    }
+  }
+  return { changes, selectionChanges: new Uint32Array(selectionChanges) }
+}
+
+export const insertLineBreak = async (editor) => {
+  const { lines, selections } = editor
+  const languageConfiguration = await Languages.getLanguageConfiguration(editor)
+  const { changes, selectionChanges } = getChanges(lines, selections, languageConfiguration)
+  return Editor.scheduleDocumentAndCursorsSelections(editor, changes, selectionChanges)
+}

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

@@ -0,0 +1,43 @@
+import * as Assert from '../Assert/Assert.js'
+import * as Clamp from '../Clamp/Clamp.js'
+import * as GetAccurateColumnIndex from '../GetAccurateColumnIndex/GetAccurateColumnIndex.js'
+
+export const at = (editor, eventX, eventY) => {
+  Assert.object(editor)
+  Assert.number(eventX)
+  Assert.number(eventY)
+  const { y, deltaY, rowHeight, fontSize, fontWeight, fontFamily, letterSpacing, lines, tabSize } = editor
+  const rowIndex = Math.floor((eventY - y + deltaY) / rowHeight)
+  if (rowIndex < 0) {
+    return {
+      rowIndex: 0,
+      columnIndex: 0,
+    }
+  }
+  const clampedRowIndex = Clamp.clamp(rowIndex, 0, lines.length - 1)
+  const line = lines[clampedRowIndex]
+  const columnIndex = GetAccurateColumnIndex.getAccurateColumnIndex(line, fontWeight, fontSize, fontFamily, letterSpacing, tabSize, eventX)
+  return {
+    rowIndex: clampedRowIndex,
+    columnIndex,
+  }
+}
+
+/**
+ * @deprecated this doesn't work for variable width characters (unicode/emoji).
+ * Use position computation in renderer process instead
+ *
+ * @param {object} editor
+ * @param {number} rowIndex
+ * @param {number} columnIndex
+ * @returns
+ */
+export const x = (editor, rowIndex, columnIndex) => {
+  const x = columnIndex * editor.columnWidth + editor.x
+  return x
+}
+
+export const y = (editor, rowIndex, columnIndex) => {
+  const y = (rowIndex + 1) * editor.rowHeight + editor.y
+  return y
+}

package/static/5a94137/packages/renderer-worker/src/parts/EditorCommand/EditorCommandSelectAll.js

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

package/static/5a94137/packages/renderer-worker/src/parts/EditorCommand/EditorCommandToggleComment.js

@@ -0,0 +1,27 @@
+import * as EditorToggleBlockComment from './EditorCommandToggleBlockComment.js'
+import * as EditorToggleLineComment from './EditorCommandToggleLineComment.js'
+import * as EditorShowMessage from './EditorCommandShowMessage.js'
+import * as Logger from '../Logger/Logger.js'
+
+// TODO rename file
+// TODO when handle case when editor has selection
+export const toggleComment = async (editor) => {
+  try {
+    const newEditor = await EditorToggleLineComment.editorToggleLineComment(editor)
+    if (editor !== newEditor) {
+      return newEditor
+    }
+    return EditorToggleBlockComment.toggleBlockComment(editor)
+  } catch (error) {
+    Logger.error(error)
+    // TODO use correct position
+    await EditorShowMessage.editorShowMessage(
+      /* editor */ editor,
+      /* rowIndex */ 0,
+      /* columnIndex */ 0,
+      /* message */ `${error}`,
+      /* isError */ true
+    )
+    return editor
+  }
+}

package/static/5a94137/packages/renderer-worker/src/parts/EditorCommand/EditorCommandType.js

@@ -0,0 +1,36 @@
+// import * as EditorCompletion from '../EditorCompletion/EditorCompletion.js'
+import * as Editor from '../Editor/Editor.js'
+import * as EditOrigin from '../EditOrigin/EditOrigin.js'
+import { editorReplaceSelections } from './EditorCommandReplaceSelection.js'
+
+export const state = {
+  listeners: [],
+}
+
+// TODO implement typing command without brace completion -> brace completion should be independent module
+export const type = async (editor, text) => {
+  // if (isBrace(text)) {
+  //   console.log('is brace')
+  //   return editorTypeWithBraceCompletion(editor, text)
+  // }
+  // if (isSlash(text)) {
+  //   return editorTypeWithSlashCompletion(editor, text)
+  // }
+  const changes = editorReplaceSelections(editor, [text], EditOrigin.EditorType)
+  // // TODO trigger characters should be monomorph -> then skip this check
+  // if (
+  //   editor.completionTriggerCharacters &&
+  //   editor.completionTriggerCharacters.includes(text)
+  // ) {
+  //   Command.execute(/* EditorCompletion.openFromType */ 988)
+  // }
+
+  // TODO should editor type command know about editor completion? -> no
+  // EditorCommandCompletion.openFromType(editor, text)
+  return Editor.scheduleDocumentAndCursorsSelections(editor, changes)
+}
+
+export const onDidType = (listener) => {
+  state.listeners.push(listener)
+  // TODO unregister
+}