@vue/language-core 1.8.18 → 1.8.19

package/out/generators/script.js

@@ -53,22 +53,13 @@ function generate(ts, fileName, _sfc, lang, scriptRanges, scriptSetupRanges, htm
         };
         scriptSetupRanges = {
             bindings: [],
-            emitsAssignName: undefined,
-            exposeRuntimeArg: undefined,
-            exposeTypeArg: undefined,
-            leadingCommentEndOffset: 0,
-            importSectionEndOffset: 0,
-            withDefaults: undefined,
-            defineProps: undefined,
-            defineSlots: undefined,
-            defineEmits: undefined,
-            defineExpose: undefined,
-            slotsAssignName: undefined,
-            propsAssignName: undefined,
-            propsRuntimeArg: undefined,
-            propsTypeArg: undefined,
-            withDefaultsArg: undefined,
+            props: {},
+            emits: {},
+            expose: {},
+            slots: {},
             defineProp: [],
+            importSectionEndOffset: 0,
+            leadingCommentEndOffset: 0,
         };
     }
     //#endregion
@@ -285,13 +276,13 @@ function generate(ts, fileName, _sfc, lang, scriptRanges, scriptSetupRanges, htm
             //#region props
             codes.push(`const __VLS_fnComponent = `);
             codes.push(`(await import('${vueCompilerOptions.lib}')).defineComponent({\n`);
-            if (scriptSetupRanges.propsRuntimeArg) {
+            if (scriptSetupRanges.props.define?.arg) {
                 codes.push(`props: `);
-                addExtraReferenceVirtualCode('scriptSetup', scriptSetupRanges.propsRuntimeArg.start, scriptSetupRanges.propsRuntimeArg.end);
+                addExtraReferenceVirtualCode('scriptSetup', scriptSetupRanges.props.define.arg.start, scriptSetupRanges.props.define.arg.end);
                 codes.push(`,\n`);
             }
-            if (scriptSetupRanges.defineEmits) {
-                codes.push(`emits: ({} as __VLS_NormalizeEmits<typeof `, scriptSetupRanges.emitsAssignName ?? '__VLS_emit', `>),\n`);
+            if (scriptSetupRanges.emits.define) {
+                codes.push(`emits: ({} as __VLS_NormalizeEmits<typeof `, scriptSetupRanges.emits.name ?? '__VLS_emit', `>),\n`);
             }
             codes.push(`});\n`);
             if (scriptSetupRanges.defineProp.length) {
@@ -312,9 +303,9 @@ function generate(ts, fileName, _sfc, lang, scriptRanges, scriptSetupRanges, htm
                 codes.push(`};\n`);
             }
             codes.push(`let __VLS_fnPropsTypeOnly!: {}`); // TODO: reuse __VLS_fnPropsTypeOnly even without generic, and remove __VLS_propsOption_defineProp
-            if (scriptSetupRanges.propsTypeArg) {
+            if (scriptSetupRanges.props.define?.typeArg) {
                 codes.push(` & `);
-                addVirtualCode('scriptSetup', scriptSetupRanges.propsTypeArg.start, scriptSetupRanges.propsTypeArg.end);
+                addVirtualCode('scriptSetup', scriptSetupRanges.props.define.typeArg.start, scriptSetupRanges.props.define.typeArg.end);
             }
             if (scriptSetupRanges.defineProp.length) {
                 codes.push(` & {\n`);
@@ -345,7 +336,7 @@ function generate(ts, fileName, _sfc, lang, scriptRanges, scriptSetupRanges, htm
             codes.push(`let __VLS_fnPropsDefineComponent!: InstanceType<typeof __VLS_fnComponent>['$props']`);
             codes.push(`;\n`);
             codes.push(`let __VLS_fnPropsSlots!: `);
-            if (scriptSetupRanges.defineSlots && vueCompilerOptions.jsxSlots) {
+            if (scriptSetupRanges.slots.define && vueCompilerOptions.jsxSlots) {
                 usedHelperTypes.PropsChildren = true;
                 codes.push(`__VLS_PropsChildren<typeof __VLS_slots>`);
             }
@@ -357,10 +348,10 @@ function generate(ts, fileName, _sfc, lang, scriptRanges, scriptSetupRanges, htm
             //#endregion
             codes.push('return {} as {\n');
             codes.push(`props: __VLS_Prettify<Omit<typeof __VLS_fnPropsDefineComponent & typeof __VLS_fnPropsTypeOnly, keyof typeof __VLS_defaultProps>> & typeof __VLS_fnPropsSlots & typeof __VLS_defaultProps,\n`);
-            codes.push(`expose(exposed: import('${vueCompilerOptions.lib}').ShallowUnwrapRef<${scriptSetupRanges.defineExpose ? 'typeof __VLS_exposed' : '{}'}>): void,\n`);
+            codes.push(`expose(exposed: import('${vueCompilerOptions.lib}').ShallowUnwrapRef<${scriptSetupRanges.expose.define ? 'typeof __VLS_exposed' : '{}'}>): void,\n`);
             codes.push('attrs: any,\n');
             codes.push('slots: ReturnType<typeof __VLS_template>,\n');
-            codes.push(`emit: typeof ${scriptSetupRanges.emitsAssignName ?? '__VLS_emit'},\n`);
+            codes.push(`emit: typeof ${scriptSetupRanges.emits.name ?? '__VLS_emit'},\n`);
             codes.push('};\n');
             codes.push('})(),\n');
             codes.push(`) => ({} as import('${vueCompilerOptions.lib}').VNode & { __ctx?: Awaited<typeof __VLS_setup> }))`);
@@ -429,35 +420,44 @@ declare function defineProp<T>(value?: T | (() => T), required?: boolean, rest?:
         }
         const scriptSetupGeneratedOffset = muggle.getLength(codes) - scriptSetupRanges.importSectionEndOffset;
         let setupCodeModifies = [];
-        if (scriptSetupRanges.defineProps && !scriptSetupRanges.propsAssignName) {
-            const ranges = scriptSetupRanges.withDefaults ?? scriptSetupRanges.defineProps;
-            codes.push(`const __VLS_props = `);
-            addVirtualCode('scriptSetup', ranges.start, ranges.end);
-            codes.push(`;\n`);
-            setupCodeModifies.push([() => codes.push(`__VLS_props`), ranges.start, ranges.end]);
+        if (scriptSetupRanges.props.define && !scriptSetupRanges.props.name) {
+            const range = scriptSetupRanges.props.withDefaults ?? scriptSetupRanges.props.define;
+            const statement = scriptSetupRanges.props.define.statement;
+            if (statement.start === range.start && statement.end === range.end) {
+                setupCodeModifies.push([() => codes.push(`const __VLS_props = `), range.start, range.start]);
+            }
+            else {
+                setupCodeModifies.push([() => {
+                        codes.push(`const __VLS_props = `);
+                        addVirtualCode('scriptSetup', range.start, range.end);
+                        codes.push(`;\n`);
+                        addVirtualCode('scriptSetup', statement.start, range.start);
+                        codes.push(`__VLS_props`);
+                    }, statement.start, range.end]);
+            }
         }
-        if (scriptSetupRanges.defineSlots && !scriptSetupRanges.slotsAssignName) {
-            setupCodeModifies.push([() => codes.push(`const __VLS_slots = `), scriptSetupRanges.defineSlots.start, scriptSetupRanges.defineSlots.start]);
+        if (scriptSetupRanges.slots.define && !scriptSetupRanges.slots.name) {
+            setupCodeModifies.push([() => codes.push(`const __VLS_slots = `), scriptSetupRanges.slots.define.start, scriptSetupRanges.slots.define.start]);
         }
-        if (scriptSetupRanges.defineEmits && !scriptSetupRanges.emitsAssignName) {
-            setupCodeModifies.push([() => codes.push(`const __VLS_emit = `), scriptSetupRanges.defineEmits.start, scriptSetupRanges.defineEmits.start]);
+        if (scriptSetupRanges.emits.define && !scriptSetupRanges.emits.name) {
+            setupCodeModifies.push([() => codes.push(`const __VLS_emit = `), scriptSetupRanges.emits.define.start, scriptSetupRanges.emits.define.start]);
         }
-        if (scriptSetupRanges.defineExpose) {
+        if (scriptSetupRanges.expose.define) {
             setupCodeModifies.push([() => {
-                    if (scriptSetupRanges?.exposeTypeArg) {
+                    if (scriptSetupRanges?.expose.define?.typeArg) {
                         codes.push(`let __VLS_exposed!: `);
-                        addExtraReferenceVirtualCode('scriptSetup', scriptSetupRanges.exposeTypeArg.start, scriptSetupRanges.exposeTypeArg.end);
+                        addExtraReferenceVirtualCode('scriptSetup', scriptSetupRanges.expose.define.typeArg.start, scriptSetupRanges.expose.define.typeArg.end);
                         codes.push(`;\n`);
                     }
-                    else if (scriptSetupRanges?.exposeRuntimeArg) {
+                    else if (scriptSetupRanges?.expose.define?.arg) {
                         codes.push(`const __VLS_exposed = `);
-                        addExtraReferenceVirtualCode('scriptSetup', scriptSetupRanges.exposeRuntimeArg.start, scriptSetupRanges.exposeRuntimeArg.end);
+                        addExtraReferenceVirtualCode('scriptSetup', scriptSetupRanges.expose.define.arg.start, scriptSetupRanges.expose.define.arg.end);
                         codes.push(`;\n`);
                     }
                     else {
                         codes.push(`const __VLS_exposed = {};\n`);
                     }
-                }, scriptSetupRanges.defineExpose.start, scriptSetupRanges.defineExpose.start]);
+                }, scriptSetupRanges.expose.define.start, scriptSetupRanges.expose.define.start]);
         }
         setupCodeModifies = setupCodeModifies.sort((a, b) => a[1] - b[1]);
         if (setupCodeModifies.length) {
@@ -477,10 +477,10 @@ declare function defineProp<T>(value?: T | (() => T), required?: boolean, rest?:
         else {
             addVirtualCode('scriptSetup', scriptSetupRanges.importSectionEndOffset);
         }
-        if (scriptSetupRanges.propsTypeArg && scriptSetupRanges.withDefaultsArg) {
+        if (scriptSetupRanges.props.define?.typeArg && scriptSetupRanges.props.withDefaults?.arg) {
             // fix https://github.com/vuejs/language-tools/issues/1187
             codes.push(`const __VLS_withDefaultsArg = (function <T>(t: T) { return t })(`);
-            addExtraReferenceVirtualCode('scriptSetup', scriptSetupRanges.withDefaultsArg.start, scriptSetupRanges.withDefaultsArg.end);
+            addExtraReferenceVirtualCode('scriptSetup', scriptSetupRanges.props.withDefaults.arg.start, scriptSetupRanges.props.withDefaults.arg.end);
             codes.push(`);\n`);
         }
         if (!functional && scriptSetupRanges.defineProp.length) {
@@ -519,7 +519,7 @@ declare function defineProp<T>(value?: T | (() => T), required?: boolean, rest?:
         }
         generateTemplate(functional);
         if (mode === 'return' || mode === 'export') {
-            if (!vueCompilerOptions.skipTemplateCodegen && (htmlGen?.hasSlot || scriptSetupRanges?.defineSlots)) {
+            if (!vueCompilerOptions.skipTemplateCodegen && (htmlGen?.hasSlot || scriptSetupRanges?.slots.define)) {
                 usedHelperTypes.WithTemplateSlots = true;
                 codes.push(`const __VLS_component = `);
                 generateComponent(functional);
@@ -553,7 +553,7 @@ declare function defineProp<T>(value?: T | (() => T), required?: boolean, rest?:
         codes.push(`setup() {\n`);
         codes.push(`return {\n`);
         generateSetupReturns();
-        if (scriptSetupRanges.defineExpose) {
+        if (scriptSetupRanges.expose.define) {
             codes.push(`...__VLS_exposed,\n`);
         }
         codes.push(`};\n`);
@@ -562,17 +562,17 @@ declare function defineProp<T>(value?: T | (() => T), required?: boolean, rest?:
     }
     function generateComponentOptions(functional) {
         if (scriptSetupRanges && !bypassDefineComponent) {
-            if (scriptSetupRanges.propsRuntimeArg || scriptSetupRanges.propsTypeArg || (!functional && scriptSetupRanges.defineProp.length)) {
+            if (scriptSetupRanges.props.define?.arg || scriptSetupRanges.props.define?.typeArg || (!functional && scriptSetupRanges.defineProp.length)) {
                 codes.push(`props: {\n`);
-                if (scriptSetupRanges.propsRuntimeArg) {
+                if (scriptSetupRanges.props.define?.arg) {
                     codes.push('...');
-                    addExtraReferenceVirtualCode('scriptSetup', scriptSetupRanges.propsRuntimeArg.start, scriptSetupRanges.propsRuntimeArg.end);
+                    addExtraReferenceVirtualCode('scriptSetup', scriptSetupRanges.props.define.arg.start, scriptSetupRanges.props.define.arg.end);
                     codes.push(',\n');
                 }
-                if (scriptSetupRanges.propsTypeArg) {
+                if (scriptSetupRanges.props.define?.typeArg) {
                     usedHelperTypes.DefinePropsToOptions = true;
                     codes.push('...{} as ');
-                    if (scriptSetupRanges.withDefaultsArg) {
+                    if (scriptSetupRanges.props.withDefaults?.arg) {
                         usedHelperTypes.MergePropDefaults = true;
                         codes.push(`__VLS_WithDefaults<`);
                     }
@@ -581,10 +581,10 @@ declare function defineProp<T>(value?: T | (() => T), required?: boolean, rest?:
                         codes.push(`typeof __VLS_fnPropsTypeOnly`);
                     }
                     else {
-                        addExtraReferenceVirtualCode('scriptSetup', scriptSetupRanges.propsTypeArg.start, scriptSetupRanges.propsTypeArg.end);
+                        addExtraReferenceVirtualCode('scriptSetup', scriptSetupRanges.props.define.typeArg.start, scriptSetupRanges.props.define.typeArg.end);
                     }
                     codes.push(`>`);
-                    if (scriptSetupRanges.withDefaultsArg) {
+                    if (scriptSetupRanges.props.withDefaults?.arg) {
                         codes.push(`, typeof __VLS_withDefaultsArg`);
                         codes.push(`>`);
                     }
@@ -595,8 +595,8 @@ declare function defineProp<T>(value?: T | (() => T), required?: boolean, rest?:
                 }
                 codes.push(`},\n`);
             }
-            if (scriptSetupRanges.defineEmits) {
-                codes.push(`emits: ({} as __VLS_NormalizeEmits<typeof `, scriptSetupRanges.emitsAssignName ?? '__VLS_emit', `>),\n`);
+            if (scriptSetupRanges.emits.define) {
+                codes.push(`emits: ({} as __VLS_NormalizeEmits<typeof `, scriptSetupRanges.emits.name ?? '__VLS_emit', `>),\n`);
             }
         }
         if (scriptRanges?.exportDefault?.args) {
@@ -606,14 +606,14 @@ declare function defineProp<T>(value?: T | (() => T), required?: boolean, rest?:
     function generateSetupReturns() {
         if (scriptSetupRanges && bypassDefineComponent) {
             // fill $props
-            if (scriptSetupRanges.defineProps) {
+            if (scriptSetupRanges.props.define) {
                 // NOTE: defineProps is inaccurate for $props
-                codes.push(`$props: __VLS_makeOptional(${scriptSetupRanges.propsAssignName ?? `__VLS_props`}),\n`);
-                codes.push(`...${scriptSetupRanges.propsAssignName ?? `__VLS_props`},\n`);
+                codes.push(`$props: __VLS_makeOptional(${scriptSetupRanges.props.name ?? `__VLS_props`}),\n`);
+                codes.push(`...${scriptSetupRanges.props.name ?? `__VLS_props`},\n`);
             }
             // fill $emit
-            if (scriptSetupRanges.defineEmits) {
-                codes.push(`$emit: ${scriptSetupRanges.emitsAssignName ?? '__VLS_emit'},\n`);
+            if (scriptSetupRanges.emits.define) {
+                codes.push(`$emit: ${scriptSetupRanges.emits.name ?? '__VLS_emit'},\n`);
             }
         }
     }
@@ -739,7 +739,7 @@ declare function defineProp<T>(value?: T | (() => T), required?: boolean, rest?:
         /* Components */
         codes.push('/* Components */\n');
         codes.push(`let __VLS_otherComponents!: NonNullable<typeof __VLS_internalComponent extends { components: infer C } ? C : {}> & typeof __VLS_componentsOption;\n`);
-        codes.push(`let __VLS_own!: __VLS_SelfComponent<typeof __VLS_name, typeof __VLS_internalComponent & (new () => { ${(0, shared_1.getSlotsPropertyName)(vueCompilerOptions.target)}: typeof ${scriptSetupRanges?.slotsAssignName ?? '__VLS_slots'} })>;\n`);
+        codes.push(`let __VLS_own!: __VLS_SelfComponent<typeof __VLS_name, typeof __VLS_internalComponent & (new () => { ${(0, shared_1.getSlotsPropertyName)(vueCompilerOptions.target)}: typeof ${scriptSetupRanges?.slots?.name ?? '__VLS_slots'} })>;\n`);
         codes.push(`let __VLS_localComponents!: typeof __VLS_otherComponents & Omit<typeof __VLS_own, keyof typeof __VLS_otherComponents>;\n`);
         codes.push(`let __VLS_components!: typeof __VLS_localComponents & __VLS_GlobalComponents & typeof __VLS_ctx;\n`); // for html completion, TS references...
         /* Style Scoped */
@@ -770,11 +770,11 @@ declare function defineProp<T>(value?: T | (() => T), required?: boolean, rest?:
         }
         if (!htmlGen) {
             codes.push(`// no template\n`);
-            if (!scriptSetupRanges?.defineSlots) {
+            if (!scriptSetupRanges?.slots.define) {
                 codes.push(`const __VLS_slots = {};\n`);
             }
         }
-        codes.push(`return ${scriptSetupRanges?.slotsAssignName ?? '__VLS_slots'};\n`);
+        codes.push(`return ${scriptSetupRanges?.slots.name ?? '__VLS_slots'};\n`);
         return { cssIds };
         function generateCssClassProperty(styleIndex, className, classRange, propertyType, optional, referencesCodeLens) {
             codes.push(`\n & { `);
@@ -811,7 +811,7 @@ declare function defineProp<T>(value?: T | (() => T), required?: boolean, rest?:
             codes.push(` }`);
         }
         function generateCssVars() {
-            const emptyLocalVars = {};
+            const emptyLocalVars = new Map();
             const identifiers = new Set();
             for (const style of _sfc.styles) {
                 for (const cssBind of style.cssVars) {
@@ -850,7 +850,7 @@ declare function defineProp<T>(value?: T | (() => T), required?: boolean, rest?:
                     usageVars.add(tag.split('.')[0]);
                 }
             }
-            for (const _id of htmlGen.identifiers) {
+            for (const _id of htmlGen.accessedGlobalVariables) {
                 usageVars.add(_id);
             }
         }

package/out/generators/template.d.ts

@@ -13,7 +13,7 @@ export declare function generate(ts: typeof import('typescript/lib/tsserverlibra
     cssCodes: Code[];
     cssCodeStacks: muggle.StackNode[];
     tagNames: Record<string, number[]>;
-    identifiers: Set<string>;
+    accessedGlobalVariables: Set<string>;
     hasSlot: boolean;
 };
 export declare function walkElementNodes(node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode, cb: (node: CompilerDOM.ElementNode) => void): void;

package/out/generators/template.js

@@ -92,9 +92,9 @@ function generate(ts, compilerOptions, vueCompilerOptions, sourceTemplate, sourc
     const slots = new Map();
     const slotExps = new Map();
     const tagNames = collectTagOffsets();
-    const localVars = {};
+    const localVars = new Map();
     const tempVars = [];
-    const identifiers = new Set();
+    const accessedGlobalVariables = new Set();
     const scopedClasses = [];
     const blockConditions = [];
     const hasSlotElements = new Set();
@@ -105,7 +105,7 @@ function generate(ts, compilerOptions, vueCompilerOptions, sourceTemplate, sourc
     let expectedErrorStart;
     let expectedErrorNode;
     if (propsAssignName) {
-        localVars[propsAssignName] = 1;
+        localVars.set(propsAssignName, 1);
     }
     generatePreResolveComponents();
     if (sfc.templateAst) {
@@ -124,7 +124,7 @@ function generate(ts, compilerOptions, vueCompilerOptions, sourceTemplate, sourc
         cssCodes,
         cssCodeStacks,
         tagNames,
-        identifiers,
+        accessedGlobalVariables,
         hasSlot,
     };
     function createSlotsTypeCode() {
@@ -458,7 +458,7 @@ function generate(ts, compilerOptions, vueCompilerOptions, sourceTemplate, sourc
             const collectAst = createTsAst(node.parseResult, `const [${leftExpressionText}]`);
             (0, transform_1.colletVars)(ts, collectAst, forBlockVars);
             for (const varName of forBlockVars)
-                localVars[varName] = (localVars[varName] ?? 0) + 1;
+                localVars.set(varName, (localVars.get(varName) ?? 0) + 1);
             codes.push([leftExpressionText, 'template', leftExpressionRange.start, capabilitiesPresets.all]);
             formatCodes.push(...createFormatCode(leftExpressionText, leftExpressionRange.start, formatBrackets.normal));
         }
@@ -477,7 +477,7 @@ function generate(ts, compilerOptions, vueCompilerOptions, sourceTemplate, sourc
             formatCodes.push(...createFormatCode(source.content, source.loc.start.offset, formatBrackets.normal));
         }
         for (const varName of forBlockVars)
-            localVars[varName]--;
+            localVars.set(varName, localVars.get(varName) - 1);
     }
     function visitElementNode(node, parentEl, componentCtxVar) {
         codes.push(`{\n`);
@@ -698,8 +698,7 @@ function generate(ts, compilerOptions, vueCompilerOptions, sourceTemplate, sourc
             }
             codes.push(';\n');
             slotBlockVars.forEach(varName => {
-                localVars[varName] ??= 0;
-                localVars[varName]++;
+                localVars.set(varName, (localVars.get(varName) ?? 0) + 1);
             });
             let prev;
             for (const childNode of node.children) {
@@ -708,7 +707,7 @@ function generate(ts, compilerOptions, vueCompilerOptions, sourceTemplate, sourc
             }
             resolveComment();
             slotBlockVars.forEach(varName => {
-                localVars[varName]--;
+                localVars.set(varName, localVars.get(varName) - 1);
             });
             let isStatic = true;
             if (slotDir?.arg?.type === 4 /* CompilerDOM.NodeTypes.SIMPLE_EXPRESSION */) {
@@ -1092,7 +1091,7 @@ function generate(ts, compilerOptions, vueCompilerOptions, sourceTemplate, sourc
                 && prop.name !== 'model'
                 && prop.name !== 'bind'
                 && (prop.name !== 'scope' && prop.name !== 'data')) {
-                identifiers.add((0, shared_1.camelize)('v-' + prop.name));
+                accessedGlobalVariables.add((0, shared_1.camelize)('v-' + prop.name));
                 if (prop.arg?.type === 4 /* CompilerDOM.NodeTypes.SIMPLE_EXPRESSION */ && !prop.arg.isStatic) {
                     codes.push(...createInterpolationCode(prop.arg.content, prop.arg.loc, prop.arg.loc.start.offset + prop.arg.loc.source.indexOf(prop.arg.content), capabilitiesPresets.all, '(', ')'), ';\n');
                     formatCodes.push(...createFormatCode(prop.arg.content, prop.arg.loc.start.offset, formatBrackets.normal));
@@ -1342,7 +1341,7 @@ function generate(ts, compilerOptions, vueCompilerOptions, sourceTemplate, sourc
                 }
                 codes.push(addSuffix);
             }
-        }, localVars, identifiers, vueCompilerOptions);
+        }, localVars, accessedGlobalVariables, vueCompilerOptions);
         if (start !== undefined) {
             for (const v of vars) {
                 v.offset = start + v.offset - prefix.length;

package/out/parsers/scriptRanges.js

@@ -4,7 +4,7 @@ exports.parseScriptRanges = void 0;
 const scriptSetupRanges_1 = require("./scriptSetupRanges");
 function parseScriptRanges(ts, ast, hasScriptSetup, withNode) {
     let exportDefault;
-    const bindings = hasScriptSetup ? (0, scriptSetupRanges_1.parseBindingRanges)(ts, ast, false) : [];
+    const bindings = hasScriptSetup ? (0, scriptSetupRanges_1.parseBindingRanges)(ts, ast) : [];
     ast.forEachChild(raw => {
         if (ts.isExportAssignment(raw)) {
             let node = raw;

package/out/parsers/scriptSetupRanges.d.ts

@@ -6,19 +6,32 @@ export declare function parseScriptSetupRanges(ts: typeof import('typescript/lib
     leadingCommentEndOffset: number;
     importSectionEndOffset: number;
     bindings: TextRange[];
-    withDefaultsArg: TextRange | undefined;
-    withDefaults: TextRange | undefined;
-    defineProps: TextRange | undefined;
-    defineSlots: TextRange | undefined;
-    defineEmits: TextRange | undefined;
-    defineExpose: TextRange | undefined;
-    propsAssignName: string | undefined;
-    propsRuntimeArg: TextRange | undefined;
-    propsTypeArg: TextRange | undefined;
-    slotsAssignName: string | undefined;
-    emitsAssignName: string | undefined;
-    exposeRuntimeArg: TextRange | undefined;
-    exposeTypeArg: TextRange | undefined;
+    props: {
+        name?: string | undefined;
+        define?: (TextRange & {
+            statement: TextRange;
+            arg?: TextRange | undefined;
+            typeArg?: TextRange | undefined;
+        }) | undefined;
+        withDefaults?: (TextRange & {
+            arg?: TextRange | undefined;
+        }) | undefined;
+    };
+    slots: {
+        name?: string | undefined;
+        define?: TextRange | undefined;
+    };
+    emits: {
+        name?: string | undefined;
+        define?: TextRange | undefined;
+    };
+    expose: {
+        name?: string | undefined;
+        define?: (TextRange & {
+            arg?: TextRange | undefined;
+            typeArg?: TextRange | undefined;
+        }) | undefined;
+    };
     defineProp: {
         name: TextRange | undefined;
         nameIsString: boolean;
@@ -27,7 +40,7 @@ export declare function parseScriptSetupRanges(ts: typeof import('typescript/lib
         required: boolean;
     }[];
 };
-export declare function parseBindingRanges(ts: typeof import('typescript/lib/tsserverlibrary'), sourceFile: ts.SourceFile, isType: boolean): TextRange[];
+export declare function parseBindingRanges(ts: typeof import('typescript/lib/tsserverlibrary'), sourceFile: ts.SourceFile): TextRange[];
 export declare function findBindingVars(ts: typeof import('typescript/lib/tsserverlibrary'), left: ts.BindingName, sourceFile: ts.SourceFile): TextRange[];
 export declare function getStartEnd(node: ts.Node, sourceFile: ts.SourceFile): {
     start: number;

package/out/parsers/scriptSetupRanges.js

@@ -4,23 +4,14 @@ exports.getStartEnd = exports.findBindingVars = exports.parseBindingRanges = exp
 function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
     let foundNonImportExportNode = false;
     let importSectionEndOffset = 0;
-    let withDefaultsArg;
-    let propsAssignName;
-    let withDefaults;
-    let defineProps;
-    let propsRuntimeArg;
-    let propsTypeArg;
-    let defineSlots;
-    let defineEmits;
-    let defineExpose;
-    let slotsAssignName;
-    let emitsAssignName;
-    let exposeRuntimeArg;
-    let exposeTypeArg;
+    const props = {};
+    const slots = {};
+    const emits = {};
+    const expose = {};
     const definePropProposalA = vueCompilerOptions.experimentalDefinePropProposal === 'kevinEdition' || ast.getFullText().trimStart().startsWith('// @experimentalDefinePropProposal=kevinEdition');
     const definePropProposalB = vueCompilerOptions.experimentalDefinePropProposal === 'johnsonEdition' || ast.getFullText().trimStart().startsWith('// @experimentalDefinePropProposal=johnsonEdition');
     const defineProp = [];
-    const bindings = parseBindingRanges(ts, ast, false);
+    const bindings = parseBindingRanges(ts, ast);
     const text = ast.getFullText();
     const leadingCommentEndOffset = ts.getLeadingCommentRanges(text, 0)?.reverse()[0].end ?? 0;
     ast.forEachChild(node => {
@@ -42,30 +33,22 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
             foundNonImportExportNode = true;
         }
     });
-    ast.forEachChild(child => visitNode(child, ast));
+    ast.forEachChild(child => visitNode(child, [ast]));
     return {
         leadingCommentEndOffset,
         importSectionEndOffset,
         bindings,
-        withDefaultsArg,
-        withDefaults,
-        defineProps,
-        defineSlots,
-        defineEmits,
-        defineExpose,
-        propsAssignName,
-        propsRuntimeArg,
-        propsTypeArg,
-        slotsAssignName,
-        emitsAssignName,
-        exposeRuntimeArg,
-        exposeTypeArg,
+        props,
+        slots,
+        emits,
+        expose,
         defineProp,
     };
     function _getStartEnd(node) {
         return getStartEnd(node, ast);
     }
-    function visitNode(node, parent) {
+    function visitNode(node, parents) {
+        const parent = parents[parents.length - 1];
         if (ts.isCallExpression(node)
             && ts.isIdentifier(node.expression)) {
             const callText = node.expression.getText(ast);
@@ -145,90 +128,102 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                 }
             }
             else if (vueCompilerOptions.macros.defineSlots.includes(callText)) {
-                defineSlots = _getStartEnd(node);
+                slots.define = _getStartEnd(node);
                 if (ts.isVariableDeclaration(parent)) {
-                    slotsAssignName = parent.name.getText(ast);
+                    slots.name = parent.name.getText(ast);
                 }
             }
             else if (vueCompilerOptions.macros.defineEmits.includes(callText)) {
-                defineEmits = _getStartEnd(node);
+                emits.define = _getStartEnd(node);
                 if (ts.isVariableDeclaration(parent)) {
-                    emitsAssignName = parent.name.getText(ast);
+                    emits.name = parent.name.getText(ast);
                 }
             }
             else if (vueCompilerOptions.macros.defineExpose.includes(callText)) {
-                defineExpose = _getStartEnd(node);
+                expose.define = _getStartEnd(node);
                 if (node.arguments.length) {
-                    exposeRuntimeArg = _getStartEnd(node.arguments[0]);
+                    expose.define.arg = _getStartEnd(node.arguments[0]);
                 }
                 if (node.typeArguments?.length) {
-                    exposeTypeArg = _getStartEnd(node.typeArguments[0]);
+                    expose.define.typeArg = _getStartEnd(node.typeArguments[0]);
                 }
             }
             else if (vueCompilerOptions.macros.defineProps.includes(callText)) {
-                defineProps = _getStartEnd(node);
+                let statementRange;
+                for (let i = parents.length - 1; i >= 0; i--) {
+                    if (ts.isStatement(parents[i])) {
+                        const statement = parents[i];
+                        statement.forEachChild(child => {
+                            const range = _getStartEnd(child);
+                            statementRange ??= range;
+                            statementRange.end = range.end;
+                        });
+                        break;
+                    }
+                }
+                if (!statementRange) {
+                    statementRange = _getStartEnd(node);
+                }
+                props.define = {
+                    ..._getStartEnd(node),
+                    statement: statementRange,
+                };
                 if (ts.isVariableDeclaration(parent)) {
-                    propsAssignName = parent.name.getText(ast);
+                    props.name = parent.name.getText(ast);
                 }
                 if (node.arguments.length) {
-                    propsRuntimeArg = _getStartEnd(node.arguments[0]);
+                    props.define.arg = _getStartEnd(node.arguments[0]);
                 }
                 if (node.typeArguments?.length) {
-                    propsTypeArg = _getStartEnd(node.typeArguments[0]);
+                    props.define.typeArg = _getStartEnd(node.typeArguments[0]);
                 }
             }
             else if (vueCompilerOptions.macros.withDefaults.includes(callText)) {
-                withDefaults = _getStartEnd(node);
+                props.withDefaults = _getStartEnd(node);
                 if (node.arguments.length >= 2) {
                     const arg = node.arguments[1];
-                    withDefaultsArg = _getStartEnd(arg);
+                    props.withDefaults.arg = _getStartEnd(arg);
                 }
                 if (ts.isVariableDeclaration(parent)) {
-                    propsAssignName = parent.name.getText(ast);
+                    props.name = parent.name.getText(ast);
                 }
             }
         }
-        node.forEachChild(child => visitNode(child, node));
+        node.forEachChild(child => {
+            parents.push(node);
+            visitNode(child, parents);
+            parents.pop();
+        });
     }
 }
 exports.parseScriptSetupRanges = parseScriptSetupRanges;
-function parseBindingRanges(ts, sourceFile, isType) {
+function parseBindingRanges(ts, sourceFile) {
     const bindings = [];
     sourceFile.forEachChild(node => {
-        if (!isType) {
-            if (ts.isVariableStatement(node)) {
-                for (const node_2 of node.declarationList.declarations) {
-                    const vars = _findBindingVars(node_2.name);
-                    for (const _var of vars) {
-                        bindings.push(_var);
-                    }
-                }
-            }
-            else if (ts.isFunctionDeclaration(node)) {
-                if (node.name && ts.isIdentifier(node.name)) {
-                    bindings.push(_getStartEnd(node.name));
+        if (ts.isVariableStatement(node)) {
+            for (const node_2 of node.declarationList.declarations) {
+                const vars = _findBindingVars(node_2.name);
+                for (const _var of vars) {
+                    bindings.push(_var);
                 }
             }
-            else if (ts.isClassDeclaration(node)) {
-                if (node.name) {
-                    bindings.push(_getStartEnd(node.name));
-                }
-            }
-            else if (ts.isEnumDeclaration(node)) {
-                bindings.push(_getStartEnd(node.name));
-            }
         }
-        else {
-            if (ts.isTypeAliasDeclaration(node)) {
+        else if (ts.isFunctionDeclaration(node)) {
+            if (node.name && ts.isIdentifier(node.name)) {
                 bindings.push(_getStartEnd(node.name));
             }
-            else if (ts.isInterfaceDeclaration(node)) {
+        }
+        else if (ts.isClassDeclaration(node)) {
+            if (node.name) {
                 bindings.push(_getStartEnd(node.name));
             }
         }
+        else if (ts.isEnumDeclaration(node)) {
+            bindings.push(_getStartEnd(node.name));
+        }
         if (ts.isImportDeclaration(node)) {
-            if (node.importClause && (isType || !node.importClause.isTypeOnly)) {
-                if (node.importClause.name && !isType) {
+            if (node.importClause && !node.importClause.isTypeOnly) {
+                if (node.importClause.name) {
                     bindings.push(_getStartEnd(node.importClause.name));
                 }
                 if (node.importClause.namedBindings) {

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

@@ -16,19 +16,32 @@ export declare const tsCodegen: WeakMap<Sfc, {
         leadingCommentEndOffset: number;
         importSectionEndOffset: number;
         bindings: import("../types").TextRange[];
-        withDefaultsArg: import("../types").TextRange | undefined;
-        withDefaults: import("../types").TextRange | undefined;
-        defineProps: import("../types").TextRange | undefined;
-        defineSlots: import("../types").TextRange | undefined;
-        defineEmits: import("../types").TextRange | undefined;
-        defineExpose: import("../types").TextRange | undefined;
-        propsAssignName: string | undefined;
-        propsRuntimeArg: import("../types").TextRange | undefined;
-        propsTypeArg: import("../types").TextRange | undefined;
-        slotsAssignName: string | undefined;
-        emitsAssignName: string | undefined;
-        exposeRuntimeArg: import("../types").TextRange | undefined;
-        exposeTypeArg: import("../types").TextRange | undefined;
+        props: {
+            name?: string | undefined;
+            define?: (import("../types").TextRange & {
+                statement: import("../types").TextRange;
+                arg?: import("../types").TextRange | undefined;
+                typeArg?: import("../types").TextRange | undefined;
+            }) | undefined;
+            withDefaults?: (import("../types").TextRange & {
+                arg?: import("../types").TextRange | undefined;
+            }) | undefined;
+        };
+        slots: {
+            name?: string | undefined;
+            define?: import("../types").TextRange | undefined;
+        };
+        emits: {
+            name?: string | undefined;
+            define?: import("../types").TextRange | undefined;
+        };
+        expose: {
+            name?: string | undefined;
+            define?: (import("../types").TextRange & {
+                arg?: import("../types").TextRange | undefined;
+                typeArg?: import("../types").TextRange | undefined;
+            }) | undefined;
+        };
         defineProp: {
             name: import("../types").TextRange | undefined;
             nameIsString: boolean;
@@ -38,12 +51,12 @@ export declare const tsCodegen: WeakMap<Sfc, {
         }[];
     } | undefined>;
     lang: import("@vue/reactivity").ComputedRef<string>;
-    tsxGen: import("@vue/reactivity").ComputedRef<{
+    generatedScript: import("@vue/reactivity").ComputedRef<{
         codes: muggle.Segment<import("@volar/language-core").FileRangeCapabilities>[];
         codeStacks: muggle.StackNode[];
         mirrorBehaviorMappings: import("@volar/source-map").Mapping<[import("@volar/language-core").MirrorBehaviorCapabilities, import("@volar/language-core").MirrorBehaviorCapabilities]>[];
     }>;
-    htmlGen: import("@vue/reactivity").ComputedRef<{
+    generatedTemplate: import("@vue/reactivity").ComputedRef<{
         codes: (string | [string, string | undefined, number | [number, number], import("@volar/language-core").FileRangeCapabilities])[];
         codeStacks: muggle.StackNode[];
         formatCodes: (string | [string, string | undefined, number | [number, number], import("@volar/language-core").FileRangeCapabilities])[];
@@ -51,7 +64,7 @@ export declare const tsCodegen: WeakMap<Sfc, {
         cssCodes: (string | [string, string | undefined, number | [number, number], import("@volar/language-core").FileRangeCapabilities])[];
         cssCodeStacks: muggle.StackNode[];
         tagNames: Record<string, number[]>;
-        identifiers: Set<string>;
+        accessedGlobalVariables: Set<string>;
         hasSlot: boolean;
     } | undefined>;
 }>;

package/out/plugins/vue-tsx.js

@@ -26,7 +26,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.tsCodegen = void 0;
 const reactivity_1 = require("@vue/reactivity");
 const script_1 = require("../generators/script");
-const templateGen = __importStar(require("../generators/template"));
+const template_1 = require("../generators/template");
 const scriptRanges_1 = require("../parsers/scriptRanges");
 const scriptSetupRanges_1 = require("../parsers/scriptSetupRanges");
 const language_core_1 = require("@volar/language-core");
@@ -64,7 +64,7 @@ const plugin = (ctx) => {
                     documentFormatting: false,
                     documentSymbol: false,
                 };
-                const tsx = _tsx.tsxGen.value;
+                const tsx = _tsx.generatedScript.value;
                 if (tsx) {
                     const [content, contentStacks] = ctx.codegenStack ? muggle.track([...tsx.codes], [...tsx.codeStacks]) : [[...tsx.codes], [...tsx.codeStacks]];
                     embeddedFile.content = content;
@@ -82,8 +82,8 @@ const plugin = (ctx) => {
                     codeAction: false,
                     inlayHint: false,
                 };
-                if (_tsx.htmlGen.value) {
-                    const [content, contentStacks] = ctx.codegenStack ? muggle.track([..._tsx.htmlGen.value.formatCodes], [..._tsx.htmlGen.value.formatCodeStacks]) : [[..._tsx.htmlGen.value.formatCodes], [..._tsx.htmlGen.value.formatCodeStacks]];
+                if (_tsx.generatedTemplate.value) {
+                    const [content, contentStacks] = ctx.codegenStack ? muggle.track([..._tsx.generatedTemplate.value.formatCodes], [..._tsx.generatedTemplate.value.formatCodeStacks]) : [[..._tsx.generatedTemplate.value.formatCodes], [..._tsx.generatedTemplate.value.formatCodeStacks]];
                     embeddedFile.content = content;
                     embeddedFile.contentStacks = contentStacks;
                 }
@@ -103,8 +103,8 @@ const plugin = (ctx) => {
             }
             else if (suffix.match(templateStyleCssReg)) {
                 embeddedFile.parentFileName = fileName + '.template.' + sfc.template?.lang;
-                if (_tsx.htmlGen.value) {
-                    const [content, contentStacks] = ctx.codegenStack ? muggle.track([..._tsx.htmlGen.value.cssCodes], [..._tsx.htmlGen.value.cssCodeStacks]) : [[..._tsx.htmlGen.value.cssCodes], [..._tsx.htmlGen.value.cssCodeStacks]];
+                if (_tsx.generatedTemplate.value) {
+                    const [content, contentStacks] = ctx.codegenStack ? muggle.track([..._tsx.generatedTemplate.value.cssCodes], [..._tsx.generatedTemplate.value.cssCodeStacks]) : [[..._tsx.generatedTemplate.value.cssCodes], [..._tsx.generatedTemplate.value.cssCodeStacks]];
                     embeddedFile.content = content;
                     embeddedFile.contentStacks = contentStacks;
                 }
@@ -135,28 +135,28 @@ function createTsx(fileName, _sfc, { vueCompilerOptions, compilerOptions, codege
     const scriptSetupRanges = (0, reactivity_1.computed)(() => _sfc.scriptSetupAst
         ? (0, scriptSetupRanges_1.parseScriptSetupRanges)(ts, _sfc.scriptSetupAst, vueCompilerOptions)
         : undefined);
-    const htmlGen = (0, reactivity_1.computed)(() => {
+    const generatedTemplate = (0, reactivity_1.computed)(() => {
         if (!_sfc.templateAst)
             return;
-        return templateGen.generate(ts, compilerOptions, vueCompilerOptions, _sfc.template?.content ?? '', _sfc.template?.lang ?? 'html', _sfc, hasScriptSetupSlots.value, slotsAssignName.value, propsAssignName.value, codegenStack);
+        return (0, template_1.generate)(ts, compilerOptions, vueCompilerOptions, _sfc.template?.content ?? '', _sfc.template?.lang ?? 'html', _sfc, hasScriptSetupSlots.value, slotsAssignName.value, propsAssignName.value, codegenStack);
     });
     //#region remove when https://github.com/vuejs/core/pull/5912 merged
     const hasScriptSetupSlots = (0, reactivity_1.shallowRef)(false);
     const slotsAssignName = (0, reactivity_1.shallowRef)();
     const propsAssignName = (0, reactivity_1.shallowRef)();
     //#endregion
-    const tsxGen = (0, reactivity_1.computed)(() => {
-        hasScriptSetupSlots.value = !!scriptSetupRanges.value?.defineSlots;
-        slotsAssignName.value = scriptSetupRanges.value?.slotsAssignName;
-        propsAssignName.value = scriptSetupRanges.value?.propsAssignName;
-        return (0, script_1.generate)(ts, fileName, _sfc, lang.value, scriptRanges.value, scriptSetupRanges.value, htmlGen.value, compilerOptions, vueCompilerOptions, codegenStack);
+    const generatedScript = (0, reactivity_1.computed)(() => {
+        hasScriptSetupSlots.value = !!scriptSetupRanges.value?.slots.define;
+        slotsAssignName.value = scriptSetupRanges.value?.slots.name;
+        propsAssignName.value = scriptSetupRanges.value?.props.name;
+        return (0, script_1.generate)(ts, fileName, _sfc, lang.value, scriptRanges.value, scriptSetupRanges.value, generatedTemplate.value, compilerOptions, vueCompilerOptions, codegenStack);
     });
     return {
         scriptRanges,
         scriptSetupRanges,
         lang,
-        tsxGen,
-        htmlGen,
+        generatedScript,
+        generatedTemplate,
     };
 }
 //# sourceMappingURL=vue-tsx.js.map

package/out/utils/transform.d.ts

@@ -1,6 +1,6 @@
 import type * as ts from 'typescript/lib/tsserverlibrary';
 import { VueCompilerOptions } from '../types';
-export declare function walkInterpolationFragment(ts: typeof import('typescript/lib/tsserverlibrary'), code: string, ast: ts.SourceFile, cb: (fragment: string, offset: number | undefined, isJustForErrorMapping?: boolean) => void, localVars: Record<string, number>, identifiers: Set<string>, vueOptions: VueCompilerOptions): {
+export declare function walkInterpolationFragment(ts: typeof import('typescript/lib/tsserverlibrary'), code: string, ast: ts.SourceFile, cb: (fragment: string, offset: number | undefined, isJustForErrorMapping?: boolean) => void, localVars: Map<string, number>, identifiers: Set<string>, vueOptions: VueCompilerOptions): {
     text: string;
     isShorthand: boolean;
     offset: number;

package/out/utils/transform.js

@@ -5,7 +5,7 @@ const shared_1 = require("@vue/shared");
 function walkInterpolationFragment(ts, code, ast, cb, localVars, identifiers, vueOptions) {
     let ctxVars = [];
     const varCb = (id, isShorthand) => {
-        if (!!localVars[id.text] ||
+        if (localVars.get(id.text) ||
             // https://github.com/vuejs/core/blob/245230e135152900189f13a4281302de45fdcfaa/packages/compiler-core/src/transforms/transformExpression.ts#L342-L352
             (0, shared_1.isGloballyWhitelisted)(id.text) ||
             id.text === 'require' ||
@@ -101,7 +101,7 @@ function walkIdentifiers(ts, node, cb, localVars, blockVars = [], isRoot = true)
     else if (ts.isVariableDeclaration(node)) {
         colletVars(ts, node.name, blockVars);
         for (const varName of blockVars) {
-            localVars[varName] = (localVars[varName] ?? 0) + 1;
+            localVars.set(varName, (localVars.get(varName) ?? 0) + 1);
         }
         if (node.initializer)
             walkIdentifiers(ts, node.initializer, cb, localVars, blockVars, false);
@@ -115,10 +115,10 @@ function walkIdentifiers(ts, node, cb, localVars, blockVars = [], isRoot = true)
             }
         }
         for (const varName of functionArgs)
-            localVars[varName] = (localVars[varName] ?? 0) + 1;
+            localVars.set(varName, (localVars.get(varName) ?? 0) + 1);
         walkIdentifiers(ts, node.body, cb, localVars, blockVars, false);
         for (const varName of functionArgs)
-            localVars[varName]--;
+            localVars.set(varName, localVars.get(varName) - 1);
     }
     else if (ts.isObjectLiteralExpression(node)) {
         for (const prop of node.properties) {
@@ -152,14 +152,14 @@ function walkIdentifiers(ts, node, cb, localVars, blockVars = [], isRoot = true)
         node.forEachChild(node => walkIdentifiers(ts, node, cb, localVars, blockVars, false));
         if (ts.isBlock(node)) {
             for (const varName of blockVars) {
-                localVars[varName]--;
+                localVars.set(varName, localVars.get(varName) - 1);
             }
         }
         blockVars = _blockVars;
     }
     if (isRoot) {
         for (const varName of blockVars) {
-            localVars[varName]--;
+            localVars.set(varName, localVars.get(varName) - 1);
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-core",
-	"version": "1.8.18",
+	"version": "1.8.19",
 	"main": "out/index.js",
 	"license": "MIT",
 	"files": [
@@ -13,8 +13,8 @@
 		"directory": "packages/vue-language-core"
 	},
 	"dependencies": {
-		"@volar/language-core": "~1.10.3",
-		"@volar/source-map": "~1.10.3",
+		"@volar/language-core": "~1.10.4",
+		"@volar/source-map": "~1.10.4",
 		"@vue/compiler-dom": "^3.3.0",
 		"@vue/reactivity": "^3.3.0",
 		"@vue/shared": "^3.3.0",
@@ -34,5 +34,5 @@
 			"optional": true
 		}
 	},
-	"gitHead": "46ef0d608f43569a8e370d1105bfcf334fcaec13"
+	"gitHead": "2e17f3c9cfa827c71e1ed07331730b3ee2596b76"
 }