@depup/vscode-languageserver-protocol 3.18.3-depup.0

package/lib/common/protocol.linkedEditingRange.d.ts

@@ -0,0 +1,53 @@
+import { RequestHandler } from 'vscode-jsonrpc';
+import { Range } from 'vscode-languageserver-types';
+import { CM, MessageDirection, ProtocolRequestType } from './messages';
+import { type StaticRegistrationOptions, type TextDocumentPositionParams, type TextDocumentRegistrationOptions, type WorkDoneProgressOptions, type WorkDoneProgressParams } from './protocol';
+/**
+ * Client capabilities for the linked editing range request.
+ *
+ * @since 3.16.0
+ */
+export interface LinkedEditingRangeClientCapabilities {
+    /**
+     * Whether implementation supports dynamic registration. If this is set to `true`
+     * the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)`
+     * return value for the corresponding server capability as well.
+     */
+    dynamicRegistration?: boolean;
+}
+export interface LinkedEditingRangeParams extends TextDocumentPositionParams, WorkDoneProgressParams {
+}
+export interface LinkedEditingRangeOptions extends WorkDoneProgressOptions {
+}
+export interface LinkedEditingRangeRegistrationOptions extends TextDocumentRegistrationOptions, LinkedEditingRangeOptions, StaticRegistrationOptions {
+}
+/**
+ * The result of a linked editing range request.
+ *
+ * @since 3.16.0
+ */
+export interface LinkedEditingRanges {
+    /**
+     * A list of ranges that can be edited together. The ranges must have
+     * identical length and contain identical text content. The ranges cannot overlap.
+     */
+    ranges: Range[];
+    /**
+     * An optional word pattern (regular expression) that describes valid contents for
+     * the given ranges. If no pattern is provided, the client configuration's word
+     * pattern will be used.
+     */
+    wordPattern?: string;
+}
+/**
+ * A request to provide ranges that can be edited together.
+ *
+ * @since 3.16.0
+ */
+export declare namespace LinkedEditingRangeRequest {
+    const method: 'textDocument/linkedEditingRange';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<LinkedEditingRangeParams, LinkedEditingRanges | null, void, void, LinkedEditingRangeRegistrationOptions>;
+    type HandlerSignature = RequestHandler<LinkedEditingRangeParams, LinkedEditingRanges | null, void>;
+    const capabilities: CM<"textDocument.linkedEditingRange", "linkedEditingRangeProvider">;
+}

package/lib/common/protocol.linkedEditingRange.js

@@ -0,0 +1,20 @@
+"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.LinkedEditingRangeRequest = void 0;
+const messages_1 = require("./messages");
+/**
+ * A request to provide ranges that can be edited together.
+ *
+ * @since 3.16.0
+ */
+var LinkedEditingRangeRequest;
+(function (LinkedEditingRangeRequest) {
+    LinkedEditingRangeRequest.method = 'textDocument/linkedEditingRange';
+    LinkedEditingRangeRequest.messageDirection = messages_1.MessageDirection.clientToServer;
+    LinkedEditingRangeRequest.type = new messages_1.ProtocolRequestType(LinkedEditingRangeRequest.method);
+    LinkedEditingRangeRequest.capabilities = messages_1.CM.create('textDocument.linkedEditingRange', 'linkedEditingRangeProvider');
+})(LinkedEditingRangeRequest || (exports.LinkedEditingRangeRequest = LinkedEditingRangeRequest = {}));

package/lib/common/protocol.moniker.d.ts

@@ -0,0 +1,107 @@
+import { MessageDirection, ProtocolRequestType, CM } from './messages';
+import { type WorkDoneProgressOptions, type WorkDoneProgressParams, type PartialResultParams, type TextDocumentRegistrationOptions, type TextDocumentPositionParams } from './protocol';
+/**
+ * Moniker uniqueness level to define scope of the moniker.
+ *
+ * @since 3.16.0
+ */
+export declare namespace UniquenessLevel {
+    /**
+     * The moniker is only unique inside a document
+     */
+    const document = "document";
+    /**
+     * The moniker is unique inside a project for which a dump got created
+     */
+    const project = "project";
+    /**
+     * The moniker is unique inside the group to which a project belongs
+     */
+    const group = "group";
+    /**
+     * The moniker is unique inside the moniker scheme.
+     */
+    const scheme = "scheme";
+    /**
+     * The moniker is globally unique
+     */
+    const global = "global";
+}
+export type UniquenessLevel = 'document' | 'project' | 'group' | 'scheme' | 'global';
+/**
+ * The moniker kind.
+ *
+ * @since 3.16.0
+ */
+export declare namespace MonikerKind {
+    /**
+     * The moniker represent a symbol that is imported into a project
+     */
+    const $import = "import";
+    /**
+     * The moniker represents a symbol that is exported from a project
+     */
+    const $export = "export";
+    /**
+     * The moniker represents a symbol that is local to a project (e.g. a local
+     * variable of a function, a class not visible outside the project, ...)
+     */
+    const local = "local";
+}
+export type MonikerKind = 'import' | 'export' | 'local';
+/**
+ * Moniker definition to match LSIF 0.5 moniker definition.
+ *
+ * @since 3.16.0
+ */
+export interface Moniker {
+    /**
+     * The scheme of the moniker. For example tsc or .Net
+     */
+    scheme: string;
+    /**
+     * The identifier of the moniker. The value is opaque in LSIF however
+     * schema owners are allowed to define the structure if they want.
+     */
+    identifier: string;
+    /**
+     * The scope in which the moniker is unique
+     */
+    unique: UniquenessLevel;
+    /**
+     * The moniker kind if known.
+     */
+    kind?: MonikerKind;
+}
+/**
+ * Client capabilities specific to the moniker request.
+ *
+ * @since 3.16.0
+ */
+export interface MonikerClientCapabilities {
+    /**
+     * Whether moniker supports dynamic registration. If this is set to `true`
+     * the client supports the new `MonikerRegistrationOptions` return value
+     * for the corresponding server capability as well.
+     */
+    dynamicRegistration?: boolean;
+}
+export interface MonikerServerCapabilities {
+}
+export interface MonikerOptions extends WorkDoneProgressOptions {
+}
+export interface MonikerRegistrationOptions extends TextDocumentRegistrationOptions, MonikerOptions {
+}
+export interface MonikerParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams {
+}
+/**
+ * A request to get the moniker of a symbol at a given text document position.
+ * The request parameter is of type {@link TextDocumentPositionParams}.
+ * The response is of type {@link Moniker Moniker[]} or `null`.
+ */
+export declare namespace MonikerRequest {
+    const method: 'textDocument/moniker';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<MonikerParams, Moniker[] | null, Moniker[], void, MonikerRegistrationOptions>;
+    const capabilities: CM<"textDocument.moniker", "monikerProvider">;
+}

package/lib/common/protocol.moniker.js

@@ -0,0 +1,69 @@
+"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.MonikerRequest = exports.MonikerKind = exports.UniquenessLevel = void 0;
+const messages_1 = require("./messages");
+/**
+ * Moniker uniqueness level to define scope of the moniker.
+ *
+ * @since 3.16.0
+ */
+var UniquenessLevel;
+(function (UniquenessLevel) {
+    /**
+     * The moniker is only unique inside a document
+     */
+    UniquenessLevel.document = 'document';
+    /**
+     * The moniker is unique inside a project for which a dump got created
+     */
+    UniquenessLevel.project = 'project';
+    /**
+     * The moniker is unique inside the group to which a project belongs
+     */
+    UniquenessLevel.group = 'group';
+    /**
+     * The moniker is unique inside the moniker scheme.
+     */
+    UniquenessLevel.scheme = 'scheme';
+    /**
+     * The moniker is globally unique
+     */
+    UniquenessLevel.global = 'global';
+})(UniquenessLevel || (exports.UniquenessLevel = UniquenessLevel = {}));
+/**
+ * The moniker kind.
+ *
+ * @since 3.16.0
+ */
+var MonikerKind;
+(function (MonikerKind) {
+    /**
+     * The moniker represent a symbol that is imported into a project
+     */
+    MonikerKind.$import = 'import';
+    /**
+     * The moniker represents a symbol that is exported from a project
+     */
+    MonikerKind.$export = 'export';
+    /**
+     * The moniker represents a symbol that is local to a project (e.g. a local
+     * variable of a function, a class not visible outside the project, ...)
+     */
+    MonikerKind.local = 'local';
+})(MonikerKind || (exports.MonikerKind = MonikerKind = {}));
+/**
+ * A request to get the moniker of a symbol at a given text document position.
+ * The request parameter is of type {@link TextDocumentPositionParams}.
+ * The response is of type {@link Moniker Moniker[]} or `null`.
+ */
+var MonikerRequest;
+(function (MonikerRequest) {
+    MonikerRequest.method = 'textDocument/moniker';
+    MonikerRequest.messageDirection = messages_1.MessageDirection.clientToServer;
+    MonikerRequest.type = new messages_1.ProtocolRequestType(MonikerRequest.method);
+    MonikerRequest.capabilities = messages_1.CM.create('textDocument.moniker', 'monikerProvider');
+})(MonikerRequest || (exports.MonikerRequest = MonikerRequest = {}));

package/lib/common/protocol.notebook.d.ts

@@ -0,0 +1,428 @@
+import { URI, integer, DocumentUri, uinteger, TextDocumentItem, TextDocumentIdentifier, VersionedTextDocumentIdentifier, LSPObject } from 'vscode-languageserver-types';
+import { MessageDirection, ProtocolNotificationType, RegistrationType } from './messages';
+import type { StaticRegistrationOptions, NotebookDocumentFilter, TextDocumentContentChangeEvent } from './protocol';
+/**
+ * Notebook specific client capabilities.
+ *
+ * @since 3.17.0
+ */
+export type NotebookDocumentSyncClientCapabilities = {
+    /**
+     * Whether implementation supports dynamic registration. If this is
+     * set to `true` the client supports the new
+     * `(TextDocumentRegistrationOptions & StaticRegistrationOptions)`
+     * return value for the corresponding server capability as well.
+     */
+    dynamicRegistration?: boolean;
+    /**
+     * The client supports sending execution summary data per cell.
+     */
+    executionSummarySupport?: boolean;
+};
+/**
+ * A notebook cell kind.
+ *
+ * @since 3.17.0
+ */
+export declare namespace NotebookCellKind {
+    /**
+     * A markup-cell is formatted source that is used for display.
+     */
+    const Markup: 1;
+    /**
+     * A code-cell is source code.
+     */
+    const Code: 2;
+    function is(value: any): value is NotebookCellKind;
+}
+export type NotebookCellKind = 1 | 2;
+export type ExecutionSummary = {
+    /**
+     * A strict monotonically increasing value
+     * indicating the execution order of a cell
+     * inside a notebook.
+     */
+    executionOrder: uinteger;
+    /**
+     * Whether the execution was successful or
+     * not if known by the client.
+     */
+    success?: boolean;
+};
+export declare namespace ExecutionSummary {
+    function create(executionOrder: number, success?: boolean): ExecutionSummary;
+    function is(value: any): value is ExecutionSummary;
+    function equals(one: ExecutionSummary | undefined, other: ExecutionSummary | undefined): boolean;
+}
+/**
+ * A notebook cell.
+ *
+ * A cell's document URI must be unique across ALL notebook
+ * cells and can therefore be used to uniquely identify a
+ * notebook cell or the cell's text document.
+ *
+ * @since 3.17.0
+ */
+export type NotebookCell = {
+    /**
+     * The cell's kind
+     */
+    kind: NotebookCellKind;
+    /**
+     * The URI of the cell's text document
+     * content.
+     */
+    document: DocumentUri;
+    /**
+     * Additional metadata stored with the cell.
+     *
+     * Note: should always be an object literal (e.g. LSPObject)
+     */
+    metadata?: LSPObject;
+    /**
+     * Additional execution summary information
+     * if supported by the client.
+     */
+    executionSummary?: ExecutionSummary;
+};
+export declare namespace NotebookCell {
+    function create(kind: NotebookCellKind, document: DocumentUri): NotebookCell;
+    function is(value: any): value is NotebookCell;
+    function diff(one: NotebookCell, two: NotebookCell): Set<keyof NotebookCell>;
+}
+/**
+ * A notebook document.
+ *
+ * @since 3.17.0
+ */
+export type NotebookDocument = {
+    /**
+     * The notebook document's uri.
+     */
+    uri: URI;
+    /**
+     * The type of the notebook.
+     */
+    notebookType: string;
+    /**
+     * The version number of this document (it will increase after each
+     * change, including undo/redo).
+     */
+    version: integer;
+    /**
+     * Additional metadata stored with the notebook
+     * document.
+     *
+     * Note: should always be an object literal (e.g. LSPObject)
+     */
+    metadata?: LSPObject;
+    /**
+     * The cells of a notebook.
+     */
+    cells: NotebookCell[];
+};
+export declare namespace NotebookDocument {
+    function create(uri: URI, notebookType: string, version: integer, cells: NotebookCell[]): NotebookDocument;
+    function is(value: any): value is NotebookDocument;
+}
+/**
+ * A literal to identify a notebook document in the client.
+ *
+ * @since 3.17.0
+ */
+export type NotebookDocumentIdentifier = {
+    /**
+     * The notebook document's uri.
+     */
+    uri: URI;
+};
+/**
+ * A versioned notebook document identifier.
+ *
+ * @since 3.17.0
+ */
+export type VersionedNotebookDocumentIdentifier = {
+    /**
+     * The version number of this notebook document.
+     */
+    version: integer;
+    /**
+     * The notebook document's uri.
+     */
+    uri: URI;
+};
+/**
+ * @since 3.18.0
+ */
+export type NotebookCellLanguage = {
+    language: string;
+};
+/**
+ * @since 3.18.0
+ */
+export type NotebookDocumentFilterWithNotebook = {
+    /**
+     * The notebook to be synced If a string
+     * value is provided it matches against the
+     * notebook type. '*' matches every notebook.
+     */
+    notebook: string | NotebookDocumentFilter;
+    /**
+     * The cells of the matching notebook to be synced.
+     */
+    cells?: NotebookCellLanguage[];
+};
+/**
+ * @since 3.18.0
+ */
+export type NotebookDocumentFilterWithCells = {
+    /**
+     * The notebook to be synced If a string
+     * value is provided it matches against the
+     * notebook type. '*' matches every notebook.
+     */
+    notebook?: string | NotebookDocumentFilter;
+    /**
+     * The cells of the matching notebook to be synced.
+     */
+    cells: NotebookCellLanguage[];
+};
+/**
+ * Options specific to a notebook plus its cells
+ * to be synced to the server.
+ *
+ * If a selector provides a notebook document
+ * filter but no cell selector all cells of a
+ * matching notebook document will be synced.
+ *
+ * If a selector provides no notebook document
+ * filter but only a cell selector all notebook
+ * document that contain at least one matching
+ * cell will be synced.
+ *
+ * @since 3.17.0
+ */
+export type NotebookDocumentSyncOptions = {
+    /**
+     * The notebooks to be synced
+     */
+    notebookSelector: (NotebookDocumentFilterWithNotebook | NotebookDocumentFilterWithCells)[];
+    /**
+     * Whether save notification should be forwarded to
+     * the server. Will only be honored if mode === `notebook`.
+     */
+    save?: boolean;
+};
+/**
+ * Registration options specific to a notebook.
+ *
+ * @since 3.17.0
+ */
+export type NotebookDocumentSyncRegistrationOptions = NotebookDocumentSyncOptions & StaticRegistrationOptions;
+export declare namespace NotebookDocumentSyncRegistrationType {
+    const method: 'notebookDocument/sync';
+    const messageDirection: MessageDirection;
+    const type: RegistrationType<NotebookDocumentSyncRegistrationOptions>;
+}
+/**
+ * The params sent in an open notebook document notification.
+ *
+ * @since 3.17.0
+ */
+export type DidOpenNotebookDocumentParams = {
+    /**
+     * The notebook document that got opened.
+     */
+    notebookDocument: NotebookDocument;
+    /**
+     * The text documents that represent the content
+     * of a notebook cell.
+     */
+    cellTextDocuments: TextDocumentItem[];
+};
+/**
+ * A notification sent when a notebook opens.
+ *
+ * @since 3.17.0
+ */
+export declare namespace DidOpenNotebookDocumentNotification {
+    const method: 'notebookDocument/didOpen';
+    const messageDirection: MessageDirection;
+    const type: ProtocolNotificationType<DidOpenNotebookDocumentParams, NotebookDocumentSyncRegistrationOptions>;
+    const registrationMethod: typeof NotebookDocumentSyncRegistrationType.method;
+}
+/**
+ * A change describing how to move a `NotebookCell`
+ * array from state S to S'.
+ *
+ * @since 3.17.0
+ */
+export type NotebookCellArrayChange = {
+    /**
+     * The start oftest of the cell that changed.
+     */
+    start: uinteger;
+    /**
+     * The deleted cells
+     */
+    deleteCount: uinteger;
+    /**
+     * The new cells, if any
+     */
+    cells?: NotebookCell[];
+};
+export declare namespace NotebookCellArrayChange {
+    function is(value: any): value is NotebookCellArrayChange;
+    function create(start: uinteger, deleteCount: uinteger, cells?: NotebookCell[]): NotebookCellArrayChange;
+}
+/**
+ * Structural changes to cells in a notebook document.
+ *
+ * @since 3.18.0
+ */
+export type NotebookDocumentCellChangeStructure = {
+    /**
+     * The change to the cell array.
+     */
+    array: NotebookCellArrayChange;
+    /**
+     * Additional opened cell text documents.
+     */
+    didOpen?: TextDocumentItem[];
+    /**
+     * Additional closed cell text documents.
+     */
+    didClose?: TextDocumentIdentifier[];
+};
+/**
+ * Content changes to a cell in a notebook document.
+ *
+ * @since 3.18.0
+ */
+export type NotebookDocumentCellContentChanges = {
+    document: VersionedTextDocumentIdentifier;
+    changes: TextDocumentContentChangeEvent[];
+};
+/**
+ * Cell changes to a notebook document.
+ *
+ * @since 3.18.0
+ */
+export type NotebookDocumentCellChanges = {
+    /**
+     * Changes to the cell structure to add or
+     * remove cells.
+     */
+    structure?: NotebookDocumentCellChangeStructure;
+    /**
+     * Changes to notebook cells properties like its
+     * kind, execution summary or metadata.
+     */
+    data?: NotebookCell[];
+    /**
+     * Changes to the text content of notebook cells.
+     */
+    textContent?: NotebookDocumentCellContentChanges[];
+};
+/**
+ * A change event for a notebook document.
+ *
+ * @since 3.17.0
+ */
+export type NotebookDocumentChangeEvent = {
+    /**
+     * The changed meta data if any.
+     *
+     * Note: should always be an object literal (e.g. LSPObject)
+     */
+    metadata?: LSPObject;
+    /**
+     * Changes to cells
+     */
+    cells?: NotebookDocumentCellChanges;
+};
+/**
+ * The params sent in a change notebook document notification.
+ *
+ * @since 3.17.0
+ */
+export type DidChangeNotebookDocumentParams = {
+    /**
+     * The notebook document that did change. The version number points
+     * to the version after all provided changes have been applied. If
+     * only the text document content of a cell changes the notebook version
+     * doesn't necessarily have to change.
+     */
+    notebookDocument: VersionedNotebookDocumentIdentifier;
+    /**
+     * The actual changes to the notebook document.
+     *
+     * The changes describe single state changes to the notebook document.
+     * So if there are two changes c1 (at array index 0) and c2 (at array
+     * index 1) for a notebook in state S then c1 moves the notebook from
+     * S to S' and c2 from S' to S''. So c1 is computed on the state S and
+     * c2 is computed on the state S'.
+     *
+     * To mirror the content of a notebook using change events use the following approach:
+     * - start with the same initial content
+     * - apply the 'notebookDocument/didChange' notifications in the order you receive them.
+     * - apply the `NotebookChangeEvent`s in a single notification in the order
+     *   you receive them.
+     */
+    change: NotebookDocumentChangeEvent;
+};
+export declare namespace DidChangeNotebookDocumentNotification {
+    const method: 'notebookDocument/didChange';
+    const messageDirection: MessageDirection;
+    const type: ProtocolNotificationType<DidChangeNotebookDocumentParams, NotebookDocumentSyncRegistrationOptions>;
+    const registrationMethod: typeof NotebookDocumentSyncRegistrationType.method;
+}
+/**
+ * The params sent in a save notebook document notification.
+ *
+ * @since 3.17.0
+ */
+export type DidSaveNotebookDocumentParams = {
+    /**
+     * The notebook document that got saved.
+     */
+    notebookDocument: NotebookDocumentIdentifier;
+};
+/**
+ * A notification sent when a notebook document is saved.
+ *
+ * @since 3.17.0
+ */
+export declare namespace DidSaveNotebookDocumentNotification {
+    const method: 'notebookDocument/didSave';
+    const messageDirection: MessageDirection;
+    const type: ProtocolNotificationType<DidSaveNotebookDocumentParams, NotebookDocumentSyncRegistrationOptions>;
+    const registrationMethod: typeof NotebookDocumentSyncRegistrationType.method;
+}
+/**
+ * The params sent in a close notebook document notification.
+ *
+ * @since 3.17.0
+ */
+export type DidCloseNotebookDocumentParams = {
+    /**
+     * The notebook document that got closed.
+     */
+    notebookDocument: NotebookDocumentIdentifier;
+    /**
+     * The text documents that represent the content
+     * of a notebook cell that got closed.
+     */
+    cellTextDocuments: TextDocumentIdentifier[];
+};
+/**
+ * A notification sent when a notebook closes.
+ *
+ * @since 3.17.0
+ */
+export declare namespace DidCloseNotebookDocumentNotification {
+    const method: 'notebookDocument/didClose';
+    const messageDirection: MessageDirection;
+    const type: ProtocolNotificationType<DidCloseNotebookDocumentParams, NotebookDocumentSyncRegistrationOptions>;
+    const registrationMethod: typeof NotebookDocumentSyncRegistrationType.method;
+}