@lvce-editor/editor-worker 1.15.0 → 2.0.0

package/dist/editorWorkerMain.js

@@ -1816,7 +1816,8 @@ const createEditor = async ({
     letterSpacing,
     charWidth,
     uid: id,
-    id
+    id,
+    widgets: []
   };
   // TODO avoid creating intermediate editors here
   const newEditor1 = setBounds(editor, x, y, width, height, 9);
@@ -2240,9 +2241,6 @@ const braceCompletion = async (editor, text) => {
   }
 };
 
-// @ts-ignore
-
-// @ts-ignore
 const cancelSelection = editor => {
   const selections = editor.selections;
   if (selections.length === 4 && selections[0] === selections[2] && selections[1] === selections[3]) {
@@ -2253,12 +2251,22 @@ const cancelSelection = editor => {
   return scheduleSelections(editor, newSelections);
 };
 
-const closeCompletion = async editor => {
-  // TODO
-  const completionUid = editor.completionUid;
-  await invoke$3('Viewlet.dispose', completionUid);
-  editor.completionUid = 0;
-  return editor;
+const isCompletionWidget = widget => {
+  return widget.id === 'completion';
+};
+const closeCompletion = editor => {
+  const {
+    widgets
+  } = editor;
+  const completionWidgetIndex = widgets.findIndex(isCompletionWidget);
+  if (completionWidgetIndex === -1) {
+    return editor;
+  }
+  const newWidgets = [...widgets.slice(0, completionWidgetIndex), ...widgets.slice(completionWidgetIndex + 1)];
+  return {
+    ...editor,
+    widgets: newWidgets
+  };
 };
 
 // @ts-ignore
@@ -3274,7 +3282,8 @@ const UiStrings = {
   EditorCloseColorPicker: 'Editor: Close Color Picker',
   EditorCopyLineDown: 'Editor: Copy Line Down',
   EditorCopyLineUp: 'Editor: Copy Line Up',
-  Replace: 'replace'
+  Replace: 'replace',
+  NoResults: 'No Results'
 };
 const noDefinitionFound = () => {
   return i18nString(UiStrings.NoDefinitionFound);
@@ -3296,6 +3305,9 @@ const noTypeDefinitionFoundFor = word => {
 const noTypeDefinitionFound = () => {
   return i18nString(UiStrings.NoTypeDefinitionFound);
 };
+const noResults = () => {
+  return i18nString(UiStrings.NoResults);
+};
 
 // @ts-ignore
 const goTo = async ({
@@ -6264,7 +6276,7 @@ const resolveCompletion = async (editor, name, completionItem) => {
   }
 };
 
-const None = 1;
+const None$1 = 1;
 
 const EmptyMatches = [];
 
@@ -6535,7 +6547,7 @@ const handleEditorDeleteLeft = (editorUid, state) => {
   const y$1 = y(editor, rowIndex);
   const wordAtOffset = getWordAtOffset(editor);
   if (!wordAtOffset) {
-    editor.completionState = None;
+    editor.completionState = None$1;
     return {
       ...state,
       disposed: true
@@ -6561,7 +6573,7 @@ const dispose = state => {
   };
 };
 const disposeWithEditor = (state, editor) => {
-  editor.completionState = None;
+  editor.completionState = None$1;
   editor.completionUid = 0;
   // Focus.removeAdditionalFocus(FocusKey.EditorCompletion)
   return dispose(state);
@@ -6603,7 +6615,8 @@ const loadContent$2 = async (editorUid, state) => {
     height,
     rowIndex,
     columnIndex,
-    editorUid
+    editorUid,
+    width: 200
   };
 };
 const advance = (state, word) => {
@@ -6614,12 +6627,24 @@ const advance = (state, word) => {
   };
 };
 
-const getEdits = async (state, editor, completionItem) => {
+const isCompletion$1 = widget => {
+  return widget.id === 'completion';
+};
+const getCompletionState = editor => {
+  const {
+    widgets
+  } = editor;
+  const child = widgets.find(isCompletion$1);
+  return child.newState;
+};
+
+const getEdits = async (editor, completionItem) => {
+  const child = getCompletionState(editor);
   // @ts-ignore
   const {
     leadingWord,
     uid
-  } = state;
+  } = child;
   const word = completionItem.label;
   const resolvedItem = await resolveCompletion(editor, word, completionItem);
   const inserted = resolvedItem ? resolvedItem.snippet : word;
@@ -6633,41 +6658,55 @@ const getEdits = async (state, editor, completionItem) => {
   const changes = replaceRange(editor, replaceRange$1, [inserted], '');
   return changes;
 };
-const select = async (state, editor, completionItem) => {
-  const changes = await getEdits(state, editor, completionItem);
+const isCompletion = widget => {
+  return widget.id === 'completion';
+};
+const select = async (editor, completionItem) => {
+  const changes = await getEdits(editor, completionItem);
   const index = editor.widgets.indexOf
   // ViewletModuleId.EditorCompletion
   ();
   if (index !== -1) {
     editor.widgets.splice(index, 1);
-    editor.completionState = None;
+    editor.completionState = None$1;
     editor.completionUid = 0;
   }
-  await invoke$3('Editor.applyEdit', changes);
-  await invoke$3('Viewlet.dispose', state.uid);
-  return state;
+  // TODO dispose completion widget
+  // TODO apply edit in editor worker instead of asking renderer worker
+  // await RendererWorker.invoke('Viewlet.dispose', state.uid)
+  const {
+    widgets
+  } = editor;
+  const completionWidgetIndex = editor.widgets.findIndex(isCompletion);
+  const newWidgets = [...widgets.slice(0, completionWidgetIndex), ...widgets.slice(completionWidgetIndex + 1)];
+  const intermediateEditor = await applyEdit(editor, changes);
+  return {
+    ...intermediateEditor,
+    widgets: newWidgets
+  };
 };
-const selectIndex = (editorUid, state, index) => {
-  const editor = getEditor(editorUid);
+const selectIndex = (editor, index) => {
+  const child = getCompletionState(editor);
   const {
     items
-  } = state;
+  } = child;
   if (index === -1) {
-    return state;
+    return editor;
   }
   if (index > items.length) {
     throw new Error('index too large');
   }
   const actualIndex = index;
   const completionItem = items[actualIndex];
-  return select(state, editor, completionItem);
+  return select(editor, completionItem);
 };
 
-const selectCurrent = (editorUid, state) => {
+const selectCurrent = editor => {
+  const child = getCompletionState(editor);
   const {
     focusedIndex
-  } = state;
-  return selectIndex(editorUid, state, focusedIndex);
+  } = child;
+  return selectIndex(editor, focusedIndex);
 };
 
 // copied from https://github.com/microsoft/vscode/tree/main/src/vs/base/common/strings.ts by Microsoft (License MIT)
@@ -7170,7 +7209,7 @@ const moveLineUp = editor => {
 };
 
 const Link$1 = 'Link';
-const Function = 'Function';
+const Function$1 = 'Function';
 const Parameter = 'Parameter';
 const Type = 'Type';
 const VariableName = 'VariableName';
@@ -7229,7 +7268,7 @@ const getDecorationClassName = type => {
     case Ts3073:
     case Ts3077:
     case Ts3088:
-      return Function;
+      return Function$1;
     case Ts1792:
     case Ts1793:
       return Parameter;
@@ -7658,7 +7697,9 @@ const getVisible = async (editor, syncIncremental) => {
 const Div = 4;
 const Span = 8;
 const Text = 12;
+const Img = 17;
 
+const ColoredMaskIcon = 'ColoredMaskIcon';
 const ColorPicker = 'ColorPicker';
 const ColorPickerBackgroundColor = 'ColorPickerBackgroundColor';
 const ColorPickerDark = 'ColorPickerDark';
@@ -7667,15 +7708,21 @@ const ColorPickerRectangle = 'ColorPickerRectangle';
 const ColorPickerSlider = 'ColorPickerSlider';
 const ColorPickerSliderThumb = 'ColorPickerSliderThumb';
 const Diagnostic = 'Diagnostic';
+const EditorCompletionItem = 'EditorCompletionItem';
+const EditorCompletionItemDeprecated = 'EditorCompletionItemDeprecated';
+const EditorCompletionItemFocused = 'EditorCompletionItemFocused';
+const EditorCompletionItemHighlight = 'EditorCompletionItemHighlight';
 const EditorCursor = 'EditorCursor';
 const EditorRow = 'EditorRow';
 const EditorSelection = 'EditorSelection';
+const FileIcon = 'FileIcon';
 const HoverDisplayString = 'HoverDisplayString';
 const HoverDocumentation = 'HoverDocumentation';
 const HoverEditorRow = 'HoverEditorRow';
 const HoverProblem = 'HoverProblem';
 const HoverProblemDetail = 'HoverProblemDetail';
 const HoverProblemMessage = 'HoverProblemMessage';
+const Label = 'Label';
 const Viewlet = 'Viewlet';
 
 const getCursorsVirtualDom = cursors => {
@@ -7813,6 +7860,315 @@ const getSelectionsVirtualDom = selections => {
   return dom;
 };
 
+const None = 'none';
+const Option = 'option';
+
+const getFileIconVirtualDom = icon => {
+  return {
+    type: Img,
+    className: FileIcon,
+    src: icon,
+    role: None,
+    childCount: 0
+  };
+};
+
+const getIconDom = (fileIcon, symbolName) => {
+  if (fileIcon) {
+    return getFileIconVirtualDom(fileIcon);
+  }
+  return {
+    type: Div,
+    className: `${ColoredMaskIcon} ${symbolName}`,
+    childCount: 0
+  };
+};
+
+const label1 = {
+  type: Div,
+  className: Label,
+  childCount: 1
+};
+const completionHighlight = {
+  type: Span,
+  className: EditorCompletionItemHighlight,
+  childCount: 1
+};
+const getHighlightedLabelDom = (label, highlights) => {
+  if (highlights.length === 0) {
+    return [label1, text(label)];
+  }
+  const dom = [];
+  const labelDom = {
+    type: Div,
+    className: Label,
+    childCount: 0
+  };
+  dom.push(labelDom);
+  let position = 0;
+  for (let i = 0; i < highlights.length; i += 2) {
+    const highlightStart = highlights[i];
+    const highlightEnd = highlights[i + 1];
+    if (position < highlightStart) {
+      const beforeText = label.slice(position, highlightStart);
+      labelDom.childCount++;
+      dom.push(text(beforeText));
+    }
+    const highlightText = label.slice(highlightStart, highlightEnd);
+    labelDom.childCount++;
+    dom.push(completionHighlight, text(highlightText));
+    position = highlightEnd;
+  }
+  if (position < label.length) {
+    const afterText = label.slice(position);
+    labelDom.childCount++;
+    dom.push(text(afterText));
+  }
+  return dom;
+};
+
+const getCompletionItemVirtualDom = visibleItem => {
+  const {
+    top,
+    label,
+    symbolName,
+    highlights,
+    focused,
+    deprecated,
+    fileIcon
+  } = visibleItem;
+  let className = EditorCompletionItem;
+  if (focused) {
+    className += ' ' + EditorCompletionItemFocused;
+  }
+  if (deprecated) {
+    className += ' ' + EditorCompletionItemDeprecated;
+  }
+  return [{
+    type: Div,
+    role: Option,
+    className,
+    top,
+    childCount: 2
+  }, getIconDom(fileIcon, symbolName), ...getHighlightedLabelDom(label, highlights)];
+};
+
+const getCompletionItemsVirtualDom = visibleItems => {
+  if (visibleItems.length === 0) {
+    return [{
+      type: Div,
+      childCount: 1
+    }, text(noResults())];
+  }
+  const root = {
+    type: Div,
+    childCount: visibleItems.length
+  };
+  const dom = [root, ...visibleItems.flatMap(getCompletionItemVirtualDom)];
+  return dom;
+};
+
+const Property = 1;
+const Value = 2;
+const Function = 3;
+const Variable = 4;
+const Keyword = 5;
+const Folder = 6;
+const File = 7;
+const Field = 8;
+
+const SymbolProperty = 'SymbolProperty';
+const SymbolValue = 'SymbolValue';
+const SymbolFunction = 'SymbolFunction';
+const SymbolVariable = 'SymbolVariable';
+const SymbolKeyword = 'SymbolKeyword';
+const SymbolDefault = 'SymbolDefault';
+const SymbolField = 'SymbolField';
+const SymbolNone = '';
+
+const getSymbolName = item => {
+  switch (item.kind) {
+    case Property:
+      return SymbolProperty;
+    case Value:
+      return SymbolValue;
+    case Function:
+      return SymbolFunction;
+    case Variable:
+      return SymbolVariable;
+    case Keyword:
+      return SymbolKeyword;
+    case Field:
+      return SymbolField;
+    case File:
+      return SymbolNone;
+    default:
+      return SymbolDefault;
+  }
+};
+
+const getHighlights = (item, leadingWord) => {
+  const {
+    matches
+  } = item;
+  return matches.slice(1);
+};
+
+// import * as IconTheme from '../IconTheme/IconTheme.ts'
+
+const getLabel = item => {
+  return item.label;
+};
+const getFileIcon = item => {
+  switch (item.kind) {
+    case File:
+      // TODO IconTheme.getFileNameIcon(item.label)
+      return '';
+    case Folder:
+      // TODO IconTheme.getFolderNameIcon(item.label)
+      return '';
+    default:
+      return '';
+  }
+};
+const getVisibleIem = (item, itemHeight, leadingWord, i, focusedIndex) => {
+  return {
+    label: getLabel(item),
+    symbolName: getSymbolName(item),
+    top: i * itemHeight,
+    highlights: getHighlights(item),
+    focused: i === focusedIndex,
+    deprecated: item.flags & Deprecated,
+    fileIcon: getFileIcon(item)
+  };
+};
+
+const getVisibleItems = (filteredItems, itemHeight, leadingWord, minLineY, maxLineY, focusedIndex) => {
+  const visibleItems = [];
+  for (let i = minLineY; i < maxLineY; i++) {
+    const filteredItem = filteredItems[i];
+    visibleItems.push(getVisibleIem(filteredItem, itemHeight, leadingWord, i, focusedIndex));
+  }
+  return visibleItems;
+};
+
+const SetBounds = 'setBounds';
+const SetColor = 'setColor';
+const SetContentHeight = 'setContentHeight';
+const SetNegativeMargin = 'setNegativeMargin';
+const SetOffsetX = 'setOffsetX';
+const SetScrollBar = 'setScrollBar';
+
+const renderItems = {
+  isEqual(oldState, newState) {
+    return oldState.items === newState.items && oldState.minLineY === newState.minLineY && oldState.maxLineY === newState.maxLineY && oldState.focusedIndex === newState.focusedIndex;
+  },
+  apply(oldState, newState) {
+    const visibleItems = getVisibleItems(newState.items, newState.itemHeight, newState.leadingWord, newState.minLineY, newState.maxLineY, newState.focusedIndex);
+    const dom = getCompletionItemsVirtualDom(visibleItems);
+    return ['setDom', dom];
+  }
+};
+const renderBounds$1 = {
+  isEqual(oldState, newState) {
+    return oldState.items === newState.items && oldState.minLineY === newState.minLineY && oldState.maxLineY === newState.maxLineY && oldState.x === newState.x && oldState.y === newState.y;
+  },
+  apply(oldState, newState) {
+    const {
+      x,
+      y,
+      width,
+      height
+    } = newState;
+    return [/* method */SetBounds, /* x */x, /* y */y, /* width */width, /* height */height];
+  }
+};
+const renderHeight = {
+  isEqual(oldState, newState) {
+    return oldState.items.length === newState.items.length;
+  },
+  apply(oldState, newState) {
+    const {
+      itemHeight
+    } = newState;
+    const contentHeight = newState.items.length * itemHeight;
+    return [/* method */SetContentHeight, /* contentHeight */contentHeight];
+  }
+};
+const renderNegativeMargin = {
+  isEqual(oldState, newState) {
+    return oldState.deltaY === newState.deltaY;
+  },
+  apply(oldState, newState) {
+    return [/* method */SetNegativeMargin, /* negativeMargin */-newState.deltaY];
+  }
+};
+const renderScrollBar = {
+  isEqual(oldState, newState) {
+    return oldState.negativeMargin === newState.negativeMargin && oldState.deltaY === newState.deltaY && oldState.height === newState.height && oldState.finalDeltaY === newState.finalDeltaY && oldState.items.length === newState.items.length;
+  },
+  apply(oldState, newState) {
+    const total = newState.items.length;
+    const contentHeight = total * newState.itemHeight;
+    const scrollBarHeight = getScrollBarSize(newState.height, contentHeight, newState.minimumSliderSize);
+    const scrollBarY = getScrollBarY(newState.deltaY, newState.finalDeltaY, newState.height - newState.headerHeight, scrollBarHeight);
+    return [/* method */SetScrollBar, /* scrollBarY */scrollBarY, /* scrollBarHeight */scrollBarHeight];
+  }
+};
+const render$3 = [renderItems, renderBounds$1, renderHeight, renderNegativeMargin, renderScrollBar];
+const renderCompletion$1 = (oldState, newState) => {
+  const commands = [];
+  for (const item of render$3) {
+    if (!item.isEqual(oldState, newState)) {
+      commands.push(item.apply(oldState, newState));
+    }
+  }
+  return commands;
+};
+
+const renderCompletion = (oldState, newState) => {
+  const commands = renderCompletion$1(oldState, newState);
+  return commands;
+};
+const addWidgetCompletion = widget => {
+  const commands = renderCompletion(widget.oldState, widget.newState);
+  const id = 'EditorCompletion';
+  // TODO how to generate a unique integer id
+  // that doesn't collide with ids created in renderer worker?
+  const uid = widget.newState.uid;
+  const allCommands = [];
+  allCommands.push(['Viewlet.create', id, uid]);
+  for (const command of commands) {
+    allCommands.push(['Viewlet.send', uid, ...command]);
+  }
+  return allCommands;
+};
+const addWidget = widget => {
+  const {
+    id
+  } = widget;
+  switch (id) {
+    case 'completion':
+      return addWidgetCompletion(widget);
+    default:
+      throw new Error('unsupported widget');
+  }
+};
+const removeCompletion = widget => {
+  return [['Viewlet.send', widget.newState.uid, 'dispose']];
+};
+const removeWidget = widget => {
+  const {
+    id
+  } = widget;
+  switch (id) {
+    case 'completion':
+      return removeCompletion(widget);
+    default:
+      throw new Error('unsupported widget');
+  }
+};
+
 const renderLines = {
   isEqual(oldState, newState) {
     return oldState.lines === newState.lines && oldState.tokenizerId === newState.tokenizerId && oldState.minLineY === newState.minLineY && oldState.decorations === newState.decorations && oldState.embeds === newState.embeds && oldState.deltaX === newState.deltaX && oldState.width === newState.width;
@@ -7909,7 +8265,53 @@ const renderGutterInfo = {
     return ['renderGutter', dom];
   }
 };
-const render$2 = [renderLines, renderSelections, renderScrollBarX, renderScrollBarY, renderFocus, renderDecorations, renderGutterInfo];
+const renderWidgets = {
+  isEqual(oldState, newState) {
+    return oldState.widgets === newState.widgets;
+  },
+  apply(oldState, newState) {
+    const addedWidgets = [];
+    const removedWidgets = [];
+    const oldWidgets = oldState.widgets || [];
+    const newWidgets = newState.widgets || [];
+    const oldWidgetMap = Object.create(null);
+    const newWidgetMap = Object.create(null);
+    for (const oldWidget of oldWidgets) {
+      oldWidgetMap[oldWidget.id] = oldWidget;
+    }
+    for (const newWidget of newWidgets) {
+      newWidgetMap[newWidget.id] = newWidget;
+    }
+    for (const oldWidget of oldWidgets) {
+      if (oldWidget.id in newWidgetMap) ; else {
+        removedWidgets.push(oldWidget);
+      }
+    }
+    for (const newWidget of newWidgets) {
+      if (newWidget.id in oldWidgetMap) ; else {
+        addedWidgets.push(newWidget);
+      }
+    }
+    const addCommands = [];
+    for (const addedWidget of addedWidgets) {
+      const childCommands = addWidget(addedWidget);
+      if (childCommands.length > 0) {
+        addCommands.push(...childCommands);
+      }
+    }
+    const removeCommands = [];
+    for (const removedWidget of removedWidgets) {
+      const childCommands = removeWidget(removedWidget);
+      if (childCommands.length > 0) {
+        removeCommands.push(...childCommands);
+      }
+    }
+    const allCommands = [...addCommands, ...removeCommands];
+    return allCommands;
+  },
+  multiple: true
+};
+const render$2 = [renderLines, renderSelections, renderScrollBarX, renderScrollBarY, renderFocus, renderDecorations, renderGutterInfo, renderWidgets];
 const renderEditor = async id => {
   const instance = get$6(id);
   if (!instance) {
@@ -7923,13 +8325,77 @@ const renderEditor = async id => {
   set$6(id, newState, newState);
   for (const item of render$2) {
     if (!item.isEqual(oldState, newState)) {
-      commands.push(await item.apply(oldState, newState));
+      const result = await item.apply(oldState, newState);
+      // @ts-ignore
+      if (item.multiple) {
+        commands.push(...result);
+      } else if (result.length > 0) {
+        commands.push(result);
+      }
     }
   }
   return commands;
 };
 
-const keep = ['ColorPicker.handleSliderPointerDown', 'ColorPicker.handleSliderPointerMove', 'ColorPicker.loadContent', 'Editor.create', 'Editor.getWordAt', 'Editor.getWordBefore', 'Editor.offsetAt', 'Editor.render', 'ColorPicker.render', 'Editor.getText', 'Editor.getSelections', 'EditorCompletion.advance', 'EditorCompletion.handleEditorBlur', 'EditorCompletion.handleEditorClick', 'EditorCompletion.handleEditorDeleteLeft', 'EditorCompletion.handleEditorType', 'EditorCompletion.loadContent', 'EditorCompletion.selectCurrent', 'EditorCompletion.selectIndex', 'FindWidget.focusFirst', 'FindWidget.focusIndex', 'FindWidget.focusLast', 'FindWidget.focusNext', 'FindWidget.focusPrevious', 'FindWidget.handleInput', 'FindWidget.loadContent', 'Font.ensure', 'Hover.getHoverInfo', 'Hover.handleSashPointerDown', 'Hover.handleSashPointerMove', 'Hover.handleSashPointerUp', 'Hover.loadContent', 'Hover.render', 'Initialize.initialize'];
+const openCompletion = async editor => {
+  const {
+    widgets,
+    uid
+  } = editor;
+  const completionUid = Math.random();
+  const completionWidget = {
+    id: 'completion',
+    oldState: {
+      items: [],
+      itemHeight: 20,
+      maxHeight: 150,
+      minLineY: 0,
+      maxLineY: 0,
+      uid: completionUid
+    },
+    newState: {
+      items: [],
+      itemHeight: 20,
+      maxHeight: 150,
+      minLineY: 0,
+      maxLineY: 10,
+      uid: completionUid
+    }
+  };
+  const newWidgets = [...widgets, completionWidget];
+  const newEditor = {
+    ...editor,
+    widgets: newWidgets
+  };
+  set$6(uid, editor, newEditor);
+  const newCompletionWidget = await loadContent$2(uid, completionWidget.newState);
+  const FocusEditorCompletions = 9;
+  await invoke$3('Focus.setAdditionalFocus', FocusEditorCompletions);
+  const latestEditor = getEditor(uid);
+  if (!latestEditor.widgets.includes(completionWidget)) {
+    return editor;
+  }
+  const index = latestEditor.widgets.indexOf(completionWidget);
+  const latestWidgets = [...latestEditor.widgets.slice(0, index), {
+    ...completionWidget,
+    newState: newCompletionWidget
+  }, ...latestEditor.widgets.slice(index + 1)];
+  return {
+    ...latestEditor,
+    widgets: latestWidgets
+  };
+};
+
+const keep = ['ColorPicker.handleSliderPointerDown', 'ColorPicker.handleSliderPointerMove', 'ColorPicker.loadContent', 'Editor.create', 'Editor.getWordAt', 'Editor.getWordBefore', 'Editor.offsetAt', 'Editor.render', 'ColorPicker.render', 'Editor.getText', 'Editor.getSelections',
+// 'EditorCompletion.advance',
+// 'EditorCompletion.handleEditorBlur',
+// 'EditorCompletion.handleEditorClick',
+// 'EditorCompletion.handleEditorDeleteLeft',
+// 'EditorCompletion.handleEditorType',
+// 'EditorCompletion.loadContent',
+// 'EditorCompletion.selectCurrent',
+// 'EditorCompletion.selectIndex',
+'FindWidget.focusFirst', 'FindWidget.focusIndex', 'FindWidget.focusLast', 'FindWidget.focusNext', 'FindWidget.focusPrevious', 'FindWidget.handleInput', 'FindWidget.loadContent', 'Font.ensure', 'Hover.getHoverInfo', 'Hover.handleSashPointerDown', 'Hover.handleSashPointerMove', 'Hover.handleSashPointerUp', 'Hover.loadContent', 'Hover.render', 'Initialize.initialize'];
 
 // TODO wrap commands globally, not per editor
 // TODO only store editor state in editor worker, not in renderer worker also
@@ -7991,10 +8457,6 @@ const getColorPickerVirtualDom = () => {
   }];
 };
 
-const SetBounds = 'setBounds';
-const SetColor = 'setColor';
-const SetOffsetX = 'setOffsetX';
-
 const renderColor = {
   isEqual(oldState, newState) {
     return oldState.color === newState.color;
@@ -8234,8 +8696,8 @@ const commandMap = {
   'Editor.deleteWordRight': deleteWordRight,
   'Editor.findAllReferences': findAllReferences,
   'Editor.format': format,
-  'Editor.getWordAt': getWordAt,
   'Editor.getText': getText,
+  'Editor.getWordAt': getWordAt,
   'Editor.getWordBefore': getWordBefore,
   'Editor.goToDefinition': goToDefinition,
   'Editor.goToTypeDefinition': goToTypeDefinition,
@@ -8273,6 +8735,7 @@ const commandMap = {
   'Editor.moveSelection': editorMoveSelection,
   'Editor.moveSelectionPx': moveSelectionPx,
   'Editor.offsetAt': offsetAt,
+  'Editor.openCompletion': openCompletion,
   'Editor.openFind': openFind,
   'Editor.organizeImports': organizeImports,
   'Editor.paste': paste,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/editor-worker",
-  "version": "1.15.0",
+  "version": "2.0.0",
   "description": "",
   "main": "dist/testWorkerMain.js",
   "type": "module",