@depup/vscode-languageserver 10.1.1-depup.0

package/lib/common/showDocument.d.ts

@@ -0,0 +1,6 @@
+import { ShowDocumentParams, ShowDocumentResult } from 'vscode-languageserver-protocol';
+import type { Feature, _RemoteWindow } from './server';
+export interface ShowDocumentFeatureShape {
+    showDocument(params: ShowDocumentParams): Promise<ShowDocumentResult>;
+}
+export declare const ShowDocumentFeature: Feature<_RemoteWindow, ShowDocumentFeatureShape>;

package/lib/common/showDocument.js

@@ -0,0 +1,16 @@
+"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.ShowDocumentFeature = void 0;
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const ShowDocumentFeature = (Base) => {
+    return class extends Base {
+        showDocument(params) {
+            return this.connection.sendRequest(vscode_languageserver_protocol_1.ShowDocumentRequest.type, params);
+        }
+    };
+};
+exports.ShowDocumentFeature = ShowDocumentFeature;

package/lib/common/textDocumentContent.d.ts

@@ -0,0 +1,14 @@
+import { type Disposable, type DocumentUri, type RequestHandler, type TextDocumentContentParams, type TextDocumentContentResult } from 'vscode-languageserver-protocol';
+import type { Feature, _RemoteWorkspace } from './server';
+/**
+ * Shape of the text document content feature
+ *
+ * @since 3.18.0
+ */
+export interface TextDocumentContentFeatureShape {
+    textDocumentContent: {
+        refresh(uri: DocumentUri): Promise<void>;
+        on(handler: RequestHandler<TextDocumentContentParams, TextDocumentContentResult | null, void>): Disposable;
+    };
+}
+export declare const TextDocumentContentFeature: Feature<_RemoteWorkspace, TextDocumentContentFeatureShape>;

package/lib/common/textDocumentContent.js

@@ -0,0 +1,25 @@
+"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.TextDocumentContentFeature = void 0;
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const TextDocumentContentFeature = (Base) => {
+    return class extends Base {
+        get textDocumentContent() {
+            return {
+                refresh: (uri) => {
+                    return this.connection.sendRequest(vscode_languageserver_protocol_1.TextDocumentContentRefreshRequest.type, { uri });
+                },
+                on: (handler) => {
+                    return this.connection.onRequest(vscode_languageserver_protocol_1.TextDocumentContentRequest.type, (params, cancel) => {
+                        return handler(params, cancel);
+                    });
+                }
+            };
+        }
+    };
+};
+exports.TextDocumentContentFeature = TextDocumentContentFeature;

package/lib/common/textDocuments.d.ts

@@ -0,0 +1,133 @@
+import { NotificationHandler, DidOpenTextDocumentParams, DidChangeTextDocumentParams, DidCloseTextDocumentParams, WillSaveTextDocumentParams, RequestHandler, TextEdit, DidSaveTextDocumentParams, DocumentUri, TextDocumentContentChangeEvent, TextDocumentSaveReason, Event, TextDocumentSyncKind, Disposable, LanguageKind } from 'vscode-languageserver-protocol';
+/**
+ * We should use a mapped type to create this from Connection.
+ */
+export interface TextDocumentConnection {
+    onDidOpenTextDocument(handler: NotificationHandler<DidOpenTextDocumentParams>): Disposable;
+    onDidChangeTextDocument(handler: NotificationHandler<DidChangeTextDocumentParams>): Disposable;
+    onDidCloseTextDocument(handler: NotificationHandler<DidCloseTextDocumentParams>): Disposable;
+    onWillSaveTextDocument(handler: NotificationHandler<WillSaveTextDocumentParams>): Disposable;
+    onWillSaveTextDocumentWaitUntil(handler: RequestHandler<WillSaveTextDocumentParams, TextEdit[] | undefined | null, void>): Disposable;
+    onDidSaveTextDocument(handler: NotificationHandler<DidSaveTextDocumentParams>): Disposable;
+}
+export interface ConnectionState {
+    __textDocumentSync: TextDocumentSyncKind | undefined;
+}
+export interface TextDocumentsConfiguration<T extends {
+    uri: DocumentUri;
+}> {
+    create(uri: DocumentUri, languageId: LanguageKind, version: number, content: string): T;
+    update(document: T, changes: TextDocumentContentChangeEvent[], version: number): T;
+}
+/**
+ * Event to signal changes to a text document.
+ */
+export interface TextDocumentChangeEvent<T> {
+    /**
+     * The document that has changed.
+     */
+    document: T;
+}
+/**
+ * Event to signal that a document will be saved.
+ */
+export interface TextDocumentWillSaveEvent<T> {
+    /**
+     * The document that will be saved
+     */
+    document: T;
+    /**
+     * The reason why save was triggered.
+     */
+    reason: TextDocumentSaveReason;
+}
+/**
+ * A manager for simple text documents. The manager requires at a minimum that
+ * the server registered for the following text document sync events in the
+ * initialize handler or via dynamic registration:
+ *
+ * - open and close events.
+ * - change events.
+ *
+ * Registering for save and will save events is optional.
+ */
+export declare class TextDocuments<T extends {
+    uri: DocumentUri;
+}> {
+    private readonly _configuration;
+    private readonly _syncedDocuments;
+    private readonly _onDidChangeContent;
+    private readonly _onDidOpen;
+    private readonly _onDidClose;
+    private readonly _onDidSave;
+    private readonly _onWillSave;
+    private _willSaveWaitUntil;
+    /**
+     * Create a new text document manager.
+     */
+    constructor(configuration: TextDocumentsConfiguration<T>);
+    /**
+     * An event that fires when a text document managed by this manager
+     * has been opened.
+     */
+    get onDidOpen(): Event<TextDocumentChangeEvent<T>>;
+    /**
+     * An event that fires when a text document managed by this manager
+     * has been opened or the content changes.
+     */
+    get onDidChangeContent(): Event<TextDocumentChangeEvent<T>>;
+    /**
+     * An event that fires when a text document managed by this manager
+     * will be saved.
+     */
+    get onWillSave(): Event<TextDocumentWillSaveEvent<T>>;
+    /**
+     * Sets a handler that will be called if a participant wants to provide
+     * edits during a text document save.
+     */
+    onWillSaveWaitUntil(handler: RequestHandler<TextDocumentWillSaveEvent<T>, TextEdit[], void>): void;
+    /**
+     * An event that fires when a text document managed by this manager
+     * has been saved.
+     */
+    get onDidSave(): Event<TextDocumentChangeEvent<T>>;
+    /**
+     * An event that fires when a text document managed by this manager
+     * has been closed.
+     */
+    get onDidClose(): Event<TextDocumentChangeEvent<T>>;
+    /**
+     * Returns the document for the given URI. Returns undefined if
+     * the document is not managed by this instance.
+     *
+     * @param uri The text document's URI to retrieve.
+     * @return the text document or `undefined`.
+     */
+    get(uri: string): T | undefined;
+    /**
+     * Returns all text documents managed by this instance.
+     *
+     * @return all text documents.
+     */
+    all(): T[];
+    /**
+     * Returns the URIs of all text documents managed by this instance.
+     *
+     * @return the URI's of all text documents.
+     */
+    keys(): string[];
+    /**
+     * Listens for `low level` notification on the given connection to
+     * update the text documents managed by this instance.
+     *
+     * Please note that the connection only provides handlers not an event model. Therefore
+     * listening on a connection will overwrite the following handlers on a connection:
+     * `onDidOpenTextDocument`, `onDidChangeTextDocument`, `onDidCloseTextDocument`,
+     * `onWillSaveTextDocument`, `onWillSaveTextDocumentWaitUntil` and `onDidSaveTextDocument`.
+     *
+     * Use the corresponding events on the TextDocuments instance instead.
+     *
+     * @param connection The connection to listen on.
+     */
+    listen(connection: TextDocumentConnection): Disposable;
+}

package/lib/common/textDocuments.js

@@ -0,0 +1,180 @@
+"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.TextDocuments = void 0;
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+/**
+ * A manager for simple text documents. The manager requires at a minimum that
+ * the server registered for the following text document sync events in the
+ * initialize handler or via dynamic registration:
+ *
+ * - open and close events.
+ * - change events.
+ *
+ * Registering for save and will save events is optional.
+ */
+class TextDocuments {
+    _configuration;
+    _syncedDocuments;
+    _onDidChangeContent;
+    _onDidOpen;
+    _onDidClose;
+    _onDidSave;
+    _onWillSave;
+    _willSaveWaitUntil;
+    /**
+     * Create a new text document manager.
+     */
+    constructor(configuration) {
+        this._configuration = configuration;
+        this._syncedDocuments = new Map();
+        this._onDidChangeContent = new vscode_languageserver_protocol_1.Emitter();
+        this._onDidOpen = new vscode_languageserver_protocol_1.Emitter();
+        this._onDidClose = new vscode_languageserver_protocol_1.Emitter();
+        this._onDidSave = new vscode_languageserver_protocol_1.Emitter();
+        this._onWillSave = new vscode_languageserver_protocol_1.Emitter();
+    }
+    /**
+     * An event that fires when a text document managed by this manager
+     * has been opened.
+     */
+    get onDidOpen() {
+        return this._onDidOpen.event;
+    }
+    /**
+     * An event that fires when a text document managed by this manager
+     * has been opened or the content changes.
+     */
+    get onDidChangeContent() {
+        return this._onDidChangeContent.event;
+    }
+    /**
+     * An event that fires when a text document managed by this manager
+     * will be saved.
+     */
+    get onWillSave() {
+        return this._onWillSave.event;
+    }
+    /**
+     * Sets a handler that will be called if a participant wants to provide
+     * edits during a text document save.
+     */
+    onWillSaveWaitUntil(handler) {
+        this._willSaveWaitUntil = handler;
+    }
+    /**
+     * An event that fires when a text document managed by this manager
+     * has been saved.
+     */
+    get onDidSave() {
+        return this._onDidSave.event;
+    }
+    /**
+     * An event that fires when a text document managed by this manager
+     * has been closed.
+     */
+    get onDidClose() {
+        return this._onDidClose.event;
+    }
+    /**
+     * Returns the document for the given URI. Returns undefined if
+     * the document is not managed by this instance.
+     *
+     * @param uri The text document's URI to retrieve.
+     * @return the text document or `undefined`.
+     */
+    get(uri) {
+        return this._syncedDocuments.get(uri);
+    }
+    /**
+     * Returns all text documents managed by this instance.
+     *
+     * @return all text documents.
+     */
+    all() {
+        return Array.from(this._syncedDocuments.values());
+    }
+    /**
+     * Returns the URIs of all text documents managed by this instance.
+     *
+     * @return the URI's of all text documents.
+     */
+    keys() {
+        return Array.from(this._syncedDocuments.keys());
+    }
+    /**
+     * Listens for `low level` notification on the given connection to
+     * update the text documents managed by this instance.
+     *
+     * Please note that the connection only provides handlers not an event model. Therefore
+     * listening on a connection will overwrite the following handlers on a connection:
+     * `onDidOpenTextDocument`, `onDidChangeTextDocument`, `onDidCloseTextDocument`,
+     * `onWillSaveTextDocument`, `onWillSaveTextDocumentWaitUntil` and `onDidSaveTextDocument`.
+     *
+     * Use the corresponding events on the TextDocuments instance instead.
+     *
+     * @param connection The connection to listen on.
+     */
+    listen(connection) {
+        connection.__textDocumentSync = vscode_languageserver_protocol_1.TextDocumentSyncKind.Incremental;
+        const disposables = [];
+        disposables.push(connection.onDidOpenTextDocument((event) => {
+            const td = event.textDocument;
+            const document = this._configuration.create(td.uri, td.languageId, td.version, td.text);
+            this._syncedDocuments.set(td.uri, document);
+            const toFire = Object.freeze({ document });
+            this._onDidOpen.fire(toFire);
+            this._onDidChangeContent.fire(toFire);
+        }));
+        disposables.push(connection.onDidChangeTextDocument((event) => {
+            const td = event.textDocument;
+            const changes = event.contentChanges;
+            if (changes.length === 0) {
+                return;
+            }
+            const { version } = td;
+            if (version === null || version === undefined) {
+                throw new Error(`Received document change event for ${td.uri} without valid version identifier`);
+            }
+            let syncedDocument = this._syncedDocuments.get(td.uri);
+            if (syncedDocument !== undefined) {
+                syncedDocument = this._configuration.update(syncedDocument, changes, version);
+                this._syncedDocuments.set(td.uri, syncedDocument);
+                this._onDidChangeContent.fire(Object.freeze({ document: syncedDocument }));
+            }
+        }));
+        disposables.push(connection.onDidCloseTextDocument((event) => {
+            const syncedDocument = this._syncedDocuments.get(event.textDocument.uri);
+            if (syncedDocument !== undefined) {
+                this._syncedDocuments.delete(event.textDocument.uri);
+                this._onDidClose.fire(Object.freeze({ document: syncedDocument }));
+            }
+        }));
+        disposables.push(connection.onWillSaveTextDocument((event) => {
+            const syncedDocument = this._syncedDocuments.get(event.textDocument.uri);
+            if (syncedDocument !== undefined) {
+                this._onWillSave.fire(Object.freeze({ document: syncedDocument, reason: event.reason }));
+            }
+        }));
+        disposables.push(connection.onWillSaveTextDocumentWaitUntil((event, token) => {
+            const syncedDocument = this._syncedDocuments.get(event.textDocument.uri);
+            if (syncedDocument !== undefined && this._willSaveWaitUntil) {
+                return this._willSaveWaitUntil(Object.freeze({ document: syncedDocument, reason: event.reason }), token);
+            }
+            else {
+                return [];
+            }
+        }));
+        disposables.push(connection.onDidSaveTextDocument((event) => {
+            const syncedDocument = this._syncedDocuments.get(event.textDocument.uri);
+            if (syncedDocument !== undefined) {
+                this._onDidSave.fire(Object.freeze({ document: syncedDocument }));
+            }
+        }));
+        return vscode_languageserver_protocol_1.Disposable.create(() => { disposables.forEach(disposable => disposable.dispose()); });
+    }
+}
+exports.TextDocuments = TextDocuments;

package/lib/common/typeHierarchy.d.ts

@@ -0,0 +1,15 @@
+import { TypeHierarchyItem, Disposable, TypeHierarchyPrepareParams, TypeHierarchySupertypesParams, TypeHierarchySubtypesParams } from 'vscode-languageserver-protocol';
+import type { Feature, _Languages, ServerRequestHandler } from './server';
+/**
+ * Shape of the type hierarchy feature
+ *
+ * @since 3.17.0
+ */
+export interface TypeHierarchyFeatureShape {
+    typeHierarchy: {
+        onPrepare(handler: ServerRequestHandler<TypeHierarchyPrepareParams, TypeHierarchyItem[] | null, never, void>): Disposable;
+        onSupertypes(handler: ServerRequestHandler<TypeHierarchySupertypesParams, TypeHierarchyItem[] | null, TypeHierarchyItem[], void>): Disposable;
+        onSubtypes(handler: ServerRequestHandler<TypeHierarchySubtypesParams, TypeHierarchyItem[] | null, TypeHierarchyItem[], void>): Disposable;
+    };
+}
+export declare const TypeHierarchyFeature: Feature<_Languages, TypeHierarchyFeatureShape>;

package/lib/common/typeHierarchy.js

@@ -0,0 +1,34 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeHierarchyFeature = void 0;
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const TypeHierarchyFeature = (Base) => {
+    return class extends Base {
+        get typeHierarchy() {
+            return {
+                onPrepare: (handler) => {
+                    return this.connection.onRequest(vscode_languageserver_protocol_1.TypeHierarchyPrepareRequest.type, (params, cancel) => {
+                        return handler(params, cancel, this.attachWorkDoneProgress(params), undefined);
+                    });
+                },
+                onSupertypes: (handler) => {
+                    const type = vscode_languageserver_protocol_1.TypeHierarchySupertypesRequest.type;
+                    return this.connection.onRequest(type, (params, cancel) => {
+                        return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(type, params));
+                    });
+                },
+                onSubtypes: (handler) => {
+                    const type = vscode_languageserver_protocol_1.TypeHierarchySubtypesRequest.type;
+                    return this.connection.onRequest(type, (params, cancel) => {
+                        return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(type, params));
+                    });
+                }
+            };
+        }
+    };
+};
+exports.TypeHierarchyFeature = TypeHierarchyFeature;

package/lib/common/utils/is.d.ts

@@ -0,0 +1,9 @@
+export declare function boolean(value: any): value is boolean;
+export declare function string(value: any): value is string;
+export declare function number(value: any): value is number;
+export declare function error(value: any): value is Error;
+export declare function func(value: any): value is Function;
+export declare function array<T>(value: any): value is T[];
+export declare function stringArray(value: any): value is string[];
+export declare function typedArray<T>(value: any, check: (value: any) => boolean): value is T[];
+export declare function thenable<T>(value: any): value is Thenable<T>;

package/lib/common/utils/is.js

@@ -0,0 +1,42 @@
+"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.boolean = boolean;
+exports.string = string;
+exports.number = number;
+exports.error = error;
+exports.func = func;
+exports.array = array;
+exports.stringArray = stringArray;
+exports.typedArray = typedArray;
+exports.thenable = thenable;
+function boolean(value) {
+    return value === true || value === false;
+}
+function string(value) {
+    return typeof value === 'string' || value instanceof String;
+}
+function number(value) {
+    return typeof value === 'number' || value instanceof Number;
+}
+function error(value) {
+    return value instanceof Error;
+}
+function func(value) {
+    return typeof value === 'function';
+}
+function array(value) {
+    return Array.isArray(value);
+}
+function stringArray(value) {
+    return array(value) && value.every(elem => string(elem));
+}
+function typedArray(value, check) {
+    return Array.isArray(value) && value.every(check);
+}
+function thenable(value) {
+    return value && func(value.then);
+}

package/lib/common/utils/uuid.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Represents a UUID as defined by rfc4122.
+ */
+export interface UUID {
+    /**
+     * @returns the canonical representation in sets of hexadecimal numbers separated by dashes.
+     */
+    asHex(): string;
+    equals(other: UUID): boolean;
+}
+/**
+ * An empty UUID that contains only zeros.
+ */
+export declare const empty: UUID;
+export declare function v4(): UUID;
+export declare function isUUID(value: string): boolean;
+/**
+ * Parses a UUID that is of the format xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.
+ * @param value A uuid string.
+ */
+export declare function parse(value: string): UUID;
+export declare function generateUuid(): string;

package/lib/common/utils/uuid.js

@@ -0,0 +1,98 @@
+"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.empty = void 0;
+exports.v4 = v4;
+exports.isUUID = isUUID;
+exports.parse = parse;
+exports.generateUuid = generateUuid;
+class ValueUUID {
+    _value;
+    constructor(_value) {
+        this._value = _value;
+        // empty
+    }
+    asHex() {
+        return this._value;
+    }
+    equals(other) {
+        return this.asHex() === other.asHex();
+    }
+}
+class V4UUID extends ValueUUID {
+    static _chars = ['0', '1', '2', '3', '4', '5', '6', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'];
+    static _timeHighBits = ['8', '9', 'a', 'b'];
+    static _oneOf(array) {
+        return array[Math.floor(array.length * Math.random())];
+    }
+    static _randomHex() {
+        return V4UUID._oneOf(V4UUID._chars);
+    }
+    constructor() {
+        super([
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            '-',
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            '-',
+            '4',
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            '-',
+            V4UUID._oneOf(V4UUID._timeHighBits),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            '-',
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+            V4UUID._randomHex(),
+        ].join(''));
+    }
+}
+/**
+ * An empty UUID that contains only zeros.
+ */
+exports.empty = new ValueUUID('00000000-0000-0000-0000-000000000000');
+function v4() {
+    return new V4UUID();
+}
+const _UUIDPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isUUID(value) {
+    return _UUIDPattern.test(value);
+}
+/**
+ * Parses a UUID that is of the format xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.
+ * @param value A uuid string.
+ */
+function parse(value) {
+    if (!isUUID(value)) {
+        throw new Error('invalid uuid');
+    }
+    return new ValueUUID(value);
+}
+function generateUuid() {
+    return v4().asHex();
+}

package/lib/common/workspaceFolder.d.ts

@@ -0,0 +1,7 @@
+import { Event, WorkspaceFolder, WorkspaceFoldersChangeEvent } from 'vscode-languageserver-protocol';
+import type { Feature, _RemoteWorkspace } from './server';
+export interface WorkspaceFolders {
+    getWorkspaceFolders(): Promise<WorkspaceFolder[] | null>;
+    onDidChangeWorkspaceFolders: Event<WorkspaceFoldersChangeEvent>;
+}
+export declare const WorkspaceFoldersFeature: Feature<_RemoteWorkspace, WorkspaceFolders>;

package/lib/common/workspaceFolder.js

@@ -0,0 +1,47 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceFoldersFeature = void 0;
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const WorkspaceFoldersFeature = (Base) => {
+    return class extends Base {
+        _onDidChangeWorkspaceFolders;
+        _unregistration;
+        _notificationIsAutoRegistered;
+        constructor() {
+            super();
+            this._notificationIsAutoRegistered = false;
+        }
+        initialize(capabilities) {
+            super.initialize(capabilities);
+            const workspaceCapabilities = capabilities.workspace;
+            if (workspaceCapabilities && workspaceCapabilities.workspaceFolders) {
+                this._onDidChangeWorkspaceFolders = new vscode_languageserver_protocol_1.Emitter();
+                this.connection.onNotification(vscode_languageserver_protocol_1.DidChangeWorkspaceFoldersNotification.type, (params) => {
+                    this._onDidChangeWorkspaceFolders.fire(params.event);
+                });
+            }
+        }
+        fillServerCapabilities(capabilities) {
+            super.fillServerCapabilities(capabilities);
+            const changeNotifications = capabilities.workspace?.workspaceFolders?.changeNotifications;
+            this._notificationIsAutoRegistered = changeNotifications === true || typeof changeNotifications === 'string';
+        }
+        getWorkspaceFolders() {
+            return this.connection.sendRequest(vscode_languageserver_protocol_1.WorkspaceFoldersRequest.type);
+        }
+        get onDidChangeWorkspaceFolders() {
+            if (!this._onDidChangeWorkspaceFolders) {
+                throw new Error('Client doesn\'t support sending workspace folder change events.');
+            }
+            if (!this._notificationIsAutoRegistered && !this._unregistration) {
+                this._unregistration = this.connection.client.register(vscode_languageserver_protocol_1.DidChangeWorkspaceFoldersNotification.type);
+            }
+            return this._onDidChangeWorkspaceFolders.event;
+        }
+    };
+};
+exports.WorkspaceFoldersFeature = WorkspaceFoldersFeature;