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

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/node.js

@@ -100,8 +100,21 @@ 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) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-server",
-	"version": "3.0.0-alpha.0",
+	"version": "3.0.0-alpha.4",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -16,15 +16,17 @@
 		"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",
+		"@vue/language-core": "3.0.0-alpha.4",
+		"@vue/language-service": "3.0.0-alpha.4",
+		"@vue/typescript-plugin": "3.0.0-alpha.4",
 		"vscode-languageserver-protocol": "^3.17.5",
 		"vscode-uri": "^3.0.8"
 	},
-	"gitHead": "4b49cbe09097e482def4603b90f6c3b93bb2e913"
+	"devDependencies": {
+		"@typescript/server-harness": "latest"
+	},
+	"gitHead": "1769cd6b94ec9e0cc2681b8dbba904f35856ba1c"
 }