Add Effect.delay factory and refactor Effect.run

The Effect.delay factory creates an effect that runs its callback after
a specified duration, with optional eager initialization. The Effect.run
method is extracted from the constructor to support manual execution.

Author: medz

packages/solidart/lib/src/v3.dart

@@ -1,13 +1,19 @@
 // ignore_for_file: public_member_api_docs
 // TODO(medz): Add code comments
 
+import 'dart:async';
+
 import 'package:meta/meta.dart';
 import 'package:solidart/deps/preset.dart' as preset;
 import 'package:solidart/deps/system.dart' as system;
 
 typedef ValueComparator<T> = bool Function(T? a, T? b);
 typedef ValueGetter<T> = T Function();
 typedef VoidCallback = ValueGetter<void>;
+typedef DelayEffectCallback =
+    ValueGetter<FutureOr<void>> Function(
+      T Function<T>(T Function() callback) on,
+    );
 
 sealed class Option<T> {
   const Option();
@@ -294,7 +300,19 @@ class Computed<T> extends preset.ComputedNode<T>
 class Effect extends preset.EffectNode
     with DisposableMixin
     implements Disposable, Configuration {
-  Effect(
+  factory Effect(
+    VoidCallback callback, {
+    bool? autoDispose,
+    String? name,
+    bool? detach,
+  }) => Effect.manual(
+    callback,
+    autoDispose: autoDispose,
+    name: name,
+    detach: detach,
+  )..run();
+
+  Effect.manual(
     VoidCallback callback, {
     bool? autoDispose,
     String? name,
@@ -306,18 +324,44 @@ class Effect extends preset.EffectNode
          fn: callback,
          flags:
              system.ReactiveFlags.watching | system.ReactiveFlags.recursedCheck,
-       ) {
-    final prevSub = preset.setActiveSub(this);
-    if (prevSub != null && !this.detach) {
-      preset.link(this, prevSub, 0);
-    }
+       );
 
-    try {
-      callback();
-    } finally {
-      preset.activeSub = prevSub;
-      flags &= ~system.ReactiveFlags.recursedCheck;
+  // TODO(nank1ro): How about this plan?
+  factory Effect.delay(
+    DelayEffectCallback factory, {
+    required Duration duration,
+    bool? autoDispose,
+    String? name,
+    bool? detach,
+    bool eager = true,
+  }) {
+    late final Effect effect;
+    T on<T>(T Function() callback) {
+      final prevSub = preset.setActiveSub(effect);
+      try {
+        return callback();
+      } finally {
+        preset.activeSub = prevSub;
+        effect.flags &= ~system.ReactiveFlags.recursedCheck;
+      }
     }
+
+    final callback = factory(on);
+    Timer? timer;
+    effect = Effect.manual(
+      autoDispose: autoDispose,
+      name: name,
+      detach: detach,
+      () {
+        timer?.cancel();
+        timer = .new(duration, () {
+          unawaited(Future.microtask(callback))
+        });
+      },
+    );
+
+    if (eager) effect.run();
+    return effect;
   }
 
   @override
@@ -328,6 +372,20 @@ class Effect extends preset.EffectNode
 
   final bool detach;
 
+  void run() {
+    final prevSub = preset.setActiveSub(this);
+    if (!detach && prevSub != null) {
+      preset.link(this, prevSub, 0);
+    }
+
+    try {
+      fn();
+    } finally {
+      preset.activeSub = prevSub;
+      flags &= ~system.ReactiveFlags.recursedCheck;
+    }
+  }
+
   @override
   void dispose() {
     if (isDisposed) return;