@vue/language-core 2.2.0 → 2.2.2

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

@@ -4,37 +4,42 @@ import { InlayHintInfo } from '../inlayHints';
 import type { TemplateCodegenOptions } from './index';
 export type TemplateCodegenContext = ReturnType<typeof createTemplateCodegenContext>;
 export declare function createTemplateCodegenContext(options: Pick<TemplateCodegenOptions, 'scriptSetupBindingNames' | 'edited'>): {
-    slots: {
-        name: string;
-        loc?: number;
-        tagRange: [number, number];
-        varName: string;
-        nodeLoc: any;
-    }[];
-    dynamicSlots: {
-        expVar: string;
-        varName: string;
-    }[];
     codeFeatures: {
         all: VueCodeInformation;
+        none: VueCodeInformation;
         verification: VueCodeInformation;
         completion: VueCodeInformation;
         additionalCompletion: VueCodeInformation;
+        withoutCompletion: VueCodeInformation;
         navigation: VueCodeInformation;
         navigationWithoutRename: VueCodeInformation;
         navigationAndCompletion: VueCodeInformation;
         navigationAndAdditionalCompletion: VueCodeInformation;
+        navigationAndVerification: VueCodeInformation;
         withoutNavigation: VueCodeInformation;
         withoutHighlight: VueCodeInformation;
+        withoutHighlightAndNavigation: VueCodeInformation;
         withoutHighlightAndCompletion: VueCodeInformation;
         withoutHighlightAndCompletionAndNavigation: VueCodeInformation;
     };
+    resolveCodeFeatures: (features: VueCodeInformation) => VueCodeInformation;
+    slots: {
+        name: string;
+        offset?: number;
+        tagRange: [number, number];
+        nodeLoc: any;
+        propsVar: string;
+    }[];
+    dynamicSlots: {
+        expVar: string;
+        propsVar: string;
+    }[];
+    specialVars: Set<string>;
     accessExternalVariables: Map<string, Set<number>>;
     lastGenericComment: {
         content: string;
         offset: number;
     } | undefined;
-    hasSlotElements: Set<CompilerDOM.ElementNode>;
     blockConditions: string[];
     scopedClasses: {
         source: string;
@@ -48,7 +53,6 @@ export declare function createTemplateCodegenContext(options: Pick<TemplateCodeg
     inheritedAttrVars: Set<string>;
     templateRefs: Map<string, [varName: string, offset: number]>;
     currentComponent: {
-        node: CompilerDOM.ElementNode;
         ctxVar: string;
         used: boolean;
     } | undefined;

package/lib/codegen/template/context.js

@@ -1,101 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTemplateCodegenContext = createTemplateCodegenContext;
+const codeFeatures_1 = require("../codeFeatures");
 const utils_1 = require("../utils");
-const _codeFeatures = {
-    all: {
-        verification: true,
-        completion: true,
-        semantic: true,
-        navigation: true,
-    },
-    verification: {
-        verification: true,
-    },
-    completion: {
-        completion: true,
-    },
-    additionalCompletion: {
-        completion: { isAdditional: true },
-    },
-    navigation: {
-        navigation: true,
-    },
-    navigationWithoutRename: {
-        navigation: {
-            shouldRename() {
-                return false;
-            },
-        },
-    },
-    navigationAndCompletion: {
-        navigation: true,
-        completion: true,
-    },
-    navigationAndAdditionalCompletion: {
-        navigation: true,
-        completion: { isAdditional: true },
-    },
-    withoutNavigation: {
-        verification: true,
-        completion: true,
-        semantic: true,
-    },
-    withoutHighlight: {
-        semantic: { shouldHighlight: () => false },
-        verification: true,
-        navigation: true,
-        completion: true,
-    },
-    withoutHighlightAndCompletion: {
-        semantic: { shouldHighlight: () => false },
-        verification: true,
-        navigation: true,
-    },
-    withoutHighlightAndCompletionAndNavigation: {
-        semantic: { shouldHighlight: () => false },
-        verification: true,
-    },
-};
 function createTemplateCodegenContext(options) {
     let ignoredError = false;
     let expectErrorToken;
     let lastGenericComment;
     let variableId = 0;
-    const codeFeatures = new Proxy(_codeFeatures, {
-        get(target, key) {
-            const data = target[key];
-            if (data.verification) {
-                if (ignoredError) {
-                    return {
-                        ...data,
-                        verification: false,
-                    };
-                }
-                if (expectErrorToken) {
-                    const token = expectErrorToken;
-                    if (typeof data.verification !== 'object' || !data.verification.shouldReport) {
-                        return {
-                            ...data,
-                            verification: {
-                                shouldReport: () => {
-                                    token.errors++;
-                                    return false;
-                                },
-                            },
-                        };
-                    }
-                }
+    function resolveCodeFeatures(features) {
+        if (features.verification) {
+            if (ignoredError) {
+                return {
+                    ...features,
+                    verification: false,
+                };
             }
-            return data;
-        },
-    });
+            if (expectErrorToken) {
+                const token = expectErrorToken;
+                return {
+                    ...features,
+                    verification: {
+                        shouldReport: () => {
+                            token.errors++;
+                            return false;
+                        },
+                    },
+                };
+            }
+        }
+        return features;
+    }
     const localVars = new Map();
+    const specialVars = new Set();
     const accessExternalVariables = new Map();
     const slots = [];
     const dynamicSlots = [];
-    const hasSlotElements = new Set();
-    ;
     const blockConditions = [];
     const scopedClasses = [];
     const emptyClassOffsets = [];
@@ -104,12 +44,18 @@ function createTemplateCodegenContext(options) {
     const inheritedAttrVars = new Set();
     const templateRefs = new Map();
     return {
+        codeFeatures: new Proxy(codeFeatures_1.codeFeatures, {
+            get(target, key) {
+                const data = target[key];
+                return resolveCodeFeatures(data);
+            },
+        }),
+        resolveCodeFeatures,
         slots,
         dynamicSlots,
-        codeFeatures,
+        specialVars,
         accessExternalVariables,
         lastGenericComment,
-        hasSlotElements,
         blockConditions,
         scopedClasses,
         emptyClassOffsets,
@@ -193,8 +139,8 @@ function createTemplateCodegenContext(options) {
                             'template',
                             offset,
                             {
-                                ...codeFeatures.additionalCompletion,
-                                ...codeFeatures.withoutHighlightAndCompletionAndNavigation,
+                                ...codeFeatures_1.codeFeatures.additionalCompletion,
+                                ...codeFeatures_1.codeFeatures.withoutHighlightAndCompletionAndNavigation,
                             },
                         ];
                     }
@@ -203,7 +149,7 @@ function createTemplateCodegenContext(options) {
                             varName,
                             'template',
                             offset,
-                            codeFeatures.additionalCompletion,
+                            codeFeatures_1.codeFeatures.additionalCompletion,
                         ];
                     }
                     yield `,`;

package/lib/codegen/template/element.js

@@ -4,7 +4,6 @@ exports.generateComponent = generateComponent;
 exports.generateElement = generateElement;
 const CompilerDOM = require("@vue/compiler-dom");
 const shared_1 = require("@vue/shared");
-const scriptSetupRanges_1 = require("../../parsers/scriptSetupRanges");
 const shared_2 = require("../../utils/shared");
 const inlayHints_1 = require("../inlayHints");
 const utils_1 = require("../utils");
@@ -14,9 +13,9 @@ const elementDirectives_1 = require("./elementDirectives");
 const elementEvents_1 = require("./elementEvents");
 const elementProps_1 = require("./elementProps");
 const interpolation_1 = require("./interpolation");
-const objectProperty_1 = require("./objectProperty");
 const propertyAccess_1 = require("./propertyAccess");
-const templateChild_1 = require("./templateChild");
+const styleScopedClasses_1 = require("./styleScopedClasses");
+const vSlot_1 = require("./vSlot");
 const colonReg = /:/g;
 function* generateComponent(options, ctx, node) {
     const tagOffsets = [node.loc.start.offset + options.template.content.slice(node.loc.start.offset).indexOf(node.tag)];
@@ -37,7 +36,6 @@ function* generateComponent(options, ctx, node) {
     const var_defineComponentCtx = ctx.getInternalVariable();
     const isComponentTag = node.tag.toLowerCase() === 'component';
     ctx.currentComponent = {
-        node,
         ctxVar: var_defineComponentCtx,
         used: false
     };
@@ -103,15 +101,20 @@ function* generateComponent(options, ctx, node) {
         yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, dynamicTagInfo.tag, dynamicTagInfo.offsets[0], dynamicTagInfo.astHolder, '(', ')');
         if (dynamicTagInfo.offsets[1] !== undefined) {
             yield `,`;
-            yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', {
-                ...ctx.codeFeatures.all,
-                completion: false,
-            }, dynamicTagInfo.tag, dynamicTagInfo.offsets[1], dynamicTagInfo.astHolder, '(', ')');
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.withoutCompletion, dynamicTagInfo.tag, dynamicTagInfo.offsets[1], dynamicTagInfo.astHolder, '(', ')');
         }
         yield `)${utils_1.endOfLine}`;
     }
     else if (!isComponentTag) {
         yield `const ${var_originalComponent} = ({} as __VLS_WithComponent<'${getCanonicalComponentName(node.tag)}', __VLS_LocalComponents, `;
+        if (options.selfComponentName && possibleOriginalNames.includes(options.selfComponentName)) {
+            yield `typeof __VLS_self & (new () => { `
+                + (0, shared_2.getSlotsPropertyName)(options.vueCompilerOptions.target)
+                + `: __VLS_Slots }), `;
+        }
+        else {
+            yield `void, `;
+        }
         yield getPossibleOriginalComponentNames(node.tag, false)
             .map(name => `'${name}'`)
             .join(`, `);
@@ -154,20 +157,20 @@ function* generateComponent(options, ctx, node) {
     }
     yield `// @ts-ignore${utils_1.newLine}`;
     yield `const ${var_functionalComponent} = __VLS_asFunctionalComponent(${var_originalComponent}, new ${var_originalComponent}({${utils_1.newLine}`;
-    yield* (0, elementProps_1.generateElementProps)(options, ctx, node, props, options.vueCompilerOptions.strictTemplates, false);
+    yield* (0, elementProps_1.generateElementProps)(options, ctx, node, props, options.vueCompilerOptions.checkUnknownProps, false);
     yield `}))${utils_1.endOfLine}`;
     yield `const `;
-    yield* (0, utils_1.wrapWith)(node.loc.start.offset, node.loc.end.offset, {
+    yield* (0, utils_1.wrapWith)(node.loc.start.offset, node.loc.end.offset, ctx.resolveCodeFeatures({
         verification: {
             shouldReport(_source, code) {
                 return String(code) !== '6133';
             },
         }
-    }, var_componentInstance);
+    }), var_componentInstance);
     yield ` = ${var_functionalComponent}`;
     yield* generateComponentGeneric(ctx);
     yield `(`;
-    yield* (0, utils_1.wrapWith)(tagOffsets[0], tagOffsets[0] + node.tag.length, ctx.codeFeatures.verification, `{${utils_1.newLine}`, ...(0, elementProps_1.generateElementProps)(options, ctx, node, props, options.vueCompilerOptions.strictTemplates, true, failedPropExps), `}`);
+    yield* (0, utils_1.wrapWith)(tagOffsets[0], tagOffsets[0] + node.tag.length, ctx.codeFeatures.verification, `{${utils_1.newLine}`, ...(0, elementProps_1.generateElementProps)(options, ctx, node, props, options.vueCompilerOptions.checkUnknownProps, true, failedPropExps), `}`);
     yield `, ...__VLS_functionalComponentArgsRest(${var_functionalComponent}))${utils_1.endOfLine}`;
     yield* generateFailedPropExps(options, ctx, failedPropExps);
     const [refName, offset] = yield* generateVScope(options, ctx, node, props);
@@ -195,19 +198,17 @@ function* generateComponent(options, ctx, node) {
         yield `let ${var_componentEmit}!: typeof ${var_defineComponentCtx}.emit${utils_1.endOfLine}`;
         yield `let ${var_componentEvents}!: __VLS_NormalizeEmits<typeof ${var_componentEmit}>${utils_1.endOfLine}`;
     }
-    if (options.vueCompilerOptions.fallthroughAttributes
-        && (node.props.some(prop => prop.type === CompilerDOM.NodeTypes.DIRECTIVE && prop.name === 'bind' && prop.exp?.loc.source === '$attrs')
-            || node === ctx.singleRootNode)) {
-        const varAttrs = ctx.getInternalVariable();
-        ctx.inheritedAttrVars.add(varAttrs);
-        yield `var ${varAttrs}!: Parameters<typeof ${var_functionalComponent}>[0];\n`;
+    if (hasVBindAttrs(options, ctx, node)) {
+        const attrsVar = ctx.getInternalVariable();
+        ctx.inheritedAttrVars.add(attrsVar);
+        yield `let ${attrsVar}!: Parameters<typeof ${var_functionalComponent}>[0];\n`;
     }
     const slotDir = node.props.find(p => p.type === CompilerDOM.NodeTypes.DIRECTIVE && p.name === 'slot');
     if (slotDir) {
-        yield* generateComponentSlot(options, ctx, node, slotDir);
+        yield* (0, vSlot_1.generateVSlot)(options, ctx, node, slotDir);
     }
     else {
-        yield* (0, elementChildren_1.generateElementChildren)(options, ctx, node);
+        yield* (0, elementChildren_1.generateElementChildren)(options, ctx, node, true);
     }
     if (ctx.currentComponent.used) {
         yield `var ${var_defineComponentCtx}!: __VLS_PickFunctionalComponentCtx<typeof ${var_originalComponent}, typeof ${var_componentInstance}>${utils_1.endOfLine}`;
@@ -219,14 +220,14 @@ function* generateElement(options, ctx, node, isVForChild) {
         ? node.loc.start.offset + node.loc.source.lastIndexOf(node.tag)
         : undefined;
     const failedPropExps = [];
-    yield `__VLS_elementAsFunction(__VLS_intrinsicElements`;
+    yield `__VLS_asFunctionalElement(__VLS_intrinsicElements`;
     yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, node.tag, startTagOffset, ctx.codeFeatures.withoutHighlightAndCompletion);
     if (endTagOffset !== undefined) {
         yield `, __VLS_intrinsicElements`;
         yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, node.tag, endTagOffset, ctx.codeFeatures.withoutHighlightAndCompletion);
     }
     yield `)(`;
-    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, options.vueCompilerOptions.strictTemplates, true, failedPropExps), `}`);
+    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, options.vueCompilerOptions.checkUnknownProps, true, failedPropExps), `}`);
     yield `)${utils_1.endOfLine}`;
     yield* generateFailedPropExps(options, ctx, failedPropExps);
     const [refName, offset] = yield* generateVScope(options, ctx, node, node.props);
@@ -240,18 +241,10 @@ function* generateElement(options, ctx, node, isVForChild) {
     if (ctx.singleRootNode === node) {
         ctx.singleRootElType = `typeof __VLS_nativeElements['${node.tag}']`;
     }
-    const slotDir = node.props.find(p => p.type === CompilerDOM.NodeTypes.DIRECTIVE && p.name === 'slot');
-    if (slotDir && ctx.currentComponent) {
-        yield* generateComponentSlot(options, ctx, node, slotDir);
-    }
-    else {
-        yield* (0, elementChildren_1.generateElementChildren)(options, ctx, node);
-    }
-    if (options.vueCompilerOptions.fallthroughAttributes
-        && (node.props.some(prop => prop.type === CompilerDOM.NodeTypes.DIRECTIVE && prop.name === 'bind' && prop.exp?.loc.source === '$attrs')
-            || node === ctx.singleRootNode)) {
+    if (hasVBindAttrs(options, ctx, node)) {
         ctx.inheritedAttrVars.add(`__VLS_intrinsicElements.${node.tag}`);
     }
+    yield* (0, elementChildren_1.generateElementChildren)(options, ctx, node);
 }
 function* generateFailedPropExps(options, ctx, failedPropExps) {
     for (const failedExp of failedPropExps) {
@@ -280,7 +273,7 @@ function* generateVScope(options, ctx, node, props) {
     }
     yield* (0, elementDirectives_1.generateElementDirectives)(options, ctx, node);
     const [refName, offset] = yield* generateReferencesForElements(options, ctx, node); // <el ref="foo" />
-    yield* generateReferencesForScopedCssClasses(options, ctx, node);
+    (0, styleScopedClasses_1.collectStyleScopedClassReferences)(options, ctx, node);
     if (inScope) {
         yield `}${utils_1.newLine}`;
         ctx.blockConditions.length = originalConditionsNum;
@@ -325,83 +318,12 @@ function* generateComponentGeneric(ctx) {
     }
     ctx.lastGenericComment = undefined;
 }
-function* generateComponentSlot(options, ctx, node, slotDir) {
-    yield `{${utils_1.newLine}`;
-    if (ctx.currentComponent) {
-        ctx.currentComponent.used = true;
-        ctx.hasSlotElements.add(ctx.currentComponent.node);
-    }
-    const slotBlockVars = [];
-    yield `const {`;
-    if (slotDir?.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && slotDir.arg.content) {
-        yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, slotDir.arg.loc.source, slotDir.arg.loc.start.offset, slotDir.arg.isStatic ? ctx.codeFeatures.withoutHighlight : ctx.codeFeatures.all, slotDir.arg.loc, false, true);
-    }
-    else {
-        yield* (0, utils_1.wrapWith)(slotDir.loc.start.offset, slotDir.loc.start.offset + (slotDir.rawName?.length ?? 0), ctx.codeFeatures.withoutHighlightAndCompletion, `default`);
-    }
-    yield `: __VLS_thisSlot } = ${ctx.currentComponent.ctxVar}.slots!${utils_1.endOfLine}`;
-    if (slotDir?.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
-        const slotAst = (0, utils_1.createTsAst)(options.ts, slotDir, `(${slotDir.exp.content}) => {}`);
-        (0, utils_1.collectVars)(options.ts, slotAst, slotAst, slotBlockVars);
-        if (!slotDir.exp.content.includes(':')) {
-            yield `const [`;
-            yield [
-                slotDir.exp.content,
-                'template',
-                slotDir.exp.loc.start.offset,
-                ctx.codeFeatures.all,
-            ];
-            yield `] = __VLS_getSlotParams(__VLS_thisSlot)${utils_1.endOfLine}`;
-        }
-        else {
-            yield `const `;
-            yield [
-                slotDir.exp.content,
-                'template',
-                slotDir.exp.loc.start.offset,
-                ctx.codeFeatures.all,
-            ];
-            yield ` = __VLS_getSlotParam(__VLS_thisSlot)${utils_1.endOfLine}`;
-        }
-    }
-    for (const varName of slotBlockVars) {
-        ctx.addLocalVariable(varName);
-    }
-    yield* ctx.resetDirectiveComments('end of slot children start');
-    let prev;
-    for (const childNode of node.children) {
-        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, prev);
-        prev = childNode;
-    }
-    for (const varName of slotBlockVars) {
-        ctx.removeLocalVariable(varName);
-    }
-    let isStatic = true;
-    if (slotDir?.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
-        isStatic = slotDir.arg.isStatic;
-    }
-    if (isStatic && slotDir && !slotDir.arg) {
-        yield `${ctx.currentComponent.ctxVar}.slots!['`;
-        yield [
-            '',
-            'template',
-            slotDir.loc.start.offset + (slotDir.loc.source.startsWith('#')
-                ? '#'.length : slotDir.loc.source.startsWith('v-slot:')
-                ? 'v-slot:'.length
-                : 0),
-            ctx.codeFeatures.completion,
-        ];
-        yield `'/* empty slot name completion */]${utils_1.newLine}`;
-    }
-    yield* ctx.generateAutoImportCompletion();
-    yield `}${utils_1.newLine}`;
-}
 function* generateReferencesForElements(options, ctx, node) {
     for (const prop of node.props) {
         if (prop.type === CompilerDOM.NodeTypes.ATTRIBUTE
             && prop.name === 'ref'
             && prop.value) {
-            const [content, startOffset] = normalizeAttributeValue(prop.value);
+            const [content, startOffset] = (0, utils_1.normalizeAttributeValue)(prop.value);
             yield `// @ts-ignore navigation for \`const ${content} = ref()\`${utils_1.newLine}`;
             yield `/** @type { typeof __VLS_ctx`;
             yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, content, startOffset, ctx.codeFeatures.navigation, prop.value.loc);
@@ -414,116 +336,11 @@ function* generateReferencesForElements(options, ctx, node) {
     }
     return [];
 }
-function* generateReferencesForScopedCssClasses(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] = 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 hasVBindAttrs(options, ctx, node) {
+    return options.vueCompilerOptions.fallthroughAttributes && (node === ctx.singleRootNode ||
+        node.props.some(prop => prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+            && prop.name === 'bind'
+            && prop.exp?.loc.source === '$attrs'));
 }
 function camelizeComponentName(newName) {
     return (0, shared_1.camelize)('-' + newName);
@@ -531,41 +348,4 @@ function camelizeComponentName(newName) {
 function getTagRenameApply(oldName) {
     return oldName === (0, shared_2.hyphenateTag)(oldName) ? shared_2.hyphenateTag : undefined;
 }
-function normalizeAttributeValue(node) {
-    let offset = node.loc.start.offset;
-    let content = node.loc.source;
-    if ((content.startsWith(`'`) && content.endsWith(`'`))
-        || (content.startsWith(`"`) && content.endsWith(`"`))) {
-        offset++;
-        content = content.slice(1, -1);
-    }
-    return [content, offset];
-}
-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=element.js.map

package/lib/codegen/template/elementChildren.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 generateElementChildren(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode): Generator<Code>;
+export declare function generateElementChildren(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, isDefaultSlot?: boolean): Generator<Code>;

package/lib/codegen/template/elementChildren.js

@@ -4,7 +4,7 @@ exports.generateElementChildren = generateElementChildren;
 const CompilerDOM = require("@vue/compiler-dom");
 const utils_1 = require("../utils");
 const templateChild_1 = require("./templateChild");
-function* generateElementChildren(options, ctx, node) {
+function* generateElementChildren(options, ctx, node, isDefaultSlot = false) {
     yield* ctx.resetDirectiveComments('end of element children start');
     let prev;
     for (const childNode of node.children) {
@@ -14,10 +14,9 @@ function* generateElementChildren(options, ctx, node) {
     yield* ctx.generateAutoImportCompletion();
     // fix https://github.com/vuejs/language-tools/issues/932
     if (ctx.currentComponent
-        && !ctx.hasSlotElements.has(node)
+        && isDefaultSlot
         && node.children.length
-        && node.tagType !== CompilerDOM.ElementTypes.ELEMENT
-        && node.tagType !== CompilerDOM.ElementTypes.TEMPLATE) {
+        && node.tagType === CompilerDOM.ElementTypes.COMPONENT) {
         ctx.currentComponent.used = true;
         yield `${ctx.currentComponent.ctxVar}.slots!.`;
         yield* (0, utils_1.wrapWith)(node.children[0].loc.start.offset, node.children[node.children.length - 1].loc.end.offset, ctx.codeFeatures.navigation, `default`);