npm - @vue/language-server - Versions diffs - 2.0.19 → 2.0.20 - Mend

@vue/language-server 2.0.19 → 2.0.20

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/lib/hybridModeProject.d.ts +16 -7
package/lib/hybridModeProject.js +61 -63
package/lib/types.d.ts +1 -2
package/node.d.ts +12 -23
package/node.js +29 -13
package/package.json +7 -7

package/lib/hybridModeProject.d.ts CHANGED Viewed

@@ -1,8 +1,17 @@
-import type { LanguagePlugin, ProviderResult, ServerProjectProvider, TypeScriptProjectHost } from '@volar/language-server';
-import { Disposable, ServiceEnvironment } from '@vue/language-service';
+import type { LanguagePlugin, LanguageServerProject, ProviderResult } from '@volar/language-server';
+import { Disposable, LanguageServiceEnvironment } from '@vue/language-service';
+import { TypeScriptProjectHost } from '@vue/typescript-plugin/lib/utils';
 import type * as ts from 'typescript';
-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;
+import { URI } from 'vscode-uri';
+export type GetLanguagePlugin<T> = (params: {
+    serviceEnv: LanguageServiceEnvironment;
+    asFileName: (scriptId: T) => string;
+    configFileName?: string;
+    projectHost?: TypeScriptProjectHost;
+    sys?: ts.System & {
+        version: number;
+        sync(): Promise<number>;
+    } & Disposable;
+}) => ProviderResult<LanguagePlugin<URI>[]>;
+export declare function createHybridModeProject(sys: ts.System, getLanguagePlugins: GetLanguagePlugin<URI>): LanguageServerProject;
+export declare function notEmpty<T>(value: T | null | undefined): value is T;

package/lib/hybridModeProject.js CHANGED Viewed

@@ -1,78 +1,81 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createHybridModeProjectProviderFactory = void 0;
+exports.notEmpty = exports.createHybridModeProject = void 0;
 const simpleProject_1 = require("@volar/language-server/lib/project/simpleProject");
-const simpleProjectProvider_1 = require("@volar/language-server/lib/project/simpleProjectProvider");
-const uriMap_1 = require("@volar/language-server/lib/utils/uriMap");
 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 createHybridModeProjectProviderFactory(sys, getLanguagePlugins) {
+function createHybridModeProject(sys, getLanguagePlugins) {
     let initialized = false;
-    const serviceEnvs = (0, uriMap_1.createUriMap)(sys.useCaseSensitiveFileNames);
-    const tsconfigProjects = (0, uriMap_1.createUriMap)(sys.useCaseSensitiveFileNames);
-    const simpleProjects = (0, uriMap_1.createUriMap)(sys.useCaseSensitiveFileNames);
+    let simpleLs;
+    let serviceEnv;
+    let server;
+    const tsconfigProjects = (0, language_service_1.createUriMap)(sys.useCaseSensitiveFileNames);
     return {
-        async get(uri) {
+        setup(_server) {
+            server = _server;
+        },
+        async getLanguageService(uri) {
             if (!initialized) {
                 initialized = true;
-                initialize(this);
-            }
-            const parsedUri = vscode_uri_1.URI.parse(uri);
-            const workspaceFolder = (0, simpleProjectProvider_1.getWorkspaceFolder)(parsedUri, this.workspaceFolders);
-            let serviceEnv = serviceEnvs.get(workspaceFolder);
-            if (!serviceEnv) {
-                serviceEnv = (0, simpleProjectProvider_1.createServiceEnvironment)(this, workspaceFolder);
-                serviceEnvs.set(workspaceFolder, serviceEnv);
+                initialize(server);
             }
-            const fileName = serviceEnv.typescript.uriToFileName(uri);
+            const fileName = asFileName(uri);
             const projectInfo = (await (0, utils_1.searchNamedPipeServerForFile)(fileName))?.projectInfo;
             if (projectInfo?.kind === 1) {
                 const tsconfig = projectInfo.name;
-                const tsconfigUri = vscode_uri_1.URI.parse(serviceEnv.typescript.fileNameToUri(tsconfig));
+                const tsconfigUri = vscode_uri_1.URI.file(tsconfig);
                 if (!tsconfigProjects.has(tsconfigUri)) {
                     tsconfigProjects.set(tsconfigUri, (async () => {
-                        const languagePlugins = await getLanguagePlugins(serviceEnv, tsconfig, undefined, {
-                            ...sys,
-                            version: 0,
-                            async sync() {
-                                return 0;
+                        serviceEnv ??= (0, simpleProject_1.createLanguageServiceEnvironment)(server, [...server.workspaceFolders.keys()]);
+                        const languagePlugins = await getLanguagePlugins({
+                            serviceEnv,
+                            configFileName: tsconfig,
+                            sys: {
+                                ...sys,
+                                version: 0,
+                                async sync() {
+                                    return 0;
+                                },
+                                dispose() { },
                             },
-                            dispose() { },
+                            asFileName,
                         });
-                        return createTSConfigProject(this, serviceEnv, languagePlugins);
+                        return createLs(server, 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);
+                simpleLs ??= (async () => {
+                    serviceEnv ??= (0, simpleProject_1.createLanguageServiceEnvironment)(server, [...server.workspaceFolders.keys()]);
+                    const languagePlugins = await getLanguagePlugins({ serviceEnv, asFileName });
+                    return createLs(server, serviceEnv, languagePlugins);
+                })();
+                return await simpleLs;
             }
         },
-        async all() {
+        async getExistingLanguageServices() {
             return Promise.all([
                 ...tsconfigProjects.values(),
-                ...simpleProjects.values(),
-            ]);
+                simpleLs,
+            ].filter(notEmpty));
         },
         reload() {
-            for (const project of [
+            for (const ls of [
                 ...tsconfigProjects.values(),
-                ...simpleProjects.values(),
+                simpleLs,
             ]) {
-                project.then(p => p.dispose());
+                ls?.then(ls => ls.dispose());
             }
             tsconfigProjects.clear();
-            simpleProjects.clear();
+            simpleLs = undefined;
         },
     };
+    function asFileName(uri) {
+        return uri.fsPath.replace(/\\/g, '/');
+    }
     function initialize(server) {
         server.onDidChangeWatchedFiles(({ changes }) => {
             for (const change of changes) {
@@ -85,31 +88,26 @@ function createHybridModeProjectProviderFactory(sys, getLanguagePlugins) {
             }
         });
     }
-    function createTSConfigProject(server, serviceEnv, languagePlugins) {
-        let languageService;
-        return {
-            getLanguageService,
-            getLanguageServiceDontCreate: () => languageService,
-            dispose() {
-                languageService?.dispose();
-            },
-        };
-        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);
+    function createLs(server, serviceEnv, languagePlugins) {
+        const language = (0, language_core_1.createLanguage)([
+            { getLanguageId: uri => server.documents.get(server.getSyncedDocumentKey(uri) ?? uri.toString())?.languageId },
+            ...languagePlugins,
+        ], (0, language_service_1.createUriMap)(), uri => {
+            const documentKey = server.getSyncedDocumentKey(uri);
+            const document = documentKey ? server.documents.get(documentKey) : undefined;
+            if (document) {
+                language.scripts.set(uri, document.getSnapshot(), document.languageId);
             }
-            return languageService;
-        }
+            else {
+                language.scripts.delete(uri);
+            }
+        });
+        return (0, language_service_1.createLanguageService)(language, server.languageServicePlugins, serviceEnv);
     }
 }
-exports.createHybridModeProjectProviderFactory = createHybridModeProjectProviderFactory;
+exports.createHybridModeProject = createHybridModeProject;
+function notEmpty(value) {
+    return value !== null && value !== undefined;
+}
+exports.notEmpty = notEmpty;
 //# sourceMappingURL=hybridModeProject.js.map

package/lib/types.d.ts CHANGED Viewed

@@ -1,5 +1,4 @@
-import type { InitializationOptions } from '@volar/language-server';
-export type VueInitializationOptions = InitializationOptions & {
+export type VueInitializationOptions = {
     typescript: {
         tsdk: string;
     };

package/node.d.ts CHANGED Viewed

@@ -1,34 +1,23 @@
 import type { Connection } from '@volar/language-server';
+import { URI } from 'vscode-uri';
 import { GetLanguagePlugin } from './lib/hybridModeProject';
 export declare const connection: Connection;
 export declare const server: {
     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;
+    initializeParams: import("@volar/language-server").InitializeParams;
+    initializeResult: import("@volar/language-server").VolarInitializeResult;
+    languageServicePlugins: import("@volar/language-server").LanguageServicePlugin<any>[];
+    project: import("@volar/language-server").LanguageServerProject;
     pullModelDiagnostics: boolean;
     documents: import("@volar/language-server").TextDocuments<import("@volar/language-server/node").SnapshotDocument>;
-    uriConverter: {
-        uriToFileName: (uri: string, parsed?: import("vscode-uri").URI | undefined) => string;
-        fileNameToUri: (fileName: string) => string;
-    };
-    workspaceFolders: {
-        clear: () => void;
-        values: () => IterableIterator<boolean>;
-        keys: () => Generator<import("vscode-uri").URI, void, unknown>;
-        delete: (uri: import("vscode-uri").URI) => boolean;
-        get: (uri: import("vscode-uri").URI) => boolean | undefined;
-        has: (uri: import("vscode-uri").URI) => boolean;
-        set: (uri: import("vscode-uri").URI, item: boolean) => Map<string, boolean>;
-    };
-    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;
+    workspaceFolders: Map<URI, boolean>;
+    getSyncedDocumentKey: (uri: URI) => string | undefined;
+    initialize: (initializeParams: import("@volar/language-server").InitializeParams, project: import("@volar/language-server").LanguageServerProject, languageServicePlugins: import("@volar/language-server").LanguageServicePlugin<any>[], options?: {
         pullModelDiagnostics?: boolean | undefined;
-    } | undefined) => import("@volar/language-server").InitializeResult<any>;
+    } | undefined) => import("@volar/language-server").VolarInitializeResult;
     initialized: () => void;
-    shutdown: () => Promise<void>;
+    shutdown: () => 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>) => {
@@ -38,6 +27,6 @@ export declare const server: {
         dispose: () => void;
     };
     clearPushDiagnostics: () => void;
-    refresh: (projects: import("@volar/language-server").ServerProjectProvider) => Promise<void>;
+    refresh: (projects: import("@volar/language-server").LanguageServerProject) => Promise<void>;
 };
-export declare const getLanguagePlugins: GetLanguagePlugin;
+export declare const getLanguagePlugins: GetLanguagePlugin<URI>;

package/node.js CHANGED Viewed

@@ -6,6 +6,7 @@ const language_core_1 = require("@vue/language-core");
 const language_service_1 = require("@vue/language-service");
 const tsPluginClient = require("@vue/typescript-plugin/lib/client");
 const utils_1 = require("@vue/typescript-plugin/lib/utils");
+const vscode_uri_1 = require("vscode-uri");
 const hybridModeProject_1 = require("./lib/hybridModeProject");
 const protocol_1 = require("./lib/protocol");
 let tsdk;
@@ -15,10 +16,16 @@ 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 getLanguagePlugins = async ({ serviceEnv, configFileName, projectHost, sys, asFileName }) => {
     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);
+    const vueLanguagePlugin = (0, language_core_1.createVueLanguagePlugin)(tsdk.typescript, asFileName, () => projectHost?.getProjectVersion?.() ?? '', fileName => {
+        const fileMap = new language_core_1.FileMap(sys?.useCaseSensitiveFileNames ?? false);
+        for (const vueFileName of projectHost?.getScriptFileNames() ?? []) {
+            fileMap.set(vueFileName, undefined);
+        }
+        return fileMap.has(fileName);
+    }, commandLine?.options ?? {}, vueOptions);
     if (!hybridMode) {
         const extensions = [
             'js', 'cjs', 'mjs', 'ts', 'cts', 'mts', 'jsx', 'tsx', 'json',
@@ -62,11 +69,17 @@ exports.connection.onInitialize(params => {
         getTsPluginClient = () => tsPluginClient;
     }
     else {
-        getTsPluginClient = (0, language_service_1.createDefaultGetTsPluginClient)(tsdk.typescript, env => envToVueOptions.get(env));
+        getTsPluginClient = (0, language_service_1.createDefaultGetTsPluginClient)(tsdk.typescript);
     }
-    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)), {
+    const result = exports.server.initialize(params, hybridMode
+        ? (0, hybridModeProject_1.createHybridModeProject)(tsdk.typescript.sys, exports.getLanguagePlugins)
+        : (0, node_1.createTypeScriptProject)(tsdk.typescript, tsdk.diagnosticMessages, (env, ctx) => (0, exports.getLanguagePlugins)({
+            serviceEnv: env,
+            configFileName: ctx.configFileName,
+            projectHost: ctx.projectHost,
+            sys: ctx.sys,
+            asFileName: ctx.asFileName,
+        })), (0, language_service_1.getVueLanguageServicePlugins)(tsdk.typescript, env => envToVueOptions.get(env), getTsPluginClient, hybridMode), {
         pullModelDiagnostics: hybridMode,
     });
     if (hybridMode) {
@@ -85,21 +98,24 @@ exports.connection.onRequest(protocol_1.ParseSFCRequest.type, params => {
     return (0, language_core_1.parse)(params);
 });
 exports.connection.onRequest(protocol_1.DetectNameCasingRequest.type, async (params) => {
-    const languageService = await getService(params.textDocument.uri);
+    const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+    const languageService = await getService(uri);
     if (languageService) {
-        return await (0, language_service_1.detect)(languageService.context, params.textDocument.uri);
+        return await (0, language_service_1.detect)(languageService.context, uri);
     }
 });
 exports.connection.onRequest(protocol_1.GetConvertTagCasingEditsRequest.type, async (params) => {
-    const languageService = await getService(params.textDocument.uri);
+    const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+    const languageService = await getService(uri);
     if (languageService) {
-        return await (0, language_service_1.convertTagName)(languageService.context, params.textDocument.uri, params.casing, getTsPluginClient(languageService.context));
+        return await (0, language_service_1.convertTagName)(languageService.context, uri, params.casing, getTsPluginClient(languageService.context));
     }
 });
 exports.connection.onRequest(protocol_1.GetConvertAttrCasingEditsRequest.type, async (params) => {
-    const languageService = await getService(params.textDocument.uri);
+    const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+    const languageService = await getService(uri);
     if (languageService) {
-        return await (0, language_service_1.convertAttrName)(languageService.context, params.textDocument.uri, params.casing, getTsPluginClient(languageService.context));
+        return await (0, language_service_1.convertAttrName)(languageService.context, uri, params.casing, getTsPluginClient(languageService.context));
     }
 });
 exports.connection.onRequest(protocol_1.GetConnectedNamedPipeServerRequest.type, async (fileName) => {
@@ -109,6 +125,6 @@ exports.connection.onRequest(protocol_1.GetConnectedNamedPipeServerRequest.type,
     }
 });
 async function getService(uri) {
-    return (await exports.server.projects.get.call(exports.server, uri)).getLanguageService();
+    return (await exports.server.project.getLanguageService(uri));
 }
 //# sourceMappingURL=node.js.map

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-server",
-	"version": "2.0.19",
+	"version": "2.0.20",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -15,13 +15,13 @@
 		"directory": "packages/language-server"
 	},
 	"dependencies": {
-		"@volar/language-core": "~2.2.4",
-		"@volar/language-server": "~2.2.4",
-		"@vue/language-core": "2.0.19",
-		"@vue/language-service": "2.0.19",
-		"@vue/typescript-plugin": "2.0.19",
+		"@volar/language-core": "~2.3.0-alpha.14",
+		"@volar/language-server": "~2.3.0-alpha.14",
+		"@vue/language-core": "2.0.20",
+		"@vue/language-service": "2.0.20",
+		"@vue/typescript-plugin": "2.0.20",
 		"vscode-languageserver-protocol": "^3.17.5",
 		"vscode-uri": "^3.0.8"
 	},
-	"gitHead": "a9fae154ad1efc4359866cfd10251d53e4b0faed"
+	"gitHead": "e1a5d2f136bf60a772c9655f9f5474c7f71a2ff9"
 }