naider 1.7.0

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

@@ -0,0 +1,15 @@
+import { TextDocument, Disposable, Position as VPosition, CancellationToken, ProviderResult, DocumentHighlightProvider, DocumentHighlight as VDocumentHighlight } from 'vscode';
+import { ClientCapabilities, DocumentHighlightOptions, DocumentHighlightRegistrationOptions, DocumentSelector, ServerCapabilities, TextDocumentRegistrationOptions } from 'vscode-languageserver-protocol';
+import { FeatureClient, TextDocumentLanguageFeature } from './features';
+export interface ProvideDocumentHighlightsSignature {
+    (this: void, document: TextDocument, position: VPosition, token: CancellationToken): ProviderResult<VDocumentHighlight[]>;
+}
+export interface DocumentHighlightMiddleware {
+    provideDocumentHighlights?: (this: void, document: TextDocument, position: VPosition, token: CancellationToken, next: ProvideDocumentHighlightsSignature) => ProviderResult<VDocumentHighlight[]>;
+}
+export declare class DocumentHighlightFeature extends TextDocumentLanguageFeature<boolean | DocumentHighlightOptions, DocumentHighlightRegistrationOptions, DocumentHighlightProvider, DocumentHighlightMiddleware> {
+    constructor(client: FeatureClient<DocumentHighlightMiddleware>);
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
+    protected registerLanguageProvider(options: TextDocumentRegistrationOptions): [Disposable, DocumentHighlightProvider];
+}

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

@@ -0,0 +1,50 @@
+"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.DocumentHighlightFeature = void 0;
+const vscode_1 = require("vscode");
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const features_1 = require("./features");
+const UUID = require("./utils/uuid");
+class DocumentHighlightFeature extends features_1.TextDocumentLanguageFeature {
+    constructor(client) {
+        super(client, vscode_languageserver_protocol_1.DocumentHighlightRequest.type);
+    }
+    fillClientCapabilities(capabilities) {
+        (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'documentHighlight').dynamicRegistration = true;
+    }
+    initialize(capabilities, documentSelector) {
+        const options = this.getRegistrationOptions(documentSelector, capabilities.documentHighlightProvider);
+        if (!options) {
+            return;
+        }
+        this.register({ id: UUID.generateUuid(), registerOptions: options });
+    }
+    registerLanguageProvider(options) {
+        const selector = options.documentSelector;
+        const provider = {
+            provideDocumentHighlights: (document, position, token) => {
+                const client = this._client;
+                const _provideDocumentHighlights = (document, position, token) => {
+                    return client.sendRequest(vscode_languageserver_protocol_1.DocumentHighlightRequest.type, client.code2ProtocolConverter.asTextDocumentPositionParams(document, position), token).then((result) => {
+                        if (token.isCancellationRequested) {
+                            return null;
+                        }
+                        return client.protocol2CodeConverter.asDocumentHighlights(result, token);
+                    }, (error) => {
+                        return client.handleFailedRequest(vscode_languageserver_protocol_1.DocumentHighlightRequest.type, token, error, null);
+                    });
+                };
+                const middleware = client.middleware;
+                return middleware.provideDocumentHighlights
+                    ? middleware.provideDocumentHighlights(document, position, token, _provideDocumentHighlights)
+                    : _provideDocumentHighlights(document, position, token);
+            }
+        };
+        return [vscode_1.languages.registerDocumentHighlightProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider), provider];
+    }
+}
+exports.DocumentHighlightFeature = DocumentHighlightFeature;

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

@@ -0,0 +1,19 @@
+import { TextDocument, Disposable, CancellationToken, ProviderResult, DocumentLinkProvider, DocumentLink as VDocumentLink } from 'vscode';
+import { ClientCapabilities, DocumentLinkOptions, DocumentLinkRegistrationOptions, DocumentSelector, ServerCapabilities } from 'vscode-languageserver-protocol';
+import { FeatureClient, TextDocumentLanguageFeature } from './features';
+export interface ProvideDocumentLinksSignature {
+    (this: void, document: TextDocument, token: CancellationToken): ProviderResult<VDocumentLink[]>;
+}
+export interface ResolveDocumentLinkSignature {
+    (this: void, link: VDocumentLink, token: CancellationToken): ProviderResult<VDocumentLink>;
+}
+export interface DocumentLinkMiddleware {
+    provideDocumentLinks?: (this: void, document: TextDocument, token: CancellationToken, next: ProvideDocumentLinksSignature) => ProviderResult<VDocumentLink[]>;
+    resolveDocumentLink?: (this: void, link: VDocumentLink, token: CancellationToken, next: ResolveDocumentLinkSignature) => ProviderResult<VDocumentLink>;
+}
+export declare class DocumentLinkFeature extends TextDocumentLanguageFeature<DocumentLinkOptions, DocumentLinkRegistrationOptions, DocumentLinkProvider, DocumentLinkMiddleware> {
+    constructor(client: FeatureClient<DocumentLinkMiddleware>);
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
+    protected registerLanguageProvider(options: DocumentLinkRegistrationOptions): [Disposable, DocumentLinkProvider];
+}

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

@@ -0,0 +1,71 @@
+"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.DocumentLinkFeature = void 0;
+const vscode_1 = require("vscode");
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const features_1 = require("./features");
+const UUID = require("./utils/uuid");
+class DocumentLinkFeature extends features_1.TextDocumentLanguageFeature {
+    constructor(client) {
+        super(client, vscode_languageserver_protocol_1.DocumentLinkRequest.type);
+    }
+    fillClientCapabilities(capabilities) {
+        const documentLinkCapabilities = (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'documentLink');
+        documentLinkCapabilities.dynamicRegistration = true;
+        documentLinkCapabilities.tooltipSupport = true;
+    }
+    initialize(capabilities, documentSelector) {
+        const options = this.getRegistrationOptions(documentSelector, capabilities.documentLinkProvider);
+        if (!options) {
+            return;
+        }
+        this.register({ id: UUID.generateUuid(), registerOptions: options });
+    }
+    registerLanguageProvider(options) {
+        const selector = options.documentSelector;
+        const provider = {
+            provideDocumentLinks: (document, token) => {
+                const client = this._client;
+                const provideDocumentLinks = (document, token) => {
+                    return client.sendRequest(vscode_languageserver_protocol_1.DocumentLinkRequest.type, client.code2ProtocolConverter.asDocumentLinkParams(document), token).then((result) => {
+                        if (token.isCancellationRequested) {
+                            return null;
+                        }
+                        return client.protocol2CodeConverter.asDocumentLinks(result, token);
+                    }, (error) => {
+                        return client.handleFailedRequest(vscode_languageserver_protocol_1.DocumentLinkRequest.type, token, error, null);
+                    });
+                };
+                const middleware = client.middleware;
+                return middleware.provideDocumentLinks
+                    ? middleware.provideDocumentLinks(document, token, provideDocumentLinks)
+                    : provideDocumentLinks(document, token);
+            },
+            resolveDocumentLink: options.resolveProvider
+                ? (link, token) => {
+                    const client = this._client;
+                    let resolveDocumentLink = (link, token) => {
+                        return client.sendRequest(vscode_languageserver_protocol_1.DocumentLinkResolveRequest.type, client.code2ProtocolConverter.asDocumentLink(link), token).then((result) => {
+                            if (token.isCancellationRequested) {
+                                return link;
+                            }
+                            return client.protocol2CodeConverter.asDocumentLink(result);
+                        }, (error) => {
+                            return client.handleFailedRequest(vscode_languageserver_protocol_1.DocumentLinkResolveRequest.type, token, error, link);
+                        });
+                    };
+                    const middleware = client.middleware;
+                    return middleware.resolveDocumentLink
+                        ? middleware.resolveDocumentLink(link, token, resolveDocumentLink)
+                        : resolveDocumentLink(link, token);
+                }
+                : undefined
+        };
+        return [vscode_1.languages.registerDocumentLinkProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider), provider];
+    }
+}
+exports.DocumentLinkFeature = DocumentLinkFeature;

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

@@ -0,0 +1,17 @@
+import { TextDocument, Disposable, CancellationToken, ProviderResult, DocumentSymbolProvider, SymbolInformation as VSymbolInformation, DocumentSymbol as VDocumentSymbol } from 'vscode';
+import { ClientCapabilities, DocumentSelector, DocumentSymbolOptions, DocumentSymbolRegistrationOptions, ServerCapabilities, SymbolKind, SymbolTag } from 'vscode-languageserver-protocol';
+import { FeatureClient, TextDocumentLanguageFeature } from './features';
+export declare const SupportedSymbolKinds: SymbolKind[];
+export declare const SupportedSymbolTags: SymbolTag[];
+export interface ProvideDocumentSymbolsSignature {
+    (this: void, document: TextDocument, token: CancellationToken): ProviderResult<VSymbolInformation[] | VDocumentSymbol[]>;
+}
+export interface DocumentSymbolMiddleware {
+    provideDocumentSymbols?: (this: void, document: TextDocument, token: CancellationToken, next: ProvideDocumentSymbolsSignature) => ProviderResult<VSymbolInformation[] | VDocumentSymbol[]>;
+}
+export declare class DocumentSymbolFeature extends TextDocumentLanguageFeature<boolean | DocumentSymbolOptions, DocumentSymbolRegistrationOptions, DocumentSymbolProvider, DocumentSymbolMiddleware> {
+    constructor(client: FeatureClient<DocumentSymbolMiddleware>);
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
+    protected registerLanguageProvider(options: DocumentSymbolRegistrationOptions): [Disposable, DocumentSymbolProvider];
+}

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

@@ -0,0 +1,104 @@
+"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.DocumentSymbolFeature = exports.SupportedSymbolTags = exports.SupportedSymbolKinds = void 0;
+const vscode_1 = require("vscode");
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const features_1 = require("./features");
+const UUID = require("./utils/uuid");
+exports.SupportedSymbolKinds = [
+    vscode_languageserver_protocol_1.SymbolKind.File,
+    vscode_languageserver_protocol_1.SymbolKind.Module,
+    vscode_languageserver_protocol_1.SymbolKind.Namespace,
+    vscode_languageserver_protocol_1.SymbolKind.Package,
+    vscode_languageserver_protocol_1.SymbolKind.Class,
+    vscode_languageserver_protocol_1.SymbolKind.Method,
+    vscode_languageserver_protocol_1.SymbolKind.Property,
+    vscode_languageserver_protocol_1.SymbolKind.Field,
+    vscode_languageserver_protocol_1.SymbolKind.Constructor,
+    vscode_languageserver_protocol_1.SymbolKind.Enum,
+    vscode_languageserver_protocol_1.SymbolKind.Interface,
+    vscode_languageserver_protocol_1.SymbolKind.Function,
+    vscode_languageserver_protocol_1.SymbolKind.Variable,
+    vscode_languageserver_protocol_1.SymbolKind.Constant,
+    vscode_languageserver_protocol_1.SymbolKind.String,
+    vscode_languageserver_protocol_1.SymbolKind.Number,
+    vscode_languageserver_protocol_1.SymbolKind.Boolean,
+    vscode_languageserver_protocol_1.SymbolKind.Array,
+    vscode_languageserver_protocol_1.SymbolKind.Object,
+    vscode_languageserver_protocol_1.SymbolKind.Key,
+    vscode_languageserver_protocol_1.SymbolKind.Null,
+    vscode_languageserver_protocol_1.SymbolKind.EnumMember,
+    vscode_languageserver_protocol_1.SymbolKind.Struct,
+    vscode_languageserver_protocol_1.SymbolKind.Event,
+    vscode_languageserver_protocol_1.SymbolKind.Operator,
+    vscode_languageserver_protocol_1.SymbolKind.TypeParameter
+];
+exports.SupportedSymbolTags = [
+    vscode_languageserver_protocol_1.SymbolTag.Deprecated
+];
+class DocumentSymbolFeature extends features_1.TextDocumentLanguageFeature {
+    constructor(client) {
+        super(client, vscode_languageserver_protocol_1.DocumentSymbolRequest.type);
+    }
+    fillClientCapabilities(capabilities) {
+        let symbolCapabilities = (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'documentSymbol');
+        symbolCapabilities.dynamicRegistration = true;
+        symbolCapabilities.symbolKind = {
+            valueSet: exports.SupportedSymbolKinds
+        };
+        symbolCapabilities.hierarchicalDocumentSymbolSupport = true;
+        symbolCapabilities.tagSupport = {
+            valueSet: exports.SupportedSymbolTags
+        };
+        symbolCapabilities.labelSupport = true;
+    }
+    initialize(capabilities, documentSelector) {
+        const options = this.getRegistrationOptions(documentSelector, capabilities.documentSymbolProvider);
+        if (!options) {
+            return;
+        }
+        this.register({ id: UUID.generateUuid(), registerOptions: options });
+    }
+    registerLanguageProvider(options) {
+        const selector = options.documentSelector;
+        const provider = {
+            provideDocumentSymbols: (document, token) => {
+                const client = this._client;
+                const _provideDocumentSymbols = async (document, token) => {
+                    try {
+                        const data = await client.sendRequest(vscode_languageserver_protocol_1.DocumentSymbolRequest.type, client.code2ProtocolConverter.asDocumentSymbolParams(document), token);
+                        if (token.isCancellationRequested || data === undefined || data === null) {
+                            return null;
+                        }
+                        if (data.length === 0) {
+                            return [];
+                        }
+                        else {
+                            const first = data[0];
+                            if (vscode_languageserver_protocol_1.DocumentSymbol.is(first)) {
+                                return await client.protocol2CodeConverter.asDocumentSymbols(data, token);
+                            }
+                            else {
+                                return await client.protocol2CodeConverter.asSymbolInformations(data, token);
+                            }
+                        }
+                    }
+                    catch (error) {
+                        return client.handleFailedRequest(vscode_languageserver_protocol_1.DocumentSymbolRequest.type, token, error, null);
+                    }
+                };
+                const middleware = client.middleware;
+                return middleware.provideDocumentSymbols
+                    ? middleware.provideDocumentSymbols(document, token, _provideDocumentSymbols)
+                    : _provideDocumentSymbols(document, token);
+            }
+        };
+        const metaData = options.label !== undefined ? { label: options.label } : undefined;
+        return [vscode_1.languages.registerDocumentSymbolProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider, metaData), provider];
+    }
+}
+exports.DocumentSymbolFeature = DocumentSymbolFeature;

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

@@ -0,0 +1,21 @@
+import { ProviderResult } from 'vscode';
+import { ClientCapabilities, ServerCapabilities, ExecuteCommandRegistrationOptions, RegistrationType } from 'vscode-languageserver-protocol';
+import { FeatureClient, DynamicFeature, FeatureState, RegistrationData } from './features';
+export interface ExecuteCommandSignature {
+    (this: void, command: string, args: any[]): ProviderResult<any>;
+}
+export interface ExecuteCommandMiddleware {
+    executeCommand?: (this: void, command: string, args: any[], next: ExecuteCommandSignature) => ProviderResult<any>;
+}
+export declare class ExecuteCommandFeature implements DynamicFeature<ExecuteCommandRegistrationOptions> {
+    private readonly _client;
+    private readonly _commands;
+    constructor(client: FeatureClient<ExecuteCommandMiddleware>);
+    getState(): FeatureState;
+    get registrationType(): RegistrationType<ExecuteCommandRegistrationOptions>;
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(capabilities: ServerCapabilities): void;
+    register(data: RegistrationData<ExecuteCommandRegistrationOptions>): void;
+    unregister(id: string): void;
+    clear(): void;
+}

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

@@ -0,0 +1,72 @@
+"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.ExecuteCommandFeature = void 0;
+const vscode_1 = require("vscode");
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const UUID = require("./utils/uuid");
+const features_1 = require("./features");
+class ExecuteCommandFeature {
+    constructor(client) {
+        this._client = client;
+        this._commands = new Map();
+    }
+    getState() {
+        return { kind: 'workspace', id: this.registrationType.method, registrations: this._commands.size > 0 };
+    }
+    get registrationType() {
+        return vscode_languageserver_protocol_1.ExecuteCommandRequest.type;
+    }
+    fillClientCapabilities(capabilities) {
+        (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'workspace'), 'executeCommand').dynamicRegistration = true;
+    }
+    initialize(capabilities) {
+        if (!capabilities.executeCommandProvider) {
+            return;
+        }
+        this.register({
+            id: UUID.generateUuid(),
+            registerOptions: Object.assign({}, capabilities.executeCommandProvider)
+        });
+    }
+    register(data) {
+        const client = this._client;
+        const middleware = client.middleware;
+        const executeCommand = (command, args) => {
+            let params = {
+                command,
+                arguments: args
+            };
+            return client.sendRequest(vscode_languageserver_protocol_1.ExecuteCommandRequest.type, params).then(undefined, (error) => {
+                return client.handleFailedRequest(vscode_languageserver_protocol_1.ExecuteCommandRequest.type, undefined, error, undefined);
+            });
+        };
+        if (data.registerOptions.commands) {
+            const disposables = [];
+            for (const command of data.registerOptions.commands) {
+                disposables.push(vscode_1.commands.registerCommand(command, (...args) => {
+                    return middleware.executeCommand
+                        ? middleware.executeCommand(command, args, executeCommand)
+                        : executeCommand(command, args);
+                }));
+            }
+            this._commands.set(data.id, disposables);
+        }
+    }
+    unregister(id) {
+        let disposables = this._commands.get(id);
+        if (disposables) {
+            disposables.forEach(disposable => disposable.dispose());
+        }
+    }
+    clear() {
+        this._commands.forEach((value) => {
+            value.forEach(disposable => disposable.dispose());
+        });
+        this._commands.clear();
+    }
+}
+exports.ExecuteCommandFeature = ExecuteCommandFeature;