@depup/vscode-languageserver 10.1.1-depup.0

package/lib/common/inlineCompletion.js

@@ -0,0 +1,22 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InlineCompletionFeature = void 0;
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const InlineCompletionFeature = (Base) => {
+    return class extends Base {
+        get inlineCompletion() {
+            return {
+                on: (handler) => {
+                    return this.connection.onRequest(vscode_languageserver_protocol_1.InlineCompletionRequest.type, (params, cancel) => {
+                        return handler(params, cancel, this.attachWorkDoneProgress(params));
+                    });
+                }
+            };
+        }
+    };
+};
+exports.InlineCompletionFeature = InlineCompletionFeature;

package/lib/common/inlineValue.d.ts

@@ -0,0 +1,22 @@
+import { InlineValue, Disposable, InlineValueParams } from 'vscode-languageserver-protocol';
+import type { Feature, _Languages, ServerRequestHandler } from './server';
+/**
+ * Shape of the inline values feature
+ *
+ * @since 3.17.0
+ */
+export interface InlineValueFeatureShape {
+    inlineValue: {
+        /**
+         * Ask the client to refresh all inline values.
+         */
+        refresh(): Promise<void>;
+        /**
+         * Installs a handler for the inline values request.
+         *
+         * @param handler The corresponding handler.
+         */
+        on(handler: ServerRequestHandler<InlineValueParams, InlineValue[] | undefined | null, InlineValue[], void>): Disposable;
+    };
+}
+export declare const InlineValueFeature: Feature<_Languages, InlineValueFeatureShape>;

package/lib/common/inlineValue.js

@@ -0,0 +1,25 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InlineValueFeature = void 0;
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const InlineValueFeature = (Base) => {
+    return class extends Base {
+        get inlineValue() {
+            return {
+                refresh: () => {
+                    return this.connection.sendRequest(vscode_languageserver_protocol_1.InlineValueRefreshRequest.type);
+                },
+                on: (handler) => {
+                    return this.connection.onRequest(vscode_languageserver_protocol_1.InlineValueRequest.type, (params, cancel) => {
+                        return handler(params, cancel, this.attachWorkDoneProgress(params));
+                    });
+                }
+            };
+        }
+    };
+};
+exports.InlineValueFeature = InlineValueFeature;

package/lib/common/linkedEditingRange.d.ts

@@ -0,0 +1,16 @@
+import { LinkedEditingRangeParams, LinkedEditingRanges, Disposable } from 'vscode-languageserver-protocol';
+import type { Feature, _Languages, ServerRequestHandler } from './server';
+/**
+ * Shape of the linked editing feature
+ *
+ * @since 3.16.0
+ */
+export interface LinkedEditingRangeFeatureShape {
+    /**
+     * Installs a handler for the linked editing range request.
+     *
+     * @param handler The corresponding handler.
+     */
+    onLinkedEditingRange(handler: ServerRequestHandler<LinkedEditingRangeParams, LinkedEditingRanges | undefined | null, void, void>): Disposable;
+}
+export declare const LinkedEditingRangeFeature: Feature<_Languages, LinkedEditingRangeFeatureShape>;

package/lib/common/linkedEditingRange.js

@@ -0,0 +1,18 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkedEditingRangeFeature = void 0;
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const LinkedEditingRangeFeature = (Base) => {
+    return class extends Base {
+        onLinkedEditingRange(handler) {
+            return this.connection.onRequest(vscode_languageserver_protocol_1.LinkedEditingRangeRequest.type, (params, cancel) => {
+                return handler(params, cancel, this.attachWorkDoneProgress(params), undefined);
+            });
+        }
+    };
+};
+exports.LinkedEditingRangeFeature = LinkedEditingRangeFeature;

package/lib/common/moniker.d.ts

@@ -0,0 +1,13 @@
+import { MonikerParams, Moniker, Disposable } from 'vscode-languageserver-protocol';
+import type { Feature, _Languages, ServerRequestHandler } from './server';
+/**
+ * Shape of the moniker feature
+ *
+ * @since 3.16.0
+ */
+export interface MonikerFeatureShape {
+    moniker: {
+        on(handler: ServerRequestHandler<MonikerParams, Moniker[] | null, Moniker[], void>): Disposable;
+    };
+}
+export declare const MonikerFeature: Feature<_Languages, MonikerFeatureShape>;

package/lib/common/moniker.js

@@ -0,0 +1,23 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MonikerFeature = void 0;
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const MonikerFeature = (Base) => {
+    return class extends Base {
+        get moniker() {
+            return {
+                on: (handler) => {
+                    const type = vscode_languageserver_protocol_1.MonikerRequest.type;
+                    return this.connection.onRequest(type, (params, cancel) => {
+                        return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(type, params));
+                    });
+                },
+            };
+        }
+    };
+};
+exports.MonikerFeature = MonikerFeature;

package/lib/common/notebook.d.ts

@@ -0,0 +1,99 @@
+import { NotificationHandler1, Event, DocumentUri, URI, Disposable, DidOpenNotebookDocumentParams, DidChangeNotebookDocumentParams, DidSaveNotebookDocumentParams, DidCloseNotebookDocumentParams, NotebookDocument, NotebookCell, LSPObject } from 'vscode-languageserver-protocol';
+import type { Feature, _Notebooks, Connection } from './server';
+import { TextDocuments, TextDocumentsConfiguration } from './textDocuments';
+/**
+ * Shape of the notebooks feature
+ *
+ * @since 3.17.0
+ */
+export interface NotebookSyncFeatureShape {
+    synchronization: {
+        onDidOpenNotebookDocument(handler: NotificationHandler1<DidOpenNotebookDocumentParams>): Disposable;
+        onDidChangeNotebookDocument(handler: NotificationHandler1<DidChangeNotebookDocumentParams>): Disposable;
+        onDidSaveNotebookDocument(handler: NotificationHandler1<DidSaveNotebookDocumentParams>): Disposable;
+        onDidCloseNotebookDocument(handler: NotificationHandler1<DidCloseNotebookDocumentParams>): Disposable;
+    };
+}
+export declare const NotebookSyncFeature: Feature<_Notebooks, NotebookSyncFeatureShape>;
+export type NotebookDocumentChangeEvent = {
+    /**
+     * The notebook document that changed.
+     */
+    notebookDocument: NotebookDocument;
+    /**
+     * The meta data change if any.
+     *
+     * Note: old and new should always be an object literal (e.g. LSPObject)
+     */
+    metadata?: {
+        old: LSPObject | undefined;
+        new: LSPObject | undefined;
+    };
+    /**
+     * The cell changes if any.
+     */
+    cells?: {
+        /**
+         * The cells that got added.
+         */
+        added: NotebookCell[];
+        /**
+         * The cells that got removed.
+         */
+        removed: NotebookCell[];
+        /**
+         * The cells that changed.
+         */
+        changed: {
+            /**
+             * The cell data has changed, excluding its
+             * text content which is reported via
+             * `textContentChanged`.
+             */
+            data: {
+                old: NotebookCell;
+                new: NotebookCell;
+            }[];
+            /**
+             * The text content of a cell has changed.
+             * The actual text is available via the `Notebooks`
+             * text document manager.
+             */
+            textContent: NotebookCell[];
+        };
+    };
+};
+export declare class NotebookDocuments<T extends {
+    uri: DocumentUri;
+}> {
+    private readonly notebookDocuments;
+    private readonly notebookCellMap;
+    private readonly _onDidOpen;
+    private readonly _onDidSave;
+    private readonly _onDidChange;
+    private readonly _onDidClose;
+    private _cellTextDocuments;
+    constructor(configurationOrTextDocuments: TextDocumentsConfiguration<T> | TextDocuments<T>);
+    get cellTextDocuments(): TextDocuments<T>;
+    getCellTextDocument(cell: NotebookCell): T | undefined;
+    getNotebookDocument(uri: URI): NotebookDocument | undefined;
+    getNotebookCell(uri: DocumentUri): NotebookCell | undefined;
+    findNotebookDocumentForCell(cell: DocumentUri | NotebookCell): NotebookDocument | undefined;
+    get onDidOpen(): Event<NotebookDocument>;
+    get onDidSave(): Event<NotebookDocument>;
+    get onDidChange(): Event<NotebookDocumentChangeEvent>;
+    get onDidClose(): Event<NotebookDocument>;
+    /**
+     * Listens for `low level` notification on the given connection to
+     * update the notebook documents managed by this instance.
+     *
+     * Please note that the connection only provides handlers not an event model. Therefore
+     * listening on a connection will overwrite the following handlers on a connection:
+     * `onDidOpenNotebookDocument`, `onDidChangeNotebookDocument`, `onDidSaveNotebookDocument`,
+     *  and `onDidCloseNotebookDocument`.
+     *
+     * @param connection The connection to listen on.
+     */
+    listen(connection: Connection): Disposable;
+    private updateCellMap;
+}

package/lib/common/notebook.js

@@ -0,0 +1,262 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotebookDocuments = exports.NotebookSyncFeature = void 0;
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const textDocuments_1 = require("./textDocuments");
+const NotebookSyncFeature = (Base) => {
+    return class extends Base {
+        get synchronization() {
+            return {
+                onDidOpenNotebookDocument: (handler) => {
+                    return this.connection.onNotification(vscode_languageserver_protocol_1.DidOpenNotebookDocumentNotification.type, (params) => {
+                        return handler(params);
+                    });
+                },
+                onDidChangeNotebookDocument: (handler) => {
+                    return this.connection.onNotification(vscode_languageserver_protocol_1.DidChangeNotebookDocumentNotification.type, (params) => {
+                        return handler(params);
+                    });
+                },
+                onDidSaveNotebookDocument: (handler) => {
+                    return this.connection.onNotification(vscode_languageserver_protocol_1.DidSaveNotebookDocumentNotification.type, (params) => {
+                        return handler(params);
+                    });
+                },
+                onDidCloseNotebookDocument: (handler) => {
+                    return this.connection.onNotification(vscode_languageserver_protocol_1.DidCloseNotebookDocumentNotification.type, (params) => {
+                        return handler(params);
+                    });
+                }
+            };
+        }
+    };
+};
+exports.NotebookSyncFeature = NotebookSyncFeature;
+class CellTextDocumentConnection {
+    static NULL_DISPOSE = Object.freeze({ dispose: () => { } });
+    openHandler;
+    changeHandler;
+    closeHandler;
+    onDidOpenTextDocument(handler) {
+        this.openHandler = handler;
+        return vscode_languageserver_protocol_1.Disposable.create(() => { this.openHandler = undefined; });
+    }
+    openTextDocument(params) {
+        return this.openHandler && this.openHandler(params);
+    }
+    onDidChangeTextDocument(handler) {
+        this.changeHandler = handler;
+        return vscode_languageserver_protocol_1.Disposable.create(() => { this.changeHandler = handler; });
+    }
+    changeTextDocument(params) {
+        return this.changeHandler && this.changeHandler(params);
+    }
+    onDidCloseTextDocument(handler) {
+        this.closeHandler = handler;
+        return vscode_languageserver_protocol_1.Disposable.create(() => { this.closeHandler = undefined; });
+    }
+    closeTextDocument(params) {
+        return this.closeHandler && this.closeHandler(params);
+    }
+    onWillSaveTextDocument() {
+        return CellTextDocumentConnection.NULL_DISPOSE;
+    }
+    onWillSaveTextDocumentWaitUntil() {
+        return CellTextDocumentConnection.NULL_DISPOSE;
+    }
+    onDidSaveTextDocument() {
+        return CellTextDocumentConnection.NULL_DISPOSE;
+    }
+}
+class NotebookDocuments {
+    notebookDocuments;
+    notebookCellMap;
+    _onDidOpen;
+    _onDidSave;
+    _onDidChange;
+    _onDidClose;
+    _cellTextDocuments;
+    constructor(configurationOrTextDocuments) {
+        if (configurationOrTextDocuments instanceof textDocuments_1.TextDocuments) {
+            this._cellTextDocuments = configurationOrTextDocuments;
+        }
+        else {
+            this._cellTextDocuments = new textDocuments_1.TextDocuments(configurationOrTextDocuments);
+        }
+        this.notebookDocuments = new Map();
+        this.notebookCellMap = new Map();
+        this._onDidOpen = new vscode_languageserver_protocol_1.Emitter();
+        this._onDidChange = new vscode_languageserver_protocol_1.Emitter();
+        this._onDidSave = new vscode_languageserver_protocol_1.Emitter();
+        this._onDidClose = new vscode_languageserver_protocol_1.Emitter();
+    }
+    get cellTextDocuments() {
+        return this._cellTextDocuments;
+    }
+    getCellTextDocument(cell) {
+        return this._cellTextDocuments.get(cell.document);
+    }
+    getNotebookDocument(uri) {
+        return this.notebookDocuments.get(uri);
+    }
+    getNotebookCell(uri) {
+        const value = this.notebookCellMap.get(uri);
+        return value && value[0];
+    }
+    findNotebookDocumentForCell(cell) {
+        const key = typeof cell === 'string' ? cell : cell.document;
+        const value = this.notebookCellMap.get(key);
+        return value && value[1];
+    }
+    get onDidOpen() {
+        return this._onDidOpen.event;
+    }
+    get onDidSave() {
+        return this._onDidSave.event;
+    }
+    get onDidChange() {
+        return this._onDidChange.event;
+    }
+    get onDidClose() {
+        return this._onDidClose.event;
+    }
+    /**
+     * Listens for `low level` notification on the given connection to
+     * update the notebook documents managed by this instance.
+     *
+     * Please note that the connection only provides handlers not an event model. Therefore
+     * listening on a connection will overwrite the following handlers on a connection:
+     * `onDidOpenNotebookDocument`, `onDidChangeNotebookDocument`, `onDidSaveNotebookDocument`,
+     *  and `onDidCloseNotebookDocument`.
+     *
+     * @param connection The connection to listen on.
+     */
+    listen(connection) {
+        const cellTextDocumentConnection = new CellTextDocumentConnection();
+        const disposables = [];
+        disposables.push(this.cellTextDocuments.listen(cellTextDocumentConnection));
+        disposables.push(connection.notebooks.synchronization.onDidOpenNotebookDocument(async (params) => {
+            this.notebookDocuments.set(params.notebookDocument.uri, params.notebookDocument);
+            for (const cellTextDocument of params.cellTextDocuments) {
+                await cellTextDocumentConnection.openTextDocument({ textDocument: cellTextDocument });
+            }
+            this.updateCellMap(params.notebookDocument);
+            this._onDidOpen.fire(params.notebookDocument);
+        }));
+        disposables.push(connection.notebooks.synchronization.onDidChangeNotebookDocument(async (params) => {
+            const notebookDocument = this.notebookDocuments.get(params.notebookDocument.uri);
+            if (notebookDocument === undefined) {
+                return;
+            }
+            notebookDocument.version = params.notebookDocument.version;
+            const oldMetadata = notebookDocument.metadata;
+            let metadataChanged = false;
+            const change = params.change;
+            if (change.metadata !== undefined) {
+                metadataChanged = true;
+                notebookDocument.metadata = change.metadata;
+            }
+            const opened = [];
+            const closed = [];
+            const data = [];
+            const text = [];
+            if (change.cells !== undefined) {
+                const changedCells = change.cells;
+                if (changedCells.structure !== undefined) {
+                    const array = changedCells.structure.array;
+                    notebookDocument.cells.splice(array.start, array.deleteCount, ...(array.cells !== undefined ? array.cells : []));
+                    // Additional open cell text documents.
+                    if (changedCells.structure.didOpen !== undefined) {
+                        for (const open of changedCells.structure.didOpen) {
+                            await cellTextDocumentConnection.openTextDocument({ textDocument: open });
+                            opened.push(open.uri);
+                        }
+                    }
+                    // Additional closed cell test documents.
+                    if (changedCells.structure.didClose) {
+                        for (const close of changedCells.structure.didClose) {
+                            await cellTextDocumentConnection.closeTextDocument({ textDocument: close });
+                            closed.push(close.uri);
+                        }
+                    }
+                }
+                if (changedCells.data !== undefined) {
+                    const cellUpdates = new Map(changedCells.data.map(cell => [cell.document, cell]));
+                    for (let i = 0; i <= notebookDocument.cells.length; i++) {
+                        const change = cellUpdates.get(notebookDocument.cells[i].document);
+                        if (change !== undefined) {
+                            const old = notebookDocument.cells.splice(i, 1, change);
+                            data.push({ old: old[0], new: change });
+                            cellUpdates.delete(change.document);
+                            if (cellUpdates.size === 0) {
+                                break;
+                            }
+                        }
+                    }
+                }
+                if (changedCells.textContent !== undefined) {
+                    for (const cellTextDocument of changedCells.textContent) {
+                        await cellTextDocumentConnection.changeTextDocument({ textDocument: cellTextDocument.document, contentChanges: cellTextDocument.changes });
+                        text.push(cellTextDocument.document.uri);
+                    }
+                }
+            }
+            // Update internal data structure.
+            this.updateCellMap(notebookDocument);
+            const changeEvent = { notebookDocument };
+            if (metadataChanged) {
+                changeEvent.metadata = { old: oldMetadata, new: notebookDocument.metadata };
+            }
+            const added = [];
+            for (const open of opened) {
+                added.push(this.getNotebookCell(open));
+            }
+            const removed = [];
+            for (const close of closed) {
+                removed.push(this.getNotebookCell(close));
+            }
+            const textContent = [];
+            for (const change of text) {
+                textContent.push(this.getNotebookCell(change));
+            }
+            if (added.length > 0 || removed.length > 0 || data.length > 0 || textContent.length > 0) {
+                changeEvent.cells = { added, removed, changed: { data, textContent } };
+            }
+            if (changeEvent.metadata !== undefined || changeEvent.cells !== undefined) {
+                this._onDidChange.fire(changeEvent);
+            }
+        }));
+        disposables.push(connection.notebooks.synchronization.onDidSaveNotebookDocument((params) => {
+            const notebookDocument = this.notebookDocuments.get(params.notebookDocument.uri);
+            if (notebookDocument === undefined) {
+                return;
+            }
+            this._onDidSave.fire(notebookDocument);
+        }));
+        disposables.push(connection.notebooks.synchronization.onDidCloseNotebookDocument(async (params) => {
+            const notebookDocument = this.notebookDocuments.get(params.notebookDocument.uri);
+            if (notebookDocument === undefined) {
+                return;
+            }
+            this._onDidClose.fire(notebookDocument);
+            for (const cellTextDocument of params.cellTextDocuments) {
+                await cellTextDocumentConnection.closeTextDocument({ textDocument: cellTextDocument });
+            }
+            this.notebookDocuments.delete(params.notebookDocument.uri);
+            for (const cell of notebookDocument.cells) {
+                this.notebookCellMap.delete(cell.document);
+            }
+        }));
+        return vscode_languageserver_protocol_1.Disposable.create(() => { disposables.forEach(disposable => disposable.dispose()); });
+    }
+    updateCellMap(notebookDocument) {
+        for (const cell of notebookDocument.cells) {
+            this.notebookCellMap.set(cell.document, [cell, notebookDocument]);
+        }
+    }
+}
+exports.NotebookDocuments = NotebookDocuments;

package/lib/common/progress.d.ts

@@ -0,0 +1,25 @@
+import { CancellationToken, ProgressToken, ProgressType, WorkDoneProgressParams, PartialResultParams, RequestParam } from 'vscode-languageserver-protocol';
+import type { Feature, _RemoteWindow } from './server';
+export interface ProgressContext {
+    sendProgress<P>(type: ProgressType<P>, token: ProgressToken, value: NoInfer<RequestParam<P>>): void;
+}
+export interface WorkDoneProgressReporter {
+    begin(title: string, percentage?: number, message?: string, cancellable?: boolean): void;
+    report(percentage: number): void;
+    report(message: string): void;
+    report(percentage: number, message: string): void;
+    done(): void;
+}
+export interface WorkDoneProgressServerReporter extends WorkDoneProgressReporter {
+    readonly token: CancellationToken;
+}
+export interface WindowProgress {
+    attachWorkDoneProgress(token: ProgressToken | undefined): WorkDoneProgressReporter;
+    createWorkDoneProgress(): Promise<WorkDoneProgressServerReporter>;
+}
+export declare function attachWorkDone(connection: ProgressContext, params: WorkDoneProgressParams | undefined): WorkDoneProgressReporter;
+export declare const ProgressFeature: Feature<_RemoteWindow, WindowProgress>;
+export interface ResultProgressReporter<R> {
+    report(data: R): void;
+}
+export declare function attachPartialResult<R>(connection: ProgressContext, params: PartialResultParams): ResultProgressReporter<R> | undefined;