@vue/typescript-plugin 2.0.23-alpha.1 → 2.0.24

package/index.js

@@ -19,7 +19,7 @@ const plugin = (0, createLanguageServicePlugin_1.createLanguageServicePlugin)((t
         languagePlugins: [languagePlugin],
         setup: language => {
             server_1.projects.set(info.project, { info, language, vueOptions });
-            (0, common_1.decorateLanguageServiceForVue)(language, info.languageService, vueOptions, ts, true, fileName => fileName);
+            info.languageService = (0, common_1.proxyLanguageServiceForVue)(ts, language, info.languageService, vueOptions, fileName => fileName);
             (0, server_1.startNamedPipeServer)(ts, info.project.projectKind, info.project.getCurrentDirectory());
             // #3963
             const timer = setInterval(() => {

package/lib/common.d.ts

@@ -1,5 +1,5 @@
-import * as vue from '@vue/language-core';
+import { Language, VueCompilerOptions, VueVirtualCode } from '@vue/language-core';
 import type * as ts from 'typescript';
 import type { RequestContext } from './requests/types';
-export declare function decorateLanguageServiceForVue<T>(language: vue.Language<T>, languageService: ts.LanguageService, vueOptions: vue.VueCompilerOptions, ts: typeof import('typescript'), isTsPlugin: boolean, getScriptId: (fileName: string) => T): void;
-export declare function getComponentSpans(this: Pick<RequestContext, 'typescript' | 'languageService'>, vueCode: vue.VueVirtualCode, template: NonNullable<vue.VueVirtualCode['sfc']['template']>, spanTemplateRange: ts.TextSpan): ts.TextSpan[];
+export declare function proxyLanguageServiceForVue<T>(ts: typeof import('typescript'), language: Language<T>, languageService: ts.LanguageService, vueOptions: VueCompilerOptions, asScriptId: (fileName: string) => T): ts.LanguageService;
+export declare function getComponentSpans(this: Pick<RequestContext, 'typescript' | 'languageService'>, vueCode: VueVirtualCode, template: NonNullable<VueVirtualCode['sfc']['template']>, spanTemplateRange: ts.TextSpan): ts.TextSpan[];

package/lib/common.js

@@ -1,13 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.decorateLanguageServiceForVue = decorateLanguageServiceForVue;
+exports.proxyLanguageServiceForVue = proxyLanguageServiceForVue;
 exports.getComponentSpans = getComponentSpans;
-const vue = require("@vue/language-core");
+const language_core_1 = require("@vue/language-core");
 const shared_1 = require("@vue/shared");
 const componentInfos_1 = require("./requests/componentInfos");
-function decorateLanguageServiceForVue(language, languageService, vueOptions, ts, isTsPlugin, getScriptId) {
-    const { getCompletionsAtPosition, getCompletionEntryDetails, getCodeFixesAtPosition, getEncodedSemanticClassifications, getQuickInfoAtPosition, } = languageService;
-    languageService.getCompletionsAtPosition = (fileName, position, options, formattingSettings) => {
+const windowsPathReg = /\\/g;
+function proxyLanguageServiceForVue(ts, language, languageService, vueOptions, asScriptId) {
+    const proxyCache = new Map();
+    const getProxyMethod = (target, p) => {
+        switch (p) {
+            case 'getCompletionsAtPosition': return getCompletionsAtPosition(vueOptions, target[p]);
+            case 'getCompletionEntryDetails': return getCompletionEntryDetails(language, asScriptId, target[p]);
+            case 'getCodeFixesAtPosition': return getCodeFixesAtPosition(target[p]);
+            case 'getQuickInfoAtPosition': return getQuickInfoAtPosition(ts, target, target[p]);
+            // TS plugin only
+            case 'getEncodedSemanticClassifications': return getEncodedSemanticClassifications(ts, language, target, asScriptId, target[p]);
+        }
+    };
+    return new Proxy(languageService, {
+        get(target, p, receiver) {
+            if (getProxyMethod) {
+                if (!proxyCache.has(p)) {
+                    proxyCache.set(p, getProxyMethod(target, p));
+                }
+                const proxyMethod = proxyCache.get(p);
+                if (proxyMethod) {
+                    return proxyMethod;
+                }
+            }
+            return Reflect.get(target, p, receiver);
+        },
+        set(target, p, value, receiver) {
+            return Reflect.set(target, p, value, receiver);
+        },
+    });
+}
+function getCompletionsAtPosition(vueOptions, getCompletionsAtPosition) {
+    return (filePath, position, options, formattingSettings) => {
+        const fileName = filePath.replace(windowsPathReg, '/');
         const result = getCompletionsAtPosition(fileName, position, options, formattingSettings);
         if (result) {
             // filter __VLS_
@@ -48,7 +79,9 @@ function decorateLanguageServiceForVue(language, languageService, vueOptions, ts
         }
         return result;
     };
-    languageService.getCompletionEntryDetails = (...args) => {
+}
+function getCompletionEntryDetails(language, asScriptId, getCompletionEntryDetails) {
+    return (...args) => {
         const details = getCompletionEntryDetails(...args);
         // modify import statement
         // @ts-expect-error
@@ -67,8 +100,8 @@ function decorateLanguageServiceForVue(language, languageService, vueOptions, ts
         if (args[6]?.__isAutoImport) {
             // @ts-expect-error
             const { fileName } = args[6]?.__isAutoImport;
-            const sourceScript = language.scripts.get(getScriptId(fileName));
-            if (sourceScript?.generated?.root instanceof vue.VueVirtualCode) {
+            const sourceScript = language.scripts.get(asScriptId(fileName));
+            if (sourceScript?.generated?.root instanceof language_core_1.VueVirtualCode) {
                 const sfc = sourceScript.generated.root.getVueSfc();
                 if (!sfc?.descriptor.script && !sfc?.descriptor.scriptSetup) {
                     for (const codeAction of details?.codeActions ?? []) {
@@ -86,13 +119,17 @@ function decorateLanguageServiceForVue(language, languageService, vueOptions, ts
         }
         return details;
     };
-    languageService.getCodeFixesAtPosition = (...args) => {
+}
+function getCodeFixesAtPosition(getCodeFixesAtPosition) {
+    return (...args) => {
         let result = getCodeFixesAtPosition(...args);
         // filter __VLS_
         result = result.filter(entry => entry.description.indexOf('__VLS_') === -1);
         return result;
     };
-    languageService.getQuickInfoAtPosition = (...args) => {
+}
+function getQuickInfoAtPosition(ts, languageService, getQuickInfoAtPosition) {
+    return (...args) => {
         const result = getQuickInfoAtPosition(...args);
         if (result && result.documentation?.length === 1 && result.documentation[0].text.startsWith('__VLS_emit,')) {
             const [_, emitVarName, eventName] = result.documentation[0].text.split(',');
@@ -128,25 +165,26 @@ function decorateLanguageServiceForVue(language, languageService, vueOptions, ts
         }
         return result;
     };
-    if (isTsPlugin) {
-        languageService.getEncodedSemanticClassifications = (fileName, span, format) => {
-            const result = getEncodedSemanticClassifications(fileName, span, format);
-            const file = language.scripts.get(getScriptId(fileName));
-            if (file?.generated?.root instanceof vue.VueVirtualCode) {
-                const { template } = file.generated.root.sfc;
-                if (template) {
-                    for (const componentSpan of getComponentSpans.call({ typescript: ts, languageService }, file.generated.root, template, {
-                        start: span.start - template.startTagEnd,
-                        length: span.length,
-                    })) {
-                        result.spans.push(componentSpan.start + template.startTagEnd, componentSpan.length, 256 // class
-                        );
-                    }
+}
+function getEncodedSemanticClassifications(ts, language, languageService, asScriptId, getEncodedSemanticClassifications) {
+    return (filePath, span, format) => {
+        const fileName = filePath.replace(windowsPathReg, '/');
+        const result = getEncodedSemanticClassifications(fileName, span, format);
+        const file = language.scripts.get(asScriptId(fileName));
+        if (file?.generated?.root instanceof language_core_1.VueVirtualCode) {
+            const { template } = file.generated.root.sfc;
+            if (template) {
+                for (const componentSpan of getComponentSpans.call({ typescript: ts, languageService }, file.generated.root, template, {
+                    start: span.start - template.startTagEnd,
+                    length: span.length,
+                })) {
+                    result.spans.push(componentSpan.start + template.startTagEnd, componentSpan.length, 256 // class
+                    );
                 }
             }
-            return result;
-        };
-    }
+        }
+        return result;
+    };
 }
 function getComponentSpans(vueCode, template, spanTemplateRange) {
     const { typescript: ts, languageService } = this;
@@ -154,10 +192,10 @@ function getComponentSpans(vueCode, template, spanTemplateRange) {
     const validComponentNames = (0, componentInfos_1._getComponentNames)(ts, languageService, vueCode);
     const components = new Set([
         ...validComponentNames,
-        ...validComponentNames.map(vue.hyphenateTag),
+        ...validComponentNames.map(language_core_1.hyphenateTag),
     ]);
     if (template.ast) {
-        for (const node of vue.forEachElementNode(template.ast)) {
+        for (const node of (0, language_core_1.forEachElementNode)(template.ast)) {
             if (node.loc.end.offset <= spanTemplateRange.start || node.loc.start.offset >= (spanTemplateRange.start + spanTemplateRange.length)) {
                 continue;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/typescript-plugin",
-	"version": "2.0.23-alpha.1",
+	"version": "2.0.24",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -12,12 +12,12 @@
 		"directory": "packages/typescript-plugin"
 	},
 	"dependencies": {
-		"@volar/typescript": "~2.4.0-alpha.0",
-		"@vue/language-core": "2.0.23-alpha.1",
+		"@volar/typescript": "~2.4.0-alpha.2",
+		"@vue/language-core": "2.0.24",
 		"@vue/shared": "^3.4.0"
 	},
 	"devDependencies": {
 		"@types/node": "latest"
 	},
-	"gitHead": "70cb34e9d58afd603d50cb5b870116b189f4662b"
+	"gitHead": "bca79db09e413ef29c17b910271c123a7a68806f"
 }