@vue/language-core 2.1.10 → 2.2.2

package/lib/codegen/template/interpolation.js

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateInterpolation = generateInterpolation;
-exports.forEachInterpolationSegment = forEachInterpolationSegment;
 const shared_1 = require("@vue/shared");
 const scriptSetupRanges_1 = require("../../parsers/scriptSetupRanges");
-const common_1 = require("../common");
-function* generateInterpolation(options, ctx, _code, astHolder, start, data, prefix, suffix) {
+const utils_1 = require("../utils");
+function* generateInterpolation(options, ctx, source, data, _code, start, astHolder = {}, prefix = '', suffix = '') {
     const code = prefix + _code + suffix;
-    const ast = (0, common_1.createTsAst)(options.ts, astHolder, code);
+    const ast = (0, utils_1.createTsAst)(options.ts, astHolder, code);
     for (let [section, offset, type] of forEachInterpolationSegment(options.ts, options.destructuredPropNames, options.templateRefNames, ctx, code, start !== undefined ? start - prefix.length : undefined, ast)) {
         if (offset === undefined) {
             yield section;
@@ -17,12 +16,12 @@ function* generateInterpolation(options, ctx, _code, astHolder, start, data, pre
             let addSuffix = '';
             const overLength = offset + section.length - _code.length;
             if (overLength > 0) {
-                addSuffix = section.substring(section.length - overLength);
-                section = section.substring(0, section.length - overLength);
+                addSuffix = section.slice(section.length - overLength);
+                section = section.slice(0, -overLength);
             }
             if (offset < 0) {
-                yield section.substring(0, -offset);
-                section = section.substring(-offset);
+                yield section.slice(0, -offset);
+                section = section.slice(-offset);
                 offset = 0;
             }
             const shouldSkip = section.length === 0 && (type === 'startText' || type === 'endText');
@@ -31,7 +30,7 @@ function* generateInterpolation(options, ctx, _code, astHolder, start, data, pre
                     && data) {
                     yield [
                         section,
-                        'template',
+                        source,
                         start + offset,
                         type === 'errorMappingOnly'
                             ? ctx.codeFeatures.verification
@@ -46,15 +45,16 @@ function* generateInterpolation(options, ctx, _code, astHolder, start, data, pre
         }
     }
 }
+;
 function* forEachInterpolationSegment(ts, destructuredPropNames, templateRefNames, ctx, code, offset, ast) {
     let ctxVars = [];
     const varCb = (id, isShorthand) => {
         const text = (0, scriptSetupRanges_1.getNodeText)(ts, id, ast);
-        if (ctx.hasLocalVariable(text) ||
+        if (ctx.hasLocalVariable(text)
             // https://github.com/vuejs/core/blob/245230e135152900189f13a4281302de45fdcfaa/packages/compiler-core/src/transforms/transformExpression.ts#L342-L352
-            (0, shared_1.isGloballyWhitelisted)(text) ||
-            text === 'require' ||
-            text.startsWith('__VLS_')) {
+            || (0, shared_1.isGloballyAllowed)(text)
+            || text === 'require'
+            || text.startsWith('__VLS_')) {
             // localVarOffsets.push(localVar.getStart(ast));
         }
         else {
@@ -78,50 +78,53 @@ function* forEachInterpolationSegment(ts, destructuredPropNames, templateRefName
     ctxVars = ctxVars.sort((a, b) => a.offset - b.offset);
     if (ctxVars.length) {
         if (ctxVars[0].isShorthand) {
-            yield [code.substring(0, ctxVars[0].offset + ctxVars[0].text.length), 0];
+            yield [code.slice(0, ctxVars[0].offset + ctxVars[0].text.length), 0];
             yield [': ', undefined];
         }
         else if (ctxVars[0].offset > 0) {
-            yield [code.substring(0, ctxVars[0].offset), 0, 'startText'];
+            yield [code.slice(0, ctxVars[0].offset), 0, 'startText'];
         }
         for (let i = 0; i < ctxVars.length - 1; i++) {
             const curVar = ctxVars[i];
             const nextVar = ctxVars[i + 1];
-            yield* generateVar(code, destructuredPropNames, templateRefNames, curVar, nextVar);
+            yield* generateVar(code, ctx.specialVars, destructuredPropNames, templateRefNames, curVar);
             if (nextVar.isShorthand) {
-                yield [code.substring(curVar.offset + curVar.text.length, nextVar.offset + nextVar.text.length), curVar.offset + curVar.text.length];
+                yield [code.slice(curVar.offset + curVar.text.length, nextVar.offset + nextVar.text.length), curVar.offset + curVar.text.length];
                 yield [': ', undefined];
             }
             else {
-                yield [code.substring(curVar.offset + curVar.text.length, nextVar.offset), curVar.offset + curVar.text.length];
+                yield [code.slice(curVar.offset + curVar.text.length, nextVar.offset), curVar.offset + curVar.text.length];
             }
         }
         const lastVar = ctxVars.at(-1);
-        yield* generateVar(code, destructuredPropNames, templateRefNames, lastVar);
+        yield* generateVar(code, ctx.specialVars, destructuredPropNames, templateRefNames, lastVar);
         if (lastVar.offset + lastVar.text.length < code.length) {
-            yield [code.substring(lastVar.offset + lastVar.text.length), lastVar.offset + lastVar.text.length, 'endText'];
+            yield [code.slice(lastVar.offset + lastVar.text.length), lastVar.offset + lastVar.text.length, 'endText'];
         }
     }
     else {
         yield [code, 0];
     }
 }
-function* generateVar(code, destructuredPropNames, templateRefNames, curVar, nextVar = curVar) {
+function* generateVar(code, specialVars, destructuredPropNames, templateRefNames, curVar) {
     // fix https://github.com/vuejs/language-tools/issues/1205
     // fix https://github.com/vuejs/language-tools/issues/1264
-    yield ['', nextVar.offset, 'errorMappingOnly'];
+    yield ['', curVar.offset, 'errorMappingOnly'];
     const isDestructuredProp = destructuredPropNames?.has(curVar.text) ?? false;
     const isTemplateRef = templateRefNames?.has(curVar.text) ?? false;
     if (isTemplateRef) {
         yield [`__VLS_unref(`, undefined];
-        yield [code.substring(curVar.offset, curVar.offset + curVar.text.length), curVar.offset];
+        yield [code.slice(curVar.offset, curVar.offset + curVar.text.length), curVar.offset];
         yield [`)`, undefined];
     }
     else {
-        if (!isDestructuredProp) {
+        if (specialVars.has(curVar.text)) {
+            yield [`__VLS_special.`, undefined];
+        }
+        else if (!isDestructuredProp) {
             yield [`__VLS_ctx.`, undefined];
         }
-        yield [code.substring(curVar.offset, curVar.offset + curVar.text.length), curVar.offset];
+        yield [code.slice(curVar.offset, curVar.offset + curVar.text.length), curVar.offset];
     }
 }
 function walkIdentifiers(ts, node, ast, cb, ctx, blockVars = [], isRoot = true) {
@@ -135,7 +138,7 @@ function walkIdentifiers(ts, node, ast, cb, ctx, blockVars = [], isRoot = true)
         walkIdentifiers(ts, node.expression, ast, cb, ctx, blockVars, false);
     }
     else if (ts.isVariableDeclaration(node)) {
-        (0, common_1.collectVars)(ts, node.name, ast, blockVars);
+        (0, utils_1.collectVars)(ts, node.name, ast, blockVars);
         for (const varName of blockVars) {
             ctx.addLocalVariable(varName);
         }
@@ -196,7 +199,7 @@ function walkIdentifiers(ts, node, ast, cb, ctx, blockVars = [], isRoot = true)
 function processFunction(ts, node, ast, cb, ctx) {
     const functionArgs = [];
     for (const param of node.parameters) {
-        (0, common_1.collectVars)(ts, param.name, ast, functionArgs);
+        (0, utils_1.collectVars)(ts, param.name, ast, functionArgs);
         if (param.type) {
             walkIdentifiers(ts, param.type, ast, cb, ctx);
         }

package/lib/codegen/template/objectProperty.js

@@ -2,29 +2,29 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateObjectProperty = generateObjectProperty;
 const shared_1 = require("@vue/shared");
-const common_1 = require("../common");
-const camelized_1 = require("./camelized");
+const utils_1 = require("../utils");
+const camelized_1 = require("../utils/camelized");
+const stringLiteralKey_1 = require("../utils/stringLiteralKey");
 const interpolation_1 = require("./interpolation");
-const stringLiteralKey_1 = require("./stringLiteralKey");
 function* generateObjectProperty(options, ctx, code, offset, features, astHolder, shouldCamelize = false, shouldBeConstant = false) {
     if (code.startsWith('[') && code.endsWith(']') && astHolder) {
         if (shouldBeConstant) {
-            yield* (0, interpolation_1.generateInterpolation)(options, ctx, code.slice(1, -1), astHolder, offset + 1, features, `[__VLS_tryAsConstant(`, `)]`);
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', features, code.slice(1, -1), offset + 1, astHolder, `[__VLS_tryAsConstant(`, `)]`);
         }
         else {
-            yield* (0, interpolation_1.generateInterpolation)(options, ctx, code, astHolder, offset, features, '', '');
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', features, code, offset, astHolder);
         }
     }
     else if (shouldCamelize) {
-        if (common_1.variableNameRegex.test((0, shared_1.camelize)(code))) {
+        if (utils_1.variableNameRegex.test((0, shared_1.camelize)(code))) {
             yield* (0, camelized_1.generateCamelized)(code, offset, features);
         }
         else {
-            yield* (0, common_1.wrapWith)(offset, offset + code.length, features, `"`, ...(0, camelized_1.generateCamelized)(code, offset, common_1.combineLastMapping), `"`);
+            yield* (0, utils_1.wrapWith)(offset, offset + code.length, features, `'`, ...(0, camelized_1.generateCamelized)(code, offset, utils_1.combineLastMapping), `'`);
         }
     }
     else {
-        if (common_1.variableNameRegex.test(code)) {
+        if (utils_1.variableNameRegex.test(code)) {
             yield [code, 'template', offset, features];
         }
         else {

package/lib/codegen/template/propertyAccess.js

@@ -1,18 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generatePropertyAccess = generatePropertyAccess;
-const common_1 = require("../common");
+const utils_1 = require("../utils");
+const stringLiteralKey_1 = require("../utils/stringLiteralKey");
 const interpolation_1 = require("./interpolation");
-const stringLiteralKey_1 = require("./stringLiteralKey");
 function* generatePropertyAccess(options, ctx, code, offset, features, astHolder) {
-    if (!options.compilerOptions.noPropertyAccessFromIndexSignature && common_1.variableNameRegex.test(code)) {
+    if (!options.compilerOptions.noPropertyAccessFromIndexSignature && utils_1.variableNameRegex.test(code)) {
         yield `.`;
         yield offset !== undefined && features
             ? [code, 'template', offset, features]
             : code;
     }
     else if (code.startsWith('[') && code.endsWith(']')) {
-        yield* (0, interpolation_1.generateInterpolation)(options, ctx, code, astHolder, offset, features, '', '');
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', features, code, offset, astHolder);
     }
     else {
         yield `[`;

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

@@ -2,4 +2,4 @@ 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 generateSlotOutlet(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.SlotOutletNode, currentComponent: CompilerDOM.ElementNode | undefined, componentCtxVar: string | undefined): Generator<Code>;
+export declare function generateSlotOutlet(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.SlotOutletNode): Generator<Code>;

package/lib/codegen/template/slotOutlet.js

@@ -2,14 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateSlotOutlet = generateSlotOutlet;
 const CompilerDOM = require("@vue/compiler-dom");
-const common_1 = require("../common");
+const inlayHints_1 = require("../inlayHints");
+const utils_1 = require("../utils");
 const elementChildren_1 = require("./elementChildren");
 const elementProps_1 = require("./elementProps");
 const interpolation_1 = require("./interpolation");
-const inlayHints_1 = require("../inlayHints");
-function* generateSlotOutlet(options, ctx, node, currentComponent, componentCtxVar) {
-    const startTagOffset = node.loc.start.offset + options.template.content.substring(node.loc.start.offset).indexOf(node.tag);
-    const varSlot = ctx.getInternalVariable();
+const propertyAccess_1 = require("./propertyAccess");
+function* generateSlotOutlet(options, ctx, node) {
+    const startTagOffset = node.loc.start.offset + options.template.content.slice(node.loc.start.offset).indexOf(node.tag);
+    const propsVar = ctx.getInternalVariable();
     const nameProp = node.props.find(prop => {
         if (prop.type === CompilerDOM.NodeTypes.ATTRIBUTE) {
             return prop.name === 'name';
@@ -22,27 +23,48 @@ function* generateSlotOutlet(options, ctx, node, currentComponent, componentCtxV
     });
     if (options.hasDefineSlots) {
         yield `__VLS_normalizeSlot(`;
-        yield* (0, common_1.wrapWith)(node.loc.start.offset, node.loc.end.offset, ctx.codeFeatures.verification, `${options.slotsAssignName ?? '__VLS_slots'}[`, ...(0, common_1.wrapWith)(node.loc.start.offset, node.loc.end.offset, ctx.codeFeatures.verification, nameProp?.type === CompilerDOM.NodeTypes.ATTRIBUTE && nameProp.value
-            ? `'${nameProp.value.content}'`
-            : nameProp?.type === CompilerDOM.NodeTypes.DIRECTIVE && nameProp.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
-                ? nameProp.exp.content
-                : `('default' as const)`), `]`);
+        if (nameProp) {
+            let codes;
+            if (nameProp.type === CompilerDOM.NodeTypes.ATTRIBUTE && nameProp.value) {
+                let { source, start: { offset } } = nameProp.value.loc;
+                if (source.startsWith('"') || source.startsWith("'")) {
+                    source = source.slice(1, -1);
+                    offset++;
+                }
+                codes = (0, propertyAccess_1.generatePropertyAccess)(options, ctx, source, offset, ctx.codeFeatures.navigationAndVerification);
+            }
+            else if (nameProp.type === CompilerDOM.NodeTypes.DIRECTIVE
+                && nameProp.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+                codes = [
+                    `[`,
+                    ...(0, elementProps_1.generatePropExp)(options, ctx, nameProp, nameProp.exp, ctx.codeFeatures.all, true),
+                    `]`
+                ];
+            }
+            else {
+                codes = [`['default']`];
+            }
+            yield* (0, utils_1.wrapWith)(nameProp.loc.start.offset, nameProp.loc.end.offset, ctx.codeFeatures.verification, `${options.slotsAssignName ?? '__VLS_slots'}`, ...codes);
+        }
+        else {
+            yield* (0, utils_1.wrapWith)(node.loc.start.offset, node.loc.end.offset, ctx.codeFeatures.verification, `${options.slotsAssignName ?? '__VLS_slots'}['default']`);
+        }
         yield `)?.(`;
-        yield* (0, common_1.wrapWith)(startTagOffset, startTagOffset + node.tag.length, ctx.codeFeatures.verification, `{${common_1.newLine}`, ...(0, elementProps_1.generateElementProps)(options, ctx, node, node.props.filter(prop => prop !== nameProp), true), `}`);
-        yield `)${common_1.endOfLine}`;
+        yield* (0, utils_1.wrapWith)(startTagOffset, startTagOffset + node.tag.length, ctx.codeFeatures.verification, `{${utils_1.newLine}`, ...(0, elementProps_1.generateElementProps)(options, ctx, node, node.props.filter(prop => prop !== nameProp), true, true), `}`);
+        yield `)${utils_1.endOfLine}`;
     }
     else {
-        yield `var ${varSlot} = {${common_1.newLine}`;
-        yield* (0, elementProps_1.generateElementProps)(options, ctx, node, node.props.filter(prop => prop !== nameProp), true);
-        yield `}${common_1.endOfLine}`;
+        yield `var ${propsVar} = {${utils_1.newLine}`;
+        yield* (0, elementProps_1.generateElementProps)(options, ctx, node, node.props.filter(prop => prop !== nameProp), options.vueCompilerOptions.checkUnknownProps, true);
+        yield `}${utils_1.endOfLine}`;
         if (nameProp?.type === CompilerDOM.NodeTypes.ATTRIBUTE
             && nameProp.value) {
             ctx.slots.push({
                 name: nameProp.value.content,
-                loc: nameProp.loc.start.offset + nameProp.loc.source.indexOf(nameProp.value.content, nameProp.name.length),
+                offset: nameProp.loc.start.offset + nameProp.loc.source.indexOf(nameProp.value.content, nameProp.name.length),
                 tagRange: [startTagOffset, startTagOffset + node.tag.length],
-                varName: varSlot,
                 nodeLoc: node.loc,
+                propsVar,
             });
         }
         else if (nameProp?.type === CompilerDOM.NodeTypes.DIRECTIVE
@@ -51,25 +73,25 @@ function* generateSlotOutlet(options, ctx, node, currentComponent, componentCtxV
             if (isShortHand) {
                 ctx.inlayHints.push((0, inlayHints_1.createVBindShorthandInlayHintInfo)(nameProp.exp.loc, 'name'));
             }
-            const slotExpVar = ctx.getInternalVariable();
-            yield `var ${slotExpVar} = `;
-            yield* (0, interpolation_1.generateInterpolation)(options, ctx, nameProp.exp.content, nameProp.exp, nameProp.exp.loc.start.offset, ctx.codeFeatures.all, '(', ')');
-            yield ` as const${common_1.endOfLine}`;
+            const expVar = ctx.getInternalVariable();
+            yield `var ${expVar} = __VLS_tryAsConstant(`;
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, nameProp.exp.content, nameProp.exp.loc.start.offset, nameProp.exp);
+            yield `)${utils_1.endOfLine}`;
             ctx.dynamicSlots.push({
-                expVar: slotExpVar,
-                varName: varSlot,
+                expVar,
+                propsVar,
             });
         }
         else {
             ctx.slots.push({
                 name: 'default',
                 tagRange: [startTagOffset, startTagOffset + node.tag.length],
-                varName: varSlot,
                 nodeLoc: node.loc,
+                propsVar,
             });
         }
     }
     yield* ctx.generateAutoImportCompletion();
-    yield* (0, elementChildren_1.generateElementChildren)(options, ctx, node, currentComponent, componentCtxVar);
+    yield* (0, elementChildren_1.generateElementChildren)(options, ctx, node);
 }
 //# sourceMappingURL=slotOutlet.js.map

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

@@ -1,3 +1,6 @@
+import * as CompilerDOM from '@vue/compiler-dom';
 import type { Code } from '../../types';
 import type { TemplateCodegenContext } from './context';
-export declare function generateStyleScopedClasses(ctx: TemplateCodegenContext, withDot?: boolean): Generator<Code>;
+import type { TemplateCodegenOptions } from './index';
+export declare function generateStyleScopedClassReferences(ctx: TemplateCodegenContext, withDot?: boolean): Generator<Code>;
+export declare function collectStyleScopedClassReferences(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode): void;

package/lib/codegen/template/styleScopedClasses.js

@@ -1,20 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateStyleScopedClasses = generateStyleScopedClasses;
-const common_1 = require("../common");
-function* generateStyleScopedClasses(ctx, withDot = false) {
+exports.generateStyleScopedClassReferences = generateStyleScopedClassReferences;
+exports.collectStyleScopedClassReferences = collectStyleScopedClassReferences;
+const CompilerDOM = require("@vue/compiler-dom");
+const scriptSetupRanges_1 = require("../../parsers/scriptSetupRanges");
+const utils_1 = require("../utils");
+function* generateStyleScopedClassReferences(ctx, withDot = false) {
+    if (!ctx.emptyClassOffsets.length && !ctx.scopedClasses.length) {
+        return;
+    }
+    yield `[`;
     for (const offset of ctx.emptyClassOffsets) {
-        yield `__VLS_styleScopedClasses['`;
+        yield `'`;
         yield [
             '',
             'template',
             offset,
             ctx.codeFeatures.additionalCompletion,
         ];
-        yield `']${common_1.endOfLine}`;
+        yield `', `;
     }
     for (const { source, className, offset } of ctx.scopedClasses) {
-        yield `__VLS_styleScopedClasses[`;
         yield [
             '',
             source,
@@ -31,9 +37,9 @@ function* generateStyleScopedClasses(ctx, withDot = false) {
             offset + className.length,
             ctx.codeFeatures.navigationWithoutRename,
         ];
-        yield `]${common_1.endOfLine}`;
+        yield `, `;
     }
-    yield common_1.newLine;
+    yield `] as (keyof __VLS_StyleScopedClasses)[]${utils_1.endOfLine}`;
     function* escapeString(source, className, offset, escapeTargets) {
         let count = 0;
         const currentEscapeTargets = [...escapeTargets];
@@ -69,4 +75,142 @@ function* generateStyleScopedClasses(ctx, withDot = false) {
         }
     }
 }
+function collectStyleScopedClassReferences(options, ctx, node) {
+    for (const prop of node.props) {
+        if (prop.type === CompilerDOM.NodeTypes.ATTRIBUTE
+            && prop.name === 'class'
+            && prop.value) {
+            if (options.template.lang === 'pug') {
+                const getClassOffset = Reflect.get(prop.value.loc.start, 'getClassOffset');
+                const content = prop.value.loc.source.slice(1, -1);
+                let startOffset = 1;
+                for (const className of content.split(' ')) {
+                    if (className) {
+                        ctx.scopedClasses.push({
+                            source: 'template',
+                            className,
+                            offset: getClassOffset(startOffset),
+                        });
+                    }
+                    startOffset += className.length + 1;
+                }
+            }
+            else {
+                let isWrapped = false;
+                const [content, startOffset] = (0, utils_1.normalizeAttributeValue)(prop.value);
+                if (content) {
+                    const classes = collectClasses(content, startOffset + (isWrapped ? 1 : 0));
+                    ctx.scopedClasses.push(...classes);
+                }
+                else {
+                    ctx.emptyClassOffsets.push(startOffset);
+                }
+            }
+        }
+        else if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+            && prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
+            && prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
+            && prop.arg.content === 'class') {
+            const content = '`${' + prop.exp.content + '}`';
+            const startOffset = prop.exp.loc.start.offset - 3;
+            const { ts } = options;
+            const ast = ts.createSourceFile('', content, 99);
+            const literals = [];
+            ts.forEachChild(ast, node => {
+                if (!ts.isExpressionStatement(node) ||
+                    !isTemplateExpression(node.expression)) {
+                    return;
+                }
+                const expression = node.expression.templateSpans[0].expression;
+                if (ts.isStringLiteralLike(expression)) {
+                    literals.push(expression);
+                }
+                if (ts.isArrayLiteralExpression(expression)) {
+                    walkArrayLiteral(expression);
+                }
+                if (ts.isObjectLiteralExpression(expression)) {
+                    walkObjectLiteral(expression);
+                }
+            });
+            for (const literal of literals) {
+                if (literal.text) {
+                    const classes = collectClasses(literal.text, literal.end - literal.text.length - 1 + startOffset);
+                    ctx.scopedClasses.push(...classes);
+                }
+                else {
+                    ctx.emptyClassOffsets.push(literal.end - 1 + startOffset);
+                }
+            }
+            function walkArrayLiteral(node) {
+                const { elements } = node;
+                for (const element of elements) {
+                    if (ts.isStringLiteralLike(element)) {
+                        literals.push(element);
+                    }
+                    else if (ts.isObjectLiteralExpression(element)) {
+                        walkObjectLiteral(element);
+                    }
+                }
+            }
+            function walkObjectLiteral(node) {
+                const { properties } = node;
+                for (const property of properties) {
+                    if (ts.isPropertyAssignment(property)) {
+                        const { name } = property;
+                        if (ts.isIdentifier(name)) {
+                            walkIdentifier(name);
+                        }
+                        else if (ts.isStringLiteral(name)) {
+                            literals.push(name);
+                        }
+                        else if (ts.isComputedPropertyName(name)) {
+                            const { expression } = name;
+                            if (ts.isStringLiteralLike(expression)) {
+                                literals.push(expression);
+                            }
+                        }
+                    }
+                    else if (ts.isShorthandPropertyAssignment(property)) {
+                        walkIdentifier(property.name);
+                    }
+                }
+            }
+            function walkIdentifier(node) {
+                const text = (0, scriptSetupRanges_1.getNodeText)(ts, node, ast);
+                ctx.scopedClasses.push({
+                    source: 'template',
+                    className: text,
+                    offset: node.end - text.length + startOffset
+                });
+            }
+        }
+    }
+}
+function collectClasses(content, startOffset = 0) {
+    const classes = [];
+    let currentClassName = '';
+    let offset = 0;
+    for (const char of (content + ' ')) {
+        if (char.trim() === '') {
+            if (currentClassName !== '') {
+                classes.push({
+                    source: 'template',
+                    className: currentClassName,
+                    offset: offset + startOffset
+                });
+                offset += currentClassName.length;
+                currentClassName = '';
+            }
+            offset += char.length;
+        }
+        else {
+            currentClassName += char;
+        }
+    }
+    return classes;
+}
+// isTemplateExpression is missing in tsc
+function isTemplateExpression(node) {
+    return node.kind === 228;
+}
 //# sourceMappingURL=styleScopedClasses.js.map

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

@@ -2,6 +2,6 @@ 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, currentComponent: CompilerDOM.ElementNode | undefined, prevNode: CompilerDOM.TemplateChildNode | undefined, componentCtxVar: string | undefined, isVForChild?: boolean): Generator<Code>;
+export declare function generateTemplateChild(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode | CompilerDOM.SimpleExpressionNode, prevNode: CompilerDOM.TemplateChildNode | undefined, isVForChild?: boolean): Generator<Code>;
 export declare function getVForNode(node: CompilerDOM.ElementNode): CompilerDOM.ForNode | undefined;
 export declare function parseInterpolationNode(node: CompilerDOM.InterpolationNode, template: string): readonly [string, number];