@vue/language-core 2.1.6-patch.1 → 2.1.8

package/lib/codegen/template/element.js

@@ -17,6 +17,7 @@ const interpolation_1 = require("./interpolation");
 const propertyAccess_1 = require("./propertyAccess");
 const templateChild_1 = require("./templateChild");
 const objectProperty_1 = require("./objectProperty");
+const inlayHints_1 = require("../inlayHints");
 const scriptSetupRanges_1 = require("../../parsers/scriptSetupRanges");
 const colonReg = /:/g;
 function* generateComponent(options, ctx, node, currentComponent) {
@@ -39,9 +40,15 @@ function* generateComponent(options, ctx, node, currentComponent) {
     let dynamicTagInfo;
     if (isComponentTag) {
         for (const prop of node.props) {
-            if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE && prop.name === 'bind' && prop.arg?.loc.source === 'is' && prop.exp) {
+            if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+                && prop.name === 'bind'
+                && prop.arg?.loc.source === 'is'
+                && prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+                if (prop.arg.loc.end.offset === prop.exp.loc.end.offset) {
+                    ctx.inlayHints.push((0, inlayHints_1.createVBindShorthandInlayHintInfo)(prop.exp.loc, 'is'));
+                }
                 dynamicTagInfo = {
-                    exp: prop.exp.loc.source,
+                    tag: prop.exp.content,
                     offsets: [prop.exp.loc.start.offset, undefined],
                     astHolder: prop.exp.loc,
                 };
@@ -53,9 +60,9 @@ function* generateComponent(options, ctx, node, currentComponent) {
     else if (node.tag.includes('.')) {
         // namespace tag
         dynamicTagInfo = {
-            exp: node.tag,
-            astHolder: node.loc,
+            tag: node.tag,
             offsets: [startTagOffset, endTagOffset],
+            astHolder: node.loc,
         };
     }
     if (matchImportName) {
@@ -86,10 +93,10 @@ function* generateComponent(options, ctx, node, currentComponent) {
     }
     else if (dynamicTagInfo) {
         yield `const ${var_originalComponent} = (`;
-        yield* (0, interpolation_1.generateInterpolation)(options, ctx, dynamicTagInfo.exp, dynamicTagInfo.astHolder, dynamicTagInfo.offsets[0], ctx.codeFeatures.all, '(', ')');
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, dynamicTagInfo.tag, dynamicTagInfo.astHolder, dynamicTagInfo.offsets[0], ctx.codeFeatures.all, '(', ')');
         if (dynamicTagInfo.offsets[1] !== undefined) {
             yield `,`;
-            yield* (0, interpolation_1.generateInterpolation)(options, ctx, dynamicTagInfo.exp, dynamicTagInfo.astHolder, dynamicTagInfo.offsets[1], {
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, dynamicTagInfo.tag, dynamicTagInfo.astHolder, dynamicTagInfo.offsets[1], {
                 ...ctx.codeFeatures.all,
                 completion: false,
             }, '(', ')');
@@ -193,7 +200,7 @@ function* generateComponent(options, ctx, node, currentComponent) {
         yield `var ${var_defineComponentCtx}!: __VLS_PickFunctionalComponentCtx<typeof ${var_originalComponent}, typeof ${var_componentInstance}>${common_1.endOfLine}`;
     }
 }
-function* generateElement(options, ctx, node, currentComponent, componentCtxVar) {
+function* generateElement(options, ctx, node, currentComponent, componentCtxVar, isVForChild) {
     const startTagOffset = node.loc.start.offset + options.template.content.substring(node.loc.start.offset).indexOf(node.tag);
     const endTagOffset = !node.isSelfClosing && options.template.lang === 'html'
         ? node.loc.start.offset + node.loc.source.lastIndexOf(node.tag)
@@ -214,7 +221,11 @@ function* generateElement(options, ctx, node, currentComponent, componentCtxVar)
     }
     const [refName, offset] = yield* generateVScope(options, ctx, node, node.props);
     if (refName) {
-        ctx.templateRefs.set(refName, [`__VLS_nativeElements['${node.tag}']`, offset]);
+        let refValue = `__VLS_nativeElements['${node.tag}']`;
+        if (isVForChild) {
+            refValue = `[${refValue}]`;
+        }
+        ctx.templateRefs.set(refName, [refValue, offset]);
     }
     if (ctx.singleRootNode === node) {
         ctx.singleRootElType = `typeof __VLS_nativeElements['${node.tag}']`;

package/lib/codegen/template/elementDirectives.js

@@ -7,42 +7,74 @@ const shared_2 = require("../../utils/shared");
 const common_1 = require("../common");
 const camelized_1 = require("./camelized");
 const interpolation_1 = require("./interpolation");
+const objectProperty_1 = require("./objectProperty");
+const stringLiteralKey_1 = require("./stringLiteralKey");
 function* generateElementDirectives(options, ctx, node) {
     for (const prop of node.props) {
-        if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
-            && prop.name !== 'slot'
-            && prop.name !== 'on'
-            && prop.name !== 'model'
-            && prop.name !== 'bind'
-            && prop.name !== 'scope'
-            && prop.name !== 'data') {
-            ctx.accessExternalVariable((0, shared_1.camelize)('v-' + prop.name), prop.loc.start.offset);
-            if (prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && !prop.arg.isStatic) {
-                yield* (0, interpolation_1.generateInterpolation)(options, ctx, prop.arg.content, prop.arg.loc, prop.arg.loc.start.offset + prop.arg.loc.source.indexOf(prop.arg.content), ctx.codeFeatures.all, '(', ')');
-                yield common_1.endOfLine;
-            }
-            yield* (0, common_1.wrapWith)(prop.loc.start.offset, prop.loc.end.offset, ctx.codeFeatures.verification, `__VLS_directiveAsFunction(__VLS_directives.`, ...(0, camelized_1.generateCamelized)('v-' + prop.name, prop.loc.start.offset, {
-                ...ctx.codeFeatures.all,
-                verification: false,
-                completion: {
-                    // fix https://github.com/vuejs/language-tools/issues/1905
-                    isAdditional: true,
-                },
-                navigation: {
-                    resolveRenameNewName: shared_1.camelize,
-                    resolveRenameEditText: getPropRenameApply(prop.name),
-                },
-            }), `)(null!, { ...__VLS_directiveBindingRestFields, `, ...(prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
-                ? [
-                    ...(0, common_1.wrapWith)(prop.exp.loc.start.offset, prop.exp.loc.end.offset, ctx.codeFeatures.verification, 'value'),
-                    ': ',
-                    ...(0, common_1.wrapWith)(prop.exp.loc.start.offset, prop.exp.loc.end.offset, ctx.codeFeatures.verification, ...(0, interpolation_1.generateInterpolation)(options, ctx, prop.exp.content, prop.exp.loc, prop.exp.loc.start.offset, ctx.codeFeatures.all, '(', ')'))
-                ]
-                : [`undefined`]), `}, null!, null!)`);
-            yield common_1.endOfLine;
+        if (prop.type !== CompilerDOM.NodeTypes.DIRECTIVE
+            || prop.name === 'slot'
+            || prop.name === 'on'
+            || prop.name === 'model'
+            || prop.name === 'bind'
+            || prop.name === 'scope'
+            || prop.name === 'data') {
+            continue;
         }
+        ctx.accessExternalVariable((0, shared_1.camelize)('v-' + prop.name), prop.loc.start.offset);
+        yield* (0, common_1.wrapWith)(prop.loc.start.offset, prop.loc.end.offset, ctx.codeFeatures.verification, `__VLS_asFunctionalDirective(`, ...generateIdentifier(ctx, prop), `)(null!, { ...__VLS_directiveBindingRestFields, `, ...generateArg(options, ctx, prop), ...generateModifiers(options, ctx, prop), ...generateValue(options, ctx, prop), `}, null!, null!)`);
+        yield common_1.endOfLine;
     }
 }
+function* generateIdentifier(ctx, prop) {
+    const rawName = 'v-' + prop.name;
+    yield* (0, common_1.wrapWith)(prop.loc.start.offset, prop.loc.start.offset + rawName.length, ctx.codeFeatures.verification, `__VLS_directives.`, ...(0, camelized_1.generateCamelized)(rawName, prop.loc.start.offset, {
+        ...ctx.codeFeatures.all,
+        verification: false,
+        completion: {
+            // fix https://github.com/vuejs/language-tools/issues/1905
+            isAdditional: true,
+        },
+        navigation: {
+            resolveRenameNewName: shared_1.camelize,
+            resolveRenameEditText: getPropRenameApply(prop.name),
+        },
+    }));
+}
+function* generateArg(options, ctx, prop) {
+    const { arg } = prop;
+    if (arg?.type !== CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+        return;
+    }
+    const startOffset = arg.loc.start.offset + arg.loc.source.indexOf(arg.content);
+    yield* (0, common_1.wrapWith)(startOffset, startOffset + arg.content.length, ctx.codeFeatures.verification, 'arg');
+    yield ': ';
+    if (arg.isStatic) {
+        yield* (0, stringLiteralKey_1.generateStringLiteralKey)(arg.content, startOffset, ctx.codeFeatures.withoutHighlight);
+    }
+    else {
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, arg.content, arg.loc, startOffset, ctx.codeFeatures.all, '(', ')');
+    }
+    yield ', ';
+}
+function* generateModifiers(options, ctx, prop) {
+    if (options.vueCompilerOptions.target < 3.5) {
+        return;
+    }
+    yield 'modifiers: { ';
+    for (const mod of prop.modifiers) {
+        yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, mod.content, mod.loc.start.offset, ctx.codeFeatures.withoutHighlight);
+        yield ': true, ';
+    }
+    yield '}, ';
+}
+function* generateValue(options, ctx, prop) {
+    if (prop.exp?.type !== CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+        return;
+    }
+    yield* (0, common_1.wrapWith)(prop.exp.loc.start.offset, prop.exp.loc.end.offset, ctx.codeFeatures.verification, 'value');
+    yield ': ';
+    yield* (0, common_1.wrapWith)(prop.exp.loc.start.offset, prop.exp.loc.end.offset, ctx.codeFeatures.verification, ...(0, interpolation_1.generateInterpolation)(options, ctx, prop.exp.content, prop.exp.loc, prop.exp.loc.start.offset, ctx.codeFeatures.all, '(', ')'));
+}
 function getPropRenameApply(oldName) {
     return oldName === (0, shared_2.hyphenateAttr)(oldName) ? shared_2.hyphenateAttr : undefined;
 }

package/lib/codegen/template/elementProps.js

@@ -11,16 +11,16 @@ const camelized_1 = require("./camelized");
 const elementEvents_1 = require("./elementEvents");
 const interpolation_1 = require("./interpolation");
 const objectProperty_1 = require("./objectProperty");
+const inlayHints_1 = require("../inlayHints");
 function* generateElementProps(options, ctx, node, props, enableCodeFeatures, propsFailedExps) {
-    const isIntrinsicElement = node.tagType === CompilerDOM.ElementTypes.ELEMENT || node.tagType === CompilerDOM.ElementTypes.TEMPLATE;
-    const canCamelize = node.tagType === CompilerDOM.ElementTypes.COMPONENT;
+    const isComponent = node.tagType === CompilerDOM.ElementTypes.COMPONENT;
     for (const prop of props) {
         if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
             && prop.name === 'on') {
             if (prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
                 && !prop.arg.loc.source.startsWith('[')
                 && !prop.arg.loc.source.endsWith(']')) {
-                if (isIntrinsicElement) {
+                if (!isComponent) {
                     yield `...{ `;
                     yield* (0, elementEvents_1.generateEventArg)(ctx, prop.arg, true);
                     yield `: `;
@@ -69,7 +69,7 @@ function* generateElementProps(options, ctx, node, props, enableCodeFeatures, pr
                 propName = propName.substring(1);
             }
             const shouldSpread = propName === 'style' || propName === 'class';
-            const shouldCamelize = canCamelize
+            const shouldCamelize = isComponent
                 && (!prop.arg || (prop.arg.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && prop.arg.isStatic)) // isStatic
                 && (0, shared_2.hyphenateAttr)(propName) === propName
                 && !options.vueCompilerOptions.htmlAttributes.some(pattern => (0, minimatch_1.minimatch)(propName, pattern));
@@ -120,7 +120,7 @@ function* generateElementProps(options, ctx, node, props, enableCodeFeatures, pr
                 continue;
             }
             const shouldSpread = prop.name === 'style' || prop.name === 'class';
-            const shouldCamelize = canCamelize
+            const shouldCamelize = isComponent
                 && (0, shared_2.hyphenateAttr)(prop.name) === prop.name
                 && !options.vueCompilerOptions.htmlAttributes.some(pattern => (0, minimatch_1.minimatch)(prop.name, pattern));
             if (shouldSpread) {
@@ -205,17 +205,7 @@ function* generatePropExp(options, ctx, prop, exp, features, isShorthand, enable
                 }
                 yield* (0, camelized_1.generateCamelized)(exp.loc.source, exp.loc.start.offset, features);
                 if (enableCodeFeatures) {
-                    ctx.inlayHints.push({
-                        blockName: 'template',
-                        offset: prop.loc.end.offset,
-                        setting: 'vue.inlayHints.vBindShorthand',
-                        label: `="${propVariableName}"`,
-                        tooltip: [
-                            `This is a shorthand for \`${prop.loc.source}="${propVariableName}"\`.`,
-                            'To hide this hint, set `vue.inlayHints.vBindShorthand` to `false` in IDE settings.',
-                            '[More info](https://github.com/vuejs/core/pull/9451)',
-                        ].join('\n\n'),
-                    });
+                    ctx.inlayHints.push((0, inlayHints_1.createVBindShorthandInlayHintInfo)(prop.loc, propVariableName));
                 }
             }
         }

package/lib/codegen/template/interpolation.js

@@ -8,7 +8,6 @@ const common_1 = require("../common");
 function* generateInterpolation(options, ctx, _code, astHolder, start, data, prefix, suffix) {
     const code = prefix + _code + suffix;
     const ast = (0, common_1.createTsAst)(options.ts, astHolder, code);
-    const vars = [];
     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;
@@ -46,11 +45,6 @@ function* generateInterpolation(options, ctx, _code, astHolder, start, data, pre
             yield addSuffix;
         }
     }
-    if (start !== undefined) {
-        for (const v of vars) {
-            v.offset = start + v.offset - prefix.length;
-        }
-    }
 }
 function* forEachInterpolationSegment(ts, destructuredPropNames, templateRefNames, ctx, code, offset, ast) {
     let ctxVars = [];

package/lib/codegen/template/slotOutlet.js

@@ -6,6 +6,7 @@ const common_1 = require("../common");
 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();
@@ -46,6 +47,10 @@ function* generateSlotOutlet(options, ctx, node, currentComponent, componentCtxV
         }
         else if (nameProp?.type === CompilerDOM.NodeTypes.DIRECTIVE
             && nameProp.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+            const isShortHand = nameProp.arg?.loc.start.offset === nameProp.exp.loc.start.offset;
+            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, '(', ')');

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): Generator<Code>;
+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 getVForNode(node: CompilerDOM.ElementNode): CompilerDOM.ForNode | undefined;
 export declare function parseInterpolationNode(node: CompilerDOM.InterpolationNode, template: string): readonly [string, number];

package/lib/codegen/template/templateChild.js

@@ -25,7 +25,7 @@ const transformContext = {
     },
     expressionPlugins: ['typescript'],
 };
-function* generateTemplateChild(options, ctx, node, currentComponent, prevNode, componentCtxVar) {
+function* generateTemplateChild(options, ctx, node, currentComponent, prevNode, componentCtxVar, isVForChild = false) {
     if (prevNode?.type === CompilerDOM.NodeTypes.COMMENT) {
         const commentText = prevNode.content.trim().split(' ')[0];
         if (commentText.match(/^@vue-skip\b[\s\S]*/)) {
@@ -70,7 +70,7 @@ function* generateTemplateChild(options, ctx, node, currentComponent, prevNode,
             }
             else if (node.tagType === CompilerDOM.ElementTypes.ELEMENT
                 || node.tagType === CompilerDOM.ElementTypes.TEMPLATE) {
-                yield* (0, element_1.generateElement)(options, ctx, node, currentComponent, componentCtxVar);
+                yield* (0, element_1.generateElement)(options, ctx, node, currentComponent, componentCtxVar, isVForChild);
             }
             else {
                 yield* (0, element_1.generateComponent)(options, ctx, node, currentComponent);

package/lib/codegen/template/vFor.js

@@ -57,7 +57,7 @@ function* generateVFor(options, ctx, node, currentComponent, componentCtxVar) {
     }
     let prev;
     for (const childNode of node.children) {
-        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, currentComponent, prev, componentCtxVar);
+        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, currentComponent, prev, componentCtxVar, true);
         prev = childNode;
     }
     for (const varName of forBlockVars) {

package/lib/parsers/scriptSetupRanges.d.ts

@@ -12,6 +12,7 @@ export declare function parseScriptSetupRanges(ts: typeof import('typescript'),
         destructured?: Set<string>;
         destructuredRest?: string;
         define?: ReturnType<(node: ts.CallExpression) => TextRange & {
+            exp: TextRange;
             arg?: TextRange;
             typeArg?: TextRange;
         }> & {
@@ -25,6 +26,7 @@ export declare function parseScriptSetupRanges(ts: typeof import('typescript'),
         name?: string;
         isObjectBindingPattern?: boolean;
         define?: ReturnType<(node: ts.CallExpression) => TextRange & {
+            exp: TextRange;
             arg?: TextRange;
             typeArg?: TextRange;
         }>;
@@ -32,15 +34,18 @@ export declare function parseScriptSetupRanges(ts: typeof import('typescript'),
     emits: {
         name?: string;
         define?: ReturnType<(node: ts.CallExpression) => TextRange & {
+            exp: TextRange;
             arg?: TextRange;
             typeArg?: TextRange;
         }> & {
+            statement: TextRange;
             hasUnionTypeArg?: boolean;
         };
     };
     expose: {
         name?: string;
         define?: ReturnType<(node: ts.CallExpression) => TextRange & {
+            exp: TextRange;
             arg?: TextRange;
             typeArg?: TextRange;
         }>;
@@ -50,8 +55,11 @@ export declare function parseScriptSetupRanges(ts: typeof import('typescript'),
         inheritAttrs?: string;
     };
     cssModules: {
-        exp: TextRange;
-        arg?: TextRange;
+        define: ReturnType<(node: ts.CallExpression) => TextRange & {
+            exp: TextRange;
+            arg?: TextRange;
+            typeArg?: TextRange;
+        }>;
     }[];
     defineProp: {
         localName: TextRange | undefined;
@@ -65,7 +73,8 @@ export declare function parseScriptSetupRanges(ts: typeof import('typescript'),
     }[];
     templateRefs: {
         name?: string;
-        define?: ReturnType<(node: ts.CallExpression) => TextRange & {
+        define: ReturnType<(node: ts.CallExpression) => TextRange & {
+            exp: TextRange;
             arg?: TextRange;
             typeArg?: TextRange;
         }>;

package/lib/parsers/scriptSetupRanges.js

@@ -76,6 +76,7 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
     function parseDefineFunction(node) {
         return {
             ..._getStartEnd(node),
+            exp: _getStartEnd(node.expression),
             arg: node.arguments.length ? _getStartEnd(node.arguments[0]) : undefined,
             typeArg: node.typeArguments?.length ? _getStartEnd(node.typeArguments[0]) : undefined,
         };
@@ -217,7 +218,10 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                 }
             }
             else if (vueCompilerOptions.macros.defineEmits.includes(callText)) {
-                emits.define = parseDefineFunction(node);
+                emits.define = {
+                    ...parseDefineFunction(node),
+                    statement: getStatementRange(ts, parents, node, ast)
+                };
                 if (ts.isVariableDeclaration(parent)) {
                     emits.name = getNodeText(ts, parent.name, ast);
                 }
@@ -252,24 +256,9 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                         props.name = getNodeText(ts, parent.name, ast);
                     }
                 }
-                let statementRange;
-                for (let i = parents.length - 1; i >= 0; i--) {
-                    if (ts.isStatement(parents[i])) {
-                        const statement = parents[i];
-                        ts.forEachChild(statement, child => {
-                            const range = _getStartEnd(child);
-                            statementRange ??= range;
-                            statementRange.end = range.end;
-                        });
-                        break;
-                    }
-                }
-                if (!statementRange) {
-                    statementRange = _getStartEnd(node);
-                }
                 props.define = {
                     ...parseDefineFunction(node),
-                    statement: statementRange,
+                    statement: getStatementRange(ts, parents, node, ast),
                 };
                 if (node.arguments.length) {
                     props.define.arg = _getStartEnd(node.arguments[0]);
@@ -308,7 +297,6 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
             }
             else if (vueCompilerOptions.composibles.useTemplateRef.includes(callText) && node.arguments.length && !node.typeArguments?.length) {
                 const define = parseDefineFunction(node);
-                define.arg = _getStartEnd(node.arguments[0]);
                 let name;
                 if (ts.isVariableDeclaration(parent)) {
                     name = getNodeText(ts, parent.name, ast);
@@ -319,13 +307,10 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                 });
             }
             else if (vueCompilerOptions.composibles.useCssModule.includes(callText)) {
-                const module = {
-                    exp: _getStartEnd(node)
-                };
-                if (node.arguments.length) {
-                    module.arg = _getStartEnd(node.arguments[0]);
-                }
-                cssModules.push(module);
+                const define = parseDefineFunction(node);
+                cssModules.push({
+                    define
+                });
             }
         }
         ts.forEachChild(node, child => {
@@ -430,4 +415,22 @@ function getNodeText(ts, node, sourceFile) {
     const { start, end } = getStartEnd(ts, node, sourceFile);
     return sourceFile.text.substring(start, end);
 }
+function getStatementRange(ts, parents, node, sourceFile) {
+    let statementRange;
+    for (let i = parents.length - 1; i >= 0; i--) {
+        if (ts.isStatement(parents[i])) {
+            const statement = parents[i];
+            ts.forEachChild(statement, child => {
+                const range = getStartEnd(ts, child, sourceFile);
+                statementRange ??= range;
+                statementRange.end = range.end;
+            });
+            break;
+        }
+    }
+    if (!statementRange) {
+        statementRange = getStartEnd(ts, node, sourceFile);
+    }
+    return statementRange;
+}
 //# sourceMappingURL=scriptSetupRanges.js.map

package/lib/plugins/vue-tsx.d.ts

@@ -1,7 +1,7 @@
 import type { Mapping } from '@volar/language-core';
 import type { Code, Sfc, VueLanguagePlugin } from '../types';
 export declare const tsCodegen: WeakMap<Sfc, {
-    scriptRanges: () => {
+    scriptRanges: import("alien-signals").ISignal<{
         exportDefault: (import("../types").TextRange & {
             expression: import("../types").TextRange;
             args: import("../types").TextRange;
@@ -14,8 +14,8 @@ export declare const tsCodegen: WeakMap<Sfc, {
         }) | undefined;
         classBlockEnd: number | undefined;
         bindings: import("../types").TextRange[];
-    } | undefined;
-    scriptSetupRanges: () => {
+    } | undefined>;
+    scriptSetupRanges: import("alien-signals").ISignal<{
         leadingCommentEndOffset: number;
         importSectionEndOffset: number;
         bindings: import("../types").TextRange[];
@@ -25,6 +25,7 @@ export declare const tsCodegen: WeakMap<Sfc, {
             destructured?: Set<string>;
             destructuredRest?: string;
             define?: ReturnType<(node: import("typescript").CallExpression) => import("../types").TextRange & {
+                exp: import("../types").TextRange;
                 arg?: import("../types").TextRange;
                 typeArg?: import("../types").TextRange;
             }> & {
@@ -38,6 +39,7 @@ export declare const tsCodegen: WeakMap<Sfc, {
             name?: string;
             isObjectBindingPattern?: boolean;
             define?: ReturnType<(node: import("typescript").CallExpression) => import("../types").TextRange & {
+                exp: import("../types").TextRange;
                 arg?: import("../types").TextRange;
                 typeArg?: import("../types").TextRange;
             }>;
@@ -45,15 +47,18 @@ export declare const tsCodegen: WeakMap<Sfc, {
         emits: {
             name?: string;
             define?: ReturnType<(node: import("typescript").CallExpression) => import("../types").TextRange & {
+                exp: import("../types").TextRange;
                 arg?: import("../types").TextRange;
                 typeArg?: import("../types").TextRange;
             }> & {
+                statement: import("../types").TextRange;
                 hasUnionTypeArg?: boolean;
             };
         };
         expose: {
             name?: string;
             define?: ReturnType<(node: import("typescript").CallExpression) => import("../types").TextRange & {
+                exp: import("../types").TextRange;
                 arg?: import("../types").TextRange;
                 typeArg?: import("../types").TextRange;
             }>;
@@ -63,8 +68,11 @@ export declare const tsCodegen: WeakMap<Sfc, {
             inheritAttrs?: string;
         };
         cssModules: {
-            exp: import("../types").TextRange;
-            arg?: import("../types").TextRange;
+            define: ReturnType<(node: import("typescript").CallExpression) => import("../types").TextRange & {
+                exp: import("../types").TextRange;
+                arg?: import("../types").TextRange;
+                typeArg?: import("../types").TextRange;
+            }>;
         }[];
         defineProp: {
             localName: import("../types").TextRange | undefined;
@@ -78,14 +86,15 @@ export declare const tsCodegen: WeakMap<Sfc, {
         }[];
         templateRefs: {
             name?: string;
-            define?: ReturnType<(node: import("typescript").CallExpression) => import("../types").TextRange & {
+            define: ReturnType<(node: import("typescript").CallExpression) => import("../types").TextRange & {
+                exp: import("../types").TextRange;
                 arg?: import("../types").TextRange;
                 typeArg?: import("../types").TextRange;
             }>;
         }[];
-    } | undefined;
-    lang: () => string;
-    generatedScript: () => {
+    } | undefined>;
+    lang: import("alien-signals").ISignal<string>;
+    generatedScript: import("alien-signals").ISignal<{
         codes: Code[];
         linkedCodeMappings: Mapping<unknown>[];
         generatedTemplate: boolean;
@@ -104,9 +113,9 @@ export declare const tsCodegen: WeakMap<Sfc, {
             readonly TypePropsToOption: string;
             readonly OmitIndexSignature: string;
         };
-        inlayHints: import("../codegen/types").InlayHintInfo[];
-    };
-    generatedTemplate: () => {
+        inlayHints: import("../codegen/inlayHints").InlayHintInfo[];
+    }>;
+    generatedTemplate: import("alien-signals").ISignal<{
         codes: Code[];
         slots: {
             name: string;
@@ -142,7 +151,7 @@ export declare const tsCodegen: WeakMap<Sfc, {
             offset: number;
         }[];
         emptyClassOffsets: number[];
-        inlayHints: import("../codegen/types").InlayHintInfo[];
+        inlayHints: import("../codegen/inlayHints").InlayHintInfo[];
         hasSlot: boolean;
         inheritedAttrVars: Set<unknown>;
         templateRefs: Map<string, [varName: string, offset: number]>;
@@ -157,7 +166,7 @@ export declare const tsCodegen: WeakMap<Sfc, {
         expectError: (prevNode: import("@vue/compiler-dom").CommentNode) => Generator<Code>;
         resetDirectiveComments: (endStr: string) => Generator<Code>;
         generateAutoImportCompletion: () => Generator<Code>;
-    } | undefined;
+    } | undefined>;
 }>;
 declare const plugin: VueLanguagePlugin;
 export default plugin;