monaco-editor11 1.0.7 → 1.0.9

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

@@ -0,0 +1,145 @@
+import { CursorColumns } from '../core/cursorColumns.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class AtomicTabMoveOperations {
+    /**
+     * Get the visible column at the position. If we get to a non-whitespace character first
+     * or past the end of string then return -1.
+     *
+     * **Note** `position` and the return value are 0-based.
+     */
+    static whitespaceVisibleColumn(lineContent, position, tabSize) {
+        const lineLength = lineContent.length;
+        let visibleColumn = 0;
+        let prevTabStopPosition = -1;
+        let prevTabStopVisibleColumn = -1;
+        for (let i = 0; i < lineLength; i++) {
+            if (i === position) {
+                return [prevTabStopPosition, prevTabStopVisibleColumn, visibleColumn];
+            }
+            if (visibleColumn % tabSize === 0) {
+                prevTabStopPosition = i;
+                prevTabStopVisibleColumn = visibleColumn;
+            }
+            const chCode = lineContent.charCodeAt(i);
+            switch (chCode) {
+                case 32 /* CharCode.Space */:
+                    visibleColumn += 1;
+                    break;
+                case 9 /* CharCode.Tab */:
+                    // Skip to the next multiple of tabSize.
+                    visibleColumn = CursorColumns.nextRenderTabStop(visibleColumn, tabSize);
+                    break;
+                default:
+                    return [-1, -1, -1];
+            }
+        }
+        if (position === lineLength) {
+            return [prevTabStopPosition, prevTabStopVisibleColumn, visibleColumn];
+        }
+        return [-1, -1, -1];
+    }
+    /**
+     * Return the position that should result from a move left, right or to the
+     * nearest tab, if atomic tabs are enabled. Left and right are used for the
+     * arrow key movements, nearest is used for mouse selection. It returns
+     * -1 if atomic tabs are not relevant and you should fall back to normal
+     * behaviour.
+     *
+     * **Note**: `position` and the return value are 0-based.
+     */
+    static atomicPosition(lineContent, position, tabSize, direction) {
+        const lineLength = lineContent.length;
+        // Get the 0-based visible column corresponding to the position, or return
+        // -1 if it is not in the initial whitespace.
+        const [prevTabStopPosition, prevTabStopVisibleColumn, visibleColumn] = AtomicTabMoveOperations.whitespaceVisibleColumn(lineContent, position, tabSize);
+        if (visibleColumn === -1) {
+            return -1;
+        }
+        // Is the output left or right of the current position. The case for nearest
+        // where it is the same as the current position is handled in the switch.
+        let left;
+        switch (direction) {
+            case 0 /* Direction.Left */:
+                left = true;
+                break;
+            case 1 /* Direction.Right */:
+                left = false;
+                break;
+            case 2 /* Direction.Nearest */:
+                // The code below assumes the output position is either left or right
+                // of the input position. If it is the same, return immediately.
+                if (visibleColumn % tabSize === 0) {
+                    return position;
+                }
+                // Go to the nearest indentation.
+                left = visibleColumn % tabSize <= (tabSize / 2);
+                break;
+        }
+        // If going left, we can just use the info about the last tab stop position and
+        // last tab stop visible column that we computed in the first walk over the whitespace.
+        if (left) {
+            if (prevTabStopPosition === -1) {
+                return -1;
+            }
+            // If the direction is left, we need to keep scanning right to ensure
+            // that targetVisibleColumn + tabSize is before non-whitespace.
+            // This is so that when we press left at the end of a partial
+            // indentation it only goes one character. For example '      foo' with
+            // tabSize 4, should jump from position 6 to position 5, not 4.
+            let currentVisibleColumn = prevTabStopVisibleColumn;
+            for (let i = prevTabStopPosition; i < lineLength; ++i) {
+                if (currentVisibleColumn === prevTabStopVisibleColumn + tabSize) {
+                    // It is a full indentation.
+                    return prevTabStopPosition;
+                }
+                const chCode = lineContent.charCodeAt(i);
+                switch (chCode) {
+                    case 32 /* CharCode.Space */:
+                        currentVisibleColumn += 1;
+                        break;
+                    case 9 /* CharCode.Tab */:
+                        currentVisibleColumn = CursorColumns.nextRenderTabStop(currentVisibleColumn, tabSize);
+                        break;
+                    default:
+                        return -1;
+                }
+            }
+            if (currentVisibleColumn === prevTabStopVisibleColumn + tabSize) {
+                return prevTabStopPosition;
+            }
+            // It must have been a partial indentation.
+            return -1;
+        }
+        // We are going right.
+        const targetVisibleColumn = CursorColumns.nextRenderTabStop(visibleColumn, tabSize);
+        // We can just continue from where whitespaceVisibleColumn got to.
+        let currentVisibleColumn = visibleColumn;
+        for (let i = position; i < lineLength; i++) {
+            if (currentVisibleColumn === targetVisibleColumn) {
+                return i;
+            }
+            const chCode = lineContent.charCodeAt(i);
+            switch (chCode) {
+                case 32 /* CharCode.Space */:
+                    currentVisibleColumn += 1;
+                    break;
+                case 9 /* CharCode.Tab */:
+                    currentVisibleColumn = CursorColumns.nextRenderTabStop(currentVisibleColumn, tabSize);
+                    break;
+                default:
+                    return -1;
+            }
+        }
+        // This condition handles when the target column is at the end of the line.
+        if (currentVisibleColumn === targetVisibleColumn) {
+            return lineLength;
+        }
+        return -1;
+    }
+}
+
+export { AtomicTabMoveOperations };

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

@@ -0,0 +1,194 @@
+import { compareBy } from '../../../base/common/arrays.js';
+import { findFirstMin, findLastMax } from '../../../base/common/arraysFind.js';
+import { CursorState } from '../cursorCommon.js';
+import { Cursor } from './oneCursor.js';
+import { Position } from '../core/position.js';
+import { Range } from '../core/range.js';
+import { Selection } from '../core/selection.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class CursorCollection {
+    constructor(context) {
+        this.context = context;
+        this.cursors = [new Cursor(context)];
+        this.lastAddedCursorIndex = 0;
+    }
+    dispose() {
+        for (const cursor of this.cursors) {
+            cursor.dispose(this.context);
+        }
+    }
+    startTrackingSelections() {
+        for (const cursor of this.cursors) {
+            cursor.startTrackingSelection(this.context);
+        }
+    }
+    stopTrackingSelections() {
+        for (const cursor of this.cursors) {
+            cursor.stopTrackingSelection(this.context);
+        }
+    }
+    updateContext(context) {
+        this.context = context;
+    }
+    ensureValidState() {
+        for (const cursor of this.cursors) {
+            cursor.ensureValidState(this.context);
+        }
+    }
+    readSelectionFromMarkers() {
+        return this.cursors.map(c => c.readSelectionFromMarkers(this.context));
+    }
+    getAll() {
+        return this.cursors.map(c => c.asCursorState());
+    }
+    getViewPositions() {
+        return this.cursors.map(c => c.viewState.position);
+    }
+    getTopMostViewPosition() {
+        return findFirstMin(this.cursors, compareBy(c => c.viewState.position, Position.compare)).viewState.position;
+    }
+    getBottomMostViewPosition() {
+        return findLastMax(this.cursors, compareBy(c => c.viewState.position, Position.compare)).viewState.position;
+    }
+    getSelections() {
+        return this.cursors.map(c => c.modelState.selection);
+    }
+    getViewSelections() {
+        return this.cursors.map(c => c.viewState.selection);
+    }
+    setSelections(selections) {
+        this.setStates(CursorState.fromModelSelections(selections));
+    }
+    getPrimaryCursor() {
+        return this.cursors[0].asCursorState();
+    }
+    setStates(states) {
+        if (states === null) {
+            return;
+        }
+        this.cursors[0].setState(this.context, states[0].modelState, states[0].viewState);
+        this._setSecondaryStates(states.slice(1));
+    }
+    /**
+     * Creates or disposes secondary cursors as necessary to match the number of `secondarySelections`.
+     */
+    _setSecondaryStates(secondaryStates) {
+        const secondaryCursorsLength = this.cursors.length - 1;
+        const secondaryStatesLength = secondaryStates.length;
+        if (secondaryCursorsLength < secondaryStatesLength) {
+            const createCnt = secondaryStatesLength - secondaryCursorsLength;
+            for (let i = 0; i < createCnt; i++) {
+                this._addSecondaryCursor();
+            }
+        }
+        else if (secondaryCursorsLength > secondaryStatesLength) {
+            const removeCnt = secondaryCursorsLength - secondaryStatesLength;
+            for (let i = 0; i < removeCnt; i++) {
+                this._removeSecondaryCursor(this.cursors.length - 2);
+            }
+        }
+        for (let i = 0; i < secondaryStatesLength; i++) {
+            this.cursors[i + 1].setState(this.context, secondaryStates[i].modelState, secondaryStates[i].viewState);
+        }
+    }
+    killSecondaryCursors() {
+        this._setSecondaryStates([]);
+    }
+    _addSecondaryCursor() {
+        this.cursors.push(new Cursor(this.context));
+        this.lastAddedCursorIndex = this.cursors.length - 1;
+    }
+    getLastAddedCursorIndex() {
+        if (this.cursors.length === 1 || this.lastAddedCursorIndex === 0) {
+            return 0;
+        }
+        return this.lastAddedCursorIndex;
+    }
+    _removeSecondaryCursor(removeIndex) {
+        if (this.lastAddedCursorIndex >= removeIndex + 1) {
+            this.lastAddedCursorIndex--;
+        }
+        this.cursors[removeIndex + 1].dispose(this.context);
+        this.cursors.splice(removeIndex + 1, 1);
+    }
+    normalize() {
+        if (this.cursors.length === 1) {
+            return;
+        }
+        const cursors = this.cursors.slice(0);
+        const sortedCursors = [];
+        for (let i = 0, len = cursors.length; i < len; i++) {
+            sortedCursors.push({
+                index: i,
+                selection: cursors[i].modelState.selection,
+            });
+        }
+        sortedCursors.sort(compareBy(s => s.selection, Range.compareRangesUsingStarts));
+        for (let sortedCursorIndex = 0; sortedCursorIndex < sortedCursors.length - 1; sortedCursorIndex++) {
+            const current = sortedCursors[sortedCursorIndex];
+            const next = sortedCursors[sortedCursorIndex + 1];
+            const currentSelection = current.selection;
+            const nextSelection = next.selection;
+            if (!this.context.cursorConfig.multiCursorMergeOverlapping) {
+                continue;
+            }
+            let shouldMergeCursors;
+            if (nextSelection.isEmpty() || currentSelection.isEmpty()) {
+                // Merge touching cursors if one of them is collapsed
+                shouldMergeCursors = nextSelection.getStartPosition().isBeforeOrEqual(currentSelection.getEndPosition());
+            }
+            else {
+                // Merge only overlapping cursors (i.e. allow touching ranges)
+                shouldMergeCursors = nextSelection.getStartPosition().isBefore(currentSelection.getEndPosition());
+            }
+            if (shouldMergeCursors) {
+                const winnerSortedCursorIndex = current.index < next.index ? sortedCursorIndex : sortedCursorIndex + 1;
+                const looserSortedCursorIndex = current.index < next.index ? sortedCursorIndex + 1 : sortedCursorIndex;
+                const looserIndex = sortedCursors[looserSortedCursorIndex].index;
+                const winnerIndex = sortedCursors[winnerSortedCursorIndex].index;
+                const looserSelection = sortedCursors[looserSortedCursorIndex].selection;
+                const winnerSelection = sortedCursors[winnerSortedCursorIndex].selection;
+                if (!looserSelection.equalsSelection(winnerSelection)) {
+                    const resultingRange = looserSelection.plusRange(winnerSelection);
+                    const looserSelectionIsLTR = (looserSelection.selectionStartLineNumber === looserSelection.startLineNumber && looserSelection.selectionStartColumn === looserSelection.startColumn);
+                    const winnerSelectionIsLTR = (winnerSelection.selectionStartLineNumber === winnerSelection.startLineNumber && winnerSelection.selectionStartColumn === winnerSelection.startColumn);
+                    // Give more importance to the last added cursor (think Ctrl-dragging + hitting another cursor)
+                    let resultingSelectionIsLTR;
+                    if (looserIndex === this.lastAddedCursorIndex) {
+                        resultingSelectionIsLTR = looserSelectionIsLTR;
+                        this.lastAddedCursorIndex = winnerIndex;
+                    }
+                    else {
+                        // Winner takes it all
+                        resultingSelectionIsLTR = winnerSelectionIsLTR;
+                    }
+                    let resultingSelection;
+                    if (resultingSelectionIsLTR) {
+                        resultingSelection = new Selection(resultingRange.startLineNumber, resultingRange.startColumn, resultingRange.endLineNumber, resultingRange.endColumn);
+                    }
+                    else {
+                        resultingSelection = new Selection(resultingRange.endLineNumber, resultingRange.endColumn, resultingRange.startLineNumber, resultingRange.startColumn);
+                    }
+                    sortedCursors[winnerSortedCursorIndex].selection = resultingSelection;
+                    const resultingState = CursorState.fromModelSelection(resultingSelection);
+                    cursors[winnerIndex].setState(this.context, resultingState.modelState, resultingState.viewState);
+                }
+                for (const sortedCursor of sortedCursors) {
+                    if (sortedCursor.index > looserIndex) {
+                        sortedCursor.index--;
+                    }
+                }
+                cursors.splice(looserIndex, 1);
+                sortedCursors.splice(looserSortedCursorIndex, 1);
+                this._removeSecondaryCursor(looserIndex - 1);
+                sortedCursorIndex--;
+            }
+        }
+    }
+}
+
+export { CursorCollection };

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

@@ -0,0 +1,93 @@
+import { SingleCursorState } from '../cursorCommon.js';
+import { Position } from '../core/position.js';
+import { Range } from '../core/range.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class ColumnSelection {
+    static columnSelect(config, model, fromLineNumber, fromVisibleColumn, toLineNumber, toVisibleColumn) {
+        const lineCount = Math.abs(toLineNumber - fromLineNumber) + 1;
+        const reversed = (fromLineNumber > toLineNumber);
+        const isRTL = (fromVisibleColumn > toVisibleColumn);
+        const isLTR = (fromVisibleColumn < toVisibleColumn);
+        const result = [];
+        // console.log(`fromVisibleColumn: ${fromVisibleColumn}, toVisibleColumn: ${toVisibleColumn}`);
+        for (let i = 0; i < lineCount; i++) {
+            const lineNumber = fromLineNumber + (reversed ? -i : i);
+            const startColumn = config.columnFromVisibleColumn(model, lineNumber, fromVisibleColumn);
+            const endColumn = config.columnFromVisibleColumn(model, lineNumber, toVisibleColumn);
+            const visibleStartColumn = config.visibleColumnFromColumn(model, new Position(lineNumber, startColumn));
+            const visibleEndColumn = config.visibleColumnFromColumn(model, new Position(lineNumber, endColumn));
+            // console.log(`lineNumber: ${lineNumber}: visibleStartColumn: ${visibleStartColumn}, visibleEndColumn: ${visibleEndColumn}`);
+            if (isLTR) {
+                if (visibleStartColumn > toVisibleColumn) {
+                    continue;
+                }
+                if (visibleEndColumn < fromVisibleColumn) {
+                    continue;
+                }
+            }
+            if (isRTL) {
+                if (visibleEndColumn > fromVisibleColumn) {
+                    continue;
+                }
+                if (visibleStartColumn < toVisibleColumn) {
+                    continue;
+                }
+            }
+            result.push(new SingleCursorState(new Range(lineNumber, startColumn, lineNumber, startColumn), 0 /* SelectionStartKind.Simple */, 0, new Position(lineNumber, endColumn), 0));
+        }
+        if (result.length === 0) {
+            // We are after all the lines, so add cursor at the end of each line
+            for (let i = 0; i < lineCount; i++) {
+                const lineNumber = fromLineNumber + (reversed ? -i : i);
+                const maxColumn = model.getLineMaxColumn(lineNumber);
+                result.push(new SingleCursorState(new Range(lineNumber, maxColumn, lineNumber, maxColumn), 0 /* SelectionStartKind.Simple */, 0, new Position(lineNumber, maxColumn), 0));
+            }
+        }
+        return {
+            viewStates: result,
+            reversed: reversed,
+            fromLineNumber: fromLineNumber,
+            fromVisualColumn: fromVisibleColumn,
+            toLineNumber: toLineNumber,
+            toVisualColumn: toVisibleColumn
+        };
+    }
+    static columnSelectLeft(config, model, prevColumnSelectData) {
+        let toViewVisualColumn = prevColumnSelectData.toViewVisualColumn;
+        if (toViewVisualColumn > 0) {
+            toViewVisualColumn--;
+        }
+        return ColumnSelection.columnSelect(config, model, prevColumnSelectData.fromViewLineNumber, prevColumnSelectData.fromViewVisualColumn, prevColumnSelectData.toViewLineNumber, toViewVisualColumn);
+    }
+    static columnSelectRight(config, model, prevColumnSelectData) {
+        let maxVisualViewColumn = 0;
+        const minViewLineNumber = Math.min(prevColumnSelectData.fromViewLineNumber, prevColumnSelectData.toViewLineNumber);
+        const maxViewLineNumber = Math.max(prevColumnSelectData.fromViewLineNumber, prevColumnSelectData.toViewLineNumber);
+        for (let lineNumber = minViewLineNumber; lineNumber <= maxViewLineNumber; lineNumber++) {
+            const lineMaxViewColumn = model.getLineMaxColumn(lineNumber);
+            const lineMaxVisualViewColumn = config.visibleColumnFromColumn(model, new Position(lineNumber, lineMaxViewColumn));
+            maxVisualViewColumn = Math.max(maxVisualViewColumn, lineMaxVisualViewColumn);
+        }
+        let toViewVisualColumn = prevColumnSelectData.toViewVisualColumn;
+        if (toViewVisualColumn < maxVisualViewColumn) {
+            toViewVisualColumn++;
+        }
+        return this.columnSelect(config, model, prevColumnSelectData.fromViewLineNumber, prevColumnSelectData.fromViewVisualColumn, prevColumnSelectData.toViewLineNumber, toViewVisualColumn);
+    }
+    static columnSelectUp(config, model, prevColumnSelectData, isPaged) {
+        const linesCount = isPaged ? config.pageSize : 1;
+        const toViewLineNumber = Math.max(1, prevColumnSelectData.toViewLineNumber - linesCount);
+        return this.columnSelect(config, model, prevColumnSelectData.fromViewLineNumber, prevColumnSelectData.fromViewVisualColumn, toViewLineNumber, prevColumnSelectData.toViewVisualColumn);
+    }
+    static columnSelectDown(config, model, prevColumnSelectData, isPaged) {
+        const linesCount = isPaged ? config.pageSize : 1;
+        const toViewLineNumber = Math.min(model.getLineCount(), prevColumnSelectData.toViewLineNumber + linesCount);
+        return this.columnSelect(config, model, prevColumnSelectData.fromViewLineNumber, prevColumnSelectData.fromViewVisualColumn, toViewLineNumber, prevColumnSelectData.toViewVisualColumn);
+    }
+}
+
+export { ColumnSelection };

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

@@ -0,0 +1,112 @@
+import { isFullWidthCharacter, isEmojiImprecise, GraphemeIterator, getNextCodePoint } from '../../../base/common/strings.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * A column in a position is the gap between two adjacent characters. The methods here
+ * work with a concept called "visible column". A visible column is a very rough approximation
+ * of the horizontal screen position of a column. For example, using a tab size of 4:
+ * ```txt
+ * |<TAB>|<TAB>|T|ext
+ * |     |     | \---- column = 4, visible column = 9
+ * |     |     \------ column = 3, visible column = 8
+ * |     \------------ column = 2, visible column = 4
+ * \------------------ column = 1, visible column = 0
+ * ```
+ *
+ * **NOTE**: Visual columns do not work well for RTL text or variable-width fonts or characters.
+ *
+ * **NOTE**: These methods work and make sense both on the model and on the view model.
+ */
+class CursorColumns {
+    static _nextVisibleColumn(codePoint, visibleColumn, tabSize) {
+        if (codePoint === 9 /* CharCode.Tab */) {
+            return CursorColumns.nextRenderTabStop(visibleColumn, tabSize);
+        }
+        if (isFullWidthCharacter(codePoint) || isEmojiImprecise(codePoint)) {
+            return visibleColumn + 2;
+        }
+        return visibleColumn + 1;
+    }
+    /**
+     * Returns a visible column from a column.
+     * @see {@link CursorColumns}
+     */
+    static visibleColumnFromColumn(lineContent, column, tabSize) {
+        const textLen = Math.min(column - 1, lineContent.length);
+        const text = lineContent.substring(0, textLen);
+        const iterator = new GraphemeIterator(text);
+        let result = 0;
+        while (!iterator.eol()) {
+            const codePoint = getNextCodePoint(text, textLen, iterator.offset);
+            iterator.nextGraphemeLength();
+            result = this._nextVisibleColumn(codePoint, result, tabSize);
+        }
+        return result;
+    }
+    /**
+     * Returns a column from a visible column.
+     * @see {@link CursorColumns}
+     */
+    static columnFromVisibleColumn(lineContent, visibleColumn, tabSize) {
+        if (visibleColumn <= 0) {
+            return 1;
+        }
+        const lineContentLength = lineContent.length;
+        const iterator = new GraphemeIterator(lineContent);
+        let beforeVisibleColumn = 0;
+        let beforeColumn = 1;
+        while (!iterator.eol()) {
+            const codePoint = getNextCodePoint(lineContent, lineContentLength, iterator.offset);
+            iterator.nextGraphemeLength();
+            const afterVisibleColumn = this._nextVisibleColumn(codePoint, beforeVisibleColumn, tabSize);
+            const afterColumn = iterator.offset + 1;
+            if (afterVisibleColumn >= visibleColumn) {
+                const beforeDelta = visibleColumn - beforeVisibleColumn;
+                const afterDelta = afterVisibleColumn - visibleColumn;
+                if (afterDelta < beforeDelta) {
+                    return afterColumn;
+                }
+                else {
+                    return beforeColumn;
+                }
+            }
+            beforeVisibleColumn = afterVisibleColumn;
+            beforeColumn = afterColumn;
+        }
+        // walked the entire string
+        return lineContentLength + 1;
+    }
+    /**
+     * ATTENTION: This works with 0-based columns (as opposed to the regular 1-based columns)
+     * @see {@link CursorColumns}
+     */
+    static nextRenderTabStop(visibleColumn, tabSize) {
+        return visibleColumn + tabSize - visibleColumn % tabSize;
+    }
+    /**
+     * ATTENTION: This works with 0-based columns (as opposed to the regular 1-based columns)
+     * @see {@link CursorColumns}
+     */
+    static nextIndentTabStop(visibleColumn, indentSize) {
+        return CursorColumns.nextRenderTabStop(visibleColumn, indentSize);
+    }
+    /**
+     * ATTENTION: This works with 0-based columns (as opposed to the regular 1-based columns)
+     * @see {@link CursorColumns}
+     */
+    static prevRenderTabStop(column, tabSize) {
+        return Math.max(0, column - 1 - (column - 1) % tabSize);
+    }
+    /**
+     * ATTENTION: This works with 0-based columns (as opposed to the regular 1-based columns)
+     * @see {@link CursorColumns}
+     */
+    static prevIndentTabStop(column, indentSize) {
+        return CursorColumns.prevRenderTabStop(column, indentSize);
+    }
+}
+
+export { CursorColumns };