@codingame/monaco-vscode-api 20.1.1 → 20.2.1

package/vscode/src/vs/editor/common/cursor/cursorTypeEditOperations.d.ts

@@ -23,7 +23,21 @@ export declare class AutoClosingOpenCharTypeOperation {
     static getEdits(config: CursorConfiguration, model: ITextModel, selections: Selection[], ch: string, chIsAlreadyTyped: boolean, isDoingComposition: boolean): EditOperationResult | undefined;
     private static _runAutoClosingOpenCharType;
     static getAutoClosingPairClose(config: CursorConfiguration, model: ITextModel, selections: Selection[], ch: string, chIsAlreadyTyped: boolean): string | null;
+    /**
+     * Find another auto-closing pair that is contained by the one passed in.
+     *
+     * e.g. when having [(,)] and [(*,*)] as auto-closing pairs
+     * this method will find [(,)] as a containment pair for [(*,*)]
+     */
     private static _findContainedAutoClosingPair;
+    /**
+     * Determine if typing `ch` at all `positions` in the `model` results in an
+     * auto closing open sequence being typed.
+     *
+     * Auto closing open sequences can consist of multiple characters, which
+     * can lead to ambiguities. In such a case, the longest auto-closing open
+     * sequence is returned.
+     */
     private static _findAutoClosingPairOpen;
     private static _isBeforeClosingBrace;
 }

package/vscode/src/vs/editor/common/cursor/cursorTypeOperations.d.ts

@@ -11,6 +11,9 @@ export declare class TypeOperations {
     static paste(config: CursorConfiguration, model: ICursorSimpleModel, selections: Selection[], text: string, pasteOnNewLine: boolean, multicursorText: string[]): EditOperationResult;
     static tab(config: CursorConfiguration, model: ITextModel, selections: Selection[]): ICommand[];
     static compositionType(prevEditOperationType: EditOperationType, config: CursorConfiguration, model: ITextModel, selections: Selection[], text: string, replacePrevCharCnt: number, replaceNextCharCnt: number, positionDelta: number): EditOperationResult;
+    /**
+     * This is very similar with typing, but the character is already in the text buffer!
+     */
     static compositionEndWithInterceptors(prevEditOperationType: EditOperationType, config: CursorConfiguration, model: ITextModel, compositions: CompositionOutcome[] | null, selections: Selection[], autoClosedCharacters: Range[]): EditOperationResult | null;
     static typeWithInterceptors(isDoingComposition: boolean, prevEditOperationType: EditOperationType, config: CursorConfiguration, model: ITextModel, selections: Selection[], autoClosedCharacters: Range[], ch: string): EditOperationResult;
     static typeWithoutInterceptors(prevEditOperationType: EditOperationType, config: CursorConfiguration, model: ITextModel, selections: Selection[], str: string): EditOperationResult;

package/vscode/src/vs/editor/common/cursor/oneCursor.d.ts

@@ -1,6 +1,9 @@
 import { CursorState, SingleCursorState } from "../cursorCommon.js";
 import { CursorContext } from "./cursorContext.js";
 import { Selection } from "../core/selection.js";
+/**
+ * Represents a single cursor.
+*/
 export declare class Cursor {
     modelState: SingleCursorState;
     viewState: SingleCursorState;

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

@@ -16,6 +16,10 @@ export interface IColumnSelectData {
     toViewLineNumber: number;
     toViewVisualColumn: number;
 }
+/**
+ * This is an operation type that will be recorded for undo/redo purposes.
+ * The goal is to introduce an undo stop when the controller switches between different operation types.
+ */
 export declare enum EditOperationType {
     Other = 0,
     DeletingLeft = 2,
@@ -71,13 +75,27 @@ export declare class CursorConfiguration {
         [key: string]: boolean;
     };
     get inputMode(): "insert" | "overtype";
+    /**
+     * Should return opening bracket type to match indentation with
+     */
     onElectricCharacter(character: string, context: LineTokens, column: number): IElectricAction | null;
     normalizeIndentation(str: string): string;
     private _getShouldAutoClose;
     private _getLanguageDefinedShouldAutoClose;
+    /**
+     * Returns a visible column from a column.
+     * @see {@link CursorColumns}
+     */
     visibleColumnFromColumn(model: ICursorSimpleModel, position: Position): number;
+    /**
+     * Returns a visible column from a column.
+     * @see {@link CursorColumns}
+     */
     columnFromVisibleColumn(model: ICursorSimpleModel, lineNumber: number, visibleColumn: number): number;
 }
+/**
+ * Represents a simple model (either the model or the view model).
+ */
 export interface ICursorSimpleModel {
     getLineCount(): number;
     getLineContent(lineNumber: number): string;
@@ -86,6 +104,10 @@ export interface ICursorSimpleModel {
     getLineFirstNonWhitespaceColumn(lineNumber: number): number;
     getLineLastNonWhitespaceColumn(lineNumber: number): number;
     normalizePosition(position: Position, affinity: PositionAffinity): Position;
+    /**
+     * Gets the column at which indentation stops at a given line.
+     * @internal
+     */
     getLineIndentColumn(lineNumber: number): number;
 }
 export type PartialCursorState = CursorState | PartialModelCursorState | PartialViewCursorState;
@@ -115,6 +137,9 @@ export declare enum SelectionStartKind {
     Word = 1,
     Line = 2
 }
+/**
+ * Represents the cursor state on either the model or on the view model.
+ */
 export declare class SingleCursorState {
     readonly selectionStart: Range;
     readonly selectionStartKind: SelectionStartKind;

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

@@ -1,26 +1,89 @@
 import { Position } from "./core/position.js";
 import { Selection } from "./core/selection.js";
+/**
+ * Describes the reason the cursor has changed its position.
+ */
 export declare enum CursorChangeReason {
+    /**
+     * Unknown or not set.
+     */
     NotSet = 0,
+    /**
+     * A `model.setValue()` was called.
+     */
     ContentFlush = 1,
+    /**
+     * The `model` has been changed outside of this cursor and the cursor recovers its position from associated markers.
+     */
     RecoverFromMarkers = 2,
+    /**
+     * There was an explicit user gesture.
+     */
     Explicit = 3,
+    /**
+     * There was a Paste.
+     */
     Paste = 4,
+    /**
+     * There was an Undo.
+     */
     Undo = 5,
+    /**
+     * There was a Redo.
+     */
     Redo = 6
 }
+/**
+ * An event describing that the cursor position has changed.
+ */
 export interface ICursorPositionChangedEvent {
+    /**
+     * Primary cursor's position.
+     */
     readonly position: Position;
+    /**
+     * Secondary cursors' position.
+     */
     readonly secondaryPositions: Position[];
+    /**
+     * Reason.
+     */
     readonly reason: CursorChangeReason;
+    /**
+     * Source of the call that caused the event.
+     */
     readonly source: string;
 }
+/**
+ * An event describing that the cursor selection has changed.
+ */
 export interface ICursorSelectionChangedEvent {
+    /**
+     * The primary selection.
+     */
     readonly selection: Selection;
+    /**
+     * The secondary selections.
+     */
     readonly secondarySelections: Selection[];
+    /**
+     * The model version id.
+     */
     readonly modelVersionId: number;
+    /**
+     * The old selections.
+     */
     readonly oldSelections: Selection[] | null;
+    /**
+     * The model version id the that `oldSelections` refer to.
+     */
     readonly oldModelVersionId: number;
+    /**
+     * Source of the call that caused the event.
+     */
     readonly source: string;
+    /**
+     * Reason.
+     */
     readonly reason: CursorChangeReason;
 }

package/vscode/src/vs/editor/common/diff/defaultLinesDiffComputer/algorithms/diffAlgorithm.d.ts

@@ -1,13 +1,25 @@
 import { OffsetRange } from "../../../core/ranges/offsetRange.js";
+/**
+ * Represents a synchronous diff algorithm. Should be executed in a worker.
+*/
 export interface IDiffAlgorithm {
     compute(sequence1: ISequence, sequence2: ISequence, timeout?: ITimeout): DiffAlgorithmResult;
 }
 export declare class DiffAlgorithmResult {
     readonly diffs: SequenceDiff[];
+    /**
+     * Indicates if the time out was reached.
+     * In that case, the diffs might be an approximation and the user should be asked to rerun the diff with more time.
+     */
     readonly hitTimeout: boolean;
     static trivial(seq1: ISequence, seq2: ISequence): DiffAlgorithmResult;
     static trivialTimedOut(seq1: ISequence, seq2: ISequence): DiffAlgorithmResult;
-    constructor(diffs: SequenceDiff[], hitTimeout: boolean);
+    constructor(diffs: SequenceDiff[], 
+    /**
+     * Indicates if the time out was reached.
+     * In that case, the diffs might be an approximation and the user should be asked to rerun the diff with more time.
+     */
+    hitTimeout: boolean);
 }
 export declare class SequenceDiff {
     readonly seq1Range: OffsetRange;
@@ -40,7 +52,17 @@ export declare class OffsetPair {
 export interface ISequence {
     getElement(offset: number): number;
     get length(): number;
+    /**
+     * The higher the score, the better that offset can be used to split the sequence.
+     * Is used to optimize insertions.
+     * Must not be negative.
+    */
     getBoundaryScore?(length: number): number;
+    /**
+     * For line sequences, getElement returns a number representing trimmed lines.
+     * This however checks equality for the original lines.
+     * It prevents shifting to less matching lines.
+     */
     isStronglyEqual(offset1: number, offset2: number): boolean;
 }
 export interface ITimeout {

package/vscode/src/vs/editor/common/diff/defaultLinesDiffComputer/algorithms/dynamicProgrammingDiffing.d.ts

@@ -1,4 +1,8 @@
 import { IDiffAlgorithm, ISequence, ITimeout, DiffAlgorithmResult } from "./diffAlgorithm.js";
+/**
+ * A O(MN) diffing algorithm that supports a score function.
+ * The algorithm can be improved by processing the 2d array diagonally.
+*/
 export declare class DynamicProgrammingDiffing implements IDiffAlgorithm {
     compute(sequence1: ISequence, sequence2: ISequence, timeout?: ITimeout, equalityScore?: (offset1: number, offset2: number) => number): DiffAlgorithmResult;
 }

package/vscode/src/vs/editor/common/diff/defaultLinesDiffComputer/algorithms/myersDiffAlgorithm.d.ts

@@ -1,4 +1,7 @@
 import { DiffAlgorithmResult, IDiffAlgorithm, ISequence, ITimeout } from "./diffAlgorithm.js";
+/**
+ * An O(ND) diff algorithm that has a quadratic space worst-case complexity.
+*/
 export declare class MyersDiffAlgorithm implements IDiffAlgorithm {
     compute(seq1: ISequence, seq2: ISequence, timeout?: ITimeout): DiffAlgorithmResult;
 }

package/vscode/src/vs/editor/common/diff/defaultLinesDiffComputer/linesSliceCharSequence.d.ts

@@ -19,7 +19,11 @@ export declare class LinesSliceCharSequence implements ISequence {
     getBoundaryScore(length: number): number;
     translateOffset(offset: number, preference?: "left" | "right"): Position;
     translateRange(range: OffsetRange): Range;
+    /**
+     * Finds the word that contains the character at the given offset
+     */
     findWordContaining(offset: number): OffsetRange | undefined;
+    /** fooBar has the two sub-words foo and bar */
     findSubWordContaining(offset: number): OffsetRange | undefined;
     countLinesIn(range: OffsetRange): number;
     isStronglyEqual(offset1: number, offset2: number): boolean;

package/vscode/src/vs/editor/common/diff/legacyLinesDiffComputer.d.ts

@@ -6,21 +6,37 @@ export declare class LegacyLinesDiffComputer implements ILinesDiffComputer {
 export interface IDiffComputationResult {
     quitEarly: boolean;
     identical: boolean;
+    /**
+     * The changes as (legacy) line change array.
+     * @deprecated Use `changes2` instead.
+     */
     changes: ILineChange[];
+    /**
+     * The changes as (modern) line range mapping array.
+     */
     changes2: readonly DetailedLineRangeMapping[];
 }
+/**
+ * A change
+ */
 export interface IChange {
     readonly originalStartLineNumber: number;
     readonly originalEndLineNumber: number;
     readonly modifiedStartLineNumber: number;
     readonly modifiedEndLineNumber: number;
 }
+/**
+ * A character level change.
+ */
 export interface ICharChange extends IChange {
     readonly originalStartColumn: number;
     readonly originalEndColumn: number;
     readonly modifiedStartColumn: number;
     readonly modifiedEndColumn: number;
 }
+/**
+ * A line change
+ */
 export interface ILineChange extends IChange {
     readonly charChanges: ICharChange[] | undefined;
 }

package/vscode/src/vs/editor/common/diff/linesDiffComputer.d.ts

@@ -10,12 +10,35 @@ export interface ILinesDiffComputerOptions {
 }
 export declare class LinesDiff {
     readonly changes: readonly DetailedLineRangeMapping[];
+    /**
+     * Sorted by original line ranges.
+     * The original line ranges and the modified line ranges must be disjoint (but can be touching).
+     */
     readonly moves: readonly MovedText[];
+    /**
+     * Indicates if the time out was reached.
+     * In that case, the diffs might be an approximation and the user should be asked to rerun the diff with more time.
+     */
     readonly hitTimeout: boolean;
-    constructor(changes: readonly DetailedLineRangeMapping[], moves: readonly MovedText[], hitTimeout: boolean);
+    constructor(changes: readonly DetailedLineRangeMapping[], 
+    /**
+     * Sorted by original line ranges.
+     * The original line ranges and the modified line ranges must be disjoint (but can be touching).
+     */
+    moves: readonly MovedText[], 
+    /**
+     * Indicates if the time out was reached.
+     * In that case, the diffs might be an approximation and the user should be asked to rerun the diff with more time.
+     */
+    hitTimeout: boolean);
 }
 export declare class MovedText {
     readonly lineRangeMapping: LineRangeMapping;
+    /**
+     * The diff from the original text to the moved text.
+     * Must be contained in the original/modified line range.
+     * Can be empty if the text didn't change (only moved).
+     */
     readonly changes: readonly DetailedLineRangeMapping[];
     constructor(lineRangeMapping: LineRangeMapping, changes: readonly DetailedLineRangeMapping[]);
     flip(): MovedText;

package/vscode/src/vs/editor/common/diff/rangeMapping.d.ts

@@ -3,37 +3,78 @@ import { Range } from "../core/range.js";
 import { TextReplacement, TextEdit } from "../core/edits/textEdit.js";
 import { AbstractText } from "../core/text/abstractText.js";
 import { IChange } from "./legacyLinesDiffComputer.js";
+/**
+ * Maps a line range in the original text model to a line range in the modified text model.
+ */
 export declare class LineRangeMapping {
     static inverse(mapping: readonly LineRangeMapping[], originalLineCount: number, modifiedLineCount: number): LineRangeMapping[];
     static clip(mapping: readonly LineRangeMapping[], originalRange: LineRange, modifiedRange: LineRange): LineRangeMapping[];
+    /**
+     * The line range in the original text model.
+     */
     readonly original: LineRange;
+    /**
+     * The line range in the modified text model.
+     */
     readonly modified: LineRange;
     constructor(originalRange: LineRange, modifiedRange: LineRange);
     toString(): string;
     flip(): LineRangeMapping;
     join(other: LineRangeMapping): LineRangeMapping;
     get changedLineCount(): number;
+    /**
+     * This method assumes that the LineRangeMapping describes a valid diff!
+     * I.e. if one range is empty, the other range cannot be the entire document.
+     * It avoids various problems when the line range points to non-existing line-numbers.
+    */
     toRangeMapping(): RangeMapping;
+    /**
+     * This method assumes that the LineRangeMapping describes a valid diff!
+     * I.e. if one range is empty, the other range cannot be the entire document.
+     * It avoids various problems when the line range points to non-existing line-numbers.
+    */
     toRangeMapping2(original: string[], modified: string[]): RangeMapping;
 }
+/**
+ * Maps a line range in the original text model to a line range in the modified text model.
+ * Also contains inner range mappings.
+ */
 export declare class DetailedLineRangeMapping extends LineRangeMapping {
     static toTextEdit(mapping: readonly DetailedLineRangeMapping[], modified: AbstractText): TextEdit;
     static fromRangeMappings(rangeMappings: RangeMapping[]): DetailedLineRangeMapping;
+    /**
+     * If inner changes have not been computed, this is set to undefined.
+     * Otherwise, it represents the character-level diff in this line range.
+     * The original range of each range mapping should be contained in the original line range (same for modified), exceptions are new-lines.
+     * Must not be an empty array.
+     */
     readonly innerChanges: RangeMapping[] | undefined;
     constructor(originalRange: LineRange, modifiedRange: LineRange, innerChanges: RangeMapping[] | undefined);
     flip(): DetailedLineRangeMapping;
     withInnerChangesFromLineRanges(): DetailedLineRangeMapping;
 }
+/**
+ * Maps a range in the original text model to a range in the modified text model.
+ */
 export declare class RangeMapping {
     static fromEdit(edit: TextEdit): RangeMapping[];
     static fromEditJoin(edit: TextEdit): RangeMapping;
     static join(rangeMappings: RangeMapping[]): RangeMapping;
     static assertSorted(rangeMappings: RangeMapping[]): void;
+    /**
+     * The original range.
+     */
     readonly originalRange: Range;
+    /**
+     * The modified range.
+     */
     readonly modifiedRange: Range;
     constructor(originalRange: Range, modifiedRange: Range);
     toString(): string;
     flip(): RangeMapping;
+    /**
+     * Creates a single text edit that describes the change from the original to the modified text.
+    */
     toTextEdit(modified: AbstractText): TextReplacement;
     join(other: RangeMapping): RangeMapping;
 }