@lvce-editor/editor-worker 19.29.12 → 19.29.13

package/dist/editorWorkerMain.js

@@ -1397,8 +1397,10 @@ const KeyJ = 38;
 const KeyK = 39;
 const KeyL = 40;
 const KeyO = 43;
+const KeyU = 49;
 const KeyV = 50;
 const KeyX = 52;
+const KeyY = 53;
 const KeyZ = 54;
 const F2 = 58;
 const F3 = 59;
@@ -4209,15 +4211,24 @@ const scheduleDocumentAndCursorsSelections = async (editor, changes, selectionCh
   // then clear old undostack from indexeddb after 3 days
   // TODO should push to undostack after rendering
   const autoClosingRanges = applyAutoClosingRangesEdit(editor, changes);
+  const change = changes[0];
+  const canCoalesceTyping = changes.length === 1 && change.origin === EditorType && change.deleted[0] === '' && change.inserted[0].length > 0 && change.inserted.length === 1 && change.start.rowIndex === change.end.rowIndex && change.start.columnIndex === change.end.columnIndex;
+  const previous = editor.undoStack.at(-1)?.[0];
+  const shouldCoalesce = editor.canCoalesceTyping && canCoalesceTyping && change.start.rowIndex === previous.start.rowIndex && change.start.columnIndex === previous.start.columnIndex + previous.inserted[0].length;
+  const undoStack = shouldCoalesce ? [...editor.undoStack.slice(0, -1), [{
+    ...previous,
+    inserted: [previous.inserted[0] + change.inserted[0]]
+  }]] : [...editor.undoStack, changes];
   const newEditor = {
     ...partialNewEditor,
     autoClosingRanges,
+    canCoalesceTyping,
     invalidStartIndex,
     lines: newLines,
     modified: true,
     redoStack: [],
     selections: newSelections,
-    undoStack: [...editor.undoStack, changes]
+    undoStack
   };
   // Update link decorations after text changes
   const linkDecorations = detectAllLinksAsDecorations(newEditor);
@@ -6406,6 +6417,21 @@ const cursorSet = (editor, rowIndex, columnIndex) => {
   return scheduleSelections(editor, selectionEdits);
 };
 
+const cursorUndo$1 = editor => {
+  const {
+    cursorUndoStack = []
+  } = editor;
+  if (cursorUndoStack.length === 0) {
+    return editor;
+  }
+  const selections = cursorUndoStack.at(-1);
+  const newEditor = {
+    ...editor,
+    cursorUndoStack: cursorUndoStack.slice(0, -1)
+  };
+  return scheduleSelections(newEditor, selections);
+};
+
 const moveSelectionWithoutIntlSegmenter = (selections, i, selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn) => {
   if (selectionStartRow === 0) {
     moveRangeToPosition$1(selections, i, 0, 0);
@@ -6887,6 +6913,7 @@ const i18nString = (key, placeholders = emptyObject) => {
 };
 
 const Copy = 'Copy';
+const CursorUndo = 'Cursor Undo';
 const Cut = 'Cut';
 const DeleteLine = 'Delete Line';
 const EditorCloseColorPicker = 'Editor: Close Color Picker';
@@ -6921,9 +6948,11 @@ const NoDefinitionFoundFor = "No definition found for '{PH1}'";
 const NoTypeDefinitionFound = 'No type definition found';
 const NoTypeDefinitionFoundFor = "No type definition found for '{PH1}'";
 const Paste = 'Paste';
+const Redo = 'Redo';
 const SourceAction = 'Source Action';
 const ToggleBlockComment = 'Toggle Block Comment';
 const ToggleBreakpoint = 'Toggle Breakpoint';
+const Undo = 'Undo';
 const Unfold = 'Editor: Unfold';
 
 const goToDefinition$1 = () => {
@@ -6978,6 +7007,15 @@ const copy = () => {
 const paste$1 = () => {
   return i18nString(Paste);
 };
+const cursorUndo = () => {
+  return i18nString(CursorUndo);
+};
+const undo$1 = () => {
+  return i18nString(Undo);
+};
+const redo$1 = () => {
+  return i18nString(Redo);
+};
 const unfold$1 = () => {
   return i18nString(Unfold);
 };
@@ -11721,6 +11759,18 @@ const getKeyBindings = () => {
     command: 'Editor.undo',
     key: CtrlCmd | KeyZ,
     when: FocusEditorText
+  }, {
+    command: 'Editor.cursorUndo',
+    key: CtrlCmd | KeyU,
+    when: FocusEditorText
+  }, {
+    command: 'Editor.redo',
+    key: CtrlCmd | Shift | KeyZ,
+    when: FocusEditorText
+  }, {
+    command: 'Editor.redo',
+    key: CtrlCmd | KeyY,
+    when: FocusEditorText
   }, {
     command: 'Editor.cursorLeft',
     key: LeftArrow,
@@ -11959,6 +12009,15 @@ const getProblems = async () => {
 
 const getQuickPickMenuEntries = () => {
   return [{
+    id: 'Editor.undo',
+    label: undo$1()
+  }, {
+    id: 'Editor.redo',
+    label: redo$1()
+  }, {
+    id: 'Editor.cursorUndo',
+    label: cursorUndo()
+  }, {
     id: 'Editor.fold',
     label: fold()
   }, {
@@ -12401,6 +12460,26 @@ const getErrorMessage = error => {
   }
   return String(error);
 };
+const getSavedHistory = (savedState, content) => {
+  if (!savedState || typeof savedState !== 'object') {
+    return undefined;
+  }
+  const {
+    lines,
+    redoStack,
+    undoStack
+  } = savedState;
+  if (!Array.isArray(lines) || lines.some(line => typeof line !== 'string') || lines.join('\n') !== content) {
+    return undefined;
+  }
+  if (!Array.isArray(redoStack) || !Array.isArray(undoStack)) {
+    return undefined;
+  }
+  return {
+    redoStack,
+    undoStack
+  };
+};
 const loadContent = async (state, savedState) => {
   const {
     assetDir,
@@ -12484,6 +12563,7 @@ const loadContent = async (state, savedState) => {
       textInfos: []
     };
   }
+  const savedHistory = existingEditor ? undefined : getSavedHistory(savedState, content);
 
   // TODO avoid creating intermediate editors here
   const newEditor1 = setBounds(newEditor0, x, y, width, height, 9);
@@ -12515,8 +12595,8 @@ const loadContent = async (state, savedState) => {
     completionsOnType,
     initial: false,
     modified: existingEditor?.modified || false,
-    redoStack: existingEditor?.redoStack || [],
-    undoStack: existingEditor?.undoStack || []
+    redoStack: existingEditor?.redoStack || savedHistory?.redoStack || [],
+    undoStack: existingEditor?.undoStack || savedHistory?.undoStack || []
   };
   return newEditor5;
 };
@@ -13527,10 +13607,14 @@ const renderEventListeners = () => {
 
 const saveState = (state, savedState) => {
   const {
-    lines
+    lines,
+    redoStack,
+    undoStack
   } = state;
   return {
-    lines
+    lines,
+    redoStack,
+    undoStack
   };
 };
 
@@ -13748,6 +13832,21 @@ const editorDiagnosticEffect = {
 };
 
 const queues = {};
+const cursorUndoLimit = 100;
+const selectionsEqual = (left, right) => {
+  if (left === right) {
+    return true;
+  }
+  if (left.length !== right.length) {
+    return false;
+  }
+  for (let i = 0; i < left.length; i++) {
+    if (left[i] !== right[i]) {
+      return false;
+    }
+  }
+  return true;
+};
 const saveAfterDelay = async (uid, token) => {
   if (!get$8(uid)) {
     consume(uid, token);
@@ -13776,7 +13875,7 @@ const saveAfterDelay = async (uid, token) => {
 // TODO wrap commands globally, not per editor
 // TODO only store editor state in editor worker, not in renderer worker also
 
-const wrapCommand = fn => async (uid, ...args) => {
+const wrapCommand = (fn, preservesTypingCoalescing = false) => async (uid, ...args) => {
   const initialInstance = get$8(uid);
   const queueKey = initialInstance?.newState.uri || uid;
   const previous = queues[queueKey];
@@ -13791,7 +13890,34 @@ const wrapCommand = fn => async (uid, ...args) => {
   try {
     const oldInstance = get$8(uid);
     const state = oldInstance.newState;
-    const newEditor = await fn(state, ...args);
+    const {
+      cursorUndoStack,
+      initial,
+      isSelecting,
+      lines,
+      modified,
+      redoStack,
+      selections,
+      undoStack,
+      uri
+    } = state;
+    const commandResult = await fn(state, ...args);
+    let newEditor = !preservesTypingCoalescing && commandResult.canCoalesceTyping ? {
+      ...commandResult,
+      canCoalesceTyping: false
+    } : commandResult;
+    if (lines !== newEditor.lines && newEditor.cursorUndoStack?.length) {
+      newEditor = {
+        ...newEditor,
+        cursorUndoStack: []
+      };
+    } else if (selections && newEditor.selections && !isSelecting && newEditor.cursorUndoStack === cursorUndoStack && (!selectionsEqual(selections, newEditor.selections) || newEditor.isSelecting)) {
+      const previousCursorUndoStack = cursorUndoStack || [];
+      newEditor = {
+        ...newEditor,
+        cursorUndoStack: [...previousCursorUndoStack.slice(1 - cursorUndoLimit), new Uint32Array(selections)]
+      };
+    }
     if (state === newEditor) {
       return newEditor;
     }
@@ -13805,14 +13931,6 @@ const wrapCommand = fn => async (uid, ...args) => {
       }
       set$8(uid, state, finalEditor);
     }
-    const {
-      initial,
-      lines,
-      modified,
-      redoStack,
-      undoStack,
-      uri
-    } = state;
     if (!initial && uri === finalEditor.uri && (lines !== finalEditor.lines || modified !== finalEditor.modified || redoStack !== finalEditor.redoStack || undoStack !== finalEditor.undoStack)) {
       for (const key of getKeys$2()) {
         const otherUid = Number(key);
@@ -13891,6 +14009,7 @@ const commandMap = {
   'Editor.cursorPageDown': wrapCommand(cursorPageDown),
   'Editor.cursorRight': wrapCommand(cursorCharacterRight),
   'Editor.cursorSet': wrapCommand(cursorSet),
+  'Editor.cursorUndo': wrapCommand(cursorUndo$1),
   'Editor.cursorUp': wrapCommand(cursorUp),
   'Editor.cursorWordLeft': wrapCommand(cursorWordLeft),
   'Editor.cursorWordPartLeft': wrapCommand(cursorWordPartLeft),
@@ -14043,8 +14162,8 @@ const commandMap = {
   'Editor.toggleBreakpoint': wrapCommand(toggleBreakpoint),
   'Editor.toggleComment': wrapCommand(toggleComment),
   'Editor.toggleLineComment': wrapCommand(editorToggleLineComment),
-  'Editor.type': wrapCommand(type),
-  'Editor.typeWithAutoClosing': wrapCommand(typeWithAutoClosing),
+  'Editor.type': wrapCommand(type, true),
+  'Editor.typeWithAutoClosing': wrapCommand(typeWithAutoClosing, true),
   '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.29.12",
+  "version": "19.29.13",
   "repository": {
     "type": "git",
     "url": "git@github.com:lvce-editor/editor-worker.git"