@codingame/monaco-vscode-api 20.1.0 → 20.2.0

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

@@ -5,6 +5,10 @@ export declare class TextModelEditSource {
     constructor(metadata: ITextModelEditSourceMetadata, _privateCtorGuard: typeof privateSymbol);
     toString(): string;
     getType(): string;
+    /**
+     * Converts the metadata to a key string.
+     * Only includes properties/values that have `level` many `$` prefixes or less.
+    */
     toKey(level: number, filter?: {
         [TKey in ITextModelEditSourceMetadataKeys]?: boolean;
     }): string;

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

@@ -3,50 +3,149 @@ import { IRange } from "./core/range.js";
 import { Selection } from "./core/selection.js";
 import { IModelDecoration, InjectedTextOptions } from "./model.js";
 import { TextModelEditSource } from "./textModelEditSource.js";
+/**
+ * An event describing that the current language associated with a model has changed.
+ */
 export interface IModelLanguageChangedEvent {
+    /**
+     * Previous language
+     */
     readonly oldLanguage: string;
+    /**
+     * New language
+     */
     readonly newLanguage: string;
+    /**
+     * Source of the call that caused the event.
+     */
     readonly source: string;
 }
+/**
+ * An event describing that the language configuration associated with a model has changed.
+ */
 export interface IModelLanguageConfigurationChangedEvent {
 }
 export interface IModelContentChange {
+    /**
+     * The old range that got replaced.
+     */
     readonly range: IRange;
+    /**
+     * The offset of the range that got replaced.
+     */
     readonly rangeOffset: number;
+    /**
+     * The length of the range that got replaced.
+     */
     readonly rangeLength: number;
+    /**
+     * The new text for the range.
+     */
     readonly text: string;
 }
+/**
+ * An event describing a change in the text of a model.
+ */
 export interface IModelContentChangedEvent {
+    /**
+     * The changes are ordered from the end of the document to the beginning, so they should be safe to apply in sequence.
+     */
     readonly changes: IModelContentChange[];
+    /**
+     * The (new) end-of-line character.
+     */
     readonly eol: string;
+    /**
+     * The new version id the model has transitioned to.
+     */
     readonly versionId: number;
+    /**
+     * Flag that indicates that this event was generated while undoing.
+     */
     readonly isUndoing: boolean;
+    /**
+     * Flag that indicates that this event was generated while redoing.
+     */
     readonly isRedoing: boolean;
+    /**
+     * Flag that indicates that all decorations were lost with this edit.
+     * The model has been reset to a new value.
+     */
     readonly isFlush: boolean;
+    /**
+     * Flag that indicates that this event describes an eol change.
+     */
     readonly isEolChange: boolean;
+    /**
+     * Detailed reason information for the change
+     * @internal
+     */
     readonly detailedReasons: TextModelEditSource[];
+    /**
+     * The sum of these lengths equals changes.length.
+     * The length of this array must equal the length of detailedReasons.
+    */
     readonly detailedReasonsChangeLengths: number[];
 }
 export interface ISerializedModelContentChangedEvent {
+    /**
+     * The changes are ordered from the end of the document to the beginning, so they should be safe to apply in sequence.
+     */
     readonly changes: IModelContentChange[];
+    /**
+     * The (new) end-of-line character.
+     */
     readonly eol: string;
+    /**
+     * The new version id the model has transitioned to.
+     */
     readonly versionId: number;
+    /**
+     * Flag that indicates that this event was generated while undoing.
+     */
     readonly isUndoing: boolean;
+    /**
+     * Flag that indicates that this event was generated while redoing.
+     */
     readonly isRedoing: boolean;
+    /**
+     * Flag that indicates that all decorations were lost with this edit.
+     * The model has been reset to a new value.
+     */
     readonly isFlush: boolean;
+    /**
+     * Flag that indicates that this event describes an eol change.
+     */
     readonly isEolChange: boolean;
+    /**
+     * Detailed reason information for the change
+     * @internal
+     */
     readonly detailedReason: Record<string, unknown> | undefined;
 }
+/**
+ * An event describing that model decorations have changed.
+ */
 export interface IModelDecorationsChangedEvent {
     readonly affectsMinimap: boolean;
     readonly affectsOverviewRuler: boolean;
     readonly affectsGlyphMargin: boolean;
     readonly affectsLineNumber: boolean;
 }
+/**
+ * An event describing that some ranges of lines have been tokenized (their tokens have changed).
+ * @internal
+ */
 export interface IModelTokensChangedEvent {
     readonly semanticTokensApplied: boolean;
     readonly ranges: {
+        /**
+         * The start of the range (inclusive)
+         */
         readonly fromLineNumber: number;
+        /**
+         * The end of the range (inclusive)
+         */
         readonly toLineNumber: number;
     }[];
 }
@@ -56,6 +155,9 @@ export interface IModelOptionsChangedEvent {
     readonly insertSpaces: boolean;
     readonly trimAutoWhitespace: boolean;
 }
+/**
+ * @internal
+ */
 export declare enum RawContentChangedType {
     Flush = 1,
     LineChanged = 2,
@@ -63,9 +165,17 @@ export declare enum RawContentChangedType {
     LinesInserted = 4,
     EOLChanged = 5
 }
+/**
+ * An event describing that a model has been reset to a new value.
+ * @internal
+ */
 export declare class ModelRawFlush {
     readonly changeType = RawContentChangedType.Flush;
 }
+/**
+ * Represents text injected on a line
+ * @internal
+ */
 export declare class LineInjectedText {
     readonly ownerId: number;
     readonly lineNumber: number;
@@ -77,66 +187,166 @@ export declare class LineInjectedText {
     constructor(ownerId: number, lineNumber: number, column: number, options: InjectedTextOptions, order: number);
     withText(text: string): LineInjectedText;
 }
+/**
+ * An event describing that a line has changed in a model.
+ * @internal
+ */
 export declare class ModelRawLineChanged {
     readonly changeType = RawContentChangedType.LineChanged;
+    /**
+     * The line that has changed.
+     */
     readonly lineNumber: number;
+    /**
+     * The new value of the line.
+     */
     readonly detail: string;
+    /**
+     * The injected text on the line.
+     */
     readonly injectedText: LineInjectedText[] | null;
     constructor(lineNumber: number, detail: string, injectedText: LineInjectedText[] | null);
 }
+/**
+ * An event describing that a line height has changed in the model.
+ * @internal
+ */
 export declare class ModelLineHeightChanged {
+    /**
+     * Editor owner ID
+     */
     readonly ownerId: number;
+    /**
+     * The decoration ID that has changed.
+     */
     readonly decorationId: string;
+    /**
+     * The line that has changed.
+     */
     readonly lineNumber: number;
+    /**
+     * The line height on the line.
+     */
     readonly lineHeight: number | null;
     constructor(ownerId: number, decorationId: string, lineNumber: number, lineHeight: number | null);
 }
+/**
+ * An event describing that a line height has changed in the model.
+ * @internal
+ */
 export declare class ModelFontChanged {
+    /**
+     * Editor owner ID
+     */
     readonly ownerId: number;
+    /**
+     * The line that has changed.
+     */
     readonly lineNumber: number;
     constructor(ownerId: number, lineNumber: number);
 }
+/**
+ * An event describing that line(s) have been deleted in a model.
+ * @internal
+ */
 export declare class ModelRawLinesDeleted {
     readonly changeType = RawContentChangedType.LinesDeleted;
+    /**
+     * At what line the deletion began (inclusive).
+     */
     readonly fromLineNumber: number;
+    /**
+     * At what line the deletion stopped (inclusive).
+     */
     readonly toLineNumber: number;
     constructor(fromLineNumber: number, toLineNumber: number);
 }
+/**
+ * An event describing that line(s) have been inserted in a model.
+ * @internal
+ */
 export declare class ModelRawLinesInserted {
     readonly changeType = RawContentChangedType.LinesInserted;
+    /**
+     * Before what line did the insertion begin
+     */
     readonly fromLineNumber: number;
+    /**
+     * `toLineNumber` - `fromLineNumber` + 1 denotes the number of lines that were inserted
+     */
     readonly toLineNumber: number;
+    /**
+     * The text that was inserted
+     */
     readonly detail: string[];
+    /**
+     * The injected texts for every inserted line.
+     */
     readonly injectedTexts: (LineInjectedText[] | null)[];
     constructor(fromLineNumber: number, toLineNumber: number, detail: string[], injectedTexts: (LineInjectedText[] | null)[]);
 }
+/**
+ * An event describing that a model has had its EOL changed.
+ * @internal
+ */
 export declare class ModelRawEOLChanged {
     readonly changeType = RawContentChangedType.EOLChanged;
 }
+/**
+ * @internal
+ */
 export type ModelRawChange = ModelRawFlush | ModelRawLineChanged | ModelRawLinesDeleted | ModelRawLinesInserted | ModelRawEOLChanged;
+/**
+ * An event describing a change in the text of a model.
+ * @internal
+ */
 export declare class ModelRawContentChangedEvent {
     readonly changes: ModelRawChange[];
+    /**
+     * The new version id the model has transitioned to.
+     */
     readonly versionId: number;
+    /**
+     * Flag that indicates that this event was generated while undoing.
+     */
     readonly isUndoing: boolean;
+    /**
+     * Flag that indicates that this event was generated while redoing.
+     */
     readonly isRedoing: boolean;
     resultingSelection: Selection[] | null;
     constructor(changes: ModelRawChange[], versionId: number, isUndoing: boolean, isRedoing: boolean);
     containsEvent(type: RawContentChangedType): boolean;
     static merge(a: ModelRawContentChangedEvent, b: ModelRawContentChangedEvent): ModelRawContentChangedEvent;
 }
+/**
+ * An event describing a change in injected text.
+ * @internal
+ */
 export declare class ModelInjectedTextChangedEvent {
     readonly changes: ModelRawLineChanged[];
     constructor(changes: ModelRawLineChanged[]);
 }
+/**
+ * An event describing a change of a line height.
+ * @internal
+ */
 export declare class ModelLineHeightChangedEvent {
     readonly changes: ModelLineHeightChanged[];
     constructor(changes: ModelLineHeightChanged[]);
     affects(rangeOrPosition: IRange | IPosition): boolean;
 }
+/**
+ * An event describing a change in fonts.
+ * @internal
+ */
 export declare class ModelFontChangedEvent {
     readonly changes: ModelFontChanged[];
     constructor(changes: ModelFontChanged[]);
 }
+/**
+ * @internal
+ */
 export declare class InternalModelContentChangeEvent {
     readonly rawContentChangedEvent: ModelRawContentChangedEvent;
     readonly contentChangedEvent: IModelContentChangedEvent;

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

@@ -1,7 +1,18 @@
 import { IPosition } from "./core/position.js";
 export interface IGuidesTextModelPart {
+    /**
+     * @internal
+     */
     getActiveIndentGuide(lineNumber: number, minLineNumber: number, maxLineNumber: number): IActiveIndentGuideInfo;
+    /**
+     * @internal
+     */
     getLinesIndentGuides(startLineNumber: number, endLineNumber: number): number[];
+    /**
+     * Requests the indent guides for the given range of lines.
+     * `result[i]` will contain the indent guides of the `startLineNumber + i`th line.
+     * @internal
+     */
     getLinesBracketGuides(startLineNumber: number, endLineNumber: number, activePosition: IPosition | null, options: BracketGuideOptions): IndentGuide[][];
 }
 export interface IActiveIndentGuideInfo {
@@ -23,10 +34,26 @@ export declare class IndentGuide {
     readonly visibleColumn: number | -1;
     readonly column: number | -1;
     readonly className: string;
+    /**
+     * If set, this indent guide is a horizontal guide (no vertical part).
+     * It starts at visibleColumn and continues until endColumn.
+    */
     readonly horizontalLine: IndentGuideHorizontalLine | null;
+    /**
+     * If set (!= -1), only show this guide for wrapped lines that don't contain this model column, but are after it.
+    */
     readonly forWrappedLinesAfterColumn: number | -1;
     readonly forWrappedLinesBeforeOrAtColumn: number | -1;
-    constructor(visibleColumn: number | -1, column: number | -1, className: string, horizontalLine: IndentGuideHorizontalLine | null, forWrappedLinesAfterColumn: number | -1, forWrappedLinesBeforeOrAtColumn: number | -1);
+    constructor(visibleColumn: number | -1, column: number | -1, className: string, 
+    /**
+     * If set, this indent guide is a horizontal guide (no vertical part).
+     * It starts at visibleColumn and continues until endColumn.
+    */
+    horizontalLine: IndentGuideHorizontalLine | null, 
+    /**
+     * If set (!= -1), only show this guide for wrapped lines that don't contain this model column, but are after it.
+    */
+    forWrappedLinesAfterColumn: number | -1, forWrappedLinesBeforeOrAtColumn: number | -1);
 }
 export declare class IndentGuideHorizontalLine {
     readonly top: boolean;

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

@@ -2,19 +2,72 @@ import { Range } from "./core/range.js";
 import { StandardTokenType } from "./encodedTokenAttributes.js";
 import { LineTokens } from "./tokens/lineTokens.js";
 import { SparseMultilineTokens } from "./tokens/sparseMultilineTokens.js";
+/**
+ * Provides tokenization related functionality of the text model.
+*/
 export interface ITokenizationTextModelPart {
     readonly hasTokens: boolean;
+    /**
+     * Replaces all semantic tokens with the provided `tokens`.
+     * @internal
+     */
     setSemanticTokens(tokens: SparseMultilineTokens[] | null, isComplete: boolean): void;
+    /**
+     * Merges the provided semantic tokens into existing semantic tokens.
+     * @internal
+     */
     setPartialSemanticTokens(range: Range, tokens: SparseMultilineTokens[] | null): void;
+    /**
+     * @internal
+     */
     hasCompleteSemanticTokens(): boolean;
+    /**
+     * @internal
+     */
     hasSomeSemanticTokens(): boolean;
+    /**
+     * Flush all tokenization state.
+     * @internal
+     */
     resetTokenization(): void;
+    /**
+     * Force tokenization information for `lineNumber` to be accurate.
+     * @internal
+     */
     forceTokenization(lineNumber: number): void;
+    /**
+     * If it is cheap, force tokenization information for `lineNumber` to be accurate.
+     * This is based on a heuristic.
+     * @internal
+     */
     tokenizeIfCheap(lineNumber: number): void;
+    /**
+     * Check if tokenization information is accurate for `lineNumber`.
+     * @internal
+     */
     hasAccurateTokensForLine(lineNumber: number): boolean;
+    /**
+     * Check if calling `forceTokenization` for this `lineNumber` will be cheap (time-wise).
+     * This is based on a heuristic.
+     * @internal
+     */
     isCheapToTokenize(lineNumber: number): boolean;
+    /**
+     * Get the tokens for the line `lineNumber`.
+     * The tokens might be inaccurate. Use `forceTokenization` to ensure accurate tokens.
+     * @internal
+     */
     getLineTokens(lineNumber: number): LineTokens;
+    /**
+    * Returns the standard token type for a character if the character were to be inserted at
+    * the given position. If the result cannot be accurate, it returns null.
+    * @internal
+    */
     getTokenTypeIfInsertingCharacter(lineNumber: number, column: number, character: string): StandardTokenType;
+    /**
+     * Tokens the lines as if they were inserted at [lineNumber, lineNumber).
+     * @internal
+    */
     tokenizeLinesAt(lineNumber: number, lines: string[]): LineTokens[] | null;
     getLanguageId(): string;
     getLanguageIdAtPosition(lineNumber: number, column: number): string;

package/vscode/src/vs/editor/common/tokens/contiguousMultilineTokens.d.ts

@@ -1,13 +1,37 @@
 import { IRange } from "../core/range.js";
 import { LineRange } from "../core/ranges/lineRange.js";
+/**
+ * Represents contiguous tokens over a contiguous range of lines.
+ */
 export declare class ContiguousMultilineTokens {
     static deserialize(buff: Uint8Array, offset: number, result: ContiguousMultilineTokens[]): number;
+    /**
+     * The start line number for this block of tokens.
+     */
     private _startLineNumber;
+    /**
+     * The tokens are stored in a binary format. There is an element for each line,
+     * so `tokens[index]` contains all tokens on line `startLineNumber + index`.
+     *
+     * On a specific line, each token occupies two array indices. For token i:
+     *  - at offset 2*i => endOffset
+     *  - at offset 2*i + 1 => metadata
+     *
+     */
     private _tokens;
+    /**
+     * (Inclusive) start line number for these tokens.
+     */
     get startLineNumber(): number;
+    /**
+     * (Inclusive) end line number for these tokens.
+     */
     get endLineNumber(): number;
     constructor(startLineNumber: number, tokens: Uint32Array[]);
     getLineRange(): LineRange;
+    /**
+     * @see {@link _tokens}
+     */
     getLineTokens(lineNumber: number): Uint32Array | ArrayBuffer | null;
     appendLineTokens(lineTokens: Uint32Array): void;
     serializeSize(): number;

package/vscode/src/vs/editor/common/tokens/contiguousTokensStore.d.ts

@@ -3,6 +3,9 @@ import { LineTokens } from "./lineTokens.js";
 import { ILanguageIdCodec } from "../languages.js";
 import { ITextModel } from "../model.js";
 import { ContiguousMultilineTokens } from "./contiguousMultilineTokens.js";
+/**
+ * Represents contiguous tokens in a text model.
+ */
 export declare class ContiguousTokensStore {
     private _lineTokens;
     private _len;

package/vscode/src/vs/editor/common/tokens/lineTokens.d.ts

@@ -49,10 +49,19 @@ export declare class LineTokens implements IViewLineTokens {
     getInlineStyle(tokenIndex: number, colorMap: string[]): string;
     getPresentation(tokenIndex: number): ITokenPresentation;
     getEndOffset(tokenIndex: number): number;
+    /**
+     * Find the token containing offset `offset`.
+     * @param offset The search offset
+     * @return The index of the token containing the offset.
+     */
     findTokenIndexAtOffset(offset: number): number;
     inflate(): IViewLineTokens;
     sliceAndInflate(startOffset: number, endOffset: number, deltaOffset: number): IViewLineTokens;
     sliceZeroCopy(range: OffsetRange): IViewLineTokens;
+    /**
+     * @pure
+     * @param insertTokens Must be sorted by offset.
+    */
     withInserted(insertTokens: {
         offset: number;
         text: string;
@@ -64,6 +73,14 @@ export declare class LineTokens implements IViewLineTokens {
     toString(): string;
 }
 export declare function getStandardTokenTypeAtPosition(model: ITextModel, position: IPosition): StandardTokenType | undefined;
+/**
+ * This class represents a sequence of tokens.
+ * Conceptually, each token has a length and a metadata number.
+ * A token array might be used to annotate a string with metadata.
+ * Use {@link TokenArrayBuilder} to efficiently create a token array.
+ *
+ * TODO: Make this class more efficient (e.g. by using a Int32Array).
+*/
 export declare class TokenArray {
     private readonly _tokenInfo;
     static fromLineTokens(lineTokens: LineTokens): TokenArray;
@@ -81,6 +98,9 @@ export declare class TokenInfo {
     readonly metadata: ITokenMetadata;
     constructor(length: number, metadata: ITokenMetadata);
 }
+/**
+ * TODO: Make this class more efficient (e.g. by using a Int32Array).
+*/
 export declare class TokenArrayBuilder {
     private readonly _tokens;
     add(length: number, metadata: ITokenMetadata): void;

package/vscode/src/vs/editor/common/tokens/sparseMultilineTokens.d.ts

@@ -1,11 +1,20 @@
 import { IRange, Range } from "../core/range.js";
 import { ITextModel } from "../model.js";
+/**
+ * Represents sparse tokens over a contiguous range of lines.
+ */
 export declare class SparseMultilineTokens {
     static create(startLineNumber: number, tokens: Uint32Array): SparseMultilineTokens;
     private _startLineNumber;
     private _endLineNumber;
     private readonly _tokens;
+    /**
+     * (Inclusive) start line number for these tokens.
+     */
     get startLineNumber(): number;
+    /**
+     * (Inclusive) end line number for these tokens.
+     */
     get endLineNumber(): number;
     private constructor();
     toString(): string;

package/vscode/src/vs/editor/common/tokens/sparseTokensStore.d.ts

@@ -3,6 +3,9 @@ import { LineTokens } from "./lineTokens.js";
 import { SparseMultilineTokens } from "./sparseMultilineTokens.js";
 import { ILanguageIdCodec } from "../languages.js";
 import { ITextModel } from "../model.js";
+/**
+ * Represents sparse tokens in a text model.
+ */
 export declare class SparseTokensStore {
     private _pieces;
     private _isComplete;

package/vscode/src/vs/editor/common/tokens/tokenWithTextArray.d.ts

@@ -1,6 +1,14 @@
 import { OffsetRange } from "../core/ranges/offsetRange.js";
 import { ILanguageIdCodec } from "../languages.js";
 import { LineTokens } from "./lineTokens.js";
+/**
+ * This class represents a sequence of tokens.
+ * Conceptually, each token has a length and a metadata number.
+ * A token array might be used to annotate a string with metadata.
+ * Use {@link TokenWithTextArrayBuilder} to efficiently create a token array.
+ *
+ * TODO: Make this class more efficient (e.g. by using a Int32Array).
+*/
 export declare class TokenWithTextArray {
     private readonly _tokenInfo;
     static fromLineTokens(lineTokens: LineTokens): TokenWithTextArray;
@@ -18,6 +26,9 @@ export declare class TokenWithTextInfo {
     readonly metadata: TokenMetadata;
     constructor(text: string, metadata: TokenMetadata);
 }
+/**
+ * TODO: Make this class more efficient (e.g. by using a Int32Array).
+*/
 export declare class TokenWithTextArrayBuilder {
     private readonly _tokens;
     add(text: string, metadata: TokenMetadata): void;