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

package/index.d.ts

@@ -1,4 +1,3 @@
 export * from './lib/types';
-export * from './lib/initialize';
 export * from '@volar/language-server/lib/types';
 export * from '@vue/language-service/lib/types';

package/index.js

@@ -15,7 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./lib/types"), exports);
-__exportStar(require("./lib/initialize"), exports);
 // export types of parent package
 __exportStar(require("@volar/language-server/lib/types"), exports);
 // only export types of depend packages

package/lib/types.d.ts

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

package/node.js

@@ -1,39 +1,134 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const simpleProject_1 = require("@volar/language-server/lib/project/simpleProject");
 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 namedPipeClient = require("@vue/typescript-plugin/lib/client");
-const hybridModeProject_1 = require("./lib/hybridModeProject");
-const initialize_1 = require("./lib/initialize");
+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;
-    const { typescript: ts, diagnosticMessages } = (0, node_1.loadTsdkByPath)(options.typescript.tsdk, params.locale);
-    const hybridMode = options.vue?.hybridMode ?? true;
-    if (hybridMode) {
-        return server.initialize(params, (0, hybridModeProject_1.createHybridModeProject)(({ asFileName, configFileName }) => {
-            const commandLine = configFileName
-                ? (0, language_core_1.createParsedCommandLine)(ts, ts.sys, configFileName)
-                : {
-                    vueOptions: (0, language_core_1.getDefaultCompilerOptions)(),
-                    options: ts.getDefaultCompilerOptions(),
-                };
-            commandLine.vueOptions.__test = params.initializationOptions.typescript.disableAutoImportCache;
-            return {
-                languagePlugins: [
-                    (0, language_core_1.createVueLanguagePlugin)(ts, commandLine.options, commandLine.vueOptions, asFileName),
-                ],
-                setup({ project }) {
-                    project.vue = { compilerOptions: commandLine.vueOptions };
-                },
-            };
-        }), (0, language_service_1.getHybridModeLanguageServicePlugins)(ts, namedPipeClient));
+    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');
     }
-    else {
-        return (0, initialize_1.initialize)(server, params, ts, diagnosticMessages);
+    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 }) => {
+        for (const change of changes) {
+            const changeUri = vscode_uri_1.URI.parse(change.uri);
+            if (tsconfigProjects.has(changeUri)) {
+                tsconfigProjects.get(changeUri).dispose();
+                tsconfigProjects.delete(changeUri);
+                file2ProjectInfo.clear();
+            }
+        }
+    });
+    let simpleLs;
+    return server.initialize(params, {
+        setup() { },
+        async getLanguageService(uri) {
+            if (uri.scheme === 'file' && options.typescript.tsserverRequestCommand) {
+                const fileName = uri.fsPath.replace(/\\/g, '/');
+                let projectInfoPromise = file2ProjectInfo.get(fileName);
+                if (!projectInfoPromise) {
+                    projectInfoPromise = sendTsRequest(ts.server.protocol.CommandTypes.ProjectInfo, {
+                        file: fileName,
+                        needFileNameList: false,
+                    });
+                    file2ProjectInfo.set(fileName, projectInfoPromise);
+                }
+                const projectInfo = await projectInfoPromise;
+                if (projectInfo) {
+                    const { configFileName } = projectInfo;
+                    let ls = tsconfigProjects.get(vscode_uri_1.URI.file(configFileName));
+                    if (!ls) {
+                        ls = createLs(server, configFileName);
+                        tsconfigProjects.set(vscode_uri_1.URI.file(configFileName), ls);
+                    }
+                    return ls;
+                }
+            }
+            return simpleLs ??= createLs(server, undefined);
+        },
+        getExistingLanguageServices() {
+            return Promise.all([
+                ...tsconfigProjects.values(),
+                simpleLs,
+            ].filter(promise => !!promise));
+        },
+        reload() {
+            for (const ls of [
+                ...tsconfigProjects.values(),
+                simpleLs,
+            ]) {
+                ls?.dispose();
+            }
+            tsconfigProjects.clear();
+            simpleLs = undefined;
+        },
+    }, (0, language_service_1.getHybridModeLanguageServicePlugins)(ts, options.typescript.tsserverRequestCommand ? {
+        collectExtractProps(...args) {
+            return sendTsRequest('vue:collectExtractProps', args);
+        },
+        getComponentDirectives(...args) {
+            return sendTsRequest('vue:getComponentDirectives', args);
+        },
+        getComponentEvents(...args) {
+            return sendTsRequest('vue:getComponentEvents', args);
+        },
+        getComponentNames(...args) {
+            return sendTsRequest('vue:getComponentNames', args);
+        },
+        getComponentProps(...args) {
+            return sendTsRequest('vue:getComponentProps', args);
+        },
+        getElementAttrs(...args) {
+            return sendTsRequest('vue:getElementAttrs', args);
+        },
+        getElementNames(...args) {
+            return sendTsRequest('vue:getElementNames', args);
+        },
+        getImportPathForFile(...args) {
+            return sendTsRequest('vue:getImportPathForFile', args);
+        },
+        getPropertiesAtLocation(...args) {
+            return sendTsRequest('vue:getPropertiesAtLocation', args);
+        },
+        getQuickInfoAtPosition(...args) {
+            return sendTsRequest('vue:getQuickInfoAtPosition', args);
+        },
+    } : undefined));
+    function sendTsRequest(command, args) {
+        return connection.sendRequest(options.typescript.tsserverRequestCommand, [command, args]);
+    }
+    function createLs(server, tsconfig) {
+        const commonLine = tsconfig
+            ? (0, language_core_1.createParsedCommandLine)(ts, ts.sys, tsconfig)
+            : {
+                options: ts.getDefaultCompilerOptions(),
+                vueOptions: (0, language_core_1.getDefaultCompilerOptions)(),
+            };
+        const language = (0, language_core_1.createLanguage)([
+            {
+                getLanguageId: uri => server.documents.get(uri)?.languageId,
+            },
+            (0, language_core_1.createVueLanguagePlugin)(ts, commonLine.options, commonLine.vueOptions, uri => uri.fsPath.replace(/\\/g, '/')),
+        ], (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);
+            }
+        });
+        return (0, language_service_1.createLanguageService)(language, server.languageServicePlugins, (0, simpleProject_1.createLanguageServiceEnvironment)(server, [...server.workspaceFolders.all]), { vue: { compilerOptions: commonLine.vueOptions } });
     }
 });
 connection.onInitialized(server.initialized);

package/package.json

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

package/lib/hybridModeProject.d.ts

@@ -1,12 +0,0 @@
-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

@@ -1,100 +0,0 @@
-"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

@@ -1,4 +0,0 @@
-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

@@ -1,87 +0,0 @@
-"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