TypeScript LanguageClient.sendRequest方法代码示例

	let performCodeAction = (args: any[]) => {
		let request: ExecuteCommandParams = {
			command: "wurst.perform_code_action",
			arguments: args
		};
		return client.sendRequest(ExecuteCommandRequest.type, request)
	}

        this.command = vscode.commands.registerCommand("PowerShell.ExpandAlias", () => {
            if (this.languageClient === undefined) {
                this.log.writeAndShowError(`<${ExpandAliasFeature.name}>: ` +
                    "Unable to instantiate; language client undefined.");
                return;
            }

            const editor = Window.activeTextEditor;
            const document = editor.document;
            const selection = editor.selection;
            const sls = selection.start;
            const sle = selection.end;

            let text;
            let range;

            if ((sls.character === sle.character) && (sls.line === sle.line)) {
                text = document.getText();
                range = new vscode.Range(0, 0, document.lineCount, text.length);
            } else {
                text = document.getText(selection);
                range = new vscode.Range(sls.line, sls.character, sle.line, sle.character);
            }

            this.languageClient.sendRequest(ExpandAliasRequestType, text).then((result) => {
                editor.edit((editBuilder) => {
                    editBuilder.replace(range, result);
                });
            });
        });

	let buildMap = async (args: any[]) => {
		let config = vscode.workspace.getConfiguration("wurst");

		let mapPromise: Thenable<string>;
		if (args && args.length > 0) {
			mapPromise = Promise.resolve(args[0]);
		} else {
			let items = workspace.findFiles('*.w3x', null, 10)
				.then(uris => uris.sort(function(a, b) {
					return fs.statSync(b.fsPath).mtime.getTime() -
							fs.statSync(a.fsPath).mtime.getTime();
				}))
				.then(uris => uris.map(uri => uri.path))
			mapPromise = window.showQuickPick(items)
		}
		let mappath = await mapPromise;
		if (!mappath) {
			return Promise.reject("No map selected.");
		}

		let request: ExecuteCommandParams = {
			command: "wurst.buildmap",
			arguments: [{
				'mappath': mappath
			}]
		};
		return client.sendRequest(ExecuteCommandRequest.type, request)
	};

 provideHover: (document, position, token, next) => {
   // This code is adapted from HoverFeature#registerLanguageProvider in
   // https://github.com/Microsoft/vscode-languageserver-node/blob/master/client/src/client.ts
   return client
     .sendRequest(HoverRequest.type,
                  client.code2ProtocolConverter.asTextDocumentPositionParams(document, position), token)
     .then(
       hover => {
         if (!hover) {
           return undefined
         }
         // The server is supposed to return string or { language: string,
         // value: string } or an array of those things, but instead it returns
         // an array of { value: string }. This used to work but with a recent
         // vscode-languageclient the user ends up seeing "[object Object]" as
         // the hover information.
         // We work around this by manually parsing the array of { value: string }
         // into a Hover.
         const contents = hover.contents as { value: string }[]
         let result: vscode.MarkdownString[] = []
         for (let element of contents) {
           let item = new vscode.MarkdownString()
           item.appendCodeblock(element.value, "scala")
           result.push(item)
         }
         return new vscode.Hover(result)
       },
       error => {
         client.logFailedRequest(HoverRequest.type, error)
         return Promise.resolve(null)
       }
     )
 }

    private processAllFilesInWorkspace()
    {
        if (workspace.rootPath == undefined) return;

        var requestType: RequestType<any, any, any> = { method: "buildObjectTreeForWorkspace" };
        this.langClient.sendRequest(requestType);
    }

    private pickPowerShellModule(): Thenable<string> {
        return this.languageClient.sendRequest(FindModuleRequestType, null).then((modules) => {
            const items: QuickPickItem[] = [];

            // We've got the modules info, let's cancel the timeout unless it's already been cancelled
            if (this.cancelFindToken) {
                this.clearCancelFindToken();
            } else {
                // Already timed out, would be weird to dislay modules after we said it timed out.
                return Promise.resolve("");
            }

            for (const item in modules) {
                if (modules.hasOwnProperty(item)) {
                    items.push({ label: modules[item].name, description: modules[item].description });
                }
            }

            if (items.length === 0) {
                return Promise.reject("No PowerShell modules were found.");
            }

            const options: vscode.QuickPickOptions = {
                placeHolder: "Select a PowerShell module to install",
                matchOnDescription: true,
                matchOnDetail: true,
            };

            return vscode.window.showQuickPick(items, options).then((item) => {
                return item ? item.label : "";
            });
        });
    }

    public async complete(): Promise<void> {
        if (this.langClient === undefined) {
            return;
        }

        const triggerStartPos = this.lastChangeRange.start;
        const doc = this.lastDocument;

        const result = await this.langClient.sendRequest(CommentHelpRequestType, {
            documentUri: doc.uri.toString(),
            triggerPosition: triggerStartPos,
            blockComment: this.settings.helpCompletion === Settings.HelpCompletion.BlockComment,
        });

        if (!(result && result.content)) {
            return;
        }

        const replaceRange = new Range(triggerStartPos.translate(0, -1), triggerStartPos.translate(0, 1));

        // TODO add indentation level to the help content
        // Trim leading whitespace (used by the rule for indentation) as VSCode takes care of the indentation.
        // Trim the last empty line and join the strings.
        const lines: string[] = result.content;
        const text = lines
            .map((x) => (x as any).trimLeft())
            .join(this.getEOL(doc.eol));

        const snippetString = new SnippetString(text);

        window.activeTextEditor.insertSnippet(snippetString, replaceRange);
    }

    var disposable = vscode.commands.registerCommand('PowerShell.ExpandAlias', () => {

        var editor = Window.activeTextEditor;
        var document = editor.document;
        var selection = editor.selection;
        var text, range;

        var sls = selection.start;
        var sle = selection.end;

        if (
            (sls.character === sle.character) &&
            (sls.line === sle.line)
        ) {
            text = document.getText();
            range = new vscode.Range(0, 0, document.lineCount, text.length);
        } else {
            text = document.getText(selection);
            range = new vscode.Range(sls.line, sls.character, sle.line, sle.character);
        }

        client.sendRequest(ExpandAliasRequest.type, text).then((result) => {
            editor.edit((editBuilder) => {
                editBuilder.replace(range, result);
            });
        });
    });

        return new Promise<void>((resolve, reject) => {
            var path = document.fileName;
            var text = document.getText();

            var requestType: RequestType<any, any, any> = { method: "buildObjectTreeForDocument" };
            this.langClient.sendRequest(requestType, { path, text }).then(() => resolve() );
        });

 Window.showQuickPick(items,{placeHolder: "Results: (" + modules.length + ")"}).then((selection) => {
 	if (!selection) { return; }
 	switch (selection.label) {
 	    default :
 	        var moduleName = selection.label;
 	        //vscode.window.setStatusBarMessage("Installing PowerShell Module " + moduleName, 1500);
 	        client.sendRequest(InstallModuleRequest.type, moduleName);
 	    }
 	});

 workspace.findFiles('**/*.php', '').then(files => {
     console.log(`Files to parse: ${files.length}`);
     fileProcessCount = files.length;
     var filePaths: string[] = [];
     // Get the objects path value for the current file system
     files.forEach(file => { filePaths.push(file.fsPath); });
     // Send the array of paths to the language server
     this.langClient.sendRequest({ method: "buildFromFiles" }, { files: filePaths });
 });

    var disposable = vscode.commands.registerCommand('PowerShell.OnlineHelp', () => {

        const editor = vscode.window.activeTextEditor;

        var selection = editor.selection;
        var doc = editor.document;
        var cwr = doc.getWordRangeAtPosition(selection.active)
        var text = doc.getText(cwr);

        client.sendRequest(ShowOnlineHelpRequest.type, text);
    });

        this.command = vscode.commands.registerCommand("PowerShell.ShowHelp", (item?) => {
            if (this.languageClient === undefined) {
                this.log.writeAndShowError(`<${ShowHelpFeature.name}>: ` +
                    "Unable to instantiate; language client undefined.");
                return;
            }
            if (!item || !item.Name) {

                const editor = vscode.window.activeTextEditor;

                const selection = editor.selection;
                const doc = editor.document;
                const cwr = doc.getWordRangeAtPosition(selection.active);
                const text = doc.getText(cwr);

                this.languageClient.sendRequest(ShowHelpRequestType, text);
            } else {
                this.languageClient.sendRequest(ShowHelpRequestType, item.Name);
            }
        });

function onCommandSelected(
    chosenItem: ExtensionCommandQuickPickItem,
    client: LanguageClient) {

    if (chosenItem !== undefined) {
        client.sendRequest(
            InvokeExtensionCommandRequest.type,
            { name: chosenItem.command.name,
              context: getEditorContext() });
    }
}

 vscode.commands.registerCommand('PowerShell.RunSelection', () => {
     var editor = vscode.window.activeTextEditor;
     var start = editor.selection.start;
     var end = editor.selection.end;
     if (editor.selection.isEmpty) {
         start = new vscode.Position(start.line, 0)
     }
     client.sendRequest(EvaluateRequest.type, {
         expression:
         editor.document.getText(
             new vscode.Range(start, end))
     });
 });