@vue/language-core 3.2.7 → 3.2.9

package/lib/codegen/template/element.js

@@ -35,13 +35,14 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateComponent = generateComponent;
 exports.generateElement = generateElement;
+exports.generateFragment = generateFragment;
 const CompilerDOM = __importStar(require("@vue/compiler-dom"));
 const shared_1 = require("@vue/shared");
 const muggle_string_1 = require("muggle-string");
 const shared_2 = require("../../utils/shared");
 const codeFeatures_1 = require("../codeFeatures");
 const inlayHints_1 = require("../inlayHints");
-const names = __importStar(require("../names"));
+const names_1 = require("../names");
 const utils_1 = require("../utils");
 const boundary_1 = require("../utils/boundary");
 const camelized_1 = require("../utils/camelized");
@@ -114,9 +115,9 @@ function* generateComponent(options, ctx, node) {
             yield utils_1.endOfLine;
         }
         else {
-            yield `let ${componentVar}!: __VLS_WithComponent<'${tag}', __VLS_LocalComponents, __VLS_GlobalComponents`;
+            yield `let ${componentVar}!: ${names_1.names.WithComponent}<'${tag}', ${names_1.names.LocalComponents}, ${names_1.names.GlobalComponents}`;
             yield originalNames.has(options.componentName)
-                ? `, typeof ${names._export}`
+                ? `, typeof ${names_1.names.export}`
                 : `, void`;
             for (const name of originalNames) {
                 yield `, '${name}'`;
@@ -131,18 +132,21 @@ function* generateComponent(options, ctx, node) {
             yield `]${utils_1.endOfLine}`;
             if (utils_1.identifierRegex.test((0, shared_1.camelize)(tag))) {
                 // navigation support
-                yield `/** @ts-ignore @type {typeof ${names.components}.`;
-                yield* (0, camelized_1.generateCamelized)(tag, 'template', startTagOffset, codeFeatures_1.codeFeatures.navigation);
-                if (tag[0] !== tag[0].toUpperCase()) {
-                    yield ` | typeof ${names.components}.`;
-                    yield* (0, camelized_1.generateCamelized)((0, shared_1.capitalize)(tag), 'template', startTagOffset, codeFeatures_1.codeFeatures.navigation);
-                }
-                if (endTagOffset !== undefined) {
-                    yield ` | typeof ${names.components}.`;
-                    yield* (0, camelized_1.generateCamelized)(tag, 'template', endTagOffset, codeFeatures_1.codeFeatures.navigation);
+                yield `/** @ts-ignore @type {`;
+                for (const offset of [startTagOffset, endTagOffset]) {
+                    if (offset === undefined) {
+                        continue;
+                    }
+                    yield ` | typeof ${names_1.names.components}.`;
+                    yield* (0, camelized_1.generateCamelized)(tag, 'template', offset, codeFeatures_1.codeFeatures.navigation);
                     if (tag[0] !== tag[0].toUpperCase()) {
-                        yield ` | typeof ${names.components}.`;
-                        yield* (0, camelized_1.generateCamelized)((0, shared_1.capitalize)(tag), 'template', endTagOffset, codeFeatures_1.codeFeatures.navigation);
+                        yield ` | typeof ${names_1.names.components}.`;
+                        yield* (0, camelized_1.generateCamelized)((0, shared_1.capitalize)(tag), 'template', offset, codeFeatures_1.codeFeatures.navigation);
+                    }
+                    if (tag.includes('-')) {
+                        yield ` | typeof ${names_1.names.components}[`;
+                        yield* (0, stringLiteralKey_1.generateStringLiteralKey)(tag, offset, codeFeatures_1.codeFeatures.navigation);
+                        yield `]`;
                     }
                 }
                 yield `} */${utils_1.newLine}`;
@@ -163,16 +167,16 @@ function* generateComponentBody(options, ctx, node, tag, tagOffset, props, compo
     const failGeneratedExpressions = [];
     const propCodes = [...(0, elementProps_1.generateElementProps)(options, ctx, node, props, options.vueCompilerOptions.checkUnknownProps, failGeneratedExpressions)];
     const functionalVar = ctx.getInternalVariable();
-    const vNodeVar = ctx.getInternalVariable();
+    const vnodeVar = ctx.getInternalVariable();
     const ctxVar = ctx.getInternalVariable();
     const propsVar = ctx.getInternalVariable();
     yield `// @ts-ignore${utils_1.newLine}`;
-    yield `const ${functionalVar} = ${options.vueCompilerOptions.checkUnknownProps ? '__VLS_asFunctionalComponent0' : '__VLS_asFunctionalComponent1'}(${componentVar}, new ${componentVar}({${utils_1.newLine}`;
+    yield `const ${functionalVar} = ${options.vueCompilerOptions.checkUnknownProps ? names_1.names.asFunctionalComponent0 : names_1.names.asFunctionalComponent1}(${componentVar}, new ${componentVar}({${utils_1.newLine}`;
     yield (0, muggle_string_1.toString)(propCodes);
     yield `}))${utils_1.endOfLine}`;
     yield `const `;
     const token = yield* (0, boundary_1.startBoundary)('template', node.loc.start.offset, codeFeatures_1.codeFeatures.doNotReportTs6133);
-    yield vNodeVar;
+    yield vnodeVar;
     yield (0, boundary_1.endBoundary)(token, node.loc.end.offset);
     yield ` = ${functionalVar}`;
     if (ctx.currentInfo.generic) {
@@ -189,7 +193,7 @@ function* generateComponentBody(options, ctx, node, tag, tagOffset, props, compo
     yield* propCodes;
     yield `}`;
     yield (0, boundary_1.endBoundary)(token2, tagOffset + tag.length);
-    yield `, ...__VLS_functionalComponentArgsRest(${functionalVar}))${utils_1.endOfLine}`;
+    yield `, ...${names_1.names.functionalComponentArgsRest}(${functionalVar}))${utils_1.endOfLine}`;
     yield* generateFailedExpressions(options, ctx, failGeneratedExpressions);
     yield* (0, elementEvents_1.generateElementEvents)(options, ctx, node, componentVar, getCtxVar, getPropsVar);
     yield* (0, elementDirectives_1.generateElementDirectives)(options, ctx, node);
@@ -220,21 +224,21 @@ function* generateComponentBody(options, ctx, node, tag, tagOffset, props, compo
         yield* (0, vSlot_1.generateVSlot)(options, ctx, node, slotDir, getCtxVar());
     }
     if (isCtxVarUsed) {
-        yield `var ${ctxVar}!: __VLS_FunctionalComponentCtx<typeof ${componentVar}, typeof ${vNodeVar}>${utils_1.endOfLine}`;
+        yield `var ${ctxVar}!: ${names_1.names.FunctionalComponentCtx}<typeof ${componentVar}, typeof ${vnodeVar}>${utils_1.endOfLine}`;
     }
     if (isPropsVarUsed) {
-        yield `var ${propsVar}!: __VLS_FunctionalComponentProps<typeof ${componentVar}, typeof ${vNodeVar}>${utils_1.endOfLine}`;
+        yield `var ${propsVar}!: ${names_1.names.FunctionalComponentProps}<typeof ${componentVar}, typeof ${vnodeVar}>${utils_1.endOfLine}`;
     }
     ctx.components.pop();
 }
 function* generateElement(options, ctx, node) {
     const [startTagOffset, endTagOffset] = (0, shared_2.getElementTagOffsets)(node, options.template);
     const failedPropExps = [];
-    yield `${options.vueCompilerOptions.checkUnknownProps ? `__VLS_asFunctionalElement0` : `__VLS_asFunctionalElement1`}(${names.intrinsics}`;
+    yield `${options.vueCompilerOptions.checkUnknownProps ? names_1.names.asFunctionalElement0 : names_1.names.asFunctionalElement1}(${names_1.names.intrinsics}`;
     yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, node.tag, startTagOffset, codeFeatures_1.codeFeatures.withoutHighlightAndCompletion);
     if (endTagOffset !== undefined) {
         yield `, `;
-        yield names.intrinsics;
+        yield names_1.names.intrinsics;
         yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, node.tag, endTagOffset, codeFeatures_1.codeFeatures.withoutHighlightAndCompletion);
     }
     yield `)(`;
@@ -248,23 +252,39 @@ function* generateElement(options, ctx, node) {
     yield* (0, elementDirectives_1.generateElementDirectives)(options, ctx, node);
     const templateRef = getTemplateRef(node);
     if (templateRef) {
-        let typeExp = `__VLS_Elements['${node.tag}']`;
+        let typeExp = `${names_1.names.Elements}['${node.tag}']`;
         if (ctx.inVFor) {
             typeExp += `[]`;
         }
         ctx.addTemplateRef(templateRef[0], typeExp, templateRef[1]);
     }
     if (ctx.singleRootNodes.has(node)) {
-        ctx.singleRootElTypes.add(`__VLS_Elements['${node.tag}']`);
+        ctx.singleRootElTypes.add(`${names_1.names.Elements}['${node.tag}']`);
     }
     if (hasVBindAttrs(options, ctx, node)) {
-        ctx.inheritedAttrVars.add(`__VLS_intrinsics.${node.tag}`);
+        ctx.inheritedAttrVars.add(`${names_1.names.intrinsics}.${node.tag}`);
     }
     yield* generateStyleScopedClassReferences(options, node);
     for (const child of node.children) {
         yield* (0, templateChild_1.generateTemplateChild)(options, ctx, child);
     }
 }
+function* generateFragment(options, ctx, node) {
+    const [startTagOffset] = (0, shared_2.getElementTagOffsets)(node, options.template);
+    // special case for <template v-for="..." :key="..." />
+    if (node.props.length) {
+        yield `__VLS_asFunctionalElement(__VLS_intrinsics.template)(`;
+        const token = yield* (0, boundary_1.startBoundary)('template', startTagOffset, codeFeatures_1.codeFeatures.verification);
+        yield `{${utils_1.newLine}`;
+        yield* (0, elementProps_1.generateElementProps)(options, ctx, node, node.props, options.vueCompilerOptions.checkUnknownProps);
+        yield `}`;
+        yield (0, boundary_1.endBoundary)(token, startTagOffset + node.tag.length);
+        yield `)${utils_1.endOfLine}`;
+    }
+    for (const child of node.children) {
+        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, child);
+    }
+}
 function* generateStyleScopedClassReferences({ template, typescript: ts }, node) {
     for (const prop of node.props) {
         if (prop.type === CompilerDOM.NodeTypes.ATTRIBUTE

package/lib/codegen/template/elementDirectives.js

@@ -38,7 +38,7 @@ exports.generateModifiers = generateModifiers;
 const CompilerDOM = __importStar(require("@vue/compiler-dom"));
 const shared_1 = require("@vue/shared");
 const codeFeatures_1 = require("../codeFeatures");
-const names = __importStar(require("../names"));
+const names_1 = require("../names");
 const utils_1 = require("../utils");
 const boundary_1 = require("../utils/boundary");
 const camelized_1 = require("../utils/camelized");
@@ -56,9 +56,9 @@ function* generateElementDirectives(options, ctx, node) {
             continue;
         }
         const token = yield* (0, boundary_1.startBoundary)('template', prop.loc.start.offset, codeFeatures_1.codeFeatures.verification);
-        yield `__VLS_asFunctionalDirective(`;
+        yield `${names_1.names.asFunctionalDirective}(`;
         yield* generateIdentifier(options, ctx, prop);
-        yield `, {} as import('${options.vueCompilerOptions.lib}').ObjectDirective)(null!, { ...__VLS_directiveBindingRestFields, `;
+        yield `, {} as import('${options.vueCompilerOptions.lib}').ObjectDirective)(null!, { ...${names_1.names.directiveBindingRestFields}, `;
         yield* generateArg(options, ctx, prop);
         yield* generateModifiers(options, ctx, prop);
         yield* generateValue(options, ctx, prop);
@@ -71,7 +71,7 @@ function* generateIdentifier(options, ctx, prop) {
     const rawName = 'v-' + prop.name;
     const startOffset = prop.loc.start.offset;
     const token = yield* (0, boundary_1.startBoundary)('template', startOffset, codeFeatures_1.codeFeatures.verification);
-    yield names.directives;
+    yield names_1.names.directives;
     yield `.`;
     yield* (0, camelized_1.generateCamelized)(rawName, 'template', prop.loc.start.offset, {
         ...codeFeatures_1.codeFeatures.withoutHighlightAndCompletion,

package/lib/codegen/template/elementEvents.js

@@ -41,6 +41,7 @@ exports.isCompoundExpression = isCompoundExpression;
 const CompilerDOM = __importStar(require("@vue/compiler-dom"));
 const shared_1 = require("@vue/shared");
 const codeFeatures_1 = require("../codeFeatures");
+const names_1 = require("../names");
 const utils_1 = require("../utils");
 const boundary_1 = require("../utils/boundary");
 const camelized_1 = require("../utils/camelized");
@@ -56,7 +57,7 @@ function* generateElementEvents(options, ctx, node, componentOriginalVar, getCtx
                     && (!prop.arg || prop.arg.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && prop.arg.isStatic))) {
             if (!emitsVar) {
                 emitsVar = ctx.getInternalVariable();
-                yield `let ${emitsVar}!: __VLS_ResolveEmits<typeof ${componentOriginalVar}, typeof ${getCtxVar()}.emit>${utils_1.endOfLine}`;
+                yield `let ${emitsVar}!: ${names_1.names.ResolveEmits}<typeof ${componentOriginalVar}, typeof ${getCtxVar()}.emit>${utils_1.endOfLine}`;
             }
             let source = prop.arg?.loc.source ?? 'model-value';
             let start = prop.arg?.loc.start.offset;
@@ -75,7 +76,7 @@ function* generateElementEvents(options, ctx, node, componentOriginalVar, getCtx
             const propName = (0, shared_1.camelize)(propPrefix + source);
             const emitName = emitPrefix + source;
             const camelizedEmitName = (0, shared_1.camelize)(emitName);
-            yield `const ${ctx.getInternalVariable()}: __VLS_NormalizeComponentEvent<typeof ${getPropsVar()}, typeof ${emitsVar}, '${propName}', '${emitName}', '${camelizedEmitName}'> = (${utils_1.newLine}`;
+            yield `const ${ctx.getInternalVariable()}: ${names_1.names.NormalizeComponentEvent}<typeof ${getPropsVar()}, typeof ${emitsVar}, '${propName}', '${emitName}', '${camelizedEmitName}'> = (${utils_1.newLine}`;
             if (prop.name === 'on') {
                 yield `{ `;
                 yield* generateEventArg(options, source, start, emitPrefix.slice(0, -1), codeFeatures_1.codeFeatures.navigation);

package/lib/codegen/template/elementProps.js

@@ -41,7 +41,7 @@ const picomatch_1 = require("picomatch");
 const shared_2 = require("../../utils/shared");
 const codeFeatures_1 = require("../codeFeatures");
 const inlayHints_1 = require("../inlayHints");
-const names = __importStar(require("../names"));
+const names_1 = require("../names");
 const utils_1 = require("../utils");
 const boundary_1 = require("../utils/boundary");
 const camelized_1 = require("../utils/camelized");
@@ -109,7 +109,7 @@ function* generateElementProps(options, ctx, node, props, strictPropsCheck, fail
                 propName = propName.slice(1);
             }
             const shouldSpread = propName === 'style' || propName === 'class';
-            const shouldCamelize = isComponent && getShouldCamelize(options, prop, propName);
+            const shouldCamelize = getShouldCamelize(options, node, prop, propName);
             const features = getPropsCodeFeatures(strictPropsCheck);
             if (shouldSpread) {
                 yield `...{ `;
@@ -136,7 +136,7 @@ function* generateElementProps(options, ctx, node, props, strictPropsCheck, fail
             if (isComponent && prop.name === 'model' && prop.modifiers.length) {
                 const propertyName = prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
                     ? !prop.arg.isStatic
-                        ? `[__VLS_tryAsConstant(\`\${${prop.arg.content}}Modifiers\`)]`
+                        ? `[${names_1.names.tryAsConstant}(\`\${${prop.arg.content}}Modifiers\`)]`
                         : (0, shared_1.camelize)(propName) + `Modifiers`
                     : `modelModifiers`;
                 yield* (0, elementDirectives_1.generateModifiers)(options, ctx, prop, propertyName);
@@ -148,7 +148,7 @@ function* generateElementProps(options, ctx, node, props, strictPropsCheck, fail
                 continue;
             }
             const shouldSpread = prop.name === 'style' || prop.name === 'class';
-            const shouldCamelize = isComponent && getShouldCamelize(options, prop, prop.name);
+            const shouldCamelize = getShouldCamelize(options, node, prop, prop.name);
             const features = getPropsCodeFeatures(strictPropsCheck);
             if (shouldSpread) {
                 yield `...{ `;
@@ -219,7 +219,7 @@ function* generatePropExp(options, ctx, prop, exp) {
             }
             else {
                 ctx.recordComponentAccess('template', propVariableName, exp.loc.start.offset);
-                yield names.ctx;
+                yield names_1.names.ctx;
                 yield `.`;
                 yield* codes;
             }
@@ -234,10 +234,10 @@ function* generateAttrValue(node, features) {
     yield* (0, unicode_1.generateUnicode)(content, offset, features);
     yield quote;
 }
-function getShouldCamelize(options, prop, propName) {
-    return (prop.type !== CompilerDOM.NodeTypes.DIRECTIVE
-        || !prop.arg
-        || (prop.arg.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && prop.arg.isStatic))
+function getShouldCamelize(options, node, prop, propName) {
+    return (node.tagType === CompilerDOM.ElementTypes.COMPONENT
+        || node.tagType === CompilerDOM.ElementTypes.SLOT) && (prop.type !== CompilerDOM.NodeTypes.DIRECTIVE
+        || prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && prop.arg.isStatic)
         && (0, shared_2.hyphenateAttr)(propName) === propName
         && !options.vueCompilerOptions.htmlAttributes.some(pattern => (0, picomatch_1.isMatch)(propName, pattern));
 }

package/lib/codegen/template/index.js

@@ -1,41 +1,8 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateTemplate = generate;
 const codeFeatures_1 = require("../codeFeatures");
-const names = __importStar(require("../names"));
+const names_1 = require("../names");
 const utils_1 = require("../utils");
 const boundary_1 = require("../utils/boundary");
 const context_1 = require("./context");
@@ -84,24 +51,24 @@ function* generateWorker(options, ctx) {
     yield* generateTemplateRefsType(options, ctx);
     yield* generateRootElType(ctx);
     if (ctx.dollarVars.size) {
-        yield `var ${names.dollars}!: {${utils_1.newLine}`;
+        yield `var ${names_1.names.dollars}!: {${utils_1.newLine}`;
         if (ctx.dollarVars.has('$slots')) {
-            const type = ctx.generatedTypes.has(names.Slots) ? names.Slots : `{}`;
+            const type = ctx.generatedTypes.has(names_1.names.Slots) ? names_1.names.Slots : `{}`;
             yield `$slots: ${type}${utils_1.endOfLine}`;
         }
         if (ctx.dollarVars.has('$attrs')) {
             yield `$attrs: import('${vueCompilerOptions.lib}').ComponentPublicInstance['$attrs']`;
-            if (ctx.generatedTypes.has(names.InheritedAttrs)) {
-                yield ` & ${names.InheritedAttrs}`;
+            if (ctx.generatedTypes.has(names_1.names.InheritedAttrs)) {
+                yield ` & ${names_1.names.InheritedAttrs}`;
             }
             yield utils_1.endOfLine;
         }
         if (ctx.dollarVars.has('$refs')) {
-            const type = ctx.generatedTypes.has(names.TemplateRefs) ? names.TemplateRefs : `{}`;
+            const type = ctx.generatedTypes.has(names_1.names.TemplateRefs) ? names_1.names.TemplateRefs : `{}`;
             yield `$refs: ${type}${utils_1.endOfLine}`;
         }
         if (ctx.dollarVars.has('$el')) {
-            const type = ctx.generatedTypes.has(names.RootEl) ? names.RootEl : `any`;
+            const type = ctx.generatedTypes.has(names_1.names.RootEl) ? names_1.names.RootEl : `any`;
             yield `$el: ${type}${utils_1.endOfLine}`;
         }
         yield `} & { [K in keyof import('${vueCompilerOptions.lib}').ComponentPublicInstance]: unknown }${utils_1.endOfLine}`;
@@ -110,14 +77,14 @@ function* generateWorker(options, ctx) {
 }
 function* generateSlotsType(options, ctx) {
     if (options.hasDefineSlots) {
-        ctx.generatedTypes.add(names.Slots);
+        ctx.generatedTypes.add(names_1.names.Slots);
         return;
     }
     if (!ctx.slots.length && !ctx.dynamicSlots.length) {
         return;
     }
-    ctx.generatedTypes.add(names.Slots);
-    yield `type ${names.Slots} = {}`;
+    ctx.generatedTypes.add(names_1.names.Slots);
+    yield `type ${names_1.names.Slots} = {}`;
     for (const { expVar, propsVar } of ctx.dynamicSlots) {
         yield `${utils_1.newLine}& { [K in NonNullable<typeof ${expVar}>]?: (props: typeof ${propsVar}) => any }`;
     }
@@ -139,16 +106,16 @@ function* generateInheritedAttrsType(ctx) {
     if (!ctx.inheritedAttrVars.size) {
         return;
     }
-    ctx.generatedTypes.add(names.InheritedAttrs);
-    yield `type ${names.InheritedAttrs} = Partial<${[...ctx.inheritedAttrVars].map(name => `typeof ${name}`).join(` & `)}>`;
+    ctx.generatedTypes.add(names_1.names.InheritedAttrs);
+    yield `type ${names_1.names.InheritedAttrs} = Partial<${[...ctx.inheritedAttrVars].map(name => `typeof ${name}`).join(` & `)}>`;
     yield utils_1.endOfLine;
 }
 function* generateTemplateRefsType(options, ctx) {
     if (!ctx.templateRefs.size) {
         return;
     }
-    ctx.generatedTypes.add(names.TemplateRefs);
-    yield `type ${names.TemplateRefs} = {}`;
+    ctx.generatedTypes.add(names_1.names.TemplateRefs);
+    yield `type ${names_1.names.TemplateRefs} = {}`;
     for (const [name, refs] of ctx.templateRefs) {
         yield `${utils_1.newLine}& `;
         if (refs.length >= 2) {
@@ -173,8 +140,8 @@ function* generateRootElType(ctx) {
     if (!ctx.singleRootElTypes.size || ctx.singleRootNodes.has(null)) {
         return;
     }
-    ctx.generatedTypes.add(names.RootEl);
-    yield `type ${names.RootEl} = `;
+    ctx.generatedTypes.add(names_1.names.RootEl);
+    yield `type ${names_1.names.RootEl} = `;
     for (const type of ctx.singleRootElTypes) {
         yield `${utils_1.newLine}| ${type}`;
     }

package/lib/codegen/template/interpolation.js

@@ -1,44 +1,11 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateInterpolation = generateInterpolation;
 const shared_1 = require("@vue/shared");
 const collectBindings_1 = require("../../utils/collectBindings");
 const shared_2 = require("../../utils/shared");
 const codeFeatures_1 = require("../codeFeatures");
-const names = __importStar(require("../names"));
+const names_1 = require("../names");
 const utils_1 = require("../utils");
 // https://github.com/vuejs/core/blob/fb0c3ca519f1fccf52049cd6b8db3a67a669afe9/packages/compiler-core/src/transforms/transformExpression.ts#L47
 const isLiteralWhitelisted = /*@__PURE__*/ (0, shared_1.makeMap)('true,false,null,this');
@@ -95,11 +62,11 @@ function* forEachInterpolationSegment(ts, setupRefs, ctx, block, originalCode, s
         else {
             yield ['', offset, 'errorMappingOnly']; // #1205, #1264
             if (ctx.dollarVars.has(name)) {
-                yield names.dollars;
+                yield names_1.names.dollars;
             }
             else {
                 ctx.recordComponentAccess(block.name, name, start - prefix.length + offset);
-                yield names.ctx;
+                yield names_1.names.ctx;
             }
             yield `.`;
             yield [name, offset, isShorthand ? 'shorthand' : undefined];

package/lib/codegen/template/objectProperty.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateObjectProperty = generateObjectProperty;
 const shared_1 = require("@vue/shared");
+const names_1 = require("../names");
 const utils_1 = require("../utils");
 const boundary_1 = require("../utils/boundary");
 const camelized_1 = require("../utils/camelized");
@@ -10,7 +11,7 @@ const interpolation_1 = require("./interpolation");
 function* generateObjectProperty(options, ctx, code, offset, features, shouldCamelize = false, shouldBeConstant = false) {
     if (code.startsWith('[') && code.endsWith(']')) {
         if (shouldBeConstant) {
-            yield* (0, interpolation_1.generateInterpolation)(options, ctx, options.template, features, code.slice(1, -1), offset + 1, `[__VLS_tryAsConstant(`, `)]`);
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, options.template, features, code.slice(1, -1), offset + 1, `[${names_1.names.tryAsConstant}(`, `)]`);
         }
         else {
             yield* (0, interpolation_1.generateInterpolation)(options, ctx, options.template, features, code, offset);

package/lib/codegen/template/slotOutlet.js

@@ -38,7 +38,7 @@ const CompilerDOM = __importStar(require("@vue/compiler-dom"));
 const shared_1 = require("../../utils/shared");
 const codeFeatures_1 = require("../codeFeatures");
 const inlayHints_1 = require("../inlayHints");
-const names = __importStar(require("../names"));
+const names_1 = require("../names");
 const utils_1 = require("../utils");
 const boundary_1 = require("../utils/boundary");
 const elementProps_1 = require("./elementProps");
@@ -59,7 +59,7 @@ function* generateSlotOutlet(options, ctx, node) {
         }
     });
     if (options.hasDefineSlots) {
-        yield `__VLS_asFunctionalSlot(`;
+        yield `${names_1.names.asFunctionalSlot}(`;
         if (nameProp) {
             let codes;
             if (nameProp.type === CompilerDOM.NodeTypes.ATTRIBUTE && nameProp.value) {
@@ -78,13 +78,13 @@ function* generateSlotOutlet(options, ctx, node) {
                 codes = [`['default']`];
             }
             const token = yield* (0, boundary_1.startBoundary)('template', nameProp.loc.start.offset, codeFeatures_1.codeFeatures.verification);
-            yield options.slotsAssignName ?? names.slots;
+            yield options.slotsAssignName ?? names_1.names.slots;
             yield* codes;
             yield (0, boundary_1.endBoundary)(token, nameProp.loc.end.offset);
         }
         else {
             const token = yield* (0, boundary_1.startBoundary)('template', startTagOffset, codeFeatures_1.codeFeatures.verification);
-            yield `${options.slotsAssignName ?? names.slots}[`;
+            yield `${options.slotsAssignName ?? names_1.names.slots}[`;
             const token2 = yield* (0, boundary_1.startBoundary)('template', startTagOffset, codeFeatures_1.codeFeatures.verification);
             yield `'default'`;
             yield (0, boundary_1.endBoundary)(token2, startTagEndOffset);
@@ -120,7 +120,7 @@ function* generateSlotOutlet(options, ctx, node) {
                 ctx.inlayHints.push((0, inlayHints_1.createVBindShorthandInlayHintInfo)(nameProp.exp.loc, 'name'));
             }
             const expVar = ctx.getInternalVariable();
-            yield `var ${expVar} = __VLS_tryAsConstant(`;
+            yield `var ${expVar} = ${names_1.names.tryAsConstant}(`;
             yield* (0, interpolation_1.generateInterpolation)(options, ctx, options.template, isShortHand
                 ? codeFeatures_1.codeFeatures.withoutHighlightAndCompletion
                 : codeFeatures_1.codeFeatures.all, nameProp.exp.content, nameProp.exp.loc.start.offset);

package/lib/codegen/template/styleScopedClasses.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.references = void 0;
 exports.generateStyleScopedClassReference = generateStyleScopedClassReference;
 const codeFeatures_1 = require("../codeFeatures");
+const names_1 = require("../names");
 const utils_1 = require("../utils");
 const boundary_1 = require("../utils/boundary");
 const escaped_1 = require("../utils/escaped");
@@ -11,7 +12,7 @@ const classNameEscapeRegex = /([\\'])/;
 exports.references = new WeakMap();
 function* generateStyleScopedClassReference(block, className, offset, fullStart = offset) {
     if (!className) {
-        yield `/** @type {__VLS_StyleScopedClasses['`;
+        yield `/** @type {${names_1.names.StyleScopedClasses}['`;
         yield ['', 'template', offset, codeFeatures_1.codeFeatures.completion];
         yield `']} */${utils_1.endOfLine}`;
         return;
@@ -25,7 +26,7 @@ function* generateStyleScopedClassReference(block, className, offset, fullStart
     else {
         cache[1].push([className, offset]);
     }
-    yield `/** @type {__VLS_StyleScopedClasses[`;
+    yield `/** @type {${names_1.names.StyleScopedClasses}[`;
     const token = yield* (0, boundary_1.startBoundary)(block.name, fullStart, codeFeatures_1.codeFeatures.navigation);
     yield `'`;
     yield* (0, escaped_1.generateEscaped)(className, block.name, offset, codeFeatures_1.codeFeatures.navigationAndCompletion, classNameEscapeRegex);

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

@@ -2,5 +2,5 @@ import * as CompilerDOM from '@vue/compiler-dom';
 import type { Code } from '../../types';
 import type { TemplateCodegenContext } from './context';
 import type { TemplateCodegenOptions } from './index';
-export declare function generateTemplateChild(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode | CompilerDOM.SimpleExpressionNode, enterNode?: boolean): Generator<Code>;
+export declare function generateTemplateChild(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode | CompilerDOM.SimpleExpressionNode, enterNode?: boolean, isVForChild?: boolean): Generator<Code>;
 export declare function parseInterpolationNode(node: CompilerDOM.InterpolationNode, template: string): readonly [string, number];

package/lib/codegen/template/templateChild.js

@@ -45,14 +45,10 @@ const slotOutlet_1 = require("./slotOutlet");
 const vFor_1 = require("./vFor");
 const vIf_1 = require("./vIf");
 const vSlot_1 = require("./vSlot");
-function* generateTemplateChild(options, ctx, node, enterNode = true) {
+function* generateTemplateChild(options, ctx, node, enterNode = true, isVForChild = false) {
     if (enterNode && !ctx.enter(node)) {
         return;
     }
-    const cur = node;
-    if (cur.codegenNode?.type === CompilerDOM.NodeTypes.JS_CACHE_EXPRESSION) {
-        cur.codegenNode = cur.codegenNode.value;
-    }
     if (node.type === CompilerDOM.NodeTypes.ROOT) {
         for (const item of collectSingleRootNodes(options, node.children)) {
             ctx.singleRootNodes.add(item);
@@ -62,27 +58,25 @@ function* generateTemplateChild(options, ctx, node, enterNode = true) {
         }
     }
     else if (node.type === CompilerDOM.NodeTypes.ELEMENT) {
-        let slotDir;
         if (node.tagType === CompilerDOM.ElementTypes.SLOT) {
             yield* (0, slotOutlet_1.generateSlotOutlet)(options, ctx, node);
         }
-        else if (node.tagType === CompilerDOM.ElementTypes.TEMPLATE
-            && ctx.components.length
-            && (slotDir = node.props.find(p => p.type === CompilerDOM.NodeTypes.DIRECTIVE && p.name === 'slot'))) {
-            yield* (0, vSlot_1.generateVSlot)(options, ctx, node, slotDir, ctx.components[ctx.components.length - 1]());
-        }
-        else if (node.tagType === CompilerDOM.ElementTypes.ELEMENT
-            || node.tagType === CompilerDOM.ElementTypes.TEMPLATE) {
-            yield* (0, element_1.generateElement)(options, ctx, node);
-        }
         else {
-            yield* (0, element_1.generateComponent)(options, ctx, node);
+            const slotDir = node.props.find(CompilerDOM.isVSlot);
+            if (node.tagType === CompilerDOM.ElementTypes.TEMPLATE && ctx.components.length && slotDir) {
+                yield* (0, vSlot_1.generateVSlot)(options, ctx, node, slotDir, ctx.components.at(-1)());
+            }
+            else if (node.tagType === CompilerDOM.ElementTypes.TEMPLATE && isVForChild) {
+                yield* (0, element_1.generateFragment)(options, ctx, node);
+            }
+            else if (node.tagType === CompilerDOM.ElementTypes.COMPONENT) {
+                yield* (0, element_1.generateComponent)(options, ctx, node);
+            }
+            else {
+                yield* (0, element_1.generateElement)(options, ctx, node);
+            }
         }
     }
-    else if (node.type === CompilerDOM.NodeTypes.TEXT_CALL) {
-        // {{ var }}
-        yield* generateTemplateChild(options, ctx, node.content, false);
-    }
     else if (node.type === CompilerDOM.NodeTypes.COMPOUND_EXPRESSION) {
         // {{ ... }} {{ ... }}
         for (const child of node.children) {
@@ -105,9 +99,6 @@ function* generateTemplateChild(options, ctx, node, enterNode = true) {
         // v-for
         yield* (0, vFor_1.generateVFor)(options, ctx, node);
     }
-    else if (node.type === CompilerDOM.NodeTypes.TEXT) {
-        // not needed progress
-    }
     if (enterNode) {
         yield* ctx.exit();
     }