css-variable-lsp 1.0.0 → 1.0.1

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

@@ -1,291 +0,0 @@
-"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/client/node_modules/vscode-languageclient/lib/common/fileOperations.d.ts

@@ -1,116 +0,0 @@
-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 {};