naider 1.7.0

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

@@ -0,0 +1,179 @@
+"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.SemanticTokensFeature = void 0;
+const vscode = require("vscode");
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const features_1 = require("./features");
+const Is = require("./utils/is");
+class SemanticTokensFeature extends features_1.TextDocumentLanguageFeature {
+    constructor(client) {
+        super(client, vscode_languageserver_protocol_1.SemanticTokensRegistrationType.type);
+    }
+    fillClientCapabilities(capabilities) {
+        const capability = (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'semanticTokens');
+        capability.dynamicRegistration = true;
+        capability.tokenTypes = [
+            vscode_languageserver_protocol_1.SemanticTokenTypes.namespace,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.type,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.class,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.enum,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.interface,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.struct,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.typeParameter,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.parameter,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.variable,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.property,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.enumMember,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.event,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.function,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.method,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.macro,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.keyword,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.modifier,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.comment,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.string,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.number,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.regexp,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.operator,
+            vscode_languageserver_protocol_1.SemanticTokenTypes.decorator
+        ];
+        capability.tokenModifiers = [
+            vscode_languageserver_protocol_1.SemanticTokenModifiers.declaration,
+            vscode_languageserver_protocol_1.SemanticTokenModifiers.definition,
+            vscode_languageserver_protocol_1.SemanticTokenModifiers.readonly,
+            vscode_languageserver_protocol_1.SemanticTokenModifiers.static,
+            vscode_languageserver_protocol_1.SemanticTokenModifiers.deprecated,
+            vscode_languageserver_protocol_1.SemanticTokenModifiers.abstract,
+            vscode_languageserver_protocol_1.SemanticTokenModifiers.async,
+            vscode_languageserver_protocol_1.SemanticTokenModifiers.modification,
+            vscode_languageserver_protocol_1.SemanticTokenModifiers.documentation,
+            vscode_languageserver_protocol_1.SemanticTokenModifiers.defaultLibrary
+        ];
+        capability.formats = [vscode_languageserver_protocol_1.TokenFormat.Relative];
+        capability.requests = {
+            range: true,
+            full: {
+                delta: true
+            }
+        };
+        capability.multilineTokenSupport = false;
+        capability.overlappingTokenSupport = false;
+        capability.serverCancelSupport = true;
+        capability.augmentsSyntaxTokens = true;
+        (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'workspace'), 'semanticTokens').refreshSupport = true;
+    }
+    initialize(capabilities, documentSelector) {
+        const client = this._client;
+        client.onRequest(vscode_languageserver_protocol_1.SemanticTokensRefreshRequest.type, async () => {
+            for (const provider of this.getAllProviders()) {
+                provider.onDidChangeSemanticTokensEmitter.fire();
+            }
+        });
+        const [id, options] = this.getRegistration(documentSelector, capabilities.semanticTokensProvider);
+        if (!id || !options) {
+            return;
+        }
+        this.register({ id: id, registerOptions: options });
+    }
+    registerLanguageProvider(options) {
+        const selector = options.documentSelector;
+        const fullProvider = Is.boolean(options.full) ? options.full : options.full !== undefined;
+        const hasEditProvider = options.full !== undefined && typeof options.full !== 'boolean' && options.full.delta === true;
+        const eventEmitter = new vscode.EventEmitter();
+        const documentProvider = fullProvider
+            ? {
+                onDidChangeSemanticTokens: eventEmitter.event,
+                provideDocumentSemanticTokens: (document, token) => {
+                    const client = this._client;
+                    const middleware = client.middleware;
+                    const provideDocumentSemanticTokens = (document, token) => {
+                        const params = {
+                            textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document)
+                        };
+                        return client.sendRequest(vscode_languageserver_protocol_1.SemanticTokensRequest.type, params, token).then((result) => {
+                            if (token.isCancellationRequested) {
+                                return null;
+                            }
+                            return client.protocol2CodeConverter.asSemanticTokens(result, token);
+                        }, (error) => {
+                            return client.handleFailedRequest(vscode_languageserver_protocol_1.SemanticTokensRequest.type, token, error, null);
+                        });
+                    };
+                    return middleware.provideDocumentSemanticTokens
+                        ? middleware.provideDocumentSemanticTokens(document, token, provideDocumentSemanticTokens)
+                        : provideDocumentSemanticTokens(document, token);
+                },
+                provideDocumentSemanticTokensEdits: hasEditProvider
+                    ? (document, previousResultId, token) => {
+                        const client = this._client;
+                        const middleware = client.middleware;
+                        const provideDocumentSemanticTokensEdits = (document, previousResultId, token) => {
+                            const params = {
+                                textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document),
+                                previousResultId
+                            };
+                            return client.sendRequest(vscode_languageserver_protocol_1.SemanticTokensDeltaRequest.type, params, token).then(async (result) => {
+                                if (token.isCancellationRequested) {
+                                    return null;
+                                }
+                                if (vscode_languageserver_protocol_1.SemanticTokens.is(result)) {
+                                    return await client.protocol2CodeConverter.asSemanticTokens(result, token);
+                                }
+                                else {
+                                    return await client.protocol2CodeConverter.asSemanticTokensEdits(result, token);
+                                }
+                            }, (error) => {
+                                return client.handleFailedRequest(vscode_languageserver_protocol_1.SemanticTokensDeltaRequest.type, token, error, null);
+                            });
+                        };
+                        return middleware.provideDocumentSemanticTokensEdits
+                            ? middleware.provideDocumentSemanticTokensEdits(document, previousResultId, token, provideDocumentSemanticTokensEdits)
+                            : provideDocumentSemanticTokensEdits(document, previousResultId, token);
+                    }
+                    : undefined
+            }
+            : undefined;
+        const hasRangeProvider = options.range === true;
+        const rangeProvider = hasRangeProvider
+            ? {
+                provideDocumentRangeSemanticTokens: (document, range, token) => {
+                    const client = this._client;
+                    const middleware = client.middleware;
+                    const provideDocumentRangeSemanticTokens = (document, range, token) => {
+                        const params = {
+                            textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document),
+                            range: client.code2ProtocolConverter.asRange(range)
+                        };
+                        return client.sendRequest(vscode_languageserver_protocol_1.SemanticTokensRangeRequest.type, params, token).then((result) => {
+                            if (token.isCancellationRequested) {
+                                return null;
+                            }
+                            return client.protocol2CodeConverter.asSemanticTokens(result, token);
+                        }, (error) => {
+                            return client.handleFailedRequest(vscode_languageserver_protocol_1.SemanticTokensRangeRequest.type, token, error, null);
+                        });
+                    };
+                    return middleware.provideDocumentRangeSemanticTokens
+                        ? middleware.provideDocumentRangeSemanticTokens(document, range, token, provideDocumentRangeSemanticTokens)
+                        : provideDocumentRangeSemanticTokens(document, range, token);
+                }
+            }
+            : undefined;
+        const disposables = [];
+        const client = this._client;
+        const legend = client.protocol2CodeConverter.asSemanticTokensLegend(options.legend);
+        const documentSelector = client.protocol2CodeConverter.asDocumentSelector(selector);
+        if (documentProvider !== undefined) {
+            disposables.push(vscode.languages.registerDocumentSemanticTokensProvider(documentSelector, documentProvider, legend));
+        }
+        if (rangeProvider !== undefined) {
+            disposables.push(vscode.languages.registerDocumentRangeSemanticTokensProvider(documentSelector, rangeProvider, legend));
+        }
+        return [new vscode.Disposable(() => disposables.forEach(item => item.dispose())), { range: rangeProvider, full: documentProvider, onDidChangeSemanticTokensEmitter: eventEmitter }];
+    }
+}
+exports.SemanticTokensFeature = SemanticTokensFeature;

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

@@ -0,0 +1,16 @@
+import { TextDocument, Disposable, Position as VPosition, CancellationToken, ProviderResult, SignatureHelpProvider, SignatureHelpContext as VSignatureHelpContext, SignatureHelp as VSignatureHelp } from 'vscode';
+import { ClientCapabilities, DocumentSelector, ServerCapabilities, SignatureHelpOptions, SignatureHelpRegistrationOptions } from 'vscode-languageserver-protocol';
+import { FeatureClient, TextDocumentLanguageFeature, DocumentSelectorOptions } from './features';
+export interface ProvideSignatureHelpSignature {
+    (this: void, document: TextDocument, position: VPosition, context: VSignatureHelpContext, token: CancellationToken): ProviderResult<VSignatureHelp>;
+}
+export interface SignatureHelpMiddleware {
+    provideSignatureHelp?: (this: void, document: TextDocument, position: VPosition, context: VSignatureHelpContext, token: CancellationToken, next: ProvideSignatureHelpSignature) => ProviderResult<VSignatureHelp>;
+}
+export declare class SignatureHelpFeature extends TextDocumentLanguageFeature<SignatureHelpOptions, SignatureHelpRegistrationOptions, SignatureHelpProvider, SignatureHelpMiddleware> {
+    constructor(client: FeatureClient<SignatureHelpMiddleware>);
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
+    protected registerLanguageProvider(options: SignatureHelpRegistrationOptions & DocumentSelectorOptions): [Disposable, SignatureHelpProvider];
+    private registerProvider;
+}

package/vscode-naide/node_modules/vscode-languageclient/lib/common/signatureHelp.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.SignatureHelpFeature = 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 SignatureHelpFeature extends features_1.TextDocumentLanguageFeature {
+    constructor(client) {
+        super(client, vscode_languageserver_protocol_1.SignatureHelpRequest.type);
+    }
+    fillClientCapabilities(capabilities) {
+        let config = (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'textDocument'), 'signatureHelp');
+        config.dynamicRegistration = true;
+        config.signatureInformation = { documentationFormat: [vscode_languageserver_protocol_1.MarkupKind.Markdown, vscode_languageserver_protocol_1.MarkupKind.PlainText] };
+        config.signatureInformation.parameterInformation = { labelOffsetSupport: true };
+        config.signatureInformation.activeParameterSupport = true;
+        config.contextSupport = true;
+    }
+    initialize(capabilities, documentSelector) {
+        const options = this.getRegistrationOptions(documentSelector, capabilities.signatureHelpProvider);
+        if (!options) {
+            return;
+        }
+        this.register({
+            id: UUID.generateUuid(),
+            registerOptions: options
+        });
+    }
+    registerLanguageProvider(options) {
+        const provider = {
+            provideSignatureHelp: (document, position, token, context) => {
+                const client = this._client;
+                const providerSignatureHelp = (document, position, context, token) => {
+                    return client.sendRequest(vscode_languageserver_protocol_1.SignatureHelpRequest.type, client.code2ProtocolConverter.asSignatureHelpParams(document, position, context), token).then((result) => {
+                        if (token.isCancellationRequested) {
+                            return null;
+                        }
+                        return client.protocol2CodeConverter.asSignatureHelp(result, token);
+                    }, (error) => {
+                        return client.handleFailedRequest(vscode_languageserver_protocol_1.SignatureHelpRequest.type, token, error, null);
+                    });
+                };
+                const middleware = client.middleware;
+                return middleware.provideSignatureHelp
+                    ? middleware.provideSignatureHelp(document, position, context, token, providerSignatureHelp)
+                    : providerSignatureHelp(document, position, context, token);
+            }
+        };
+        return [this.registerProvider(options, provider), provider];
+    }
+    registerProvider(options, provider) {
+        const selector = this._client.protocol2CodeConverter.asDocumentSelector(options.documentSelector);
+        if (options.retriggerCharacters === undefined) {
+            const triggerCharacters = options.triggerCharacters || [];
+            return vscode_1.languages.registerSignatureHelpProvider(selector, provider, ...triggerCharacters);
+        }
+        else {
+            const metaData = {
+                triggerCharacters: options.triggerCharacters || [],
+                retriggerCharacters: options.retriggerCharacters || []
+            };
+            return vscode_1.languages.registerSignatureHelpProvider(selector, provider, metaData);
+        }
+    }
+}
+exports.SignatureHelpFeature = SignatureHelpFeature;

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

@@ -0,0 +1,101 @@
+import { TextDocument, TextDocumentChangeEvent, TextDocumentWillSaveEvent, TextEdit as VTextEdit, DocumentSelector as VDocumentSelector, Event } from 'vscode';
+import { ClientCapabilities, DidChangeTextDocumentParams, DidCloseTextDocumentParams, DidOpenTextDocumentParams, DidSaveTextDocumentParams, DocumentSelector, ProtocolNotificationType, RegistrationType, ServerCapabilities, TextDocumentChangeRegistrationOptions, TextDocumentRegistrationOptions, TextDocumentSaveRegistrationOptions, TextDocumentSyncKind, TextDocumentSyncOptions, WillSaveTextDocumentParams } from 'vscode-languageserver-protocol';
+import { FeatureClient, TextDocumentEventFeature, DynamicFeature, NextSignature, TextDocumentSendFeature, NotifyingFeature, RegistrationData, DynamicDocumentFeature, NotificationSendEvent } from './features';
+export interface TextDocumentSynchronizationMiddleware {
+    didOpen?: NextSignature<TextDocument, Promise<void>>;
+    didChange?: NextSignature<TextDocumentChangeEvent, Promise<void>>;
+    willSave?: NextSignature<TextDocumentWillSaveEvent, Promise<void>>;
+    willSaveWaitUntil?: NextSignature<TextDocumentWillSaveEvent, Thenable<VTextEdit[]>>;
+    didSave?: NextSignature<TextDocument, Promise<void>>;
+    didClose?: NextSignature<TextDocument, Promise<void>>;
+}
+export interface DidOpenTextDocumentFeatureShape extends DynamicFeature<TextDocumentRegistrationOptions>, TextDocumentSendFeature<(textDocument: TextDocument) => Promise<void>>, NotifyingFeature<DidOpenTextDocumentParams> {
+    openDocuments: Iterable<TextDocument>;
+}
+export type ResolvedTextDocumentSyncCapabilities = {
+    resolvedTextDocumentSync?: TextDocumentSyncOptions;
+};
+export declare class DidOpenTextDocumentFeature extends TextDocumentEventFeature<DidOpenTextDocumentParams, TextDocument, TextDocumentSynchronizationMiddleware> implements DidOpenTextDocumentFeatureShape {
+    private readonly _syncedDocuments;
+    constructor(client: FeatureClient<TextDocumentSynchronizationMiddleware>, syncedDocuments: Map<string, TextDocument>);
+    get openDocuments(): IterableIterator<TextDocument>;
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
+    get registrationType(): RegistrationType<TextDocumentRegistrationOptions>;
+    register(data: RegistrationData<TextDocumentRegistrationOptions>): void;
+    protected getTextDocument(data: TextDocument): TextDocument;
+    protected notificationSent(textDocument: TextDocument, type: ProtocolNotificationType<DidOpenTextDocumentParams, TextDocumentRegistrationOptions>, params: DidOpenTextDocumentParams): void;
+}
+export interface DidCloseTextDocumentFeatureShape extends DynamicFeature<TextDocumentRegistrationOptions>, TextDocumentSendFeature<(textDocument: TextDocument) => Promise<void>>, NotifyingFeature<DidCloseTextDocumentParams> {
+}
+export declare class DidCloseTextDocumentFeature extends TextDocumentEventFeature<DidCloseTextDocumentParams, TextDocument, TextDocumentSynchronizationMiddleware> implements DidCloseTextDocumentFeatureShape {
+    private readonly _syncedDocuments;
+    private readonly _pendingTextDocumentChanges;
+    constructor(client: FeatureClient<TextDocumentSynchronizationMiddleware>, syncedDocuments: Map<string, TextDocument>, pendingTextDocumentChanges: Map<string, TextDocument>);
+    get registrationType(): RegistrationType<TextDocumentRegistrationOptions>;
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
+    protected callback(data: TextDocument): Promise<void>;
+    protected getTextDocument(data: TextDocument): TextDocument;
+    protected notificationSent(textDocument: TextDocument, type: ProtocolNotificationType<DidCloseTextDocumentParams, TextDocumentRegistrationOptions>, params: DidCloseTextDocumentParams): void;
+    unregister(id: string): void;
+}
+export interface DidChangeTextDocumentFeatureShape extends DynamicFeature<TextDocumentChangeRegistrationOptions>, TextDocumentSendFeature<(event: TextDocumentChangeEvent) => Promise<void>>, NotifyingFeature<DidChangeTextDocumentParams> {
+}
+export declare class DidChangeTextDocumentFeature extends DynamicDocumentFeature<TextDocumentChangeRegistrationOptions, TextDocumentSynchronizationMiddleware> implements DidChangeTextDocumentFeatureShape {
+    private _listener;
+    private readonly _changeData;
+    private readonly _onNotificationSent;
+    private readonly _onPendingChangeAdded;
+    private readonly _pendingTextDocumentChanges;
+    private _syncKind;
+    constructor(client: FeatureClient<TextDocumentSynchronizationMiddleware>, pendingTextDocumentChanges: Map<string, TextDocument>);
+    get onNotificationSent(): Event<NotificationSendEvent<DidChangeTextDocumentParams>>;
+    get onPendingChangeAdded(): Event<void>;
+    get syncKind(): TextDocumentSyncKind;
+    get registrationType(): RegistrationType<TextDocumentChangeRegistrationOptions>;
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
+    register(data: RegistrationData<TextDocumentChangeRegistrationOptions>): void;
+    getDocumentSelectors(): IterableIterator<VDocumentSelector>;
+    private callback;
+    notificationSent(textDocument: TextDocument, type: ProtocolNotificationType<DidChangeTextDocumentParams, TextDocumentRegistrationOptions>, params: DidChangeTextDocumentParams): void;
+    unregister(id: string): void;
+    clear(): void;
+    getPendingDocumentChanges(excludes: Set<string>): TextDocument[];
+    getProvider(document: TextDocument): {
+        send: (event: TextDocumentChangeEvent) => Promise<void>;
+    } | undefined;
+    private updateSyncKind;
+}
+export declare class WillSaveFeature extends TextDocumentEventFeature<WillSaveTextDocumentParams, TextDocumentWillSaveEvent, TextDocumentSynchronizationMiddleware> {
+    constructor(client: FeatureClient<TextDocumentSynchronizationMiddleware>);
+    get registrationType(): RegistrationType<TextDocumentRegistrationOptions>;
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
+    protected getTextDocument(data: TextDocumentWillSaveEvent): TextDocument;
+}
+export declare class WillSaveWaitUntilFeature extends DynamicDocumentFeature<TextDocumentRegistrationOptions, TextDocumentSynchronizationMiddleware> {
+    private _listener;
+    private readonly _selectors;
+    constructor(client: FeatureClient<TextDocumentSynchronizationMiddleware>);
+    protected getDocumentSelectors(): IterableIterator<VDocumentSelector>;
+    get registrationType(): RegistrationType<TextDocumentRegistrationOptions>;
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
+    register(data: RegistrationData<TextDocumentRegistrationOptions>): void;
+    private callback;
+    unregister(id: string): void;
+    clear(): void;
+}
+export interface DidSaveTextDocumentFeatureShape extends DynamicFeature<TextDocumentRegistrationOptions>, TextDocumentSendFeature<(textDocument: TextDocument) => Promise<void>>, NotifyingFeature<DidSaveTextDocumentParams> {
+}
+export declare class DidSaveTextDocumentFeature extends TextDocumentEventFeature<DidSaveTextDocumentParams, TextDocument, TextDocumentSynchronizationMiddleware> implements DidSaveTextDocumentFeatureShape {
+    private _includeText;
+    constructor(client: FeatureClient<TextDocumentSynchronizationMiddleware>);
+    get registrationType(): RegistrationType<TextDocumentSaveRegistrationOptions>;
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(capabilities: ServerCapabilities, documentSelector: DocumentSelector): void;
+    register(data: RegistrationData<TextDocumentSaveRegistrationOptions>): void;
+    protected getTextDocument(data: TextDocument): TextDocument;
+}