@lvce-editor/server 0.12.0 → 0.13.0

package/static/7f432e2/packages/renderer-worker/src/parts/Editor/Editor.js

@@ -1,358 +0,0 @@
-import * as Assert from '../Assert/Assert.js'
-import * as GlobalEventBus from '../GlobalEventBus/GlobalEventBus.js'
-import * as RendererProcess from '../RendererProcess/RendererProcess.js'
-import * as ScrollBarFunctions from '../ScrollBarFunctions/ScrollBarFunctions.js'
-import * as TextDocument from '../TextDocument/TextDocument.js'
-import * as SplitLines from '../SplitLines/SplitLines.js'
-import * as Tokenizer from '../Tokenizer/Tokenizer.js'
-import * as EditorCursor from './EditorCursor.js'
-import * as EditorScrolling from './EditorScrolling.js'
-import * as EditorSelection from './EditorSelection.js'
-import * as EditorText from './EditorText.js'
-
-const MINIMUM_SLIDER_SIZE = 20
-
-// TODO
-export const create = (id, uri, languageId, content) => {
-  const tokenizer = Tokenizer.getTokenizer(languageId)
-
-  // TODO flatten structure
-  return {
-    uri,
-    languageId,
-    lines: SplitLines.splitLines(content),
-    // TODO cursor should be part of selection,
-    // codemirror has selections: Selection[]
-    //            selectionIndex: number
-
-    // TODO how to get the trigger characters here from extension host
-    completionTriggerCharacters: [],
-    primarySelectionIndex: 0,
-    selections: new Uint32Array([0, 0, 0, 0]),
-    id,
-    tokenizer,
-    deltaY: 0,
-    minLineY: 0,
-    maxLineY: 0,
-    numberOfVisibleLines: 0,
-    finalY: 0,
-    finalDeltaY: 0,
-    height: 0,
-    y: 0,
-    x: 0,
-    columnWidth: 0,
-    rowHeight: 0,
-    fontSize: 15, // TODO find out if it is possible to use all numeric values for settings for efficiency, maybe settings could be an array
-    letterSpacing: 0,
-    scrollBarHeight: 0,
-    undoStack: [],
-    // TODO maybe put these into separate tokenization module
-    lineCache: [],
-    validLines: [],
-    invalidStartIndex: 0,
-    decorations: [],
-    focused: false,
-    /**
-     * Offset at which scrollbar thumb has been clicked
-     */
-    handleOffset: 0,
-    itemHeight: 20,
-    fontFamily: '',
-    fontWeight: 400,
-    cursorWidth: 2,
-  }
-}
-
-export const dispose = (id) => {
-  // delete state.editors[id]
-}
-
-export const renderText = (editor) => {
-  Assert.object(editor)
-  const textInfos = EditorText.getVisible(editor)
-  RendererProcess.invoke(
-    /* Viewlet.send */ 'Viewlet.send',
-    /* id */ 'EditorText',
-    /* method */ 'renderText',
-    /* scrollBarY */ editor.scrollBarY,
-    /* scrollBarHeight */ editor.scrollBarHeight,
-    /* textInfos */ textInfos,
-    /* fontSize */ editor.fontSize, // TODO only send these properties once on first render
-    /* lineHeight */ editor.rowHeight,
-    /* letterSpacing */ editor.letterSpacing
-  )
-}
-
-export const renderTextAndCursorAndSelectionsCommands = (editor) => {
-  Assert.object(editor)
-  const textInfos = EditorText.getVisible(editor)
-  const { cursorInfos, selectionInfos } = EditorSelection.getVisible(editor)
-  const scrollBarHeight = editor.scrollBarHeight
-  const scrollBarY = (editor.deltaY / editor.finalDeltaY) * (editor.height - editor.scrollBarHeight)
-  return [
-    /* Viewlet.invoke */ 'Viewlet.send',
-    /* id */ 'EditorText',
-    /* method */ 'renderTextAndCursorsAndSelections',
-    /* scrollBarY */ scrollBarY,
-    /* scrollBarHeight */ scrollBarHeight,
-    /* textInfos */ textInfos,
-    /* cursorInfos */ cursorInfos,
-    /* selectionInfos */ selectionInfos,
-  ]
-}
-
-export const renderTextAndCursorAndSelections = (editor) => {
-  const commands = renderTextAndCursorAndSelectionsCommands(editor)
-  RendererProcess.send(commands)
-}
-
-export const setTokenizer = (editor, tokenizer) => {
-  editor.tokenizer = Tokenizer.getTokenizer(editor.languageId)
-  editor.invalidStartIndex = 0
-}
-
-// TODO
-export const setDeltaYFixedValue = (editor, value) => {
-  return EditorScrolling.setDeltaY(editor, value)
-  // renderTextAndCursorAndSelections(editor)
-}
-
-export const setDeltaY = (editor, value) => {
-  return setDeltaYFixedValue(editor, editor.deltaY + value)
-}
-
-export const scheduleSelections = (editor, selectionEdits) => {
-  return EditorSelection.setSelections(editor, selectionEdits)
-  // const cursorInfos = EditorCursor.getVisible(editor)
-  // const selectionInfos = EditorSelection.getVisible(editor)
-  // RendererProcess.send([
-  //   /* Viewlet.invoke */ 'Viewlet.send',
-  //   /* id */ 'EditorText',
-  //   /* method */ 'renderCursorsAndSelections',
-  //   /* cursorInfos */ cursorInfos,
-  //   /* selectionInfos */ selectionInfos,
-  // ])
-}
-
-export const scheduleSelectionsAndScrollPosition = (editor, selectionEdits, deltaY) => {
-  const newEditor1 = EditorSelection.setSelections(editor, selectionEdits)
-  const newEditor2 = EditorScrolling.setDeltaY(newEditor1, deltaY)
-  return newEditor2
-  // EditorScrolling.setDeltaY(editor, deltaY)
-  // EditorSelection.setSelections(editor, selectionEdits)
-  // const cursorInfos = EditorCursor.getVisible(editor)
-  // const selectionInfos = EditorSelection.getVisible(editor)
-  // const textInfos = EditorText.getVisible(editor)
-  // // TODO scrollbar calculation duplicate code
-  // const scrollBarY =
-  //   (editor.deltaY / editor.finalDeltaY) *
-  //   (editor.height - editor.scrollBarHeight)
-  // const scrollBarHeight = editor.scrollBarHeight
-  // RendererProcess.send([
-  //   /* Viewlet.invoke */ 'Viewlet.send',
-  //   /* id */ 'EditorText',
-  //   /* method */ 'renderTextAndCursorsAndSelections',
-  //   /* deltaY */ scrollBarY,
-  //   /* scrollBarHeight */ scrollBarHeight,
-  //   /* textInfos */ textInfos,
-  //   /* cursorInfos */ cursorInfos,
-  //   /* selectionInfos */ selectionInfos,
-  // ])
-}
-
-/**
- *
- * @param {any} editor
- * @param {any[]} changes
- * @param {Uint32Array|undefined} selectionChanges
- * @returns
- */
-export const scheduleDocumentAndCursorsSelections = (editor, changes, selectionChanges = undefined) => {
-  Assert.object(editor)
-  Assert.array(changes)
-  if (changes.length === 0) {
-    return editor
-  }
-  const newLines = TextDocument.applyEdits(editor, changes)
-  const partialNewEditor = {
-    ...editor,
-    lines: newLines,
-  }
-  const newSelections = selectionChanges || EditorSelection.applyEdit(partialNewEditor, changes)
-  // 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
-  const invalidStartIndex = Math.min(editor.invalidStartIndex, changes[0].start.rowIndex)
-
-  // TODO maybe put undostack into indexeddb so that there is no memory leak in application
-  // then clear old undostack from indexeddb after 3 days
-  // TODO should push to undostack after rendering
-
-  const newEditor = {
-    ...partialNewEditor,
-    lines: newLines,
-    selections: newSelections,
-    undoStack: [...editor.undoStack, changes],
-    invalidStartIndex,
-  }
-  GlobalEventBus.emitEvent('editor.change', newEditor, changes)
-
-  return newEditor
-}
-
-export const scheduleDocumentAndCursorsSelectionIsUndo = (editor, changes) => {
-  Assert.object(editor)
-  Assert.array(changes)
-  if (changes.length === 0) {
-    return editor
-  }
-  const newLines = TextDocument.applyEdits(editor, changes)
-  const partialNewEditor = {
-    ...editor,
-    lines: newLines,
-  }
-  const newSelections = EditorSelection.applyEdit(partialNewEditor, changes)
-  const invalidStartIndex = Math.min(editor.invalidStartIndex, changes[0].start.rowIndex)
-  const newEditor = {
-    ...partialNewEditor,
-    lines: newLines,
-    selections: newSelections,
-    // undoStack: [...editor.undoStack.slice(0, -2)],
-    invalidStartIndex,
-  }
-  GlobalEventBus.emitEvent('editor.change', newEditor, changes)
-  return newEditor
-}
-
-export const scheduleDocument = async (editor, changes) => {
-  // console.log('before')
-  // console.log([...editor.lines])
-  const newLines = TextDocument.applyEdits(editor, changes)
-  // console.log('after')
-  // console.log([...editor.lines])
-  const invalidStartIndex = changes[0].start.rowIndex
-  // if (editor.undoStack) {
-  //   editor.undoStack.push(changes)
-  // }
-  // const cursorInfos = EditorCursor.getVisible(editor)
-  // const selectionInfos = EditorSelection.getVisible(editor)
-  // const textInfos = EditorText.getVisible(editor)
-  // TODO scrollbar calculation duplicate code
-  // const scrollBarY =
-  //   (editor.deltaY / editor.finalDeltaY) *
-  //   (editor.height - editor.scrollBarHeight)
-  // const scrollBarHeight = editor.scrollBarHeight
-
-  const newEditor = {
-    ...editor,
-    undoStack: [...editor.undoStack, changes],
-    lines: newLines,
-    invalidStartIndex,
-  }
-  // TODO change event should be emitted after rendering
-  GlobalEventBus.emitEvent('editor.change', editor, changes)
-  return newEditor
-  // RendererProcess.send([
-  //   /* Viewlet.invoke */ 'Viewlet.send',
-  //   /* id */ 'EditorText',
-  //   /* method */ 'renderTextAndCursorsAndSelections',
-  //   /* deltaY */ scrollBarY,
-  //   /* scrollBarHeight */ scrollBarHeight,
-  //   /* textInfos */ textInfos,
-  //   /* cursorInfos */ cursorInfos,
-  //   /* selectionInfos */ selectionInfos,
-  // ])
-}
-
-export const hasSelection = (editor) => {
-  // TODO editor.selections should always be defined
-  return editor.selections && editor.selections.length > 0
-}
-
-export const setBounds = (editor, x, y, height, columnWidth) => {
-  const { itemHeight } = editor
-  const numberOfVisibleLines = Math.floor(height / itemHeight)
-  const total = editor.lines.length
-  const maxLineY = Math.min(numberOfVisibleLines, total)
-  const finalY = Math.max(total - numberOfVisibleLines, 0)
-  const finalDeltaY = finalY * itemHeight
-  return {
-    ...editor,
-    x,
-    y,
-    height,
-    columnWidth,
-    numberOfVisibleLines,
-    maxLineY,
-    finalY,
-    finalDeltaY,
-  }
-}
-
-export const setText = (editor, text) => {
-  const lines = SplitLines.splitLines(text)
-  const { itemHeight, numberOfVisibleLines } = editor
-  const total = lines.length
-  const maxLineY = Math.min(numberOfVisibleLines, total)
-  const finalY = Math.max(total - numberOfVisibleLines, 0)
-  const finalDeltaY = finalY * itemHeight
-  const contentHeight = lines.length * editor.rowHeight
-  const scrollBarHeight = ScrollBarFunctions.getScrollBarHeight(editor.height, contentHeight, MINIMUM_SLIDER_SIZE)
-  return {
-    ...editor,
-    lines,
-    maxLineY,
-    finalY,
-    finalDeltaY,
-    scrollBarHeight,
-  }
-}
-
-const renderLines = {
-  isEqual(oldState, newState) {
-    return (
-      oldState.lines === newState.lines &&
-      oldState.tokenizer === newState.tokenizer &&
-      oldState.minLineY === newState.minLineY &&
-      oldState.decorations === newState.decorations
-    )
-  },
-  apply(oldState, newState) {
-    const textInfos = EditorText.getVisible(newState)
-    return [/* method */ 'setText', /* textInfos */ textInfos]
-  },
-}
-
-const renderSelections = {
-  isEqual(oldState, newState) {
-    return oldState.selections === newState.selections && oldState.focused === newState.focused && oldState.minLineY === newState.minLineY
-  },
-  apply(oldState, newState) {
-    const { cursorInfos, selectionInfos } = EditorSelection.getVisible(newState)
-    return [/* method */ 'setSelections', /* cursorInfos */ cursorInfos, /* selectionInfos */ selectionInfos]
-  },
-}
-
-const renderScrollBar = {
-  isEqual(oldState, newState) {
-    return oldState.deltaY === newState.deltaY && oldState.scrollBarHeight === newState.scrollBarHeight
-  },
-  apply(oldState, newState) {
-    const scrollBarY = ScrollBarFunctions.getScrollBarY(newState.deltaY, newState.finalDeltaY, newState.height, newState.scrollBarHeight)
-    return [/* method */ 'setScrollBar', /* scrollBarY */ scrollBarY, /* scrollBarHeight */ newState.scrollBarHeight]
-  },
-}
-
-const renderFocus = {
-  isEqual(oldState, newState) {
-    return oldState.focused === newState.focused
-  },
-  apply(oldState, newState) {
-    if (!newState.focused) {
-      return []
-    }
-    return [/* method */ 'focus']
-  },
-}
-
-export const render = [renderLines, renderSelections, renderScrollBar, renderFocus]

package/static/7f432e2/packages/renderer-worker/src/parts/Editor/EditorText.js

@@ -1,266 +0,0 @@
-import * as TextDocument from '../TextDocument/TextDocument.js'
-import * as SafeTokenizeLine from '../SafeTokenizeLine/SafeTokenizeLine.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
-// }
-
-const getTokensFromCache = (result) => {
-  return result.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
-const getTokensViewport = (editor, startLineIndex, endLineIndex) => {
-  const invalidStartIndex = editor.invalidStartIndex
-  const lineCache = editor.lineCache
-  const hasArrayReturn = editor.tokenizer.hasArrayReturn
-  const tokenizeStartIndex = invalidStartIndex
-  const tokenizeEndIndex =
-    invalidStartIndex < endLineIndex ? endLineIndex : tokenizeStartIndex
-  const tokenizeLine = editor.tokenizer.tokenizeLine
-  for (let i = tokenizeStartIndex; i < tokenizeEndIndex; i++) {
-    const lineState =
-      i === 0 ? editor.tokenizer.initialLineState : editor.lineCache[i]
-    const line = editor.lines[i]
-    const result = SafeTokenizeLine.safeTokenizeLine(
-      tokenizeLine,
-      line,
-      lineState,
-      hasArrayReturn
-    )
-
-    // TODO if lineCacheEnd matches the one before, skip tokenizing lines after
-    lineCache[i + 1] = result
-  }
-  editor.invalidStartIndex = Math.max(invalidStartIndex, tokenizeEndIndex)
-  return lineCache
-    .slice(startLineIndex + 1, endLineIndex + 1)
-    .map(getTokensFromCache)
-}
-
-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 getDecorationClassName = (type) => {
-  switch (type) {
-    case 2816:
-    case 2817:
-    case 2824:
-    case 2825:
-    case 2856:
-    case 2857:
-    case 3072:
-    case 3073:
-    case 3077:
-    case 3088:
-      return 'Function'
-    case 1792:
-    case 1793:
-      return 'Parameter'
-    case 512:
-    case 513:
-    case 769:
-    case 1024:
-    case 1536:
-    case 1537:
-    case 1544:
-    case 1545:
-      return 'Type'
-    case 2048:
-    case 2049:
-    case 2056:
-    case 2057:
-    case 2064:
-    case 2080:
-    case 2081:
-    case 2088:
-    case 2089:
-    case 2313:
-    case 2560:
-    case 2561:
-    case 2569:
-    case 2584:
-      return 'VariableName'
-    case 256:
-    case 257:
-    case 272:
-      return 'Class'
-    default:
-      return `Unknown-${type}`
-  }
-}
-
-const getLineInfo = (line, tokens, decorations, TokenMap, lineOffset) => {
-  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
-    }
-  }
-
-  // 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(decorationType)
-    }
-
-    end += tokenLength
-    const text = line.slice(start, end)
-    const className = `Token ${
-      extraClassName || TokenMap[tokenType] || 'Unknown'
-    }`
-    lineInfo.push(text, className)
-    start = end
-  }
-  return lineInfo
-}
-
-// TODO need lots of tests for this
-const getLineInfosViewport = (
-  editor,
-  tokens,
-  minLineY,
-  maxLineY,
-  minLineOffset
-) => {
-  const result = []
-  const { lines, tokenizer, decorations } = editor
-  const { TokenMap } = tokenizer
-  let offset = minLineOffset
-  for (let i = minLineY; i < maxLineY; i++) {
-    const line = lines[i]
-    result.push(
-      getLineInfo(line, tokens[i - minLineY], decorations, TokenMap, offset)
-    )
-    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 = getTokensViewport(editor, minLineY, maxLineY)
-  const minLineOffset = TextDocument.offsetAt(editor, minLineY, 0)
-  const textInfos = getLineInfosViewport(
-    editor,
-    tokens,
-    minLineY,
-    maxLineY,
-    minLineOffset
-  )
-  return textInfos
-}

package/static/7f432e2/packages/renderer-worker/src/parts/EditorCommand/EditorCommandCopy.js

@@ -1,31 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as TextDocument from '../TextDocument/TextDocument.js'
-import * as Editor from '../Editor/Editor.js'
-
-// TODO add test
-export const copy = async (editor) => {
-  if (!Editor.hasSelection(editor)) {
-    // TODO copy line where cursor is
-    return editor
-  }
-  const selectionStartRowIndex = editor.selections[0]
-  const selectionStartColumnIndex = editor.selections[1]
-  const selectionEndRowIndex = editor.selections[2]
-  const selectionEndColumnIndex = editor.selections[3]
-  const range = {
-    start: {
-      rowIndex: selectionStartRowIndex,
-      columnIndex: selectionStartColumnIndex,
-    },
-    end: {
-      rowIndex: selectionEndRowIndex,
-      columnIndex: selectionEndColumnIndex,
-    },
-  }
-  const text = TextDocument.getSelectionText(editor, range).join('\n')
-  await Command.execute(
-    /* ClipBoard.writeText */ 'ClipBoard.writeText',
-    /* text */ text
-  )
-  return editor
-}

package/static/7f432e2/packages/renderer-worker/src/parts/EditorCommand/EditorCommandCut.js

@@ -1,21 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as Editor from '../Editor/Editor.js'
-import * as EditOrigin from '../EditOrigin/EditOrigin.js'
-import { editorReplaceSelections } from './EditorCommandReplaceSelection.js'
-
-export const cut = async (editor) => {
-  const selection = editor.selections[0]
-  if (selection.start === selection.end) {
-    // TODO cut line where cursor is
-  } else {
-    // cut selection
-  }
-  const changes = editorReplaceSelections(editor, [''], EditOrigin.EditorCut)
-  const text = changes[0].deleted.join('\n')
-  // TODO remove selected text from document
-  await Command.execute(
-    /* ClipBoard.writeText */ 'ClipBoard.writeText',
-    /* text */ text
-  )
-  return Editor.scheduleDocumentAndCursorsSelections(editor, changes)
-}

package/static/7f432e2/packages/renderer-worker/src/parts/EditorCommand/EditorCommandHandleDoubleClick.js

@@ -1,7 +0,0 @@
-import * as EditorSelectWord from './EditorCommandSelectWord.js'
-import * as EditorPosition from './EditorCommandPosition.js'
-
-export const handleDoubleClick = (editor, x, y) => {
-  const position = EditorPosition.at(editor, x, y)
-  return EditorSelectWord.selectWord(editor, position.rowIndex, position.columnIndex)
-}