monaco-editor11 1.0.9 → 1.1.0

package/dist/workers/editor/common/cursorTypeOperations.js

@@ -1,173 +0,0 @@
-import { ShiftCommand } from '../commands/shiftCommand.js';
-import { CompositionSurroundSelectionCommand } from '../commands/surroundSelectionCommand.js';
-import { isQuote, EditOperationResult } from '../cursorCommon.js';
-import { PasteOperation, TabOperation, CompositionOperation, CompositionEndOvertypeOperation, shouldSurroundChar, AutoClosingOvertypeWithInterceptorsOperation, AutoClosingOpenCharTypeOperation, EnterOperation, AutoIndentOperation, AutoClosingOvertypeOperation, SurroundSelectionOperation, InterceptorElectricCharOperation, SimpleCharacterTypeOperation, TypeWithoutInterceptorsOperation } from './cursorTypeEditOperations.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-class TypeOperations {
-    static indent(config, model, selections) {
-        if (model === null || selections === null) {
-            return [];
-        }
-        const commands = [];
-        for (let i = 0, len = selections.length; i < len; i++) {
-            commands[i] = new ShiftCommand(selections[i], {
-                isUnshift: false,
-                tabSize: config.tabSize,
-                indentSize: config.indentSize,
-                insertSpaces: config.insertSpaces,
-                useTabStops: config.useTabStops,
-                autoIndent: config.autoIndent
-            }, config.languageConfigurationService);
-        }
-        return commands;
-    }
-    static outdent(config, model, selections) {
-        const commands = [];
-        for (let i = 0, len = selections.length; i < len; i++) {
-            commands[i] = new ShiftCommand(selections[i], {
-                isUnshift: true,
-                tabSize: config.tabSize,
-                indentSize: config.indentSize,
-                insertSpaces: config.insertSpaces,
-                useTabStops: config.useTabStops,
-                autoIndent: config.autoIndent
-            }, config.languageConfigurationService);
-        }
-        return commands;
-    }
-    static paste(config, model, selections, text, pasteOnNewLine, multicursorText) {
-        return PasteOperation.getEdits(config, model, selections, text, pasteOnNewLine, multicursorText);
-    }
-    static tab(config, model, selections) {
-        return TabOperation.getCommands(config, model, selections);
-    }
-    static compositionType(prevEditOperationType, config, model, selections, text, replacePrevCharCnt, replaceNextCharCnt, positionDelta) {
-        return CompositionOperation.getEdits(prevEditOperationType, config, model, selections, text, replacePrevCharCnt, replaceNextCharCnt, positionDelta);
-    }
-    /**
-     * This is very similar with typing, but the character is already in the text buffer!
-     */
-    static compositionEndWithInterceptors(prevEditOperationType, config, model, compositions, selections, autoClosedCharacters) {
-        if (!compositions) {
-            // could not deduce what the composition did
-            return null;
-        }
-        let insertedText = null;
-        for (const composition of compositions) {
-            if (insertedText === null) {
-                insertedText = composition.insertedText;
-            }
-            else if (insertedText !== composition.insertedText) {
-                // not all selections agree on what was typed
-                return null;
-            }
-        }
-        if (!insertedText || insertedText.length !== 1) {
-            // we're only interested in the case where a single character was inserted
-            return CompositionEndOvertypeOperation.getEdits(config, compositions);
-        }
-        const ch = insertedText;
-        let hasDeletion = false;
-        for (const composition of compositions) {
-            if (composition.deletedText.length !== 0) {
-                hasDeletion = true;
-                break;
-            }
-        }
-        if (hasDeletion) {
-            // Check if this could have been a surround selection
-            if (!shouldSurroundChar(config, ch) || !config.surroundingPairs.hasOwnProperty(ch)) {
-                return null;
-            }
-            const isTypingAQuoteCharacter = isQuote(ch);
-            for (const composition of compositions) {
-                if (composition.deletedSelectionStart !== 0 || composition.deletedSelectionEnd !== composition.deletedText.length) {
-                    // more text was deleted than was selected, so this could not have been a surround selection
-                    return null;
-                }
-                if (/^[ \t]+$/.test(composition.deletedText)) {
-                    // deleted text was only whitespace
-                    return null;
-                }
-                if (isTypingAQuoteCharacter && isQuote(composition.deletedText)) {
-                    // deleted text was a quote
-                    return null;
-                }
-            }
-            const positions = [];
-            for (const selection of selections) {
-                if (!selection.isEmpty()) {
-                    return null;
-                }
-                positions.push(selection.getPosition());
-            }
-            if (positions.length !== compositions.length) {
-                return null;
-            }
-            const commands = [];
-            for (let i = 0, len = positions.length; i < len; i++) {
-                commands.push(new CompositionSurroundSelectionCommand(positions[i], compositions[i].deletedText, config.surroundingPairs[ch]));
-            }
-            return new EditOperationResult(4 /* EditOperationType.TypingOther */, commands, {
-                shouldPushStackElementBefore: true,
-                shouldPushStackElementAfter: false
-            });
-        }
-        const autoClosingOvertypeEdits = AutoClosingOvertypeWithInterceptorsOperation.getEdits(config, model, selections, autoClosedCharacters, ch);
-        if (autoClosingOvertypeEdits !== undefined) {
-            return autoClosingOvertypeEdits;
-        }
-        const autoClosingOpenCharEdits = AutoClosingOpenCharTypeOperation.getEdits(config, model, selections, ch, true, false);
-        if (autoClosingOpenCharEdits !== undefined) {
-            return autoClosingOpenCharEdits;
-        }
-        return CompositionEndOvertypeOperation.getEdits(config, compositions);
-    }
-    static typeWithInterceptors(isDoingComposition, prevEditOperationType, config, model, selections, autoClosedCharacters, ch) {
-        const enterEdits = EnterOperation.getEdits(config, model, selections, ch, isDoingComposition);
-        if (enterEdits !== undefined) {
-            return enterEdits;
-        }
-        const autoIndentEdits = AutoIndentOperation.getEdits(config, model, selections, ch, isDoingComposition);
-        if (autoIndentEdits !== undefined) {
-            return autoIndentEdits;
-        }
-        const autoClosingOverTypeEdits = AutoClosingOvertypeOperation.getEdits(prevEditOperationType, config, model, selections, autoClosedCharacters, ch);
-        if (autoClosingOverTypeEdits !== undefined) {
-            return autoClosingOverTypeEdits;
-        }
-        const autoClosingOpenCharEdits = AutoClosingOpenCharTypeOperation.getEdits(config, model, selections, ch, false, isDoingComposition);
-        if (autoClosingOpenCharEdits !== undefined) {
-            return autoClosingOpenCharEdits;
-        }
-        const surroundSelectionEdits = SurroundSelectionOperation.getEdits(config, model, selections, ch, isDoingComposition);
-        if (surroundSelectionEdits !== undefined) {
-            return surroundSelectionEdits;
-        }
-        const interceptorElectricCharOperation = InterceptorElectricCharOperation.getEdits(prevEditOperationType, config, model, selections, ch, isDoingComposition);
-        if (interceptorElectricCharOperation !== undefined) {
-            return interceptorElectricCharOperation;
-        }
-        return SimpleCharacterTypeOperation.getEdits(config, prevEditOperationType, selections, ch, isDoingComposition);
-    }
-    static typeWithoutInterceptors(prevEditOperationType, config, model, selections, str) {
-        return TypeWithoutInterceptorsOperation.getEdits(prevEditOperationType, selections, str);
-    }
-}
-class CompositionOutcome {
-    constructor(deletedText, deletedSelectionStart, deletedSelectionEnd, insertedText, insertedSelectionStart, insertedSelectionEnd, insertedTextRange) {
-        this.deletedText = deletedText;
-        this.deletedSelectionStart = deletedSelectionStart;
-        this.deletedSelectionEnd = deletedSelectionEnd;
-        this.insertedText = insertedText;
-        this.insertedSelectionStart = insertedSelectionStart;
-        this.insertedSelectionEnd = insertedSelectionEnd;
-        this.insertedTextRange = insertedTextRange;
-    }
-}
-
-export { CompositionOutcome, TypeOperations };

package/dist/workers/editor/common/cursorUtils.js

@@ -1,75 +0,0 @@
-function gotoNextSibling(newCursor, oldCursor) {
-    const n = newCursor.gotoNextSibling();
-    const o = oldCursor.gotoNextSibling();
-    if (n !== o) {
-        throw new Error('Trees are out of sync');
-    }
-    return n && o;
-}
-function gotoParent(newCursor, oldCursor) {
-    const n = newCursor.gotoParent();
-    const o = oldCursor.gotoParent();
-    if (n !== o) {
-        throw new Error('Trees are out of sync');
-    }
-    return n && o;
-}
-function gotoNthChild(newCursor, oldCursor, index) {
-    const n = newCursor.gotoFirstChild();
-    const o = oldCursor.gotoFirstChild();
-    if (n !== o) {
-        throw new Error('Trees are out of sync');
-    }
-    if (index === 0) {
-        return n && o;
-    }
-    for (let i = 1; i <= index; i++) {
-        const nn = newCursor.gotoNextSibling();
-        const oo = oldCursor.gotoNextSibling();
-        if (nn !== oo) {
-            throw new Error('Trees are out of sync');
-        }
-        if (!nn || !oo) {
-            return false;
-        }
-    }
-    return n && o;
-}
-function nextSiblingOrParentSibling(newCursor, oldCursor) {
-    do {
-        if (newCursor.currentNode.nextSibling) {
-            return gotoNextSibling(newCursor, oldCursor);
-        }
-        if (newCursor.currentNode.parent) {
-            gotoParent(newCursor, oldCursor);
-        }
-    } while (newCursor.currentNode.nextSibling || newCursor.currentNode.parent);
-    return false;
-}
-function getClosestPreviousNodes(cursor, tree) {
-    // Go up parents until the end of the parent is before the start of the current.
-    const findPrev = tree.walk();
-    findPrev.resetTo(cursor);
-    const startingNode = cursor.currentNode;
-    do {
-        if (findPrev.currentNode.previousSibling && ((findPrev.currentNode.endIndex - findPrev.currentNode.startIndex) !== 0)) {
-            findPrev.gotoPreviousSibling();
-        }
-        else {
-            while (!findPrev.currentNode.previousSibling && findPrev.currentNode.parent) {
-                findPrev.gotoParent();
-            }
-            findPrev.gotoPreviousSibling();
-        }
-    } while ((findPrev.currentNode.endIndex > startingNode.startIndex)
-        && (findPrev.currentNode.parent || findPrev.currentNode.previousSibling)
-        && (findPrev.currentNode.id !== startingNode.id));
-    if ((findPrev.currentNode.id !== startingNode.id) && findPrev.currentNode.endIndex <= startingNode.startIndex) {
-        return findPrev.currentNode;
-    }
-    else {
-        return undefined;
-    }
-}
-
-export { getClosestPreviousNodes, gotoNextSibling, gotoNthChild, gotoParent, nextSiblingOrParentSibling };