@vue/language-core 2.1.4 → 2.1.6-patch.1

package/lib/codegen/template/index.js

@@ -18,79 +18,89 @@ function* generateTemplate(options) {
     if (options.propsAssignName) {
         ctx.addLocalVariable(options.propsAssignName);
     }
+    ctx.addLocalVariable('$el');
     ctx.addLocalVariable('$refs');
-    yield* generatePreResolveComponents();
+    yield* generatePreResolveComponents(options);
     if (options.template.ast) {
         yield* (0, templateChild_1.generateTemplateChild)(options, ctx, options.template.ast, undefined, undefined, undefined);
     }
     yield* (0, styleScopedClasses_1.generateStyleScopedClasses)(ctx);
     if (!options.hasDefineSlots) {
         yield `var __VLS_slots!:`;
-        yield* generateSlotsType();
+        yield* generateSlotsType(options, ctx);
         yield common_1.endOfLine;
     }
-    yield* generateInheritedAttrs();
     yield* ctx.generateAutoImportCompletion();
-    yield* generateRefs();
+    yield* generateInheritedAttrs(ctx);
+    yield* generateRefs(ctx);
+    yield* generateRootEl(ctx);
     return ctx;
-    function* generateRefs() {
-        yield `const __VLS_refs = {${common_1.newLine}`;
-        for (const [name, [varName, offset]] of options.templateRefNames) {
-            yield* (0, stringLiteralKey_1.generateStringLiteralKey)(name, offset, ctx.codeFeatures.navigationAndCompletion);
-            yield `: ${varName},${common_1.newLine}`;
-        }
-        yield `}${common_1.endOfLine}`;
-        yield `declare var $refs: typeof __VLS_refs${common_1.endOfLine}`;
+}
+function* generateSlotsType(options, ctx) {
+    for (const { expVar, varName } of ctx.dynamicSlots) {
+        ctx.hasSlot = true;
+        yield `Partial<Record<NonNullable<typeof ${expVar}>, (_: typeof ${varName}) => any>> &${common_1.newLine}`;
     }
-    function* generateSlotsType() {
-        for (const { expVar, varName } of ctx.dynamicSlots) {
-            ctx.hasSlot = true;
-            yield `Partial<Record<NonNullable<typeof ${expVar}>, (_: typeof ${varName}) => any>> &${common_1.newLine}`;
+    yield `{${common_1.newLine}`;
+    for (const slot of ctx.slots) {
+        ctx.hasSlot = true;
+        if (slot.name && slot.loc !== undefined) {
+            yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, slot.name, slot.loc, ctx.codeFeatures.withoutHighlightAndCompletion, slot.nodeLoc);
         }
-        yield `{${common_1.newLine}`;
-        for (const slot of ctx.slots) {
-            ctx.hasSlot = true;
-            if (slot.name && slot.loc !== undefined) {
-                yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, slot.name, slot.loc, ctx.codeFeatures.withoutHighlightAndCompletion, slot.nodeLoc);
-            }
-            else {
-                yield* (0, common_1.wrapWith)(slot.tagRange[0], slot.tagRange[1], ctx.codeFeatures.withoutHighlightAndCompletion, `default`);
-            }
-            yield `?(_: typeof ${slot.varName}): any,${common_1.newLine}`;
+        else {
+            yield* (0, common_1.wrapWith)(slot.tagRange[0], slot.tagRange[1], ctx.codeFeatures.withoutHighlightAndCompletion, `default`);
         }
-        yield `}`;
+        yield `?(_: typeof ${slot.varName}): any,${common_1.newLine}`;
     }
-    function* generateInheritedAttrs() {
-        yield 'var __VLS_inheritedAttrs!: {}';
-        for (const varName of ctx.inheritedAttrVars) {
-            yield ` & typeof ${varName}`;
-        }
-        yield common_1.endOfLine;
+    yield `}`;
+}
+function* generateInheritedAttrs(ctx) {
+    yield 'var __VLS_inheritedAttrs!: {}';
+    for (const varName of ctx.inheritedAttrVars) {
+        yield ` & typeof ${varName}`;
     }
-    function* generatePreResolveComponents() {
-        yield `let __VLS_resolvedLocalAndGlobalComponents!: Required<{}`;
-        if (options.template.ast) {
-            const components = new Set();
-            for (const node of forEachElementNode(options.template.ast)) {
-                if (node.tagType === CompilerDOM.ElementTypes.COMPONENT
-                    && node.tag.toLowerCase() !== 'component'
-                    && !node.tag.includes('.') // namespace tag 
-                ) {
-                    if (components.has(node.tag)) {
-                        continue;
-                    }
-                    components.add(node.tag);
-                    yield common_1.newLine;
-                    yield ` & __VLS_WithComponent<'${(0, element_1.getCanonicalComponentName)(node.tag)}', typeof __VLS_localComponents, `;
-                    yield (0, element_1.getPossibleOriginalComponentNames)(node.tag, false)
-                        .map(name => `"${name}"`)
-                        .join(', ');
-                    yield `>`;
+    yield common_1.endOfLine;
+}
+function* generateRefs(ctx) {
+    yield `const __VLS_refs = {${common_1.newLine}`;
+    for (const [name, [varName, offset]] of ctx.templateRefs) {
+        yield* (0, stringLiteralKey_1.generateStringLiteralKey)(name, offset, ctx.codeFeatures.navigationAndCompletion);
+        yield `: ${varName},${common_1.newLine}`;
+    }
+    yield `}${common_1.endOfLine}`;
+    yield `var $refs!: typeof __VLS_refs${common_1.endOfLine}`;
+}
+function* generateRootEl(ctx) {
+    if (ctx.singleRootElType) {
+        yield `var $el!: ${ctx.singleRootElType}${common_1.endOfLine}`;
+    }
+    else {
+        yield `var $el!: any${common_1.endOfLine}`;
+    }
+}
+function* generatePreResolveComponents(options) {
+    yield `let __VLS_resolvedLocalAndGlobalComponents!: Required<{}`;
+    if (options.template.ast) {
+        const components = new Set();
+        for (const node of forEachElementNode(options.template.ast)) {
+            if (node.tagType === CompilerDOM.ElementTypes.COMPONENT
+                && node.tag.toLowerCase() !== 'component'
+                && !node.tag.includes('.') // namespace tag 
+            ) {
+                if (components.has(node.tag)) {
+                    continue;
                 }
+                components.add(node.tag);
+                yield common_1.newLine;
+                yield ` & __VLS_WithComponent<'${(0, element_1.getCanonicalComponentName)(node.tag)}', typeof __VLS_localComponents, `;
+                yield (0, element_1.getPossibleOriginalComponentNames)(node.tag, false)
+                    .map(name => `"${name}"`)
+                    .join(', ');
+                yield `>`;
             }
         }
-        yield `>${common_1.endOfLine}`;
     }
+    yield `>${common_1.endOfLine}`;
 }
 function* forEachElementNode(node) {
     if (node.type === CompilerDOM.NodeTypes.ROOT) {

package/lib/codegen/template/interpolation.d.ts

@@ -3,4 +3,4 @@ import type { Code, VueCodeInformation } from '../../types';
 import type { TemplateCodegenContext } from './context';
 import type { TemplateCodegenOptions } from './index';
 export declare function generateInterpolation(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, _code: string, astHolder: any, start: number | undefined, data: VueCodeInformation | ((offset: number) => VueCodeInformation) | undefined, prefix: string, suffix: string): Generator<Code>;
-export declare function forEachInterpolationSegment(ts: typeof import('typescript'), ctx: TemplateCodegenContext, code: string, offset: number | undefined, ast: ts.SourceFile): Generator<[fragment: string, offset: number | undefined, isJustForErrorMapping?: boolean]>;
+export declare function forEachInterpolationSegment(ts: typeof import('typescript'), destructuredPropNames: Set<string> | undefined, templateRefNames: Set<string> | undefined, ctx: TemplateCodegenContext, code: string, offset: number | undefined, ast: ts.SourceFile): Generator<[fragment: string, offset: number | undefined, type?: 'errorMappingOnly' | 'startText' | 'endText']>;

package/lib/codegen/template/interpolation.js

@@ -9,7 +9,7 @@ function* generateInterpolation(options, ctx, _code, astHolder, start, data, pre
     const code = prefix + _code + suffix;
     const ast = (0, common_1.createTsAst)(options.ts, astHolder, code);
     const vars = [];
-    for (let [section, offset, onlyError] of forEachInterpolationSegment(options.ts, ctx, code, start !== undefined ? start - prefix.length : undefined, ast)) {
+    for (let [section, offset, type] of forEachInterpolationSegment(options.ts, options.destructuredPropNames, options.templateRefNames, ctx, code, start !== undefined ? start - prefix.length : undefined, ast)) {
         if (offset === undefined) {
             yield section;
         }
@@ -26,18 +26,22 @@ function* generateInterpolation(options, ctx, _code, astHolder, start, data, pre
                 section = section.substring(-offset);
                 offset = 0;
             }
-            if (start !== undefined && data !== undefined) {
-                yield [
-                    section,
-                    'template',
-                    start + offset,
-                    onlyError
-                        ? ctx.codeFeatures.verification
-                        : typeof data === 'function' ? data(start + offset) : data,
-                ];
-            }
-            else {
-                yield section;
+            const shouldSkip = section.length === 0 && (type === 'startText' || type === 'endText');
+            if (!shouldSkip) {
+                if (start !== undefined
+                    && data) {
+                    yield [
+                        section,
+                        'template',
+                        start + offset,
+                        type === 'errorMappingOnly'
+                            ? ctx.codeFeatures.verification
+                            : typeof data === 'function' ? data(start + offset) : data,
+                    ];
+                }
+                else {
+                    yield section;
+                }
             }
             yield addSuffix;
         }
@@ -48,7 +52,7 @@ function* generateInterpolation(options, ctx, _code, astHolder, start, data, pre
         }
     }
 }
-function* forEachInterpolationSegment(ts, ctx, code, offset, ast) {
+function* forEachInterpolationSegment(ts, destructuredPropNames, templateRefNames, ctx, code, offset, ast) {
     let ctxVars = [];
     const varCb = (id, isShorthand) => {
         const text = (0, scriptSetupRanges_1.getNodeText)(ts, id, ast);
@@ -65,6 +69,9 @@ function* forEachInterpolationSegment(ts, ctx, code, offset, ast) {
                 isShorthand: isShorthand,
                 offset: (0, scriptSetupRanges_1.getStartEnd)(ts, id, ast).start,
             });
+            if (destructuredPropNames?.has(text)) {
+                return;
+            }
             if (offset !== undefined) {
                 ctx.accessExternalVariable(text, offset + (0, scriptSetupRanges_1.getStartEnd)(ts, id, ast).start);
             }
@@ -80,30 +87,49 @@ function* forEachInterpolationSegment(ts, ctx, code, offset, ast) {
             yield [code.substring(0, ctxVars[0].offset + ctxVars[0].text.length), 0];
             yield [': ', undefined];
         }
-        else {
-            yield [code.substring(0, ctxVars[0].offset), 0];
+        else if (ctxVars[0].offset > 0) {
+            yield [code.substring(0, ctxVars[0].offset), 0, 'startText'];
         }
         for (let i = 0; i < ctxVars.length - 1; i++) {
-            // fix https://github.com/vuejs/language-tools/issues/1205
-            // fix https://github.com/vuejs/language-tools/issues/1264
-            yield ['', ctxVars[i + 1].offset, true];
-            yield ['__VLS_ctx.', undefined];
-            if (ctxVars[i + 1].isShorthand) {
-                yield [code.substring(ctxVars[i].offset, ctxVars[i + 1].offset + ctxVars[i + 1].text.length), ctxVars[i].offset];
+            const curVar = ctxVars[i];
+            const nextVar = ctxVars[i + 1];
+            yield* generateVar(code, destructuredPropNames, templateRefNames, curVar, nextVar);
+            if (nextVar.isShorthand) {
+                yield [code.substring(curVar.offset + curVar.text.length, nextVar.offset + nextVar.text.length), curVar.offset + curVar.text.length];
                 yield [': ', undefined];
             }
             else {
-                yield [code.substring(ctxVars[i].offset, ctxVars[i + 1].offset), ctxVars[i].offset];
+                yield [code.substring(curVar.offset + curVar.text.length, nextVar.offset), curVar.offset + curVar.text.length];
             }
         }
-        yield ['', ctxVars[ctxVars.length - 1].offset, true];
-        yield ['__VLS_ctx.', undefined];
-        yield [code.substring(ctxVars[ctxVars.length - 1].offset), ctxVars[ctxVars.length - 1].offset];
+        const lastVar = ctxVars.at(-1);
+        yield* generateVar(code, destructuredPropNames, templateRefNames, lastVar);
+        if (lastVar.offset + lastVar.text.length < code.length) {
+            yield [code.substring(lastVar.offset + lastVar.text.length), lastVar.offset + lastVar.text.length, 'endText'];
+        }
     }
     else {
         yield [code, 0];
     }
 }
+function* generateVar(code, destructuredPropNames, templateRefNames, curVar, nextVar = curVar) {
+    // fix https://github.com/vuejs/language-tools/issues/1205
+    // fix https://github.com/vuejs/language-tools/issues/1264
+    yield ['', nextVar.offset, 'errorMappingOnly'];
+    const isDestructuredProp = destructuredPropNames?.has(curVar.text) ?? false;
+    const isTemplateRef = templateRefNames?.has(curVar.text) ?? false;
+    if (isTemplateRef) {
+        yield [`__VLS_unref(`, undefined];
+        yield [code.substring(curVar.offset, curVar.offset + curVar.text.length), curVar.offset];
+        yield [`)`, undefined];
+    }
+    else {
+        if (!isDestructuredProp) {
+            yield [`__VLS_ctx.`, undefined];
+        }
+        yield [code.substring(curVar.offset, curVar.offset + curVar.text.length), curVar.offset];
+    }
+}
 function walkIdentifiers(ts, node, ast, cb, ctx, blockVars = [], isRoot = true) {
     if (ts.isIdentifier(node)) {
         cb(node, false);

package/lib/codegen/template/templateChild.js

@@ -40,6 +40,10 @@ function* generateTemplateChild(options, ctx, node, currentComponent, prevNode,
         }
     }
     const shouldInheritRootNodeAttrs = options.inheritAttrs;
+    const cur = node;
+    if (cur.codegenNode?.type === CompilerDOM.NodeTypes.JS_CACHE_EXPRESSION) {
+        cur.codegenNode = cur.codegenNode.value;
+    }
     if (node.type === CompilerDOM.NodeTypes.ROOT) {
         let prev;
         if (shouldInheritRootNodeAttrs && node.children.length === 1 && node.children[0].type === CompilerDOM.NodeTypes.ELEMENT) {

package/lib/parsers/scriptRanges.d.ts

@@ -9,6 +9,7 @@ export declare function parseScriptRanges(ts: typeof import('typescript'), ast:
         argsNode: ts.ObjectLiteralExpression | undefined;
         componentsOption: TextRange | undefined;
         componentsOptionNode: ts.ObjectLiteralExpression | undefined;
+        directivesOption: TextRange | undefined;
         nameOption: TextRange | undefined;
         inheritAttrsOption: string | undefined;
     }) | undefined;

package/lib/parsers/scriptRanges.js

@@ -24,6 +24,7 @@ function parseScriptRanges(ts, ast, hasScriptSetup, withNode) {
             }
             if (obj) {
                 let componentsOptionNode;
+                let directivesOptionNode;
                 let nameOptionNode;
                 let inheritAttrsOption;
                 ts.forEachChild(obj, node => {
@@ -32,10 +33,13 @@ function parseScriptRanges(ts, ast, hasScriptSetup, withNode) {
                         if (name === 'components' && ts.isObjectLiteralExpression(node.initializer)) {
                             componentsOptionNode = node.initializer;
                         }
-                        if (name === 'name') {
+                        else if (name === 'directives' && ts.isObjectLiteralExpression(node.initializer)) {
+                            directivesOptionNode = node.initializer;
+                        }
+                        else if (name === 'name') {
                             nameOptionNode = node.initializer;
                         }
-                        if (name === 'inheritAttrs') {
+                        else if (name === 'inheritAttrs') {
                             inheritAttrsOption = (0, scriptSetupRanges_1.getNodeText)(ts, node.initializer, ast);
                         }
                     }
@@ -47,6 +51,7 @@ function parseScriptRanges(ts, ast, hasScriptSetup, withNode) {
                     argsNode: withNode ? obj : undefined,
                     componentsOption: componentsOptionNode ? _getStartEnd(componentsOptionNode) : undefined,
                     componentsOptionNode: withNode ? componentsOptionNode : undefined,
+                    directivesOption: directivesOptionNode ? _getStartEnd(directivesOptionNode) : undefined,
                     nameOption: nameOptionNode ? _getStartEnd(nameOptionNode) : undefined,
                     inheritAttrsOption,
                 };

package/lib/parsers/scriptSetupRanges.d.ts

@@ -9,7 +9,8 @@ export declare function parseScriptSetupRanges(ts: typeof import('typescript'),
     importComponentNames: Set<string>;
     props: {
         name?: string;
-        destructured?: string[];
+        destructured?: Set<string>;
+        destructuredRest?: string;
         define?: ReturnType<(node: ts.CallExpression) => TextRange & {
             arg?: TextRange;
             typeArg?: TextRange;

package/lib/parsers/scriptSetupRanges.js

@@ -236,7 +236,17 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
             else if (vueCompilerOptions.macros.defineProps.includes(callText)) {
                 if (ts.isVariableDeclaration(parent)) {
                     if (ts.isObjectBindingPattern(parent.name)) {
-                        props.destructured = (0, common_1.collectVars)(ts, parent.name, ast, [], false);
+                        props.destructured = new Set();
+                        const identifiers = (0, common_1.collectIdentifiers)(ts, parent.name, []);
+                        for (const [id, isRest] of identifiers) {
+                            const name = getNodeText(ts, id, ast);
+                            if (isRest) {
+                                props.destructuredRest = name;
+                            }
+                            else {
+                                props.destructured.add(name);
+                            }
+                        }
                     }
                     else {
                         props.name = getNodeText(ts, parent.name, ast);
@@ -296,7 +306,7 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                     }
                 }
             }
-            else if (vueCompilerOptions.macros.templateRef.includes(callText) && node.arguments.length && !node.typeArguments?.length) {
+            else if (vueCompilerOptions.composibles.useTemplateRef.includes(callText) && node.arguments.length && !node.typeArguments?.length) {
                 const define = parseDefineFunction(node);
                 define.arg = _getStartEnd(node.arguments[0]);
                 let name;

package/lib/plugins/vue-sfc-template.js

@@ -5,7 +5,7 @@ const plugin = () => {
     return {
         version: 2.1,
         getEmbeddedCodes(_fileName, sfc) {
-            if (sfc.template) {
+            if (sfc.template?.lang === 'html') {
                 return [{
                         id: 'template',
                         lang: sfc.template.lang,
@@ -14,7 +14,7 @@ const plugin = () => {
             return [];
         },
         resolveEmbeddedCode(_fileName, sfc, embeddedFile) {
-            if (embeddedFile.id === 'template' && sfc.template) {
+            if (embeddedFile.id === 'template' && sfc.template?.lang === 'html') {
                 embeddedFile.content.push([
                     sfc.template.content,
                     sfc.template.name,

package/lib/plugins/vue-tsx.d.ts

@@ -8,6 +8,7 @@ export declare const tsCodegen: WeakMap<Sfc, {
             argsNode: import("typescript").ObjectLiteralExpression | undefined;
             componentsOption: import("../types").TextRange | undefined;
             componentsOptionNode: import("typescript").ObjectLiteralExpression | undefined;
+            directivesOption: import("../types").TextRange | undefined;
             nameOption: import("../types").TextRange | undefined;
             inheritAttrsOption: string | undefined;
         }) | undefined;
@@ -21,7 +22,8 @@ export declare const tsCodegen: WeakMap<Sfc, {
         importComponentNames: Set<string>;
         props: {
             name?: string;
-            destructured?: string[];
+            destructured?: Set<string>;
+            destructuredRest?: string;
             define?: ReturnType<(node: import("typescript").CallExpression) => import("../types").TextRange & {
                 arg?: import("../types").TextRange;
                 typeArg?: import("../types").TextRange;
@@ -143,6 +145,8 @@ export declare const tsCodegen: WeakMap<Sfc, {
         inlayHints: import("../codegen/types").InlayHintInfo[];
         hasSlot: boolean;
         inheritedAttrVars: Set<unknown>;
+        templateRefs: Map<string, [varName: string, offset: number]>;
+        singleRootElType: string | undefined;
         singleRootNode: import("@vue/compiler-dom").ElementNode | undefined;
         accessExternalVariable(name: string, offset?: number): void;
         hasLocalVariable: (name: string) => boolean;

package/lib/plugins/vue-tsx.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tsCodegen = void 0;
 const computeds_1 = require("computeds");
-const path = require("path-browserify");
+const path_browserify_1 = require("path-browserify");
 const script_1 = require("../codegen/script");
 const template_1 = require("../codegen/template");
 const scriptRanges_1 = require("../parsers/scriptRanges");
@@ -10,6 +10,7 @@ const scriptSetupRanges_1 = require("../parsers/scriptSetupRanges");
 exports.tsCodegen = new WeakMap();
 const fileEditTimes = new Map();
 const plugin = ctx => {
+    let appendedGlobalTypes = false;
     return {
         version: 2.1,
         requiredCompilerOptions: [
@@ -38,13 +39,18 @@ const plugin = ctx => {
     };
     function useTsx(fileName, sfc) {
         if (!exports.tsCodegen.has(sfc)) {
-            exports.tsCodegen.set(sfc, createTsx(fileName, sfc, ctx));
+            let appendGlobalTypes = false;
+            if (!ctx.vueCompilerOptions.__setupedGlobalTypes && !appendedGlobalTypes) {
+                appendGlobalTypes = true;
+                appendedGlobalTypes = true;
+            }
+            exports.tsCodegen.set(sfc, createTsx(fileName, sfc, ctx, appendGlobalTypes));
         }
         return exports.tsCodegen.get(sfc);
     }
 };
 exports.default = plugin;
-function createTsx(fileName, _sfc, ctx) {
+function createTsx(fileName, _sfc, ctx, appendGlobalTypes) {
     const ts = ctx.modules.typescript;
     const lang = (0, computeds_1.computed)(() => {
         return !_sfc.script && !_sfc.scriptSetup ? 'ts'
@@ -59,7 +65,7 @@ function createTsx(fileName, _sfc, ctx) {
         ? (0, scriptSetupRanges_1.parseScriptSetupRanges)(ts, _sfc.scriptSetup.ast, ctx.vueCompilerOptions)
         : undefined);
     const generatedTemplate = (0, computeds_1.computed)(() => {
-        if (!_sfc.template) {
+        if (ctx.vueCompilerOptions.skipTemplateCodegen || !_sfc.template) {
             return;
         }
         const codes = [];
@@ -71,7 +77,8 @@ function createTsx(fileName, _sfc, ctx) {
             edited: ctx.vueCompilerOptions.__test || (fileEditTimes.get(fileName) ?? 0) >= 2,
             scriptSetupBindingNames: scriptSetupBindingNames(),
             scriptSetupImportComponentNames: scriptSetupImportComponentNames(),
-            templateRefNames: new Map(),
+            destructuredPropNames: destructuredPropNames(),
+            templateRefNames: templateRefNames(),
             hasDefineSlots: hasDefineSlots(),
             slotsAssignName: slotsAssignName(),
             propsAssignName: propsAssignName(),
@@ -88,7 +95,6 @@ function createTsx(fileName, _sfc, ctx) {
             codes: codes,
         };
     });
-    const hasDefineSlots = (0, computeds_1.computed)(() => !!scriptSetupRanges()?.slots.define);
     const scriptSetupBindingNames = (0, computeds_1.computed)(oldNames => {
         const newNames = new Set();
         const bindings = scriptSetupRanges()?.bindings;
@@ -104,11 +110,32 @@ function createTsx(fileName, _sfc, ctx) {
     });
     const scriptSetupImportComponentNames = (0, computeds_1.computed)(oldNames => {
         const newNames = scriptSetupRanges()?.importComponentNames ?? new Set();
-        if (newNames && oldNames && twoSetsEqual(newNames, oldNames)) {
+        if (oldNames && twoSetsEqual(newNames, oldNames)) {
             return oldNames;
         }
         return newNames;
     });
+    const destructuredPropNames = (0, computeds_1.computed)(oldNames => {
+        const newNames = scriptSetupRanges()?.props.destructured ?? new Set();
+        const rest = scriptSetupRanges()?.props.destructuredRest;
+        if (rest) {
+            newNames.add(rest);
+        }
+        if (oldNames && twoSetsEqual(newNames, oldNames)) {
+            return oldNames;
+        }
+        return newNames;
+    });
+    const templateRefNames = (0, computeds_1.computed)(oldNames => {
+        const newNames = new Set(scriptSetupRanges()?.templateRefs
+            .map(({ name }) => name)
+            .filter(name => name !== undefined));
+        if (oldNames && twoSetsEqual(newNames, oldNames)) {
+            return oldNames;
+        }
+        return newNames;
+    });
+    const hasDefineSlots = (0, computeds_1.computed)(() => !!scriptSetupRanges()?.slots.define);
     const slotsAssignName = (0, computeds_1.computed)(() => scriptSetupRanges()?.slots.name);
     const propsAssignName = (0, computeds_1.computed)(() => scriptSetupRanges()?.props.name);
     const inheritAttrs = (0, computeds_1.computed)(() => {
@@ -118,21 +145,21 @@ function createTsx(fileName, _sfc, ctx) {
     const generatedScript = (0, computeds_1.computed)(() => {
         const codes = [];
         const linkedCodeMappings = [];
-        const _template = generatedTemplate();
         let generatedLength = 0;
         const codegen = (0, script_1.generateScript)({
             ts,
-            fileBaseName: path.basename(fileName),
+            fileBaseName: path_browserify_1.posix.basename(fileName),
             sfc: _sfc,
             lang: lang(),
             scriptRanges: scriptRanges(),
             scriptSetupRanges: scriptSetupRanges(),
-            templateCodegen: _template,
+            templateCodegen: generatedTemplate(),
             compilerOptions: ctx.compilerOptions,
             vueCompilerOptions: ctx.vueCompilerOptions,
             edited: ctx.vueCompilerOptions.__test || (fileEditTimes.get(fileName) ?? 0) >= 2,
             getGeneratedLength: () => generatedLength,
             linkedCodeMappings,
+            appendGlobalTypes,
         });
         fileEditTimes.set(fileName, (fileEditTimes.get(fileName) ?? 0) + 1);
         let current = codegen.next();

package/lib/types.d.ts

@@ -36,16 +36,16 @@ export interface VueCompilerOptions {
         defineModel: string[];
         defineOptions: string[];
         withDefaults: string[];
-        templateRef: string[];
     };
     composibles: {
         useCssModule: string[];
+        useTemplateRef: string[];
     };
     plugins: VueLanguagePlugin[];
     experimentalDefinePropProposal: 'kevinEdition' | 'johnsonEdition' | false;
     experimentalResolveStyleCssClasses: 'scoped' | 'always' | 'never';
     experimentalModelPropName: Record<string, Record<string, boolean | Record<string, string> | Record<string, string>[]>>;
-    __setupedGlobalTypes?: () => boolean;
+    __setupedGlobalTypes?: boolean;
     __test?: boolean;
 }
 export declare const validVersions: readonly [2, 2.1];

package/lib/utils/ts.d.ts

@@ -3,6 +3,12 @@ import type { VueCompilerOptions } from '../types';
 export type ParsedCommandLine = ts.ParsedCommandLine & {
     vueOptions: VueCompilerOptions;
 };
-export declare function createParsedCommandLineByJson(ts: typeof import('typescript'), parseConfigHost: ts.ParseConfigHost, rootDir: string, json: any, configFileName?: string): ParsedCommandLine;
-export declare function createParsedCommandLine(ts: typeof import('typescript'), parseConfigHost: ts.ParseConfigHost, tsConfigPath: string): ParsedCommandLine;
+export declare function createParsedCommandLineByJson(ts: typeof import('typescript'), parseConfigHost: ts.ParseConfigHost & {
+    writeFile?(path: string, data: string): void;
+}, rootDir: string, json: any, configFileName?: string, skipGlobalTypesSetup?: boolean): ParsedCommandLine;
+export declare function createParsedCommandLine(ts: typeof import('typescript'), parseConfigHost: ts.ParseConfigHost, tsConfigPath: string, skipGlobalTypesSetup?: boolean): ParsedCommandLine;
 export declare function resolveVueCompilerOptions(vueOptions: Partial<VueCompilerOptions>): VueCompilerOptions;
+export declare function setupGlobalTypes(rootDir: string, vueOptions: VueCompilerOptions, host: {
+    fileExists(path: string): boolean;
+    writeFile?(path: string, data: string): void;
+}): boolean;