naider 1.7.0

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

@@ -0,0 +1,54 @@
+"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.DeclarationFeature = void 0;
+const vscode_1 = require("vscode");
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const features_1 = require("./features");
+class DeclarationFeature extends features_1.TextDocumentLanguageFeature {
+    constructor(client) {
+        super(client, vscode_languageserver_protocol_1.DeclarationRequest.type);
+    }
+    fillClientCapabilities(capabilities) {
+        const declarationSupport = (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'declaration');
+        declarationSupport.dynamicRegistration = true;
+        declarationSupport.linkSupport = true;
+    }
+    initialize(capabilities, documentSelector) {
+        const [id, options] = this.getRegistration(documentSelector, capabilities.declarationProvider);
+        if (!id || !options) {
+            return;
+        }
+        this.register({ id: id, registerOptions: options });
+    }
+    registerLanguageProvider(options) {
+        const selector = options.documentSelector;
+        const provider = {
+            provideDeclaration: (document, position, token) => {
+                const client = this._client;
+                const provideDeclaration = (document, position, token) => {
+                    return client.sendRequest(vscode_languageserver_protocol_1.DeclarationRequest.type, client.code2ProtocolConverter.asTextDocumentPositionParams(document, position), token).then((result) => {
+                        if (token.isCancellationRequested) {
+                            return null;
+                        }
+                        return client.protocol2CodeConverter.asDeclarationResult(result, token);
+                    }, (error) => {
+                        return client.handleFailedRequest(vscode_languageserver_protocol_1.DeclarationRequest.type, token, error, null);
+                    });
+                };
+                const middleware = client.middleware;
+                return middleware.provideDeclaration
+                    ? middleware.provideDeclaration(document, position, token, provideDeclaration)
+                    : provideDeclaration(document, position, token);
+            }
+        };
+        return [this.registerProvider(selector, provider), provider];
+    }
+    registerProvider(selector, provider) {
+        return vscode_1.languages.registerDeclarationProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider);
+    }
+}
+exports.DeclarationFeature = DeclarationFeature;

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

@@ -0,0 +1,16 @@
+import { TextDocument, Disposable, Position as VPosition, CancellationToken, ProviderResult, DefinitionProvider, Definition as VDefinition, DefinitionLink as VDefinitionLink } from 'vscode';
+import { ClientCapabilities, DefinitionOptions, DefinitionRegistrationOptions, DocumentSelector, ServerCapabilities } from 'vscode-languageserver-protocol';
+import { FeatureClient, TextDocumentLanguageFeature } from './features';
+export interface ProvideDefinitionSignature {
+    (this: void, document: TextDocument, position: VPosition, token: CancellationToken): ProviderResult<VDefinition | VDefinitionLink[]>;
+}
+export interface DefinitionMiddleware {
+    provideDefinition?: (this: void, document: TextDocument, position: VPosition, token: CancellationToken, next: ProvideDefinitionSignature) => ProviderResult<VDefinition | VDefinitionLink[]>;
+}
+export declare class DefinitionFeature extends TextDocumentLanguageFeature<boolean | DefinitionOptions, DefinitionRegistrationOptions, DefinitionProvider, DefinitionMiddleware> {
+    constructor(client: FeatureClient<DefinitionMiddleware>);
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
+    protected registerLanguageProvider(options: DefinitionRegistrationOptions): [Disposable, DefinitionProvider];
+    private registerProvider;
+}

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

@@ -0,0 +1,55 @@
+"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.DefinitionFeature = 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 DefinitionFeature extends features_1.TextDocumentLanguageFeature {
+    constructor(client) {
+        super(client, vscode_languageserver_protocol_1.DefinitionRequest.type);
+    }
+    fillClientCapabilities(capabilities) {
+        let definitionSupport = (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'definition');
+        definitionSupport.dynamicRegistration = true;
+        definitionSupport.linkSupport = true;
+    }
+    initialize(capabilities, documentSelector) {
+        const options = this.getRegistrationOptions(documentSelector, capabilities.definitionProvider);
+        if (!options) {
+            return;
+        }
+        this.register({ id: UUID.generateUuid(), registerOptions: options });
+    }
+    registerLanguageProvider(options) {
+        const selector = options.documentSelector;
+        const provider = {
+            provideDefinition: (document, position, token) => {
+                const client = this._client;
+                const provideDefinition = (document, position, token) => {
+                    return client.sendRequest(vscode_languageserver_protocol_1.DefinitionRequest.type, client.code2ProtocolConverter.asTextDocumentPositionParams(document, position), token).then((result) => {
+                        if (token.isCancellationRequested) {
+                            return null;
+                        }
+                        return client.protocol2CodeConverter.asDefinitionResult(result, token);
+                    }, (error) => {
+                        return client.handleFailedRequest(vscode_languageserver_protocol_1.DefinitionRequest.type, token, error, null);
+                    });
+                };
+                const middleware = client.middleware;
+                return middleware.provideDefinition
+                    ? middleware.provideDefinition(document, position, token, provideDefinition)
+                    : provideDefinition(document, position, token);
+            }
+        };
+        return [this.registerProvider(selector, provider), provider];
+    }
+    registerProvider(selector, provider) {
+        return vscode_1.languages.registerDefinitionProvider(this._client.protocol2CodeConverter.asDocumentSelector(selector), provider);
+    }
+}
+exports.DefinitionFeature = DefinitionFeature;

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

@@ -0,0 +1,122 @@
+import { Disposable, CancellationToken, ProviderResult, Diagnostic as VDiagnostic, TextDocument, Event as VEvent, EventEmitter, Uri } from 'vscode';
+import { ClientCapabilities, ServerCapabilities, DocumentSelector, DiagnosticRegistrationOptions, DiagnosticOptions } from 'vscode-languageserver-protocol';
+import { TextDocumentLanguageFeature, FeatureClient } from './features';
+export declare namespace vsdiag {
+    enum DocumentDiagnosticReportKind {
+        full = "full",
+        unChanged = "unChanged"
+    }
+    interface FullDocumentDiagnosticReport {
+        kind: DocumentDiagnosticReportKind.full;
+        resultId?: string;
+        items: VDiagnostic[];
+    }
+    interface RelatedFullDocumentDiagnosticReport extends FullDocumentDiagnosticReport {
+        relatedDocuments?: {
+            [uri: string /** DocumentUri */]: FullDocumentDiagnosticReport | UnchangedDocumentDiagnosticReport;
+        };
+    }
+    interface UnchangedDocumentDiagnosticReport {
+        kind: DocumentDiagnosticReportKind.unChanged;
+        resultId: string;
+    }
+    interface RelatedUnchangedDocumentDiagnosticReport extends UnchangedDocumentDiagnosticReport {
+        relatedDocuments?: {
+            [uri: string /** DocumentUri */]: FullDocumentDiagnosticReport | UnchangedDocumentDiagnosticReport;
+        };
+    }
+    type DocumentDiagnosticReport = RelatedFullDocumentDiagnosticReport | RelatedUnchangedDocumentDiagnosticReport;
+    type PreviousResultId = {
+        uri: Uri;
+        value: string;
+    };
+    interface WorkspaceFullDocumentDiagnosticReport extends FullDocumentDiagnosticReport {
+        uri: Uri;
+        version: number | null;
+    }
+    interface WorkspaceUnchangedDocumentDiagnosticReport extends UnchangedDocumentDiagnosticReport {
+        uri: Uri;
+        version: number | null;
+    }
+    type WorkspaceDocumentDiagnosticReport = WorkspaceFullDocumentDiagnosticReport | WorkspaceUnchangedDocumentDiagnosticReport;
+    interface WorkspaceDiagnosticReport {
+        items: WorkspaceDocumentDiagnosticReport[];
+    }
+    interface WorkspaceDiagnosticReportPartialResult {
+        items: WorkspaceDocumentDiagnosticReport[];
+    }
+    interface ResultReporter {
+        (chunk: WorkspaceDiagnosticReportPartialResult | null): void;
+    }
+    interface DiagnosticProvider {
+        onDidChangeDiagnostics: VEvent<void>;
+        provideDiagnostics(document: TextDocument | Uri, previousResultId: string | undefined, token: CancellationToken): ProviderResult<DocumentDiagnosticReport>;
+        provideWorkspaceDiagnostics?(resultIds: PreviousResultId[], token: CancellationToken, resultReporter: ResultReporter): ProviderResult<WorkspaceDiagnosticReport>;
+    }
+}
+export type ProvideDiagnosticSignature = (this: void, document: TextDocument | Uri, previousResultId: string | undefined, token: CancellationToken) => ProviderResult<vsdiag.DocumentDiagnosticReport>;
+export type ProvideWorkspaceDiagnosticSignature = (this: void, resultIds: vsdiag.PreviousResultId[], token: CancellationToken, resultReporter: vsdiag.ResultReporter) => ProviderResult<vsdiag.WorkspaceDiagnosticReport>;
+export type DiagnosticProviderMiddleware = {
+    provideDiagnostics?: (this: void, document: TextDocument | Uri, previousResultId: string | undefined, token: CancellationToken, next: ProvideDiagnosticSignature) => ProviderResult<vsdiag.DocumentDiagnosticReport>;
+    provideWorkspaceDiagnostics?: (this: void, resultIds: vsdiag.PreviousResultId[], token: CancellationToken, resultReporter: vsdiag.ResultReporter, next: ProvideWorkspaceDiagnosticSignature) => ProviderResult<vsdiag.WorkspaceDiagnosticReport>;
+};
+export declare enum DiagnosticPullMode {
+    onType = "onType",
+    onSave = "onSave"
+}
+export type DiagnosticPullOptions = {
+    /**
+     * Whether to pull for diagnostics on document change.
+     */
+    onChange?: boolean;
+    /**
+     * Whether to pull for diagnostics on document save.
+     */
+    onSave?: boolean;
+    /**
+     * An optional filter method that is consulted when triggering a
+     * diagnostic pull during document change or document save.
+     *
+     * The document gets filtered if the method returns `true`.
+     *
+     * @param document The document that changed or got saved.
+     * @param mode The pull mode.
+     * @returns whether the document should be filtered (`true`) or not.
+     */
+    filter?(document: TextDocument, mode: DiagnosticPullMode): boolean;
+    /**
+     * Whether to pull for diagnostics on resources of non instantiated
+     * tabs. If it is set to true it is highly recommended to provide
+     * a match method as well. Otherwise the client will not pull for
+     * tabs if the used document selector specifies a language property
+     * since the language value is not known for resources.
+     */
+    onTabs?: boolean;
+    /**
+     * An optional match method that is consulted when pulling for diagnostics
+     * when only a URI is known (e.g. for not instantiated tabs)
+     *
+     * The method should return `true` if the document selector matches the
+     * given resource. See also the `vscode.languages.match` function.
+     *
+     * @param documentSelector The document selector.
+     * @param resource The resource.
+     * @returns whether the resource is matched by the given document selector.
+     */
+    match?(documentSelector: DocumentSelector, resource: Uri): boolean;
+};
+export type $DiagnosticPullOptions = {
+    diagnosticPullOptions?: DiagnosticPullOptions;
+};
+export type DiagnosticProviderShape = {
+    onDidChangeDiagnosticsEmitter: EventEmitter<void>;
+    diagnostics: vsdiag.DiagnosticProvider;
+};
+export declare class DiagnosticFeature extends TextDocumentLanguageFeature<DiagnosticOptions, DiagnosticRegistrationOptions, DiagnosticProviderShape, DiagnosticProviderMiddleware, $DiagnosticPullOptions> {
+    private tabs;
+    constructor(client: FeatureClient<DiagnosticProviderMiddleware, $DiagnosticPullOptions>);
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
+    clear(): void;
+    protected registerLanguageProvider(options: DiagnosticRegistrationOptions): [Disposable, DiagnosticProviderShape];
+}