@vue/typescript-plugin 3.1.2 → 3.1.4

package/index.js

@@ -108,12 +108,12 @@ module.exports = (0, createLanguageServicePlugin_1.createLanguageServicePlugin)(
         session.addProtocolHandler('_vue:getElementAttrs', request => {
             const [fileName, tag] = request.arguments;
             const { project } = getProject(fileName);
-            return createResponse((0, getElementAttrs_1.getElementAttrs)(ts, project.getLanguageService().getProgram(), fileName, tag));
+            return createResponse((0, getElementAttrs_1.getElementAttrs)(ts, project.getLanguageService().getProgram(), tag));
         });
         session.addProtocolHandler('_vue:getElementNames', request => {
             const [fileName] = request.arguments;
             const { project } = getProject(fileName);
-            return createResponse((0, getElementNames_1.getElementNames)(ts, project.getLanguageService().getProgram(), fileName));
+            return createResponse((0, getElementNames_1.getElementNames)(ts, project.getLanguageService().getProgram()));
         });
         projectService.logger.info('Vue specific commands are successfully added.');
         function createResponse(res) {

package/lib/common.js

@@ -15,7 +15,7 @@ function createVueLanguageServiceProxy(ts, language, languageService, vueOptions
             case 'getCodeFixesAtPosition':
                 return getCodeFixesAtPosition(target[p]);
             case 'getDefinitionAndBoundSpan':
-                return getDefinitionAndBoundSpan(ts, language, asScriptId, languageService, vueOptions, target[p]);
+                return getDefinitionAndBoundSpan(ts, language, asScriptId, target[p]);
         }
     };
     return new Proxy(languageService, {
@@ -151,84 +151,56 @@ function getCodeFixesAtPosition(getCodeFixesAtPosition) {
         return result;
     };
 }
-function getDefinitionAndBoundSpan(ts, language, asScriptId, languageService, vueOptions, getDefinitionAndBoundSpan) {
+function getDefinitionAndBoundSpan(ts, language, asScriptId, getDefinitionAndBoundSpan) {
     return (fileName, position) => {
         const result = getDefinitionAndBoundSpan(fileName, position);
-        if (!result?.definitions?.length) {
-            return result;
-        }
-        const program = languageService.getProgram();
         const sourceScript = language.scripts.get(asScriptId(fileName));
-        if (!sourceScript?.generated) {
-            return result;
-        }
-        const root = sourceScript.generated.root;
+        const root = sourceScript?.generated?.root;
         if (!(root instanceof language_core_1.VueVirtualCode)) {
             return result;
         }
+        if (!result?.definitions?.length) {
+            const { template } = root.sfc;
+            if (template) {
+                const textSpan = {
+                    start: template.start + 1,
+                    length: 'template'.length,
+                };
+                if (position >= textSpan.start && position <= textSpan.start + textSpan.length) {
+                    return {
+                        textSpan,
+                        definitions: [{
+                                fileName,
+                                textSpan,
+                                kind: ts.ScriptElementKind.scriptElement,
+                                name: fileName,
+                                containerKind: ts.ScriptElementKind.unknown,
+                                containerName: '',
+                            }],
+                    };
+                }
+            }
+            return;
+        }
         if (!root.sfc.template
             || position < root.sfc.template.startTagEnd
             || position > root.sfc.template.endTagStart) {
             return result;
         }
         const definitions = new Set(result.definitions);
-        const skippedDefinitions = [];
         // #5275
         if (result.definitions.length >= 2) {
             for (const definition of result.definitions) {
                 if (root.sfc.content[definition.textSpan.start - 1] === '@'
                     || root.sfc.content.slice(definition.textSpan.start - 5, definition.textSpan.start) === 'v-on:') {
-                    skippedDefinitions.push(definition);
+                    definitions.delete(definition);
                 }
             }
         }
-        for (const definition of result.definitions) {
-            if (vueOptions.extensions.some(ext => definition.fileName.endsWith(ext))) {
-                continue;
-            }
-            const sourceFile = program.getSourceFile(definition.fileName);
-            if (!sourceFile) {
-                continue;
-            }
-            visit(sourceFile, definition, sourceFile);
-        }
-        for (const definition of skippedDefinitions) {
-            definitions.delete(definition);
-        }
         return {
             definitions: [...definitions],
             textSpan: result.textSpan,
         };
-        function visit(node, definition, sourceFile) {
-            if (ts.isPropertySignature(node) && node.type) {
-                proxy(node.name, node.type, definition, sourceFile);
-            }
-            else if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.type && !node.initializer) {
-                proxy(node.name, node.type, definition, sourceFile);
-            }
-            else {
-                ts.forEachChild(node, child => visit(child, definition, sourceFile));
-            }
-        }
-        function proxy(name, type, definition, sourceFile) {
-            const { textSpan, fileName } = definition;
-            const start = name.getStart(sourceFile);
-            const end = name.getEnd();
-            if (start !== textSpan.start || end - start !== textSpan.length) {
-                return;
-            }
-            if (!ts.isIndexedAccessTypeNode(type)) {
-                return;
-            }
-            const pos = type.indexType.getStart(sourceFile);
-            const res = getDefinitionAndBoundSpan(fileName, pos);
-            if (res?.definitions?.length) {
-                for (const definition of res.definitions) {
-                    definitions.add(definition);
-                }
-                skippedDefinitions.push(definition);
-            }
-        }
     };
 }
 //# sourceMappingURL=common.js.map

package/lib/requests/getElementAttrs.d.ts

@@ -1,2 +1,2 @@
 import type * as ts from 'typescript';
-export declare function getElementAttrs(ts: typeof import('typescript'), program: ts.Program, fileName: string, tag: string): string[];
+export declare function getElementAttrs(ts: typeof import('typescript'), program: ts.Program, tag: string): string[];

package/lib/requests/getElementAttrs.js

@@ -1,18 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getElementAttrs = getElementAttrs;
-const utils_1 = require("./utils");
-function getElementAttrs(ts, program, fileName, tag) {
+function getElementAttrs(ts, program, tag) {
     const checker = program.getTypeChecker();
-    const elements = (0, utils_1.getVariableType)(ts, program, fileName, '__VLS_elements');
+    const elements = checker.resolveName('__VLS_intrinsics', undefined, ts.SymbolFlags.Variable, false);
     if (!elements) {
         return [];
     }
-    const elementType = elements.type.getProperty(tag);
+    const elementType = checker.getTypeOfSymbol(elements).getProperty(tag);
     if (!elementType) {
         return [];
     }
-    const attrs = checker.getTypeOfSymbol(elementType).getProperties();
-    return attrs.map(c => c.name);
+    return checker.getTypeOfSymbol(elementType).getProperties().map(c => c.name);
 }
 //# sourceMappingURL=getElementAttrs.js.map

package/lib/requests/getElementNames.d.ts

@@ -1,2 +1,2 @@
 import type * as ts from 'typescript';
-export declare function getElementNames(ts: typeof import('typescript'), program: ts.Program, fileName: string): string[];
+export declare function getElementNames(ts: typeof import('typescript'), program: ts.Program): string[];

package/lib/requests/getElementNames.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getElementNames = getElementNames;
-const utils_1 = require("./utils");
-function getElementNames(ts, program, fileName) {
-    return (0, utils_1.getVariableType)(ts, program, fileName, '__VLS_elements')
-        ?.type
-        .getProperties()
-        .map(c => c.name)
-        ?? [];
+function getElementNames(ts, program) {
+    const checker = program.getTypeChecker();
+    const elements = checker.resolveName('__VLS_intrinsics', undefined, ts.SymbolFlags.Variable, false);
+    if (!elements) {
+        return [];
+    }
+    return checker.getTypeOfSymbol(elements).getProperties().map(c => c.name);
 }
 //# sourceMappingURL=getElementNames.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/typescript-plugin",
-	"version": "3.1.2",
+	"version": "3.1.4",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -14,7 +14,7 @@
 	},
 	"dependencies": {
 		"@volar/typescript": "2.4.23",
-		"@vue/language-core": "3.1.2",
+		"@vue/language-core": "3.1.4",
 		"@vue/shared": "^3.5.0",
 		"path-browserify": "^1.0.1"
 	},
@@ -22,5 +22,5 @@
 		"@types/node": "^22.10.4",
 		"@types/path-browserify": "^1.0.1"
 	},
-	"gitHead": "77db3d889305e8c02740f4c14793bff0156ccdb8"
+	"gitHead": "9670176c727993d16f9224f48406077e20972353"
 }