@vue/language-server 2.0.14 → 2.0.16

package/lib/hybridModeProject.d.ts

@@ -1,3 +1,8 @@
-import type { ServerProjectProviderFactory } from '@volar/language-server';
+import type { LanguagePlugin, ProviderResult, ServerProjectProvider, TypeScriptProjectHost } from '@volar/language-server';
+import { Disposable, ServiceEnvironment } from '@vue/language-service';
 import type * as ts from 'typescript';
-export declare function createHybridModeProjectProviderFactory(sys: ts.System): ServerProjectProviderFactory;
+export type GetLanguagePlugin = (serviceEnv: ServiceEnvironment, configFileName?: string, host?: TypeScriptProjectHost, sys?: ts.System & {
+    version: number;
+    sync(): Promise<number>;
+} & Disposable) => ProviderResult<LanguagePlugin[]>;
+export declare function createHybridModeProjectProviderFactory(sys: ts.System, getLanguagePlugins: GetLanguagePlugin): ServerProjectProvider;

package/lib/hybridModeProject.js

@@ -6,109 +6,96 @@ const simpleProjectProvider_1 = require("@volar/language-server/lib/project/simp
 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");
-function createHybridModeProjectProviderFactory(sys) {
-    return (context, servicePlugins, getLanguagePlugins) => {
-        const serviceEnvs = new language_core_1.FileMap(sys.useCaseSensitiveFileNames);
-        const tsconfigProjects = new language_core_1.FileMap(sys.useCaseSensitiveFileNames);
-        const simpleProjects = new language_core_1.FileMap(sys.useCaseSensitiveFileNames);
-        context.onDidChangeWatchedFiles(({ changes }) => {
+function createHybridModeProjectProviderFactory(sys, getLanguagePlugins) {
+    let initialized = false;
+    const serviceEnvs = new language_core_1.FileMap(sys.useCaseSensitiveFileNames);
+    const tsconfigProjects = new language_core_1.FileMap(sys.useCaseSensitiveFileNames);
+    const simpleProjects = new language_core_1.FileMap(sys.useCaseSensitiveFileNames);
+    return {
+        async get(uri) {
+            if (!initialized) {
+                initialized = true;
+                initialize(this);
+            }
+            const workspaceFolder = (0, simpleProjectProvider_1.getWorkspaceFolder)(uri, this.workspaceFolders);
+            let serviceEnv = serviceEnvs.get(workspaceFolder);
+            if (!serviceEnv) {
+                serviceEnv = (0, simpleProjectProvider_1.createServiceEnvironment)(this, workspaceFolder);
+                serviceEnvs.set(workspaceFolder, serviceEnv);
+            }
+            const fileName = serviceEnv.typescript.uriToFileName(uri);
+            const projectInfo = (await (0, utils_1.searchNamedPipeServerForFile)(fileName))?.projectInfo;
+            if (projectInfo?.kind === 1) {
+                const tsconfig = projectInfo.name;
+                const tsconfigUri = serviceEnv.typescript.fileNameToUri(tsconfig);
+                if (!tsconfigProjects.has(tsconfigUri)) {
+                    tsconfigProjects.set(tsconfigUri, (async () => {
+                        const languagePlugins = await getLanguagePlugins(serviceEnv, tsconfig, undefined, {
+                            ...sys,
+                            version: 0,
+                            async sync() {
+                                return 0;
+                            },
+                            dispose() { },
+                        });
+                        return createTSConfigProject(this, serviceEnv, languagePlugins);
+                    })());
+                }
+                return await tsconfigProjects.get(tsconfigUri);
+            }
+            else {
+                if (!simpleProjects.has(workspaceFolder)) {
+                    simpleProjects.set(workspaceFolder, (async () => {
+                        const languagePlugins = await getLanguagePlugins(serviceEnv);
+                        return (0, simpleProject_1.createSimpleServerProject)(this, serviceEnv, languagePlugins);
+                    })());
+                }
+                return await simpleProjects.get(workspaceFolder);
+            }
+        },
+        async all() {
+            return Promise.all([
+                ...tsconfigProjects.values(),
+                ...simpleProjects.values(),
+            ]);
+        },
+    };
+    function initialize(server) {
+        server.onDidChangeWatchedFiles(({ changes }) => {
             for (const change of changes) {
                 if (tsconfigProjects.has(change.uri)) {
                     tsconfigProjects.get(change.uri)?.then(project => project.dispose());
                     tsconfigProjects.delete(change.uri);
-                    context.reloadDiagnostics();
+                    server.clearPushDiagnostics();
                 }
             }
         });
+    }
+    function createTSConfigProject(server, serviceEnv, languagePlugins) {
+        let languageService;
         return {
-            async getProject(uri) {
-                const workspaceFolder = (0, simpleProjectProvider_1.getWorkspaceFolder)(uri, context.workspaceFolders);
-                let serviceEnv = serviceEnvs.get(workspaceFolder);
-                if (!serviceEnv) {
-                    serviceEnv = (0, simpleProjectProvider_1.createServiceEnvironment)(context, workspaceFolder);
-                    serviceEnvs.set(workspaceFolder, serviceEnv);
-                }
-                const fileName = serviceEnv.typescript.uriToFileName(uri);
-                const projectInfo = (await (0, utils_1.searchNamedPipeServerForFile)(fileName))?.projectInfo;
-                if (projectInfo?.kind === 1) {
-                    const tsconfig = projectInfo.name;
-                    const tsconfigUri = serviceEnv.typescript.fileNameToUri(tsconfig);
-                    if (!tsconfigProjects.has(tsconfigUri)) {
-                        tsconfigProjects.set(tsconfigUri, (async () => {
-                            const languagePlugins = await getLanguagePlugins(serviceEnv, {
-                                typescript: {
-                                    configFileName: tsconfig,
-                                    host: {
-                                        getScriptFileNames() {
-                                            return [];
-                                        },
-                                    },
-                                    sys: {
-                                        ...sys,
-                                        version: 0,
-                                        async sync() {
-                                            return 0;
-                                        },
-                                        dispose() { },
-                                    },
-                                },
-                            });
-                            return createTSConfigProject(context, serviceEnv, languagePlugins, servicePlugins);
-                        })());
-                    }
-                    return await tsconfigProjects.get(tsconfigUri);
-                }
-                else {
-                    if (!simpleProjects.has(workspaceFolder)) {
-                        simpleProjects.set(workspaceFolder, (() => {
-                            return (0, simpleProject_1.createSimpleServerProject)(context, serviceEnv, servicePlugins, getLanguagePlugins);
-                        })());
-                    }
-                    return await simpleProjects.get(workspaceFolder);
-                }
-            },
-            async getProjects() {
-                return Promise.all([
-                    ...tsconfigProjects.values(),
-                    ...simpleProjects.values(),
-                ]);
-            },
-            async reloadProjects() {
-                for (const project of [
-                    ...tsconfigProjects.values(),
-                    ...simpleProjects.values(),
-                ]) {
-                    (await project).dispose();
-                }
-                tsconfigProjects.clear();
+            getLanguageService,
+            getLanguageServiceDontCreate: () => languageService,
+            dispose() {
+                languageService?.dispose();
             },
         };
-        function createTSConfigProject(context, serviceEnv, languagePlugins, servicePlugins) {
-            let languageService;
-            return {
-                getLanguageService,
-                getLanguageServiceDontCreate: () => languageService,
-                dispose() {
-                    languageService?.dispose();
-                },
-            };
-            function getLanguageService() {
-                if (!languageService) {
-                    const language = (0, language_core_1.createLanguage)(languagePlugins, false, uri => {
-                        const script = context.documents.get(uri);
-                        if (script) {
-                            language.scripts.set(uri, script.languageId, script.getSnapshot());
-                        }
-                        else {
-                            language.scripts.delete(uri);
-                        }
-                    });
-                    languageService = (0, language_service_1.createLanguageService)(language, servicePlugins, serviceEnv);
-                }
-                return languageService;
+        function getLanguageService() {
+            if (!languageService) {
+                const language = (0, language_core_1.createLanguage)(languagePlugins, false, uri => {
+                    const document = server.documents.get(uri);
+                    if (document) {
+                        language.scripts.set(uri, document.getSnapshot(), document.languageId);
+                    }
+                    else {
+                        language.scripts.delete(uri);
+                    }
+                });
+                languageService = (0, language_service_1.createLanguageService)(language, server.languageServicePlugins, serviceEnv);
             }
+            return languageService;
         }
-    };
+    }
 }
 exports.createHybridModeProjectProviderFactory = createHybridModeProjectProviderFactory;
 //# sourceMappingURL=hybridModeProject.js.map

package/lib/types.d.ts

@@ -5,9 +5,5 @@ export type VueInitializationOptions = InitializationOptions & {
     };
     vue?: {
         hybridMode?: boolean;
-        /**
-         * @example ['vue1', 'vue2']
-         */
-        additionalExtensions?: string[];
     };
 };

package/node.d.ts

@@ -1,11 +1,43 @@
 import type { Connection } from '@volar/language-server';
+import { GetLanguagePlugin } from './lib/hybridModeProject';
 export declare const connection: Connection;
 export declare const server: {
-    initialize: (params: Omit<import("@volar/language-server").InitializeParams, "initializationOptions"> & {
-        initializationOptions?: import("@volar/language-server").InitializationOptions | undefined;
-    }, projectProviderFactory: import("@volar/language-server").ServerProjectProviderFactory, _serverOptions: import("@volar/language-server/lib/server").ServerOptions) => Promise<import("@volar/language-server").InitializeResult<any>>;
+    connection: Connection;
+    initializeParams: import("@volar/language-server").VolarInitializeParams;
+    languageServicePlugins: import("@volar/language-server").LanguageServicePlugin<any>[];
+    projects: import("@volar/language-server").ServerProjectProvider;
+    fs: import("@volar/language-server").FileSystem;
+    semanticTokensLegend: import("@volar/language-server").SemanticTokensLegend;
+    pullModelDiagnostics: boolean;
+    documents: import("@volar/language-server").TextDocuments<import("@volar/language-server/node").SnapshotDocument>;
+    workspaceFolders: {
+        clear: () => void;
+        values: () => IterableIterator<boolean>;
+        uriKeys: () => IterableIterator<string>;
+        uriDelete: (_uri: string) => boolean;
+        uriGet: (_uri: string) => boolean | undefined;
+        uriHas: (_uri: string) => boolean;
+        uriSet: (_uri: string, item: boolean) => void;
+        pathDelete: (path: string) => boolean;
+        pathGet: (path: string) => boolean | undefined;
+        pathHas: (path: string) => boolean | undefined;
+        pathSet: (path: string, item: boolean) => void;
+    };
+    initialize: (initializeParams: import("@volar/language-server").VolarInitializeParams, languageServicePlugins: import("@volar/language-server").LanguageServicePlugin<any>[], projects: import("@volar/language-server").ServerProjectProvider, options?: {
+        semanticTokensLegend?: import("@volar/language-server").SemanticTokensLegend | undefined;
+        pullModelDiagnostics?: boolean | undefined;
+    } | undefined) => import("@volar/language-server").InitializeResult<any>;
     initialized: () => void;
-    shutdown: () => void;
-    readonly projects: import("@volar/language-server").ServerProjectProvider;
-    readonly env: import("@volar/language-server").ServerRuntimeEnvironment;
+    shutdown: () => Promise<void>;
+    watchFiles: (patterns: string[]) => void;
+    getConfiguration: <T>(section: string, scopeUri?: string | undefined) => Promise<T | undefined>;
+    onDidChangeConfiguration: (cb: import("@volar/language-server").NotificationHandler<import("@volar/language-server").DidChangeConfigurationParams>) => {
+        dispose(): void;
+    };
+    onDidChangeWatchedFiles: (cb: import("@volar/language-server").NotificationHandler<import("@volar/language-server").DidChangeWatchedFilesParams>) => {
+        dispose: () => void;
+    };
+    clearPushDiagnostics: () => void;
+    refresh: (projects: import("@volar/language-server").ServerProjectProvider) => Promise<void>;
 };
+export declare const getLanguagePlugins: GetLanguagePlugin;

package/node.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.server = exports.connection = void 0;
+exports.getLanguagePlugins = exports.server = exports.connection = void 0;
 const node_1 = require("@volar/language-server/node");
 const language_core_1 = require("@vue/language-core");
 const language_service_1 = require("@vue/language-service");
@@ -8,80 +8,69 @@ const tsPluginClient = require("@vue/typescript-plugin/lib/client");
 const utils_1 = require("@vue/typescript-plugin/lib/utils");
 const hybridModeProject_1 = require("./lib/hybridModeProject");
 const protocol_1 = require("./lib/protocol");
-exports.connection = (0, node_1.createConnection)();
-exports.server = (0, node_1.createServer)(exports.connection);
-const envToVueOptions = new WeakMap();
 let tsdk;
+let hybridMode;
 let getTsPluginClient;
+const envToVueOptions = new WeakMap();
+const watchedExtensions = new Set();
+exports.connection = (0, node_1.createConnection)();
+exports.server = (0, node_1.createServer)(exports.connection);
+const getLanguagePlugins = async (serviceEnv, configFileName, host, sys) => {
+    const commandLine = await parseCommandLine();
+    const vueOptions = commandLine?.vueOptions ?? (0, language_core_1.resolveVueCompilerOptions)({});
+    const vueLanguagePlugin = (0, language_core_1.createVueLanguagePlugin)(tsdk.typescript, serviceEnv.typescript.uriToFileName, sys?.useCaseSensitiveFileNames ?? false, () => host?.getProjectVersion?.() ?? '', () => host?.getScriptFileNames() ?? [], commandLine?.options ?? {}, vueOptions);
+    if (!hybridMode) {
+        const extensions = [
+            'js', 'cjs', 'mjs', 'ts', 'cts', 'mts', 'jsx', 'tsx', 'json',
+            ...vueOptions.extensions.map(ext => ext.slice(1)),
+            ...vueOptions.vitePressExtensions.map(ext => ext.slice(1)),
+            ...vueOptions.petiteVueExtensions.map(ext => ext.slice(1)),
+        ];
+        const newExtensions = extensions.filter(ext => !watchedExtensions.has(ext));
+        if (newExtensions.length) {
+            for (const ext of newExtensions) {
+                watchedExtensions.add(ext);
+            }
+            exports.server.watchFiles(['**/*.{' + newExtensions.join(',') + '}']);
+        }
+    }
+    envToVueOptions.set(serviceEnv, vueOptions);
+    return [vueLanguagePlugin];
+    async function parseCommandLine() {
+        let commandLine;
+        let sysVersion;
+        if (sys) {
+            let newSysVersion = await sys.sync();
+            while (sysVersion !== newSysVersion) {
+                sysVersion = newSysVersion;
+                if (configFileName) {
+                    commandLine = (0, language_core_1.createParsedCommandLine)(tsdk.typescript, sys, configFileName);
+                }
+                newSysVersion = await sys.sync();
+            }
+        }
+        return commandLine;
+    }
+};
+exports.getLanguagePlugins = getLanguagePlugins;
 exports.connection.listen();
-exports.connection.onInitialize(async (params) => {
+exports.connection.onInitialize(params => {
     const options = params.initializationOptions;
-    const hybridMode = options.vue?.hybridMode ?? true;
-    const vueFileExtensions = ['vue'];
+    hybridMode = options.vue?.hybridMode ?? true;
     tsdk = (0, node_1.loadTsdkByPath)(options.typescript.tsdk, params.locale);
-    if (options.vue?.additionalExtensions) {
-        for (const additionalExtension of options.vue.additionalExtensions) {
-            vueFileExtensions.push(additionalExtension);
-        }
-    }
     if (hybridMode) {
         getTsPluginClient = () => tsPluginClient;
     }
     else {
         getTsPluginClient = (0, language_service_1.createDefaultGetTsPluginClient)(tsdk.typescript, env => envToVueOptions.get(env));
     }
-    const result = await exports.server.initialize(params, hybridMode
-        ? (0, hybridModeProject_1.createHybridModeProjectProviderFactory)(tsdk.typescript.sys)
-        : (0, node_1.createTypeScriptProjectProviderFactory)(tsdk.typescript, tsdk.diagnosticMessages), {
-        watchFileExtensions: ['js', 'cjs', 'mjs', 'ts', 'cts', 'mts', 'jsx', 'tsx', 'json', ...vueFileExtensions],
-        getLanguageId(uri) {
-            if (vueFileExtensions.some(ext => uri.endsWith(`.${ext}`))) {
-                if (uri.endsWith('.html')) {
-                    return 'html';
-                }
-                else if (uri.endsWith('.md')) {
-                    return 'markdown';
-                }
-                else {
-                    return 'vue';
-                }
-            }
-            return (0, language_core_1.resolveCommonLanguageId)(uri);
-        },
-        getServicePlugins() {
-            return (0, language_service_1.createVueServicePlugins)(tsdk.typescript, env => envToVueOptions.get(env), getTsPluginClient, hybridMode);
-        },
-        async getLanguagePlugins(serviceEnv, projectContext) {
-            const commandLine = await parseCommandLine();
-            const vueOptions = commandLine?.vueOptions ?? (0, language_core_1.resolveVueCompilerOptions)({});
-            for (const ext of vueFileExtensions) {
-                if (!vueOptions.extensions.includes(`.${ext}`)) {
-                    vueOptions.extensions.push(`.${ext}`);
-                }
-            }
-            const vueLanguagePlugin = (0, language_core_1.createVueLanguagePlugin)(tsdk.typescript, serviceEnv.typescript.uriToFileName, projectContext.typescript?.sys.useCaseSensitiveFileNames ?? false, () => projectContext.typescript?.host.getProjectVersion?.() ?? '', () => projectContext.typescript?.host.getScriptFileNames() ?? [], commandLine?.options ?? {}, vueOptions);
-            envToVueOptions.set(serviceEnv, vueOptions);
-            return [vueLanguagePlugin];
-            async function parseCommandLine() {
-                let commandLine;
-                if (projectContext.typescript) {
-                    const { sys } = projectContext.typescript;
-                    let sysVersion;
-                    let newSysVersion = await sys.sync();
-                    while (sysVersion !== newSysVersion) {
-                        sysVersion = newSysVersion;
-                        if (projectContext.typescript.configFileName) {
-                            commandLine = (0, language_core_1.createParsedCommandLine)(tsdk.typescript, sys, projectContext.typescript.configFileName);
-                        }
-                        newSysVersion = await sys.sync();
-                    }
-                }
-                return commandLine;
-            }
-        },
+    const result = exports.server.initialize(params, (0, language_service_1.getVueLanguageServicePlugins)(tsdk.typescript, env => envToVueOptions.get(env), getTsPluginClient, hybridMode), hybridMode
+        ? (0, hybridModeProject_1.createHybridModeProjectProviderFactory)(tsdk.typescript.sys, exports.getLanguagePlugins)
+        : (0, node_1.createTypeScriptProjectProvider)(tsdk.typescript, tsdk.diagnosticMessages, (env, ctx) => (0, exports.getLanguagePlugins)(env, ctx.configFileName, ctx.host, ctx.sys)), {
+        pullModelDiagnostics: hybridMode,
     });
     if (hybridMode) {
-        // handle by tsserver + @vue/typescript-plugin
+        // provided by tsserver + @vue/typescript-plugin
         result.capabilities.semanticTokensProvider = undefined;
     }
     return result;
@@ -98,7 +87,7 @@ exports.connection.onRequest(protocol_1.ParseSFCRequest.type, params => {
 exports.connection.onRequest(protocol_1.DetectNameCasingRequest.type, async (params) => {
     const languageService = await getService(params.textDocument.uri);
     if (languageService) {
-        return await (0, language_service_1.detect)(languageService.context, params.textDocument.uri, getTsPluginClient(languageService.context));
+        return await (0, language_service_1.detect)(languageService.context, params.textDocument.uri);
     }
 });
 exports.connection.onRequest(protocol_1.GetConvertTagCasingEditsRequest.type, async (params) => {
@@ -120,6 +109,6 @@ exports.connection.onRequest(protocol_1.GetConnectedNamedPipeServerRequest.type,
     }
 });
 async function getService(uri) {
-    return (await exports.server.projects.getProject(uri)).getLanguageService();
+    return (await exports.server.projects.get.call(exports.server, uri)).getLanguageService();
 }
 //# sourceMappingURL=node.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-server",
-	"version": "2.0.14",
+	"version": "2.0.16",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -15,12 +15,12 @@
 		"directory": "packages/language-server"
 	},
 	"dependencies": {
-		"@volar/language-core": "2.2.0-alpha.10",
-		"@volar/language-server": "2.2.0-alpha.10",
-		"@vue/language-core": "2.0.14",
-		"@vue/language-service": "2.0.14",
-		"@vue/typescript-plugin": "2.0.14",
+		"@volar/language-core": "~2.2.0",
+		"@volar/language-server": "~2.2.0",
+		"@vue/language-core": "2.0.16",
+		"@vue/language-service": "2.0.16",
+		"@vue/typescript-plugin": "2.0.16",
 		"vscode-languageserver-protocol": "^3.17.5"
 	},
-	"gitHead": "ce1412067f88b7f9af03a2d3e04c220b4921c363"
+	"gitHead": "95b78c38cbf75481ebb59e11956b592346f01d92"
 }