@astralsight/astroforge-rsbuild-plugin 0.0.6 → 0.0.8

package/dist/index.d.mts

@@ -134,6 +134,7 @@ type StyleSlotValue = {
 };
 interface Binding {
   path: string;
+  expr?: string;
   is_callable: boolean;
 }
 interface Conditional {

package/dist/index.mjs

@@ -322,8 +322,9 @@ function extractPageModuleFromTsx(source, options) {
 	});
 	const bindings = collectAstroForgeImports(ast.program.body);
 	const pageFunction = findDefaultPageFunction(ast.program.body, options.filename);
-	const script = extractScript(source, ast.program.body, pageFunction.node, options.filename);
-	const template = templateFromRenderExpression(pageFunction.renderExpression, bindings, options.filename);
+	const scriptExtraction = extractScript(source, ast.program.body, pageFunction.node, options.filename);
+	const script = scriptExtraction.script;
+	const template = templateFromRenderExpression(pageFunction.renderExpression, bindings, createTemplateContext(source, options.filename, scriptExtraction.context));
 	const components = extractLocalComponents(source, ast.program.body, pageFunction.node, bindings, options.filename);
 	const componentImports = collectComponentImports(ast.program.body, bindings, Object.keys(components));
 	const imports = importsFromTemplate(template, components);
@@ -346,16 +347,17 @@ function extractComponentFromTsx(source, options) {
 	});
 	const bindings = collectAstroForgeImports(ast.program.body);
 	const located = locateComponentFunction(ast.program.body, options.exportName, options.filename);
-	const template = templateFromRenderExpression(located.renderExpression, bindings, options.filename);
+	const script = {
+		...createEmptyScript(),
+		props: extractComponentProps(located.node, ast.program.body, options.filename)
+	};
+	const template = templateFromRenderExpression(located.renderExpression, bindings, createTemplateContext(source, options.filename));
 	const componentImports = collectComponentImports(ast.program.body, bindings, []);
 	return {
 		component: {
 			name: kebabCase(located.localName),
 			template,
-			script: {
-				...createEmptyScript(),
-				props: extractComponentProps(located.node, ast.program.body, options.filename)
-			},
+			script,
 			style: extractStyleTable(source, ast.program.body, options.filename, options.loadStyle)
 		},
 		componentImports
@@ -467,7 +469,7 @@ function extractLocalComponents(source, body, pageFunction, bindings, filename)
 		const name = kebabCase(candidate.name);
 		components[name] = {
 			name,
-			template: templateFromRenderExpression(renderExpressionFromFunction(fn, filename), bindings, filename),
+			template: templateFromRenderExpression(renderExpressionFromFunction(fn, filename), bindings, createTemplateContext(source, filename)),
 			script: {
 				...createEmptyScript(),
 				props: extractComponentProps(fn, body, filename)
@@ -655,13 +657,19 @@ function findDefaultPageFunction(body, filename) {
 function extractScript(source, moduleBody, pageFunction, filename) {
 	const script = createEmptyScript();
 	const body = unwrapExpression(pageFunction.body);
-	if (body.type !== "BlockStatement") return script;
 	const context = createScriptContext(source, filename);
+	if (body.type !== "BlockStatement") return {
+		script,
+		context
+	};
 	for (const statement of body.body) collectUseStateDeclaration(script, context, statement);
 	for (const statement of body.body) collectMethod(script, context, statement);
 	collectPageLifecycle(script, context, moduleBody);
 	collectUseEffectCalls(script, context, body.body);
-	return script;
+	return {
+		script,
+		context
+	};
 }
 function createScriptContext(source, filename) {
 	return {
@@ -671,6 +679,22 @@ function createScriptContext(source, filename) {
 		stateSetters: /* @__PURE__ */ new Map()
 	};
 }
+function createTemplateContext(source, filename, scriptContext = createScriptContext(source, filename), aliases = /* @__PURE__ */ new Map()) {
+	return {
+		source,
+		filename,
+		scriptContext,
+		aliases
+	};
+}
+function withTemplateAliases(context, aliases) {
+	const next = new Map(context.aliases);
+	for (const [source, target] of aliases) next.set(source, target);
+	return {
+		...context,
+		aliases: next
+	};
+}
 function collectUseStateDeclaration(script, context, statement) {
 	if (statement.type !== "VariableDeclaration") return;
 	for (const declarator of statement.declarations) {
@@ -881,6 +905,180 @@ function lowerStateSetterCall(context, stateName, node) {
 	}
 	return `this.${stateName} = ${lowerExpression(context, expression)}`;
 }
+function lowerTemplateEventHandler(context, node) {
+	const fn = unwrapExpression(node);
+	const firstParam = fn.params?.[0];
+	const aliases = [];
+	if (firstParam?.type === "Identifier") aliases.push([firstParam.name, "evt"]);
+	return `function(evt) ${lowerTemplateFunctionBody(withTemplateAliases(context, aliases), fn.body)}`;
+}
+function lowerTemplateFunctionBody(context, body) {
+	const node = unwrapExpression(body);
+	if (node.type !== "BlockStatement") return `{ return ${lowerTemplateExpression(context, node)}; }`;
+	const statements = node.body.map((statement) => lowerTemplateStatement(context, statement)).filter(Boolean);
+	if (statements.length === 0) return "{}";
+	return `{\n${statements.map((statement) => `  ${statement}`).join("\n")}\n}`;
+}
+function lowerTemplateStatement(context, statement) {
+	switch (statement.type) {
+		case "ExpressionStatement": return `${lowerTemplateExpression(context, statement.expression)};`;
+		case "ReturnStatement": return statement.argument ? `return ${lowerTemplateExpression(context, statement.argument)};` : "return;";
+		case "VariableDeclaration": return lowerTemplateVariableDeclaration(context, statement);
+		case "IfStatement": return lowerTemplateIfStatement(context, statement);
+		case "BlockStatement": {
+			const body = statement.body.map((item) => lowerTemplateStatement(context, item)).filter(Boolean).map((item) => `  ${item}`).join("\n");
+			return body ? `{\n${body}\n}` : "{}";
+		}
+		default: throw new Error(`${context.filename ?? "TSX"}: 内联事件暂不支持 ${statement.type}`);
+	}
+}
+function lowerTemplateVariableDeclaration(context, statement) {
+	const declarations = statement.declarations.map((declarator) => {
+		const id = sourceForNode(context.source, declarator.id);
+		if (!declarator.init) return id;
+		return `${id} = ${lowerTemplateExpression(context, declarator.init)}`;
+	});
+	return `${statement.kind} ${declarations.join(", ")};`;
+}
+function lowerTemplateIfStatement(context, statement) {
+	const test = lowerTemplateExpression(context, statement.test);
+	const consequent = lowerTemplateStatementAsBlock(context, statement.consequent);
+	if (!statement.alternate) return `if (${test}) ${consequent}`;
+	return `if (${test}) ${consequent} else ${statement.alternate.type === "IfStatement" ? lowerTemplateIfStatement(context, statement.alternate) : lowerTemplateStatementAsBlock(context, statement.alternate)}`;
+}
+function lowerTemplateStatementAsBlock(context, statement) {
+	if (statement.type === "BlockStatement") return lowerTemplateStatement(context, statement);
+	return `{\n  ${lowerTemplateStatement(context, statement)}\n}`;
+}
+function lowerTemplateExpression(context, expression) {
+	const node = unwrapExpression(expression);
+	switch (node.type) {
+		case "Identifier": return lowerTemplateIdentifier(context, node.name);
+		case "StringLiteral": return JSON.stringify(node.value);
+		case "NumericLiteral": return String(node.value);
+		case "BooleanLiteral": return String(node.value);
+		case "NullLiteral": return "null";
+		case "TemplateLiteral": return lowerTemplateLiteral(context, node);
+		case "ConditionalExpression": return `${lowerTemplateExpression(context, node.test)} ? ${lowerTemplateExpression(context, node.consequent)} : ${lowerTemplateExpression(context, node.alternate)}`;
+		case "BinaryExpression":
+		case "LogicalExpression": return `${lowerTemplateExpression(context, node.left)} ${node.operator} ${lowerTemplateExpression(context, node.right)}`;
+		case "UnaryExpression": return `${node.operator}${lowerTemplateExpression(context, node.argument)}`;
+		case "AssignmentExpression": return `${lowerTemplateExpression(context, node.left)} ${node.operator} ${lowerTemplateExpression(context, node.right)}`;
+		case "UpdateExpression": {
+			const argument = lowerTemplateExpression(context, node.argument);
+			return node.prefix ? `${node.operator}${argument}` : `${argument}${node.operator}`;
+		}
+		case "MemberExpression":
+		case "OptionalMemberExpression": return lowerTemplateMemberExpression(context, node);
+		case "CallExpression":
+		case "OptionalCallExpression": return lowerTemplateCallExpression(context, node);
+		case "ArrayExpression": return `[${node.elements.map((item) => item ? item.type === "SpreadElement" ? `...${lowerTemplateExpression(context, item.argument)}` : lowerTemplateExpression(context, item) : "").join(", ")}]`;
+		case "ObjectExpression": return lowerTemplateObjectExpression(context, node);
+		case "ArrowFunctionExpression":
+		case "FunctionExpression": return lowerTemplateEventHandler(context, node);
+		default: throw new Error(`${context.filename ?? "TSX"}: 文本绑定暂不支持 ${node.type}`);
+	}
+}
+function lowerTemplateIdentifier(context, name) {
+	const alias = context.aliases.get(name);
+	if (alias) return alias;
+	if (TEMPLATE_GLOBALS.has(name)) return name;
+	return `_vm_.${name}`;
+}
+function lowerTemplateMemberExpression(context, node) {
+	const object = unwrapExpression(node.object);
+	let base;
+	if (object.type === "Identifier" && object.name === "props") base = "_vm_";
+	else base = lowerTemplateExpression(context, object);
+	const operator = node.optional ? "?." : ".";
+	if (node.computed) return `${base}${node.optional ? "?." : ""}[${lowerTemplateExpression(context, node.property)}]`;
+	const property = sourceForNode(context.source, node.property);
+	return `${base}${operator}${property}`;
+}
+function lowerTemplateCallExpression(context, node) {
+	const setterTarget = node.callee.type === "Identifier" ? context.scriptContext.stateSetters.get(node.callee.name) : void 0;
+	if (setterTarget) return lowerTemplateStateSetterCall(context, setterTarget, node);
+	const optional = node.optional ? "?." : "";
+	return `${lowerTemplateExpression(context, node.callee)}${optional}(${node.arguments.map((arg) => {
+		if (arg.type === "SpreadElement") return `...${lowerTemplateExpression(context, arg.argument)}`;
+		return lowerTemplateExpression(context, arg);
+	}).join(", ")})`;
+}
+function lowerTemplateStateSetterCall(context, stateName, node) {
+	const next = node.arguments[0];
+	if (!next) return `_vm_.${stateName} = null`;
+	const expression = unwrapExpression(next);
+	if (expression.type === "ArrowFunctionExpression") {
+		const firstParam = expression.params[0];
+		const aliases = firstParam?.type === "Identifier" ? [[firstParam.name, `_vm_.${stateName}`]] : [];
+		if (expression.body.type === "BlockStatement") throw new Error(`${context.filename ?? "TSX"}: setState updater 暂不支持 block body`);
+		return `_vm_.${stateName} = ${lowerTemplateExpression(withTemplateAliases(context, aliases), expression.body)}`;
+	}
+	return `_vm_.${stateName} = ${lowerTemplateExpression(context, expression)}`;
+}
+function lowerTemplateLiteral(context, node) {
+	const parts = [];
+	node.quasis.forEach((quasi, index) => {
+		const text = quasi.value.cooked ?? quasi.value.raw ?? "";
+		if (text) parts.push(JSON.stringify(text));
+		const expression = node.expressions[index];
+		if (expression) parts.push(`(${lowerTemplateExpression(context, expression)})`);
+	});
+	return parts.length > 0 ? parts.join(" + ") : "\"\"";
+}
+function lowerTemplateObjectExpression(context, node) {
+	return `{ ${node.properties.map((property) => {
+		if (property.type === "SpreadElement") return `...${lowerTemplateExpression(context, property.argument)}`;
+		if (property.type !== "ObjectProperty") throw new Error(`${context.filename ?? "TSX"}: 文本绑定暂不支持对象方法`);
+		return `${property.computed ? `[${lowerTemplateExpression(context, property.key)}]` : jsObjectKey(objectPropertyKey(property.key, context.filename))}: ${lowerTemplateExpression(context, property.value)}`;
+	}).join(", ")} }`;
+}
+function jsObjectKey(key) {
+	return /^[A-Za-z_$][\w$]*$/.test(key) ? key : JSON.stringify(key);
+}
+const TEMPLATE_GLOBALS = new Set([
+	"Array",
+	"Boolean",
+	"Date",
+	"Infinity",
+	"JSON",
+	"Math",
+	"NaN",
+	"Number",
+	"Object",
+	"Promise",
+	"String",
+	"console",
+	"false",
+	"isFinite",
+	"isNaN",
+	"null",
+	"parseFloat",
+	"parseInt",
+	"network",
+	"router",
+	"storage",
+	"true",
+	"undefined",
+	"velaBattery",
+	"velaBluetoothBLE",
+	"velaBrightness",
+	"velaConfiguration",
+	"velaCrypto",
+	"velaDebug",
+	"velaEvent",
+	"velaExchange",
+	"velaFolme",
+	"velaInterconnect",
+	"velaJumpApp",
+	"velaLocale",
+	"velaMediaSession",
+	"velaMqttMessage",
+	"velaProtobuf",
+	"velaServiceClient",
+	"velaVolume",
+	"velaZlib"
+]);
 function findTopLevelBinding(body, name) {
 	for (const statement of body) {
 		if (statement.type === "FunctionDeclaration" && statement.id?.name === name) return statement;
@@ -899,50 +1097,50 @@ function renderExpressionFromFunction(node, filename) {
 	}
 	throw new Error(`${filename ?? "TSX"}: 页面函数缺少 return 语句`);
 }
-function templateFromRenderExpression(expression, bindings, filename) {
-	const node = nodeFromJsx(expression, bindings, filename);
+function templateFromRenderExpression(expression, bindings, context) {
+	const node = nodeFromJsx(expression, bindings, context);
 	if (node.kind === "fragment") return node.value;
 	return [node];
 }
-function nodeFromJsx(node, bindings, filename) {
+function nodeFromJsx(node, bindings, context) {
 	switch (node.type) {
 		case "JSXElement": return {
 			kind: "element",
-			value: elementFromJsx(node, bindings, filename)
+			value: elementFromJsx(node, bindings, context)
 		};
 		case "JSXFragment": return {
 			kind: "fragment",
-			value: childrenFromJsx(node.children, bindings, filename)
+			value: childrenFromJsx(node.children, bindings, context)
 		};
-		default: throw new Error(`${filename ?? "TSX"}: 不支持的 JSX 根节点 ${node.type}`);
+		default: throw new Error(`${context.filename ?? "TSX"}: 不支持的 JSX 根节点 ${node.type}`);
 	}
 }
-function elementFromJsx(node, bindings, filename) {
-	const name = jsxElementName(node.openingElement.name, filename);
+function elementFromJsx(node, bindings, context) {
+	const name = jsxElementName(node.openingElement.name, context.filename);
 	const tag = bindings.get(name) ?? name;
 	const isComponent = !bindings.has(name) && /^[A-Z]/.test(name);
 	const attrs = {};
 	const events = {};
 	for (const attr of node.openingElement.attributes) {
-		if (attr.type === "JSXSpreadAttribute") throw new Error(`${filename ?? "TSX"}: 暂不支持 JSX spread 属性`);
-		const attrName = jsxAttributeName(attr.name, filename);
+		if (attr.type === "JSXSpreadAttribute") throw new Error(`${context.filename ?? "TSX"}: 暂不支持 JSX spread 属性`);
+		const attrName = jsxAttributeName(attr.name, context.filename);
 		if (attrName === "key") continue;
 		if (isEventAttribute(attrName)) {
-			events[eventNameFromAttribute(attrName)] = bindingFromAttribute(attr.value, true, filename);
+			events[eventNameFromAttribute(attrName)] = bindingFromAttribute(attr.value, true, context);
 			continue;
 		}
 		const normalizedName = normalizeAttributeName(attrName, isComponent);
-		attrs[normalizedName] = attrFromValue(normalizedName, attr.value, filename);
+		attrs[normalizedName] = attrFromValue(normalizedName, attr.value, context);
 	}
 	return {
 		tag: isComponent ? kebabCase(tag) : tag,
 		is_component: isComponent,
 		attrs,
 		events,
-		children: childrenFromJsx(node.children, bindings, filename)
+		children: childrenFromJsx(node.children, bindings, context)
 	};
 }
-function childrenFromJsx(children, bindings, filename) {
+function childrenFromJsx(children, bindings, context) {
 	const out = [];
 	for (const child of children) {
 		if (child.type === "JSXText") {
@@ -954,7 +1152,7 @@ function childrenFromJsx(children, bindings, filename) {
 			continue;
 		}
 		if (child.type === "JSXElement" || child.type === "JSXFragment") {
-			const node = nodeFromJsx(child, bindings, filename);
+			const node = nodeFromJsx(child, bindings, context);
 			if (node.kind === "fragment") out.push(...node.value);
 			else out.push(node);
 			continue;
@@ -962,18 +1160,18 @@ function childrenFromJsx(children, bindings, filename) {
 		if (child.type === "JSXExpressionContainer") {
 			const expression = unwrapExpression(child.expression);
 			if (expression.type === "JSXEmptyExpression") continue;
-			out.push(nodeFromExpression(expression, bindings, filename));
+			out.push(nodeFromExpression(expression, bindings, context));
 			continue;
 		}
-		throw new Error(`${filename ?? "TSX"}: 不支持的 JSX 子节点 ${child.type}`);
+		throw new Error(`${context.filename ?? "TSX"}: 不支持的 JSX 子节点 ${child.type}`);
 	}
 	return out;
 }
-function nodeFromExpression(expression, bindings, filename) {
-	const conditional = conditionalFromExpression(expression, bindings, filename);
-	if (conditional) return conditional;
-	const list = listFromExpression(expression, bindings, filename);
+function nodeFromExpression(expression, bindings, context) {
+	const list = listFromExpression(expression, bindings, context);
 	if (list) return list;
+	const conditional = conditionalFromExpression(expression, bindings, context);
+	if (conditional) return conditional;
 	const value = literalValue(expression);
 	if (value !== void 0) return {
 		kind: "text",
@@ -981,65 +1179,80 @@ function nodeFromExpression(expression, bindings, filename) {
 	};
 	return {
 		kind: "expression",
-		value: bindingFromExpression(expression, false, filename)
+		value: bindingFromExpression(expression, false, context)
 	};
 }
-function conditionalFromExpression(expression, bindings, filename) {
+function conditionalFromExpression(expression, bindings, context) {
 	const node = unwrapExpression(expression);
-	if (node.type === "ConditionalExpression") return {
-		kind: "conditional",
-		value: { branches: [{
-			guard: bindingFromExpression(node.test, false, filename),
-			body: nodesFromBranchExpression(node.consequent, bindings, filename)
-		}, ...alternateBranches(node.alternate, bindings, filename)] }
-	};
-	if (node.type === "LogicalExpression" && node.operator === "&&") return {
-		kind: "conditional",
-		value: { branches: [{
-			guard: bindingFromExpression(node.left, false, filename),
-			body: nodesFromBranchExpression(node.right, bindings, filename)
-		}] }
-	};
+	if (node.type === "ConditionalExpression") {
+		if (!isControlFlowBranch(node.consequent) && !isControlFlowBranch(node.alternate)) return;
+		return {
+			kind: "conditional",
+			value: { branches: [{
+				guard: bindingFromExpression(node.test, false, context),
+				body: nodesFromBranchExpression(node.consequent, bindings, context)
+			}, ...alternateBranches(node.alternate, bindings, context)] }
+		};
+	}
+	if (node.type === "LogicalExpression" && node.operator === "&&") {
+		if (!isControlFlowBranch(node.right)) return;
+		return {
+			kind: "conditional",
+			value: { branches: [{
+				guard: bindingFromExpression(node.left, false, context),
+				body: nodesFromBranchExpression(node.right, bindings, context)
+			}] }
+		};
+	}
 }
-function alternateBranches(expression, bindings, filename) {
+function alternateBranches(expression, bindings, context) {
 	const node = unwrapExpression(expression);
 	if (node.type === "ConditionalExpression") return [{
-		guard: bindingFromExpression(node.test, false, filename),
-		body: nodesFromBranchExpression(node.consequent, bindings, filename)
-	}, ...alternateBranches(node.alternate, bindings, filename)];
+		guard: bindingFromExpression(node.test, false, context),
+		body: nodesFromBranchExpression(node.consequent, bindings, context)
+	}, ...alternateBranches(node.alternate, bindings, context)];
 	return [{
 		guard: null,
-		body: nodesFromBranchExpression(node, bindings, filename)
+		body: nodesFromBranchExpression(node, bindings, context)
 	}];
 }
-function nodesFromBranchExpression(expression, bindings, filename) {
+function nodesFromBranchExpression(expression, bindings, context) {
 	const node = unwrapExpression(expression);
 	if (node.type === "NullLiteral") return [];
 	if (node.type === "BooleanLiteral" && node.value === false) return [];
 	if (node.type === "JSXElement" || node.type === "JSXFragment") {
-		const result = nodeFromJsx(node, bindings, filename);
+		const result = nodeFromJsx(node, bindings, context);
 		return result.kind === "fragment" ? result.value : [result];
 	}
-	return [nodeFromExpression(node, bindings, filename)];
+	return [nodeFromExpression(node, bindings, context)];
 }
-function listFromExpression(expression, bindings, filename) {
+function isControlFlowBranch(expression) {
+	const node = unwrapExpression(expression);
+	if (node.type === "JSXElement" || node.type === "JSXFragment") return true;
+	if (node.type === "NullLiteral") return true;
+	if (node.type === "BooleanLiteral" && node.value === false) return true;
+	if (node.type === "ConditionalExpression") return isControlFlowBranch(node.consequent) || isControlFlowBranch(node.alternate);
+	return false;
+}
+function listFromExpression(expression, bindings, context) {
 	const node = unwrapExpression(expression);
 	if (node.type !== "CallExpression" || node.callee.type !== "MemberExpression" || node.callee.computed || node.callee.property.type !== "Identifier" || node.callee.property.name !== "map") return;
 	const callback = unwrapExpression(node.arguments[0]);
-	if (!callback || !isFunctionLike(callback)) throw new Error(`${filename ?? "TSX"}: list render 的 map 参数必须是函数`);
+	if (!callback || !isFunctionLike(callback)) throw new Error(`${context.filename ?? "TSX"}: list render 的 map 参数必须是函数`);
 	const itemParam = callback.params[0];
-	if (itemParam?.type !== "Identifier") throw new Error(`${filename ?? "TSX"}: list render 必须声明 item 参数`);
+	if (itemParam?.type !== "Identifier") throw new Error(`${context.filename ?? "TSX"}: list render 必须声明 item 参数`);
 	const indexParam = callback.params[1];
-	if (indexParam && indexParam.type !== "Identifier") throw new Error(`${filename ?? "TSX"}: list render 的 index 参数必须是标识符`);
-	const bodyExpression = renderExpressionFromMapCallback(callback, filename);
+	if (indexParam && indexParam.type !== "Identifier") throw new Error(`${context.filename ?? "TSX"}: list render 的 index 参数必须是标识符`);
+	const bodyExpression = renderExpressionFromMapCallback(callback, context.filename);
+	const listContext = withTemplateAliases(context, [[itemParam.name, itemParam.name], ...indexParam ? [[indexParam.name, indexParam.name]] : []]);
 	return {
 		kind: "list",
 		value: {
-			source: bindingFromExpression(node.callee.object, false, filename),
+			source: bindingFromExpression(node.callee.object, false, context),
 			item_var: itemParam.name,
 			index_var: indexParam?.name,
-			key: keyBindingFromJsx(bodyExpression, filename),
-			body: nodesFromBranchExpression(bodyExpression, bindings, filename)
+			key: keyBindingFromJsx(bodyExpression, listContext),
+			body: nodesFromBranchExpression(bodyExpression, bindings, listContext)
 		}
 	};
 }
@@ -1053,14 +1266,14 @@ function renderExpressionFromMapCallback(callback, filename) {
 	}
 	throw new Error(`${filename ?? "TSX"}: list render 函数缺少 return 语句`);
 }
-function keyBindingFromJsx(expression, filename) {
+function keyBindingFromJsx(expression, context) {
 	const node = unwrapExpression(expression);
 	if (node.type !== "JSXElement") return;
 	const keyAttr = node.openingElement.attributes.find((attr) => attr.type === "JSXAttribute" && attr.name.type === "JSXIdentifier" && attr.name.name === "key");
 	if (!keyAttr) return;
-	return bindingFromAttribute(keyAttr.value, false, filename);
+	return bindingFromAttribute(keyAttr.value, false, context);
 }
-function attrFromValue(name, value, filename) {
+function attrFromValue(name, value, context) {
 	if (!value) return {
 		kind: "static",
 		value: true
@@ -1069,7 +1282,7 @@ function attrFromValue(name, value, filename) {
 		kind: "static",
 		value: value.value
 	};
-	if (value.type !== "JSXExpressionContainer") throw new Error(`${filename ?? "TSX"}: 不支持的属性值 ${value.type}`);
+	if (value.type !== "JSXExpressionContainer") throw new Error(`${context.filename ?? "TSX"}: 不支持的属性值 ${value.type}`);
 	const expression = unwrapExpression(value.expression);
 	const literal = literalValue(expression);
 	if (literal !== void 0) return {
@@ -1082,7 +1295,7 @@ function attrFromValue(name, value, filename) {
 		value: name === "style" ? normalizeStyleLiteral(staticObject) : staticObject
 	};
 	if (name === "style") {
-		const styleObject = styleObjectAttr(expression, filename);
+		const styleObject = styleObjectAttr(expression, context);
 		if (styleObject) return {
 			kind: "style_object",
 			value: styleObject
@@ -1090,16 +1303,16 @@ function attrFromValue(name, value, filename) {
 	}
 	return {
 		kind: "dynamic",
-		value: bindingFromExpression(expression, false, filename)
+		value: bindingFromExpression(expression, false, context)
 	};
 }
-function styleObjectAttr(expression, filename) {
+function styleObjectAttr(expression, context) {
 	const node = unwrapExpression(expression);
 	if (node.type !== "ObjectExpression") return void 0;
 	const slots = [];
 	for (const property of node.properties) {
-		if (property.type !== "ObjectProperty" || property.computed) throw new Error(`${filename ?? "TSX"}: style 对象暂不支持展开、方法或计算键`);
-		const key = kebabToCamel(objectPropertyKey(property.key, filename));
+		if (property.type !== "ObjectProperty" || property.computed) throw new Error(`${context.filename ?? "TSX"}: style 对象暂不支持展开、方法或计算键`);
+		const key = kebabToCamel(objectPropertyKey(property.key, context.filename));
 		const value = staticAttrLiteral(property.value);
 		if (value !== void 0) {
 			slots.push({
@@ -1115,7 +1328,7 @@ function styleObjectAttr(expression, filename) {
 			name: key,
 			value: {
 				kind: "dynamic",
-				value: bindingFromExpression(property.value, false, filename)
+				value: bindingFromExpression(property.value, false, context)
 			}
 		});
 	}
@@ -1160,17 +1373,27 @@ function staticAttrLiteral(expression) {
 		return out;
 	}
 }
-function bindingFromAttribute(value, callable, filename) {
-	if (!value || value.type !== "JSXExpressionContainer") throw new Error(`${filename ?? "TSX"}: 事件属性必须使用表达式绑定`);
-	return bindingFromExpression(unwrapExpression(value.expression), callable, filename);
+function bindingFromAttribute(value, callable, context) {
+	if (!value || value.type !== "JSXExpressionContainer") throw new Error(`${context.filename ?? "TSX"}: 事件属性必须使用表达式绑定`);
+	return bindingFromExpression(unwrapExpression(value.expression), callable, context);
 }
-function bindingFromExpression(expression, callable, filename) {
+function bindingFromExpression(expression, callable, context) {
+	const node = unwrapExpression(expression);
+	if (callable && isFunctionLike(node)) return {
+		path: sourceForNode(context.source, node),
+		expr: lowerTemplateEventHandler(context, node),
+		is_callable: true
+	};
 	const path = bindingPath(expression);
-	if (!path) throw new Error(`${filename ?? "TSX"}: 当前阶段仅支持标识符或成员访问绑定`);
-	return {
+	if (path) return {
 		path,
 		is_callable: callable
 	};
+	return {
+		path: sourceForNode(context.source, node),
+		expr: lowerTemplateExpression(context, node),
+		is_callable: callable
+	};
 }
 function bindingPath(expression) {
 	const node = unwrapExpression(expression);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astralsight/astroforge-rsbuild-plugin",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "AstroForge Plugin for RsBuild",
   "license": "MIT",
   "repository": {
@@ -38,7 +38,7 @@
   },
   "dependencies": {
     "@babel/parser": "^7.29.3",
-    "@astralsight/astroforge-core": "^0.0.6"
+    "@astralsight/astroforge-core": "^0.0.8"
   },
   "scripts": {
     "build": "tsdown"