@lvce-editor/editor-worker 19.72.10 → 19.73.1

package/dist/editorWorkerMain.js

@@ -7048,6 +7048,445 @@ const disposeEditor = async editorUid => {
   return commands;
 };
 
+const getIndex = (widgets, id) => {
+  for (const [i, widget] of widgets.entries()) {
+    if (widget.id === id) {
+      return i;
+    }
+  }
+  return -1;
+};
+const removeEditorWidget = (widgets, id) => {
+  const index = getIndex(widgets, id);
+  const newWidgets = [...widgets.slice(0, index), ...widgets.slice(index + 1)];
+  return newWidgets;
+};
+
+const closeCompletion = editor => {
+  const {
+    widgets
+  } = editor;
+  const widgetRevision = next(editor.uid);
+  if (widgets.every(widget => widget.id !== Completion)) {
+    return editor;
+  }
+  return {
+    ...editor,
+    additionalFocus: 0,
+    focused: true,
+    widgetRevision,
+    widgets: removeEditorWidget(widgets, Completion)
+  };
+};
+
+const hasWidget = (widgets, id) => {
+  for (const widget of widgets) {
+    if (widget.id === id) {
+      return true;
+    }
+  }
+  return false;
+};
+
+const addWidgetToEditor = async (widgetId, focusKey, editor, factory, newStateGenerator, fullFocus) => {
+  const {
+    widgets = []
+  } = editor;
+  if (hasWidget(widgets, widgetId)) {
+    return editor;
+  }
+  const widgetRevision = next(editor.uid);
+  const widget = factory();
+  // @ts-ignore
+  widget.newState.editorUid = editor.uid;
+  const newState = await newStateGenerator(widget.newState, editor.uid);
+  if (!newState) {
+    return editor;
+  }
+  if (get(editor.uid) !== widgetRevision) {
+    return get$8(editor.uid)?.newState || editor;
+  }
+  // @ts-ignore
+  newState.editorUid = editor.uid;
+  const latestWidget = {
+    ...widget,
+    newState
+  };
+  const newWidgets = [...widgets, latestWidget];
+  const newFocus = !fullFocus;
+  const newEditor = {
+    ...editor,
+    additionalFocus: fullFocus ? 0 : focusKey,
+    focus: fullFocus ? focusKey : FocusEditorText$1,
+    focused: newFocus,
+    widgetRevision,
+    widgets: newWidgets
+  };
+  return newEditor;
+};
+
+const state$5 = {
+  configured: false,
+  lastId: -1,
+  nextId: 0
+};
+const configure = (start, end) => {
+  const {
+    configured
+  } = state$5;
+  if (configured) {
+    throw new Error('Component id range is already configured');
+  }
+  if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start <= 0 || end < start) {
+    throw new Error('Invalid component id range');
+  }
+  state$5.nextId = start;
+  state$5.lastId = end;
+  state$5.configured = true;
+};
+const create$8 = () => {
+  const {
+    configured,
+    lastId,
+    nextId
+  } = state$5;
+  if (!configured) {
+    // Compatibility with renderer versions that do not assign worker id ranges.
+    return Math.random();
+  }
+  if (nextId > lastId) {
+    throw new Error('Component id range exhausted');
+  }
+  return state$5.nextId++;
+};
+
+const create$7 = () => {
+  const completionUid = create$8();
+  const completionWidget = {
+    id: Completion,
+    newState: {
+      commands: [],
+      height: 0,
+      uid: completionUid,
+      width: 0,
+      x: 0,
+      y: 0
+    },
+    oldState: {
+      commands: [],
+      height: 0,
+      uid: completionUid,
+      width: 0,
+      x: 0,
+      y: 0
+    }
+  };
+  return completionWidget;
+};
+
+const {
+  invoke: invoke$4,
+  setFactory
+} = createLazyRpc(CompletionWorker);
+
+// These commits preserve the document, selection, layout, widgets and lifecycle.
+const diagnosticFields = new Set(['decorations', 'diagnostics', 'lightBulbRowIndex', 'visualDecorations']);
+const isCurrent$1 = (snapshot, current) => {
+  if (!current || current.lifecycle?.disposed) {
+    return false;
+  }
+  if (snapshot === current) {
+    return true;
+  }
+  const keys = new Set([...Object.keys(snapshot), ...Object.keys(current)]);
+  for (const key of keys) {
+    if (diagnosticFields.has(key)) {
+      continue;
+    }
+    const field = key;
+    if (Object.hasOwn(snapshot, field) !== Object.hasOwn(current, field) || snapshot[field] !== current[field]) {
+      return false;
+    }
+  }
+  return true;
+};
+const merge = (current, snapshot, result) => {
+  if (!isCurrent$1(snapshot, current) || result === snapshot || result === current) {
+    return current;
+  }
+  if (current === snapshot) {
+    return result;
+  }
+  return {
+    ...result,
+    decorations: current.decorations,
+    diagnostics: current.diagnostics,
+    lightBulbRowIndex: current.lightBulbRowIndex,
+    visualDecorations: current.visualDecorations
+  };
+};
+
+const updateWidget = (editor, widgetId, newState) => {
+  // TODO avoid closure
+  const isWidget = widget => {
+    return widget.id === widgetId;
+  };
+  const childIndex = editor.widgets.findIndex(isWidget);
+  if (childIndex === -1) {
+    return editor;
+  }
+  // TODO scroll up/down if necessary
+  const childWidget = editor.widgets[childIndex];
+  const newWidget = {
+    ...childWidget,
+    newState,
+    oldState: childWidget.newState
+  };
+  const newWidgets = [...editor.widgets.slice(0, childIndex), newWidget, ...editor.widgets.slice(childIndex + 1)];
+  return {
+    ...editor,
+    widgets: newWidgets
+  };
+};
+
+const disposeCompletion = async uid => {
+  try {
+    await invoke$4('Completions.dispose', uid);
+  } catch {
+    // A completion worker may already have disposed this state during shutdown.
+  }
+};
+const newStateGenerator$4 = async (state, parentUid, markCreated, automatic) => {
+  const {
+    height,
+    uid,
+    width,
+    x,
+    y
+  } = state;
+  const {
+    newState
+  } = get$8(parentUid);
+  const {
+    applicationId,
+    languageId
+  } = newState;
+  await invoke$4('Completions.create', uid, x, y, width, height, parentUid, languageId, applicationId);
+  markCreated();
+  await invoke$4('Completions.loadContent', uid, automatic);
+  if (automatic && !(await invoke$4('Completions.hasItems', uid))) {
+    return undefined;
+  }
+  const diff = await invoke$4('Completions.diff2', uid);
+  const commands = await invoke$4('Completions.render2', uid, diff);
+  return {
+    ...state,
+    automatic,
+    commands
+  };
+};
+const openCompletion = async (editor, automatic = false) => {
+  const widget = (editor.widgets || []).find(candidate => candidate.id === Completion);
+  if (widget && (automatic || widget.newState.automatic)) {
+    const {
+      uid
+    } = widget.newState;
+    await invoke$4('Completions.loadContent', uid, automatic);
+    if (!isCurrent$1(editor, get$8(editor.uid)?.newState)) {
+      return get$8(editor.uid)?.newState || editor;
+    }
+    if (automatic && !(await invoke$4('Completions.hasItems', uid))) {
+      return closeCompletion(editor);
+    }
+    const diff = await invoke$4('Completions.diff2', uid);
+    const commands = await invoke$4('Completions.render2', uid, diff);
+    return updateWidget(editor, Completion, {
+      ...widget.newState,
+      automatic,
+      commands
+    });
+  }
+  let completionUid = 0;
+  let created = false;
+  const generateState = async (state, parentUid) => {
+    completionUid = state.uid;
+    try {
+      const result = await newStateGenerator$4(state, parentUid, () => {
+        created = true;
+      }, automatic);
+      return result;
+    } catch (error) {
+      if (created) {
+        await disposeCompletion(completionUid);
+      }
+      throw error;
+    }
+  };
+  const fullFocus = false;
+  const result = await addWidgetToEditor(Completion, EditorCompletion, editor, create$7, generateState, fullFocus);
+  const wasAdded = (result?.widgets || []).some(widget => widget.id === Completion && widget.newState.uid === completionUid);
+  const currentEditor = get$8(editor.uid)?.newState;
+  if (created && (!wasAdded || !isCurrent$1(editor, currentEditor))) {
+    await disposeCompletion(completionUid);
+  }
+  return result;
+};
+
+const expressionKeywords = new Set(['return', 'throw', 'yield', 'await', 'typeof', 'void', 'delete', 'case', 'new', 'in', 'of']);
+const isIdentifier = character => /[\w$]/u.test(character);
+
+// Scan the document prefix, retaining lexical state across lines and nested template expressions.
+const isTypeScriptCode = text => {
+  const frames = [{
+    context: 'code',
+    depth: 0
+  }];
+  let expressionStart = true;
+  let regexClass = false;
+  scan: for (let index = 0; index < text.length; index++) {
+    const frame = frames.at(-1);
+    const character = text[index];
+    const next = text[index + 1];
+    switch (frame.context) {
+      case 'blockComment':
+        if (character === '*' && next === '/') {
+          frames.pop();
+          index++;
+        }
+        continue scan;
+      case 'code':
+        if (character === '/' && next === '/') {
+          frames.push({
+            context: 'lineComment',
+            depth: 0
+          });
+          index++;
+        } else if (character === '/' && next === '*') {
+          frames.push({
+            context: 'blockComment',
+            depth: 0
+          });
+          index++;
+        } else if (["'", '"', '`'].includes(character)) {
+          frames.push({
+            context: character === "'" ? 'single' : character === '"' ? 'double' : 'template',
+            depth: 0
+          });
+        } else if (character === '/' && expressionStart) {
+          frames.push({
+            context: 'regex',
+            depth: 0
+          });
+          regexClass = false;
+        } else if (character === '{') {
+          frame.depth++;
+          expressionStart = true;
+        } else if (character === '}') {
+          frame.depth--;
+          if (frame.depth === 0 && frames.length > 1) {
+            frames.pop();
+          }
+          expressionStart = false;
+        } else if (isIdentifier(character)) {
+          const start = index;
+          while (index + 1 < text.length && isIdentifier(text[index + 1])) {
+            index++;
+          }
+          expressionStart = expressionKeywords.has(text.slice(start, index + 1));
+        } else if (!/\s/u.test(character)) {
+          expressionStart = '=(:,[!&|?;+-*%<>'.includes(character);
+        }
+        continue scan;
+      case 'double':
+      case 'single':
+        if (character === '\\') {
+          index++;
+        } else if ([frame.context === 'single' ? "'" : '"', '\n', '\r'].includes(character)) {
+          frames.pop();
+          expressionStart = false;
+        }
+        continue scan;
+      case 'lineComment':
+        if (['\n', '\r'].includes(character)) {
+          frames.pop();
+        }
+        continue scan;
+      case 'regex':
+        switch (character) {
+          case '[':
+            {
+              regexClass = true;
+              continue scan;
+            }
+          case ']':
+            {
+              regexClass = false;
+              continue scan;
+            }
+          case '\\':
+            {
+              index++;
+              continue scan;
+            }
+          default:
+            if (character === '/' && !regexClass || ['\n', '\r'].includes(character)) {
+              frames.pop();
+              expressionStart = false;
+            }
+        }
+        continue scan;
+      case 'template':
+        if (character === '\\') {
+          index++;
+        } else if (character === '`') {
+          frames.pop();
+          expressionStart = false;
+        } else if (character === '$' && next === '{') {
+          frames.push({
+            context: 'code',
+            depth: 1
+          });
+          expressionStart = true;
+          index++;
+        }
+        continue scan;
+    }
+  }
+  return frames.at(-1).context === 'code';
+};
+
+const shouldOpenAutomaticCompletion = editor => {
+  const {
+    completionsOnType,
+    isQuickSuggestionsEnabled,
+    languageId,
+    largeFile,
+    lines,
+    selections
+  } = editor;
+  if (largeFile || !(completionsOnType || languageId === 'typescript' && isQuickSuggestionsEnabled)) {
+    return false;
+  }
+  if (languageId !== 'typescript') {
+    return true;
+  }
+  const rowIndex = selections[0];
+  const columnIndex = selections[1];
+  const prefix = [...lines.slice(0, rowIndex), lines[rowIndex].slice(0, columnIndex)].join('\n');
+  return /[\w$.]$/u.test(prefix) && isTypeScriptCode(prefix);
+};
+
+const updateAutomaticCompletion = async editor => {
+  const widget = (editor.widgets || []).find(candidate => candidate.id === Completion);
+  if (widget && !widget.newState.automatic) {
+    return editor;
+  }
+  if (!shouldOpenAutomaticCompletion(editor)) {
+    return widget ? closeCompletion(editor) : editor;
+  }
+  return openCompletion(editor, true);
+};
+
 const getAcceptedLines = (lines, conflict, action) => {
   const current = lines.slice(conflict.currentStartRowIndex, conflict.currentEndRowIndex);
   const incoming = lines.slice(conflict.incomingStartRowIndex, conflict.incomingEndRowIndex);
@@ -7542,55 +7981,6 @@ const isFormattingError = error => {
   return error && error instanceof Error && error.message.startsWith(expectedErrorMessage$1);
 };
 
-const state$5 = {
-  configured: false,
-  lastId: -1,
-  nextId: 0
-};
-const configure = (start, end) => {
-  const {
-    configured
-  } = state$5;
-  if (configured) {
-    throw new Error('Component id range is already configured');
-  }
-  if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start <= 0 || end < start) {
-    throw new Error('Invalid component id range');
-  }
-  state$5.nextId = start;
-  state$5.lastId = end;
-  state$5.configured = true;
-};
-const create$8 = () => {
-  const {
-    configured,
-    lastId,
-    nextId
-  } = state$5;
-  if (!configured) {
-    // Compatibility with renderer versions that do not assign worker id ranges.
-    return Math.random();
-  }
-  if (nextId > lastId) {
-    throw new Error('Component id range exhausted');
-  }
-  return state$5.nextId++;
-};
-
-const getIndex = (widgets, id) => {
-  for (const [i, widget] of widgets.entries()) {
-    if (widget.id === id) {
-      return i;
-    }
-  }
-  return -1;
-};
-const removeEditorWidget = (widgets, id) => {
-  const index = getIndex(widgets, id);
-  const newWidgets = [...widgets.slice(0, index), ...widgets.slice(index + 1)];
-  return newWidgets;
-};
-
 const Message = 9;
 
 const getAccurateColumnIndexAscii = async (line, guess, averageCharWidth, eventX, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth) => {
@@ -7606,7 +7996,7 @@ const getAccurateColumnIndexAscii = async (line, guess, averageCharWidth, eventX
 const supported = () => {
   return 'Segmenter' in Intl;
 };
-const create$7 = () => {
+const create$6 = () => {
   // @ts-ignore
   const segmenter = new Intl.Segmenter();
   return {
@@ -7641,7 +8031,7 @@ const create$7 = () => {
 };
 
 const getAccurateColumnIndexUnicode = async (line, guess, averageCharWidth, eventX, fontWeight, fontSize, fontFamily, letterSpacing) => {
-  const segmenter = create$7();
+  const segmenter = create$6();
   const segments = segmenter.getSegments(line);
   const isMonospaceFont = false;
   const charWidth = 0;
@@ -8210,7 +8600,7 @@ const wrapFocusCommand$1 = (fn, returnState = true) => {
 
 // Optional provider work must not hold the editing queue while another worker responds.
 const wrapDeferredCommand$1 = (fn, returnState = true) => {
-  const apply = wrapCommand$1((editor, snapshot, result) => editor === snapshot ? result : editor, false, returnState);
+  const apply = wrapCommand$1((editor, snapshot, result) => merge(editor, snapshot, result), false, returnState);
   return async (uid, ...args) => {
     const snapshot = await enqueue(uid, async () => get$8(uid)?.newState);
     if (!snapshot) {
@@ -8321,15 +8711,6 @@ const closeWidgetsMaybe = widgets => {
   return widgets.filter(widget => isPersistentWidget(widget.id));
 };
 
-const hasWidget = (widgets, id) => {
-  for (const widget of widgets) {
-    if (widget.id === id) {
-      return true;
-    }
-  }
-  return false;
-};
-
 const handleBlur$1 = async editor => {
   if (!editor.focused) {
     return editor;
@@ -8745,23 +9126,6 @@ const closeCodeGenerator = editor => {
   };
 };
 
-const closeCompletion = editor => {
-  const {
-    widgets
-  } = editor;
-  const widgetRevision = next(editor.uid);
-  if (widgets.every(widget => widget.id !== Completion)) {
-    return editor;
-  }
-  return {
-    ...editor,
-    additionalFocus: 0,
-    focused: true,
-    widgetRevision,
-    widgets: removeEditorWidget(widgets, Completion)
-  };
-};
-
 const isMatchingWidget$1 = widget => {
   return widget.id === Find;
 };
@@ -8831,44 +9195,7 @@ const closeSourceAction = editor => {
   };
 };
 
-const addWidgetToEditor = async (widgetId, focusKey, editor, factory, newStateGenerator, fullFocus) => {
-  const {
-    widgets = []
-  } = editor;
-  if (hasWidget(widgets, widgetId)) {
-    return editor;
-  }
-  const widgetRevision = next(editor.uid);
-  const widget = factory();
-  // @ts-ignore
-  widget.newState.editorUid = editor.uid;
-  const newState = await newStateGenerator(widget.newState, editor.uid);
-  if (!newState) {
-    return editor;
-  }
-  if (get(editor.uid) !== widgetRevision) {
-    return get$8(editor.uid)?.newState || editor;
-  }
-  // @ts-ignore
-  newState.editorUid = editor.uid;
-  const latestWidget = {
-    ...widget,
-    newState
-  };
-  const newWidgets = [...widgets, latestWidget];
-  const newFocus = !fullFocus;
-  const newEditor = {
-    ...editor,
-    additionalFocus: fullFocus ? 0 : focusKey,
-    focus: fullFocus ? focusKey : FocusEditorText$1,
-    focused: newFocus,
-    widgetRevision,
-    widgets: newWidgets
-  };
-  return newEditor;
-};
-
-const create$6 = (bounds, range, undoStackIndex) => {
+const create$5 = (bounds, range, undoStackIndex) => {
   const completionUid = create$8();
   const state = {
     ...bounds,
@@ -8922,7 +9249,7 @@ const getColorPickerBounds = editor => {
   };
 };
 
-const newStateGenerator$4 = (state, parentUid) => {
+const newStateGenerator$3 = (state, parentUid) => {
   return loadContent$3(state, parentUid);
 };
 const openColorPicker = async editor => {
@@ -8932,8 +9259,8 @@ const openColorPicker = async editor => {
     getColorPickerRange
   } = await Promise.resolve().then(function () { return GetColorPickerRange; });
   const range = await getColorPickerRange(editor);
-  const createWidget = () => create$6(bounds, range, editor.undoStack.length);
-  return addWidgetToEditor(ColorPicker$2, ColorPicker, editor, createWidget, newStateGenerator$4, fullFocus);
+  const createWidget = () => create$5(bounds, range, editor.undoStack.length);
+  return addWidgetToEditor(ColorPicker$2, ColorPicker, editor, createWidget, newStateGenerator$3, fullFocus);
 };
 const closeColorPicker = editor => {
   const {
@@ -9247,7 +9574,7 @@ const characterLeft = (line, columnIndex) => {
   if (columnIndex > line.length) {
     return 1;
   }
-  const segmenter = create$7();
+  const segmenter = create$6();
   const last = segmenter.at(line, columnIndex - 1);
   if (!last) {
     return 1;
@@ -9262,7 +9589,7 @@ const characterRight = (line, columnIndex) => {
   if (!supported()) {
     return 1;
   }
-  const segmenter = create$7();
+  const segmenter = create$6();
   const next = segmenter.at(line, columnIndex);
   // @ts-ignore
   return next.segment.length;
@@ -11006,7 +11333,7 @@ const getDiagnosticHoverInfo = async (editor, diagnostic) => {
   };
 };
 
-const create$5 = () => {
+const create$4 = () => {
   const uid = create$8();
   const widget = {
     id: Hover,
@@ -11225,29 +11552,6 @@ const loadHoverContent = async (state, position) => {
   };
 };
 
-const updateWidget = (editor, widgetId, newState) => {
-  // TODO avoid closure
-  const isWidget = widget => {
-    return widget.id === widgetId;
-  };
-  const childIndex = editor.widgets.findIndex(isWidget);
-  if (childIndex === -1) {
-    return editor;
-  }
-  // TODO scroll up/down if necessary
-  const childWidget = editor.widgets[childIndex];
-  const newWidget = {
-    ...childWidget,
-    newState,
-    oldState: childWidget.newState
-  };
-  const newWidgets = [...editor.widgets.slice(0, childIndex), newWidget, ...editor.widgets.slice(childIndex + 1)];
-  return {
-    ...editor,
-    widgets: newWidgets
-  };
-};
-
 const getHoverWidgetIndex = widgets => {
   return widgets.findIndex(widget => widget.id === Hover);
 };
@@ -11257,7 +11561,7 @@ const applyHoverContent = async (editor, getNewState) => {
   } = editor;
   const widgetIndex = getHoverWidgetIndex(widgets);
   if (widgetIndex === -1) {
-    return addWidgetToEditor(Hover, FocusEditorHover, editor, create$5, getNewState);
+    return addWidgetToEditor(Hover, FocusEditorHover, editor, create$4, getNewState);
   }
   const widgetRevision = next(editor.uid);
   const widget = widgets[widgetIndex];
@@ -12175,7 +12479,7 @@ const previousDiagnostic = editor => {
 const Script = 2;
 const Unknown$1 = 0;
 
-const create$4 = () => {
+const create$3 = () => {
   const completionUid = create$8();
   const widget = {
     id: CodeGenerator,
@@ -12203,7 +12507,7 @@ const create$4 = () => {
   return widget;
 };
 
-const newStateGenerator$3 = async state => {
+const newStateGenerator$2 = async state => {
   const latestState = {
     ...state,
     height: 45,
@@ -12215,65 +12519,7 @@ const newStateGenerator$3 = async state => {
 };
 const openCodeGenerator = async editor => {
   const fullFocus = true;
-  return addWidgetToEditor(CodeGenerator, FocusCodeGenerator, editor, create$4, newStateGenerator$3, fullFocus);
-};
-
-const create$3 = () => {
-  const completionUid = create$8();
-  const completionWidget = {
-    id: Completion,
-    newState: {
-      commands: [],
-      height: 0,
-      uid: completionUid,
-      width: 0,
-      x: 0,
-      y: 0
-    },
-    oldState: {
-      commands: [],
-      height: 0,
-      uid: completionUid,
-      width: 0,
-      x: 0,
-      y: 0
-    }
-  };
-  return completionWidget;
-};
-
-const {
-  invoke: invoke$4,
-  setFactory
-} = createLazyRpc(CompletionWorker);
-
-const newStateGenerator$2 = async (state, parentUid) => {
-  const {
-    height,
-    uid,
-    width,
-    x,
-    y
-  } = state;
-  const {
-    newState
-  } = get$8(parentUid);
-  const {
-    applicationId,
-    languageId
-  } = newState;
-  await invoke$4('Completions.create', uid, x, y, width, height, parentUid, languageId, applicationId);
-  await invoke$4('Completions.loadContent', uid);
-  const diff = await invoke$4('Completions.diff2', uid);
-  const commands = await invoke$4('Completions.render2', uid, diff);
-  return {
-    ...state,
-    commands
-  };
-};
-const openCompletion = async editor => {
-  const fullFocus = false;
-  return addWidgetToEditor(Completion, EditorCompletion, editor, create$3, newStateGenerator$2, fullFocus);
+  return addWidgetToEditor(CodeGenerator, FocusCodeGenerator, editor, create$3, newStateGenerator$2, fullFocus);
 };
 
 const isFunctional = widgetId => {
@@ -13808,7 +14054,7 @@ const showSignatureHelp = async editor => {
   const newStateGenerator = async state => {
     return loadSignatureHelpContent(state);
   };
-  return addWidgetToEditor(Hover, FocusEditorHover, editorWithoutHover, create$5, newStateGenerator);
+  return addWidgetToEditor(Hover, FocusEditorHover, editorWithoutHover, create$4, newStateGenerator);
 };
 
 const create = () => {
@@ -14429,14 +14675,7 @@ const toggleCompletion = async editor => {
 
 const type = async (editor, text) => {
   const changes = editorReplaceSelections(editor, [text], EditorType);
-  const newEditor = await scheduleDocumentAndCursorsSelections(editor, changes);
-  if (newEditor.completionsOnType) {
-    // TODO if completion widget is already visible, advance
-    // TODO if character typed is space or tab or separator, close completions
-    const withCompletion = await openCompletion(newEditor);
-    return withCompletion;
-  }
-  return newEditor;
+  return scheduleDocumentAndCursorsSelections(editor, changes);
 };
 
 const Slash = '/';
@@ -14815,6 +15054,15 @@ const add$7 = widget => {
 const remove$6 = widget => {
   return [];
 };
+const fns = createFns(['handleEditorType', 'handleEditorDeleteLeft'], 'Completions', Completion);
+const handleEditorType$1 = editor => {
+  const widget = (editor.widgets || []).find(candidate => candidate.id === Completion);
+  return widget?.newState.automatic ? editor : fns.handleEditorType(editor);
+};
+const handleEditorDeleteLeft$1 = editor => {
+  const widget = (editor.widgets || []).find(candidate => candidate.id === Completion);
+  return widget?.newState.automatic ? editor : fns.handleEditorDeleteLeft(editor);
+};
 const {
   close: close$3,
   closeDetails: closeDetails$1,
@@ -14825,8 +15073,6 @@ const {
   focusPrevious: focusPrevious$1,
   handleEditorBlur,
   handleEditorClick,
-  handleEditorDeleteLeft: handleEditorDeleteLeft$1,
-  handleEditorType: handleEditorType$1,
   handlePointerDown,
   handleWheel: handleWheel$1,
   openDetails,
@@ -18978,6 +19224,22 @@ const resize = async (editor, dimensions) => {
   const resizedEditor = resize$2(editor, dimensions, editor.columnWidth);
   return resize$1(resizedEditor, dimensions);
 };
+const openCompletionDeferred = wrapDeferredCommand(openCompletion);
+const updateAutomaticCompletionDeferred = wrapDeferredCommand(updateAutomaticCompletion);
+const wrapTypingCommand = (fn, shouldOpenCompletion) => {
+  const command = wrapCommand(fn, true);
+  return async (uid, ...args) => {
+    await command(uid, ...args);
+    const editor = get$8(uid)?.newState;
+    if (editor && (shouldOpenCompletion(...args) && shouldOpenAutomaticCompletion(editor) || editor.widgets?.some(widget => widget.id === Completion && widget.newState.automatic))) {
+      void updateAutomaticCompletionDeferred(uid).then(() => invoke$d('Editor.renderPending', uid)).catch(error => handleError$1(error, 'Failed to open completion widget: '));
+    }
+  };
+};
+const deleteLeftCommand = wrapTypingCommand(deleteCharacterLeft, () => false);
+const typeCommand = wrapTypingCommand(type, () => true);
+const typeWithAutoClosingCommand = wrapTypingCommand(typeWithAutoClosing, () => true);
+const handleBeforeInputCommand = wrapTypingCommand(handleBeforeInput, inputType => inputType === InsertText);
 const commandMap = {
   'ActivateByEvent.activateByEvent': activateByEvent,
   'CodeGenerator.accept': codeGeneratorAccept,
@@ -19031,10 +19293,10 @@ const commandMap = {
   'Editor.deleteAll': wrapCommand(deleteAll),
   'Editor.deleteAllLeft': wrapCommand(deleteAllLeft),
   'Editor.deleteAllRight': wrapCommand(deleteAllRight),
-  'Editor.deleteCharacterLeft': wrapCommand(deleteCharacterLeft),
+  'Editor.deleteCharacterLeft': deleteLeftCommand,
   'Editor.deleteCharacterRight': wrapCommand(deleteCharacterRight),
   'Editor.deleteHorizontalRight': wrapCommand(editorDeleteHorizontalRight),
-  'Editor.deleteLeft': wrapCommand(deleteCharacterLeft),
+  'Editor.deleteLeft': deleteLeftCommand,
   'Editor.deleteLine': wrapCommand(deleteLine$1),
   'Editor.deleteRight': wrapCommand(deleteCharacterRight),
   'Editor.deleteWordLeft': wrapCommand(deleteWordLeft),
@@ -19077,7 +19339,7 @@ const commandMap = {
   'Editor.goToBracket': wrapCommand(goToBracket$1),
   'Editor.goToDefinition': wrapCommand(goToDefinition),
   'Editor.goToTypeDefinition': wrapCommand(goToTypeDefinition),
-  'Editor.handleBeforeInput': wrapCommand(handleBeforeInput, true),
+  'Editor.handleBeforeInput': handleBeforeInputCommand,
   'Editor.handleBeforeInputFromContentEditable': wrapCommand(handleBeforeInputFromContentEditable),
   'Editor.handleBlur': wrapCommand(handleBlur$1),
   'Editor.handleClickAtPosition': wrapCommand(handleClickAtPosition),
@@ -19130,7 +19392,7 @@ const commandMap = {
   'Editor.offsetAt': offsetAt,
   'Editor.openCodeGenerator': wrapCommand(openCodeGenerator),
   'Editor.openColorPicker': wrapCommand(openColorPicker),
-  'Editor.openCompletion': wrapCommand(openCompletion),
+  'Editor.openCompletion': openCompletionDeferred,
   'Editor.openFind': wrapCommand(openFind),
   'Editor.openFind2': wrapCommand(openFind2),
   'Editor.openRename': wrapCommand(openRename),
@@ -19194,11 +19456,11 @@ const commandMap = {
   'Editor.toggleBlockComment': wrapCommand(toggleBlockComment),
   'Editor.toggleBreakpoint': wrapCommand(toggleBreakpoint),
   'Editor.toggleComment': wrapCommand(toggleComment),
-  'Editor.toggleCompletion': wrapCommand(toggleCompletion),
+  'Editor.toggleCompletion': wrapDeferredCommand(toggleCompletion),
   'Editor.toggleLineComment': wrapCommand(editorToggleLineComment),
   'Editor.toggleMinimap': toggleMinimap,
-  'Editor.type': wrapCommand(type, true),
-  'Editor.typeWithAutoClosing': wrapCommand(typeWithAutoClosing, true),
+  'Editor.type': typeCommand,
+  'Editor.typeWithAutoClosing': typeWithAutoClosingCommand,
   'Editor.undo': wrapCommand(undo),
   'Editor.unfold': wrapCommand(unfold),
   'Editor.unIndent': wrapCommand(editorUnindent),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/editor-worker",
-  "version": "19.72.10",
+  "version": "19.73.1",
   "repository": {
     "type": "git",
     "url": "git@github.com:lvce-editor/editor-worker.git"