@fictjs/compiler 0.0.10 → 0.0.12

package/dist/index.cjs

@@ -22760,114 +22760,151 @@ function lowerIntrinsicElement(jsx, ctx) {
   for (const binding of bindings) {
     const targetId = resolveHIRBindingPath(binding.path, nodeCache, statements, ctx);
     if (binding.type === "event" && binding.expr && binding.name) {
-      const shouldWrapHandler = isExpressionReactive(binding.expr, ctx);
-      const prevWrapTracked = ctx.wrapTrackedExpressions;
-      ctx.wrapTrackedExpressions = false;
-      const valueExpr = lowerDomExpression(binding.expr, ctx, containingRegion, {
-        skipHookAccessors: true,
-        skipRegionRootOverride: true
-      });
-      ctx.wrapTrackedExpressions = prevWrapTracked;
-      const eventParam = t2.identifier("_e");
-      const isFn = t2.isArrowFunctionExpression(valueExpr) || t2.isFunctionExpression(valueExpr);
-      const ensureHandlerParam = (fn) => {
-        if (t2.isArrowFunctionExpression(fn)) {
-          if (fn.params.length > 0) return fn;
-          return t2.arrowFunctionExpression([eventParam], fn.body, fn.async);
-        }
-        if (t2.isFunctionExpression(fn)) {
-          if (fn.params.length > 0) return fn;
-          return t2.functionExpression(fn.id, [eventParam], fn.body, fn.generator, fn.async);
-        }
-        return t2.arrowFunctionExpression(
-          [eventParam],
-          t2.callExpression(fn, [eventParam])
-        );
-      };
-      const handlerExpr = !isFn && shouldWrapHandler ? t2.arrowFunctionExpression([], valueExpr) : ensureHandlerParam(valueExpr);
       const eventName = binding.name;
       const hasEventOptions = binding.eventOptions && (binding.eventOptions.capture || binding.eventOptions.passive || binding.eventOptions.once);
       const isDelegated = DelegatedEvents.has(eventName) && !hasEventOptions;
-      const dataBinding = isDelegated && !shouldWrapHandler ? extractDelegatedEventData(valueExpr, t2) : null;
-      if (isDelegated) {
+      const hirDataBinding = isDelegated && binding.expr ? extractDelegatedEventDataFromHIR(binding.expr, ctx) : null;
+      if (hirDataBinding) {
         ctx.delegatedEventsUsed?.add(eventName);
-        const finalHandler = !isFn && shouldWrapHandler ? t2.arrowFunctionExpression([eventParam], t2.callExpression(valueExpr, [eventParam])) : handlerExpr;
-        const normalizeHandler = (expr) => {
-          if (t2.isCallExpression(expr) && (t2.isIdentifier(expr.callee) || t2.isMemberExpression(expr.callee))) {
-            return expr.callee;
-          }
-          return expr;
-        };
-        const normalizedDataHandler = dataBinding !== null ? normalizeHandler(dataBinding?.handler ?? handlerExpr) : null;
-        const dataForDelegate = dataBinding?.data && (t2.isArrowFunctionExpression(dataBinding.data) || t2.isFunctionExpression(dataBinding.data) ? dataBinding.data : t2.arrowFunctionExpression([], dataBinding.data));
-        const handlerForDelegate = normalizedDataHandler ?? (dataBinding ? normalizeHandler(handlerExpr) : finalHandler);
-        const handlerIsCallableExpr = t2.isArrowFunctionExpression(handlerForDelegate) || t2.isFunctionExpression(handlerForDelegate) || t2.isIdentifier(handlerForDelegate) || t2.isMemberExpression(handlerForDelegate);
-        let handlerToAssign = handlerIsCallableExpr ? handlerForDelegate : t2.arrowFunctionExpression([eventParam], handlerForDelegate);
-        if (dataForDelegate) {
-          let payloadExpr;
-          if (t2.isArrowFunctionExpression(dataForDelegate) && dataForDelegate.params.length === 0) {
-            payloadExpr = t2.isBlockStatement(dataForDelegate.body) ? t2.callExpression(t2.arrowFunctionExpression([], dataForDelegate.body), []) : dataForDelegate.body;
-          } else {
-            payloadExpr = t2.callExpression(dataForDelegate, []);
-          }
-          handlerToAssign = t2.arrowFunctionExpression(
-            [eventParam],
-            t2.callExpression(handlerForDelegate, [payloadExpr])
-          );
-        }
+        const handlerExpr = lowerExpression(hirDataBinding.handler, ctx);
+        const dataExpr = lowerDomExpression(hirDataBinding.data, ctx, containingRegion, {
+          skipHookAccessors: false,
+          skipRegionRootOverride: true
+        });
+        const dataParam = t2.identifier("__data");
+        const eventParam = t2.identifier("_e");
+        const wrappedHandler = t2.arrowFunctionExpression(
+          [dataParam, eventParam],
+          t2.callExpression(handlerExpr, [dataParam])
+        );
         statements.push(
           t2.expressionStatement(
             t2.assignmentExpression(
               "=",
               t2.memberExpression(targetId, t2.identifier(`$$${eventName}`)),
-              handlerToAssign
+              wrappedHandler
             )
           )
         );
-        if (dataForDelegate) {
+        const dataGetter = t2.arrowFunctionExpression([], dataExpr);
+        statements.push(
+          t2.expressionStatement(
+            t2.assignmentExpression(
+              "=",
+              t2.memberExpression(targetId, t2.identifier(`$$${eventName}Data`)),
+              dataGetter
+            )
+          )
+        );
+      } else {
+        const shouldWrapHandler = isExpressionReactive(binding.expr, ctx);
+        const prevWrapTracked = ctx.wrapTrackedExpressions;
+        ctx.wrapTrackedExpressions = false;
+        const valueExpr = lowerDomExpression(binding.expr, ctx, containingRegion, {
+          skipHookAccessors: true,
+          skipRegionRootOverride: true
+        });
+        ctx.wrapTrackedExpressions = prevWrapTracked;
+        const eventParam = t2.identifier("_e");
+        const isFn = t2.isArrowFunctionExpression(valueExpr) || t2.isFunctionExpression(valueExpr);
+        const ensureHandlerParam = (fn) => {
+          if (t2.isArrowFunctionExpression(fn)) {
+            if (fn.params.length > 0) return fn;
+            return t2.arrowFunctionExpression([eventParam], fn.body, fn.async);
+          }
+          if (t2.isFunctionExpression(fn)) {
+            if (fn.params.length > 0) return fn;
+            return t2.functionExpression(fn.id, [eventParam], fn.body, fn.generator, fn.async);
+          }
+          return t2.arrowFunctionExpression(
+            [eventParam],
+            t2.callExpression(fn, [eventParam])
+          );
+        };
+        const handlerExpr = !isFn && shouldWrapHandler ? t2.arrowFunctionExpression([], valueExpr) : ensureHandlerParam(valueExpr);
+        const dataBinding = isDelegated && !shouldWrapHandler ? extractDelegatedEventData(valueExpr, t2) : null;
+        if (isDelegated) {
+          ctx.delegatedEventsUsed?.add(eventName);
+          const finalHandler = !isFn && shouldWrapHandler ? t2.arrowFunctionExpression([eventParam], t2.callExpression(valueExpr, [eventParam])) : handlerExpr;
+          const normalizeHandler = (expr) => {
+            if (t2.isCallExpression(expr) && (t2.isIdentifier(expr.callee) || t2.isMemberExpression(expr.callee))) {
+              return expr.callee;
+            }
+            return expr;
+          };
+          const normalizedDataHandler = dataBinding !== null ? normalizeHandler(
+            dataBinding?.handler ?? handlerExpr
+          ) : null;
+          const dataForDelegate = dataBinding?.data && (t2.isArrowFunctionExpression(dataBinding.data) || t2.isFunctionExpression(dataBinding.data) ? dataBinding.data : t2.arrowFunctionExpression([], dataBinding.data));
+          const handlerForDelegate = normalizedDataHandler ?? (dataBinding ? normalizeHandler(handlerExpr) : finalHandler);
+          const handlerIsCallableExpr = t2.isArrowFunctionExpression(handlerForDelegate) || t2.isFunctionExpression(handlerForDelegate) || t2.isIdentifier(handlerForDelegate) || t2.isMemberExpression(handlerForDelegate);
+          let handlerToAssign = handlerIsCallableExpr ? handlerForDelegate : t2.arrowFunctionExpression([eventParam], handlerForDelegate);
+          if (dataForDelegate) {
+            let payloadExpr;
+            if (t2.isArrowFunctionExpression(dataForDelegate) && dataForDelegate.params.length === 0) {
+              payloadExpr = t2.isBlockStatement(dataForDelegate.body) ? t2.callExpression(t2.arrowFunctionExpression([], dataForDelegate.body), []) : dataForDelegate.body;
+            } else {
+              payloadExpr = t2.callExpression(dataForDelegate, []);
+            }
+            handlerToAssign = t2.arrowFunctionExpression(
+              [eventParam],
+              t2.callExpression(handlerForDelegate, [payloadExpr])
+            );
+          }
           statements.push(
             t2.expressionStatement(
               t2.assignmentExpression(
                 "=",
-                t2.memberExpression(targetId, t2.identifier(`$$${eventName}Data`)),
-                dataForDelegate
+                t2.memberExpression(targetId, t2.identifier(`$$${eventName}`)),
+                handlerToAssign
               )
             )
           );
-        }
-      } else {
-        ctx.helpersUsed.add("bindEvent");
-        ctx.helpersUsed.add("onDestroy");
-        const cleanupId = genTemp(ctx, "evt");
-        const args = [
-          targetId,
-          t2.stringLiteral(eventName),
-          handlerExpr
-        ];
-        if (hasEventOptions && binding.eventOptions) {
-          const optionProps = [];
-          if (binding.eventOptions.capture) {
-            optionProps.push(t2.objectProperty(t2.identifier("capture"), t2.booleanLiteral(true)));
-          }
-          if (binding.eventOptions.passive) {
-            optionProps.push(t2.objectProperty(t2.identifier("passive"), t2.booleanLiteral(true)));
+          if (dataForDelegate) {
+            statements.push(
+              t2.expressionStatement(
+                t2.assignmentExpression(
+                  "=",
+                  t2.memberExpression(targetId, t2.identifier(`$$${eventName}Data`)),
+                  dataForDelegate
+                )
+              )
+            );
           }
-          if (binding.eventOptions.once) {
-            optionProps.push(t2.objectProperty(t2.identifier("once"), t2.booleanLiteral(true)));
+        } else {
+          ctx.helpersUsed.add("bindEvent");
+          ctx.helpersUsed.add("onDestroy");
+          const cleanupId = genTemp(ctx, "evt");
+          const args = [
+            targetId,
+            t2.stringLiteral(eventName),
+            handlerExpr
+          ];
+          if (hasEventOptions && binding.eventOptions) {
+            const optionProps = [];
+            if (binding.eventOptions.capture) {
+              optionProps.push(t2.objectProperty(t2.identifier("capture"), t2.booleanLiteral(true)));
+            }
+            if (binding.eventOptions.passive) {
+              optionProps.push(t2.objectProperty(t2.identifier("passive"), t2.booleanLiteral(true)));
+            }
+            if (binding.eventOptions.once) {
+              optionProps.push(t2.objectProperty(t2.identifier("once"), t2.booleanLiteral(true)));
+            }
+            args.push(t2.objectExpression(optionProps));
           }
-          args.push(t2.objectExpression(optionProps));
-        }
-        statements.push(
-          t2.variableDeclaration("const", [
-            t2.variableDeclarator(
-              cleanupId,
-              t2.callExpression(t2.identifier(RUNTIME_ALIASES.bindEvent), args)
+          statements.push(
+            t2.variableDeclaration("const", [
+              t2.variableDeclarator(
+                cleanupId,
+                t2.callExpression(t2.identifier(RUNTIME_ALIASES.bindEvent), args)
+              )
+            ]),
+            t2.expressionStatement(
+              t2.callExpression(t2.identifier(RUNTIME_ALIASES.onDestroy), [cleanupId])
             )
-          ]),
-          t2.expressionStatement(
-            t2.callExpression(t2.identifier(RUNTIME_ALIASES.onDestroy), [cleanupId])
-          )
-        );
+          );
+        }
       }
     } else if (binding.type === "attr" && binding.name) {
       const attrName = binding.name;
@@ -23254,6 +23291,82 @@ function extractDelegatedEventData(expr, t2) {
     data: dataArg && t2.isExpression(dataArg) ? dataArg : void 0
   };
 }
+function extractDelegatedEventDataFromHIR(expr, ctx) {
+  if (expr.kind !== "ArrowFunction" && expr.kind !== "FunctionExpression") {
+    return null;
+  }
+  let bodyExpr = null;
+  if (expr.kind === "ArrowFunction") {
+    if (expr.isExpression && !Array.isArray(expr.body)) {
+      bodyExpr = expr.body;
+    }
+  }
+  if (!bodyExpr || bodyExpr.kind !== "CallExpression") {
+    return null;
+  }
+  const callee = bodyExpr.callee;
+  if (callee.kind !== "Identifier") {
+    return null;
+  }
+  if (bodyExpr.arguments.length !== 1) {
+    return null;
+  }
+  if (callee.kind === "Identifier") {
+    const handlerName = deSSAVarName(callee.name);
+    const isTrackedAccessor = ctx.signalVars?.has(handlerName) || ctx.memoVars?.has(handlerName) || ctx.aliasVars?.has(handlerName);
+    if (isTrackedAccessor) {
+      return null;
+    }
+  }
+  const paramNames = new Set(expr.params.map((p) => p.name));
+  const dataExpr = bodyExpr.arguments[0];
+  if (!dataExpr) {
+    return null;
+  }
+  if (hirExpressionUsesIdentifiers(dataExpr, paramNames)) {
+    return null;
+  }
+  return {
+    handler: callee,
+    data: dataExpr
+  };
+}
+function hirExpressionUsesIdentifiers(expr, names) {
+  if (expr.kind === "Identifier") {
+    return names.has(deSSAVarName(expr.name));
+  }
+  switch (expr.kind) {
+    case "BinaryExpression":
+    case "LogicalExpression":
+      return hirExpressionUsesIdentifiers(expr.left, names) || hirExpressionUsesIdentifiers(expr.right, names);
+    case "UnaryExpression":
+      return hirExpressionUsesIdentifiers(expr.argument, names);
+    case "ConditionalExpression":
+      return hirExpressionUsesIdentifiers(expr.test, names) || hirExpressionUsesIdentifiers(expr.consequent, names) || hirExpressionUsesIdentifiers(expr.alternate, names);
+    case "CallExpression":
+    case "OptionalCallExpression":
+      return hirExpressionUsesIdentifiers(expr.callee, names) || expr.arguments.some((arg) => hirExpressionUsesIdentifiers(arg, names));
+    case "MemberExpression":
+    case "OptionalMemberExpression":
+      return hirExpressionUsesIdentifiers(expr.object, names) || expr.computed && hirExpressionUsesIdentifiers(expr.property, names);
+    case "ArrayExpression":
+      return expr.elements.some((el) => el && hirExpressionUsesIdentifiers(el, names));
+    case "ObjectExpression":
+      return expr.properties.some((prop) => {
+        if (prop.kind === "SpreadElement") {
+          return hirExpressionUsesIdentifiers(prop.argument, names);
+        }
+        return hirExpressionUsesIdentifiers(prop.key, names) || hirExpressionUsesIdentifiers(prop.value, names);
+      });
+    case "TemplateLiteral":
+      return expr.expressions.some((e) => hirExpressionUsesIdentifiers(e, names));
+    case "ArrowFunction":
+    case "FunctionExpression":
+      return false;
+    default:
+      return false;
+  }
+}
 function getTrackedCallIdentifier(expr, ctx, itemParamName) {
   if (ctx.t.isCallExpression(expr) && ctx.t.isIdentifier(expr.callee)) {
     if (expr.arguments.length !== 0) return null;

package/dist/index.js

@@ -22748,114 +22748,151 @@ function lowerIntrinsicElement(jsx, ctx) {
   for (const binding of bindings) {
     const targetId = resolveHIRBindingPath(binding.path, nodeCache, statements, ctx);
     if (binding.type === "event" && binding.expr && binding.name) {
-      const shouldWrapHandler = isExpressionReactive(binding.expr, ctx);
-      const prevWrapTracked = ctx.wrapTrackedExpressions;
-      ctx.wrapTrackedExpressions = false;
-      const valueExpr = lowerDomExpression(binding.expr, ctx, containingRegion, {
-        skipHookAccessors: true,
-        skipRegionRootOverride: true
-      });
-      ctx.wrapTrackedExpressions = prevWrapTracked;
-      const eventParam = t2.identifier("_e");
-      const isFn = t2.isArrowFunctionExpression(valueExpr) || t2.isFunctionExpression(valueExpr);
-      const ensureHandlerParam = (fn) => {
-        if (t2.isArrowFunctionExpression(fn)) {
-          if (fn.params.length > 0) return fn;
-          return t2.arrowFunctionExpression([eventParam], fn.body, fn.async);
-        }
-        if (t2.isFunctionExpression(fn)) {
-          if (fn.params.length > 0) return fn;
-          return t2.functionExpression(fn.id, [eventParam], fn.body, fn.generator, fn.async);
-        }
-        return t2.arrowFunctionExpression(
-          [eventParam],
-          t2.callExpression(fn, [eventParam])
-        );
-      };
-      const handlerExpr = !isFn && shouldWrapHandler ? t2.arrowFunctionExpression([], valueExpr) : ensureHandlerParam(valueExpr);
       const eventName = binding.name;
       const hasEventOptions = binding.eventOptions && (binding.eventOptions.capture || binding.eventOptions.passive || binding.eventOptions.once);
       const isDelegated = DelegatedEvents.has(eventName) && !hasEventOptions;
-      const dataBinding = isDelegated && !shouldWrapHandler ? extractDelegatedEventData(valueExpr, t2) : null;
-      if (isDelegated) {
+      const hirDataBinding = isDelegated && binding.expr ? extractDelegatedEventDataFromHIR(binding.expr, ctx) : null;
+      if (hirDataBinding) {
         ctx.delegatedEventsUsed?.add(eventName);
-        const finalHandler = !isFn && shouldWrapHandler ? t2.arrowFunctionExpression([eventParam], t2.callExpression(valueExpr, [eventParam])) : handlerExpr;
-        const normalizeHandler = (expr) => {
-          if (t2.isCallExpression(expr) && (t2.isIdentifier(expr.callee) || t2.isMemberExpression(expr.callee))) {
-            return expr.callee;
-          }
-          return expr;
-        };
-        const normalizedDataHandler = dataBinding !== null ? normalizeHandler(dataBinding?.handler ?? handlerExpr) : null;
-        const dataForDelegate = dataBinding?.data && (t2.isArrowFunctionExpression(dataBinding.data) || t2.isFunctionExpression(dataBinding.data) ? dataBinding.data : t2.arrowFunctionExpression([], dataBinding.data));
-        const handlerForDelegate = normalizedDataHandler ?? (dataBinding ? normalizeHandler(handlerExpr) : finalHandler);
-        const handlerIsCallableExpr = t2.isArrowFunctionExpression(handlerForDelegate) || t2.isFunctionExpression(handlerForDelegate) || t2.isIdentifier(handlerForDelegate) || t2.isMemberExpression(handlerForDelegate);
-        let handlerToAssign = handlerIsCallableExpr ? handlerForDelegate : t2.arrowFunctionExpression([eventParam], handlerForDelegate);
-        if (dataForDelegate) {
-          let payloadExpr;
-          if (t2.isArrowFunctionExpression(dataForDelegate) && dataForDelegate.params.length === 0) {
-            payloadExpr = t2.isBlockStatement(dataForDelegate.body) ? t2.callExpression(t2.arrowFunctionExpression([], dataForDelegate.body), []) : dataForDelegate.body;
-          } else {
-            payloadExpr = t2.callExpression(dataForDelegate, []);
-          }
-          handlerToAssign = t2.arrowFunctionExpression(
-            [eventParam],
-            t2.callExpression(handlerForDelegate, [payloadExpr])
-          );
-        }
+        const handlerExpr = lowerExpression(hirDataBinding.handler, ctx);
+        const dataExpr = lowerDomExpression(hirDataBinding.data, ctx, containingRegion, {
+          skipHookAccessors: false,
+          skipRegionRootOverride: true
+        });
+        const dataParam = t2.identifier("__data");
+        const eventParam = t2.identifier("_e");
+        const wrappedHandler = t2.arrowFunctionExpression(
+          [dataParam, eventParam],
+          t2.callExpression(handlerExpr, [dataParam])
+        );
         statements.push(
           t2.expressionStatement(
             t2.assignmentExpression(
               "=",
               t2.memberExpression(targetId, t2.identifier(`$$${eventName}`)),
-              handlerToAssign
+              wrappedHandler
             )
           )
         );
-        if (dataForDelegate) {
+        const dataGetter = t2.arrowFunctionExpression([], dataExpr);
+        statements.push(
+          t2.expressionStatement(
+            t2.assignmentExpression(
+              "=",
+              t2.memberExpression(targetId, t2.identifier(`$$${eventName}Data`)),
+              dataGetter
+            )
+          )
+        );
+      } else {
+        const shouldWrapHandler = isExpressionReactive(binding.expr, ctx);
+        const prevWrapTracked = ctx.wrapTrackedExpressions;
+        ctx.wrapTrackedExpressions = false;
+        const valueExpr = lowerDomExpression(binding.expr, ctx, containingRegion, {
+          skipHookAccessors: true,
+          skipRegionRootOverride: true
+        });
+        ctx.wrapTrackedExpressions = prevWrapTracked;
+        const eventParam = t2.identifier("_e");
+        const isFn = t2.isArrowFunctionExpression(valueExpr) || t2.isFunctionExpression(valueExpr);
+        const ensureHandlerParam = (fn) => {
+          if (t2.isArrowFunctionExpression(fn)) {
+            if (fn.params.length > 0) return fn;
+            return t2.arrowFunctionExpression([eventParam], fn.body, fn.async);
+          }
+          if (t2.isFunctionExpression(fn)) {
+            if (fn.params.length > 0) return fn;
+            return t2.functionExpression(fn.id, [eventParam], fn.body, fn.generator, fn.async);
+          }
+          return t2.arrowFunctionExpression(
+            [eventParam],
+            t2.callExpression(fn, [eventParam])
+          );
+        };
+        const handlerExpr = !isFn && shouldWrapHandler ? t2.arrowFunctionExpression([], valueExpr) : ensureHandlerParam(valueExpr);
+        const dataBinding = isDelegated && !shouldWrapHandler ? extractDelegatedEventData(valueExpr, t2) : null;
+        if (isDelegated) {
+          ctx.delegatedEventsUsed?.add(eventName);
+          const finalHandler = !isFn && shouldWrapHandler ? t2.arrowFunctionExpression([eventParam], t2.callExpression(valueExpr, [eventParam])) : handlerExpr;
+          const normalizeHandler = (expr) => {
+            if (t2.isCallExpression(expr) && (t2.isIdentifier(expr.callee) || t2.isMemberExpression(expr.callee))) {
+              return expr.callee;
+            }
+            return expr;
+          };
+          const normalizedDataHandler = dataBinding !== null ? normalizeHandler(
+            dataBinding?.handler ?? handlerExpr
+          ) : null;
+          const dataForDelegate = dataBinding?.data && (t2.isArrowFunctionExpression(dataBinding.data) || t2.isFunctionExpression(dataBinding.data) ? dataBinding.data : t2.arrowFunctionExpression([], dataBinding.data));
+          const handlerForDelegate = normalizedDataHandler ?? (dataBinding ? normalizeHandler(handlerExpr) : finalHandler);
+          const handlerIsCallableExpr = t2.isArrowFunctionExpression(handlerForDelegate) || t2.isFunctionExpression(handlerForDelegate) || t2.isIdentifier(handlerForDelegate) || t2.isMemberExpression(handlerForDelegate);
+          let handlerToAssign = handlerIsCallableExpr ? handlerForDelegate : t2.arrowFunctionExpression([eventParam], handlerForDelegate);
+          if (dataForDelegate) {
+            let payloadExpr;
+            if (t2.isArrowFunctionExpression(dataForDelegate) && dataForDelegate.params.length === 0) {
+              payloadExpr = t2.isBlockStatement(dataForDelegate.body) ? t2.callExpression(t2.arrowFunctionExpression([], dataForDelegate.body), []) : dataForDelegate.body;
+            } else {
+              payloadExpr = t2.callExpression(dataForDelegate, []);
+            }
+            handlerToAssign = t2.arrowFunctionExpression(
+              [eventParam],
+              t2.callExpression(handlerForDelegate, [payloadExpr])
+            );
+          }
           statements.push(
             t2.expressionStatement(
               t2.assignmentExpression(
                 "=",
-                t2.memberExpression(targetId, t2.identifier(`$$${eventName}Data`)),
-                dataForDelegate
+                t2.memberExpression(targetId, t2.identifier(`$$${eventName}`)),
+                handlerToAssign
               )
             )
           );
-        }
-      } else {
-        ctx.helpersUsed.add("bindEvent");
-        ctx.helpersUsed.add("onDestroy");
-        const cleanupId = genTemp(ctx, "evt");
-        const args = [
-          targetId,
-          t2.stringLiteral(eventName),
-          handlerExpr
-        ];
-        if (hasEventOptions && binding.eventOptions) {
-          const optionProps = [];
-          if (binding.eventOptions.capture) {
-            optionProps.push(t2.objectProperty(t2.identifier("capture"), t2.booleanLiteral(true)));
-          }
-          if (binding.eventOptions.passive) {
-            optionProps.push(t2.objectProperty(t2.identifier("passive"), t2.booleanLiteral(true)));
+          if (dataForDelegate) {
+            statements.push(
+              t2.expressionStatement(
+                t2.assignmentExpression(
+                  "=",
+                  t2.memberExpression(targetId, t2.identifier(`$$${eventName}Data`)),
+                  dataForDelegate
+                )
+              )
+            );
           }
-          if (binding.eventOptions.once) {
-            optionProps.push(t2.objectProperty(t2.identifier("once"), t2.booleanLiteral(true)));
+        } else {
+          ctx.helpersUsed.add("bindEvent");
+          ctx.helpersUsed.add("onDestroy");
+          const cleanupId = genTemp(ctx, "evt");
+          const args = [
+            targetId,
+            t2.stringLiteral(eventName),
+            handlerExpr
+          ];
+          if (hasEventOptions && binding.eventOptions) {
+            const optionProps = [];
+            if (binding.eventOptions.capture) {
+              optionProps.push(t2.objectProperty(t2.identifier("capture"), t2.booleanLiteral(true)));
+            }
+            if (binding.eventOptions.passive) {
+              optionProps.push(t2.objectProperty(t2.identifier("passive"), t2.booleanLiteral(true)));
+            }
+            if (binding.eventOptions.once) {
+              optionProps.push(t2.objectProperty(t2.identifier("once"), t2.booleanLiteral(true)));
+            }
+            args.push(t2.objectExpression(optionProps));
           }
-          args.push(t2.objectExpression(optionProps));
-        }
-        statements.push(
-          t2.variableDeclaration("const", [
-            t2.variableDeclarator(
-              cleanupId,
-              t2.callExpression(t2.identifier(RUNTIME_ALIASES.bindEvent), args)
+          statements.push(
+            t2.variableDeclaration("const", [
+              t2.variableDeclarator(
+                cleanupId,
+                t2.callExpression(t2.identifier(RUNTIME_ALIASES.bindEvent), args)
+              )
+            ]),
+            t2.expressionStatement(
+              t2.callExpression(t2.identifier(RUNTIME_ALIASES.onDestroy), [cleanupId])
             )
-          ]),
-          t2.expressionStatement(
-            t2.callExpression(t2.identifier(RUNTIME_ALIASES.onDestroy), [cleanupId])
-          )
-        );
+          );
+        }
       }
     } else if (binding.type === "attr" && binding.name) {
       const attrName = binding.name;
@@ -23242,6 +23279,82 @@ function extractDelegatedEventData(expr, t2) {
     data: dataArg && t2.isExpression(dataArg) ? dataArg : void 0
   };
 }
+function extractDelegatedEventDataFromHIR(expr, ctx) {
+  if (expr.kind !== "ArrowFunction" && expr.kind !== "FunctionExpression") {
+    return null;
+  }
+  let bodyExpr = null;
+  if (expr.kind === "ArrowFunction") {
+    if (expr.isExpression && !Array.isArray(expr.body)) {
+      bodyExpr = expr.body;
+    }
+  }
+  if (!bodyExpr || bodyExpr.kind !== "CallExpression") {
+    return null;
+  }
+  const callee = bodyExpr.callee;
+  if (callee.kind !== "Identifier") {
+    return null;
+  }
+  if (bodyExpr.arguments.length !== 1) {
+    return null;
+  }
+  if (callee.kind === "Identifier") {
+    const handlerName = deSSAVarName(callee.name);
+    const isTrackedAccessor = ctx.signalVars?.has(handlerName) || ctx.memoVars?.has(handlerName) || ctx.aliasVars?.has(handlerName);
+    if (isTrackedAccessor) {
+      return null;
+    }
+  }
+  const paramNames = new Set(expr.params.map((p) => p.name));
+  const dataExpr = bodyExpr.arguments[0];
+  if (!dataExpr) {
+    return null;
+  }
+  if (hirExpressionUsesIdentifiers(dataExpr, paramNames)) {
+    return null;
+  }
+  return {
+    handler: callee,
+    data: dataExpr
+  };
+}
+function hirExpressionUsesIdentifiers(expr, names) {
+  if (expr.kind === "Identifier") {
+    return names.has(deSSAVarName(expr.name));
+  }
+  switch (expr.kind) {
+    case "BinaryExpression":
+    case "LogicalExpression":
+      return hirExpressionUsesIdentifiers(expr.left, names) || hirExpressionUsesIdentifiers(expr.right, names);
+    case "UnaryExpression":
+      return hirExpressionUsesIdentifiers(expr.argument, names);
+    case "ConditionalExpression":
+      return hirExpressionUsesIdentifiers(expr.test, names) || hirExpressionUsesIdentifiers(expr.consequent, names) || hirExpressionUsesIdentifiers(expr.alternate, names);
+    case "CallExpression":
+    case "OptionalCallExpression":
+      return hirExpressionUsesIdentifiers(expr.callee, names) || expr.arguments.some((arg) => hirExpressionUsesIdentifiers(arg, names));
+    case "MemberExpression":
+    case "OptionalMemberExpression":
+      return hirExpressionUsesIdentifiers(expr.object, names) || expr.computed && hirExpressionUsesIdentifiers(expr.property, names);
+    case "ArrayExpression":
+      return expr.elements.some((el) => el && hirExpressionUsesIdentifiers(el, names));
+    case "ObjectExpression":
+      return expr.properties.some((prop) => {
+        if (prop.kind === "SpreadElement") {
+          return hirExpressionUsesIdentifiers(prop.argument, names);
+        }
+        return hirExpressionUsesIdentifiers(prop.key, names) || hirExpressionUsesIdentifiers(prop.value, names);
+      });
+    case "TemplateLiteral":
+      return expr.expressions.some((e) => hirExpressionUsesIdentifiers(e, names));
+    case "ArrowFunction":
+    case "FunctionExpression":
+      return false;
+    default:
+      return false;
+  }
+}
 function getTrackedCallIdentifier(expr, ctx, itemParamName) {
   if (ctx.t.isCallExpression(expr) && ctx.t.isIdentifier(expr.callee)) {
     if (expr.arguments.length !== 0) return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fictjs/compiler",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "description": "Babel plugin for Fict Compiler",
   "publishConfig": {
     "access": "public",
@@ -45,7 +45,7 @@
     "@types/babel__helper-plugin-utils": "^7.10.3",
     "@types/babel__traverse": "^7.28.0",
     "tsup": "^8.5.1",
-    "@fictjs/runtime": "0.0.10"
+    "@fictjs/runtime": "0.0.12"
   },
   "scripts": {
     "build": "tsup src/index.ts --format cjs,esm --dts",