monaco-editor-core 0.57.0 → 0.58.0-dev-20261104

package/esm/vs/editor/common/cursor/cursorTypeEditOperations.js

@@ -5,6 +5,7 @@
 import { onUnexpectedError } from '../../../base/common/errors.js';
 import * as strings from '../../../base/common/strings.js';
 import { ReplaceCommand, ReplaceCommandWithOffsetCursorState, ReplaceCommandWithoutChangingPosition, ReplaceCommandThatPreservesSelection, ReplaceOvertypeCommand, ReplaceOvertypeCommandOnCompositionEnd } from '../commands/replaceCommand.js';
+import { ColumnSelectionPasteCommand } from '../commands/columnSelectionPasteCommand.js';
 import { ShiftCommand } from '../commands/shiftCommand.js';
 import { SurroundSelectionCommand } from '../commands/surroundSelectionCommand.js';
 import { EditOperationResult, isQuote } from '../cursorCommon.js';
@@ -28,8 +29,8 @@ export class AutoIndentOperation {
                 }
                 indentationForSelections.push({ selection, indentation });
             }
-            const autoClosingPairClose = AutoClosingOpenCharTypeOperation.getAutoClosingPairClose(config, model, selections, ch, false);
-            return this._getIndentationAndAutoClosingPairEdits(config, model, indentationForSelections, ch, autoClosingPairClose);
+            const autoClosingPair = AutoClosingOpenCharTypeOperation.getAutoClosingPair(config, model, selections, ch, false);
+            return this._getIndentationAndAutoClosingPairEdits(config, model, indentationForSelections, ch, autoClosingPair);
         }
         return;
     }
@@ -62,12 +63,13 @@ export class AutoIndentOperation {
         }
         return actualIndentation;
     }
-    static _getIndentationAndAutoClosingPairEdits(config, model, indentationForSelections, ch, autoClosingPairClose) {
+    static _getIndentationAndAutoClosingPairEdits(config, model, indentationForSelections, ch, autoClosingPair) {
+        const autoCloseWithUndoStop = autoClosingPair !== null && autoClosingPair.open.length > ch.length;
         const commands = indentationForSelections.map(({ selection, indentation }) => {
-            if (autoClosingPairClose !== null) {
+            if (autoClosingPair !== null && !autoCloseWithUndoStop) {
                 // Apply both auto closing pair edits and auto indentation edits
                 const indentationEdit = this._getEditFromIndentationAndSelection(config, model, indentation, selection, ch, false);
-                return new TypeWithIndentationAndAutoClosingCommand(indentationEdit, selection, ch, autoClosingPairClose);
+                return new TypeWithIndentationAndAutoClosingCommand(indentationEdit, selection, ch, autoClosingPair.close);
             }
             else {
                 // Apply only auto indentation edits
@@ -75,6 +77,9 @@ export class AutoIndentOperation {
                 return typeCommand(indentationEdit.range, indentationEdit.text, false);
             }
         });
+        if (autoClosingPair !== null && autoCloseWithUndoStop) {
+            return AutoClosingOpenCharTypeOperation.typeAndAutoCloseWithUndoStop(model, commands, ch, autoClosingPair.close);
+        }
         const editOptions = { shouldPushStackElementBefore: true, shouldPushStackElementAfter: false };
         return new EditOperationResult(4 /* EditOperationType.TypingOther */, commands, editOptions);
     }
@@ -128,25 +133,53 @@ export class AutoClosingOvertypeWithInterceptorsOperation {
 export class AutoClosingOpenCharTypeOperation {
     static getEdits(config, model, selections, ch, chIsAlreadyTyped, isDoingComposition) {
         if (!isDoingComposition) {
-            const autoClosingPairClose = this.getAutoClosingPairClose(config, model, selections, ch, chIsAlreadyTyped);
-            if (autoClosingPairClose !== null) {
-                return this._runAutoClosingOpenCharType(selections, ch, chIsAlreadyTyped, autoClosingPairClose);
+            const autoClosingPair = this.getAutoClosingPair(config, model, selections, ch, chIsAlreadyTyped);
+            if (autoClosingPair !== null) {
+                return this._runAutoClosingOpenCharType(model, selections, ch, chIsAlreadyTyped, autoClosingPair);
             }
         }
         return;
     }
-    static _runAutoClosingOpenCharType(selections, ch, chIsAlreadyTyped, autoClosingPairClose) {
+    static _runAutoClosingOpenCharType(model, selections, ch, chIsAlreadyTyped, autoClosingPair) {
+        if (!chIsAlreadyTyped && autoClosingPair.open.length > ch.length) {
+            return this.typeAndAutoCloseWithUndoStop(model, selections.map(selection => typeCommand(selection, ch, false)), ch, autoClosingPair.close);
+        }
         const commands = [];
         for (let i = 0, len = selections.length; i < len; i++) {
             const selection = selections[i];
-            commands[i] = new TypeWithAutoClosingCommand(selection, ch, !chIsAlreadyTyped, autoClosingPairClose);
+            commands[i] = new TypeWithAutoClosingCommand(selection, ch, !chIsAlreadyTyped, autoClosingPair.close);
         }
         return new EditOperationResult(4 /* EditOperationType.TypingOther */, commands, {
             shouldPushStackElementBefore: true,
             shouldPushStackElementAfter: false
         });
     }
-    static getAutoClosingPairClose(config, model, selections, ch, chIsAlreadyTyped) {
+    /**
+     * Executes `typeCommands`, which type `ch`, and then inserts `autoClosingPairClose` after `ch` with an undo stop in between.
+     * This way, undo first removes only the auto-closed characters and keeps a typed multi-character opening pair (e.g. `begin`).
+     */
+    static typeAndAutoCloseWithUndoStop(model, typeCommands, ch, autoClosingPairClose) {
+        const expectedVersionId = model.getVersionId() + 1;
+        return new EditOperationResult(4 /* EditOperationType.TypingOther */, typeCommands, {
+            shouldPushStackElementBefore: true,
+            shouldPushStackElementAfter: true,
+            followUp: selections => {
+                const canAutoClose = model.getVersionId() === expectedVersionId
+                    && selections.length === typeCommands.length && selections.every(s => s.isEmpty() && s.positionColumn > ch.length && model.getValueInRange(new Range(s.positionLineNumber, s.positionColumn - ch.length, s.positionLineNumber, s.positionColumn)) === ch);
+                if (!canAutoClose) {
+                    return null;
+                }
+                return new EditOperationResult(4 /* EditOperationType.TypingOther */, selections.map(selection => new TypeWithAutoClosingCommand(selection, ch, false, autoClosingPairClose)), {
+                    shouldPushStackElementBefore: false,
+                    shouldPushStackElementAfter: false
+                });
+            }
+        });
+    }
+    /**
+     * Returns the auto-closing pair whose opening ends with `ch`, together with the closing characters to insert.
+     */
+    static getAutoClosingPair(config, model, selections, ch, chIsAlreadyTyped) {
         for (const selection of selections) {
             if (!selection.isEmpty()) {
                 return null;
@@ -265,10 +298,10 @@ export class AutoClosingOpenCharTypeOperation {
             }
         }
         if (isContainedPairPresent) {
-            return pair.close.substring(0, pair.close.length - containedPairClose.length);
+            return { open: pair.open, close: pair.close.substring(0, pair.close.length - containedPairClose.length) };
         }
         else {
-            return pair.close;
+            return { open: pair.open, close: pair.close };
         }
     }
     /**
@@ -318,6 +351,13 @@ export class AutoClosingOpenCharTypeOperation {
                         candidateIsMatch = false;
                         break;
                     }
+                    if (candidate.beforeText) {
+                        const prefix = model.getValueInRange(new Range(position.lineNumber, 1, position.lineNumber, position.column));
+                        if (!candidate.shouldAutoCloseBefore(prefix + ch)) {
+                            candidateIsMatch = false;
+                            break;
+                        }
+                    }
                 }
                 if (candidateIsMatch) {
                     result = candidate;
@@ -615,7 +655,11 @@ export class EnterOperation {
     }
 }
 export class PasteOperation {
-    static getEdits(config, model, selections, text, pasteOnNewLine, multicursorText) {
+    static getEdits(config, model, selections, text, pasteOnNewLine, multicursorText, isBlock = false) {
+        const distributeBlockToCursor = isBlock && config.multiCursorPaste === 'spread' && selections.length === 1;
+        if (distributeBlockToCursor) {
+            return this._blockPaste(config, selections[0], text);
+        }
         const distributedPaste = this._distributePasteToCursors(config, selections, text, pasteOnNewLine, multicursorText);
         if (distributedPaste) {
             selections = selections.sort(Range.compareRangesUsingStarts);
@@ -625,6 +669,15 @@ export class PasteOperation {
             return this._simplePaste(config, model, selections, text, pasteOnNewLine);
         }
     }
+    static _blockPaste(config, selection, text) {
+        const lines = strings.splitLines(text);
+        const shouldOvertypeOnPaste = config.overtypeOnPaste && config.inputMode === 'overtype';
+        const command = new ColumnSelectionPasteCommand(selection, lines, config.tabSize, shouldOvertypeOnPaste);
+        return new EditOperationResult(0 /* EditOperationType.Other */, [command], {
+            shouldPushStackElementBefore: true,
+            shouldPushStackElementAfter: true
+        });
+    }
     static _distributePasteToCursors(config, selections, text, pasteOnNewLine, multicursorText) {
         if (selections.length === 1) {
             return null;