naider 1.7.0

package/vscode-naide/node_modules/vscode-languageclient/lib/common/linkedEditingRange.js

@@ -0,0 +1,53 @@
+"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.LinkedEditingFeature = void 0;
+const code = require("vscode");
+const proto = require("vscode-languageserver-protocol");
+const features_1 = require("./features");
+class LinkedEditingFeature extends features_1.TextDocumentLanguageFeature {
+    constructor(client) {
+        super(client, proto.LinkedEditingRangeRequest.type);
+    }
+    fillClientCapabilities(capabilities) {
+        const linkedEditingSupport = (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'linkedEditingRange');
+        linkedEditingSupport.dynamicRegistration = true;
+    }
+    initialize(capabilities, documentSelector) {
+        let [id, options] = this.getRegistration(documentSelector, capabilities.linkedEditingRangeProvider);
+        if (!id || !options) {
+            return;
+        }
+        this.register({ id: id, registerOptions: options });
+    }
+    registerLanguageProvider(options) {
+        const selector = options.documentSelector;
+        const provider = {
+            provideLinkedEditingRanges: (document, position, token) => {
+                const client = this._client;
+                const provideLinkedEditing = (document, position, token) => {
+                    return client.sendRequest(proto.LinkedEditingRangeRequest.type, client.code2ProtocolConverter.asTextDocumentPositionParams(document, position), token).then((result) => {
+                        if (token.isCancellationRequested) {
+                            return null;
+                        }
+                        return client.protocol2CodeConverter.asLinkedEditingRanges(result, token);
+                    }, (error) => {
+                        return client.handleFailedRequest(proto.LinkedEditingRangeRequest.type, token, error, null);
+                    });
+                };
+                const middleware = client.middleware;
+                return middleware.provideLinkedEditingRange
+                    ? middleware.provideLinkedEditingRange(document, position, token, provideLinkedEditing)
+                    : provideLinkedEditing(document, position, token);
+            }
+        };
+        return [this.registerProvider(selector, provider), provider];
+    }
+    registerProvider(selector, provider) {
+        return code.languages.registerLinkedEditingRangeProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider);
+    }
+}
+exports.LinkedEditingFeature = LinkedEditingFeature;

package/vscode-naide/node_modules/vscode-languageclient/lib/common/notebook.d.ts

@@ -0,0 +1,96 @@
+import * as vscode from 'vscode';
+import * as proto from 'vscode-languageserver-protocol';
+import { NotebookCellTextDocumentFilter } from 'vscode-languageserver-protocol';
+import { DynamicFeature, FeatureClient, RegistrationData, FeatureState } from './features';
+export type VNotebookDocumentChangeEvent = {
+    /**
+     * The notebook document
+     */
+    notebook: vscode.NotebookDocument;
+    /**
+     * The changed meta data if any.
+     */
+    metadata?: {
+        [key: string]: any;
+    };
+    /**
+     * Changes to cells.
+     */
+    cells?: {
+        /**
+        * Changes to the cell structure to add or
+        * remove cells.
+        */
+        structure?: {
+            /**
+             * The change to the cell array.
+             */
+            array: {
+                start: number;
+                deleteCount: number;
+                cells?: vscode.NotebookCell[];
+            };
+            /**
+             * Additional opened cell text documents.
+             */
+            didOpen?: vscode.NotebookCell[];
+            /**
+             * Additional closed cell text documents.
+             */
+            didClose?: vscode.NotebookCell[];
+        };
+        /**
+         * Changes to notebook cells properties like its
+         * kind or metadata.
+         */
+        data?: vscode.NotebookCell[];
+        /**
+         * Changes to the text content of notebook cells.
+         */
+        textContent?: vscode.TextDocumentChangeEvent[];
+    };
+};
+export type NotebookDocumentOptions = {
+    filterCells?(notebookDocument: vscode.NotebookDocument, cells: vscode.NotebookCell[]): vscode.NotebookCell[];
+};
+export type $NotebookDocumentOptions = {
+    notebookDocumentOptions?: NotebookDocumentOptions;
+};
+export type NotebookDocumentMiddleware = {
+    notebooks?: {
+        didOpen?: (this: void, notebookDocument: vscode.NotebookDocument, cells: vscode.NotebookCell[], next: (this: void, notebookDocument: vscode.NotebookDocument, cells: vscode.NotebookCell[]) => Promise<void>) => Promise<void>;
+        didSave?: (this: void, notebookDocument: vscode.NotebookDocument, next: (this: void, notebookDocument: vscode.NotebookDocument) => Promise<void>) => Promise<void>;
+        didChange?: (this: void, event: VNotebookDocumentChangeEvent, next: (this: void, event: VNotebookDocumentChangeEvent) => Promise<void>) => Promise<void>;
+        didClose?: (this: void, notebookDocument: vscode.NotebookDocument, cells: vscode.NotebookCell[], next: (this: void, notebookDocument: vscode.NotebookDocument, cells: vscode.NotebookCell[]) => Promise<void>) => Promise<void>;
+    };
+};
+export interface NotebookDocumentSyncFeatureShape {
+    sendDidOpenNotebookDocument(notebookDocument: vscode.NotebookDocument): Promise<void>;
+    sendDidSaveNotebookDocument(notebookDocument: vscode.NotebookDocument): Promise<void>;
+    sendDidChangeNotebookDocument(event: VNotebookDocumentChangeEvent): Promise<void>;
+    sendDidCloseNotebookDocument(notebookDocument: vscode.NotebookDocument): Promise<void>;
+}
+export type $NotebookCellTextDocumentFilter = NotebookCellTextDocumentFilter & {
+    sync: true;
+};
+export type NotebookDocumentProviderShape = {
+    getProvider(notebookCell: vscode.NotebookCell): NotebookDocumentSyncFeatureShape | undefined;
+};
+export declare class NotebookDocumentSyncFeature implements DynamicFeature<proto.NotebookDocumentSyncRegistrationOptions>, NotebookDocumentProviderShape {
+    static readonly CellScheme: string;
+    private readonly client;
+    private readonly registrations;
+    private dedicatedChannel;
+    constructor(client: FeatureClient<NotebookDocumentMiddleware, $NotebookDocumentOptions>);
+    getState(): FeatureState;
+    readonly registrationType: proto.RegistrationType<proto.NotebookDocumentSyncRegistrationOptions>;
+    fillClientCapabilities(capabilities: proto.ClientCapabilities): void;
+    preInitialize(capabilities: proto.ServerCapabilities<any>): void;
+    initialize(capabilities: proto.ServerCapabilities<any>): void;
+    register(data: RegistrationData<proto.NotebookDocumentSyncRegistrationOptions>): void;
+    unregister(id: string): void;
+    clear(): void;
+    handles(textDocument: vscode.TextDocument): boolean;
+    getProvider(notebookCell: vscode.NotebookCell): NotebookDocumentSyncFeatureShape | undefined;
+    private findNotebookDocumentAndCell;
+}