@codingame/monaco-vscode-api 20.5.0 → 21.0.1

package/vscode/src/vs/workbench/api/common/extHostTypes/selection.js

@@ -0,0 +1,76 @@
+
+import { __decorate } from '../../../../../../../external/tslib/tslib.es6.js';
+import { es5ClassCompat } from './es5ClassCompat.js';
+import { Position } from './position.js';
+import { Range, getDebugDescriptionOfRange } from './range.js';
+
+var Selection_1;
+let Selection = Selection_1 = class Selection extends Range {
+    static isSelection(thing) {
+        if (thing instanceof Selection_1) {
+            return true;
+        }
+        if (!thing) {
+            return false;
+        }
+        return Range.isRange(thing)
+            && Position.isPosition(thing.anchor)
+            && Position.isPosition(thing.active)
+            && typeof thing.isReversed === 'boolean';
+    }
+    get anchor() {
+        return this._anchor;
+    }
+    get active() {
+        return this._active;
+    }
+    constructor(anchorLineOrAnchor, anchorColumnOrActive, activeLine, activeColumn) {
+        let anchor;
+        let active;
+        if (typeof anchorLineOrAnchor === 'number' && typeof anchorColumnOrActive === 'number' && typeof activeLine === 'number' && typeof activeColumn === 'number') {
+            anchor = ( new Position(anchorLineOrAnchor, anchorColumnOrActive));
+            active = ( new Position(activeLine, activeColumn));
+        }
+        else if (Position.isPosition(anchorLineOrAnchor) && Position.isPosition(anchorColumnOrActive)) {
+            anchor = Position.of(anchorLineOrAnchor);
+            active = Position.of(anchorColumnOrActive);
+        }
+        if (!anchor || !active) {
+            throw ( new Error('Invalid arguments'));
+        }
+        super(anchor, active);
+        this._anchor = anchor;
+        this._active = active;
+    }
+    get isReversed() {
+        return this._anchor === this._end;
+    }
+    toJSON() {
+        return {
+            start: this.start,
+            end: this.end,
+            active: this.active,
+            anchor: this.anchor
+        };
+    }
+    [Symbol.for('debug.description')]() {
+        return getDebugDescriptionOfSelection(this);
+    }
+};
+Selection = Selection_1 = ( __decorate([
+    es5ClassCompat
+], Selection));
+function getDebugDescriptionOfSelection(selection) {
+    let rangeStr = getDebugDescriptionOfRange(selection);
+    if (!selection.isEmpty) {
+        if (selection.active.isEqual(selection.start)) {
+            rangeStr = `|${rangeStr}`;
+        }
+        else {
+            rangeStr = `${rangeStr}|`;
+        }
+    }
+    return rangeStr;
+}
+
+export { Selection, getDebugDescriptionOfSelection };

package/vscode/src/vs/workbench/api/common/extHostTypes/snippetString.d.ts

@@ -0,0 +1,12 @@
+export declare class SnippetString {
+    static isSnippetString(thing: any): thing is SnippetString;
+    private static _escape;
+    private _tabstop;
+    value: string;
+    constructor(value?: string);
+    appendText(string: string): SnippetString;
+    appendTabstop(number?: number): SnippetString;
+    appendPlaceholder(value: string | ((snippet: SnippetString) => any), number?: number): SnippetString;
+    appendChoice(values: string[], number?: number): SnippetString;
+    appendVariable(name: string, defaultValue?: string | ((snippet: SnippetString) => any)): SnippetString;
+}

package/vscode/src/vs/workbench/api/common/extHostTypes/snippetString.js

@@ -0,0 +1,84 @@
+
+import { __decorate } from '../../../../../../../external/tslib/tslib.es6.js';
+import { es5ClassCompat } from './es5ClassCompat.js';
+
+var SnippetString_1;
+let SnippetString = SnippetString_1 = class SnippetString {
+    static isSnippetString(thing) {
+        if (thing instanceof SnippetString_1) {
+            return true;
+        }
+        if (!thing) {
+            return false;
+        }
+        return typeof thing.value === 'string';
+    }
+    static _escape(value) {
+        return value.replace(/\$|}|\\/g, '\\$&');
+    }
+    constructor(value) {
+        this._tabstop = 1;
+        this.value = value || '';
+    }
+    appendText(string) {
+        this.value += SnippetString_1._escape(string);
+        return this;
+    }
+    appendTabstop(number = this._tabstop++) {
+        this.value += '$';
+        this.value += number;
+        return this;
+    }
+    appendPlaceholder(value, number = this._tabstop++) {
+        if (typeof value === 'function') {
+            const nested = ( new SnippetString_1());
+            nested._tabstop = this._tabstop;
+            value(nested);
+            this._tabstop = nested._tabstop;
+            value = nested.value;
+        }
+        else {
+            value = SnippetString_1._escape(value);
+        }
+        this.value += '${';
+        this.value += number;
+        this.value += ':';
+        this.value += value;
+        this.value += '}';
+        return this;
+    }
+    appendChoice(values, number = this._tabstop++) {
+        const value = ( values.map(s => s.replaceAll(/[|\\,]/g, '\\$&'))).join(',');
+        this.value += '${';
+        this.value += number;
+        this.value += '|';
+        this.value += value;
+        this.value += '|}';
+        return this;
+    }
+    appendVariable(name, defaultValue) {
+        if (typeof defaultValue === 'function') {
+            const nested = ( new SnippetString_1());
+            nested._tabstop = this._tabstop;
+            defaultValue(nested);
+            this._tabstop = nested._tabstop;
+            defaultValue = nested.value;
+        }
+        else if (typeof defaultValue === 'string') {
+            defaultValue = defaultValue.replace(/\$|}/g, '\\$&');
+        }
+        this.value += '${';
+        this.value += name;
+        if (defaultValue) {
+            this.value += ':';
+            this.value += defaultValue;
+        }
+        this.value += '}';
+        return this;
+    }
+};
+SnippetString = SnippetString_1 = ( __decorate([
+    es5ClassCompat
+], SnippetString));
+
+export { SnippetString };

package/vscode/src/vs/workbench/api/common/extHostTypes/snippetTextEdit.d.ts

@@ -0,0 +1,13 @@
+import type * as vscode from "vscode";
+import { SnippetString } from "./snippetString.js";
+import { Position } from "./position.js";
+import { Range } from "./range.js";
+export declare class SnippetTextEdit implements vscode.SnippetTextEdit {
+    static isSnippetTextEdit(thing: any): thing is SnippetTextEdit;
+    static replace(range: Range, snippet: SnippetString): SnippetTextEdit;
+    static insert(position: Position, snippet: SnippetString): SnippetTextEdit;
+    range: Range;
+    snippet: SnippetString;
+    keepWhitespace?: boolean;
+    constructor(range: Range, snippet: SnippetString);
+}

package/vscode/src/vs/workbench/api/common/extHostTypes/snippetTextEdit.js

@@ -0,0 +1,28 @@
+
+import { SnippetString } from './snippetString.js';
+import { Range } from './range.js';
+
+class SnippetTextEdit {
+    static isSnippetTextEdit(thing) {
+        if (thing instanceof SnippetTextEdit) {
+            return true;
+        }
+        if (!thing) {
+            return false;
+        }
+        return Range.isRange(thing.range)
+            && SnippetString.isSnippetString(thing.snippet);
+    }
+    static replace(range, snippet) {
+        return ( new SnippetTextEdit(range, snippet));
+    }
+    static insert(position, snippet) {
+        return SnippetTextEdit.replace(( new Range(position, position)), snippet);
+    }
+    constructor(range, snippet) {
+        this.range = range;
+        this.snippet = snippet;
+    }
+}
+
+export { SnippetTextEdit };

package/vscode/src/vs/workbench/api/common/extHostTypes/symbolInformation.d.ts

@@ -0,0 +1,45 @@
+import { URI } from "../../../../base/common/uri.js";
+import { Location } from "./location.js";
+import { Range } from "./range.js";
+export declare enum SymbolKind {
+    File = 0,
+    Module = 1,
+    Namespace = 2,
+    Package = 3,
+    Class = 4,
+    Method = 5,
+    Property = 6,
+    Field = 7,
+    Constructor = 8,
+    Enum = 9,
+    Interface = 10,
+    Function = 11,
+    Variable = 12,
+    Constant = 13,
+    String = 14,
+    Number = 15,
+    Boolean = 16,
+    Array = 17,
+    Object = 18,
+    Key = 19,
+    Null = 20,
+    EnumMember = 21,
+    Struct = 22,
+    Event = 23,
+    Operator = 24,
+    TypeParameter = 25
+}
+export declare enum SymbolTag {
+    Deprecated = 1
+}
+export declare class SymbolInformation {
+    static validate(candidate: SymbolInformation): void;
+    name: string;
+    location: Location;
+    kind: SymbolKind;
+    tags?: SymbolTag[];
+    containerName: string | undefined;
+    constructor(name: string, kind: SymbolKind, containerName: string | undefined, location: Location);
+    constructor(name: string, kind: SymbolKind, range: Range, uri?: URI, containerName?: string);
+    toJSON(): any;
+}

package/vscode/src/vs/workbench/api/common/extHostTypes/symbolInformation.js

@@ -0,0 +1,75 @@
+
+import { __decorate } from '../../../../../../../external/tslib/tslib.es6.js';
+import { es5ClassCompat } from './es5ClassCompat.js';
+import { Location } from './location.js';
+import { Range } from './range.js';
+
+var SymbolInformation_1;
+var SymbolKind;
+(function (SymbolKind) {
+    SymbolKind[SymbolKind["File"] = 0] = "File";
+    SymbolKind[SymbolKind["Module"] = 1] = "Module";
+    SymbolKind[SymbolKind["Namespace"] = 2] = "Namespace";
+    SymbolKind[SymbolKind["Package"] = 3] = "Package";
+    SymbolKind[SymbolKind["Class"] = 4] = "Class";
+    SymbolKind[SymbolKind["Method"] = 5] = "Method";
+    SymbolKind[SymbolKind["Property"] = 6] = "Property";
+    SymbolKind[SymbolKind["Field"] = 7] = "Field";
+    SymbolKind[SymbolKind["Constructor"] = 8] = "Constructor";
+    SymbolKind[SymbolKind["Enum"] = 9] = "Enum";
+    SymbolKind[SymbolKind["Interface"] = 10] = "Interface";
+    SymbolKind[SymbolKind["Function"] = 11] = "Function";
+    SymbolKind[SymbolKind["Variable"] = 12] = "Variable";
+    SymbolKind[SymbolKind["Constant"] = 13] = "Constant";
+    SymbolKind[SymbolKind["String"] = 14] = "String";
+    SymbolKind[SymbolKind["Number"] = 15] = "Number";
+    SymbolKind[SymbolKind["Boolean"] = 16] = "Boolean";
+    SymbolKind[SymbolKind["Array"] = 17] = "Array";
+    SymbolKind[SymbolKind["Object"] = 18] = "Object";
+    SymbolKind[SymbolKind["Key"] = 19] = "Key";
+    SymbolKind[SymbolKind["Null"] = 20] = "Null";
+    SymbolKind[SymbolKind["EnumMember"] = 21] = "EnumMember";
+    SymbolKind[SymbolKind["Struct"] = 22] = "Struct";
+    SymbolKind[SymbolKind["Event"] = 23] = "Event";
+    SymbolKind[SymbolKind["Operator"] = 24] = "Operator";
+    SymbolKind[SymbolKind["TypeParameter"] = 25] = "TypeParameter";
+})(SymbolKind || (SymbolKind = {}));
+var SymbolTag;
+(function (SymbolTag) {
+    SymbolTag[SymbolTag["Deprecated"] = 1] = "Deprecated";
+})(SymbolTag || (SymbolTag = {}));
+let SymbolInformation = SymbolInformation_1 = class SymbolInformation {
+    static validate(candidate) {
+        if (!candidate.name) {
+            throw ( new Error('name must not be falsy'));
+        }
+    }
+    constructor(name, kind, rangeOrContainer, locationOrUri, containerName) {
+        this.name = name;
+        this.kind = kind;
+        this.containerName = containerName;
+        if (typeof rangeOrContainer === 'string') {
+            this.containerName = rangeOrContainer;
+        }
+        if (locationOrUri instanceof Location) {
+            this.location = locationOrUri;
+        }
+        else if (rangeOrContainer instanceof Range) {
+            this.location = ( new Location(locationOrUri, rangeOrContainer));
+        }
+        SymbolInformation_1.validate(this);
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            kind: SymbolKind[this.kind],
+            location: this.location,
+            containerName: this.containerName
+        };
+    }
+};
+SymbolInformation = SymbolInformation_1 = ( __decorate([
+    es5ClassCompat
+], SymbolInformation));
+
+export { SymbolInformation, SymbolKind, SymbolTag };

package/vscode/src/vs/workbench/api/common/extHostTypes/textEdit.d.ts

@@ -0,0 +1,24 @@
+import { Position } from "./position.js";
+import { Range } from "./range.js";
+export declare enum EndOfLine {
+    LF = 1,
+    CRLF = 2
+}
+export declare class TextEdit {
+    static isTextEdit(thing: any): thing is TextEdit;
+    static replace(range: Range, newText: string): TextEdit;
+    static insert(position: Position, newText: string): TextEdit;
+    static delete(range: Range): TextEdit;
+    static setEndOfLine(eol: EndOfLine): TextEdit;
+    protected _range: Range;
+    protected _newText: string | null;
+    protected _newEol?: EndOfLine;
+    get range(): Range;
+    set range(value: Range);
+    get newText(): string;
+    set newText(value: string);
+    get newEol(): EndOfLine | undefined;
+    set newEol(value: EndOfLine | undefined);
+    constructor(range: Range, newText: string | null);
+    toJSON(): any;
+}

package/vscode/src/vs/workbench/api/common/extHostTypes/textEdit.js

@@ -0,0 +1,82 @@
+
+import { __decorate } from '../../../../../../../external/tslib/tslib.es6.js';
+import { illegalArgument } from '../../../../base/common/errors.js';
+import { es5ClassCompat } from './es5ClassCompat.js';
+import { Position } from './position.js';
+import { Range } from './range.js';
+
+var TextEdit_1;
+var EndOfLine;
+(function (EndOfLine) {
+    EndOfLine[EndOfLine["LF"] = 1] = "LF";
+    EndOfLine[EndOfLine["CRLF"] = 2] = "CRLF";
+})(EndOfLine || (EndOfLine = {}));
+let TextEdit = TextEdit_1 = class TextEdit {
+    static isTextEdit(thing) {
+        if (thing instanceof TextEdit_1) {
+            return true;
+        }
+        if (!thing) {
+            return false;
+        }
+        return Range.isRange(thing)
+            && typeof thing.newText === 'string';
+    }
+    static replace(range, newText) {
+        return ( new TextEdit_1(range, newText));
+    }
+    static insert(position, newText) {
+        return TextEdit_1.replace(( new Range(position, position)), newText);
+    }
+    static delete(range) {
+        return TextEdit_1.replace(range, '');
+    }
+    static setEndOfLine(eol) {
+        const ret = ( new TextEdit_1(( new Range(( new Position(0, 0)), ( new Position(0, 0)))), ''));
+        ret.newEol = eol;
+        return ret;
+    }
+    get range() {
+        return this._range;
+    }
+    set range(value) {
+        if (value && !Range.isRange(value)) {
+            throw illegalArgument('range');
+        }
+        this._range = value;
+    }
+    get newText() {
+        return this._newText || '';
+    }
+    set newText(value) {
+        if (value && typeof value !== 'string') {
+            throw illegalArgument('newText');
+        }
+        this._newText = value;
+    }
+    get newEol() {
+        return this._newEol;
+    }
+    set newEol(value) {
+        if (value && typeof value !== 'number') {
+            throw illegalArgument('newEol');
+        }
+        this._newEol = value;
+    }
+    constructor(range, newText) {
+        this._range = range;
+        this._newText = newText;
+    }
+    toJSON() {
+        return {
+            range: this.range,
+            newText: this.newText,
+            newEol: this._newEol
+        };
+    }
+};
+TextEdit = TextEdit_1 = ( __decorate([
+    es5ClassCompat
+], TextEdit));
+
+export { EndOfLine, TextEdit };

package/vscode/src/vs/workbench/api/common/extHostTypes/workspaceEdit.d.ts

@@ -0,0 +1,99 @@
+import type * as vscode from "vscode";
+import { URI } from "../../../../base/common/uri.js";
+import { ICellMetadataEdit, IDocumentMetadataEdit } from "../../../contrib/notebook/common/notebookCommon.js";
+import { NotebookEdit } from "./notebooks.js";
+import { SnippetTextEdit } from "./snippetTextEdit.js";
+import { Position } from "./position.js";
+import { Range } from "./range.js";
+import { TextEdit } from "./textEdit.js";
+export interface IFileOperationOptions {
+    readonly overwrite?: boolean;
+    readonly ignoreIfExists?: boolean;
+    readonly ignoreIfNotExists?: boolean;
+    readonly recursive?: boolean;
+    readonly contents?: Uint8Array | vscode.DataTransferFile;
+}
+export declare enum FileEditType {
+    File = 1,
+    Text = 2,
+    Cell = 3,
+    CellReplace = 5,
+    Snippet = 6
+}
+export interface IFileOperation {
+    readonly _type: FileEditType.File;
+    readonly from?: URI;
+    readonly to?: URI;
+    readonly options?: IFileOperationOptions;
+    readonly metadata?: vscode.WorkspaceEditEntryMetadata;
+}
+export interface IFileTextEdit {
+    readonly _type: FileEditType.Text;
+    readonly uri: URI;
+    readonly edit: TextEdit;
+    readonly metadata?: vscode.WorkspaceEditEntryMetadata;
+}
+export interface IFileSnippetTextEdit {
+    readonly _type: FileEditType.Snippet;
+    readonly uri: URI;
+    readonly range: vscode.Range;
+    readonly edit: vscode.SnippetString;
+    readonly metadata?: vscode.WorkspaceEditEntryMetadata;
+    readonly keepWhitespace?: boolean;
+}
+export interface IFileCellEdit {
+    readonly _type: FileEditType.Cell;
+    readonly uri: URI;
+    readonly edit?: ICellMetadataEdit | IDocumentMetadataEdit;
+    readonly metadata?: vscode.WorkspaceEditEntryMetadata;
+}
+export interface ICellEdit {
+    readonly _type: FileEditType.CellReplace;
+    readonly metadata?: vscode.WorkspaceEditEntryMetadata;
+    readonly uri: URI;
+    readonly index: number;
+    readonly count: number;
+    readonly cells: vscode.NotebookCellData[];
+}
+export type WorkspaceEditEntry = IFileOperation | IFileTextEdit | IFileSnippetTextEdit | IFileCellEdit | ICellEdit;
+export declare class WorkspaceEdit implements vscode.WorkspaceEdit {
+    private readonly _edits;
+    _allEntries(): ReadonlyArray<WorkspaceEditEntry>;
+    renameFile(from: vscode.Uri, to: vscode.Uri, options?: {
+        readonly overwrite?: boolean;
+        readonly ignoreIfExists?: boolean;
+    }, metadata?: vscode.WorkspaceEditEntryMetadata): void;
+    createFile(uri: vscode.Uri, options?: {
+        readonly overwrite?: boolean;
+        readonly ignoreIfExists?: boolean;
+        readonly contents?: Uint8Array | vscode.DataTransferFile;
+    }, metadata?: vscode.WorkspaceEditEntryMetadata): void;
+    deleteFile(uri: vscode.Uri, options?: {
+        readonly recursive?: boolean;
+        readonly ignoreIfNotExists?: boolean;
+    }, metadata?: vscode.WorkspaceEditEntryMetadata): void;
+    private replaceNotebookMetadata;
+    private replaceNotebookCells;
+    private replaceNotebookCellMetadata;
+    replace(uri: URI, range: Range, newText: string, metadata?: vscode.WorkspaceEditEntryMetadata): void;
+    insert(resource: URI, position: Position, newText: string, metadata?: vscode.WorkspaceEditEntryMetadata): void;
+    delete(resource: URI, range: Range, metadata?: vscode.WorkspaceEditEntryMetadata): void;
+    has(uri: URI): boolean;
+    set(uri: URI, edits: ReadonlyArray<TextEdit | SnippetTextEdit>): void;
+    set(uri: URI, edits: ReadonlyArray<[
+        TextEdit | SnippetTextEdit,
+        vscode.WorkspaceEditEntryMetadata | undefined
+    ]>): void;
+    set(uri: URI, edits: readonly NotebookEdit[]): void;
+    set(uri: URI, edits: ReadonlyArray<[
+        NotebookEdit,
+        vscode.WorkspaceEditEntryMetadata | undefined
+    ]>): void;
+    get(uri: URI): TextEdit[];
+    entries(): [
+        URI,
+        TextEdit[]
+    ][];
+    get size(): number;
+    toJSON(): any;
+}