@lvce-editor/editor-worker 1.5.1 → 1.7.0

package/dist/editorWorkerMain.js

@@ -71,7 +71,7 @@ const getNewColor = (x, max) => {
   const newColor = `hsl(${hue}, 100%, 50%)`;
   return newColor;
 };
-const loadContent$1 = state => {
+const loadContent$2 = state => {
   const max = 300;
   const x = 20;
   const color = getNewColor(x, max);
@@ -464,9 +464,13 @@ const measureTextWidth = (text, fontWeight, fontSize, fontFamily, letterSpacing,
   return width;
 };
 
+const Dash = '-';
+const Dot = '.';
 const EmptyString = '';
 const Space = ' ';
 const Tab = '\t';
+const Underline = '_';
+const T = 't';
 
 const normalizeText = (text, normalize, tabSize) => {
   if (normalize) {
@@ -1695,6 +1699,8 @@ const {
   invoke: invoke$2
 } = createRpc(ExtensionHostWorker);
 
+const CompletionExecute = 'ExtensionHostCompletion.execute';
+const CompletionResolveExecute = 'ExtensionHostCompletion.executeResolve';
 const HoverExecute = 'ExtensionHostHover.execute';
 const TextDocumentSyncFull = 'ExtensionHostTextDocument.syncFull';
 
@@ -6180,6 +6186,493 @@ const editorUnindent = editor => {
 
 // editor.lines //?
 
+const OnCompletion = 'onCompletion';
+const OnHover = 'onHover';
+
+// TODO add tests for this
+const activateByEvent = async event => {
+  await invoke$3('ExtensionHostManagement.activateByEvent', event);
+};
+
+const execute = async ({
+  editor,
+  args,
+  event,
+  method,
+  noProviderFoundMessage,
+  noProviderFoundResult = undefined
+}) => {
+  const fullEvent = `${event}:${editor.languageId}`;
+  await activateByEvent(fullEvent);
+  const result = await invoke$2(method, editor.uid, ...args);
+  return result;
+};
+
+const combineResults = results => {
+  return results[0] ?? [];
+};
+const executeCompletionProvider = (editor, offset) => {
+  return execute({
+    editor,
+    event: OnCompletion,
+    method: CompletionExecute,
+    args: [offset],
+    noProviderFoundMessage: 'no completion provider found',
+    noProviderFoundResult: [],
+    combineResults
+  });
+};
+const combineResultsResolve = items => {
+  return items[0] ?? undefined;
+};
+const executeResolveCompletionItem = (editor, offset, name, completionItem) => {
+  return execute({
+    editor,
+    event: OnCompletion,
+    method: CompletionResolveExecute,
+    args: [offset, name, completionItem],
+    noProviderFoundMessage: 'no completion provider found',
+    noProviderFoundResult: [],
+    combineResults: combineResultsResolve
+  });
+};
+
+// TODO possible to do this with events/state machine instead of promises -> enables canceling operations / concurrent calls
+const getCompletions = async editor => {
+  const {
+    selections
+  } = editor;
+  const rowIndex = selections[0];
+  const columnIndex = selections[1];
+  // Editor.sync(editor)
+  const offset = await offsetAt(editor, rowIndex, columnIndex);
+  const completions = await executeCompletionProvider(editor, offset);
+  return completions;
+};
+
+// TODO don't send unnecessary parts of completion item like matches
+const resolveCompletion = async (editor, name, completionItem) => {
+  try {
+    object(editor);
+    string(name);
+    object(completionItem);
+    const rowIndex = editor.selections[0];
+    const columnIndex = editor.selections[1];
+    const offset = await offsetAt(editor, rowIndex, columnIndex);
+    // @ts-ignore
+    const resolvedCompletionItem = await executeResolveCompletionItem(editor, offset, name, completionItem);
+    return resolvedCompletionItem;
+  } catch {
+    return undefined;
+  }
+};
+
+const None = 1;
+
+const EmptyMatches = [];
+
+const Diagonal = 1;
+const Left = 2;
+
+// based on https://github.com/microsoft/vscode/blob/3059063b805ed0ac10a6d9539e213386bfcfb852/src/vs/base/common/filters.ts by Microsoft (License MIT)
+
+const createTable = size => {
+  const table = [];
+  for (let i = 0; i < size; i++) {
+    const row = new Uint8Array(size);
+    table.push(row);
+  }
+  return table;
+};
+
+const isLowerCase = char => {
+  return char === char.toLowerCase();
+};
+
+const isUpperCase = char => {
+  return char === char.toUpperCase();
+};
+
+// based on https://github.com/microsoft/vscode/blob/3059063b805ed0ac10a6d9539e213386bfcfb852/src/vs/base/common/filters.ts by Microsoft (License MIT)
+const isGap = (columnCharBefore, columnChar) => {
+  switch (columnCharBefore) {
+    case Dash:
+    case Underline:
+    case EmptyString:
+    case T:
+    case Space:
+    case Dot:
+      return true;
+  }
+  if (isLowerCase(columnCharBefore) && isUpperCase(columnChar)) {
+    return true;
+  }
+  return false;
+};
+
+// based on https://github.com/microsoft/vscode/blob/3059063b805ed0ac10a6d9539e213386bfcfb852/src/vs/base/common/filters.ts by Microsoft (License MIT)
+const getScore = (rowCharLow, rowChar, columnCharBefore, columnCharLow, columnChar, column, wordLength, isDiagonalMatch) => {
+  if (rowCharLow !== columnCharLow) {
+    return -1;
+  }
+  const isMatch = rowChar === columnChar;
+  if (isMatch) {
+    if (isDiagonalMatch) {
+      return 8;
+    }
+    if (isGap(columnCharBefore, columnChar)) {
+      return 8;
+    }
+    return 5;
+  }
+  if (isGap(columnCharBefore, columnChar)) {
+    return 8;
+  }
+  return 5;
+};
+
+// based on https://github.com/microsoft/vscode/blob/3059063b805ed0ac10a6d9539e213386bfcfb852/src/vs/base/common/filters.ts by Microsoft (License MIT)
+
+const isPatternInWord = (patternLow, patternPos, patternLen, wordLow, wordPos, wordLen) => {
+  while (patternPos < patternLen && wordPos < wordLen) {
+    if (patternLow[patternPos] === wordLow[wordPos]) {
+      patternPos += 1;
+    }
+    wordPos += 1;
+  }
+  return patternPos === patternLen; // pattern must be exhausted
+};
+
+// based on https://github.com/microsoft/vscode/blob/3059063b805ed0ac10a6d9539e213386bfcfb852/src/vs/base/common/filters.ts by Microsoft (License MIT)
+const traceHighlights = (table, arrows, patternLength, wordLength) => {
+  let row = patternLength;
+  let column = wordLength;
+  const matches = [];
+  while (row >= 1 && column >= 1) {
+    const arrow = arrows[row][column];
+    if (arrow === Left) {
+      column--;
+    } else if (arrow === Diagonal) {
+      row--;
+      column--;
+      const start = column + 1;
+      while (row >= 1 && column >= 1) {
+        const arrow = arrows[row][column];
+        if (arrow === Left) {
+          break;
+        }
+        if (arrow === Diagonal) {
+          row--;
+          column--;
+        }
+      }
+      const end = column;
+      matches.unshift(end, start);
+    }
+  }
+  matches.unshift(table[patternLength][wordLength - 1]);
+  return matches;
+};
+
+// based on https://github.com/microsoft/vscode/blob/3059063b805ed0ac10a6d9539e213386bfcfb852/src/vs/base/common/filters.ts by Microsoft (License MIT)
+const gridSize = 128;
+const table = createTable(gridSize);
+const arrows = createTable(gridSize);
+// @ts-ignore
+createTable(gridSize);
+const filterCompletionItem = (pattern, word) => {
+  const patternLength = Math.min(pattern.length, gridSize - 1);
+  const wordLength = Math.min(word.length, gridSize - 1);
+  const patternLower = pattern.toLowerCase();
+  const wordLower = word.toLowerCase();
+  if (!isPatternInWord(patternLower, 0, patternLength, wordLower, 0, wordLength)) {
+    return EmptyMatches;
+  }
+  let strongMatch = false;
+  for (let row = 1; row < patternLength + 1; row++) {
+    const rowChar = pattern[row - 1];
+    const rowCharLow = patternLower[row - 1];
+    for (let column = 1; column < wordLength + 1; column++) {
+      const columnChar = word[column - 1];
+      const columnCharLow = wordLower[column - 1];
+      const columnCharBefore = word[column - 2] || '';
+      const isDiagonalMatch = arrows[row - 1][column - 1] === Diagonal;
+      const score = getScore(rowCharLow, rowChar, columnCharBefore, columnCharLow, columnChar, column, wordLength, isDiagonalMatch);
+      if (row === 1 && score > 5) {
+        strongMatch = true;
+      }
+      let diagonalScore = score + table[row - 1][column - 1];
+      if (isDiagonalMatch && score !== -1) {
+        diagonalScore += 2;
+      }
+      const leftScore = table[row][column - 1];
+      if (leftScore > diagonalScore) {
+        table[row][column] = leftScore;
+        arrows[row][column] = Left;
+      } else {
+        table[row][column] = diagonalScore;
+        arrows[row][column] = Diagonal;
+      }
+    }
+  }
+  if (!strongMatch) {
+    return EmptyMatches;
+  }
+  // printTables(pattern, 0, word, 0)
+  const highlights = traceHighlights(table, arrows, patternLength, wordLength);
+  return highlights;
+};
+
+const Deprecated = 1 << 0;
+
+const addEmptyMatch = item => {
+  return {
+    ...item,
+    matches: EmptyMatches
+  };
+};
+const filterCompletionItems = (completionItems, word) => {
+  if (word === EmptyString) {
+    return completionItems.map(addEmptyMatch);
+  }
+  const filteredCompletions = [];
+  const deprecated = [];
+  for (const completionItem of completionItems) {
+    const {
+      label,
+      flags
+    } = completionItem;
+    const result = filterCompletionItem(word, label);
+    if (result !== EmptyMatches) {
+      if (flags & Deprecated) {
+        // TODO avoid mutation
+        completionItem.matches = EmptyMatches;
+        deprecated.push(completionItem);
+      } else {
+        // TODO avoid mutation
+        completionItem.matches = result;
+        filteredCompletions.push(completionItem);
+      }
+    }
+  }
+  if (deprecated.length > 0) {
+    filteredCompletions.push(...deprecated);
+  }
+  return filteredCompletions;
+};
+
+const getFinalDeltaY = (height, itemHeight, itemsLength) => {
+  const contentHeight = itemsLength * itemHeight;
+  const finalDeltaY = Math.max(contentHeight - height, 0);
+  return finalDeltaY;
+};
+
+const getListHeight = (itemsLength, itemHeight, maxHeight) => {
+  number$1(itemsLength);
+  number$1(itemHeight);
+  number$1(maxHeight);
+  if (itemsLength === 0) {
+    return itemHeight;
+  }
+  const totalHeight = itemsLength * itemHeight;
+  return Math.min(totalHeight, maxHeight);
+};
+
+const RE_WORD = /[\w\-]+$/;
+const getWordAtOffset = editor => {
+  const {
+    lines,
+    selections
+  } = editor;
+  const rowIndex = selections[0];
+  const columnIndex = selections[1];
+  const line = lines[rowIndex];
+  const part = line.slice(0, columnIndex);
+  const wordMatch = part.match(RE_WORD);
+  if (wordMatch) {
+    return wordMatch[0];
+  }
+  return '';
+};
+const handleEditorType = (editorUid, state, text) => {
+  const editor = getEditor(editorUid);
+  const {
+    unfilteredItems,
+    itemHeight,
+    maxHeight
+  } = state;
+  const rowIndex = editor.selections[0];
+  const columnIndex = editor.selections[1];
+  const x$1 = x(editor, rowIndex, columnIndex);
+  // @ts-ignore
+  const y$1 = y(editor, rowIndex);
+  const wordAtOffset = getWordAtOffset(editor);
+  const items = filterCompletionItems(unfilteredItems, wordAtOffset);
+  const newMinLineY = 0;
+  const newMaxLineY = Math.min(items.length, 8);
+  const height = getListHeight(items.length, itemHeight, maxHeight);
+  const finalDeltaY = items.length * itemHeight - height;
+  return {
+    ...state,
+    items,
+    x: x$1,
+    y: y$1,
+    minLineY: newMinLineY,
+    maxLineY: newMaxLineY,
+    leadingWord: wordAtOffset,
+    height,
+    finalDeltaY
+  };
+};
+const handleEditorDeleteLeft = (editorUid, state) => {
+  const editor = getEditor(editorUid);
+  const {
+    unfilteredItems,
+    itemHeight,
+    maxHeight
+  } = state;
+  const rowIndex = editor.selections[0];
+  const columnIndex = editor.selections[1];
+  const x$1 = x(editor, rowIndex, columnIndex);
+  // @ts-ignore
+  const y$1 = y(editor, rowIndex);
+  const wordAtOffset = getWordAtOffset(editor);
+  if (!wordAtOffset) {
+    editor.completionState = None;
+    return {
+      ...state,
+      disposed: true
+    };
+  }
+  const items = filterCompletionItems(unfilteredItems, wordAtOffset);
+  const newMaxLineY = Math.min(items.length, 8);
+  const height = getListHeight(items.length, itemHeight, maxHeight);
+  return {
+    ...state,
+    items,
+    x: x$1,
+    y: y$1,
+    maxLineY: newMaxLineY,
+    leadingWord: wordAtOffset,
+    height
+  };
+};
+const dispose = state => {
+  return {
+    ...state,
+    disposed: true
+  };
+};
+const disposeWithEditor = (state, editor) => {
+  editor.completionState = None;
+  editor.completionUid = 0;
+  // Focus.removeAdditionalFocus(FocusKey.EditorCompletion)
+  return dispose(state);
+};
+const handleEditorClick = disposeWithEditor;
+const handleEditorBlur = disposeWithEditor;
+const loadContent$1 = async (editorUid, state) => {
+  const editor = getEditor(editorUid);
+  const {
+    itemHeight,
+    maxHeight
+  } = state;
+  const unfilteredItems = await getCompletions(editor);
+  const wordAtOffset = getWordAtOffset(editor);
+  const items = filterCompletionItems(unfilteredItems, wordAtOffset);
+  const rowIndex = editor.selections[0];
+  const columnIndex = editor.selections[1];
+  const x$1 = x(editor, rowIndex, columnIndex);
+  // @ts-ignore
+  const y$1 = y(editor, rowIndex);
+  const newMaxLineY = Math.min(items.length, 8);
+  editor.widgets = editor.widgets || [];
+  // editor.widgets.push(ViewletModuleId.EditorCompletion)
+  const itemsLength = items.length;
+  const newFocusedIndex = itemsLength === 0 ? -1 : 0;
+  const total = items.length;
+  const height = getListHeight(items.length, itemHeight, maxHeight);
+  const finalDeltaY = getFinalDeltaY(height, itemHeight, total);
+  return {
+    ...state,
+    unfilteredItems,
+    items,
+    x: x$1,
+    y: y$1,
+    maxLineY: newMaxLineY,
+    focusedIndex: newFocusedIndex,
+    finalDeltaY,
+    leadingWord: wordAtOffset,
+    height,
+    rowIndex,
+    columnIndex,
+    editorUid
+  };
+};
+const advance = (state, word) => {
+  const filteredItems = filterCompletionItems(state.items, word);
+  return {
+    ...state,
+    filteredItems
+  };
+};
+
+const getEdits = async (state, editor, completionItem) => {
+  // @ts-ignore
+  const {
+    leadingWord,
+    uid
+  } = state;
+  const word = completionItem.label;
+  const resolvedItem = await resolveCompletion(editor, word, completionItem);
+  const inserted = resolvedItem ? resolvedItem.snippet : word;
+  // TODO type and dispose commands should be sent to renderer process at the same time
+  const {
+    selections
+  } = editor;
+  const [startRowIndex, startColumnIndex] = selections;
+  const leadingWordLength = leadingWord.length;
+  const replaceRange$1 = new Uint32Array([startRowIndex, startColumnIndex - leadingWordLength, startRowIndex, startColumnIndex]);
+  const changes = replaceRange(editor, replaceRange$1, [inserted], '');
+  return changes;
+};
+const select = async (state, editor, completionItem) => {
+  const changes = await getEdits(state, editor, completionItem);
+  const index = editor.widgets.indexOf
+  // ViewletModuleId.EditorCompletion
+  ();
+  if (index !== -1) {
+    editor.widgets.splice(index, 1);
+    editor.completionState = None;
+    editor.completionUid = 0;
+  }
+  await execute$1('Editor.applyEdit', changes);
+  // await Viewlet.dispose(uid)
+  return state;
+};
+const selectIndex = (editorUid, state, index) => {
+  const editor = getEditor(editorUid);
+  const {
+    items
+  } = state;
+  if (index === -1) {
+    return state;
+  }
+  if (index > items.length) {
+    throw new Error('index too large');
+  }
+  const actualIndex = index;
+  const completionItem = items[actualIndex];
+  return select(state, editor, completionItem);
+};
+
+const selectCurrent = (editorUid, state) => {
+  const {
+    focusedIndex
+  } = state;
+  return selectIndex(editorUid, state, focusedIndex);
+};
+
 // copied from https://github.com/microsoft/vscode/tree/main/src/vs/base/common/strings.ts by Microsoft (License MIT)
 
 const RE_ESCAPE = /[\\\{\}\*\+\?\|\^\$\.\[\]\(\)]/g;
@@ -6224,8 +6717,8 @@ const getMatchCount = matches => {
   return matches.length / 2;
 };
 
-const loadContent = editorUid => {
-  const editor = getEditor(editorUid);
+const loadContent = editorId => {
+  const editor = getEditor(editorId);
   const {
     selections,
     lines
@@ -6278,10 +6771,15 @@ const focusIndex = async (state, index) => {
   if (index === matchIndex) {
     return state;
   }
+  // TODO find next match and highlight it
+  const matchRowIndex = matches[index * 2];
+  const matchColumnIndex = matches[index * 2 + 1];
+  // @ts-ignore
+  const newSelections = new Uint32Array([matchRowIndex, matchColumnIndex, matchRowIndex, matchColumnIndex + value.length]);
   // TODO set selections synchronously and render input match index,
   // input value and new selections at the same time
   // TODO
-  // await Command.execute('Editor.setSelections', newSelections)
+  await invoke$3('Editor.setSelections', newSelections);
   return {
     ...state,
     matchIndex: index
@@ -6376,27 +6874,6 @@ const ensure = async (fontName, fontUrl) => {
   setLoaded(fontName);
 };
 
-const OnHover = 'onHover';
-
-// TODO add tests for this
-const activateByEvent = async event => {
-  await invoke$3('ExtensionHostManagement.activateByEvent', event);
-};
-
-const execute = async ({
-  editor,
-  args,
-  event,
-  method,
-  noProviderFoundMessage,
-  noProviderFoundResult = undefined
-}) => {
-  const fullEvent = `${event}:${editor.languageId}`;
-  await activateByEvent(fullEvent);
-  const result = await invoke$2(method, editor.uid, ...args);
-  return result;
-};
-
 const executeHoverProvider = (editor, offset) => {
   object(editor);
   number$1(offset);
@@ -7459,7 +7936,7 @@ const renderEditor = async id => {
   return commands;
 };
 
-const keep = ['ColorPicker.handleSliderPointerDown', 'ColorPicker.handleSliderPointerMove', 'ColorPicker.loadContent', 'Editor.create', 'Editor.getWordAt', 'Editor.getWordBefore', 'Editor.offsetAt', 'Editor.render', 'FindWidget.focusFirst', 'FindWidget.focusIndex', 'FindWidget.focusLast', 'FindWidget.focusNext', 'FindWidget.focusPrevious', 'FindWidget.handleInput', 'FindWidget.loadContent', 'Font.ensure', 'Hover.getHoverInfo', 'Initialize.initialize'];
+const keep = ['ColorPicker.handleSliderPointerDown', 'ColorPicker.handleSliderPointerMove', 'ColorPicker.loadContent', 'Editor.create', 'Editor.getWordAt', 'Editor.getWordBefore', 'Editor.offsetAt', 'Editor.render', 'FindWidget.focusFirst', 'FindWidget.focusIndex', 'FindWidget.focusLast', 'FindWidget.focusNext', 'FindWidget.focusPrevious', 'FindWidget.handleInput', 'FindWidget.loadContent', 'Font.ensure', 'Hover.getHoverInfo', 'Initialize.initialize', 'EditorCompletion.advance', 'EditorCompletion.handleEditorBlur', 'EditorCompletion.handleEditorClick', 'EditorCompletion.handleEditorDeleteLeft', 'EditorCompletion.handleEditorType', 'EditorCompletion.loadContent', 'EditorCompletion.selectCurrent', 'EditorCompletion.selectIndex'];
 
 // TODO wrap commands globally, not per editor
 // TODO only store editor state in editor worker, not in renderer worker also
@@ -7484,7 +7961,7 @@ const wrapCommands = commands => {
 const commandMap = {
   'ColorPicker.handleSliderPointerDown': handleSliderPointerDown,
   'ColorPicker.handleSliderPointerMove': handleSliderPointerMove,
-  'ColorPicker.loadContent': loadContent$1,
+  'ColorPicker.loadContent': loadContent$2,
   'Editor.addCursorAbove': addCursorAbove,
   'Editor.addCursorBelow': addCursorBelow,
   'Editor.applyEdit': applyEdit,
@@ -7603,6 +8080,14 @@ const commandMap = {
   'Editor.typeWithAutoClosing': typeWithAutoClosing,
   'Editor.undo': undo,
   'Editor.unIndent': editorUnindent,
+  'EditorCompletion.advance': advance,
+  'EditorCompletion.handleEditorBlur': handleEditorBlur,
+  'EditorCompletion.handleEditorClick': handleEditorClick,
+  'EditorCompletion.handleEditorDeleteLeft': handleEditorDeleteLeft,
+  'EditorCompletion.handleEditorType': handleEditorType,
+  'EditorCompletion.loadContent': loadContent$1,
+  'EditorCompletion.selectCurrent': selectCurrent,
+  'EditorCompletion.selectIndex': selectIndex,
   'FindWidget.focusFirst': focusFirst,
   'FindWidget.focusIndex': focusIndex,
   'FindWidget.focusLast': focusLast,

package/package.json

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