@vue/language-core 3.1.4 → 3.1.6

package/lib/codegen/script/template.js

@@ -1,169 +1,125 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateTemplate = generateTemplate;
-const shared_1 = require("@vue/shared");
 const path = require("path-browserify");
 const codeFeatures_1 = require("../codeFeatures");
-const modules_1 = require("../style/modules");
-const scopedClasses_1 = require("../style/scopedClasses");
-const context_1 = require("../template/context");
-const interpolation_1 = require("../template/interpolation");
-const styleScopedClasses_1 = require("../template/styleScopedClasses");
+const names = require("../names");
 const utils_1 = require("../utils");
 const merge_1 = require("../utils/merge");
 function* generateTemplate(options, ctx) {
-    ctx.generatedTemplate = true;
     yield* generateSelf(options);
+    yield* generateSetupExposed(options, ctx);
     yield* generateTemplateCtx(options, ctx);
     yield* generateTemplateComponents(options);
     yield* generateTemplateDirectives(options);
-    yield* generateTemplateBody(options, ctx);
+    if (options.styleCodegen) {
+        yield* options.styleCodegen.codes;
+    }
+    if (options.templateCodegen) {
+        yield* options.templateCodegen.codes;
+    }
 }
-function* generateSelf(options) {
-    if (options.sfc.script && options.scriptRanges?.componentOptions) {
-        yield `const __VLS_self = (await import('${options.vueCompilerOptions.lib}')).defineComponent(`;
-        const { args } = options.scriptRanges.componentOptions;
-        yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, args.start, args.end, codeFeatures_1.codeFeatures.all);
+function* generateSelf({ script, scriptRanges, vueCompilerOptions, fileName }) {
+    if (script && scriptRanges?.componentOptions) {
+        yield `const ${names.self} = (await import('${vueCompilerOptions.lib}')).defineComponent(`;
+        const { args } = scriptRanges.componentOptions;
+        yield* (0, utils_1.generateSfcBlockSection)(script, args.start, args.end, codeFeatures_1.codeFeatures.all);
         yield `)${utils_1.endOfLine}`;
     }
-    else if (options.sfc.script && options.scriptRanges?.exportDefault) {
-        yield `const __VLS_self = `;
-        const { expression } = options.scriptRanges.exportDefault;
-        yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, expression.start, expression.end, codeFeatures_1.codeFeatures.all);
+    else if (script && scriptRanges?.exportDefault) {
+        yield `const ${names.self} = `;
+        const { expression } = scriptRanges.exportDefault;
+        yield* (0, utils_1.generateSfcBlockSection)(script, expression.start, expression.end, codeFeatures_1.codeFeatures.all);
         yield utils_1.endOfLine;
     }
-    else if (options.sfc.script?.src) {
-        yield `let __VLS_self!: typeof import('./${path.basename(options.fileName)}').default${utils_1.endOfLine}`;
+    else if (script?.src) {
+        yield `let ${names.self}!: typeof import('./${path.basename(fileName)}').default${utils_1.endOfLine}`;
     }
 }
-function* generateTemplateCtx(options, ctx) {
+function* generateTemplateCtx({ vueCompilerOptions, script, scriptRanges, styleCodegen, scriptSetupRanges, fileName }, ctx) {
     const exps = [];
-    if (options.vueCompilerOptions.petiteVueExtensions.some(ext => options.fileName.endsWith(ext))) {
-        exps.push(`globalThis`);
+    const emitTypes = [];
+    const propTypes = [];
+    if (vueCompilerOptions.petiteVueExtensions.some(ext => fileName.endsWith(ext))) {
+        exps.push([`globalThis`]);
     }
-    if (options.sfc.script?.src || options.scriptRanges?.exportDefault) {
-        exps.push(`{} as InstanceType<__VLS_PickNotAny<typeof __VLS_self, new () => {}>>`);
+    if (script?.src || scriptRanges?.exportDefault) {
+        exps.push([`{} as InstanceType<__VLS_PickNotAny<typeof ${names.self}, new () => {}>>`]);
     }
     else {
-        exps.push(`{} as import('${options.vueCompilerOptions.lib}').ComponentPublicInstance`);
+        exps.push([`{} as import('${vueCompilerOptions.lib}').ComponentPublicInstance`]);
     }
-    if (options.sfc.styles.some(style => style.module)) {
-        exps.push(`{} as __VLS_StyleModules`);
+    if (styleCodegen?.generatedTypes.has(names.StyleModules)) {
+        exps.push([`{} as ${names.StyleModules}`]);
     }
-    const emitTypes = [];
-    if (options.scriptSetupRanges?.defineEmits) {
-        const { defineEmits } = options.scriptSetupRanges;
-        emitTypes.push(`typeof ${defineEmits.name ?? `__VLS_emit`}`);
+    if (scriptSetupRanges?.defineEmits) {
+        const { defineEmits } = scriptSetupRanges;
+        emitTypes.push(`typeof ${defineEmits.name ?? names.emit}`);
     }
-    if (options.scriptSetupRanges?.defineModel.length) {
-        emitTypes.push(`typeof __VLS_modelEmit`);
+    if (scriptSetupRanges?.defineModel.length) {
+        emitTypes.push(`typeof ${names.modelEmit}`);
     }
     if (emitTypes.length) {
-        yield `type __VLS_EmitProps = __VLS_EmitsToProps<__VLS_NormalizeEmits<${emitTypes.join(` & `)}>>${utils_1.endOfLine}`;
-        exps.push(`{} as { $emit: ${emitTypes.join(` & `)} }`);
+        yield `type ${names.EmitProps} = __VLS_EmitsToProps<__VLS_NormalizeEmits<${emitTypes.join(` & `)}>>${utils_1.endOfLine}`;
+        exps.push([`{} as { $emit: ${emitTypes.join(` & `)} }`]);
     }
-    const propTypes = [];
-    const { defineProps, withDefaults } = options.scriptSetupRanges ?? {};
-    const props = defineProps?.arg
-        ? `typeof ${defineProps.name ?? `__VLS_props`}`
-        : defineProps?.typeArg
-            ? withDefaults?.arg
-                ? `__VLS_WithDefaultsGlobal<__VLS_Props, typeof __VLS_defaults>`
-                : `__VLS_Props`
-            : undefined;
-    if (props) {
-        propTypes.push(props);
-    }
-    if (options.scriptSetupRanges?.defineModel.length) {
-        propTypes.push(`__VLS_ModelProps`);
+    if (scriptSetupRanges?.defineProps) {
+        propTypes.push(`typeof ${scriptSetupRanges.defineProps.name ?? names.props}`);
+    }
+    if (scriptSetupRanges?.defineModel.length) {
+        propTypes.push(names.ModelProps);
     }
     if (emitTypes.length) {
-        propTypes.push(`__VLS_EmitProps`);
+        propTypes.push(names.EmitProps);
     }
     if (propTypes.length) {
-        yield `type __VLS_InternalProps = ${propTypes.join(` & `)}${utils_1.endOfLine}`;
-        exps.push(`{} as { $props: __VLS_InternalProps }`);
-        exps.push(`{} as __VLS_InternalProps`);
+        yield `type ${names.InternalProps} = ${propTypes.join(` & `)}${utils_1.endOfLine}`;
+        exps.push([`{} as { $props: ${names.InternalProps} }`]);
+        exps.push([`{} as ${names.InternalProps}`]);
     }
-    if (options.scriptSetupRanges && ctx.bindingNames.size) {
-        exps.push(`{} as __VLS_Bindings`);
+    if (ctx.generatedTypes.has(names.SetupExposed)) {
+        exps.push([`{} as ${names.SetupExposed}`]);
     }
-    yield `const __VLS_ctx = `;
+    yield `const ${names.ctx} = `;
     yield* (0, merge_1.generateSpreadMerge)(exps);
     yield utils_1.endOfLine;
 }
 function* generateTemplateComponents(options) {
-    const types = [`typeof __VLS_ctx`];
-    if (options.sfc.script && options.scriptRanges?.componentOptions?.components) {
+    const types = [`typeof ${names.ctx}`];
+    if (options.script && options.scriptRanges?.componentOptions?.components) {
         const { components } = options.scriptRanges.componentOptions;
         yield `const __VLS_componentsOption = `;
-        yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, components.start, components.end, codeFeatures_1.codeFeatures.navigation);
+        yield* (0, utils_1.generateSfcBlockSection)(options.script, components.start, components.end, codeFeatures_1.codeFeatures.navigation);
         yield utils_1.endOfLine;
         types.push(`typeof __VLS_componentsOption`);
     }
     yield `type __VLS_LocalComponents = ${types.join(` & `)}${utils_1.endOfLine}`;
-    yield `let __VLS_components!: __VLS_LocalComponents & __VLS_GlobalComponents${utils_1.endOfLine}`;
+    yield `let ${names.components}!: __VLS_LocalComponents & __VLS_GlobalComponents${utils_1.endOfLine}`;
 }
 function* generateTemplateDirectives(options) {
-    const types = [`typeof __VLS_ctx`];
-    if (options.sfc.script && options.scriptRanges?.componentOptions?.directives) {
+    const types = [`typeof ${names.ctx}`];
+    if (options.script && options.scriptRanges?.componentOptions?.directives) {
         const { directives } = options.scriptRanges.componentOptions;
         yield `const __VLS_directivesOption = `;
-        yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, directives.start, directives.end, codeFeatures_1.codeFeatures.navigation);
+        yield* (0, utils_1.generateSfcBlockSection)(options.script, directives.start, directives.end, codeFeatures_1.codeFeatures.navigation);
         yield utils_1.endOfLine;
         types.push(`__VLS_ResolveDirectives<typeof __VLS_directivesOption>`);
     }
     yield `type __VLS_LocalDirectives = ${types.join(` & `)}${utils_1.endOfLine}`;
-    yield `let __VLS_directives!: __VLS_LocalDirectives & __VLS_GlobalDirectives${utils_1.endOfLine}`;
-}
-function* generateTemplateBody(options, ctx) {
-    const templateCodegenCtx = (0, context_1.createTemplateCodegenContext)({
-        scriptSetupBindingNames: new Set(),
-    });
-    yield* (0, scopedClasses_1.generateStyleScopedClasses)(options, templateCodegenCtx);
-    yield* (0, styleScopedClasses_1.generateStyleScopedClassReferences)(templateCodegenCtx, true);
-    yield* (0, modules_1.generateStyleModules)(options);
-    yield* generateCssVars(options, templateCodegenCtx);
-    yield* generateBindings(options, ctx, templateCodegenCtx);
-    if (options.templateCodegen) {
-        yield* options.templateCodegen.codes;
-    }
-    else {
-        if (!options.scriptSetupRanges?.defineSlots) {
-            yield `type __VLS_Slots = {}${utils_1.endOfLine}`;
-        }
-        yield `type __VLS_InheritedAttrs = {}${utils_1.endOfLine}`;
-        yield `type __VLS_TemplateRefs = {}${utils_1.endOfLine}`;
-        yield `type __VLS_RootEl = any${utils_1.endOfLine}`;
-    }
-}
-function* generateCssVars(options, ctx) {
-    for (const style of options.sfc.styles) {
-        for (const binding of style.bindings) {
-            yield* (0, interpolation_1.generateInterpolation)(options, ctx, style.name, codeFeatures_1.codeFeatures.all, binding.text, binding.offset, `(`, `)`);
-            yield utils_1.endOfLine;
-        }
-    }
+    yield `let ${names.directives}!: __VLS_LocalDirectives & __VLS_GlobalDirectives${utils_1.endOfLine}`;
 }
-function* generateBindings(options, ctx, templateCodegenCtx) {
-    if (!options.sfc.scriptSetup || !ctx.bindingNames.size) {
+function* generateSetupExposed({ setupExposed }, ctx) {
+    if (!setupExposed.size) {
         return;
     }
-    const usageVars = new Set([
-        ...options.sfc.template?.ast?.components.flatMap(c => [(0, shared_1.camelize)(c), (0, shared_1.capitalize)((0, shared_1.camelize)(c))]) ?? [],
-        ...options.templateCodegen?.accessExternalVariables.keys() ?? [],
-        ...templateCodegenCtx.accessExternalVariables.keys(),
-    ]);
-    yield `type __VLS_Bindings = __VLS_ProxyRefs<{${utils_1.newLine}`;
-    for (const varName of ctx.bindingNames) {
-        if (!usageVars.has(varName)) {
-            continue;
-        }
-        const token = Symbol(varName.length);
+    ctx.generatedTypes.add(names.SetupExposed);
+    yield `type ${names.SetupExposed} = __VLS_ProxyRefs<{${utils_1.newLine}`;
+    for (const bindingName of setupExposed) {
+        const token = Symbol(bindingName.length);
         yield ['', undefined, 0, { __linkedToken: token }];
-        yield `${varName}: typeof `;
+        yield `${bindingName}: typeof `;
         yield ['', undefined, 0, { __linkedToken: token }];
-        yield varName;
+        yield bindingName;
         yield utils_1.endOfLine;
     }
     yield `}>${utils_1.endOfLine}`;

package/lib/codegen/style/common.d.ts

@@ -0,0 +1,3 @@
+import type { Code, Sfc } from '../../types';
+export declare function generateClassProperty(source: string, classNameWithDot: string, offset: number, propertyType: string): Generator<Code>;
+export declare function generateStyleImports(style: Sfc['styles'][number]): Generator<Code>;

package/lib/codegen/style/common.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateClassProperty = generateClassProperty;
+exports.generateStyleImports = generateStyleImports;
+const codeFeatures_1 = require("../codeFeatures");
+const utils_1 = require("../utils");
+const boundary_1 = require("../utils/boundary");
+function* generateClassProperty(source, classNameWithDot, offset, propertyType) {
+    yield `${utils_1.newLine} & { `;
+    const token = yield* (0, boundary_1.startBoundary)(source, offset, codeFeatures_1.codeFeatures.navigation);
+    yield `'`;
+    yield [classNameWithDot.slice(1), source, offset + 1, { __combineToken: token }];
+    yield `'`;
+    yield (0, boundary_1.endBoundary)(token, offset + classNameWithDot.length);
+    yield `: ${propertyType}`;
+    yield ` }`;
+}
+function* generateStyleImports(style) {
+    const features = {
+        navigation: true,
+        verification: true,
+    };
+    if (typeof style.src === 'object') {
+        yield `${utils_1.newLine} & typeof import(`;
+        const token = yield* (0, boundary_1.startBoundary)('main', style.src.offset, features);
+        yield `'`;
+        yield [style.src.text, 'main', style.src.offset, { __combineToken: token }];
+        yield `'`;
+        yield (0, boundary_1.endBoundary)(token, style.src.offset + style.src.text.length);
+        yield `).default`;
+    }
+    for (const { text, offset } of style.imports) {
+        yield `${utils_1.newLine} & typeof import('`;
+        yield [
+            text,
+            style.name,
+            offset,
+            features,
+        ];
+        yield `').default`;
+    }
+}
+//# sourceMappingURL=common.js.map

package/lib/codegen/style/index.d.ts

@@ -0,0 +1,63 @@
+import type { Code, Sfc, VueCompilerOptions } from '../../types';
+export interface StyleCodegenOptions {
+    ts: typeof import('typescript');
+    vueCompilerOptions: VueCompilerOptions;
+    styles: Sfc['styles'];
+    setupRefs: Set<string>;
+    setupConsts: Set<string>;
+}
+export { generate as generateStyle };
+declare function generate(options: StyleCodegenOptions): {
+    codes: Code[];
+    generatedTypes: Set<string>;
+    currentInfo: {
+        ignoreError?: boolean;
+        expectError?: {
+            token: number;
+            node: import("@vue/compiler-dom").CommentNode;
+        };
+        generic?: {
+            content: string;
+            offset: number;
+        };
+    };
+    resolveCodeFeatures: (features: import("../../types").VueCodeInformation) => import("../../types").VueCodeInformation;
+    inVFor: boolean;
+    slots: {
+        name: string;
+        offset?: number;
+        tagRange: [number, number];
+        nodeLoc: any;
+        propsVar: string;
+    }[];
+    dynamicSlots: {
+        expVar: string;
+        propsVar: string;
+    }[];
+    dollarVars: Set<string>;
+    componentAccessMap: Map<string, Map<string, Set<number>>>;
+    blockConditions: string[];
+    inlayHints: import("../inlayHints").InlayHintInfo[];
+    inheritedAttrVars: Set<string>;
+    templateRefs: Map<string, {
+        typeExp: string;
+        offset: number;
+    }[]>;
+    currentComponent: {
+        get ctxVar(): string;
+        get propsVar(): string;
+    } | undefined;
+    singleRootElTypes: Set<string>;
+    singleRootNodes: Set<import("@vue/compiler-dom").ElementNode | null>;
+    addTemplateRef(name: string, typeExp: string, offset: number): void;
+    recordComponentAccess(source: string, name: string, offset?: number): void;
+    scopes: Set<string>[];
+    declare(...varNames: string[]): void;
+    startScope(): () => Generator<Code, any, any>;
+    getInternalVariable(): string;
+    getHoistVariable(originalVar: string): string;
+    generateHoistVariables(): Generator<string, void, unknown>;
+    generateConditionGuards(): Generator<string, void, unknown>;
+    enter(node: import("@vue/compiler-dom").RootNode | import("@vue/compiler-dom").TemplateChildNode | import("@vue/compiler-dom").SimpleExpressionNode): boolean;
+    exit(): Generator<Code>;
+};

package/lib/codegen/style/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateStyle = generate;
+const codeFeatures_1 = require("../codeFeatures");
+const modules_1 = require("../style/modules");
+const scopedClasses_1 = require("../style/scopedClasses");
+const context_1 = require("../template/context");
+const interpolation_1 = require("../template/interpolation");
+const utils_1 = require("../utils");
+function generate(options) {
+    const ctx = (0, context_1.createTemplateCodegenContext)();
+    const codeGenerator = generateWorker(options, ctx);
+    const codes = [];
+    for (const code of codeGenerator) {
+        if (typeof code === 'object') {
+            code[3] = ctx.resolveCodeFeatures(code[3]);
+        }
+        codes.push(code);
+    }
+    return { ...ctx, codes };
+}
+function* generateWorker(options, ctx) {
+    const endScope = ctx.startScope();
+    ctx.declare(...options.setupConsts);
+    yield* (0, scopedClasses_1.generateStyleScopedClasses)(options);
+    yield* (0, modules_1.generateStyleModules)(options, ctx);
+    yield* generateCssVars(options, ctx);
+    yield* endScope();
+}
+function* generateCssVars(options, ctx) {
+    for (const style of options.styles) {
+        for (const binding of style.bindings) {
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, style, codeFeatures_1.codeFeatures.all, binding.text, binding.offset, `(`, `)`);
+            yield utils_1.endOfLine;
+        }
+    }
+}
+//# sourceMappingURL=index.js.map

package/lib/codegen/style/modules.d.ts

@@ -1,3 +1,4 @@
 import type { Code } from '../../types';
-import type { ScriptCodegenOptions } from '../script';
-export declare function generateStyleModules(options: ScriptCodegenOptions): Generator<Code>;
+import type { TemplateCodegenContext } from '../template/context';
+import type { StyleCodegenOptions } from '.';
+export declare function generateStyleModules({ styles, vueCompilerOptions }: StyleCodegenOptions, ctx: TemplateCodegenContext): Generator<Code>;

package/lib/codegen/style/modules.js

@@ -2,16 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateStyleModules = generateStyleModules;
 const codeFeatures_1 = require("../codeFeatures");
+const names = require("../names");
 const utils_1 = require("../utils");
-const classProperty_1 = require("./classProperty");
-const imports_1 = require("./imports");
-function* generateStyleModules(options) {
-    const styles = options.sfc.styles.map((style, i) => [style, i]).filter(([style]) => style.module);
-    if (!styles.length && !options.scriptSetupRanges?.useCssModule.length) {
+const common_1 = require("./common");
+function* generateStyleModules({ styles, vueCompilerOptions }, ctx) {
+    const styleModules = styles.filter(style => style.module);
+    if (!styleModules.length) {
         return;
     }
-    yield `type __VLS_StyleModules = {${utils_1.newLine}`;
-    for (const [style, i] of styles) {
+    ctx.generatedTypes.add(names.StyleModules);
+    yield `type ${names.StyleModules} = {${utils_1.newLine}`;
+    for (const style of styleModules) {
         if (style.module === true) {
             yield `$style`;
         }
@@ -25,15 +26,15 @@ function* generateStyleModules(options) {
             ];
         }
         yield `: `;
-        if (!options.vueCompilerOptions.strictCssModules) {
+        if (!vueCompilerOptions.strictCssModules) {
             yield `Record<string, string> & `;
         }
         yield `__VLS_PrettifyGlobal<{}`;
-        if (options.vueCompilerOptions.resolveStyleImports) {
-            yield* (0, imports_1.generateStyleImports)(style);
+        if (vueCompilerOptions.resolveStyleImports) {
+            yield* (0, common_1.generateStyleImports)(style);
         }
         for (const className of style.classNames) {
-            yield* (0, classProperty_1.generateClassProperty)(i, className.text, className.offset, 'string');
+            yield* (0, common_1.generateClassProperty)(style.name, className.text, className.offset, 'string');
         }
         yield `>${utils_1.endOfLine}`;
     }

package/lib/codegen/style/scopedClasses.d.ts

@@ -1,4 +1,3 @@
 import type { Code } from '../../types';
-import type { ScriptCodegenOptions } from '../script';
-import type { TemplateCodegenContext } from '../template/context';
-export declare function generateStyleScopedClasses(options: ScriptCodegenOptions, ctx: TemplateCodegenContext): Generator<Code>;
+import type { StyleCodegenOptions } from '.';
+export declare function generateStyleScopedClasses({ vueCompilerOptions, styles }: StyleCodegenOptions): Generator<Code>;

package/lib/codegen/style/scopedClasses.js

@@ -1,36 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateStyleScopedClasses = generateStyleScopedClasses;
+const styleScopedClasses_1 = require("../template/styleScopedClasses");
 const utils_1 = require("../utils");
-const classProperty_1 = require("./classProperty");
-const imports_1 = require("./imports");
-function* generateStyleScopedClasses(options, ctx) {
-    const option = options.vueCompilerOptions.resolveStyleClassNames;
-    const styles = options.sfc.styles
-        .map((style, i) => [style, i])
-        .filter(([style]) => option === true || (option === 'scoped' && style.scoped));
-    if (!styles.length) {
+const common_1 = require("./common");
+function* generateStyleScopedClasses({ vueCompilerOptions, styles }) {
+    const { resolveStyleClassNames, resolveStyleImports } = vueCompilerOptions;
+    if (!resolveStyleClassNames) {
         return;
     }
-    const firstClasses = new Set();
+    const scopedStyles = styles.filter(style => resolveStyleClassNames === true || style.scoped);
+    if (!scopedStyles.length) {
+        return;
+    }
+    const visited = new Set();
+    const deferredGenerations = [];
     yield `type __VLS_StyleScopedClasses = {}`;
-    for (const [style, i] of styles) {
-        if (options.vueCompilerOptions.resolveStyleImports) {
-            yield* (0, imports_1.generateStyleImports)(style);
+    for (const style of scopedStyles) {
+        if (resolveStyleImports) {
+            yield* (0, common_1.generateStyleImports)(style);
         }
         for (const className of style.classNames) {
-            if (firstClasses.has(className.text)) {
-                ctx.scopedClasses.push({
-                    source: 'style_' + i,
-                    className: className.text.slice(1),
-                    offset: className.offset + 1,
-                });
-                continue;
+            if (!visited.has(className.text)) {
+                visited.add(className.text);
+                yield* (0, common_1.generateClassProperty)(style.name, className.text, className.offset, 'boolean');
+            }
+            else {
+                deferredGenerations.push((0, styleScopedClasses_1.generateStyleScopedClassReference)(style, className.text.slice(1), className.offset + 1));
             }
-            firstClasses.add(className.text);
-            yield* (0, classProperty_1.generateClassProperty)(i, className.text, className.offset, 'boolean');
         }
     }
     yield utils_1.endOfLine;
+    for (const generate of deferredGenerations) {
+        yield* generate;
+    }
 }
 //# sourceMappingURL=scopedClasses.js.map

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

@@ -1,7 +1,6 @@
 import * as CompilerDOM from '@vue/compiler-dom';
 import type { Code, VueCodeInformation } from '../../types';
 import type { InlayHintInfo } from '../inlayHints';
-import type { TemplateCodegenOptions } from './index';
 export type TemplateCodegenContext = ReturnType<typeof createTemplateCodegenContext>;
 /**
  * Creates and returns a Context object used for generating type-checkable TS code
@@ -100,7 +99,8 @@ export type TemplateCodegenContext = ReturnType<typeof createTemplateCodegenCont
  * an error/diagnostic was encountered for a region of code covered by a `@vue-expect-error` directive,
  * and additionally how we use that to determine whether to propagate diagnostics back upward.
  */
-export declare function createTemplateCodegenContext(options: Pick<TemplateCodegenOptions, 'scriptSetupBindingNames'>, templateAst?: CompilerDOM.RootNode): {
+export declare function createTemplateCodegenContext(): {
+    generatedTypes: Set<string>;
     readonly currentInfo: {
         ignoreError?: boolean;
         expectError?: {
@@ -113,7 +113,6 @@ export declare function createTemplateCodegenContext(options: Pick<TemplateCodeg
         };
     };
     resolveCodeFeatures: (features: VueCodeInformation) => VueCodeInformation;
-    inlineTsAsts: Map<string, import("typescript").SourceFile> | undefined;
     inVFor: boolean;
     slots: {
         name: string;
@@ -127,37 +126,29 @@ export declare function createTemplateCodegenContext(options: Pick<TemplateCodeg
         propsVar: string;
     }[];
     dollarVars: Set<string>;
-    accessExternalVariables: Map<string, Set<number>>;
+    componentAccessMap: Map<string, Map<string, Set<number>>>;
     blockConditions: string[];
-    scopedClasses: {
-        source: string;
-        className: string;
-        offset: number;
-    }[];
-    emptyClassOffsets: number[];
     inlayHints: InlayHintInfo[];
-    bindingAttrLocs: CompilerDOM.SourceLocation[];
     inheritedAttrVars: Set<string>;
     templateRefs: Map<string, {
         typeExp: string;
         offset: number;
     }[]>;
     currentComponent: {
-        ctxVar: string;
-        used: boolean;
+        get ctxVar(): string;
+        get propsVar(): string;
     } | undefined;
-    singleRootElTypes: string[];
+    singleRootElTypes: Set<string>;
     singleRootNodes: Set<CompilerDOM.ElementNode | null>;
     addTemplateRef(name: string, typeExp: string, offset: number): void;
-    accessExternalVariable(name: string, offset?: number): void;
-    hasLocalVariable(name: string): boolean;
-    addLocalVariable(name: string): void;
-    removeLocalVariable(name: string): void;
+    recordComponentAccess(source: string, name: string, offset?: number): void;
+    scopes: Set<string>[];
+    declare(...varNames: string[]): void;
+    startScope(): () => Generator<Code, any, any>;
     getInternalVariable(): string;
     getHoistVariable(originalVar: string): string;
     generateHoistVariables(): Generator<string, void, unknown>;
     generateConditionGuards(): Generator<string, void, unknown>;
-    generateAutoImportCompletion(): Generator<Code>;
     enter(node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode | CompilerDOM.SimpleExpressionNode): boolean;
     exit(): Generator<Code>;
 };