naider 1.7.0

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

@@ -0,0 +1,291 @@
+"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.WorkspaceFeature = exports.TextDocumentLanguageFeature = exports.TextDocumentEventFeature = exports.DynamicDocumentFeature = exports.DynamicFeature = exports.StaticFeature = exports.ensure = exports.LSPCancellationError = void 0;
+const vscode_1 = require("vscode");
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const Is = require("./utils/is");
+const UUID = require("./utils/uuid");
+class LSPCancellationError extends vscode_1.CancellationError {
+    constructor(data) {
+        super();
+        this.data = data;
+    }
+}
+exports.LSPCancellationError = LSPCancellationError;
+function ensure(target, key) {
+    if (target[key] === undefined) {
+        target[key] = {};
+    }
+    return target[key];
+}
+exports.ensure = ensure;
+var StaticFeature;
+(function (StaticFeature) {
+    function is(value) {
+        const candidate = value;
+        return candidate !== undefined && candidate !== null &&
+            Is.func(candidate.fillClientCapabilities) && Is.func(candidate.initialize) && Is.func(candidate.getState) && Is.func(candidate.clear) &&
+            (candidate.fillInitializeParams === undefined || Is.func(candidate.fillInitializeParams));
+    }
+    StaticFeature.is = is;
+})(StaticFeature || (exports.StaticFeature = StaticFeature = {}));
+var DynamicFeature;
+(function (DynamicFeature) {
+    function is(value) {
+        const candidate = value;
+        return candidate !== undefined && candidate !== null &&
+            Is.func(candidate.fillClientCapabilities) && Is.func(candidate.initialize) && Is.func(candidate.getState) && Is.func(candidate.clear) &&
+            (candidate.fillInitializeParams === undefined || Is.func(candidate.fillInitializeParams)) && Is.func(candidate.register) &&
+            Is.func(candidate.unregister) && candidate.registrationType !== undefined;
+    }
+    DynamicFeature.is = is;
+})(DynamicFeature || (exports.DynamicFeature = DynamicFeature = {}));
+/**
+ * An abstract dynamic feature implementation that operates on documents (e.g. text
+ * documents or notebooks).
+ */
+class DynamicDocumentFeature {
+    constructor(client) {
+        this._client = client;
+    }
+    /**
+     * Returns the state the feature is in.
+     */
+    getState() {
+        const selectors = this.getDocumentSelectors();
+        let count = 0;
+        for (const selector of selectors) {
+            count++;
+            for (const document of vscode_1.workspace.textDocuments) {
+                if (vscode_1.languages.match(selector, document) > 0) {
+                    return { kind: 'document', id: this.registrationType.method, registrations: true, matches: true };
+                }
+            }
+        }
+        const registrations = count > 0;
+        return { kind: 'document', id: this.registrationType.method, registrations, matches: false };
+    }
+}
+exports.DynamicDocumentFeature = DynamicDocumentFeature;
+/**
+ * An abstract base class to implement features that react to events
+ * emitted from text documents.
+ */
+class TextDocumentEventFeature extends DynamicDocumentFeature {
+    static textDocumentFilter(selectors, textDocument) {
+        for (const selector of selectors) {
+            if (vscode_1.languages.match(selector, textDocument) > 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+    constructor(client, event, type, middleware, createParams, textDocument, selectorFilter) {
+        super(client);
+        this._event = event;
+        this._type = type;
+        this._middleware = middleware;
+        this._createParams = createParams;
+        this._textDocument = textDocument;
+        this._selectorFilter = selectorFilter;
+        this._selectors = new Map();
+        this._onNotificationSent = new vscode_1.EventEmitter();
+    }
+    getStateInfo() {
+        return [this._selectors.values(), false];
+    }
+    getDocumentSelectors() {
+        return this._selectors.values();
+    }
+    register(data) {
+        if (!data.registerOptions.documentSelector) {
+            return;
+        }
+        if (!this._listener) {
+            this._listener = this._event((data) => {
+                this.callback(data).catch((error) => {
+                    this._client.error(`Sending document notification ${this._type.method} failed.`, error);
+                });
+            });
+        }
+        this._selectors.set(data.id, this._client.protocol2CodeConverter.asDocumentSelector(data.registerOptions.documentSelector));
+    }
+    async callback(data) {
+        const doSend = async (data) => {
+            const params = this._createParams(data);
+            await this._client.sendNotification(this._type, params);
+            this.notificationSent(this.getTextDocument(data), this._type, params);
+        };
+        if (this.matches(data)) {
+            const middleware = this._middleware();
+            return middleware ? middleware(data, (data) => doSend(data)) : doSend(data);
+        }
+    }
+    matches(data) {
+        if (this._client.hasDedicatedTextSynchronizationFeature(this._textDocument(data))) {
+            return false;
+        }
+        return !this._selectorFilter || this._selectorFilter(this._selectors.values(), data);
+    }
+    get onNotificationSent() {
+        return this._onNotificationSent.event;
+    }
+    notificationSent(textDocument, type, params) {
+        this._onNotificationSent.fire({ textDocument, type, params });
+    }
+    unregister(id) {
+        this._selectors.delete(id);
+        if (this._selectors.size === 0 && this._listener) {
+            this._listener.dispose();
+            this._listener = undefined;
+        }
+    }
+    clear() {
+        this._selectors.clear();
+        this._onNotificationSent.dispose();
+        if (this._listener) {
+            this._listener.dispose();
+            this._listener = undefined;
+        }
+    }
+    getProvider(document) {
+        for (const selector of this._selectors.values()) {
+            if (vscode_1.languages.match(selector, document) > 0) {
+                return {
+                    send: (data) => {
+                        return this.callback(data);
+                    }
+                };
+            }
+        }
+        return undefined;
+    }
+}
+exports.TextDocumentEventFeature = TextDocumentEventFeature;
+/**
+ * A abstract feature implementation that registers language providers
+ * for text documents using a given document selector.
+ */
+class TextDocumentLanguageFeature extends DynamicDocumentFeature {
+    constructor(client, registrationType) {
+        super(client);
+        this._registrationType = registrationType;
+        this._registrations = new Map();
+    }
+    *getDocumentSelectors() {
+        for (const registration of this._registrations.values()) {
+            const selector = registration.data.registerOptions.documentSelector;
+            if (selector === null) {
+                continue;
+            }
+            yield this._client.protocol2CodeConverter.asDocumentSelector(selector);
+        }
+    }
+    get registrationType() {
+        return this._registrationType;
+    }
+    register(data) {
+        if (!data.registerOptions.documentSelector) {
+            return;
+        }
+        let registration = this.registerLanguageProvider(data.registerOptions, data.id);
+        this._registrations.set(data.id, { disposable: registration[0], data, provider: registration[1] });
+    }
+    unregister(id) {
+        let registration = this._registrations.get(id);
+        if (registration !== undefined) {
+            registration.disposable.dispose();
+        }
+    }
+    clear() {
+        this._registrations.forEach((value) => {
+            value.disposable.dispose();
+        });
+        this._registrations.clear();
+    }
+    getRegistration(documentSelector, capability) {
+        if (!capability) {
+            return [undefined, undefined];
+        }
+        else if (vscode_languageserver_protocol_1.TextDocumentRegistrationOptions.is(capability)) {
+            const id = vscode_languageserver_protocol_1.StaticRegistrationOptions.hasId(capability) ? capability.id : UUID.generateUuid();
+            const selector = capability.documentSelector ?? documentSelector;
+            if (selector) {
+                return [id, Object.assign({}, capability, { documentSelector: selector })];
+            }
+        }
+        else if (Is.boolean(capability) && capability === true || vscode_languageserver_protocol_1.WorkDoneProgressOptions.is(capability)) {
+            if (!documentSelector) {
+                return [undefined, undefined];
+            }
+            const options = (Is.boolean(capability) && capability === true ? { documentSelector } : Object.assign({}, capability, { documentSelector }));
+            return [UUID.generateUuid(), options];
+        }
+        return [undefined, undefined];
+    }
+    getRegistrationOptions(documentSelector, capability) {
+        if (!documentSelector || !capability) {
+            return undefined;
+        }
+        return (Is.boolean(capability) && capability === true ? { documentSelector } : Object.assign({}, capability, { documentSelector }));
+    }
+    getProvider(textDocument) {
+        for (const registration of this._registrations.values()) {
+            let selector = registration.data.registerOptions.documentSelector;
+            if (selector !== null && vscode_1.languages.match(this._client.protocol2CodeConverter.asDocumentSelector(selector), textDocument) > 0) {
+                return registration.provider;
+            }
+        }
+        return undefined;
+    }
+    getAllProviders() {
+        const result = [];
+        for (const item of this._registrations.values()) {
+            result.push(item.provider);
+        }
+        return result;
+    }
+}
+exports.TextDocumentLanguageFeature = TextDocumentLanguageFeature;
+class WorkspaceFeature {
+    constructor(client, registrationType) {
+        this._client = client;
+        this._registrationType = registrationType;
+        this._registrations = new Map();
+    }
+    getState() {
+        const registrations = this._registrations.size > 0;
+        return { kind: 'workspace', id: this._registrationType.method, registrations };
+    }
+    get registrationType() {
+        return this._registrationType;
+    }
+    register(data) {
+        const registration = this.registerLanguageProvider(data.registerOptions);
+        this._registrations.set(data.id, { disposable: registration[0], provider: registration[1] });
+    }
+    unregister(id) {
+        let registration = this._registrations.get(id);
+        if (registration !== undefined) {
+            registration.disposable.dispose();
+        }
+    }
+    clear() {
+        this._registrations.forEach((registration) => {
+            registration.disposable.dispose();
+        });
+        this._registrations.clear();
+    }
+    getProviders() {
+        const result = [];
+        for (const registration of this._registrations.values()) {
+            result.push(registration.provider);
+        }
+        return result;
+    }
+}
+exports.WorkspaceFeature = WorkspaceFeature;

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

@@ -0,0 +1,116 @@
+import * as code from 'vscode';
+import * as proto from 'vscode-languageserver-protocol';
+import { DynamicFeature, RegistrationData, NextSignature, FeatureState, FeatureClient } from './features';
+/**
+ * File operation middleware
+ *
+ * @since 3.16.0
+ */
+export interface FileOperationsMiddleware {
+    didCreateFiles?: NextSignature<code.FileCreateEvent, Promise<void>>;
+    willCreateFiles?: NextSignature<code.FileWillCreateEvent, Thenable<code.WorkspaceEdit | null | undefined>>;
+    didRenameFiles?: NextSignature<code.FileRenameEvent, Promise<void>>;
+    willRenameFiles?: NextSignature<code.FileWillRenameEvent, Thenable<code.WorkspaceEdit | null | undefined>>;
+    didDeleteFiles?: NextSignature<code.FileDeleteEvent, Promise<void>>;
+    willDeleteFiles?: NextSignature<code.FileWillDeleteEvent, Thenable<code.WorkspaceEdit | null | undefined>>;
+}
+interface FileOperationsWorkspaceMiddleware {
+    workspace?: FileOperationsMiddleware;
+}
+interface Event<I> {
+    readonly files: ReadonlyArray<I>;
+}
+declare abstract class FileOperationFeature<I, E extends Event<I>> implements DynamicFeature<proto.FileOperationRegistrationOptions> {
+    protected readonly _client: FeatureClient<FileOperationsWorkspaceMiddleware>;
+    private readonly _event;
+    private readonly _registrationType;
+    private readonly _clientCapability;
+    private readonly _serverCapability;
+    private _listener;
+    private readonly _filters;
+    constructor(client: FeatureClient<FileOperationsWorkspaceMiddleware>, event: code.Event<E>, registrationType: proto.RegistrationType<proto.FileOperationRegistrationOptions>, clientCapability: keyof proto.FileOperationClientCapabilities, serverCapability: keyof proto.FileOperationOptions);
+    getState(): FeatureState;
+    protected filterSize(): number;
+    get registrationType(): proto.RegistrationType<proto.FileOperationRegistrationOptions>;
+    fillClientCapabilities(capabilities: proto.ClientCapabilities): void;
+    initialize(capabilities: proto.ServerCapabilities): void;
+    register(data: RegistrationData<proto.FileOperationRegistrationOptions>): void;
+    abstract send(data: E): Promise<void>;
+    unregister(id: string): void;
+    clear(): void;
+    protected getFileType(uri: code.Uri): Promise<code.FileType | undefined>;
+    protected filter(event: E, prop: (i: I) => code.Uri): Promise<E>;
+    protected static getFileType(uri: code.Uri): Promise<code.FileType | undefined>;
+    private static asMinimatchOptions;
+}
+declare abstract class NotificationFileOperationFeature<I, E extends {
+    readonly files: ReadonlyArray<I>;
+}, P> extends FileOperationFeature<I, E> {
+    private _notificationType;
+    private _accessUri;
+    private _createParams;
+    constructor(client: FeatureClient<FileOperationsWorkspaceMiddleware>, event: code.Event<E>, notificationType: proto.ProtocolNotificationType<P, proto.FileOperationRegistrationOptions>, clientCapability: keyof proto.FileOperationClientCapabilities, serverCapability: keyof proto.FileOperationOptions, accessUri: (i: I) => code.Uri, createParams: (e: E) => P);
+    send(originalEvent: E): Promise<void>;
+    protected abstract doSend(event: E, next: (event: E) => Promise<void>): Promise<void>;
+}
+declare abstract class CachingNotificationFileOperationFeature<I, E extends {
+    readonly files: ReadonlyArray<I>;
+}, P> extends NotificationFileOperationFeature<I, E, P> {
+    protected _willListener: code.Disposable | undefined;
+    private readonly _fsPathFileTypes;
+    protected getFileType(uri: code.Uri): Promise<code.FileType | undefined>;
+    protected cacheFileTypes(event: E, prop: (i: I) => code.Uri): Promise<void>;
+    protected clearFileTypeCache(): void;
+    unregister(id: string): void;
+    clear(): void;
+}
+export declare class DidCreateFilesFeature extends NotificationFileOperationFeature<code.Uri, code.FileCreateEvent, proto.CreateFilesParams> {
+    constructor(client: FeatureClient<FileOperationsWorkspaceMiddleware>);
+    protected doSend(event: code.FileCreateEvent, next: (event: code.FileCreateEvent) => Promise<void>): Promise<void>;
+}
+export declare class DidRenameFilesFeature extends CachingNotificationFileOperationFeature<{
+    oldUri: code.Uri;
+    newUri: code.Uri;
+}, code.FileRenameEvent, proto.RenameFilesParams> {
+    constructor(client: FeatureClient<FileOperationsWorkspaceMiddleware>);
+    register(data: RegistrationData<proto.FileOperationRegistrationOptions>): void;
+    private willRename;
+    protected doSend(event: code.FileRenameEvent, next: (event: code.FileRenameEvent) => Promise<void>): Promise<void>;
+}
+export declare class DidDeleteFilesFeature extends CachingNotificationFileOperationFeature<code.Uri, code.FileDeleteEvent, proto.DeleteFilesParams> {
+    constructor(client: FeatureClient<FileOperationsWorkspaceMiddleware>);
+    register(data: RegistrationData<proto.FileOperationRegistrationOptions>): void;
+    private willDelete;
+    protected doSend(event: code.FileCreateEvent, next: (event: code.FileCreateEvent) => Promise<void>): Promise<void>;
+}
+interface RequestEvent<I> {
+    readonly token: code.CancellationToken;
+    readonly files: ReadonlyArray<I>;
+    waitUntil(thenable: Thenable<code.WorkspaceEdit>): void;
+    waitUntil(thenable: Thenable<any>): void;
+}
+declare abstract class RequestFileOperationFeature<I, E extends RequestEvent<I>, P> extends FileOperationFeature<I, E> {
+    private _requestType;
+    private _accessUri;
+    private _createParams;
+    constructor(client: FeatureClient<FileOperationsWorkspaceMiddleware>, event: code.Event<E>, requestType: proto.ProtocolRequestType<P, proto.WorkspaceEdit | null, never, void, proto.FileOperationRegistrationOptions>, clientCapability: keyof proto.FileOperationClientCapabilities, serverCapability: keyof proto.FileOperationOptions, accessUri: (i: I) => code.Uri, createParams: (e: Event<I>) => P);
+    send(originalEvent: E & RequestEvent<I>): Promise<void>;
+    private waitUntil;
+    protected abstract doSend(event: E, next: (event: RequestEvent<I>) => Thenable<code.WorkspaceEdit> | Thenable<any>): Thenable<code.WorkspaceEdit> | Thenable<any>;
+}
+export declare class WillCreateFilesFeature extends RequestFileOperationFeature<code.Uri, code.FileWillCreateEvent, proto.CreateFilesParams> {
+    constructor(client: FeatureClient<FileOperationsWorkspaceMiddleware>);
+    protected doSend(event: code.FileWillCreateEvent, next: (event: code.FileWillCreateEvent) => Thenable<code.WorkspaceEdit> | Thenable<any>): Thenable<code.WorkspaceEdit> | Thenable<any>;
+}
+export declare class WillRenameFilesFeature extends RequestFileOperationFeature<{
+    oldUri: code.Uri;
+    newUri: code.Uri;
+}, code.FileWillRenameEvent, proto.RenameFilesParams> {
+    constructor(client: FeatureClient<FileOperationsWorkspaceMiddleware>);
+    protected doSend(event: code.FileWillRenameEvent, next: (event: code.FileWillRenameEvent) => Thenable<code.WorkspaceEdit> | Thenable<any>): Thenable<code.WorkspaceEdit> | Thenable<any>;
+}
+export declare class WillDeleteFilesFeature extends RequestFileOperationFeature<code.Uri, code.FileWillDeleteEvent, proto.DeleteFilesParams> {
+    constructor(client: FeatureClient<FileOperationsWorkspaceMiddleware>);
+    protected doSend(event: code.FileWillDeleteEvent, next: (event: code.FileWillDeleteEvent) => Thenable<code.WorkspaceEdit> | Thenable<any>): Thenable<code.WorkspaceEdit> | Thenable<any>;
+}
+export {};