@vue/language-server 3.0.0-alpha.0 → 3.0.0-alpha.10

package/lib/hybridModeProject.d.ts

@@ -0,0 +1,12 @@
+import type { Language, LanguagePlugin, LanguageServerProject, ProjectContext, ProviderResult } from '@volar/language-server';
+import { URI } from 'vscode-uri';
+export declare function createHybridModeProject(create: (params: {
+    configFileName?: string;
+    asFileName: (scriptId: URI) => string;
+}) => ProviderResult<{
+    languagePlugins: LanguagePlugin<URI>[];
+    setup?(options: {
+        language: Language;
+        project: ProjectContext;
+    }): void;
+}>): LanguageServerProject;

package/lib/hybridModeProject.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHybridModeProject = createHybridModeProject;
+const simpleProject_1 = require("@volar/language-server/lib/project/simpleProject");
+const language_core_1 = require("@vue/language-core");
+const language_service_1 = require("@vue/language-service");
+const utils_1 = require("@vue/typescript-plugin/lib/utils");
+const vscode_uri_1 = require("vscode-uri");
+function createHybridModeProject(create) {
+    let simpleLs;
+    let server;
+    const tsconfigProjects = (0, language_service_1.createUriMap)();
+    const project = {
+        setup(_server) {
+            server = _server;
+            utils_1.onServerReady.push(() => {
+                server.languageFeatures.requestRefresh(false);
+            });
+            server.fileWatcher.onDidChangeWatchedFiles(({ changes }) => {
+                for (const change of changes) {
+                    const changeUri = vscode_uri_1.URI.parse(change.uri);
+                    if (tsconfigProjects.has(changeUri)) {
+                        tsconfigProjects.get(changeUri)?.then(project => project.dispose());
+                        tsconfigProjects.delete(changeUri);
+                    }
+                }
+            });
+            const end = Date.now() + 60000;
+            const pipeWatcher = setInterval(() => {
+                for (const server of utils_1.configuredServers) {
+                    server.update();
+                }
+                for (const server of utils_1.inferredServers) {
+                    server.update();
+                }
+                if (Date.now() > end) {
+                    clearInterval(pipeWatcher);
+                }
+            }, 2500);
+        },
+        async getLanguageService(uri) {
+            const fileName = asFileName(uri);
+            const namedPipeServer = await (0, utils_1.getBestServer)(fileName);
+            if (namedPipeServer?.projectInfo?.kind === 1) {
+                const tsconfig = namedPipeServer.projectInfo.name;
+                const tsconfigUri = vscode_uri_1.URI.file(tsconfig);
+                if (!tsconfigProjects.has(tsconfigUri)) {
+                    tsconfigProjects.set(tsconfigUri, createLs(server, tsconfig));
+                }
+                return await tsconfigProjects.get(tsconfigUri);
+            }
+            else {
+                simpleLs ??= createLs(server, undefined);
+                return await simpleLs;
+            }
+        },
+        getExistingLanguageServices() {
+            return Promise.all([
+                ...tsconfigProjects.values(),
+                simpleLs,
+            ].filter(promise => !!promise));
+        },
+        reload() {
+            for (const ls of [
+                ...tsconfigProjects.values(),
+                simpleLs,
+            ]) {
+                ls?.then(ls => ls.dispose());
+            }
+            tsconfigProjects.clear();
+            simpleLs = undefined;
+        },
+    };
+    return project;
+    function asFileName(uri) {
+        return uri.fsPath.replace(/\\/g, '/');
+    }
+    async function createLs(server, tsconfig) {
+        const { languagePlugins, setup } = await create({
+            configFileName: tsconfig,
+            asFileName,
+        });
+        const language = (0, language_core_1.createLanguage)([
+            { getLanguageId: uri => server.documents.get(uri)?.languageId },
+            ...languagePlugins,
+        ], (0, language_service_1.createUriMap)(), uri => {
+            const document = server.documents.get(uri);
+            if (document) {
+                language.scripts.set(uri, document.getSnapshot(), document.languageId);
+            }
+            else {
+                language.scripts.delete(uri);
+            }
+        });
+        const project = {};
+        setup?.({ language, project });
+        return (0, language_service_1.createLanguageService)(language, server.languageServicePlugins, (0, simpleProject_1.createLanguageServiceEnvironment)(server, [...server.workspaceFolders.all]), project);
+    }
+}
+//# sourceMappingURL=hybridModeProject.js.map

package/lib/initialize.d.ts

@@ -0,0 +1,4 @@
+import type { LanguageServer } from '@volar/language-server';
+import { InitializeParams } from '@vue/language-service';
+import type * as ts from 'typescript';
+export declare function initialize(server: LanguageServer, params: InitializeParams, ts: typeof import('typescript'), tsLocalized: ts.MapLike<string> | undefined): import("@volar/language-server").InitializeResult<import("@volar/language-server").ExperimentalFeatures>;

package/lib/initialize.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initialize = initialize;
+const node_1 = require("@volar/language-server/node");
+const language_core_1 = require("@vue/language-core");
+const language_service_1 = require("@vue/language-service");
+function initialize(server, params, ts, tsLocalized) {
+    const watchingExtensions = new Set();
+    let fileWatcher;
+    return server.initialize(params, (0, node_1.createTypeScriptProject)(ts, tsLocalized, async ({ configFileName, sys, uriConverter }) => {
+        let compilerOptions;
+        let vueCompilerOptions;
+        if (configFileName) {
+            let commandLine = (0, language_core_1.createParsedCommandLine)(ts, sys, configFileName, true);
+            let sysVersion = sys.version;
+            let newSysVersion = await sys.sync();
+            while (sysVersion !== newSysVersion) {
+                commandLine = (0, language_core_1.createParsedCommandLine)(ts, sys, configFileName, true);
+                sysVersion = newSysVersion;
+                newSysVersion = await sys.sync();
+            }
+            compilerOptions = commandLine.options;
+            vueCompilerOptions = commandLine.vueOptions;
+        }
+        else {
+            compilerOptions = ts.getDefaultCompilerOptions();
+            vueCompilerOptions = (0, language_core_1.getDefaultCompilerOptions)();
+        }
+        vueCompilerOptions.__test = params.initializationOptions.typescript.disableAutoImportCache;
+        updateFileWatcher(vueCompilerOptions);
+        return {
+            languagePlugins: [
+                (0, language_core_1.createVueLanguagePlugin)(ts, compilerOptions, vueCompilerOptions, s => uriConverter.asFileName(s)),
+            ],
+            setup({ project }) {
+                project.vue = { compilerOptions: vueCompilerOptions };
+                if (project.typescript) {
+                    const directoryExists = project.typescript.languageServiceHost.directoryExists?.bind(project.typescript.languageServiceHost);
+                    const fileExists = project.typescript.languageServiceHost.fileExists.bind(project.typescript.languageServiceHost);
+                    const getScriptSnapshot = project.typescript.languageServiceHost.getScriptSnapshot.bind(project.typescript.languageServiceHost);
+                    const globalTypesName = (0, language_core_1.getGlobalTypesFileName)(vueCompilerOptions);
+                    const globalTypesContents = `// @ts-nocheck\nexport {};\n` + (0, language_core_1.generateGlobalTypes)(vueCompilerOptions);
+                    const globalTypesSnapshot = {
+                        getText: (start, end) => globalTypesContents.slice(start, end),
+                        getLength: () => globalTypesContents.length,
+                        getChangeRange: () => undefined,
+                    };
+                    if (directoryExists) {
+                        project.typescript.languageServiceHost.directoryExists = path => {
+                            if (path.endsWith('.vue-global-types')) {
+                                return true;
+                            }
+                            return directoryExists(path);
+                        };
+                    }
+                    project.typescript.languageServiceHost.fileExists = path => {
+                        if (path.endsWith(`.vue-global-types/${globalTypesName}`) || path.endsWith(`.vue-global-types\\${globalTypesName}`)) {
+                            return true;
+                        }
+                        return fileExists(path);
+                    };
+                    project.typescript.languageServiceHost.getScriptSnapshot = path => {
+                        if (path.endsWith(`.vue-global-types/${globalTypesName}`) || path.endsWith(`.vue-global-types\\${globalTypesName}`)) {
+                            return globalTypesSnapshot;
+                        }
+                        return getScriptSnapshot(path);
+                    };
+                }
+            },
+        };
+    }), (0, language_service_1.getFullLanguageServicePlugins)(ts, { disableAutoImportCache: params.initializationOptions.typescript.disableAutoImportCache }));
+    function updateFileWatcher(vueCompilerOptions) {
+        const extensions = [
+            'js', 'cjs', 'mjs', 'ts', 'cts', 'mts', 'jsx', 'tsx', 'json',
+            ...(0, language_core_1.getAllExtensions)(vueCompilerOptions).map(ext => ext.slice(1)),
+        ];
+        const newExtensions = extensions.filter(ext => !watchingExtensions.has(ext));
+        if (newExtensions.length) {
+            for (const ext of newExtensions) {
+                watchingExtensions.add(ext);
+            }
+            fileWatcher?.then(dispose => dispose.dispose());
+            fileWatcher = server.fileWatcher.watchFiles(['**/*.{' + [...watchingExtensions].join(',') + '}']);
+        }
+    }
+}
+//# sourceMappingURL=initialize.js.map

package/lib/types.d.ts

@@ -1,8 +1,2 @@
-export type VueInitializationOptions = {
-    typescript: {
-        tsdk: string;
-        tsserverRequestCommand?: string;
-    };
-};
 export * from '@volar/language-server/lib/types';
 export * from '@vue/language-service/lib/types';

package/node.js

@@ -4,19 +4,12 @@ const simpleProject_1 = require("@volar/language-server/lib/project/simpleProjec
 const node_1 = require("@volar/language-server/node");
 const language_core_1 = require("@vue/language-core");
 const language_service_1 = require("@vue/language-service");
+const ts = require("typescript");
 const vscode_uri_1 = require("vscode-uri");
 const connection = (0, node_1.createConnection)();
 const server = (0, node_1.createServer)(connection);
 connection.listen();
 connection.onInitialize(params => {
-    const options = params.initializationOptions;
-    if (!options.typescript?.tsdk) {
-        throw new Error('typescript.tsdk is required');
-    }
-    if (!options.typescript?.tsserverRequestCommand) {
-        connection.console.warn('typescript.tsserverRequestCommand is required since >= 3.0 for complete TS features');
-    }
-    const { typescript: ts } = (0, node_1.loadTsdkByPath)(options.typescript.tsdk, params.locale);
     const tsconfigProjects = (0, language_service_1.createUriMap)();
     const file2ProjectInfo = new Map();
     server.fileWatcher.onDidChangeWatchedFiles(({ changes }) => {
@@ -30,10 +23,16 @@ connection.onInitialize(params => {
         }
     });
     let simpleLs;
+    let tsserverRequestId = 0;
+    const tsserverRequestHandlers = new Map();
+    connection.onNotification('tsserver/response', ([id, res]) => {
+        tsserverRequestHandlers.get(id)?.(res);
+        tsserverRequestHandlers.delete(id);
+    });
     return server.initialize(params, {
         setup() { },
         async getLanguageService(uri) {
-            if (uri.scheme === 'file' && options.typescript.tsserverRequestCommand) {
+            if (uri.scheme === 'file') {
                 const fileName = uri.fsPath.replace(/\\/g, '/');
                 let projectInfoPromise = file2ProjectInfo.get(fileName);
                 if (!projectInfoPromise) {
@@ -63,16 +62,16 @@ connection.onInitialize(params => {
             ].filter(promise => !!promise));
         },
         reload() {
-            for (const ls of [
-                ...tsconfigProjects.values(),
-                simpleLs,
-            ]) {
-                ls?.dispose();
+            for (const ls of tsconfigProjects.values()) {
+                ls.dispose();
             }
             tsconfigProjects.clear();
-            simpleLs = undefined;
+            if (simpleLs) {
+                simpleLs.dispose();
+                simpleLs = undefined;
+            }
         },
-    }, (0, language_service_1.getHybridModeLanguageServicePlugins)(ts, options.typescript.tsserverRequestCommand ? {
+    }, (0, language_service_1.getHybridModeLanguageServicePlugins)(ts, {
         collectExtractProps(...args) {
             return sendTsRequest('vue:collectExtractProps', args);
         },
@@ -100,12 +99,29 @@ connection.onInitialize(params => {
         getPropertiesAtLocation(...args) {
             return sendTsRequest('vue:getPropertiesAtLocation', args);
         },
-        getQuickInfoAtPosition(...args) {
-            return sendTsRequest('vue:getQuickInfoAtPosition', args);
+        getDocumentHighlights(fileName, position) {
+            return sendTsRequest('documentHighlights-full', // internal command
+            {
+                file: fileName,
+                ...{ position },
+                filesToSearch: [fileName],
+            });
+        },
+        async getQuickInfoAtPosition(fileName, { line, character }) {
+            const result = await sendTsRequest(ts.server.protocol.CommandTypes.Quickinfo, {
+                file: fileName,
+                line: line + 1,
+                offset: character + 1,
+            });
+            return ts.displayPartsToString(result?.displayParts ?? []);
         },
-    } : undefined));
-    function sendTsRequest(command, args) {
-        return connection.sendRequest(options.typescript.tsserverRequestCommand, [command, args]);
+    }));
+    async function sendTsRequest(command, args) {
+        return await new Promise(resolve => {
+            const requestId = ++tsserverRequestId;
+            tsserverRequestHandlers.set(requestId, resolve);
+            connection.sendNotification('tsserver/request', [requestId, command, args]);
+        });
     }
     function createLs(server, tsconfig) {
         const commonLine = tsconfig

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-server",
-	"version": "3.0.0-alpha.0",
+	"version": "3.0.0-alpha.10",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -16,15 +16,20 @@
 		"directory": "packages/language-server"
 	},
 	"dependencies": {
-		"@typescript/server-harness": "latest",
-		"@volar/language-core": "~2.4.11",
-		"@volar/language-server": "~2.4.11",
-		"@volar/test-utils": "~2.4.11",
-		"@vue/language-core": "3.0.0-alpha.0",
-		"@vue/language-service": "3.0.0-alpha.0",
-		"@vue/typescript-plugin": "3.0.0-alpha.0",
+		"@volar/language-core": "~2.4.13",
+		"@volar/language-server": "~2.4.13",
+		"@volar/test-utils": "~2.4.13",
+		"@vue/language-core": "3.0.0-alpha.10",
+		"@vue/language-service": "3.0.0-alpha.10",
+		"@vue/typescript-plugin": "3.0.0-alpha.10",
 		"vscode-languageserver-protocol": "^3.17.5",
 		"vscode-uri": "^3.0.8"
 	},
-	"gitHead": "4b49cbe09097e482def4603b90f6c3b93bb2e913"
+	"peerDependencies": {
+		"typescript": "*"
+	},
+	"devDependencies": {
+		"@typescript/server-harness": "latest"
+	},
+	"gitHead": "28308b4f76cc80c7632f39ae7e0944f1889661a2"
 }