@codingame/monaco-vscode-api 20.4.1 → 21.0.0

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

@@ -0,0 +1,84 @@
+import type * as vscode from "vscode";
+export declare enum NotebookCellKind {
+    Markup = 1,
+    Code = 2
+}
+export declare class NotebookRange {
+    static isNotebookRange(thing: any): thing is vscode.NotebookRange;
+    private _start;
+    private _end;
+    get start(): number;
+    get end(): number;
+    get isEmpty(): boolean;
+    constructor(start: number, end: number);
+    with(change: {
+        start?: number;
+        end?: number;
+    }): NotebookRange;
+}
+export declare class NotebookCellData {
+    static validate(data: NotebookCellData): void;
+    static isNotebookCellDataArray(value: unknown): value is vscode.NotebookCellData[];
+    static isNotebookCellData(value: unknown): value is vscode.NotebookCellData;
+    kind: NotebookCellKind;
+    value: string;
+    languageId: string;
+    mime?: string;
+    outputs?: vscode.NotebookCellOutput[];
+    metadata?: Record<string, any>;
+    executionSummary?: vscode.NotebookCellExecutionSummary;
+    constructor(kind: NotebookCellKind, value: string, languageId: string, mime?: string, outputs?: vscode.NotebookCellOutput[], metadata?: Record<string, any>, executionSummary?: vscode.NotebookCellExecutionSummary);
+}
+export declare class NotebookData {
+    cells: NotebookCellData[];
+    metadata?: {
+        [key: string]: any;
+    };
+    constructor(cells: NotebookCellData[]);
+}
+export declare class NotebookEdit implements vscode.NotebookEdit {
+    static isNotebookCellEdit(thing: any): thing is NotebookEdit;
+    static replaceCells(range: NotebookRange, newCells: NotebookCellData[]): NotebookEdit;
+    static insertCells(index: number, newCells: vscode.NotebookCellData[]): vscode.NotebookEdit;
+    static deleteCells(range: NotebookRange): NotebookEdit;
+    static updateCellMetadata(index: number, newMetadata: {
+        [key: string]: any;
+    }): NotebookEdit;
+    static updateNotebookMetadata(newMetadata: {
+        [key: string]: any;
+    }): NotebookEdit;
+    range: NotebookRange;
+    newCells: NotebookCellData[];
+    newCellMetadata?: {
+        [key: string]: any;
+    };
+    newNotebookMetadata?: {
+        [key: string]: any;
+    };
+    constructor(range: NotebookRange, newCells: NotebookCellData[]);
+}
+export declare class NotebookCellOutputItem {
+    #private;
+    data: Uint8Array;
+    mime: string;
+    static isNotebookCellOutputItem(obj: unknown): obj is vscode.NotebookCellOutputItem;
+    static error(err: Error | {
+        name: string;
+        message?: string;
+        stack?: string;
+    }): NotebookCellOutputItem;
+    static stdout(value: string): NotebookCellOutputItem;
+    static stderr(value: string): NotebookCellOutputItem;
+    static bytes(value: Uint8Array, mime?: string): NotebookCellOutputItem;
+    static text(value: string, mime?: string): NotebookCellOutputItem;
+    static json(value: any, mime?: string): NotebookCellOutputItem;
+    constructor(data: Uint8Array, mime: string);
+}
+export declare class NotebookCellOutput {
+    static isNotebookCellOutput(candidate: any): candidate is vscode.NotebookCellOutput;
+    static ensureUniqueMimeTypes(items: NotebookCellOutputItem[], warn?: boolean): NotebookCellOutputItem[];
+    id: string;
+    items: NotebookCellOutputItem[];
+    metadata?: Record<string, any>;
+    constructor(items: NotebookCellOutputItem[], idOrMetadata?: string | Record<string, any>, metadata?: Record<string, any>);
+}

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

@@ -0,0 +1,229 @@
+
+import { __decorate } from '../../../../../../../external/tslib/tslib.es6.js';
+import { es5ClassCompat } from './es5ClassCompat.js';
+import { illegalArgument } from '../../../../base/common/errors.js';
+import { Mimes, normalizeMimeType, isTextStreamMime } from '../../../../base/common/mime.js';
+import { generateUuid } from '../../../../base/common/uuid.js';
+
+var NotebookEdit_1;
+var NotebookCellKind;
+(function (NotebookCellKind) {
+    NotebookCellKind[NotebookCellKind["Markup"] = 1] = "Markup";
+    NotebookCellKind[NotebookCellKind["Code"] = 2] = "Code";
+})(NotebookCellKind || (NotebookCellKind = {}));
+class NotebookRange {
+    static isNotebookRange(thing) {
+        if (thing instanceof NotebookRange) {
+            return true;
+        }
+        if (!thing) {
+            return false;
+        }
+        return typeof thing.start === 'number'
+            && typeof thing.end === 'number';
+    }
+    get start() {
+        return this._start;
+    }
+    get end() {
+        return this._end;
+    }
+    get isEmpty() {
+        return this._start === this._end;
+    }
+    constructor(start, end) {
+        if (start < 0) {
+            throw illegalArgument('start must be positive');
+        }
+        if (end < 0) {
+            throw illegalArgument('end must be positive');
+        }
+        if (start <= end) {
+            this._start = start;
+            this._end = end;
+        }
+        else {
+            this._start = end;
+            this._end = start;
+        }
+    }
+    with(change) {
+        let start = this._start;
+        let end = this._end;
+        if (change.start !== undefined) {
+            start = change.start;
+        }
+        if (change.end !== undefined) {
+            end = change.end;
+        }
+        if (start === this._start && end === this._end) {
+            return this;
+        }
+        return ( new NotebookRange(start, end));
+    }
+}
+class NotebookCellData {
+    static validate(data) {
+        if (typeof data.kind !== 'number') {
+            throw ( new Error('NotebookCellData MUST have \'kind\' property'));
+        }
+        if (typeof data.value !== 'string') {
+            throw ( new Error('NotebookCellData MUST have \'value\' property'));
+        }
+        if (typeof data.languageId !== 'string') {
+            throw ( new Error('NotebookCellData MUST have \'languageId\' property'));
+        }
+    }
+    static isNotebookCellDataArray(value) {
+        return Array.isArray(value) && value.every(elem => NotebookCellData.isNotebookCellData(elem));
+    }
+    static isNotebookCellData(value) {
+        return true;
+    }
+    constructor(kind, value, languageId, mime, outputs, metadata, executionSummary) {
+        this.kind = kind;
+        this.value = value;
+        this.languageId = languageId;
+        this.mime = mime;
+        this.outputs = outputs ?? [];
+        this.metadata = metadata;
+        this.executionSummary = executionSummary;
+        NotebookCellData.validate(this);
+    }
+}
+class NotebookData {
+    constructor(cells) {
+        this.cells = cells;
+    }
+}
+let NotebookEdit = NotebookEdit_1 = class NotebookEdit {
+    static isNotebookCellEdit(thing) {
+        if (thing instanceof NotebookEdit_1) {
+            return true;
+        }
+        if (!thing) {
+            return false;
+        }
+        return NotebookRange.isNotebookRange(thing)
+            && Array.isArray(thing.newCells);
+    }
+    static replaceCells(range, newCells) {
+        return ( new NotebookEdit_1(range, newCells));
+    }
+    static insertCells(index, newCells) {
+        return ( new NotebookEdit_1(( new NotebookRange(index, index)), newCells));
+    }
+    static deleteCells(range) {
+        return ( new NotebookEdit_1(range, []));
+    }
+    static updateCellMetadata(index, newMetadata) {
+        const edit = ( new NotebookEdit_1(( new NotebookRange(index, index)), []));
+        edit.newCellMetadata = newMetadata;
+        return edit;
+    }
+    static updateNotebookMetadata(newMetadata) {
+        const edit = ( new NotebookEdit_1(( new NotebookRange(0, 0)), []));
+        edit.newNotebookMetadata = newMetadata;
+        return edit;
+    }
+    constructor(range, newCells) {
+        this.range = range;
+        this.newCells = newCells;
+    }
+};
+NotebookEdit = NotebookEdit_1 = ( __decorate([
+    es5ClassCompat
+], NotebookEdit));
+class NotebookCellOutputItem {
+    static isNotebookCellOutputItem(obj) {
+        if (obj instanceof NotebookCellOutputItem) {
+            return true;
+        }
+        if (!obj) {
+            return false;
+        }
+        return typeof obj.mime === 'string'
+            && obj.data instanceof Uint8Array;
+    }
+    static error(err) {
+        const obj = {
+            name: err.name,
+            message: err.message,
+            stack: err.stack
+        };
+        return NotebookCellOutputItem.json(obj, 'application/vnd.code.notebook.error');
+    }
+    static stdout(value) {
+        return NotebookCellOutputItem.text(value, 'application/vnd.code.notebook.stdout');
+    }
+    static stderr(value) {
+        return NotebookCellOutputItem.text(value, 'application/vnd.code.notebook.stderr');
+    }
+    static bytes(value, mime = 'application/octet-stream') {
+        return ( new NotebookCellOutputItem(value, mime));
+    }
+    static #encoder = ( new TextEncoder());
+    static text(value, mime = Mimes.text) {
+        const bytes = NotebookCellOutputItem.#encoder.encode(String(value));
+        return ( new NotebookCellOutputItem(bytes, mime));
+    }
+    static json(value, mime = 'text/x-json') {
+        const rawStr = JSON.stringify(value, undefined, '\t');
+        return NotebookCellOutputItem.text(rawStr, mime);
+    }
+    constructor(data, mime) {
+        this.data = data;
+        this.mime = mime;
+        const mimeNormalized = normalizeMimeType(mime, true);
+        if (!mimeNormalized) {
+            throw ( new Error(
+                `INVALID mime type: ${mime}. Must be in the format "type/subtype[;optionalparameter]"`
+            ));
+        }
+        this.mime = mimeNormalized;
+    }
+}
+class NotebookCellOutput {
+    static isNotebookCellOutput(candidate) {
+        if (candidate instanceof NotebookCellOutput) {
+            return true;
+        }
+        if (!candidate || typeof candidate !== 'object') {
+            return false;
+        }
+        return typeof candidate.id === 'string' && Array.isArray(candidate.items);
+    }
+    static ensureUniqueMimeTypes(items, warn = false) {
+        const seen = ( new Set());
+        const removeIdx = ( new Set());
+        for (let i = 0; i < items.length; i++) {
+            const item = items[i];
+            const normalMime = normalizeMimeType(item.mime);
+            if (!( seen.has(normalMime)) || isTextStreamMime(normalMime)) {
+                seen.add(normalMime);
+                continue;
+            }
+            removeIdx.add(i);
+            if (warn) {
+                console.warn(`DUPLICATED mime type '${item.mime}' will be dropped`);
+            }
+        }
+        if (removeIdx.size === 0) {
+            return items;
+        }
+        return items.filter((_item, index) => !( removeIdx.has(index)));
+    }
+    constructor(items, idOrMetadata, metadata) {
+        this.items = NotebookCellOutput.ensureUniqueMimeTypes(items, true);
+        if (typeof idOrMetadata === 'string') {
+            this.id = idOrMetadata;
+            this.metadata = metadata;
+        }
+        else {
+            this.id = generateUuid();
+            this.metadata = idOrMetadata ?? metadata;
+        }
+    }
+}
+
+export { NotebookCellData, NotebookCellKind, NotebookCellOutput, NotebookCellOutputItem, NotebookData, NotebookEdit, NotebookRange };

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

@@ -0,0 +1,29 @@
+import type * as vscode from "vscode";
+export declare class Position {
+    static Min(...positions: Position[]): Position;
+    static Max(...positions: Position[]): Position;
+    static isPosition(other: any): other is Position;
+    static of(obj: vscode.Position): Position;
+    private _line;
+    private _character;
+    get line(): number;
+    get character(): number;
+    constructor(line: number, character: number);
+    isBefore(other: Position): boolean;
+    isBeforeOrEqual(other: Position): boolean;
+    isAfter(other: Position): boolean;
+    isAfterOrEqual(other: Position): boolean;
+    isEqual(other: Position): boolean;
+    compareTo(other: Position): number;
+    translate(change: {
+        lineDelta?: number;
+        characterDelta?: number;
+    }): Position;
+    translate(lineDelta?: number, characterDelta?: number): Position;
+    with(change: {
+        line?: number;
+        character?: number;
+    }): Position;
+    with(line?: number, character?: number): Position;
+    toJSON(): any;
+}

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

@@ -0,0 +1,169 @@
+
+import { __decorate } from '../../../../../../../external/tslib/tslib.es6.js';
+import { illegalArgument } from '../../../../base/common/errors.js';
+import { es5ClassCompat } from './es5ClassCompat.js';
+
+var Position_1;
+let Position = Position_1 = class Position {
+    static Min(...positions) {
+        if (positions.length === 0) {
+            throw ( new TypeError());
+        }
+        let result = positions[0];
+        for (let i = 1; i < positions.length; i++) {
+            const p = positions[i];
+            if (p.isBefore(result)) {
+                result = p;
+            }
+        }
+        return result;
+    }
+    static Max(...positions) {
+        if (positions.length === 0) {
+            throw ( new TypeError());
+        }
+        let result = positions[0];
+        for (let i = 1; i < positions.length; i++) {
+            const p = positions[i];
+            if (p.isAfter(result)) {
+                result = p;
+            }
+        }
+        return result;
+    }
+    static isPosition(other) {
+        if (!other) {
+            return false;
+        }
+        if (other instanceof Position_1) {
+            return true;
+        }
+        const { line, character } = other;
+        if (typeof line === 'number' && typeof character === 'number') {
+            return true;
+        }
+        return false;
+    }
+    static of(obj) {
+        if (obj instanceof Position_1) {
+            return obj;
+        }
+        else if (this.isPosition(obj)) {
+            return ( new Position_1(obj.line, obj.character));
+        }
+        throw ( new Error('Invalid argument, is NOT a position-like object'));
+    }
+    get line() {
+        return this._line;
+    }
+    get character() {
+        return this._character;
+    }
+    constructor(line, character) {
+        if (line < 0) {
+            throw illegalArgument('line must be non-negative');
+        }
+        if (character < 0) {
+            throw illegalArgument('character must be non-negative');
+        }
+        this._line = line;
+        this._character = character;
+    }
+    isBefore(other) {
+        if (this._line < other._line) {
+            return true;
+        }
+        if (other._line < this._line) {
+            return false;
+        }
+        return this._character < other._character;
+    }
+    isBeforeOrEqual(other) {
+        if (this._line < other._line) {
+            return true;
+        }
+        if (other._line < this._line) {
+            return false;
+        }
+        return this._character <= other._character;
+    }
+    isAfter(other) {
+        return !this.isBeforeOrEqual(other);
+    }
+    isAfterOrEqual(other) {
+        return !this.isBefore(other);
+    }
+    isEqual(other) {
+        return this._line === other._line && this._character === other._character;
+    }
+    compareTo(other) {
+        if (this._line < other._line) {
+            return -1;
+        }
+        else if (this._line > other.line) {
+            return 1;
+        }
+        else {
+            if (this._character < other._character) {
+                return -1;
+            }
+            else if (this._character > other._character) {
+                return 1;
+            }
+            else {
+                return 0;
+            }
+        }
+    }
+    translate(lineDeltaOrChange, characterDelta = 0) {
+        if (lineDeltaOrChange === null || characterDelta === null) {
+            throw illegalArgument();
+        }
+        let lineDelta;
+        if (typeof lineDeltaOrChange === 'undefined') {
+            lineDelta = 0;
+        }
+        else if (typeof lineDeltaOrChange === 'number') {
+            lineDelta = lineDeltaOrChange;
+        }
+        else {
+            lineDelta = typeof lineDeltaOrChange.lineDelta === 'number' ? lineDeltaOrChange.lineDelta : 0;
+            characterDelta = typeof lineDeltaOrChange.characterDelta === 'number' ? lineDeltaOrChange.characterDelta : 0;
+        }
+        if (lineDelta === 0 && characterDelta === 0) {
+            return this;
+        }
+        return ( new Position_1(this.line + lineDelta, this.character + characterDelta));
+    }
+    with(lineOrChange, character = this.character) {
+        if (lineOrChange === null || character === null) {
+            throw illegalArgument();
+        }
+        let line;
+        if (typeof lineOrChange === 'undefined') {
+            line = this.line;
+        }
+        else if (typeof lineOrChange === 'number') {
+            line = lineOrChange;
+        }
+        else {
+            line = typeof lineOrChange.line === 'number' ? lineOrChange.line : this.line;
+            character = typeof lineOrChange.character === 'number' ? lineOrChange.character : this.character;
+        }
+        if (line === this.line && character === this.character) {
+            return this;
+        }
+        return ( new Position_1(line, character));
+    }
+    toJSON() {
+        return { line: this.line, character: this.character };
+    }
+    [Symbol.for('debug.description')]() {
+        return `(${this.line}:${this.character})`;
+    }
+};
+Position = Position_1 = ( __decorate([
+    es5ClassCompat
+], Position));
+
+export { Position };

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

@@ -0,0 +1,26 @@
+import type * as vscode from "vscode";
+import { Position } from "./position.js";
+export declare class Range {
+    static isRange(thing: any): thing is vscode.Range;
+    static of(obj: vscode.Range): Range;
+    protected _start: Position;
+    protected _end: Position;
+    get start(): Position;
+    get end(): Position;
+    constructor(start: vscode.Position, end: vscode.Position);
+    constructor(start: Position, end: Position);
+    constructor(startLine: number, startColumn: number, endLine: number, endColumn: number);
+    contains(positionOrRange: Position | Range): boolean;
+    isEqual(other: Range): boolean;
+    intersection(other: Range): Range | undefined;
+    union(other: Range): Range;
+    get isEmpty(): boolean;
+    get isSingleLine(): boolean;
+    with(change: {
+        start?: Position;
+        end?: Position;
+    }): Range;
+    with(start?: Position, end?: Position): Range;
+    toJSON(): any;
+}
+export declare function getDebugDescriptionOfRange(range: vscode.Range): string;

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

@@ -0,0 +1,137 @@
+
+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';
+
+var Range_1;
+let Range = Range_1 = class Range {
+    static isRange(thing) {
+        if (thing instanceof Range_1) {
+            return true;
+        }
+        if (!thing) {
+            return false;
+        }
+        return Position.isPosition(thing.start)
+            && Position.isPosition(thing.end);
+    }
+    static of(obj) {
+        if (obj instanceof Range_1) {
+            return obj;
+        }
+        if (this.isRange(obj)) {
+            return ( new Range_1(obj.start, obj.end));
+        }
+        throw ( new Error('Invalid argument, is NOT a range-like object'));
+    }
+    get start() {
+        return this._start;
+    }
+    get end() {
+        return this._end;
+    }
+    constructor(startLineOrStart, startColumnOrEnd, endLine, endColumn) {
+        let start;
+        let end;
+        if (typeof startLineOrStart === 'number' && typeof startColumnOrEnd === 'number' && typeof endLine === 'number' && typeof endColumn === 'number') {
+            start = ( new Position(startLineOrStart, startColumnOrEnd));
+            end = ( new Position(endLine, endColumn));
+        }
+        else if (Position.isPosition(startLineOrStart) && Position.isPosition(startColumnOrEnd)) {
+            start = Position.of(startLineOrStart);
+            end = Position.of(startColumnOrEnd);
+        }
+        if (!start || !end) {
+            throw ( new Error('Invalid arguments'));
+        }
+        if (start.isBefore(end)) {
+            this._start = start;
+            this._end = end;
+        }
+        else {
+            this._start = end;
+            this._end = start;
+        }
+    }
+    contains(positionOrRange) {
+        if (Range_1.isRange(positionOrRange)) {
+            return this.contains(positionOrRange.start)
+                && this.contains(positionOrRange.end);
+        }
+        else if (Position.isPosition(positionOrRange)) {
+            if (Position.of(positionOrRange).isBefore(this._start)) {
+                return false;
+            }
+            if (this._end.isBefore(positionOrRange)) {
+                return false;
+            }
+            return true;
+        }
+        return false;
+    }
+    isEqual(other) {
+        return this._start.isEqual(other._start) && this._end.isEqual(other._end);
+    }
+    intersection(other) {
+        const start = Position.Max(other.start, this._start);
+        const end = Position.Min(other.end, this._end);
+        if (start.isAfter(end)) {
+            return undefined;
+        }
+        return ( new Range_1(start, end));
+    }
+    union(other) {
+        if (this.contains(other)) {
+            return this;
+        }
+        else if (other.contains(this)) {
+            return other;
+        }
+        const start = Position.Min(other.start, this._start);
+        const end = Position.Max(other.end, this.end);
+        return ( new Range_1(start, end));
+    }
+    get isEmpty() {
+        return this._start.isEqual(this._end);
+    }
+    get isSingleLine() {
+        return this._start.line === this._end.line;
+    }
+    with(startOrChange, end = this.end) {
+        if (startOrChange === null || end === null) {
+            throw illegalArgument();
+        }
+        let start;
+        if (!startOrChange) {
+            start = this.start;
+        }
+        else if (Position.isPosition(startOrChange)) {
+            start = startOrChange;
+        }
+        else {
+            start = startOrChange.start || this.start;
+            end = startOrChange.end || this.end;
+        }
+        if (start.isEqual(this._start) && end.isEqual(this.end)) {
+            return this;
+        }
+        return ( new Range_1(start, end));
+    }
+    toJSON() {
+        return [this.start, this.end];
+    }
+    [Symbol.for('debug.description')]() {
+        return getDebugDescriptionOfRange(this);
+    }
+};
+Range = Range_1 = ( __decorate([
+    es5ClassCompat
+], Range));
+function getDebugDescriptionOfRange(range) {
+    return range.isEmpty
+        ? `[${range.start.line}:${range.start.character})`
+        : `[${range.start.line}:${range.start.character} -> ${range.end.line}:${range.end.character})`;
+}
+
+export { Range, getDebugDescriptionOfRange };

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

@@ -0,0 +1,20 @@
+import type * as vscode from "vscode";
+import { Position } from "./position.js";
+import { Range } from "./range.js";
+export declare class Selection extends Range {
+    static isSelection(thing: any): thing is Selection;
+    private _anchor;
+    get anchor(): Position;
+    private _active;
+    get active(): Position;
+    constructor(anchor: Position, active: Position);
+    constructor(anchorLine: number, anchorColumn: number, activeLine: number, activeColumn: number);
+    get isReversed(): boolean;
+    toJSON(): {
+        start: Position;
+        end: Position;
+        active: Position;
+        anchor: Position;
+    };
+}
+export declare function getDebugDescriptionOfSelection(selection: vscode.Selection): string;