@codingame/monaco-vscode-api 24.3.0 → 25.0.1

package/vscode/src/vs/editor/common/model/tokens/annotations.d.ts

@@ -0,0 +1,85 @@
+import { StringEdit } from "../../core/edits/stringEdit.js";
+import { OffsetRange } from "../../core/ranges/offsetRange.js";
+export interface IAnnotation<T> {
+    range: OffsetRange;
+    annotation: T;
+}
+export interface IAnnotatedString<T> {
+    /**
+     * Set annotations for a specific line.
+     * Annotations should be sorted and non-overlapping.
+     */
+    setAnnotations(annotations: AnnotationsUpdate<T>): void;
+    /**
+     * Return annotations intersecting with the given offset range.
+     */
+    getAnnotationsIntersecting(range: OffsetRange): IAnnotation<T>[];
+    /**
+     * Get all the annotations. Method is used for testing.
+     */
+    getAllAnnotations(): IAnnotation<T>[];
+    /**
+     * Apply a string edit to the annotated string.
+     * @returns The annotations that were deleted (became empty) as a result of the edit.
+     */
+    applyEdit(edit: StringEdit): IAnnotation<T>[];
+    /**
+     * Clone the annotated string.
+     */
+    clone(): IAnnotatedString<T>;
+}
+export declare class AnnotatedString<T> implements IAnnotatedString<T> {
+    /**
+     * Annotations are non intersecting and contiguous in the array.
+     */
+    private _annotations;
+    constructor(annotations?: IAnnotation<T>[]);
+    /**
+     * Set annotations for a specific range.
+     * Annotations should be sorted and non-overlapping.
+     * If the annotation value is undefined, the annotation is removed.
+     */
+    setAnnotations(annotations: AnnotationsUpdate<T>): void;
+    /**
+     * Returns all annotations that intersect with the given offset range.
+     */
+    getAnnotationsIntersecting(range: OffsetRange): IAnnotation<T>[];
+    private _getStartIndexOfIntersectingAnnotation;
+    private _getEndIndexOfIntersectingAnnotation;
+    /**
+     * Returns a copy of all annotations.
+     */
+    getAllAnnotations(): IAnnotation<T>[];
+    /**
+     * Applies a string edit to the annotated string, updating annotation ranges accordingly.
+     * @param edit The string edit to apply.
+     * @returns The annotations that were deleted (became empty) as a result of the edit.
+     */
+    applyEdit(edit: StringEdit): IAnnotation<T>[];
+    /**
+     * Creates a shallow clone of this annotated string.
+     */
+    clone(): IAnnotatedString<T>;
+}
+export interface IAnnotationUpdate<T> {
+    range: OffsetRange;
+    annotation: T | undefined;
+}
+type DefinedValue = object | string | number | boolean;
+export type ISerializedAnnotation<TSerializedProperty extends DefinedValue> = {
+    range: {
+        start: number;
+        endExclusive: number;
+    };
+    annotation: TSerializedProperty | undefined;
+};
+export declare class AnnotationsUpdate<T> {
+    static create<T>(annotations: IAnnotationUpdate<T>[]): AnnotationsUpdate<T>;
+    private _annotations;
+    private constructor();
+    get annotations(): IAnnotationUpdate<T>[];
+    rebase(edit: StringEdit): void;
+    serialize<TSerializedProperty extends DefinedValue>(serializingFunc: (annotation: T) => TSerializedProperty): ISerializedAnnotation<TSerializedProperty>[];
+    static deserialize<T, TSerializedProperty extends DefinedValue>(serializedAnnotations: ISerializedAnnotation<TSerializedProperty>[], deserializingFunc: (annotation: TSerializedProperty) => T): AnnotationsUpdate<T>;
+}
+export {};

package/vscode/src/vs/editor/common/model/tokens/annotations.js

@@ -0,0 +1,180 @@
+
+import { binarySearch2 } from '../../../../base/common/arrays.js';
+import { OffsetRange } from '../../core/ranges/offsetRange.js';
+
+class AnnotatedString {
+    constructor(annotations = []) {
+        this._annotations = [];
+        this._annotations = annotations;
+    }
+    setAnnotations(annotations) {
+        for (const annotation of annotations.annotations) {
+            const startIndex = this._getStartIndexOfIntersectingAnnotation(annotation.range.start);
+            const endIndexExclusive = this._getEndIndexOfIntersectingAnnotation(annotation.range.endExclusive);
+            if (annotation.annotation !== undefined) {
+                this._annotations.splice(startIndex, endIndexExclusive - startIndex, { range: annotation.range, annotation: annotation.annotation });
+            }
+            else {
+                this._annotations.splice(startIndex, endIndexExclusive - startIndex);
+            }
+        }
+    }
+    getAnnotationsIntersecting(range) {
+        const startIndex = this._getStartIndexOfIntersectingAnnotation(range.start);
+        const endIndexExclusive = this._getEndIndexOfIntersectingAnnotation(range.endExclusive);
+        return this._annotations.slice(startIndex, endIndexExclusive);
+    }
+    _getStartIndexOfIntersectingAnnotation(offset) {
+        const startIndexWhereToReplace = binarySearch2(this._annotations.length, (index) => {
+            return this._annotations[index].range.start - offset;
+        });
+        let startIndex;
+        if (startIndexWhereToReplace >= 0) {
+            startIndex = startIndexWhereToReplace;
+        }
+        else {
+            const candidate = this._annotations[-(startIndexWhereToReplace + 2)]?.range;
+            if (candidate && offset >= candidate.start && offset <= candidate.endExclusive) {
+                startIndex = -(startIndexWhereToReplace + 2);
+            }
+            else {
+                startIndex = -(startIndexWhereToReplace + 1);
+            }
+        }
+        return startIndex;
+    }
+    _getEndIndexOfIntersectingAnnotation(offset) {
+        const endIndexWhereToReplace = binarySearch2(this._annotations.length, (index) => {
+            return this._annotations[index].range.endExclusive - offset;
+        });
+        let endIndexExclusive;
+        if (endIndexWhereToReplace >= 0) {
+            endIndexExclusive = endIndexWhereToReplace + 1;
+        }
+        else {
+            const candidate = this._annotations[-(endIndexWhereToReplace + 1)]?.range;
+            if (candidate && offset >= candidate.start && offset <= candidate.endExclusive) {
+                endIndexExclusive = -endIndexWhereToReplace;
+            }
+            else {
+                endIndexExclusive = -(endIndexWhereToReplace + 1);
+            }
+        }
+        return endIndexExclusive;
+    }
+    getAllAnnotations() {
+        return this._annotations.slice();
+    }
+    applyEdit(edit) {
+        const annotations = this._annotations.slice();
+        const finalAnnotations = [];
+        const deletedAnnotations = [];
+        let offset = 0;
+        for (const e of edit.replacements) {
+            while (true) {
+                const annotation = annotations[0];
+                if (!annotation) {
+                    break;
+                }
+                const range = annotation.range;
+                if (range.endExclusive >= e.replaceRange.start) {
+                    break;
+                }
+                annotations.shift();
+                const newAnnotation = { range: range.delta(offset), annotation: annotation.annotation };
+                if (!newAnnotation.range.isEmpty) {
+                    finalAnnotations.push(newAnnotation);
+                }
+                else {
+                    deletedAnnotations.push(newAnnotation);
+                }
+            }
+            const intersecting = [];
+            while (true) {
+                const annotation = annotations[0];
+                if (!annotation) {
+                    break;
+                }
+                const range = annotation.range;
+                if (!range.intersectsOrTouches(e.replaceRange)) {
+                    break;
+                }
+                annotations.shift();
+                intersecting.push(annotation);
+            }
+            for (let i = intersecting.length - 1; i >= 0; i--) {
+                const annotation = intersecting[i];
+                let r = annotation.range;
+                const shouldExtend = i === 0 && (e.replaceRange.endExclusive > r.start) && (e.replaceRange.start < r.endExclusive);
+                const overlap = r.intersect(e.replaceRange).length;
+                r = r.deltaEnd(-overlap + (shouldExtend ? e.newText.length : 0));
+                const rangeAheadOfReplaceRange = r.start - e.replaceRange.start;
+                if (rangeAheadOfReplaceRange > 0) {
+                    r = r.delta(-rangeAheadOfReplaceRange);
+                }
+                if (!shouldExtend && rangeAheadOfReplaceRange >= 0) {
+                    r = r.delta(e.newText.length);
+                }
+                r = r.delta(-(e.newText.length - e.replaceRange.length));
+                annotations.unshift({ annotation: annotation.annotation, range: r });
+            }
+            offset += e.newText.length - e.replaceRange.length;
+        }
+        while (true) {
+            const annotation = annotations[0];
+            if (!annotation) {
+                break;
+            }
+            annotations.shift();
+            const newAnnotation = { annotation: annotation.annotation, range: annotation.range.delta(offset) };
+            if (!newAnnotation.range.isEmpty) {
+                finalAnnotations.push(newAnnotation);
+            }
+            else {
+                deletedAnnotations.push(newAnnotation);
+            }
+        }
+        this._annotations = finalAnnotations;
+        return deletedAnnotations;
+    }
+    clone() {
+        return ( new AnnotatedString(this._annotations.slice()));
+    }
+}
+class AnnotationsUpdate {
+    static create(annotations) {
+        return ( new AnnotationsUpdate(annotations));
+    }
+    constructor(annotations) {
+        this._annotations = annotations;
+    }
+    get annotations() {
+        return this._annotations;
+    }
+    rebase(edit) {
+        const annotatedString = ( new AnnotatedString(this._annotations));
+        annotatedString.applyEdit(edit);
+        this._annotations = annotatedString.getAllAnnotations();
+    }
+    serialize(serializingFunc) {
+        return ( this._annotations.map(annotation => {
+            const range = { start: annotation.range.start, endExclusive: annotation.range.endExclusive };
+            if (!annotation.annotation) {
+                return { range, annotation: undefined };
+            }
+            return { range, annotation: serializingFunc(annotation.annotation) };
+        }));
+    }
+    static deserialize(serializedAnnotations, deserializingFunc) {
+        const annotations = ( serializedAnnotations.map(serializedAnnotation => {
+            const range = ( new OffsetRange(serializedAnnotation.range.start, serializedAnnotation.range.endExclusive));
+            if (!serializedAnnotation.annotation) {
+                return { range, annotation: undefined };
+            }
+            return { range, annotation: deserializingFunc(serializedAnnotation.annotation) };
+        }));
+        return ( new AnnotationsUpdate(annotations));
+    }
+}
+
+export { AnnotatedString, AnnotationsUpdate };

package/vscode/src/vs/editor/common/model/tokens/tokenizationFontDecorationsProvider.d.ts

@@ -0,0 +1,24 @@
+import { Disposable } from "../../../../base/common/lifecycle.js";
+import { IModelDecoration, ITextModel } from "../../model.js";
+import { TokenizationTextModelPart } from "./tokenizationTextModelPart.js";
+import { Range } from "../../core/range.js";
+import { DecorationProvider, LineFontChangingDecoration, LineHeightChangingDecoration } from "../decorationProvider.js";
+import { IFontTokenOption, IModelContentChangedEvent } from "../../textModelEvents.js";
+export interface IFontTokenAnnotation {
+    decorationId: string;
+    fontToken: IFontTokenOption;
+}
+export declare class TokenizationFontDecorationProvider extends Disposable implements DecorationProvider {
+    private readonly textModel;
+    private readonly tokenizationTextModelPart;
+    private static DECORATION_COUNT;
+    private readonly _onDidChangeLineHeight;
+    readonly onDidChangeLineHeight: import("../../../../base/common/event.js").Event<Set<LineHeightChangingDecoration>>;
+    private readonly _onDidChangeFont;
+    readonly onDidChangeFont: import("../../../../base/common/event.js").Event<Set<LineFontChangingDecoration>>;
+    private _fontAnnotatedString;
+    constructor(textModel: ITextModel, tokenizationTextModelPart: TokenizationTextModelPart);
+    handleDidChangeContent(change: IModelContentChangedEvent): void;
+    getDecorationsInRange(range: Range, ownerId?: number, filterOutValidation?: boolean, onlyMinimapDecorations?: boolean): IModelDecoration[];
+    getAllDecorations(ownerId?: number, filterOutValidation?: boolean): IModelDecoration[];
+}

package/vscode/src/vs/editor/common/model/tokens/tokenizationFontDecorationsProvider.js

@@ -0,0 +1,126 @@
+
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { Range } from '../../core/range.js';
+import { LineHeightChangingDecoration, LineFontChangingDecoration } from '../decorationProvider.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { classNameForFontTokenDecorations } from '../../languages/supports/tokenization.js';
+import { Position } from '../../core/position.js';
+import { AnnotatedString, AnnotationsUpdate } from './annotations.js';
+import { OffsetRange } from '../../core/ranges/offsetRange.js';
+import { offsetEditFromContentChanges } from '../textModelStringEdit.js';
+
+class TokenizationFontDecorationProvider extends Disposable {
+    static { this.DECORATION_COUNT = 0; }
+    constructor(textModel, tokenizationTextModelPart) {
+        super();
+        this.textModel = textModel;
+        this.tokenizationTextModelPart = tokenizationTextModelPart;
+        this._onDidChangeLineHeight = ( new Emitter());
+        this.onDidChangeLineHeight = this._onDidChangeLineHeight.event;
+        this._onDidChangeFont = ( new Emitter());
+        this.onDidChangeFont = this._onDidChangeFont.event;
+        this._fontAnnotatedString = ( new AnnotatedString());
+        this._register(this.tokenizationTextModelPart.onDidChangeFontTokens(fontChanges => {
+            const linesChanged = ( new Set());
+            const fontTokenAnnotations = [];
+            const affectedLineHeights = ( new Set());
+            const affectedLineFonts = ( new Set());
+            for (const annotation of fontChanges.changes.annotations) {
+                const startPosition = this.textModel.getPositionAt(annotation.range.start);
+                const endPosition = this.textModel.getPositionAt(annotation.range.endExclusive);
+                if (startPosition.lineNumber !== endPosition.lineNumber) {
+                    continue;
+                }
+                const lineNumber = startPosition.lineNumber;
+                let fontTokenAnnotation;
+                if (annotation.annotation === undefined) {
+                    fontTokenAnnotation = {
+                        range: annotation.range,
+                        annotation: undefined
+                    };
+                }
+                else {
+                    const decorationId = `tokenization-font-decoration-${TokenizationFontDecorationProvider.DECORATION_COUNT}`;
+                    const fontTokenDecoration = {
+                        fontToken: annotation.annotation,
+                        decorationId
+                    };
+                    fontTokenAnnotation = {
+                        range: annotation.range,
+                        annotation: fontTokenDecoration
+                    };
+                    TokenizationFontDecorationProvider.DECORATION_COUNT++;
+                    if (annotation.annotation.lineHeight) {
+                        affectedLineHeights.add(( new LineHeightChangingDecoration(0, decorationId, lineNumber, annotation.annotation.lineHeight)));
+                    }
+                    affectedLineFonts.add(( new LineFontChangingDecoration(0, decorationId, lineNumber)));
+                }
+                fontTokenAnnotations.push(fontTokenAnnotation);
+                if (!( linesChanged.has(lineNumber))) {
+                    const lineNumberStartOffset = this.textModel.getOffsetAt(( new Position(lineNumber, 1)));
+                    const lineNumberEndOffset = this.textModel.getOffsetAt(( new Position(lineNumber, this.textModel.getLineMaxColumn(lineNumber))));
+                    const lineOffsetRange = ( new OffsetRange(lineNumberStartOffset, lineNumberEndOffset));
+                    const lineAnnotations = this._fontAnnotatedString.getAnnotationsIntersecting(lineOffsetRange);
+                    for (const annotation of lineAnnotations) {
+                        const decorationId = annotation.annotation.decorationId;
+                        affectedLineHeights.add(( new LineHeightChangingDecoration(0, decorationId, lineNumber, null)));
+                        affectedLineFonts.add(( new LineFontChangingDecoration(0, decorationId, lineNumber)));
+                    }
+                    linesChanged.add(lineNumber);
+                }
+            }
+            this._fontAnnotatedString.setAnnotations(AnnotationsUpdate.create(fontTokenAnnotations));
+            this._onDidChangeLineHeight.fire(affectedLineHeights);
+            this._onDidChangeFont.fire(affectedLineFonts);
+        }));
+    }
+    handleDidChangeContent(change) {
+        const edits = offsetEditFromContentChanges(change.changes);
+        const deletedAnnotations = this._fontAnnotatedString.applyEdit(edits);
+        if (deletedAnnotations.length === 0) {
+            return;
+        }
+        const affectedLineHeights = ( new Set());
+        const affectedLineFonts = ( new Set());
+        for (const deletedAnnotation of deletedAnnotations) {
+            const startPosition = this.textModel.getPositionAt(deletedAnnotation.range.start);
+            const lineNumber = startPosition.lineNumber;
+            const decorationId = deletedAnnotation.annotation.decorationId;
+            affectedLineHeights.add(( new LineHeightChangingDecoration(0, decorationId, lineNumber, null)));
+            affectedLineFonts.add(( new LineFontChangingDecoration(0, decorationId, lineNumber)));
+        }
+        this._onDidChangeLineHeight.fire(affectedLineHeights);
+        this._onDidChangeFont.fire(affectedLineFonts);
+    }
+    getDecorationsInRange(range, ownerId, filterOutValidation, onlyMinimapDecorations) {
+        const startOffsetOfRange = this.textModel.getOffsetAt(range.getStartPosition());
+        const endOffsetOfRange = this.textModel.getOffsetAt(range.getEndPosition());
+        const annotations = this._fontAnnotatedString.getAnnotationsIntersecting(( new OffsetRange(startOffsetOfRange, endOffsetOfRange)));
+        const decorations = [];
+        for (const annotation of annotations) {
+            const annotationStartPosition = this.textModel.getPositionAt(annotation.range.start);
+            const annotationEndPosition = this.textModel.getPositionAt(annotation.range.endExclusive);
+            const range = Range.fromPositions(annotationStartPosition, annotationEndPosition);
+            const anno = annotation.annotation;
+            const className = classNameForFontTokenDecorations(anno.fontToken.fontFamily ?? '', anno.fontToken.fontSize ?? '');
+            const affectsFont = !!(anno.fontToken.fontFamily || anno.fontToken.fontSize);
+            const id = anno.decorationId;
+            decorations.push({
+                id: id,
+                options: {
+                    description: 'FontOptionDecoration',
+                    inlineClassName: className,
+                    affectsFont
+                },
+                ownerId: 0,
+                range
+            });
+        }
+        return decorations;
+    }
+    getAllDecorations(ownerId, filterOutValidation) {
+        return this.getDecorationsInRange(( new Range(1, 1, this.textModel.getLineCount(), 1)), ownerId, filterOutValidation);
+    }
+}
+
+export { TokenizationFontDecorationProvider };

package/vscode/src/vs/editor/common/model/tokens/tokenizationTextModelPart.d.ts

@@ -10,7 +10,7 @@ import { BracketPairsTextModelPart } from "../bracketPairsTextModelPart/bracketP
 import { TextModel } from "../textModel.js";
 import { TextModelPart } from "../textModelPart.js";
 import { AbstractSyntaxTokenBackend, AttachedViews } from "./abstractSyntaxTokenBackend.js";
-import { IModelContentChangedEvent, IModelLanguageChangedEvent, IModelLanguageConfigurationChangedEvent, IModelTokensChangedEvent } from "../../textModelEvents.js";
+import { IModelContentChangedEvent, IModelLanguageChangedEvent, IModelLanguageConfigurationChangedEvent, IModelTokensChangedEvent, IModelFontTokensChangedEvent } from "../../textModelEvents.js";
 import { ITokenizationTextModelPart } from "../../tokenizationTextModelPart.js";
 import { LineTokens } from "../../tokens/lineTokens.js";
 import { SparseMultilineTokens } from "../../tokens/sparseMultilineTokens.js";
@@ -33,6 +33,8 @@ export declare class TokenizationTextModelPart extends TextModelPart implements
     readonly onDidChangeLanguageConfiguration: Event<IModelLanguageConfigurationChangedEvent>;
     private readonly _onDidChangeTokens;
     readonly onDidChangeTokens: Event<IModelTokensChangedEvent>;
+    private readonly _onDidChangeFontTokens;
+    readonly onDidChangeFontTokens: Event<IModelFontTokensChangedEvent>;
     readonly tokens: IObservable<AbstractSyntaxTokenBackend>;
     private readonly _useTreeSitter;
     private readonly _languageIdObs;

package/vscode/src/vs/editor/common/model/tokens/tokenizationTextModelPart.js

@@ -30,6 +30,8 @@ let TokenizationTextModelPart = TokenizationTextModelPart_1 = class Tokenization
         this._languageConfigurationService = _languageConfigurationService;
         this._instantiationService = _instantiationService;
         this._treeSitterLibraryService = _treeSitterLibraryService;
+        this._onDidChangeFontTokens = this._register(( new Emitter()));
+        this.onDidChangeFontTokens = this._onDidChangeFontTokens.event;
         this._languageIdObs = observableValue(this, this._languageId);
         this._useTreeSitter = derived(this, reader => {
             const languageId = this._languageIdObs.read(reader);
@@ -51,6 +53,11 @@ let TokenizationTextModelPart = TokenizationTextModelPart_1 = class Tokenization
             reader.store.add(tokens.onDidChangeTokens(e => {
                 this._emitModelTokensChangedEvent(e);
             }));
+            reader.store.add(tokens.onDidChangeFontTokens(e => {
+                if (!this._textModel._isDisposing()) {
+                    this._onDidChangeFontTokens.fire(e);
+                }
+            }));
             reader.store.add(tokens.onDidChangeBackgroundTokenizationState(e => {
                 this._bracketPairsTextModelPart.handleDidChangeBackgroundTokenizationState();
             }));
@@ -70,6 +77,8 @@ let TokenizationTextModelPart = TokenizationTextModelPart_1 = class Tokenization
         this.onDidChangeLanguageConfiguration = this._onDidChangeLanguageConfiguration.event;
         this._onDidChangeTokens = this._register(( new Emitter()));
         this.onDidChangeTokens = this._onDidChangeTokens.event;
+        this._onDidChangeFontTokens = this._register(( new Emitter()));
+        this.onDidChangeFontTokens = this._onDidChangeFontTokens.event;
     }
     _hasListeners() {
         return (this._onDidChangeLanguage.hasListeners()

package/vscode/src/vs/editor/common/model/tokens/tokenizerSyntaxTokenBackend.d.ts

@@ -25,6 +25,7 @@ export declare class TokenizerSyntaxTokenBackend extends AbstractSyntaxTokenBack
     handleDidChangeAttached(): void;
     handleDidChangeContent(e: IModelContentChangedEvent): void;
     private setTokens;
+    private setFontInfo;
     private refreshAllVisibleLineTokens;
     private refreshRanges;
     private refreshRange;

package/vscode/src/vs/editor/common/model/tokens/tokenizerSyntaxTokenBackend.js

@@ -102,6 +102,9 @@ class TokenizerSyntaxTokenBackend extends AbstractSyntaxTokenBackend {
                 setTokens: (tokens) => {
                     this.setTokens(tokens);
                 },
+                setFontInfo: (changes) => {
+                    this.setFontInfo(changes);
+                },
                 backgroundTokenizationFinished: () => {
                     if (this._backgroundTokenizationState === BackgroundTokenizationState.Completed) {
                         return;
@@ -136,6 +139,9 @@ class TokenizerSyntaxTokenBackend extends AbstractSyntaxTokenBackend {
                     setTokens: (tokens) => {
                         this._debugBackgroundTokens?.setMultilineTokens(tokens, this._textModel);
                     },
+                    setFontInfo: (changes) => {
+                        this.setFontInfo(changes);
+                    },
                     backgroundTokenizationFinished() {
                     },
                     setEndState: (lineNumber, state) => {
@@ -178,6 +184,9 @@ class TokenizerSyntaxTokenBackend extends AbstractSyntaxTokenBackend {
         }
         return { changes: changes };
     }
+    setFontInfo(changes) {
+        this._onDidChangeFontTokens.fire({ changes });
+    }
     refreshAllVisibleLineTokens() {
         const ranges = LineRange.joinMany(( [...this._attachedViewStates].map(([_, s]) => s.lineRanges)));
         this.refreshRanges(ranges);

package/vscode/src/vs/editor/common/standaloneStrings.d.ts

@@ -27,6 +27,7 @@ export declare namespace AccessibilityHelpNLS {
     const showAccessibilityHelpAction: string;
     const listSignalSounds: string;
     const listAlerts: string;
+    const announceCursorPosition: string;
     const quickChat: string;
     const startInlineChat: string;
     const startDebugging: string;