Run hover, cursorEnter and cursorExit reactions

They were never wired: a tooltip shown on hover never appeared. A node with
them gets a non-blocking MouseRegion that runs them on enter and exit.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NNTVgYqUeBTGwAHuspt3D7

Author: claude

lib/src/transformers/widget_node_transformer_manager.dart

@@ -227,6 +227,59 @@ abstract class WidgetNodeTransformerManager
 
   /// Convenience method to handle widget reactions.
   Widget wrapWithReaction(BuildContext context, BaseNode node, Widget widget) {
+    return _wrapWithPointerReactions(
+      context,
+      node,
+      _wrapWithTapReactions(context, node, widget),
+    );
+  }
+
+  /// Runs [node]'s hover and cursorEnter reactions when a mouse enters it
+  /// and its cursorExit reactions when it leaves, e.g. to show a tooltip
+  /// over a map pad. Doesn't take part in hit testing, so taps still reach
+  /// the widget.
+  Widget _wrapWithPointerReactions(
+    BuildContext context,
+    BaseNode node,
+    Widget widget,
+  ) {
+    if (node is! ReactionMixin || node is CanvasNode) return widget;
+    List<Reaction> of(Set<TriggerType> types) => (node as ReactionMixin)
+        .reactions
+        .where((r) => types.contains(r.trigger.type) && r.action.enabled)
+        .toList();
+    final List<Reaction> enter = of({
+      TriggerType.hover,
+      TriggerType.cursorEnter,
+    });
+    final List<Reaction> exit = of({TriggerType.cursorExit});
+    if (enter.isEmpty && exit.isEmpty) return widget;
+    return MouseRegion(
+      opaque: false,
+      hitTestBehavior: HitTestBehavior.translucent,
+      onEnter: enter.isEmpty
+          ? null
+          : (_) => FunctionsRepository.triggerAction(
+              context,
+              enter.first.trigger.type,
+              reactions: enter,
+            ),
+      onExit: exit.isEmpty
+          ? null
+          : (_) => FunctionsRepository.triggerAction(
+              context,
+              TriggerType.cursorExit,
+              reactions: exit,
+            ),
+      child: widget,
+    );
+  }
+
+  Widget _wrapWithTapReactions(
+    BuildContext context,
+    BaseNode node,
+    Widget widget,
+  ) {
     if (node is! ReactionMixin) return widget;
     if (node case CanvasNode() || SpacerNode()) return widget;
     if (node is CustomPropertiesMixin &&
@@ -293,7 +346,6 @@ abstract class WidgetNodeTransformerManager
       if (onClickReactions.isEmpty && onLongPressReactions.isEmpty) {
         return widget;
       }
-      // TODO: should handle TriggerType.hover and TriggerType.unhover too.
       return MouseRegion(
         cursor: SystemMouseCursors.click,
         hitTestBehavior: HitTestBehavior.opaque,

test/pointer_reactions_test.dart

@@ -0,0 +1,78 @@
+import 'package:codelessly_api/codelessly_api.dart';
+import 'package:codelessly_sdk/codelessly_sdk.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+Reaction reaction(TriggerType type) => Reaction(
+  name: type.name,
+  trigger: TriggerModel(type: type),
+  action: LinkAction(url: ''),
+);
+
+RectangleNode pad(List<Reaction> reactions) => RectangleNode(
+  id: 'pad',
+  name: 'Pad',
+  basicBoxLocal: NodeBox(0, 0, 44, 30),
+  reactions: reactions,
+);
+
+void main() {
+  final manager = PassiveNodeTransformerManager(
+    (id) => throw StateError(id),
+    (context, bounds, pageID, layoutID, canvasID) => const SizedBox(),
+  );
+
+  Future<MouseRegion?> regionFor(
+    WidgetTester tester,
+    RectangleNode node,
+  ) async {
+    await tester.pumpWidget(
+      MaterialApp(
+        home: Builder(
+          builder: (context) => manager.wrapWithReaction(
+            context,
+            node,
+            const SizedBox(key: Key('pad'), width: 44, height: 30),
+          ),
+        ),
+      ),
+    );
+    final regions = tester
+        .widgetList<MouseRegion>(
+          find.ancestor(
+            of: find.byKey(const Key('pad')),
+            matching: find.byType(MouseRegion),
+          ),
+        )
+        .where((r) => r.onEnter != null || r.onExit != null);
+    return regions.firstOrNull;
+  }
+
+  testWidgets('hover and cursor enter/exit reactions get a mouse region', (
+    tester,
+  ) async {
+    final MouseRegion? both = await regionFor(
+      tester,
+      pad([
+        reaction(TriggerType.cursorEnter),
+        reaction(TriggerType.cursorExit),
+      ]),
+    );
+    expect(both, isNotNull);
+    expect(both!.onEnter, isNotNull);
+    expect(both.onExit, isNotNull);
+    expect(both.opaque, isFalse, reason: 'taps still reach the node');
+
+    final MouseRegion? hover = await regionFor(
+      tester,
+      pad([reaction(TriggerType.hover)]),
+    );
+    expect(hover?.onEnter, isNotNull);
+    expect(hover?.onExit, isNull);
+  });
+
+  testWidgets('a node without pointer reactions gets none', (tester) async {
+    expect(await regionFor(tester, pad([reaction(TriggerType.click)])), isNull);
+    expect(await regionFor(tester, pad([])), isNull);
+  });
+}