@vue/language-service 3.0.7-alpha.1 → 3.1.0-alpha.0

package/lib/plugins/vue-destructured-props-hints.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = create;
+exports.findDestructuredProps = findDestructuredProps;
+const language_core_1 = require("@vue/language-core");
+const vscode_uri_1 = require("vscode-uri");
+function create(ts) {
+    return {
+        name: 'vue-destructured-props-hints',
+        capabilities: {
+            inlayHintProvider: {},
+        },
+        create(context) {
+            return {
+                async provideInlayHints(document) {
+                    const enabled = await context.env.getConfiguration?.('vue.inlayHints.destructuredProps') ?? false;
+                    if (!enabled) {
+                        return;
+                    }
+                    const uri = vscode_uri_1.URI.parse(document.uri);
+                    const decoded = context.decodeEmbeddedDocumentUri(uri);
+                    const sourceScript = decoded && context.language.scripts.get(decoded[0]);
+                    const virtualCode = decoded && sourceScript?.generated?.embeddedCodes.get(decoded[1]);
+                    if (!sourceScript?.generated || virtualCode?.id !== 'main') {
+                        return;
+                    }
+                    const root = sourceScript.generated.root;
+                    if (!(root instanceof language_core_1.VueVirtualCode)) {
+                        return;
+                    }
+                    const result = [];
+                    const codegen = language_core_1.tsCodegen.get(root.sfc);
+                    const scriptSetupRanges = codegen?.getScriptSetupRanges();
+                    if (!scriptSetupRanges?.defineProps?.destructured || !root.sfc.scriptSetup?.ast) {
+                        return;
+                    }
+                    for (const [prop, isShorthand] of findDestructuredProps(ts, root.sfc.scriptSetup.ast, scriptSetupRanges.defineProps.destructured.keys())) {
+                        const name = prop.text;
+                        const end = prop.getEnd();
+                        const pos = isShorthand ? end : end - name.length;
+                        const label = isShorthand ? `: props.${name}` : 'props.';
+                        result.push({
+                            label,
+                            position: document.positionAt(root.sfc.scriptSetup.startTagEnd + pos),
+                            kind: 2,
+                        });
+                    }
+                    return result;
+                },
+            };
+        },
+    };
+}
+/**
+ * Refactored from https://github.com/vuejs/core/blob/main/packages/compiler-sfc/src/script/definePropsDestructure.ts
+ */
+function findDestructuredProps(ts, ast, props) {
+    const rootScope = Object.create(null);
+    const scopeStack = [rootScope];
+    let currentScope = rootScope;
+    const excludedIds = new WeakSet();
+    const parentStack = [];
+    for (const prop of props) {
+        rootScope[prop] = true;
+    }
+    function pushScope() {
+        scopeStack.push(currentScope = Object.create(currentScope));
+    }
+    function popScope() {
+        scopeStack.pop();
+        currentScope = scopeStack[scopeStack.length - 1] || null;
+    }
+    function registerLocalBinding(id) {
+        excludedIds.add(id);
+        if (currentScope) {
+            currentScope[id.text] = false;
+        }
+    }
+    const references = [];
+    walkScope(ast, true);
+    walk(ast);
+    return references;
+    function walkScope(node, isRoot = false) {
+        ts.forEachChild(node, stmt => {
+            if (ts.isVariableStatement(stmt)) {
+                for (const decl of stmt.declarationList.declarations) {
+                    walkVariableDeclaration(decl, isRoot);
+                }
+            }
+            else if (ts.isFunctionDeclaration(stmt)
+                || ts.isClassDeclaration(stmt)) {
+                const declare = ts.getModifiers(stmt)?.find(modifier => modifier.kind === ts.SyntaxKind.DeclareKeyword);
+                if (!stmt.name || declare) {
+                    return;
+                }
+                registerLocalBinding(stmt.name);
+            }
+            else if ((ts.isForOfStatement(stmt) || ts.isForInStatement(stmt))
+                && ts.isVariableDeclarationList(stmt.initializer)) {
+                walkVariableDeclaration(stmt.initializer.declarations[0], isRoot);
+            }
+            else if (ts.isLabeledStatement(stmt)
+                && ts.isVariableDeclaration(stmt.statement)) {
+                walkVariableDeclaration(stmt.statement, isRoot);
+            }
+        });
+    }
+    function walkVariableDeclaration(decl, isRoot = false) {
+        const { initializer, name } = decl;
+        const isDefineProps = isRoot
+            && initializer
+            && ts.isCallExpression(initializer)
+            && initializer.expression.getText(ast) === 'defineProps';
+        for (const { id } of (0, language_core_1.collectIdentifiers)(ts, name)) {
+            if (isDefineProps) {
+                excludedIds.add(id);
+            }
+            else {
+                registerLocalBinding(id);
+            }
+        }
+    }
+    function walkFunctionDeclaration(node) {
+        const { name, parameters } = node;
+        if (name && ts.isIdentifier(name)) {
+            registerLocalBinding(name);
+        }
+        for (const p of parameters) {
+            for (const { id } of (0, language_core_1.collectIdentifiers)(ts, p)) {
+                registerLocalBinding(id);
+            }
+        }
+    }
+    function walk(parent) {
+        ts.forEachChild(parent, node => {
+            if (enter(node) ?? true) {
+                walk(node);
+                leave(node);
+            }
+        });
+        function enter(node) {
+            if (parent) {
+                parentStack.push(parent);
+            }
+            if (ts.isTypeLiteralNode(node)
+                || ts.isTypeReferenceNode(node)) {
+                return false;
+            }
+            if (ts.isFunctionLike(node)) {
+                pushScope();
+                walkFunctionDeclaration(node);
+                if ('body' in node) {
+                    walkScope(node.body);
+                }
+                return;
+            }
+            if (ts.isCatchClause(node)) {
+                pushScope();
+                const { variableDeclaration: p } = node;
+                if (p && ts.isIdentifier(p.name)) {
+                    registerLocalBinding(p.name);
+                }
+                walkScope(node.block);
+                return;
+            }
+            if (ts.isBlock(node)
+                && !ts.isFunctionLike(parent)
+                && !ts.isCatchClause(parent)) {
+                pushScope();
+                walkScope(node);
+                return;
+            }
+            if (ts.isIdentifier(node)
+                && isReferencedIdentifier(node, parent)
+                && !excludedIds.has(node)) {
+                const name = node.text;
+                if (currentScope[name]) {
+                    const isShorthand = ts.isShorthandPropertyAssignment(parent);
+                    references.push([node, isShorthand]);
+                }
+            }
+        }
+        function leave(node) {
+            if (parent) {
+                parentStack.pop();
+            }
+            if (ts.isFunctionLike(node)
+                || ts.isCatchClause(node)
+                || (ts.isBlock(node)
+                    && !ts.isFunctionLike(parent)
+                    && !ts.isCatchClause(parent))) {
+                popScope();
+            }
+        }
+    }
+    // TODO: more conditions
+    function isReferencedIdentifier(id, parent) {
+        if (!parent) {
+            return false;
+        }
+        if (id.text === 'arguments') {
+            return false;
+        }
+        if (ts.isExpressionWithTypeArguments(parent)
+            || ts.isInterfaceDeclaration(parent)
+            || ts.isTypeAliasDeclaration(parent)
+            || ts.isPropertySignature(parent)) {
+            return false;
+        }
+        if (ts.isPropertyAccessExpression(parent)
+            || ts.isPropertyAssignment(parent)
+            || ts.isPropertyDeclaration(parent)) {
+            if (parent.name === id) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=vue-destructured-props-hints.js.map

package/lib/plugins/vue-diagnostic-global-types.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/plugins/vue-diagnostic-global-types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=vue-diagnostic-global-types.js.map

package/lib/plugins/vue-document-drop.js

@@ -18,48 +18,50 @@ function create(ts, { getImportPathForFile }) {
         create(context) {
             return {
                 async provideDocumentDropEdits(document, _position, dataTransfer) {
-                    const info = (0, utils_1.getEmbeddedInfo)(context, document, 'template', 'html');
-                    if (!info) {
+                    if (document.languageId !== 'html') {
+                        return;
+                    }
+                    const info = (0, utils_1.resolveEmbeddedCode)(context, document.uri);
+                    if (info?.code.id !== 'template') {
                         return;
                     }
-                    const { sourceScript, root } = info;
                     let importUri;
                     for (const [mimeType, item] of dataTransfer) {
                         if (mimeType === 'text/uri-list') {
                             importUri = item.value;
                         }
                     }
-                    if (!importUri || !root.vueCompilerOptions.extensions.some(ext => importUri.endsWith(ext))) {
+                    if (!importUri || !info.root.vueCompilerOptions.extensions.some(ext => importUri.endsWith(ext))) {
                         return;
                     }
-                    const { sfc } = root;
+                    const { sfc } = info.root;
                     const script = sfc.scriptSetup ?? sfc.script;
                     if (!script) {
                         return;
                     }
-                    const casing = await (0, nameCasing_1.checkCasing)(context, sourceScript.id);
+                    const casing = await (0, nameCasing_1.checkCasing)(context, info.script.id);
                     const baseName = path_browserify_1.posix.basename(importUri);
                     const newName = (0, shared_1.capitalize)((0, shared_1.camelize)(baseName.slice(0, baseName.lastIndexOf('.'))));
                     const additionalEdit = {};
-                    const code = [...(0, language_core_1.forEachEmbeddedCode)(root)].find(code => code.id === (sfc.scriptSetup ? 'scriptsetup_raw' : 'script_raw'));
+                    const code = [...(0, language_core_1.forEachEmbeddedCode)(info.root)].find(code => code.id === (sfc.scriptSetup ? 'scriptsetup_raw' : 'script_raw'));
                     const lastImportNode = (0, vue_extract_file_1.getLastImportNode)(ts, script.ast);
                     const incomingFileName = vscode_uri_1.URI.parse(importUri).fsPath.replace(/\\/g, '/');
                     let importPath;
-                    const serviceScript = sourceScript.generated.languagePlugin.typescript?.getServiceScript(root);
+                    const serviceScript = info.script.generated.languagePlugin.typescript?.getServiceScript(info.root);
                     if (serviceScript) {
-                        const tsDocumentUri = context.encodeEmbeddedDocumentUri(sourceScript.id, serviceScript.code.id);
+                        const tsDocumentUri = context.encodeEmbeddedDocumentUri(info.script.id, serviceScript.code.id);
                         const tsDocument = context.documents.get(tsDocumentUri, serviceScript.code.languageId, serviceScript.code.snapshot);
                         const preferences = await (0, getUserPreferences_1.getUserPreferences)(context, tsDocument);
-                        importPath = (await getImportPathForFile(root.fileName, incomingFileName, preferences) ?? {}).path;
+                        importPath = await getImportPathForFile(info.root.fileName, incomingFileName, preferences);
                     }
                     if (!importPath) {
-                        importPath = path_browserify_1.posix.relative(path_browserify_1.posix.dirname(root.fileName), incomingFileName)
+                        importPath = path_browserify_1.posix.relative(path_browserify_1.posix.dirname(info.root.fileName), incomingFileName)
                             || importUri.slice(importUri.lastIndexOf('/') + 1);
                         if (!importPath.startsWith('./') && !importPath.startsWith('../')) {
                             importPath = './' + importPath;
                         }
                     }
-                    const embeddedDocumentUriStr = context.encodeEmbeddedDocumentUri(sourceScript.id, code.id).toString();
+                    const embeddedDocumentUriStr = context.encodeEmbeddedDocumentUri(info.script.id, code.id).toString();
                     additionalEdit.changes ??= {};
                     additionalEdit.changes[embeddedDocumentUriStr] = [];
                     additionalEdit.changes[embeddedDocumentUriStr].push({

package/lib/plugins/vue-document-highlights.js

@@ -12,12 +12,11 @@ function create({ getDocumentHighlights }) {
         create(context) {
             return {
                 async provideDocumentHighlights(document, position) {
-                    const info = (0, utils_1.getEmbeddedInfo)(context, document, 'main');
-                    if (!info) {
+                    const info = (0, utils_1.resolveEmbeddedCode)(context, document.uri);
+                    if (info?.code.id !== 'main') {
                         return;
                     }
-                    const { root } = info;
-                    const { template } = root.sfc;
+                    const { template } = info.root.sfc;
                     const offset = document.offsetAt(position);
                     if (template?.ast && offset >= template.startTagEnd && offset <= template.endTagStart) {
                         const pos = offset - template.startTagEnd;
@@ -32,9 +31,9 @@ function create({ getDocumentHighlights }) {
                             }
                         }
                     }
-                    const result = await getDocumentHighlights(root.fileName, offset);
+                    const result = await getDocumentHighlights(info.root.fileName, offset);
                     return result
-                        ?.filter(({ fileName }) => fileName === root.fileName)
+                        ?.filter(({ fileName }) => fileName === info.root.fileName)
                         .flatMap(({ highlightSpans }) => highlightSpans)
                         .map(({ textSpan, kind }) => ({
                         range: {

package/lib/plugins/vue-document-links.d.ts

@@ -0,0 +1,2 @@
+import type { LanguageServicePlugin } from '@volar/language-service';
+export declare function create(): LanguageServicePlugin;

package/lib/plugins/vue-document-links.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = create;
+const language_core_1 = require("@vue/language-core");
+const vscode_uri_1 = require("vscode-uri");
+function create() {
+    return {
+        name: 'vue-document-links',
+        capabilities: {
+            documentLinkProvider: {},
+        },
+        create(context) {
+            return {
+                provideDocumentLinks(document) {
+                    const uri = vscode_uri_1.URI.parse(document.uri);
+                    const decoded = context.decodeEmbeddedDocumentUri(uri);
+                    const sourceScript = decoded && context.language.scripts.get(decoded[0]);
+                    const virtualCode = decoded && sourceScript?.generated?.embeddedCodes.get(decoded[1]);
+                    if (!sourceScript?.generated || (virtualCode?.id !== 'template' && virtualCode?.id !== 'scriptsetup_raw')) {
+                        return;
+                    }
+                    const root = sourceScript.generated.root;
+                    if (!(root instanceof language_core_1.VueVirtualCode)) {
+                        return;
+                    }
+                    const { sfc } = root;
+                    const codegen = language_core_1.tsCodegen.get(sfc);
+                    const result = [];
+                    if (virtualCode.id === 'template') {
+                        const scopedClasses = codegen?.getGeneratedTemplate()?.scopedClasses ?? [];
+                        const styleClasses = new Map();
+                        const option = root.vueCompilerOptions.resolveStyleClassNames;
+                        for (let i = 0; i < sfc.styles.length; i++) {
+                            const style = sfc.styles[i];
+                            if (option === true || (option === 'scoped' && style.scoped)) {
+                                for (const className of style.classNames) {
+                                    if (!styleClasses.has(className.text.slice(1))) {
+                                        styleClasses.set(className.text.slice(1), []);
+                                    }
+                                    styleClasses.get(className.text.slice(1)).push({
+                                        index: i,
+                                        style,
+                                        classOffset: className.offset,
+                                    });
+                                }
+                            }
+                        }
+                        for (const { className, offset } of scopedClasses) {
+                            const styles = styleClasses.get(className);
+                            if (styles) {
+                                for (const style of styles) {
+                                    const styleDocumentUri = context.encodeEmbeddedDocumentUri(decoded[0], 'style_' + style.index);
+                                    const styleVirtualCode = sourceScript.generated.embeddedCodes.get('style_' + style.index);
+                                    if (!styleVirtualCode) {
+                                        continue;
+                                    }
+                                    const styleDocument = context.documents.get(styleDocumentUri, styleVirtualCode.languageId, styleVirtualCode.snapshot);
+                                    const start = styleDocument.positionAt(style.classOffset);
+                                    const end = styleDocument.positionAt(style.classOffset + className.length + 1);
+                                    result.push({
+                                        range: {
+                                            start: document.positionAt(offset),
+                                            end: document.positionAt(offset + className.length),
+                                        },
+                                        target: context.encodeEmbeddedDocumentUri(decoded[0], 'style_' + style.index)
+                                            + `#L${start.line + 1},${start.character + 1}-L${end.line + 1},${end.character + 1}`,
+                                    });
+                                }
+                            }
+                        }
+                    }
+                    else if (virtualCode.id === 'scriptsetup_raw') {
+                        if (!sfc.scriptSetup) {
+                            return;
+                        }
+                        const templateVirtualCode = sourceScript.generated.embeddedCodes.get('template');
+                        if (!templateVirtualCode) {
+                            return;
+                        }
+                        const templateDocumentUri = context.encodeEmbeddedDocumentUri(decoded[0], 'template');
+                        const templateDocument = context.documents.get(templateDocumentUri, templateVirtualCode.languageId, templateVirtualCode.snapshot);
+                        const templateRefs = codegen?.getGeneratedTemplate()?.templateRefs;
+                        const useTemplateRefs = codegen?.getScriptSetupRanges()?.useTemplateRef ?? [];
+                        for (const { arg } of useTemplateRefs) {
+                            if (!arg) {
+                                continue;
+                            }
+                            const name = sfc.scriptSetup.content.slice(arg.start + 1, arg.end - 1);
+                            for (const { offset } of templateRefs?.get(name) ?? []) {
+                                const start = templateDocument.positionAt(offset);
+                                const end = templateDocument.positionAt(offset + name.length);
+                                result.push({
+                                    range: {
+                                        start: document.positionAt(arg.start + 1),
+                                        end: document.positionAt(arg.end - 1),
+                                    },
+                                    target: templateDocumentUri
+                                        + `#L${start.line + 1},${start.character + 1}-L${end.line + 1},${end.character + 1}`,
+                                });
+                            }
+                        }
+                    }
+                    return result;
+                },
+            };
+        },
+    };
+}
+//# sourceMappingURL=vue-document-links.js.map

package/lib/plugins/vue-extract-file.js

@@ -27,12 +27,11 @@ function create(ts, { collectExtractProps }) {
                     if (startOffset === endOffset) {
                         return;
                     }
-                    const info = (0, utils_1.getEmbeddedInfo)(context, document, 'template');
-                    if (!info) {
+                    const info = (0, utils_1.resolveEmbeddedCode)(context, document.uri);
+                    if (info?.code.id !== 'template') {
                         return;
                     }
-                    const { root } = info;
-                    const { sfc } = root;
+                    const { sfc } = info.root;
                     const script = sfc.scriptSetup ?? sfc.script;
                     if (!sfc.template || !script) {
                         return;
@@ -56,12 +55,11 @@ function create(ts, { collectExtractProps }) {
                 async resolveCodeAction(codeAction) {
                     const { uri, range, newName } = codeAction.data;
                     const [startOffset, endOffset] = range;
-                    const info = (0, utils_1.getEmbeddedInfo)(context, { uri }, 'template');
-                    if (!info) {
+                    const info = (0, utils_1.resolveEmbeddedCode)(context, uri);
+                    if (info?.code.id !== 'template') {
                         return codeAction;
                     }
-                    const { sourceScript, virtualCode, root } = info;
-                    const { sfc } = root;
+                    const { sfc } = info.root;
                     const script = sfc.scriptSetup ?? sfc.script;
                     if (!sfc.template || !script) {
                         return codeAction;
@@ -70,12 +68,12 @@ function create(ts, { collectExtractProps }) {
                     if (!templateCodeRange) {
                         return codeAction;
                     }
-                    const toExtract = await collectExtractProps(root.fileName, templateCodeRange) ?? [];
+                    const toExtract = await collectExtractProps(info.root.fileName, templateCodeRange) ?? [];
                     const templateInitialIndent = await context.env.getConfiguration('vue.format.template.initialIndent') ?? true;
                     const scriptInitialIndent = await context.env.getConfiguration('vue.format.script.initialIndent')
                         ?? false;
-                    const document = context.documents.get(vscode_uri_1.URI.parse(uri), virtualCode.languageId, virtualCode.snapshot);
-                    const sfcDocument = context.documents.get(sourceScript.id, sourceScript.languageId, sourceScript.snapshot);
+                    const document = context.documents.get(vscode_uri_1.URI.parse(uri), info.code.languageId, info.code.snapshot);
+                    const sfcDocument = context.documents.get(info.script.id, info.script.languageId, info.script.snapshot);
                     const newUri = sfcDocument.uri.slice(0, sfcDocument.uri.lastIndexOf('/') + 1) + `${newName}.vue`;
                     const lastImportNode = getLastImportNode(ts, script.ast);
                     let newFileTags = [];
@@ -136,7 +134,7 @@ function create(ts, { collectExtractProps }) {
                                 // editing vue sfc
                                 {
                                     textDocument: {
-                                        uri: sourceScript.id.toString(),
+                                        uri: info.script.id.toString(),
                                         version: null,
                                     },
                                     edits: sfcEdits,
@@ -261,7 +259,7 @@ function createAddComponentToOptionEdit(ts, sfc, ast, componentName) {
             newText: unescape(printText.replace(unicodeReg, '%u')),
         };
     }
-    else if (exportDefault.args && exportDefault.argsNode) {
+    else {
         const newNode = {
             ...exportDefault.argsNode,
             properties: [

package/lib/plugins/vue-global-types-error.js

@@ -14,16 +14,15 @@ function create() {
         create(context) {
             return {
                 provideDiagnostics(document) {
-                    const info = (0, utils_1.getEmbeddedInfo)(context, document, 'root_tags');
-                    if (!info) {
+                    const info = (0, utils_1.resolveEmbeddedCode)(context, document.uri);
+                    if (info?.code.id !== 'root_tags') {
                         return;
                     }
-                    const { sourceScript, root } = info;
-                    if (sourceScript.id.scheme !== 'file') {
+                    if (info.script.id.scheme !== 'file') {
                         return;
                     }
-                    const { vueCompilerOptions } = root;
-                    const globalTypesPath = vueCompilerOptions.globalTypesPath(root.fileName);
+                    const { vueCompilerOptions } = info.root;
+                    const globalTypesPath = vueCompilerOptions.globalTypesPath(info.root.fileName);
                     if (globalTypesPath) {
                         return;
                     }

package/lib/plugins/vue-inlayhints.js

@@ -13,21 +13,20 @@ function create(ts) {
         create(context) {
             return {
                 async provideInlayHints(document, range) {
-                    const info = (0, utils_1.getEmbeddedInfo)(context, document, 'main');
-                    if (!info) {
+                    const info = (0, utils_1.resolveEmbeddedCode)(context, document.uri);
+                    if (info?.code.id !== 'main') {
                         return;
                     }
-                    const { root } = info;
                     const settings = {};
                     async function getSettingEnabled(key) {
                         return settings[key] ??= await context.env.getConfiguration?.(key) ?? false;
                     }
                     const result = [];
-                    const { sfc } = root;
+                    const { sfc } = info.root;
                     const codegen = language_core_1.tsCodegen.get(sfc);
                     const inlayHints = [
                         ...codegen?.getGeneratedTemplate()?.inlayHints ?? [],
-                        ...codegen?.getGeneratedScript()?.inlayHints ?? [],
+                        ...codegen?.getGeneratedScript().inlayHints ?? [],
                     ];
                     const scriptSetupRanges = codegen?.getScriptSetupRanges();
                     if (scriptSetupRanges?.defineProps?.destructured && sfc.scriptSetup?.ast) {
@@ -96,7 +95,6 @@ function findDestructuredProps(ts, ast, props) {
     const scopeStack = [rootScope];
     let currentScope = rootScope;
     const excludedIds = new WeakSet();
-    const parentStack = [];
     for (const prop of props) {
         rootScope[prop] = true;
     }
@@ -176,9 +174,6 @@ function findDestructuredProps(ts, ast, props) {
             }
         });
         function enter(node) {
-            if (parent) {
-                parentStack.push(parent);
-            }
             if (ts.isTypeLiteralNode(node)
                 || ts.isTypeReferenceNode(node)) {
                 return false;
@@ -218,9 +213,6 @@ function findDestructuredProps(ts, ast, props) {
             }
         }
         function leave(node) {
-            if (parent) {
-                parentStack.pop();
-            }
             if (ts.isFunctionLike(node)
                 || ts.isCatchClause(node)
                 || (ts.isBlock(node)

package/lib/plugins/vue-missing-props-hints.js

@@ -15,11 +15,10 @@ function create({ getComponentNames, getElementNames, getComponentProps }) {
             let intrinsicElementNames;
             return {
                 async provideInlayHints(document, range, cancellationToken) {
-                    const info = (0, utils_1.getEmbeddedInfo)(context, document, 'template');
-                    if (!info) {
+                    const info = (0, utils_1.resolveEmbeddedCode)(context, document.uri);
+                    if (info?.code.id !== 'template') {
                         return;
                     }
-                    const { sourceScript, root } = info;
                     const enabled = await context.env.getConfiguration?.('vue.inlayHints.missingProps') ?? false;
                     if (!enabled) {
                         return;
@@ -29,10 +28,10 @@ function create({ getComponentNames, getElementNames, getComponentProps }) {
                         return;
                     }
                     const result = [];
-                    const casing = await (0, nameCasing_1.checkCasing)(context, sourceScript.id);
-                    const components = await getComponentNames(root.fileName) ?? [];
-                    const componentProps = {};
-                    intrinsicElementNames ??= new Set(await getElementNames(root.fileName) ?? []);
+                    const casing = await (0, nameCasing_1.checkCasing)(context, info.script.id);
+                    const components = await getComponentNames(info.root.fileName) ?? [];
+                    const componentProps = new Map();
+                    intrinsicElementNames ??= new Set(await getElementNames(info.root.fileName) ?? []);
                     let token;
                     let current;
                     while ((token = scanner.scan()) !== html.TokenType.EOS) {
@@ -51,16 +50,16 @@ function create({ getComponentNames, getElementNames, getComponentProps }) {
                             if (tagOffset > document.offsetAt(range.end)) {
                                 break;
                             }
-                            if (!componentProps[checkTag]) {
+                            if (!componentProps.has(checkTag)) {
                                 if (cancellationToken.isCancellationRequested) {
                                     break;
                                 }
-                                componentProps[checkTag] = (await getComponentProps(root.fileName, checkTag) ?? [])
+                                componentProps.set(checkTag, (await getComponentProps(info.root.fileName, checkTag) ?? [])
                                     .filter(prop => prop.required)
-                                    .map(prop => prop.name);
+                                    .map(prop => prop.name));
                             }
                             current = {
-                                unburnedRequiredProps: [...componentProps[checkTag]],
+                                unburnedRequiredProps: [...componentProps.get(checkTag)],
                                 labelOffset: scanner.getTokenOffset() + scanner.getTokenLength(),
                             };
                         }
@@ -86,7 +85,7 @@ function create({ getComponentNames, getElementNames, getComponentProps }) {
                                         attrText = attrText.slice('v-model:'.length);
                                     }
                                     else if (attrText === 'v-model') {
-                                        attrText = root.vueCompilerOptions.target >= 3 ? 'modelValue' : 'value'; // TODO: support for experimentalModelPropName?
+                                        attrText = 'modelValue'; // TODO: support for experimentalModelPropName?
                                     }
                                     else if (attrText.startsWith('v-on:')) {
                                         attrText = 'on-' + (0, language_core_1.hyphenateAttr)(attrText.slice('v-on:'.length));