@vue/language-core 3.1.5 → 3.1.7

package/lib/codegen/script/scriptSetup.js

@@ -1,15 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateScriptSetupImports = generateScriptSetupImports;
-exports.generateScriptSetup = generateScriptSetup;
+exports.generateGeneric = generateGeneric;
+exports.generateSetupFunction = generateSetupFunction;
 const shared_1 = require("@vue/shared");
 const codeFeatures_1 = require("../codeFeatures");
+const names = require("../names");
 const utils_1 = require("../utils");
+const boundary_1 = require("../utils/boundary");
 const camelized_1 = require("../utils/camelized");
-const wrapWith_1 = require("../utils/wrapWith");
+const transform_1 = require("../utils/transform");
 const component_1 = require("./component");
-const index_1 = require("./index");
-const template_1 = require("./template");
 function* generateScriptSetupImports(scriptSetup, scriptSetupRanges) {
     yield [
         scriptSetup.content.slice(0, Math.max(scriptSetupRanges.importSectionEndOffset, scriptSetupRanges.leadingCommentEndOffset)),
@@ -18,363 +19,288 @@ function* generateScriptSetupImports(scriptSetup, scriptSetupRanges) {
         codeFeatures_1.codeFeatures.all,
     ];
 }
-function* generateScriptSetup(options, ctx, scriptSetup, scriptSetupRanges) {
-    if (scriptSetup.generic) {
-        yield* (0, index_1.generateConstExport)(options, scriptSetup);
-        yield `(`;
-        if (typeof scriptSetup.generic === 'object') {
-            yield `<`;
-            yield [
-                scriptSetup.generic.text,
-                'main',
-                scriptSetup.generic.offset,
-                codeFeatures_1.codeFeatures.all,
-            ];
-            if (!scriptSetup.generic.text.endsWith(`,`)) {
-                yield `,`;
-            }
-            yield `>`;
-        }
-        yield `(${utils_1.newLine}`
-            + `	__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>['props'],${utils_1.newLine}`
-            + `	__VLS_ctx?: ${ctx.localTypes.PrettifyLocal}<Pick<NonNullable<Awaited<typeof __VLS_setup>>, 'attrs' | 'emit' | 'slots'>>,${utils_1.newLine}` // use __VLS_Prettify for less dts code
-            + `	__VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>['expose'],${utils_1.newLine}`
-            + `	__VLS_setup = (async () => {${utils_1.newLine}`;
-        yield* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, undefined);
-        const propTypes = [];
-        if (ctx.generatedPropsType) {
-            propTypes.push(`__VLS_PublicProps`);
-        }
-        if (scriptSetupRanges.defineProps?.arg) {
-            yield `const __VLS_propsOption = `;
-            yield (0, utils_1.generateSfcBlockSection)(scriptSetup, scriptSetupRanges.defineProps.arg.start, scriptSetupRanges.defineProps.arg.end, codeFeatures_1.codeFeatures.navigation);
-            yield utils_1.endOfLine;
-            propTypes.push(`import('${options.vueCompilerOptions.lib}').${options.vueCompilerOptions.target >= 3.3 ? `ExtractPublicPropTypes` : `ExtractPropTypes`}<typeof __VLS_propsOption>`);
-        }
-        if (scriptSetupRanges.defineEmits || scriptSetupRanges.defineModel.length) {
-            propTypes.push(`__VLS_EmitProps`);
-        }
-        if (options.templateCodegen?.inheritedAttrVars.size) {
-            propTypes.push(`__VLS_InheritedAttrs`);
-        }
-        const emitTypes = [];
-        if (scriptSetupRanges.defineEmits) {
-            emitTypes.push(`typeof ${scriptSetupRanges.defineEmits.name ?? '__VLS_emit'}`);
+function* generateGeneric(options, ctx, scriptSetup, scriptSetupRanges, generic, body) {
+    yield `(`;
+    if (typeof generic === 'object') {
+        yield `<`;
+        yield [generic.text, 'main', generic.offset, codeFeatures_1.codeFeatures.all];
+        if (!generic.text.endsWith(`,`)) {
+            yield `,`;
         }
-        if (scriptSetupRanges.defineModel.length) {
-            emitTypes.push(`typeof __VLS_modelEmit`);
-        }
-        yield `return {} as {${utils_1.newLine}`
-            + `	props: ${propTypes.length ? `${ctx.localTypes.PrettifyLocal}<${propTypes.join(` & `)}> & ` : ``}${options.vueCompilerOptions.target >= 3.4
-                ? `import('${options.vueCompilerOptions.lib}').PublicProps`
-                : options.vueCompilerOptions.target >= 3
-                    ? `import('${options.vueCompilerOptions.lib}').VNodeProps`
-                        + ` & import('${options.vueCompilerOptions.lib}').AllowedComponentProps`
-                        + ` & import('${options.vueCompilerOptions.lib}').ComponentCustomProps`
-                    : `globalThis.JSX.IntrinsicAttributes`} & (typeof globalThis extends { __VLS_PROPS_FALLBACK: infer P } ? P : {})${utils_1.endOfLine}`
-            + `	expose: (exposed: ${scriptSetupRanges.defineExpose
-                ? `import('${options.vueCompilerOptions.lib}').ShallowUnwrapRef<typeof __VLS_exposed>`
-                : `{}`}) => void${utils_1.endOfLine}`
-            + `	attrs: any${utils_1.endOfLine}`
-            + `	slots: __VLS_Slots${utils_1.endOfLine}`
-            + `	emit: ${emitTypes.length ? emitTypes.join(` & `) : `{}`}${utils_1.endOfLine}`
-            + `}${utils_1.endOfLine}`;
-        yield `})(),${utils_1.newLine}`; // __VLS_setup = (async () => {
-        yield `) => ({} as import('${options.vueCompilerOptions.lib}').VNode & { __ctx?: Awaited<typeof __VLS_setup> }))${utils_1.endOfLine}`;
-    }
-    else if (!options.sfc.script) {
-        // no script block, generate script setup code at root
-        yield* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, 'export default');
+        yield `>`;
+    }
+    yield `(${utils_1.newLine}`
+        + `	${names.props}: NonNullable<Awaited<typeof ${names.setup}>>['props'],${utils_1.newLine}`
+        + `	${names.ctx}?: ${ctx.localTypes.PrettifyLocal}<Pick<NonNullable<Awaited<typeof ${names.setup}>>, 'attrs' | 'emit' | 'slots'>>,${utils_1.newLine}` // use __VLS_Prettify for less dts code
+        + `	${names.exposed}?: NonNullable<Awaited<typeof ${names.setup}>>['expose'],${utils_1.newLine}`
+        + `	${names.setup} = (async () => {${utils_1.newLine}`;
+    yield* body;
+    const propTypes = [];
+    const { vueCompilerOptions } = options;
+    if (ctx.generatedTypes.has(names.PublicProps)) {
+        propTypes.push(names.PublicProps);
     }
-    else {
-        yield* (0, index_1.generateConstExport)(options, scriptSetup);
-        yield `await (async () => {${utils_1.newLine}`;
-        yield* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, 'return');
-        yield `})()${utils_1.endOfLine}`;
+    if (scriptSetupRanges.defineProps?.arg) {
+        yield `const __VLS_propsOption = `;
+        yield* (0, utils_1.generateSfcBlockSection)(scriptSetup, scriptSetupRanges.defineProps.arg.start, scriptSetupRanges.defineProps.arg.end, codeFeatures_1.codeFeatures.navigation);
+        yield utils_1.endOfLine;
+        propTypes.push(`import('${vueCompilerOptions.lib}').${vueCompilerOptions.target >= 3.3 ? `ExtractPublicPropTypes` : `ExtractPropTypes`}<typeof __VLS_propsOption>`);
+    }
+    if (scriptSetupRanges.defineEmits || scriptSetupRanges.defineModel.length) {
+        propTypes.push(names.EmitProps);
+    }
+    if (options.templateCodegen?.generatedTypes.has(names.InheritedAttrs)) {
+        propTypes.push(names.InheritedAttrs);
+    }
+    const emitTypes = [];
+    if (scriptSetupRanges.defineEmits) {
+        emitTypes.push(`typeof ${scriptSetupRanges.defineEmits.name ?? names.emit}`);
     }
+    if (scriptSetupRanges.defineModel.length) {
+        emitTypes.push(`typeof ${names.modelEmit}`);
+    }
+    yield `return {} as {${utils_1.newLine}`;
+    yield `	props: ${propTypes.length ? `${ctx.localTypes.PrettifyLocal}<${propTypes.join(` & `)}> & ` : ``}${vueCompilerOptions.target >= 3.4
+        ? `import('${vueCompilerOptions.lib}').PublicProps`
+        : vueCompilerOptions.target >= 3
+            ? `import('${vueCompilerOptions.lib}').VNodeProps`
+                + ` & import('${vueCompilerOptions.lib}').AllowedComponentProps`
+                + ` & import('${vueCompilerOptions.lib}').ComponentCustomProps`
+            : `globalThis.JSX.IntrinsicAttributes`} & (typeof globalThis extends { ${names.PROPS_FALLBACK}: infer P } ? P : {})${utils_1.endOfLine}`;
+    yield `	expose: (exposed: `;
+    yield scriptSetupRanges.defineExpose
+        ? `import('${vueCompilerOptions.lib}').ShallowUnwrapRef<typeof ${names.exposed}>`
+        : `{}`;
+    if (options.vueCompilerOptions.inferComponentDollarRefs
+        && options.templateCodegen?.generatedTypes.has(names.TemplateRefs)) {
+        yield ` & { $refs: ${names.TemplateRefs}; }`;
+    }
+    if (options.vueCompilerOptions.inferComponentDollarEl
+        && options.templateCodegen?.generatedTypes.has(names.RootEl)) {
+        yield ` & { $el: ${names.RootEl}; }`;
+    }
+    yield `) => void${utils_1.endOfLine}`;
+    yield `	attrs: any${utils_1.endOfLine}`;
+    yield `	slots: ${hasSlotsType(options) ? names.Slots : `{}`}${utils_1.endOfLine}`;
+    yield `	emit: ${emitTypes.length ? emitTypes.join(` & `) : `{}`}${utils_1.endOfLine}`;
+    yield `}${utils_1.endOfLine}`;
+    yield `})(),${utils_1.newLine}`; // __VLS_setup = (async () => {
+    yield `) => ({} as import('${vueCompilerOptions.lib}').VNode & { __ctx?: Awaited<typeof ${names.setup}> }))${utils_1.endOfLine}`;
 }
-function* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, syntax) {
-    let setupCodeModifies = [];
+function* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, body, output) {
+    const transforms = [];
     if (scriptSetupRanges.defineProps) {
         const { name, statement, callExp, typeArg } = scriptSetupRanges.defineProps;
-        setupCodeModifies.push(...generateDefineWithType(scriptSetup, statement, scriptSetupRanges.withDefaults?.callExp ?? callExp, typeArg, name, `__VLS_props`, `__VLS_Props`));
+        const _callExp = scriptSetupRanges.withDefaults?.callExp ?? callExp;
+        transforms.push(...generateDefineWithTypeTransforms(scriptSetup, statement, _callExp, typeArg, name, names.props, names.Props));
     }
     if (scriptSetupRanges.defineEmits) {
         const { name, statement, callExp, typeArg } = scriptSetupRanges.defineEmits;
-        setupCodeModifies.push(...generateDefineWithType(scriptSetup, statement, callExp, typeArg, name, `__VLS_emit`, `__VLS_Emit`));
+        transforms.push(...generateDefineWithTypeTransforms(scriptSetup, statement, callExp, typeArg, name, names.emit, names.Emit));
     }
     if (scriptSetupRanges.defineSlots) {
         const { name, statement, callExp, typeArg } = scriptSetupRanges.defineSlots;
-        setupCodeModifies.push(...generateDefineWithType(scriptSetup, statement, callExp, typeArg, name, `__VLS_slots`, `__VLS_Slots`));
+        transforms.push(...generateDefineWithTypeTransforms(scriptSetup, statement, callExp, typeArg, name, names.slots, names.Slots));
     }
     if (scriptSetupRanges.defineExpose) {
         const { callExp, arg, typeArg } = scriptSetupRanges.defineExpose;
         if (typeArg) {
-            setupCodeModifies.push([
-                [
-                    `let __VLS_exposed!: `,
-                    (0, utils_1.generateSfcBlockSection)(scriptSetup, typeArg.start, typeArg.end, codeFeatures_1.codeFeatures.all),
-                    utils_1.endOfLine,
-                ],
-                callExp.start,
-                callExp.start,
-            ], [
-                [`typeof __VLS_exposed`],
-                typeArg.start,
-                typeArg.end,
-            ]);
+            transforms.push((0, transform_1.insert)(callExp.start, function* () {
+                yield `let ${names.exposed}!: `;
+                yield* (0, utils_1.generateSfcBlockSection)(scriptSetup, typeArg.start, typeArg.end, codeFeatures_1.codeFeatures.all);
+                yield utils_1.endOfLine;
+            }), (0, transform_1.replace)(typeArg.start, typeArg.end, function* () {
+                yield `typeof ${names.exposed}`;
+            }));
         }
         else if (arg) {
-            setupCodeModifies.push([
-                [
-                    `const __VLS_exposed = `,
-                    (0, utils_1.generateSfcBlockSection)(scriptSetup, arg.start, arg.end, codeFeatures_1.codeFeatures.all),
-                    utils_1.endOfLine,
-                ],
-                callExp.start,
-                callExp.start,
-            ], [
-                [`__VLS_exposed`],
-                arg.start,
-                arg.end,
-            ]);
+            transforms.push((0, transform_1.insert)(callExp.start, function* () {
+                yield `const ${names.exposed} = `;
+                yield* (0, utils_1.generateSfcBlockSection)(scriptSetup, arg.start, arg.end, codeFeatures_1.codeFeatures.all);
+                yield utils_1.endOfLine;
+            }), (0, transform_1.replace)(arg.start, arg.end, function* () {
+                yield `${names.exposed}`;
+            }));
         }
         else {
-            setupCodeModifies.push([
-                [`const __VLS_exposed = {}${utils_1.endOfLine}`],
-                callExp.start,
-                callExp.start,
-            ]);
+            transforms.push((0, transform_1.insert)(callExp.start, function* () {
+                yield `const ${names.exposed} = {}${utils_1.endOfLine}`;
+            }));
         }
     }
     if (options.vueCompilerOptions.inferTemplateDollarAttrs) {
         for (const { callExp } of scriptSetupRanges.useAttrs) {
-            setupCodeModifies.push([
-                [`(`],
-                callExp.start,
-                callExp.start,
-            ], [
-                [` as typeof __VLS_dollars.$attrs)`],
-                callExp.end,
-                callExp.end,
-            ]);
+            transforms.push((0, transform_1.insert)(callExp.start, function* () {
+                yield `(`;
+            }), (0, transform_1.insert)(callExp.end, function* () {
+                yield ` as typeof ${names.dollars}.$attrs)`;
+            }));
         }
     }
     for (const { callExp, exp, arg } of scriptSetupRanges.useCssModule) {
-        setupCodeModifies.push([
-            [`(`],
-            callExp.start,
-            callExp.start,
-        ], [
-            arg
-                ? [
-                    ` as Omit<__VLS_StyleModules, '$style'>[`,
-                    (0, utils_1.generateSfcBlockSection)(scriptSetup, arg.start, arg.end, codeFeatures_1.codeFeatures.withoutSemantic),
-                    `])`,
-                ]
-                : [
-                    ` as __VLS_StyleModules[`,
-                    ...(0, wrapWith_1.wrapWith)(scriptSetup.name, exp.start, exp.end, codeFeatures_1.codeFeatures.verification, `'$style'`),
-                    `])`,
-                ],
-            callExp.end,
-            callExp.end,
-        ]);
+        transforms.push((0, transform_1.insert)(callExp.start, function* () {
+            yield `(`;
+        }));
+        const type = options.styleCodegen?.generatedTypes.has(names.StyleModules)
+            ? names.StyleModules
+            : `{}`;
         if (arg) {
-            setupCodeModifies.push([
-                [`__VLS_placeholder`],
-                arg.start,
-                arg.end,
-            ]);
+            transforms.push((0, transform_1.insert)(callExp.end, function* () {
+                yield ` as Omit<${type}, '$style'>[`;
+                yield* (0, utils_1.generateSfcBlockSection)(scriptSetup, arg.start, arg.end, codeFeatures_1.codeFeatures.withoutSemantic);
+                yield `])`;
+            }), (0, transform_1.replace)(arg.start, arg.end, function* () {
+                yield names.placeholder;
+            }));
+        }
+        else {
+            transforms.push((0, transform_1.insert)(callExp.end, function* () {
+                yield ` as ${type}[`;
+                const token = yield* (0, boundary_1.startBoundary)(scriptSetup.name, exp.start, codeFeatures_1.codeFeatures.verification);
+                yield `'$style'`;
+                yield (0, boundary_1.endBoundary)(token, exp.end);
+                yield `])`;
+            }));
         }
     }
     if (options.vueCompilerOptions.inferTemplateDollarSlots) {
         for (const { callExp } of scriptSetupRanges.useSlots) {
-            setupCodeModifies.push([
-                [`(`],
-                callExp.start,
-                callExp.start,
-            ], [
-                [` as typeof __VLS_dollars.$slots)`],
-                callExp.end,
-                callExp.end,
-            ]);
+            transforms.push((0, transform_1.insert)(callExp.start, function* () {
+                yield `(`;
+            }), (0, transform_1.insert)(callExp.end, function* () {
+                yield ` as typeof ${names.dollars}.$slots)`;
+            }));
         }
     }
-    const isTs = options.lang !== 'js' && options.lang !== 'jsx';
-    for (const { callExp, exp, arg } of scriptSetupRanges.useTemplateRef) {
-        const templateRefType = arg
-            ? [
-                `__VLS_TemplateRefs[`,
-                (0, utils_1.generateSfcBlockSection)(scriptSetup, arg.start, arg.end, codeFeatures_1.codeFeatures.withoutSemantic),
-                `]`,
-            ]
-            : [`unknown`];
-        if (isTs) {
-            setupCodeModifies.push([
-                [
-                    `<`,
-                    ...templateRefType,
-                    `>`,
-                ],
-                exp.end,
-                exp.end,
-            ]);
-        }
-        else {
-            setupCodeModifies.push([
-                [`(`],
-                callExp.start,
-                callExp.start,
-            ], [
-                [
-                    ` as __VLS_UseTemplateRef<`,
-                    ...templateRefType,
-                    `>)`,
-                ],
-                callExp.end,
-                callExp.end,
-            ]);
-        }
+    for (const { callExp, arg } of scriptSetupRanges.useTemplateRef) {
+        transforms.push((0, transform_1.insert)(callExp.start, function* () {
+            yield `(`;
+        }), (0, transform_1.insert)(callExp.end, function* () {
+            yield ` as __VLS_UseTemplateRef<`;
+            if (arg) {
+                yield names.TemplateRefs;
+                yield `[`;
+                yield* (0, utils_1.generateSfcBlockSection)(scriptSetup, arg.start, arg.end, codeFeatures_1.codeFeatures.withoutSemantic);
+                yield `]`;
+            }
+            else {
+                yield `unknown`;
+            }
+            yield `>)`;
+        }));
         if (arg) {
-            setupCodeModifies.push([
-                [`__VLS_placeholder`],
-                arg.start,
-                arg.end,
-            ]);
+            transforms.push((0, transform_1.replace)(arg.start, arg.end, function* () {
+                yield names.placeholder;
+            }));
         }
     }
-    setupCodeModifies = setupCodeModifies.sort((a, b) => a[1] - b[1]);
-    let nextStart = Math.max(scriptSetupRanges.importSectionEndOffset, scriptSetupRanges.leadingCommentEndOffset);
-    for (const [codes, start, end] of setupCodeModifies) {
-        yield (0, utils_1.generateSfcBlockSection)(scriptSetup, nextStart, start, codeFeatures_1.codeFeatures.all);
-        yield* codes;
-        nextStart = end;
-    }
-    yield (0, utils_1.generateSfcBlockSection)(scriptSetup, nextStart, scriptSetup.content.length, codeFeatures_1.codeFeatures.all);
-    yield* (0, utils_1.generatePartiallyEnding)(scriptSetup.name, scriptSetup.content.length, '#3632/scriptSetup.vue');
-    yield* generateMacros(options, ctx);
-    const hasSlots = !!(scriptSetupRanges.defineSlots
-        || options.templateCodegen?.slots.length
-        || options.templateCodegen?.dynamicSlots.length);
+    yield* (0, transform_1.generateCodeWithTransforms)(Math.max(scriptSetupRanges.importSectionEndOffset, scriptSetupRanges.leadingCommentEndOffset), scriptSetup.content.length, transforms, (start, end) => (0, utils_1.generateSfcBlockSection)(scriptSetup, start, end, codeFeatures_1.codeFeatures.all));
+    yield* generateMacros(options);
     yield* generateModels(scriptSetup, scriptSetupRanges);
-    yield* generatePublicProps(options, ctx, scriptSetup, scriptSetupRanges, hasSlots);
-    yield* (0, template_1.generateTemplate)(options, ctx);
-    if (syntax) {
-        const prefix = syntax === 'return'
-            ? [`return `]
-            : (0, index_1.generateConstExport)(options, scriptSetup);
-        if (hasSlots) {
+    yield* generatePublicProps(options, ctx, scriptSetup, scriptSetupRanges);
+    yield* body;
+    if (output) {
+        if (hasSlotsType(options)) {
             yield `const __VLS_base = `;
             yield* (0, component_1.generateComponent)(options, ctx, scriptSetup, scriptSetupRanges);
             yield utils_1.endOfLine;
-            yield* prefix;
-            yield `{} as ${ctx.localTypes.WithSlots}<typeof __VLS_base, __VLS_Slots>${utils_1.endOfLine}`;
+            yield* output;
+            yield `{} as ${ctx.localTypes.WithSlots}<typeof __VLS_base, ${names.Slots}>${utils_1.endOfLine}`;
         }
         else {
-            yield* prefix;
+            yield* output;
             yield* (0, component_1.generateComponent)(options, ctx, scriptSetup, scriptSetupRanges);
             yield utils_1.endOfLine;
         }
     }
 }
-function* generateMacros(options, ctx) {
+function* generateMacros(options) {
     if (options.vueCompilerOptions.target >= 3.3) {
         yield `// @ts-ignore${utils_1.newLine}`;
         yield `declare const { `;
         for (const macro of Object.keys(options.vueCompilerOptions.macros)) {
-            if (!ctx.bindingNames.has(macro)) {
+            if (!options.setupExposed.has(macro)) {
                 yield `${macro}, `;
             }
         }
         yield `}: typeof import('${options.vueCompilerOptions.lib}')${utils_1.endOfLine}`;
     }
 }
-function* generateDefineWithType(scriptSetup, statement, callExp, typeArg, name, defaultName, typeName) {
+function* generateDefineWithTypeTransforms(scriptSetup, statement, callExp, typeArg, name, defaultName, typeName) {
     if (typeArg) {
-        yield [
-            [
-                `type ${typeName} = `,
-                (0, utils_1.generateSfcBlockSection)(scriptSetup, typeArg.start, typeArg.end, codeFeatures_1.codeFeatures.all),
-                utils_1.endOfLine,
-            ],
-            statement.start,
-            statement.start,
-        ];
-        yield [[typeName], typeArg.start, typeArg.end];
+        yield (0, transform_1.insert)(statement.start, function* () {
+            yield `type ${typeName} = `;
+            yield* (0, utils_1.generateSfcBlockSection)(scriptSetup, typeArg.start, typeArg.end, codeFeatures_1.codeFeatures.all);
+            yield utils_1.endOfLine;
+        });
+        yield (0, transform_1.replace)(typeArg.start, typeArg.end, function* () {
+            yield typeName;
+        });
     }
     if (!name) {
         if (statement.start === callExp.start && statement.end === callExp.end) {
-            yield [[`const ${defaultName} = `], callExp.start, callExp.start];
+            yield (0, transform_1.insert)(callExp.start, function* () {
+                yield `const ${defaultName} = `;
+            });
         }
         else if (typeArg) {
-            yield [
-                [
-                    `const ${defaultName} = `,
-                    (0, utils_1.generateSfcBlockSection)(scriptSetup, callExp.start, typeArg.start, codeFeatures_1.codeFeatures.all),
-                ],
-                statement.start,
-                typeArg.start,
-            ];
-            yield [
-                [
-                    (0, utils_1.generateSfcBlockSection)(scriptSetup, typeArg.end, callExp.end, codeFeatures_1.codeFeatures.all),
-                    utils_1.endOfLine,
-                    (0, utils_1.generateSfcBlockSection)(scriptSetup, statement.start, callExp.start, codeFeatures_1.codeFeatures.all),
-                    defaultName,
-                ],
-                typeArg.end,
-                callExp.end,
-            ];
+            yield (0, transform_1.replace)(statement.start, typeArg.start, function* () {
+                yield `const ${defaultName} = `;
+                yield* (0, utils_1.generateSfcBlockSection)(scriptSetup, callExp.start, typeArg.start, codeFeatures_1.codeFeatures.all);
+            });
+            yield (0, transform_1.replace)(typeArg.end, callExp.end, function* () {
+                yield* (0, utils_1.generateSfcBlockSection)(scriptSetup, typeArg.end, callExp.end, codeFeatures_1.codeFeatures.all);
+                yield utils_1.endOfLine;
+                yield* (0, utils_1.generateSfcBlockSection)(scriptSetup, statement.start, callExp.start, codeFeatures_1.codeFeatures.all);
+                yield defaultName;
+            });
         }
         else {
-            yield [
-                [
-                    `const ${defaultName} = `,
-                    (0, utils_1.generateSfcBlockSection)(scriptSetup, callExp.start, callExp.end, codeFeatures_1.codeFeatures.all),
-                    utils_1.endOfLine,
-                    (0, utils_1.generateSfcBlockSection)(scriptSetup, statement.start, callExp.start, codeFeatures_1.codeFeatures.all),
-                    defaultName,
-                ],
-                statement.start,
-                callExp.end,
-            ];
+            yield (0, transform_1.replace)(statement.start, callExp.end, function* () {
+                yield `const ${defaultName} = `;
+                yield* (0, utils_1.generateSfcBlockSection)(scriptSetup, callExp.start, callExp.end, codeFeatures_1.codeFeatures.all);
+                yield utils_1.endOfLine;
+                yield* (0, utils_1.generateSfcBlockSection)(scriptSetup, statement.start, callExp.start, codeFeatures_1.codeFeatures.all);
+                yield defaultName;
+            });
         }
     }
     else if (!utils_1.identifierRegex.test(name)) {
-        yield [[`const ${defaultName} = `], statement.start, callExp.start];
-        yield [
-            [
-                utils_1.endOfLine,
-                (0, utils_1.generateSfcBlockSection)(scriptSetup, statement.start, callExp.start, codeFeatures_1.codeFeatures.all),
-                defaultName,
-            ],
-            statement.end,
-            statement.end,
-        ];
+        yield (0, transform_1.replace)(statement.start, callExp.start, function* () {
+            yield `const ${defaultName} = `;
+        });
+        yield (0, transform_1.insert)(statement.end, function* () {
+            yield utils_1.endOfLine;
+            yield* (0, utils_1.generateSfcBlockSection)(scriptSetup, statement.start, callExp.start, codeFeatures_1.codeFeatures.all);
+            yield defaultName;
+        });
     }
 }
-function* generatePublicProps(options, ctx, scriptSetup, scriptSetupRanges, hasSlots) {
+function* generatePublicProps(options, ctx, scriptSetup, scriptSetupRanges) {
     if (scriptSetupRanges.defineProps?.typeArg && scriptSetupRanges.withDefaults?.arg) {
-        yield `const __VLS_defaults = `;
-        yield (0, utils_1.generateSfcBlockSection)(scriptSetup, scriptSetupRanges.withDefaults.arg.start, scriptSetupRanges.withDefaults.arg.end, codeFeatures_1.codeFeatures.navigation);
+        yield `const ${names.defaults} = `;
+        yield* (0, utils_1.generateSfcBlockSection)(scriptSetup, scriptSetupRanges.withDefaults.arg.start, scriptSetupRanges.withDefaults.arg.end, codeFeatures_1.codeFeatures.navigation);
         yield utils_1.endOfLine;
     }
     const propTypes = [];
-    if (options.vueCompilerOptions.jsxSlots && hasSlots) {
-        propTypes.push(`${ctx.localTypes.PropsChildren}<__VLS_Slots>`);
+    if (options.vueCompilerOptions.jsxSlots && hasSlotsType(options)) {
+        propTypes.push(`${ctx.localTypes.PropsChildren}<${names.Slots}>`);
     }
     if (scriptSetupRanges.defineProps?.typeArg) {
-        propTypes.push(`__VLS_Props`);
+        propTypes.push(names.Props);
     }
     if (scriptSetupRanges.defineModel.length) {
-        propTypes.push(`__VLS_ModelProps`);
+        propTypes.push(names.ModelProps);
     }
     if (propTypes.length) {
-        ctx.generatedPropsType = true;
-        yield `type __VLS_PublicProps = ${propTypes.join(` & `)}${utils_1.endOfLine}`;
+        yield `type ${names.PublicProps} = ${propTypes.join(` & `)}${utils_1.endOfLine}`;
+        ctx.generatedTypes.add(names.PublicProps);
     }
 }
+function hasSlotsType(options) {
+    return !!(options.scriptSetupRanges?.defineSlots
+        || options.templateCodegen?.generatedTypes.has(names.Slots));
+}
 function* generateModels(scriptSetup, scriptSetupRanges) {
     if (!scriptSetupRanges.defineModel.length) {
         return;
@@ -397,7 +323,7 @@ function* generateModels(scriptSetup, scriptSetupRanges) {
         }
         else if (defineModel.defaultValue && propName) {
             // Infer from defineModel({ default: T })
-            modelType = `typeof __VLS_defaultModels['${propName}']`;
+            modelType = `typeof ${names.defaultModels}['${propName}']`;
         }
         else {
             modelType = `any`;
@@ -409,21 +335,21 @@ function* generateModels(scriptSetup, scriptSetupRanges) {
         emitCodes.push(generateModelEmit(defineModel, propName, modelType));
     }
     if (defaultCodes.length) {
-        yield `const __VLS_defaultModels = {${utils_1.newLine}`;
+        yield `const ${names.defaultModels} = {${utils_1.newLine}`;
         yield* defaultCodes;
         yield `}${utils_1.endOfLine}`;
     }
-    yield `type __VLS_ModelProps = {${utils_1.newLine}`;
+    yield `type ${names.ModelProps} = {${utils_1.newLine}`;
     for (const codes of propCodes) {
         yield* codes;
     }
     yield `}${utils_1.endOfLine}`;
-    yield `type __VLS_ModelEmit = {${utils_1.newLine}`;
+    yield `type ${names.ModelEmit} = {${utils_1.newLine}`;
     for (const codes of emitCodes) {
         yield* codes;
     }
     yield `}${utils_1.endOfLine}`;
-    yield `const __VLS_modelEmit = defineEmits<__VLS_ModelEmit>()${utils_1.endOfLine}`;
+    yield `const ${names.modelEmit} = defineEmits<${names.ModelEmit}>()${utils_1.endOfLine}`;
 }
 function* generateModelProp(scriptSetup, defineModel, propName, modelType) {
     if (defineModel.comments) {

package/lib/codegen/script/src.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateSrc = generateSrc;
 const codeFeatures_1 = require("../codeFeatures");
 const utils_1 = require("../utils");
-const wrapWith_1 = require("../utils/wrapWith");
+const boundary_1 = require("../utils/boundary");
 function* generateSrc(src) {
     if (src === true) {
         return;
@@ -22,10 +22,16 @@ function* generateSrc(src) {
         text = text + '.js';
     }
     yield `export * from `;
-    yield* (0, wrapWith_1.wrapWith)('main', src.offset, src.offset + src.text.length, {
+    const wrapCodeFeatures = {
         ...codeFeatures_1.codeFeatures.all,
         ...text !== src.text ? codeFeatures_1.codeFeatures.navigationWithoutRename : {},
-    }, `'`, [text.slice(0, src.text.length), 'main', src.offset, utils_1.combineLastMapping], text.slice(src.text.length), `'`);
+    };
+    const token = yield* (0, boundary_1.startBoundary)('main', src.offset, wrapCodeFeatures);
+    yield `'`;
+    yield [text.slice(0, src.text.length), 'main', src.offset, { __combineToken: token }];
+    yield text.slice(src.text.length);
+    yield `'`;
+    yield (0, boundary_1.endBoundary)(token, src.offset + src.text.length);
     yield utils_1.endOfLine;
     yield `export { default } from '${text}'${utils_1.endOfLine}`;
 }