@volar/test-utils 2.0.0-alpha.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-present Johnson Chu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,31 @@
+# @volar/test-utils
+
+This module provides a simple way to start a language server and interact with it. It exports a function `startLanguageServer` which starts a language server and returns a handle to interact with it.
+
+## Usage
+
+First, import the module and start the language server:
+
+```typescript
+import { startLanguageServer } from '@volar/test-utils';
+
+const serverHandle = startLanguageServer('path/to/server/module');
+```
+
+The `startLanguageServer` function takes the path to the server module as a string and optionally a current working directory as a string or URL.
+
+The returned server handle provides several methods to interact with the language server:
+
+- `initialize(rootUri: string, initializationOptions: InitializationOptions)`: Initializes the language server.
+- `openTextDocument(fileName: string, languageId: string)`: Opens a text document.
+- `openUntitledTextDocument(content: string, languageId: string)`: Opens an untitled text document.
+- `closeTextDocument(uri: string)`: Closes a text document.
+- Various `send*Request` methods: Send language-related requests to the server.
+
+For example, to open a text document and send a completion request:
+
+```typescript
+await serverHandle.initialize('file:///path/to/workspace', {});
+const document = await serverHandle.openTextDocument('path/to/file', 'typescript');
+const completions = await serverHandle.sendCompletionRequest(document.uri, { line: 0, character: 0 });
+```

package/index.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="node" />
+import * as _ from '@volar/language-server/node';
+import * as cp from 'child_process';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+export type LanguageServerHandle = ReturnType<typeof startLanguageServer>;
+export declare function startLanguageServer(serverModule: string, cwd?: string | URL): {
+    process: cp.ChildProcess;
+    connection: _.ProtocolConnection;
+    initialize(rootUri: string, initializationOptions: _.InitializationOptions): Promise<_.InitializeResult<any>>;
+    openTextDocument(fileName: string, languageId: string): Promise<TextDocument>;
+    openUntitledTextDocument(content: string, languageId: string): Promise<TextDocument>;
+    closeTextDocument(uri: string): Promise<void>;
+    sendCompletionRequest(uri: string, position: _.Position): Promise<_.CompletionList | null>;
+    sendCompletionResolveRequest(item: _.CompletionItem): Promise<_.CompletionItem>;
+    sendDocumentDiagnosticRequest(uri: string): Promise<_.DocumentDiagnosticReport>;
+    sendHoverRequest(uri: string, position: _.Position): Promise<_.Hover | null>;
+    sendDocumentFormattingRequest(uri: string, options: _.FormattingOptions): Promise<_.TextEdit[] | null>;
+    sendRenameRequest(uri: string, position: _.Position, newName: string): Promise<_.WorkspaceEdit | null>;
+    sendPrepareRenameRequest(uri: string, position: _.Position): Promise<_.PrepareRenameResult | null>;
+    sendFoldingRangesRequest(uri: string): Promise<_.FoldingRange[] | null>;
+    sendDocumentSymbolRequest(uri: string): Promise<_.DocumentSymbol[] | _.SymbolInformation[] | null>;
+    sendDocumentColorRequest(uri: string): Promise<_.ColorInformation[]>;
+    sendDefinitionRequest(uri: string, position: _.Position): Promise<_.Definition | _.LocationLink[] | null>;
+    sendTypeDefinitionRequest(uri: string, position: _.Position): Promise<_.Definition | _.LocationLink[] | null>;
+    sendReferencesRequest(uri: string, position: _.Position, context: _.ReferenceContext): Promise<_.Location[] | null>;
+    sendSignatureHelpRequest(uri: string, position: _.Position): Promise<_.SignatureHelp | null>;
+    sendSelectionRangesRequest(uri: string, positions: _.Position[]): Promise<_.SelectionRange[] | null>;
+    sendCodeActionsRequest(uri: string, range: _.Range, context: _.CodeActionContext): Promise<(_.CodeAction | _.Command)[] | null>;
+    sendCodeActionResolveRequest(codeAction: _.CodeAction): Promise<_.CodeAction>;
+    sendExecuteCommandRequest(command: string, args?: any[]): Promise<any>;
+    sendSemanticTokensRequest(uri: string): Promise<_.SemanticTokens | null>;
+    sendSemanticTokensRangeRequest(uri: string, range: _.Range): Promise<_.SemanticTokens | null>;
+    sendColorPresentationRequest(uri: string, color: _.Color, range: _.Range): Promise<_.ColorPresentation[]>;
+    sendDocumentLinkRequest(uri: string): Promise<_.DocumentLink[] | null>;
+    sendDocumentLinkResolveRequest(link: _.DocumentLink): Promise<_.DocumentLink>;
+};

package/index.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startLanguageServer = void 0;
+const _ = require("@volar/language-server/node");
+const assert = require("assert");
+const cp = require("child_process");
+const fs = require("fs");
+const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
+const vscode_uri_1 = require("vscode-uri");
+function startLanguageServer(serverModule, cwd) {
+    const childProcess = cp.fork(serverModule, ['--node-ipc', `--clientProcessId=${process.pid.toString()}`], {
+        execArgv: ['--nolazy'],
+        env: process.env,
+        cwd,
+    });
+    const connection = _.createProtocolConnection(new _.IPCMessageReader(childProcess), new _.IPCMessageWriter(childProcess));
+    const openedDocuments = new Map();
+    let untitledCounter = 0;
+    connection.listen();
+    connection.onClose((e) => console.log(e));
+    connection.onUnhandledNotification((e) => console.log(e));
+    connection.onError((e) => console.log(e));
+    connection.onDispose(() => {
+        childProcess.kill();
+    });
+    return {
+        process: childProcess,
+        connection,
+        async initialize(rootUri, initializationOptions) {
+            const result = await connection.sendRequest(_.InitializeRequest.type, {
+                processId: childProcess.pid ?? null,
+                rootUri,
+                capabilities: {},
+                initializationOptions,
+            });
+            await connection.sendNotification(_.InitializedNotification.type);
+            return result;
+        },
+        async openTextDocument(fileName, languageId) {
+            const uri = vscode_uri_1.URI.file(fileName).toString();
+            if (!openedDocuments.has(uri)) {
+                const document = vscode_languageserver_textdocument_1.TextDocument.create(uri, languageId, 0, fs.readFileSync(fileName, 'utf-8'));
+                openedDocuments.set(uri, document);
+                await connection.sendNotification(_.DidOpenTextDocumentNotification.type, {
+                    textDocument: {
+                        uri,
+                        languageId,
+                        version: document.version,
+                        text: document.getText(),
+                    },
+                });
+            }
+            return openedDocuments.get(uri);
+        },
+        async openUntitledTextDocument(content, languageId) {
+            const uri = vscode_uri_1.URI.from({ scheme: 'untitled', path: `Untitled-${untitledCounter++}` }).toString();
+            const document = vscode_languageserver_textdocument_1.TextDocument.create(uri, languageId, 0, content);
+            openedDocuments.set(uri, document);
+            await connection.sendNotification(_.DidOpenTextDocumentNotification.type, {
+                textDocument: {
+                    uri,
+                    languageId,
+                    version: document.version,
+                    text: document.getText(),
+                },
+            });
+            return document;
+        },
+        closeTextDocument(uri) {
+            assert(openedDocuments.has(uri));
+            openedDocuments.delete(uri);
+            return connection.sendNotification(_.DidCloseTextDocumentNotification.type, {
+                textDocument: { uri },
+            });
+        },
+        async sendCompletionRequest(uri, position) {
+            const result = await connection.sendRequest(_.CompletionRequest.type, {
+                textDocument: { uri },
+                position,
+            });
+            // @volar/language-server only returns CompletionList
+            assert(!Array.isArray(result));
+            return result;
+        },
+        async sendCompletionResolveRequest(item) {
+            return connection.sendRequest(_.CompletionResolveRequest.type, item);
+        },
+        sendDocumentDiagnosticRequest(uri) {
+            return connection.sendRequest(_.DocumentDiagnosticRequest.type, {
+                textDocument: { uri },
+            });
+        },
+        sendHoverRequest(uri, position) {
+            return connection.sendRequest(_.HoverRequest.type, {
+                textDocument: { uri },
+                position,
+            });
+        },
+        sendDocumentFormattingRequest(uri, options) {
+            return connection.sendRequest(_.DocumentFormattingRequest.type, {
+                textDocument: { uri },
+                options,
+            });
+        },
+        sendRenameRequest(uri, position, newName) {
+            return connection.sendRequest(_.RenameRequest.type, {
+                textDocument: { uri },
+                position,
+                newName,
+            });
+        },
+        sendPrepareRenameRequest(uri, position) {
+            return connection.sendRequest(_.PrepareRenameRequest.type, {
+                textDocument: { uri },
+                position,
+            });
+        },
+        sendFoldingRangesRequest(uri) {
+            return connection.sendRequest(_.FoldingRangeRequest.type, {
+                textDocument: { uri },
+            });
+        },
+        sendDocumentSymbolRequest(uri) {
+            return connection.sendRequest(_.DocumentSymbolRequest.type, {
+                textDocument: { uri },
+            });
+        },
+        sendDocumentColorRequest(uri) {
+            return connection.sendRequest(_.DocumentColorRequest.type, {
+                textDocument: { uri },
+            });
+        },
+        sendDefinitionRequest(uri, position) {
+            return connection.sendRequest(_.DefinitionRequest.type, {
+                textDocument: { uri },
+                position,
+            });
+        },
+        sendTypeDefinitionRequest(uri, position) {
+            return connection.sendRequest(_.TypeDefinitionRequest.type, {
+                textDocument: { uri },
+                position,
+            });
+        },
+        sendReferencesRequest(uri, position, context) {
+            return connection.sendRequest(_.ReferencesRequest.type, {
+                textDocument: { uri },
+                position,
+                context,
+            });
+        },
+        sendSignatureHelpRequest(uri, position) {
+            return connection.sendRequest(_.SignatureHelpRequest.type, {
+                textDocument: { uri },
+                position,
+            });
+        },
+        sendSelectionRangesRequest(uri, positions) {
+            return connection.sendRequest(_.SelectionRangeRequest.type, {
+                textDocument: { uri },
+                positions,
+            });
+        },
+        sendCodeActionsRequest(uri, range, context) {
+            return connection.sendRequest(_.CodeActionRequest.type, {
+                textDocument: { uri },
+                range,
+                context,
+            });
+        },
+        sendCodeActionResolveRequest(codeAction) {
+            return connection.sendRequest(_.CodeActionResolveRequest.type, codeAction);
+        },
+        sendExecuteCommandRequest(command, args) {
+            return connection.sendRequest(_.ExecuteCommandRequest.type, {
+                command,
+                arguments: args,
+            });
+        },
+        sendSemanticTokensRequest(uri) {
+            return connection.sendRequest(_.SemanticTokensRequest.type, {
+                textDocument: { uri },
+            });
+        },
+        sendSemanticTokensRangeRequest(uri, range) {
+            return connection.sendRequest(_.SemanticTokensRangeRequest.type, {
+                textDocument: { uri },
+                range,
+            });
+        },
+        sendColorPresentationRequest(uri, color, range) {
+            return connection.sendRequest(_.ColorPresentationRequest.type, {
+                textDocument: { uri },
+                color,
+                range,
+            });
+        },
+        sendDocumentLinkRequest(uri) {
+            return connection.sendRequest(_.DocumentLinkRequest.type, {
+                textDocument: { uri },
+            });
+        },
+        sendDocumentLinkResolveRequest(link) {
+            return connection.sendRequest(_.DocumentLinkResolveRequest.type, link);
+        },
+    };
+}
+exports.startLanguageServer = startLanguageServer;
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,22 @@
+{
+	"name": "@volar/test-utils",
+	"version": "2.0.0-alpha.2",
+	"license": "MIT",
+	"files": [
+		"**/*.js",
+		"**/*.d.ts"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/volarjs/volar.js.git",
+		"directory": "packages/test-utils"
+	},
+	"devDependencies": {
+		"@types/node": "latest"
+	},
+	"dependencies": {
+		"@volar/language-server": "2.0.0-alpha.2",
+		"vscode-languageserver-textdocument": "^1.0.11",
+		"vscode-uri": "^3.0.8"
+	}
+}