@wevu/compiler 6.6.10 → 6.6.11

package/dist/index.d.mts

@@ -239,6 +239,7 @@ interface ForParseResult {
   item?: string;
   index?: string;
   key?: string;
+  itemAliases?: Record<string, string>;
 }
 /**
  * 模板编译选项。

package/dist/index.mjs

@@ -4125,6 +4125,8 @@ function getClassStyleWxsSource(options = {}) {
 
 //#endregion
 //#region src/plugins/vue/compiler/template/elements/helpers.ts
+const IDENTIFIER_RE$1 = /^[A-Z_$][\w$]*$/i;
+const FOR_ITEM_ALIAS_PLACEHOLDER = "__wv_for_item__";
 function isStructuralDirective(node) {
 	for (const prop of node.props) if (prop.type === NodeTypes.DIRECTIVE) {
 		if (prop.name === "if" || prop.name === "else-if" || prop.name === "else") return {
@@ -4218,35 +4220,217 @@ function isScopedSlotsDisabled(context) {
 function findSlotDirective(node) {
 	return node.props.find((prop) => prop.type === NodeTypes.DIRECTIVE && prop.name === "slot");
 }
-function parseForExpression(exp) {
-	const match = exp.match(/^\(([^,]+),\s*([^,]+),\s*([^)]+)\)\s+in\s+(.+)$/);
-	if (match) {
-		const [, item, _key, index, list] = match;
-		return {
-			listExp: list,
-			item,
-			index,
-			key: _key
-		};
+function isIdentifier(value) {
+	return IDENTIFIER_RE$1.test(value);
+}
+function splitTopLevelByComma(input) {
+	const out = [];
+	let start = 0;
+	let parenDepth = 0;
+	let bracketDepth = 0;
+	let braceDepth = 0;
+	let quote = "";
+	let escaped = false;
+	for (let i = 0; i < input.length; i += 1) {
+		const ch = input[i];
+		if (quote) {
+			if (escaped) {
+				escaped = false;
+				continue;
+			}
+			if (ch === "\\") {
+				escaped = true;
+				continue;
+			}
+			if (ch === quote) quote = "";
+			continue;
+		}
+		if (ch === "'" || ch === "\"" || ch === "`") {
+			quote = ch;
+			continue;
+		}
+		if (ch === "(") {
+			parenDepth += 1;
+			continue;
+		}
+		if (ch === ")") {
+			parenDepth = Math.max(0, parenDepth - 1);
+			continue;
+		}
+		if (ch === "[") {
+			bracketDepth += 1;
+			continue;
+		}
+		if (ch === "]") {
+			bracketDepth = Math.max(0, bracketDepth - 1);
+			continue;
+		}
+		if (ch === "{") {
+			braceDepth += 1;
+			continue;
+		}
+		if (ch === "}") {
+			braceDepth = Math.max(0, braceDepth - 1);
+			continue;
+		}
+		if (ch === "," && parenDepth === 0 && bracketDepth === 0 && braceDepth === 0) {
+			out.push(input.slice(start, i).trim());
+			start = i + 1;
+		}
 	}
-	const match2 = exp.match(/^\(([^,]+),\s*([^)]+)\)\s+in\s+(.+)$/);
-	if (match2) {
-		const [, item, index, list] = match2;
-		return {
-			listExp: list,
-			item,
-			index
+	out.push(input.slice(start).trim());
+	return out.filter(Boolean);
+}
+function splitForExpression(exp) {
+	let parenDepth = 0;
+	let bracketDepth = 0;
+	let braceDepth = 0;
+	let quote = "";
+	let escaped = false;
+	for (let i = 0; i < exp.length; i += 1) {
+		const ch = exp[i];
+		if (quote) {
+			if (escaped) {
+				escaped = false;
+				continue;
+			}
+			if (ch === "\\") {
+				escaped = true;
+				continue;
+			}
+			if (ch === quote) quote = "";
+			continue;
+		}
+		if (ch === "'" || ch === "\"" || ch === "`") {
+			quote = ch;
+			continue;
+		}
+		if (ch === "(") {
+			parenDepth += 1;
+			continue;
+		}
+		if (ch === ")") {
+			parenDepth = Math.max(0, parenDepth - 1);
+			continue;
+		}
+		if (ch === "[") {
+			bracketDepth += 1;
+			continue;
+		}
+		if (ch === "]") {
+			bracketDepth = Math.max(0, bracketDepth - 1);
+			continue;
+		}
+		if (ch === "{") {
+			braceDepth += 1;
+			continue;
+		}
+		if (ch === "}") {
+			braceDepth = Math.max(0, braceDepth - 1);
+			continue;
+		}
+		if (parenDepth !== 0 || bracketDepth !== 0 || braceDepth !== 0) continue;
+		if (exp.startsWith(" in ", i) || exp.startsWith(" of ", i)) return {
+			source: exp.slice(0, i).trim(),
+			list: exp.slice(i + 4).trim()
 		};
 	}
-	const match3 = exp.match(/^(\w+)\s+in\s+(.+)$/);
-	if (match3) {
-		const [, item, list] = match3;
-		return {
-			listExp: list,
-			item
-		};
+	return null;
+}
+function stripOuterParentheses(value) {
+	const trimmed = value.trim();
+	if (!trimmed.startsWith("(") || !trimmed.endsWith(")")) return trimmed;
+	let depth = 0;
+	for (let i = 0; i < trimmed.length; i += 1) {
+		const ch = trimmed[i];
+		if (ch === "(") depth += 1;
+		else if (ch === ")") {
+			depth -= 1;
+			if (depth === 0 && i !== trimmed.length - 1) return trimmed;
+		}
 	}
-	return {};
+	return trimmed.slice(1, -1).trim();
+}
+function toMemberAccess(base, property, computed) {
+	if (!computed) {
+		if (t.isIdentifier(property) && isIdentifier(property.name)) return `${base}.${property.name}`;
+		if (t.isStringLiteral(property)) return `${base}[${JSON.stringify(property.value)}]`;
+	}
+	if (t.isExpression(property)) return `${base}[${generateExpression(property)}]`;
+	return base;
+}
+function collectPatternAliases(node, base, aliases) {
+	if (t.isIdentifier(node)) {
+		aliases[node.name] = base;
+		return;
+	}
+	if (t.isAssignmentPattern(node)) {
+		collectPatternAliases(node.left, base, aliases);
+		return;
+	}
+	if (t.isRestElement(node)) {
+		if (t.isIdentifier(node.argument)) aliases[node.argument.name] = base;
+		return;
+	}
+	if (t.isArrayPattern(node)) {
+		node.elements.forEach((element, index) => {
+			if (!element) return;
+			if (t.isRestElement(element)) {
+				collectPatternAliases(element, `${base}.slice(${index})`, aliases);
+				return;
+			}
+			collectPatternAliases(element, `${base}[${index}]`, aliases);
+		});
+		return;
+	}
+	if (!t.isObjectPattern(node)) return;
+	node.properties.forEach((property) => {
+		if (t.isRestElement(property)) {
+			if (t.isIdentifier(property.argument)) aliases[property.argument.name] = base;
+			return;
+		}
+		const nextBase = toMemberAccess(base, property.key, property.computed);
+		collectPatternAliases(property.value, nextBase, aliases);
+	});
+}
+function parseItemAliases(pattern) {
+	try {
+		const stmt = parseJsLike(`(${pattern}) => {}`).program.body[0];
+		if (!stmt || stmt.type !== "ExpressionStatement") return {};
+		const exp = stmt.expression;
+		if (!t.isArrowFunctionExpression(exp) || exp.params.length !== 1) return {};
+		const aliases = {};
+		collectPatternAliases(exp.params[0], FOR_ITEM_ALIAS_PLACEHOLDER, aliases);
+		return aliases;
+	} catch {
+		return {};
+	}
+}
+function parseForExpression(exp) {
+	const split = splitForExpression(exp.trim());
+	if (!split) return {};
+	const segments = splitTopLevelByComma(stripOuterParentheses(split.source));
+	if (!segments.length || segments.length > 3) return { listExp: split.list };
+	const result = { listExp: split.list };
+	const rawItem = segments[0]?.trim();
+	if (rawItem) if (isIdentifier(rawItem)) result.item = rawItem;
+	else {
+		const aliases = parseItemAliases(rawItem);
+		if (Object.keys(aliases).length) {
+			result.item = FOR_ITEM_ALIAS_PLACEHOLDER;
+			result.itemAliases = aliases;
+		}
+	}
+	if (segments.length === 2) {
+		const rawIndex = segments[1]?.trim();
+		if (rawIndex && isIdentifier(rawIndex)) result.index = rawIndex;
+	} else if (segments.length === 3) {
+		const rawKey = segments[1]?.trim();
+		const rawIndex = segments[2]?.trim();
+		if (rawKey && isIdentifier(rawKey)) result.key = rawKey;
+		if (rawIndex && isIdentifier(rawIndex)) result.index = rawIndex;
+	}
+	return result;
 }
 
 //#endregion
@@ -4293,6 +4477,23 @@ function collectSlotPropMapping(context) {
 	for (const entry of context.slotPropStack) Object.assign(mapping, entry);
 	return mapping;
 }
+function collectForAliasMapping$2(context) {
+	const mapping = {};
+	for (const forInfo of context.forStack) {
+		if (!forInfo.itemAliases) continue;
+		Object.assign(mapping, forInfo.itemAliases);
+	}
+	return mapping;
+}
+function replaceIdentifierWithExpression(path, replacement) {
+	const parent = path.parentPath;
+	if (parent.isObjectProperty() && parent.node.shorthand && parent.node.key === path.node) {
+		parent.node.shorthand = false;
+		parent.node.value = replacement;
+		return;
+	}
+	path.replaceWith(replacement);
+}
 function rewriteScopedSlotExpression(exp, context) {
 	const normalized = normalizeWxmlExpression(exp);
 	const parsed = parseBabelExpressionFile(normalized);
@@ -4300,6 +4501,7 @@ function rewriteScopedSlotExpression(exp, context) {
 	const { ast } = parsed;
 	const locals = collectScopedSlotLocals(context);
 	const slotProps = collectSlotPropMapping(context);
+	const forAliases = collectForAliasMapping$2(context);
 	const createMemberAccess = (target, prop) => {
 		if (!prop) return t.identifier(target);
 		if (/^[A-Z_$][\w$]*$/i.test(prop)) return t.memberExpression(t.identifier(target), t.identifier(prop));
@@ -4309,33 +4511,48 @@ function rewriteScopedSlotExpression(exp, context) {
 		if (!path.isReferencedIdentifier()) return;
 		const name = path.node.name;
 		if (SCOPED_SLOT_GLOBALS.has(name)) return;
-		if (locals.has(name)) return;
-		if (Object.prototype.hasOwnProperty.call(slotProps, name)) {
-			const member = createMemberAccess("__wvSlotPropsData", slotProps[name]);
-			const parent = path.parentPath;
-			if (parent.isObjectProperty() && parent.node.shorthand && parent.node.key === path.node) {
-				parent.node.shorthand = false;
-				parent.node.value = member;
+		if (path.scope.hasBinding(name)) return;
+		if (Object.prototype.hasOwnProperty.call(forAliases, name)) {
+			const aliasExp = parseBabelExpression(forAliases[name]);
+			if (aliasExp) {
+				replaceIdentifierWithExpression(path, t.cloneNode(aliasExp, true));
 				return;
 			}
-			path.replaceWith(member);
-			return;
 		}
-		const member = createMemberAccess("__wvOwner", name);
-		const parent = path.parentPath;
-		if (parent.isObjectProperty() && parent.node.shorthand && parent.node.key === path.node) {
-			parent.node.shorthand = false;
-			parent.node.value = member;
+		if (locals.has(name)) return;
+		if (Object.prototype.hasOwnProperty.call(slotProps, name)) {
+			replaceIdentifierWithExpression(path, createMemberAccess("__wvSlotPropsData", slotProps[name]));
 			return;
 		}
-		path.replaceWith(member);
+		replaceIdentifierWithExpression(path, createMemberAccess("__wvOwner", name));
+	} });
+	const stmt = ast.program.body[0];
+	const updatedExpression = stmt && "expression" in stmt ? stmt.expression : null;
+	return updatedExpression ? generateExpression(updatedExpression) : normalized;
+}
+function rewriteForAliasExpression(exp, context) {
+	const normalized = normalizeWxmlExpression(exp);
+	const forAliases = collectForAliasMapping$2(context);
+	if (!Object.keys(forAliases).length) return normalized;
+	const parsed = parseBabelExpressionFile(normalized);
+	if (!parsed) return normalized;
+	const { ast } = parsed;
+	traverse(ast, { Identifier(path) {
+		if (!path.isReferencedIdentifier()) return;
+		const name = path.node.name;
+		if (path.scope.hasBinding(name)) return;
+		if (!Object.prototype.hasOwnProperty.call(forAliases, name)) return;
+		const aliasExp = parseBabelExpression(forAliases[name]);
+		if (!aliasExp) return;
+		replaceIdentifierWithExpression(path, t.cloneNode(aliasExp, true));
 	} });
 	const stmt = ast.program.body[0];
 	const updatedExpression = stmt && "expression" in stmt ? stmt.expression : null;
 	return updatedExpression ? generateExpression(updatedExpression) : normalized;
 }
 function normalizeWxmlExpressionWithContext(exp, context) {
-	if (!context?.rewriteScopedSlot) return normalizeWxmlExpression(exp);
+	if (!context) return normalizeWxmlExpression(exp);
+	if (!context.rewriteScopedSlot) return rewriteForAliasExpression(exp, context);
 	return rewriteScopedSlotExpression(exp, context);
 }
 
@@ -4561,6 +4778,14 @@ function buildScopeResolvers(usedLocals, context, slotProps, indexBindings) {
 	}
 	return resolvers;
 }
+function collectForAliasMapping$1(context) {
+	const mapping = {};
+	for (const forInfo of context.forStack) {
+		if (!forInfo.itemAliases) continue;
+		Object.assign(mapping, forInfo.itemAliases);
+	}
+	return mapping;
+}
 function registerInlineExpression(exp, context) {
 	const parsed = parseBabelExpressionFile(exp);
 	if (!parsed) return null;
@@ -4576,10 +4801,13 @@ function registerInlineExpression(exp, context) {
 		usedLocals.push(name);
 	};
 	rewriteExpressionAst(ast, locals, { markLocal });
+	const forAliases = collectForAliasMapping$1(context);
 	const updatedStmt = ast.program.body[0];
 	const updatedExpressionNode = updatedStmt && "expression" in updatedStmt ? updatedStmt.expression : null;
 	const updatedExpression = updatedExpressionNode ? generateExpression(updatedExpressionNode) : exp;
 	const scopeBindings = usedLocals.map((name) => {
+		const forAlias = forAliases[name];
+		if (forAlias) return forAlias;
 		return resolveSlotPropBinding(slotProps, name) ?? name;
 	});
 	const indexBindings = buildInlineIndexBindings(context);
@@ -4688,6 +4916,14 @@ function createIdentifierAccessWithPropsFallback(name) {
 	const shouldUsePropsAccess = t.logicalExpression("&&", hasUsablePropsValue, t.unaryExpression("!", hasThisMember));
 	return t.conditionalExpression(shouldUseStateAccess, thisAccess, t.conditionalExpression(shouldUsePropsAccess, propsAccess, thisAccess));
 }
+function collectForAliasMapping(context) {
+	const mapping = {};
+	for (const forInfo of context.forStack) {
+		if (!forInfo.itemAliases) continue;
+		Object.assign(mapping, forInfo.itemAliases);
+	}
+	return mapping;
+}
 function normalizeJsExpressionWithContext(exp, context, options) {
 	const trimmed = exp.trim();
 	if (!trimmed) return null;
@@ -4700,11 +4936,26 @@ function normalizeJsExpressionWithContext(exp, context, options) {
 	const { ast } = parsed;
 	const locals = collectScopedSlotLocals(context);
 	const slotProps = context.rewriteScopedSlot ? collectSlotPropMapping(context) : {};
+	const forAliases = collectForAliasMapping(context);
 	traverse(ast, { Identifier(path) {
 		if (!path.isReferencedIdentifier()) return;
 		const name = path.node.name;
 		if (JS_RUNTIME_GLOBALS.has(name)) return;
 		if (path.scope.hasBinding(name)) return;
+		if (Object.prototype.hasOwnProperty.call(forAliases, name)) {
+			const aliasExp = parseBabelExpression(forAliases[name]);
+			if (aliasExp) {
+				const replacement = t.cloneNode(aliasExp, true);
+				const parent = path.parentPath;
+				if (parent.isObjectProperty() && parent.node.shorthand && parent.node.key === path.node) {
+					parent.node.shorthand = false;
+					parent.node.value = replacement;
+					return;
+				}
+				path.replaceWith(replacement);
+				return;
+			}
+		}
 		if (locals.has(name)) return;
 		let replacement;
 		if (context.rewriteScopedSlot) if (Object.prototype.hasOwnProperty.call(slotProps, name)) {
@@ -5038,6 +5289,12 @@ function transformModelDirective(node, context, elementNode) {
 //#endregion
 //#region src/plugins/vue/compiler/template/directives/on.ts
 const isSimpleHandler = (value) => /^[A-Z_$][\w$]*$/i.test(value);
+function shouldUseDetailPayload(options) {
+	return options?.isComponent === true;
+}
+function normalizeEventDatasetSuffix(eventName) {
+	return eventName.trim().replace(/[^a-z0-9]+/gi, "-").replace(/^-+|-+$/g, "").toLowerCase() || "event";
+}
 function buildInlineScopeAttrs(scopeBindings, context) {
 	return scopeBindings.map((binding, index) => {
 		return `data-wv-s${index}="${renderMustache(binding.replace(/"/g, "&quot;"), context)}"`;
@@ -5059,32 +5316,41 @@ function resolveEventPrefix(modifiers) {
 	if (hasCapture) return "capture-bind";
 	return "bind";
 }
-function transformOnDirective(node, context) {
+function transformOnDirective(node, context, options) {
 	const { exp, arg } = node;
 	if (!arg) return null;
 	const argValue = arg.type === NodeTypes.SIMPLE_EXPRESSION ? arg.content : "";
 	if (!exp) return null;
-	const rawExpValue = exp.type === NodeTypes.SIMPLE_EXPRESSION ? exp.content : "";
-	const isInlineExpression = rawExpValue && !isSimpleHandler(rawExpValue);
-	const inlineExpression = isInlineExpression ? registerInlineExpression(rawExpValue, context) : null;
+	const rawExpValue = exp.type === NodeTypes.SIMPLE_EXPRESSION ? exp.content.trim() : "";
+	const useDetailPayload = shouldUseDetailPayload(options);
+	const inlineSource = useDetailPayload && isSimpleHandler(rawExpValue) ? `${rawExpValue}($event)` : rawExpValue;
+	const isInlineExpression = inlineSource && !isSimpleHandler(inlineSource);
+	const inlineExpression = isInlineExpression ? registerInlineExpression(inlineSource, context) : null;
 	const mappedEvent = context.platform.mapEventName(argValue);
+	const eventSuffix = normalizeEventDatasetSuffix(mappedEvent);
 	const eventPrefix = resolveEventPrefix(node.modifiers);
 	const bindAttr = context.platform.eventBindingAttr(`${eventPrefix}:${mappedEvent}`);
+	const detailAttr = useDetailPayload ? `data-wv-event-detail-${eventSuffix}="1"` : "";
 	if (context.rewriteScopedSlot) {
 		if (inlineExpression) {
 			const scopeAttrs = buildInlineScopeAttrs(inlineExpression.scopeBindings, context);
 			const indexAttrs = buildInlineIndexAttrs(inlineExpression.indexBindings, context);
 			return [
-				`data-wv-inline-id="${inlineExpression.id}"`,
+				detailAttr,
+				`data-wv-inline-id-${eventSuffix}="${inlineExpression.id}"`,
 				...scopeAttrs,
 				...indexAttrs,
 				`${bindAttr}="__weapp_vite_owner"`
 			].filter(Boolean).join(" ");
 		}
-		if (!isInlineExpression && rawExpValue) return `data-wv-handler="${rawExpValue}" ${bindAttr}="__weapp_vite_owner"`;
+		if (!isInlineExpression && rawExpValue) return [
+			detailAttr,
+			`data-wv-handler-${eventSuffix}="${rawExpValue}"`,
+			`${bindAttr}="__weapp_vite_owner"`
+		].filter(Boolean).join(" ");
 		if (isInlineExpression) {
 			context.warnings.push("作用域插槽的事件处理解析失败，请使用简单的方法引用。");
-			return `${bindAttr}="__weapp_vite_owner"`;
+			return [detailAttr, `${bindAttr}="__weapp_vite_owner"`].filter(Boolean).join(" ");
 		}
 	}
 	const expValue = normalizeWxmlExpressionWithContext(rawExpValue, context);
@@ -5092,14 +5358,19 @@ function transformOnDirective(node, context) {
 		const scopeAttrs = buildInlineScopeAttrs(inlineExpression.scopeBindings, context);
 		const indexAttrs = buildInlineIndexAttrs(inlineExpression.indexBindings, context);
 		return [
-			`data-wv-inline-id="${inlineExpression.id}"`,
+			detailAttr,
+			`data-wv-inline-id-${eventSuffix}="${inlineExpression.id}"`,
 			...scopeAttrs,
 			...indexAttrs,
 			`${bindAttr}="__weapp_vite_inline"`
 		].filter(Boolean).join(" ");
 	}
-	if (isInlineExpression) return `data-wv-inline="${rawExpValue.replace(/"/g, "&quot;")}" ${bindAttr}="__weapp_vite_inline"`;
-	return `${bindAttr}="${expValue}"`;
+	if (isInlineExpression) return [
+		detailAttr,
+		`data-wv-inline-${eventSuffix}="${inlineSource.replace(/"/g, "&quot;")}"`,
+		`${bindAttr}="__weapp_vite_inline"`
+	].filter(Boolean).join(" ");
+	return [detailAttr, `${bindAttr}="${expValue}"`].filter(Boolean).join(" ");
 }
 
 //#endregion
@@ -5112,10 +5383,10 @@ function transformShowDirective(node, context) {
 
 //#endregion
 //#region src/plugins/vue/compiler/template/directives/index.ts
-function transformDirective(node, context, elementNode, forInfo) {
+function transformDirective(node, context, elementNode, forInfo, options) {
 	const { name, exp, arg } = node;
 	if (name === "bind") return transformBindDirective(node, context, forInfo);
-	if (name === "on") return transformOnDirective(node, context);
+	if (name === "on") return transformOnDirective(node, context, options);
 	if (name === "model") return transformModelDirective(node, context, elementNode);
 	if (name === "show") return transformShowDirective(node, context);
 	if (name === "html") {
@@ -5138,6 +5409,7 @@ function isBuiltinTag(tag) {
 }
 function collectElementAttributes(node, context, options) {
 	const { props } = node;
+	const isComponentElement = options?.isComponent ?? !isBuiltinTag(node.tag);
 	const attrs = options?.extraAttrs ? [...options.extraAttrs] : [];
 	let staticClass;
 	let dynamicClassExp;
@@ -5195,20 +5467,19 @@ function collectElementAttributes(node, context, options) {
 				vTextExp = (shouldFallbackToRuntimeBinding(rawExp) ? registerRuntimeBindingExpression(rawExp, context, { hint: "v-text" }) : null) ?? normalizeWxmlExpressionWithContext(rawExp, context);
 				continue;
 			}
-			const dir = transformDirective(prop, context, node, options?.forInfo);
+			const dir = transformDirective(prop, context, node, options?.forInfo, { isComponent: isComponentElement });
 			if (dir) attrs.push(dir);
 		}
 	}
 	if (templateRef) {
 		const className = `__wv-ref-${context.templateRefIndexSeed++}`;
 		staticClass = staticClass ? `${staticClass} ${className}` : className;
-		const isComponentRef = options?.isComponent ?? !isBuiltinTag(node.tag);
 		context.templateRefs.push({
 			selector: `.${className}`,
 			inFor,
 			name: templateRef.name,
 			expAst: templateRef.expAst,
-			kind: isComponentRef ? "component" : "element"
+			kind: isComponentElement ? "component" : "element"
 		});
 	}
 	const classAttr = renderClassAttribute(staticClass, dynamicClassExp, context);
@@ -5586,7 +5857,7 @@ function transformComponentElement(node, context, transformNode) {
 		const attr = transformAttribute(prop, context);
 		if (attr) attrs.push(attr);
 	} else if (prop.type === NodeTypes.DIRECTIVE) {
-		const dir = transformDirective(prop, context, node);
+		const dir = transformDirective(prop, context, node, void 0, { isComponent: true });
 		if (dir) attrs.push(dir);
 	}
 	const children = node.children.map((child) => transformNode(child, context)).join("");
@@ -5644,6 +5915,17 @@ function transformForElement(node, context, transformNode) {
 	const forDirective = node.props.find((prop) => prop.type === NodeTypes.DIRECTIVE && prop.name === "for");
 	if (!forDirective || !forDirective.exp) return transformNormalElement(node, context, transformNode);
 	const forInfo = parseForExpression(forDirective.exp.type === NodeTypes.SIMPLE_EXPRESSION ? forDirective.exp.content : "");
+	if (forInfo.item === FOR_ITEM_ALIAS_PLACEHOLDER) {
+		const generatedItem = `__wv_item_${context.forIndexSeed++}`;
+		forInfo.item = generatedItem;
+		if (forInfo.itemAliases) {
+			const escaped = FOR_ITEM_ALIAS_PLACEHOLDER.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+			const placeholderRE = new RegExp(`\\b${escaped}\\b`, "g");
+			forInfo.itemAliases = Object.fromEntries(Object.entries(forInfo.itemAliases).map(([alias, expression]) => {
+				return [alias, expression.replace(placeholderRE, generatedItem)];
+			}));
+		}
+	}
 	if (context.classStyleRuntime === "js" && !forInfo.index) forInfo.index = `__wv_index_${context.forIndexSeed++}`;
 	const listExp = forInfo.listExp ? resolveConditionExpression$1(forInfo.listExp, context, "v-for 列表") : void 0;
 	const listExpAst = forInfo.listExp ? normalizeJsExpressionWithContext(forInfo.listExp, context, { hint: "v-for 列表" }) : void 0;
@@ -5658,7 +5940,8 @@ function transformForElement(node, context, transformNode) {
 	const scopeNames = [
 		forInfo.item,
 		forInfo.index,
-		forInfo.key
+		forInfo.key,
+		...Object.keys(forInfo.itemAliases ?? {})
 	].filter(Boolean);
 	return withForScope(context, scopedForInfo, () => withScope(context, scopeNames, () => {
 		const otherProps = node.props.filter((prop) => prop !== forDirective);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@wevu/compiler",
   "type": "module",
-  "version": "6.6.10",
+  "version": "6.6.11",
   "description": "wevu 编译器基础包，面向小程序模板的编译与转换",
   "author": "ice breaker <1324318532@qq.com>",
   "license": "MIT",
@@ -45,14 +45,14 @@
     "@babel/parser": "^7.29.0",
     "@babel/traverse": "^7.29.0",
     "@babel/types": "^7.29.0",
-    "@vue/compiler-core": "^3.5.28",
+    "@vue/compiler-core": "^3.5.29",
     "comment-json": "^4.5.1",
     "fs-extra": "^11.3.3",
     "lru-cache": "^11.2.6",
     "magic-string": "^0.30.21",
     "merge": "^2.1.1",
     "pathe": "^2.0.3",
-    "vue": "^3.5.28",
+    "vue": "^3.5.29",
     "@weapp-core/shared": "3.0.1",
     "rolldown-require": "2.0.6"
   },