@codingame/monaco-vscode-api 16.1.1 → 17.1.0

package/vscode/src/vs/editor/common/viewLayout/lineHeights.d.ts

@@ -0,0 +1,35 @@
+export declare class CustomLine {
+    index: number;
+    lineNumber: number;
+    specialHeight: number;
+    prefixSum: number;
+    maximumSpecialHeight: number;
+    decorationId: string;
+    deleted: boolean;
+    constructor(decorationId: string, index: number, lineNumber: number, specialHeight: number, prefixSum: number);
+}
+export declare class LineHeightsManager {
+    private _decorationIDToCustomLine;
+    private _orderedCustomLines;
+    private _pendingSpecialLinesToInsert;
+    private _invalidIndex;
+    private _defaultLineHeight;
+    private _hasPending;
+    constructor(defaultLineHeight: number, customLineHeightData: ICustomLineHeightData[]);
+    set defaultLineHeight(defaultLineHeight: number);
+    get defaultLineHeight(): number;
+    removeCustomLineHeight(decorationID: string): void;
+    insertOrChangeCustomLineHeight(decorationId: string, startLineNumber: number, endLineNumber: number, lineHeight: number): void;
+    heightForLineNumber(lineNumber: number): number;
+    getAccumulatedLineHeightsIncludingLineNumber(lineNumber: number): number;
+    onLinesDeleted(fromLineNumber: number, toLineNumber: number): void;
+    onLinesInserted(fromLineNumber: number, toLineNumber: number): void;
+    commit(): void;
+    private _binarySearchOverOrderedCustomLinesArray;
+}
+export interface ICustomLineHeightData {
+    readonly decorationId: string;
+    readonly startLineNumber: number;
+    readonly endLineNumber: number;
+    readonly lineHeight: number;
+}

package/vscode/src/vs/editor/common/viewLayout/lineHeights.js

@@ -0,0 +1,339 @@
+
+import { binarySearch2 } from '../../../base/common/arrays.js';
+import { intersection } from '../../../base/common/collections.js';
+
+class CustomLine {
+    constructor(decorationId, index, lineNumber, specialHeight, prefixSum) {
+        this.decorationId = decorationId;
+        this.index = index;
+        this.lineNumber = lineNumber;
+        this.specialHeight = specialHeight;
+        this.prefixSum = prefixSum;
+        this.maximumSpecialHeight = specialHeight;
+        this.deleted = false;
+    }
+}
+class LineHeightsManager {
+    constructor(defaultLineHeight, customLineHeightData) {
+        this._decorationIDToCustomLine = ( new ArrayMap());
+        this._orderedCustomLines = [];
+        this._pendingSpecialLinesToInsert = [];
+        this._invalidIndex = 0;
+        this._hasPending = false;
+        this._defaultLineHeight = defaultLineHeight;
+        if (customLineHeightData.length > 0) {
+            for (const data of customLineHeightData) {
+                this.insertOrChangeCustomLineHeight(data.decorationId, data.startLineNumber, data.endLineNumber, data.lineHeight);
+            }
+            this.commit();
+        }
+    }
+    set defaultLineHeight(defaultLineHeight) {
+        this._defaultLineHeight = defaultLineHeight;
+    }
+    get defaultLineHeight() {
+        return this._defaultLineHeight;
+    }
+    removeCustomLineHeight(decorationID) {
+        const customLines = this._decorationIDToCustomLine.get(decorationID);
+        if (!customLines) {
+            return;
+        }
+        this._decorationIDToCustomLine.delete(decorationID);
+        for (const customLine of customLines) {
+            customLine.deleted = true;
+            this._invalidIndex = Math.min(this._invalidIndex, customLine.index);
+        }
+        this._hasPending = true;
+    }
+    insertOrChangeCustomLineHeight(decorationId, startLineNumber, endLineNumber, lineHeight) {
+        this.removeCustomLineHeight(decorationId);
+        for (let lineNumber = startLineNumber; lineNumber <= endLineNumber; lineNumber++) {
+            const customLine = ( new CustomLine(decorationId, -1, lineNumber, lineHeight, 0));
+            this._pendingSpecialLinesToInsert.push(customLine);
+        }
+        this._hasPending = true;
+    }
+    heightForLineNumber(lineNumber) {
+        const searchIndex = this._binarySearchOverOrderedCustomLinesArray(lineNumber);
+        if (searchIndex >= 0) {
+            return this._orderedCustomLines[searchIndex].maximumSpecialHeight;
+        }
+        return this._defaultLineHeight;
+    }
+    getAccumulatedLineHeightsIncludingLineNumber(lineNumber) {
+        const searchIndex = this._binarySearchOverOrderedCustomLinesArray(lineNumber);
+        if (searchIndex >= 0) {
+            return this._orderedCustomLines[searchIndex].prefixSum + this._orderedCustomLines[searchIndex].maximumSpecialHeight;
+        }
+        if (searchIndex === -1) {
+            return this._defaultLineHeight * lineNumber;
+        }
+        const modifiedIndex = -(searchIndex + 1);
+        const previousSpecialLine = this._orderedCustomLines[modifiedIndex - 1];
+        return previousSpecialLine.prefixSum + previousSpecialLine.maximumSpecialHeight + this._defaultLineHeight * (lineNumber - previousSpecialLine.lineNumber);
+    }
+    onLinesDeleted(fromLineNumber, toLineNumber) {
+        const deleteCount = toLineNumber - fromLineNumber + 1;
+        const numberOfCustomLines = this._orderedCustomLines.length;
+        const candidateStartIndexOfDeletion = this._binarySearchOverOrderedCustomLinesArray(fromLineNumber);
+        let startIndexOfDeletion;
+        if (candidateStartIndexOfDeletion >= 0) {
+            startIndexOfDeletion = candidateStartIndexOfDeletion;
+            for (let i = candidateStartIndexOfDeletion - 1; i >= 0; i--) {
+                if (this._orderedCustomLines[i].lineNumber === fromLineNumber) {
+                    startIndexOfDeletion--;
+                }
+                else {
+                    break;
+                }
+            }
+        }
+        else {
+            startIndexOfDeletion = candidateStartIndexOfDeletion === -(numberOfCustomLines + 1) && candidateStartIndexOfDeletion !== -1 ? numberOfCustomLines - 1 : -(candidateStartIndexOfDeletion + 1);
+        }
+        const candidateEndIndexOfDeletion = this._binarySearchOverOrderedCustomLinesArray(toLineNumber);
+        let endIndexOfDeletion;
+        if (candidateEndIndexOfDeletion >= 0) {
+            endIndexOfDeletion = candidateEndIndexOfDeletion;
+            for (let i = candidateEndIndexOfDeletion + 1; i < numberOfCustomLines; i++) {
+                if (this._orderedCustomLines[i].lineNumber === toLineNumber) {
+                    endIndexOfDeletion++;
+                }
+                else {
+                    break;
+                }
+            }
+        }
+        else {
+            endIndexOfDeletion = candidateEndIndexOfDeletion === -(numberOfCustomLines + 1) && candidateEndIndexOfDeletion !== -1 ? numberOfCustomLines - 1 : -(candidateEndIndexOfDeletion + 1);
+        }
+        const isEndIndexBiggerThanStartIndex = endIndexOfDeletion > startIndexOfDeletion;
+        const isEndIndexEqualToStartIndexAndCoversCustomLine = endIndexOfDeletion === startIndexOfDeletion
+            && this._orderedCustomLines[startIndexOfDeletion]
+            && this._orderedCustomLines[startIndexOfDeletion].lineNumber >= fromLineNumber
+            && this._orderedCustomLines[startIndexOfDeletion].lineNumber <= toLineNumber;
+        if (isEndIndexBiggerThanStartIndex || isEndIndexEqualToStartIndexAndCoversCustomLine) {
+            let maximumSpecialHeightOnDeletedInterval = 0;
+            for (let i = startIndexOfDeletion; i <= endIndexOfDeletion; i++) {
+                maximumSpecialHeightOnDeletedInterval = Math.max(maximumSpecialHeightOnDeletedInterval, this._orderedCustomLines[i].maximumSpecialHeight);
+            }
+            let prefixSumOnDeletedInterval = 0;
+            if (startIndexOfDeletion > 0) {
+                const previousSpecialLine = this._orderedCustomLines[startIndexOfDeletion - 1];
+                prefixSumOnDeletedInterval = previousSpecialLine.prefixSum + previousSpecialLine.maximumSpecialHeight + this._defaultLineHeight * (fromLineNumber - previousSpecialLine.lineNumber - 1);
+            }
+            else {
+                prefixSumOnDeletedInterval = fromLineNumber > 0 ? (fromLineNumber - 1) * this._defaultLineHeight : 0;
+            }
+            const firstSpecialLineDeleted = this._orderedCustomLines[startIndexOfDeletion];
+            const lastSpecialLineDeleted = this._orderedCustomLines[endIndexOfDeletion];
+            const firstSpecialLineAfterDeletion = this._orderedCustomLines[endIndexOfDeletion + 1];
+            const heightOfFirstLineAfterDeletion = firstSpecialLineAfterDeletion && firstSpecialLineAfterDeletion.lineNumber === toLineNumber + 1 ? firstSpecialLineAfterDeletion.maximumSpecialHeight : this._defaultLineHeight;
+            const totalHeightDeleted = lastSpecialLineDeleted.prefixSum
+                + lastSpecialLineDeleted.maximumSpecialHeight
+                - firstSpecialLineDeleted.prefixSum
+                + this._defaultLineHeight * (toLineNumber - lastSpecialLineDeleted.lineNumber)
+                + this._defaultLineHeight * (firstSpecialLineDeleted.lineNumber - fromLineNumber)
+                + heightOfFirstLineAfterDeletion - maximumSpecialHeightOnDeletedInterval;
+            const decorationIdsSeen = ( new Set());
+            const newOrderedCustomLines = [];
+            const newDecorationIDToSpecialLine = ( new ArrayMap());
+            let numberOfDeletions = 0;
+            for (let i = 0; i < this._orderedCustomLines.length; i++) {
+                const customLine = this._orderedCustomLines[i];
+                if (i < startIndexOfDeletion) {
+                    newOrderedCustomLines.push(customLine);
+                    newDecorationIDToSpecialLine.add(customLine.decorationId, customLine);
+                }
+                else if (i >= startIndexOfDeletion && i <= endIndexOfDeletion) {
+                    const decorationId = customLine.decorationId;
+                    if (!( decorationIdsSeen.has(decorationId))) {
+                        customLine.index -= numberOfDeletions;
+                        customLine.lineNumber = fromLineNumber;
+                        customLine.prefixSum = prefixSumOnDeletedInterval;
+                        customLine.maximumSpecialHeight = maximumSpecialHeightOnDeletedInterval;
+                        newOrderedCustomLines.push(customLine);
+                        newDecorationIDToSpecialLine.add(customLine.decorationId, customLine);
+                    }
+                    else {
+                        numberOfDeletions++;
+                    }
+                }
+                else if (i > endIndexOfDeletion) {
+                    customLine.index -= numberOfDeletions;
+                    customLine.lineNumber -= deleteCount;
+                    customLine.prefixSum -= totalHeightDeleted;
+                    newOrderedCustomLines.push(customLine);
+                    newDecorationIDToSpecialLine.add(customLine.decorationId, customLine);
+                }
+                decorationIdsSeen.add(customLine.decorationId);
+            }
+            this._orderedCustomLines = newOrderedCustomLines;
+            this._decorationIDToCustomLine = newDecorationIDToSpecialLine;
+        }
+        else {
+            const totalHeightDeleted = deleteCount * this._defaultLineHeight;
+            for (let i = endIndexOfDeletion; i < this._orderedCustomLines.length; i++) {
+                const customLine = this._orderedCustomLines[i];
+                customLine.lineNumber -= deleteCount;
+                customLine.prefixSum -= totalHeightDeleted;
+            }
+        }
+    }
+    onLinesInserted(fromLineNumber, toLineNumber) {
+        const insertCount = toLineNumber - fromLineNumber + 1;
+        const candidateStartIndexOfInsertion = this._binarySearchOverOrderedCustomLinesArray(fromLineNumber);
+        let startIndexOfInsertion;
+        if (candidateStartIndexOfInsertion >= 0) {
+            startIndexOfInsertion = candidateStartIndexOfInsertion;
+            for (let i = candidateStartIndexOfInsertion - 1; i >= 0; i--) {
+                if (this._orderedCustomLines[i].lineNumber === fromLineNumber) {
+                    startIndexOfInsertion--;
+                }
+                else {
+                    break;
+                }
+            }
+        }
+        else {
+            startIndexOfInsertion = -(candidateStartIndexOfInsertion + 1);
+        }
+        const toReAdd = [];
+        const decorationsImmediatelyAfter = ( new Set());
+        for (let i = startIndexOfInsertion; i < this._orderedCustomLines.length; i++) {
+            if (this._orderedCustomLines[i].lineNumber === fromLineNumber) {
+                decorationsImmediatelyAfter.add(this._orderedCustomLines[i].decorationId);
+            }
+        }
+        const decorationsImmediatelyBefore = ( new Set());
+        for (let i = startIndexOfInsertion - 1; i >= 0; i--) {
+            if (this._orderedCustomLines[i].lineNumber === fromLineNumber - 1) {
+                decorationsImmediatelyBefore.add(this._orderedCustomLines[i].decorationId);
+            }
+        }
+        const decorationsWithGaps = intersection(decorationsImmediatelyBefore, decorationsImmediatelyAfter);
+        for (let i = startIndexOfInsertion; i < this._orderedCustomLines.length; i++) {
+            this._orderedCustomLines[i].lineNumber += insertCount;
+            this._orderedCustomLines[i].prefixSum += this._defaultLineHeight * insertCount;
+        }
+        if (decorationsWithGaps.size > 0) {
+            for (const decorationId of decorationsWithGaps) {
+                const decoration = this._decorationIDToCustomLine.get(decorationId);
+                if (decoration) {
+                    const startLineNumber = decoration.reduce((min, l) => Math.min(min, l.lineNumber), fromLineNumber);
+                    const endLineNumber = decoration.reduce((max, l) => Math.max(max, l.lineNumber), fromLineNumber);
+                    const lineHeight = decoration.reduce((max, l) => Math.max(max, l.specialHeight), 0);
+                    toReAdd.push({
+                        decorationId,
+                        startLineNumber,
+                        endLineNumber,
+                        lineHeight
+                    });
+                }
+            }
+            for (const dec of toReAdd) {
+                this.insertOrChangeCustomLineHeight(dec.decorationId, dec.startLineNumber, dec.endLineNumber, dec.lineHeight);
+            }
+            this.commit();
+        }
+    }
+    commit() {
+        if (!this._hasPending) {
+            return;
+        }
+        for (const pendingChange of this._pendingSpecialLinesToInsert) {
+            const candidateInsertionIndex = this._binarySearchOverOrderedCustomLinesArray(pendingChange.lineNumber);
+            const insertionIndex = candidateInsertionIndex >= 0 ? candidateInsertionIndex : -(candidateInsertionIndex + 1);
+            this._orderedCustomLines.splice(insertionIndex, 0, pendingChange);
+            this._invalidIndex = Math.min(this._invalidIndex, insertionIndex);
+        }
+        this._pendingSpecialLinesToInsert = [];
+        const newDecorationIDToSpecialLine = ( new ArrayMap());
+        const newOrderedSpecialLines = [];
+        for (let i = 0; i < this._invalidIndex; i++) {
+            const customLine = this._orderedCustomLines[i];
+            newOrderedSpecialLines.push(customLine);
+            newDecorationIDToSpecialLine.add(customLine.decorationId, customLine);
+        }
+        let numberOfDeletions = 0;
+        let previousSpecialLine = (this._invalidIndex > 0) ? newOrderedSpecialLines[this._invalidIndex - 1] : undefined;
+        for (let i = this._invalidIndex; i < this._orderedCustomLines.length; i++) {
+            const customLine = this._orderedCustomLines[i];
+            if (customLine.deleted) {
+                numberOfDeletions++;
+                continue;
+            }
+            customLine.index = i - numberOfDeletions;
+            if (previousSpecialLine && previousSpecialLine.lineNumber === customLine.lineNumber) {
+                customLine.maximumSpecialHeight = previousSpecialLine.maximumSpecialHeight;
+                customLine.prefixSum = previousSpecialLine.prefixSum;
+            }
+            else {
+                let maximumSpecialHeight = customLine.specialHeight;
+                for (let j = i; j < this._orderedCustomLines.length; j++) {
+                    const nextSpecialLine = this._orderedCustomLines[j];
+                    if (nextSpecialLine.deleted) {
+                        continue;
+                    }
+                    if (nextSpecialLine.lineNumber !== customLine.lineNumber) {
+                        break;
+                    }
+                    maximumSpecialHeight = Math.max(maximumSpecialHeight, nextSpecialLine.specialHeight);
+                }
+                customLine.maximumSpecialHeight = maximumSpecialHeight;
+                let prefixSum;
+                if (previousSpecialLine) {
+                    prefixSum = previousSpecialLine.prefixSum + previousSpecialLine.maximumSpecialHeight + this._defaultLineHeight * (customLine.lineNumber - previousSpecialLine.lineNumber - 1);
+                }
+                else {
+                    prefixSum = this._defaultLineHeight * (customLine.lineNumber - 1);
+                }
+                customLine.prefixSum = prefixSum;
+            }
+            previousSpecialLine = customLine;
+            newOrderedSpecialLines.push(customLine);
+            newDecorationIDToSpecialLine.add(customLine.decorationId, customLine);
+        }
+        this._orderedCustomLines = newOrderedSpecialLines;
+        this._decorationIDToCustomLine = newDecorationIDToSpecialLine;
+        this._invalidIndex = Infinity;
+        this._hasPending = false;
+    }
+    _binarySearchOverOrderedCustomLinesArray(lineNumber) {
+        return binarySearch2(this._orderedCustomLines.length, (index) => {
+            const line = this._orderedCustomLines[index];
+            if (line.lineNumber === lineNumber) {
+                return 0;
+            }
+            else if (line.lineNumber < lineNumber) {
+                return -1;
+            }
+            else {
+                return 1;
+            }
+        });
+    }
+}
+class ArrayMap {
+    constructor() {
+        this._map = ( new Map());
+    }
+    add(key, value) {
+        const array = this._map.get(key);
+        if (!array) {
+            this._map.set(key, [value]);
+        }
+        else {
+            array.push(value);
+        }
+    }
+    get(key) {
+        return this._map.get(key);
+    }
+    delete(key) {
+        this._map.delete(key);
+    }
+}
+
+export { CustomLine, LineHeightsManager };

package/vscode/src/vs/editor/common/viewLayout/linesLayout.d.ts

@@ -1,4 +1,5 @@
-import { IEditorWhitespace, IPartialViewLinesViewportData, IViewWhitespaceViewportData, IWhitespaceChangeAccessor } from "../viewModel.js";
+import { IEditorWhitespace, IPartialViewLinesViewportData, ILineHeightChangeAccessor, IViewWhitespaceViewportData, IWhitespaceChangeAccessor } from "../viewModel.js";
+import { ICustomLineHeightData } from "./lineHeights.js";
 interface IPendingChange {
     id: string;
     newAfterLineNumber: number;
@@ -25,17 +26,17 @@ export declare class LinesLayout {
     private _prefixSumValidIndex;
     private _minWidth;
     private _lineCount;
-    private _lineHeight;
     private _paddingTop;
     private _paddingBottom;
-    constructor(lineCount: number, lineHeight: number, paddingTop: number, paddingBottom: number);
+    private _lineHeightsManager;
+    constructor(lineCount: number, defaultLineHeight: number, paddingTop: number, paddingBottom: number, customLineHeightData: ICustomLineHeightData[]);
     static findInsertionIndex(arr: EditorWhitespace[], afterLineNumber: number, ordinal: number): number;
-    setLineHeight(lineHeight: number): void;
+    setDefaultLineHeight(lineHeight: number): void;
     setPadding(paddingTop: number, paddingBottom: number): void;
-    onFlushed(lineCount: number): void;
+    onFlushed(lineCount: number, customLineHeightData: ICustomLineHeightData[]): void;
+    changeLineHeights(callback: (accessor: ILineHeightChangeAccessor) => void): boolean;
     changeWhitespace(callback: (accessor: IWhitespaceChangeAccessor) => void): boolean;
     _commitPendingChanges(inserts: EditorWhitespace[], changes: IPendingChange[], removes: IPendingRemove[]): void;
-    private _checkPendingChanges;
     private _insertWhitespace;
     private _findWhitespaceIndex;
     private _changeOneWhitespace;
@@ -50,6 +51,7 @@ export declare class LinesLayout {
     private _findFirstWhitespaceAfterLineNumber;
     getFirstWhitespaceIndexAfterLineNumber(lineNumber: number): number;
     getVerticalOffsetForLineNumber(lineNumber: number, includeViewZones?: boolean): number;
+    getLineHeightForLineNumber(lineNumber: number): number;
     getVerticalOffsetAfterLineNumber(lineNumber: number, includeViewZones?: boolean): number;
     hasWhitespace(): boolean;
     getWhitespaceMinWidth(): number;