naider 1.7.0

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

@@ -0,0 +1,79 @@
+"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.WorkspaceSymbolFeature = void 0;
+const vscode_1 = require("vscode");
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const features_1 = require("./features");
+const documentSymbol_1 = require("./documentSymbol");
+const UUID = require("./utils/uuid");
+class WorkspaceSymbolFeature extends features_1.WorkspaceFeature {
+    constructor(client) {
+        super(client, vscode_languageserver_protocol_1.WorkspaceSymbolRequest.type);
+    }
+    fillClientCapabilities(capabilities) {
+        let symbolCapabilities = (0, features_1.ensure)((0, features_1.ensure)(capabilities, 'workspace'), 'symbol');
+        symbolCapabilities.dynamicRegistration = true;
+        symbolCapabilities.symbolKind = {
+            valueSet: documentSymbol_1.SupportedSymbolKinds
+        };
+        symbolCapabilities.tagSupport = {
+            valueSet: documentSymbol_1.SupportedSymbolTags
+        };
+        symbolCapabilities.resolveSupport = { properties: ['location.range'] };
+    }
+    initialize(capabilities) {
+        if (!capabilities.workspaceSymbolProvider) {
+            return;
+        }
+        this.register({
+            id: UUID.generateUuid(),
+            registerOptions: capabilities.workspaceSymbolProvider === true ? { workDoneProgress: false } : capabilities.workspaceSymbolProvider
+        });
+    }
+    registerLanguageProvider(options) {
+        const provider = {
+            provideWorkspaceSymbols: (query, token) => {
+                const client = this._client;
+                const provideWorkspaceSymbols = (query, token) => {
+                    return client.sendRequest(vscode_languageserver_protocol_1.WorkspaceSymbolRequest.type, { query }, token).then((result) => {
+                        if (token.isCancellationRequested) {
+                            return null;
+                        }
+                        return client.protocol2CodeConverter.asSymbolInformations(result, token);
+                    }, (error) => {
+                        return client.handleFailedRequest(vscode_languageserver_protocol_1.WorkspaceSymbolRequest.type, token, error, null);
+                    });
+                };
+                const middleware = client.middleware;
+                return middleware.provideWorkspaceSymbols
+                    ? middleware.provideWorkspaceSymbols(query, token, provideWorkspaceSymbols)
+                    : provideWorkspaceSymbols(query, token);
+            },
+            resolveWorkspaceSymbol: options.resolveProvider === true
+                ? (item, token) => {
+                    const client = this._client;
+                    const resolveWorkspaceSymbol = (item, token) => {
+                        return client.sendRequest(vscode_languageserver_protocol_1.WorkspaceSymbolResolveRequest.type, client.code2ProtocolConverter.asWorkspaceSymbol(item), token).then((result) => {
+                            if (token.isCancellationRequested) {
+                                return null;
+                            }
+                            return client.protocol2CodeConverter.asSymbolInformation(result);
+                        }, (error) => {
+                            return client.handleFailedRequest(vscode_languageserver_protocol_1.WorkspaceSymbolResolveRequest.type, token, error, null);
+                        });
+                    };
+                    const middleware = client.middleware;
+                    return middleware.resolveWorkspaceSymbol
+                        ? middleware.resolveWorkspaceSymbol(item, token, resolveWorkspaceSymbol)
+                        : resolveWorkspaceSymbol(item, token);
+                }
+                : undefined
+        };
+        return [vscode_1.languages.registerWorkspaceSymbolProvider(provider), provider];
+    }
+}
+exports.WorkspaceSymbolFeature = WorkspaceSymbolFeature;

package/vscode-naide/node_modules/vscode-languageclient/lib/node/main.d.ts

@@ -0,0 +1,100 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import * as cp from 'child_process';
+import ChildProcess = cp.ChildProcess;
+import { Disposable } from 'vscode';
+import { BaseLanguageClient, LanguageClientOptions, MessageTransports } from '../common/client';
+import { InitializeParams } from 'vscode-languageserver-protocol/node';
+export * from 'vscode-languageserver-protocol/node';
+export * from '../common/api';
+export declare enum TransportKind {
+    stdio = 0,
+    ipc = 1,
+    pipe = 2,
+    socket = 3
+}
+export interface SocketTransport {
+    kind: TransportKind.socket;
+    port: number;
+}
+/**
+ * To avoid any timing, pipe name or port number issues the pipe (TransportKind.pipe)
+ * and the sockets (TransportKind.socket and SocketTransport) are owned by the
+ * VS Code processes. The server process simply connects to the pipe / socket.
+ * In node term the VS Code process calls `createServer`, then starts the server
+ * process, waits until the server process has connected to the pipe / socket
+ * and then signals that the connection has been established and messages can
+ * be send back and forth. If the language server is implemented in a different
+ * program language the server simply needs to create a connection to the
+ * passed pipe name or port number.
+ */
+export type Transport = TransportKind | SocketTransport;
+export interface ExecutableOptions {
+    cwd?: string;
+    env?: any;
+    detached?: boolean;
+    shell?: boolean;
+}
+export interface Executable {
+    command: string;
+    transport?: Transport;
+    args?: string[];
+    options?: ExecutableOptions;
+}
+export interface ForkOptions {
+    cwd?: string;
+    env?: any;
+    encoding?: string;
+    execArgv?: string[];
+}
+export interface NodeModule {
+    module: string;
+    transport?: Transport;
+    args?: string[];
+    runtime?: string;
+    options?: ForkOptions;
+}
+export interface StreamInfo {
+    writer: NodeJS.WritableStream;
+    reader: NodeJS.ReadableStream;
+    detached?: boolean;
+}
+export interface ChildProcessInfo {
+    process: ChildProcess;
+    detached: boolean;
+}
+export type ServerOptions = Executable | {
+    run: Executable;
+    debug: Executable;
+} | {
+    run: NodeModule;
+    debug: NodeModule;
+} | NodeModule | (() => Promise<ChildProcess | StreamInfo | MessageTransports | ChildProcessInfo>);
+export declare class LanguageClient extends BaseLanguageClient {
+    private readonly _serverOptions;
+    private readonly _forceDebug;
+    private _serverProcess;
+    private _isDetached;
+    private _isInDebugMode;
+    constructor(name: string, serverOptions: ServerOptions, clientOptions: LanguageClientOptions, forceDebug?: boolean);
+    constructor(id: string, name: string, serverOptions: ServerOptions, clientOptions: LanguageClientOptions, forceDebug?: boolean);
+    private checkVersion;
+    get isInDebugMode(): boolean;
+    restart(): Promise<void>;
+    stop(timeout?: number): Promise<void>;
+    private checkProcessDied;
+    protected handleConnectionClosed(): Promise<void>;
+    protected fillInitializeParams(params: InitializeParams): void;
+    protected createMessageTransports(encoding: string): Promise<MessageTransports>;
+    private _getRuntimePath;
+    private _mainGetRootPath;
+    private _getServerWorkingDir;
+}
+export declare class SettingMonitor {
+    private _client;
+    private _setting;
+    private _listeners;
+    constructor(_client: LanguageClient, _setting: string);
+    start(): Disposable;
+    private onDidChangeConfiguration;
+}