From 1ae8ad59f2cf85d5e38f54bf264e8dd3b5c831ee Mon Sep 17 00:00:00 2001
From: mcmah309 <dillonmcmahon79@gmail.com>
Date: Mon, 2 Dec 2024 06:31:49 +0000
Subject: [PATCH 1/5] feat: Add computedFrom for records

---
 .../signals_core/lib/src/async/computed.dart  | 135 +++++++++++++++++-
 .../lib/src/mixins/signals.dart               | 124 +++++++++++++++-
 2 files changed, 257 insertions(+), 2 deletions(-)

diff --git a/packages/signals_core/lib/src/async/computed.dart b/packages/signals_core/lib/src/async/computed.dart
index e8cf6228..d612d83b 100644
--- a/packages/signals_core/lib/src/async/computed.dart
+++ b/packages/signals_core/lib/src/async/computed.dart
@@ -10,7 +10,7 @@ import 'future.dart';
 ///
 /// ```dart
 /// final movieId = signal('id');
-/// late final movie = computedFrom(args, ([movieId]) => fetchMovie(args.first));
+/// late final movie = computedFrom([movieId], (args) => fetchMovie(args.first));
 /// ```
 ///
 /// Since all dependencies are passed in as arguments there is no need to worry about calling the signals before any async gaps with await.
@@ -32,6 +32,139 @@ FutureSignal<T> computedFrom<T, A>(
   );
 }
 
+/// [computedFrom] for a one element record.
+FutureSignal<T> computedFrom1<T, A>(
+  (ReadonlySignal<A>,) signals,
+  Future<T> Function((A,) args) fn, {
+  T? initialValue,
+  String? debugLabel,
+  bool autoDispose = false,
+  bool lazy = true,
+}) {
+  return FutureSignal<T>(
+    () => fn((signals.$1(),)),
+    dependencies: [signals.$1],
+    initialValue: initialValue,
+    debugLabel: debugLabel,
+    autoDispose: autoDispose,
+    lazy: lazy,
+  );
+}
+
+/// [computedFrom] for a two element record.
+FutureSignal<T> computedFrom2<T, A, B>(
+  (ReadonlySignal<A>, ReadonlySignal<B>) signals,
+  Future<T> Function(
+          (
+            A,
+            B,
+          ) args)
+      fn, {
+  T? initialValue,
+  String? debugLabel,
+  bool autoDispose = false,
+  bool lazy = true,
+}) {
+  return FutureSignal<T>(
+    () => fn((signals.$1(), signals.$2())),
+    dependencies: [signals.$1, signals.$2],
+    initialValue: initialValue,
+    debugLabel: debugLabel,
+    autoDispose: autoDispose,
+    lazy: lazy,
+  );
+}
+
+/// [computedFrom] for a three element record.
+FutureSignal<T> computedFrom3<T, A, B, C>(
+  (ReadonlySignal<A>, ReadonlySignal<B>, ReadonlySignal<C>) signals,
+  Future<T> Function(
+          (
+            A,
+            B,
+            C,
+          ) args)
+      fn, {
+  T? initialValue,
+  String? debugLabel,
+  bool autoDispose = false,
+  bool lazy = true,
+}) {
+  return FutureSignal<T>(
+    () => fn((signals.$1(), signals.$2(), signals.$3())),
+    dependencies: [signals.$1, signals.$2, signals.$3],
+    initialValue: initialValue,
+    debugLabel: debugLabel,
+    autoDispose: autoDispose,
+    lazy: lazy,
+  );
+}
+
+/// [computedFrom] for a four element record.
+FutureSignal<T> computedFrom4<T, A, B, C, D>(
+  (
+    ReadonlySignal<A>,
+    ReadonlySignal<B>,
+    ReadonlySignal<C>,
+    ReadonlySignal<D>
+  ) signals,
+  Future<T> Function(
+          (
+            A,
+            B,
+            C,
+            D,
+          ) args)
+      fn, {
+  T? initialValue,
+  String? debugLabel,
+  bool autoDispose = false,
+  bool lazy = true,
+}) {
+  return FutureSignal<T>(
+    () => fn((signals.$1(), signals.$2(), signals.$3(), signals.$4())),
+    dependencies: [signals.$1, signals.$2, signals.$3, signals.$4],
+    initialValue: initialValue,
+    debugLabel: debugLabel,
+    autoDispose: autoDispose,
+    lazy: lazy,
+  );
+}
+
+/// [computedFrom] for a five element record.
+FutureSignal<T> computedFrom5<T, A, B, C, D, E>(
+  (
+    ReadonlySignal<A>,
+    ReadonlySignal<B>,
+    ReadonlySignal<C>,
+    ReadonlySignal<D>,
+    ReadonlySignal<E>
+  ) signals,
+  Future<T> Function(
+          (
+            A,
+            B,
+            C,
+            D,
+            E,
+          ) args)
+      fn, {
+  T? initialValue,
+  String? debugLabel,
+  bool autoDispose = false,
+  bool lazy = true,
+}) {
+  return FutureSignal<T>(
+    () => fn(
+        (signals.$1(), signals.$2(), signals.$3(), signals.$4(), signals.$5())),
+    dependencies: [signals.$1, signals.$2, signals.$3, signals.$4, signals.$5],
+    initialValue: initialValue,
+    debugLabel: debugLabel,
+    autoDispose: autoDispose,
+    lazy: lazy,
+  );
+}
+
 /// Async Computed is syntax sugar around [FutureSignal].
 ///
 /// _Inspired by [computedAsync](https://ngxtension.netlify.app/utilities/signals/computed-async/) from Angular NgExtension._
diff --git a/packages/signals_flutter/lib/src/mixins/signals.dart b/packages/signals_flutter/lib/src/mixins/signals.dart
index 7b2196d4..3ba94386 100644
--- a/packages/signals_flutter/lib/src/mixins/signals.dart
+++ b/packages/signals_flutter/lib/src/mixins/signals.dart
@@ -105,7 +105,7 @@ mixin SignalsMixin<T extends StatefulWidget> on State<T> {
   ///
   /// ```dart
   /// final movieId = signal('id');
-  /// late final movie = computedFrom(args, ([movieId]) => fetchMovie(args.first));
+  /// late final movie = computedFrom([movieId], (args) => fetchMovie(args.first));
   /// ```
   ///
   /// Since all dependencies are passed in as arguments there is no need to worry about calling the signals before any async gaps with await.
@@ -125,6 +125,128 @@ mixin SignalsMixin<T extends StatefulWidget> on State<T> {
     ));
   }
 
+  /// [createComputedFrom] for a one element record.
+  FutureSignal<S> createComputedFrom1<S, A>(
+    (ReadonlySignal<A>,) signals,
+    Future<S> Function((A,) args) fn, {
+    S? initialValue,
+    String? debugLabel,
+    bool lazy = true,
+  }) {
+    return _bindLocal(computedFrom1<S, A>(
+      signals,
+      fn,
+      initialValue: initialValue,
+      debugLabel: debugLabel,
+      lazy: lazy,
+    ));
+  }
+
+  /// [createComputedFrom] for a two element record.
+  FutureSignal<S> createComputedFrom2<S, A, B>(
+    (ReadonlySignal<A>, ReadonlySignal<B>) signals,
+    Future<S> Function(
+            (
+              A,
+              B,
+            ) args)
+        fn, {
+    S? initialValue,
+    String? debugLabel,
+    bool lazy = true,
+  }) {
+    return _bindLocal(computedFrom2<S, A, B>(
+      signals,
+      fn,
+      initialValue: initialValue,
+      debugLabel: debugLabel,
+      lazy: lazy,
+    ));
+  }
+
+  /// [createComputedFrom] for a three element record.
+  FutureSignal<S> createComputedFrom3<S, A, B, C>(
+    (ReadonlySignal<A>, ReadonlySignal<B>, ReadonlySignal<C>) signals,
+    Future<S> Function(
+            (
+              A,
+              B,
+              C,
+            ) args)
+        fn, {
+    S? initialValue,
+    String? debugLabel,
+    bool lazy = true,
+  }) {
+    return _bindLocal(computedFrom3<S, A, B, C>(
+      signals,
+      fn,
+      initialValue: initialValue,
+      debugLabel: debugLabel,
+      lazy: lazy,
+    ));
+  }
+
+  /// [createComputedFrom] for a four element record.
+  FutureSignal<S> createComputedFrom4<S, A, B, C, D>(
+    (
+      ReadonlySignal<A>,
+      ReadonlySignal<B>,
+      ReadonlySignal<C>,
+      ReadonlySignal<D>
+    ) signals,
+    Future<S> Function(
+            (
+              A,
+              B,
+              C,
+              D,
+            ) args)
+        fn, {
+    S? initialValue,
+    String? debugLabel,
+    bool lazy = true,
+  }) {
+    return _bindLocal(computedFrom4<S, A, B, C, D>(
+      signals,
+      fn,
+      initialValue: initialValue,
+      debugLabel: debugLabel,
+      lazy: lazy,
+    ));
+  }
+
+  /// [createComputedFrom] for a five element record.
+  FutureSignal<S> createComputedFrom5<S, A, B, C, D, E>(
+    (
+      ReadonlySignal<A>,
+      ReadonlySignal<B>,
+      ReadonlySignal<C>,
+      ReadonlySignal<D>,
+      ReadonlySignal<E>
+    ) signals,
+    Future<S> Function(
+            (
+              A,
+              B,
+              C,
+              D,
+              E,
+            ) args)
+        fn, {
+    S? initialValue,
+    String? debugLabel,
+    bool lazy = true,
+  }) {
+    return _bindLocal(computedFrom5<S, A, B, C, D, E>(
+      signals,
+      fn,
+      initialValue: initialValue,
+      debugLabel: debugLabel,
+      lazy: lazy,
+    ));
+  }
+
   /// Async Computed is syntax sugar around [FutureSignal].
   ///
   /// _Inspired by [computedAsync](https://ngxtension.netlify.app/utilities/signals/computed-async/) from Angular NgExtension._

From 4e712fc6947deb6668e53874953f57df416bbc4f Mon Sep 17 00:00:00 2001
From: mcmah309 <dillonmcmahon79@gmail.com>
Date: Mon, 2 Dec 2024 08:13:12 +0000
Subject: [PATCH 2/5] feat: Use elements instead of records

---
 .../signals_core/lib/src/async/computed.dart  | 109 ++++++++----------
 .../lib/src/mixins/signals.dart               |  96 +++++++--------
 2 files changed, 90 insertions(+), 115 deletions(-)

diff --git a/packages/signals_core/lib/src/async/computed.dart b/packages/signals_core/lib/src/async/computed.dart
index d612d83b..8d1b00d9 100644
--- a/packages/signals_core/lib/src/async/computed.dart
+++ b/packages/signals_core/lib/src/async/computed.dart
@@ -32,18 +32,18 @@ FutureSignal<T> computedFrom<T, A>(
   );
 }
 
-/// [computedFrom] for a one element record.
+/// [computedFrom] for a one element.
 FutureSignal<T> computedFrom1<T, A>(
-  (ReadonlySignal<A>,) signals,
-  Future<T> Function((A,) args) fn, {
+  ReadonlySignal<A> signal1,
+  Future<T> Function(A signal1) fn, {
   T? initialValue,
   String? debugLabel,
   bool autoDispose = false,
   bool lazy = true,
 }) {
   return FutureSignal<T>(
-    () => fn((signals.$1(),)),
-    dependencies: [signals.$1],
+    () => fn(signal1.value),
+    dependencies: [signal1],
     initialValue: initialValue,
     debugLabel: debugLabel,
     autoDispose: autoDispose,
@@ -51,23 +51,22 @@ FutureSignal<T> computedFrom1<T, A>(
   );
 }
 
-/// [computedFrom] for a two element record.
+/// [computedFrom] for a two elements.
 FutureSignal<T> computedFrom2<T, A, B>(
-  (ReadonlySignal<A>, ReadonlySignal<B>) signals,
+  ReadonlySignal<A> signal1,
+  ReadonlySignal<B> signal2,
   Future<T> Function(
-          (
-            A,
-            B,
-          ) args)
-      fn, {
+    A signal1,
+    B signal2,
+  ) fn, {
   T? initialValue,
   String? debugLabel,
   bool autoDispose = false,
   bool lazy = true,
 }) {
   return FutureSignal<T>(
-    () => fn((signals.$1(), signals.$2())),
-    dependencies: [signals.$1, signals.$2],
+    () => fn(signal1.value, signal2.value),
+    dependencies: [signal1, signal2],
     initialValue: initialValue,
     debugLabel: debugLabel,
     autoDispose: autoDispose,
@@ -75,24 +74,24 @@ FutureSignal<T> computedFrom2<T, A, B>(
   );
 }
 
-/// [computedFrom] for a three element record.
+/// [computedFrom] for a three elements.
 FutureSignal<T> computedFrom3<T, A, B, C>(
-  (ReadonlySignal<A>, ReadonlySignal<B>, ReadonlySignal<C>) signals,
+  ReadonlySignal<A> signal1,
+  ReadonlySignal<B> signal2,
+  ReadonlySignal<C> signal3,
   Future<T> Function(
-          (
-            A,
-            B,
-            C,
-          ) args)
-      fn, {
+    A signal1,
+    B signal2,
+    C signal3,
+  ) fn, {
   T? initialValue,
   String? debugLabel,
   bool autoDispose = false,
   bool lazy = true,
 }) {
   return FutureSignal<T>(
-    () => fn((signals.$1(), signals.$2(), signals.$3())),
-    dependencies: [signals.$1, signals.$2, signals.$3],
+    () => fn(signal1.value, signal2.value, signal3.value),
+    dependencies: [signal1, signal2, signal3],
     initialValue: initialValue,
     debugLabel: debugLabel,
     autoDispose: autoDispose,
@@ -100,30 +99,26 @@ FutureSignal<T> computedFrom3<T, A, B, C>(
   );
 }
 
-/// [computedFrom] for a four element record.
+/// [computedFrom] for a four elements.
 FutureSignal<T> computedFrom4<T, A, B, C, D>(
-  (
-    ReadonlySignal<A>,
-    ReadonlySignal<B>,
-    ReadonlySignal<C>,
-    ReadonlySignal<D>
-  ) signals,
+  ReadonlySignal<A> signal1,
+  ReadonlySignal<B> signal2,
+  ReadonlySignal<C> signal3,
+  ReadonlySignal<D> signal4,
   Future<T> Function(
-          (
-            A,
-            B,
-            C,
-            D,
-          ) args)
-      fn, {
+    A signal1,
+    B signal2,
+    C signal3,
+    D signal4,
+  ) fn, {
   T? initialValue,
   String? debugLabel,
   bool autoDispose = false,
   bool lazy = true,
 }) {
   return FutureSignal<T>(
-    () => fn((signals.$1(), signals.$2(), signals.$3(), signals.$4())),
-    dependencies: [signals.$1, signals.$2, signals.$3, signals.$4],
+    () => fn(signal1.value, signal2.value, signal3.value, signal4.value),
+    dependencies: [signal1, signal2, signal3, signal4],
     initialValue: initialValue,
     debugLabel: debugLabel,
     autoDispose: autoDispose,
@@ -131,33 +126,29 @@ FutureSignal<T> computedFrom4<T, A, B, C, D>(
   );
 }
 
-/// [computedFrom] for a five element record.
+/// [computedFrom] for a five elements.
 FutureSignal<T> computedFrom5<T, A, B, C, D, E>(
-  (
-    ReadonlySignal<A>,
-    ReadonlySignal<B>,
-    ReadonlySignal<C>,
-    ReadonlySignal<D>,
-    ReadonlySignal<E>
-  ) signals,
+  ReadonlySignal<A> signal1,
+  ReadonlySignal<B> signal2,
+  ReadonlySignal<C> signal3,
+  ReadonlySignal<D> signal4,
+  ReadonlySignal<E> signal5,
   Future<T> Function(
-          (
-            A,
-            B,
-            C,
-            D,
-            E,
-          ) args)
-      fn, {
+    A signal1,
+    B signal2,
+    C signal3,
+    D signal4,
+    E signal5,
+  ) fn, {
   T? initialValue,
   String? debugLabel,
   bool autoDispose = false,
   bool lazy = true,
 }) {
   return FutureSignal<T>(
-    () => fn(
-        (signals.$1(), signals.$2(), signals.$3(), signals.$4(), signals.$5())),
-    dependencies: [signals.$1, signals.$2, signals.$3, signals.$4, signals.$5],
+    () => fn(signal1.value, signal2.value, signal3.value, signal4.value,
+        signal5.value),
+    dependencies: [signal1, signal2, signal3, signal4, signal5],
     initialValue: initialValue,
     debugLabel: debugLabel,
     autoDispose: autoDispose,
diff --git a/packages/signals_flutter/lib/src/mixins/signals.dart b/packages/signals_flutter/lib/src/mixins/signals.dart
index 3ba94386..9e2b0def 100644
--- a/packages/signals_flutter/lib/src/mixins/signals.dart
+++ b/packages/signals_flutter/lib/src/mixins/signals.dart
@@ -125,16 +125,16 @@ mixin SignalsMixin<T extends StatefulWidget> on State<T> {
     ));
   }
 
-  /// [createComputedFrom] for a one element record.
+  /// [createComputedFrom] for a one element.
   FutureSignal<S> createComputedFrom1<S, A>(
-    (ReadonlySignal<A>,) signals,
-    Future<S> Function((A,) args) fn, {
+    ReadonlySignal<A> signal1,
+    Future<S> Function(A signal1) fn, {
     S? initialValue,
     String? debugLabel,
     bool lazy = true,
   }) {
     return _bindLocal(computedFrom1<S, A>(
-      signals,
+      signal1,
       fn,
       initialValue: initialValue,
       debugLabel: debugLabel,
@@ -142,21 +142,18 @@ mixin SignalsMixin<T extends StatefulWidget> on State<T> {
     ));
   }
 
-  /// [createComputedFrom] for a two element record.
+  /// [createComputedFrom] for a two elements.
   FutureSignal<S> createComputedFrom2<S, A, B>(
-    (ReadonlySignal<A>, ReadonlySignal<B>) signals,
-    Future<S> Function(
-            (
-              A,
-              B,
-            ) args)
-        fn, {
+    ReadonlySignal<A> signal1,
+    ReadonlySignal<B> signal2,
+    Future<S> Function(A signal1, B signal2) fn, {
     S? initialValue,
     String? debugLabel,
     bool lazy = true,
   }) {
     return _bindLocal(computedFrom2<S, A, B>(
-      signals,
+      signal1,
+      signal2,
       fn,
       initialValue: initialValue,
       debugLabel: debugLabel,
@@ -164,22 +161,20 @@ mixin SignalsMixin<T extends StatefulWidget> on State<T> {
     ));
   }
 
-  /// [createComputedFrom] for a three element record.
+  /// [createComputedFrom] for a three elements.
   FutureSignal<S> createComputedFrom3<S, A, B, C>(
-    (ReadonlySignal<A>, ReadonlySignal<B>, ReadonlySignal<C>) signals,
-    Future<S> Function(
-            (
-              A,
-              B,
-              C,
-            ) args)
-        fn, {
+    ReadonlySignal<A> signal1,
+    ReadonlySignal<B> signal2,
+    ReadonlySignal<C> signal3,
+    Future<S> Function(A signal1, B signal2, C signal3) fn, {
     S? initialValue,
     String? debugLabel,
     bool lazy = true,
   }) {
     return _bindLocal(computedFrom3<S, A, B, C>(
-      signals,
+      signal1,
+      signal2,
+      signal3,
       fn,
       initialValue: initialValue,
       debugLabel: debugLabel,
@@ -187,28 +182,22 @@ mixin SignalsMixin<T extends StatefulWidget> on State<T> {
     ));
   }
 
-  /// [createComputedFrom] for a four element record.
+  /// [createComputedFrom] for a four elements.
   FutureSignal<S> createComputedFrom4<S, A, B, C, D>(
-    (
-      ReadonlySignal<A>,
-      ReadonlySignal<B>,
-      ReadonlySignal<C>,
-      ReadonlySignal<D>
-    ) signals,
-    Future<S> Function(
-            (
-              A,
-              B,
-              C,
-              D,
-            ) args)
-        fn, {
+    ReadonlySignal<A> signal1,
+    ReadonlySignal<B> signal2,
+    ReadonlySignal<C> signal3,
+    ReadonlySignal<D> signal4,
+    Future<S> Function(A signal1, B signal2, C signal3, D signal4) fn, {
     S? initialValue,
     String? debugLabel,
     bool lazy = true,
   }) {
     return _bindLocal(computedFrom4<S, A, B, C, D>(
-      signals,
+      signal1,
+      signal2,
+      signal3,
+      signal4,
       fn,
       initialValue: initialValue,
       debugLabel: debugLabel,
@@ -216,30 +205,25 @@ mixin SignalsMixin<T extends StatefulWidget> on State<T> {
     ));
   }
 
-  /// [createComputedFrom] for a five element record.
+  /// [createComputedFrom] for a five elements.
   FutureSignal<S> createComputedFrom5<S, A, B, C, D, E>(
-    (
-      ReadonlySignal<A>,
-      ReadonlySignal<B>,
-      ReadonlySignal<C>,
-      ReadonlySignal<D>,
-      ReadonlySignal<E>
-    ) signals,
-    Future<S> Function(
-            (
-              A,
-              B,
-              C,
-              D,
-              E,
-            ) args)
+    ReadonlySignal<A> signal1,
+    ReadonlySignal<B> signal2,
+    ReadonlySignal<C> signal3,
+    ReadonlySignal<D> signal4,
+    ReadonlySignal<E> signal5,
+    Future<S> Function(A signal1, B signal2, C signal3, D signal4, E signal5)
         fn, {
     S? initialValue,
     String? debugLabel,
     bool lazy = true,
   }) {
     return _bindLocal(computedFrom5<S, A, B, C, D, E>(
-      signals,
+      signal1,
+      signal2,
+      signal3,
+      signal4,
+      signal5,
       fn,
       initialValue: initialValue,
       debugLabel: debugLabel,

From 0c7890a9daa99fd05fc8db27c6e70ab9764fe165 Mon Sep 17 00:00:00 2001
From: mcmah309 <dillonmcmahon79@gmail.com>
Date: Mon, 2 Dec 2024 08:19:49 +0000
Subject: [PATCH 3/5] doc: Typo

---
 packages/signals_core/lib/src/async/computed.dart | 10 +++++-----
 packages/signals_core/test/async/state_test.dart  |  2 +-
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/packages/signals_core/lib/src/async/computed.dart b/packages/signals_core/lib/src/async/computed.dart
index 8d1b00d9..741645b2 100644
--- a/packages/signals_core/lib/src/async/computed.dart
+++ b/packages/signals_core/lib/src/async/computed.dart
@@ -32,7 +32,7 @@ FutureSignal<T> computedFrom<T, A>(
   );
 }
 
-/// [computedFrom] for a one element.
+/// [computedFrom] for one element.
 FutureSignal<T> computedFrom1<T, A>(
   ReadonlySignal<A> signal1,
   Future<T> Function(A signal1) fn, {
@@ -51,7 +51,7 @@ FutureSignal<T> computedFrom1<T, A>(
   );
 }
 
-/// [computedFrom] for a two elements.
+/// [computedFrom] for two elements.
 FutureSignal<T> computedFrom2<T, A, B>(
   ReadonlySignal<A> signal1,
   ReadonlySignal<B> signal2,
@@ -74,7 +74,7 @@ FutureSignal<T> computedFrom2<T, A, B>(
   );
 }
 
-/// [computedFrom] for a three elements.
+/// [computedFrom] for three elements.
 FutureSignal<T> computedFrom3<T, A, B, C>(
   ReadonlySignal<A> signal1,
   ReadonlySignal<B> signal2,
@@ -99,7 +99,7 @@ FutureSignal<T> computedFrom3<T, A, B, C>(
   );
 }
 
-/// [computedFrom] for a four elements.
+/// [computedFrom] for four elements.
 FutureSignal<T> computedFrom4<T, A, B, C, D>(
   ReadonlySignal<A> signal1,
   ReadonlySignal<B> signal2,
@@ -126,7 +126,7 @@ FutureSignal<T> computedFrom4<T, A, B, C, D>(
   );
 }
 
-/// [computedFrom] for a five elements.
+/// [computedFrom] for five elements.
 FutureSignal<T> computedFrom5<T, A, B, C, D, E>(
   ReadonlySignal<A> signal1,
   ReadonlySignal<B> signal2,
diff --git a/packages/signals_core/test/async/state_test.dart b/packages/signals_core/test/async/state_test.dart
index 92431f6d..586d6d61 100644
--- a/packages/signals_core/test/async/state_test.dart
+++ b/packages/signals_core/test/async/state_test.dart
@@ -152,7 +152,7 @@ void main() {
         expect(value, true);
       });
     });
-    
+
     group('pattern matching', () {
       test('loading', () {
         final s = AsyncState<int>.loading();

From e85b9699cf029ab1c5b03831acc02aea0e62de94 Mon Sep 17 00:00:00 2001
From: mcmah309 <dillonmcmahon79@gmail.com>
Date: Mon, 2 Dec 2024 08:38:38 +0000
Subject: [PATCH 4/5] refactor: Rename param

---
 .../signals_core/lib/src/async/computed.dart  | 41 +++++++++----------
 .../lib/src/mixins/signals.dart               | 21 +++++-----
 2 files changed, 30 insertions(+), 32 deletions(-)

diff --git a/packages/signals_core/lib/src/async/computed.dart b/packages/signals_core/lib/src/async/computed.dart
index 741645b2..c49ca176 100644
--- a/packages/signals_core/lib/src/async/computed.dart
+++ b/packages/signals_core/lib/src/async/computed.dart
@@ -35,14 +35,14 @@ FutureSignal<T> computedFrom<T, A>(
 /// [computedFrom] for one element.
 FutureSignal<T> computedFrom1<T, A>(
   ReadonlySignal<A> signal1,
-  Future<T> Function(A signal1) fn, {
+  Future<T> Function(A value1) fn, {
   T? initialValue,
   String? debugLabel,
   bool autoDispose = false,
   bool lazy = true,
 }) {
   return FutureSignal<T>(
-    () => fn(signal1.value),
+    () => fn(signal1()),
     dependencies: [signal1],
     initialValue: initialValue,
     debugLabel: debugLabel,
@@ -56,8 +56,8 @@ FutureSignal<T> computedFrom2<T, A, B>(
   ReadonlySignal<A> signal1,
   ReadonlySignal<B> signal2,
   Future<T> Function(
-    A signal1,
-    B signal2,
+    A value1,
+    B value2,
   ) fn, {
   T? initialValue,
   String? debugLabel,
@@ -65,7 +65,7 @@ FutureSignal<T> computedFrom2<T, A, B>(
   bool lazy = true,
 }) {
   return FutureSignal<T>(
-    () => fn(signal1.value, signal2.value),
+    () => fn(signal1(), signal2()),
     dependencies: [signal1, signal2],
     initialValue: initialValue,
     debugLabel: debugLabel,
@@ -80,9 +80,9 @@ FutureSignal<T> computedFrom3<T, A, B, C>(
   ReadonlySignal<B> signal2,
   ReadonlySignal<C> signal3,
   Future<T> Function(
-    A signal1,
-    B signal2,
-    C signal3,
+    A value1,
+    B value2,
+    C value3,
   ) fn, {
   T? initialValue,
   String? debugLabel,
@@ -90,7 +90,7 @@ FutureSignal<T> computedFrom3<T, A, B, C>(
   bool lazy = true,
 }) {
   return FutureSignal<T>(
-    () => fn(signal1.value, signal2.value, signal3.value),
+    () => fn(signal1(), signal2(), signal3()),
     dependencies: [signal1, signal2, signal3],
     initialValue: initialValue,
     debugLabel: debugLabel,
@@ -106,10 +106,10 @@ FutureSignal<T> computedFrom4<T, A, B, C, D>(
   ReadonlySignal<C> signal3,
   ReadonlySignal<D> signal4,
   Future<T> Function(
-    A signal1,
-    B signal2,
-    C signal3,
-    D signal4,
+    A value1,
+    B value2,
+    C value3,
+    D value4,
   ) fn, {
   T? initialValue,
   String? debugLabel,
@@ -117,7 +117,7 @@ FutureSignal<T> computedFrom4<T, A, B, C, D>(
   bool lazy = true,
 }) {
   return FutureSignal<T>(
-    () => fn(signal1.value, signal2.value, signal3.value, signal4.value),
+    () => fn(signal1(), signal2(), signal3(), signal4()),
     dependencies: [signal1, signal2, signal3, signal4],
     initialValue: initialValue,
     debugLabel: debugLabel,
@@ -134,11 +134,11 @@ FutureSignal<T> computedFrom5<T, A, B, C, D, E>(
   ReadonlySignal<D> signal4,
   ReadonlySignal<E> signal5,
   Future<T> Function(
-    A signal1,
-    B signal2,
-    C signal3,
-    D signal4,
-    E signal5,
+    A value1,
+    B value2,
+    C value3,
+    D value4,
+    E value5,
   ) fn, {
   T? initialValue,
   String? debugLabel,
@@ -146,8 +146,7 @@ FutureSignal<T> computedFrom5<T, A, B, C, D, E>(
   bool lazy = true,
 }) {
   return FutureSignal<T>(
-    () => fn(signal1.value, signal2.value, signal3.value, signal4.value,
-        signal5.value),
+    () => fn(signal1(), signal2(), signal3(), signal4(), signal5()),
     dependencies: [signal1, signal2, signal3, signal4, signal5],
     initialValue: initialValue,
     debugLabel: debugLabel,
diff --git a/packages/signals_flutter/lib/src/mixins/signals.dart b/packages/signals_flutter/lib/src/mixins/signals.dart
index 9e2b0def..a9c2d2b2 100644
--- a/packages/signals_flutter/lib/src/mixins/signals.dart
+++ b/packages/signals_flutter/lib/src/mixins/signals.dart
@@ -125,10 +125,10 @@ mixin SignalsMixin<T extends StatefulWidget> on State<T> {
     ));
   }
 
-  /// [createComputedFrom] for a one element.
+  /// [createComputedFrom] for one element.
   FutureSignal<S> createComputedFrom1<S, A>(
     ReadonlySignal<A> signal1,
-    Future<S> Function(A signal1) fn, {
+    Future<S> Function(A value1) fn, {
     S? initialValue,
     String? debugLabel,
     bool lazy = true,
@@ -142,11 +142,11 @@ mixin SignalsMixin<T extends StatefulWidget> on State<T> {
     ));
   }
 
-  /// [createComputedFrom] for a two elements.
+  /// [createComputedFrom] for two elements.
   FutureSignal<S> createComputedFrom2<S, A, B>(
     ReadonlySignal<A> signal1,
     ReadonlySignal<B> signal2,
-    Future<S> Function(A signal1, B signal2) fn, {
+    Future<S> Function(A value1, B value2) fn, {
     S? initialValue,
     String? debugLabel,
     bool lazy = true,
@@ -161,12 +161,12 @@ mixin SignalsMixin<T extends StatefulWidget> on State<T> {
     ));
   }
 
-  /// [createComputedFrom] for a three elements.
+  /// [createComputedFrom] for three elements.
   FutureSignal<S> createComputedFrom3<S, A, B, C>(
     ReadonlySignal<A> signal1,
     ReadonlySignal<B> signal2,
     ReadonlySignal<C> signal3,
-    Future<S> Function(A signal1, B signal2, C signal3) fn, {
+    Future<S> Function(A value1, B value2, C value3) fn, {
     S? initialValue,
     String? debugLabel,
     bool lazy = true,
@@ -182,13 +182,13 @@ mixin SignalsMixin<T extends StatefulWidget> on State<T> {
     ));
   }
 
-  /// [createComputedFrom] for a four elements.
+  /// [createComputedFrom] for four elements.
   FutureSignal<S> createComputedFrom4<S, A, B, C, D>(
     ReadonlySignal<A> signal1,
     ReadonlySignal<B> signal2,
     ReadonlySignal<C> signal3,
     ReadonlySignal<D> signal4,
-    Future<S> Function(A signal1, B signal2, C signal3, D signal4) fn, {
+    Future<S> Function(A value1, B value2, C value3, D value4) fn, {
     S? initialValue,
     String? debugLabel,
     bool lazy = true,
@@ -205,15 +205,14 @@ mixin SignalsMixin<T extends StatefulWidget> on State<T> {
     ));
   }
 
-  /// [createComputedFrom] for a five elements.
+  /// [createComputedFrom] for five elements.
   FutureSignal<S> createComputedFrom5<S, A, B, C, D, E>(
     ReadonlySignal<A> signal1,
     ReadonlySignal<B> signal2,
     ReadonlySignal<C> signal3,
     ReadonlySignal<D> signal4,
     ReadonlySignal<E> signal5,
-    Future<S> Function(A signal1, B signal2, C signal3, D signal4, E signal5)
-        fn, {
+    Future<S> Function(A value1, B value2, C value3, D value, E value5) fn, {
     S? initialValue,
     String? debugLabel,
     bool lazy = true,

From 94b82dc774a55f5ded73694ed66d3fbaa2c08660 Mon Sep 17 00:00:00 2001
From: mcmah309 <dillonmcmahon79@gmail.com>
Date: Mon, 2 Dec 2024 08:42:27 +0000
Subject: [PATCH 5/5] doc: Update

---
 packages/signals_core/lib/src/async/computed.dart    | 10 +++++-----
 packages/signals_flutter/lib/src/mixins/signals.dart | 10 +++++-----
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/packages/signals_core/lib/src/async/computed.dart b/packages/signals_core/lib/src/async/computed.dart
index c49ca176..3e77f79b 100644
--- a/packages/signals_core/lib/src/async/computed.dart
+++ b/packages/signals_core/lib/src/async/computed.dart
@@ -32,7 +32,7 @@ FutureSignal<T> computedFrom<T, A>(
   );
 }
 
-/// [computedFrom] for one element.
+/// [computedFrom] for one signal.
 FutureSignal<T> computedFrom1<T, A>(
   ReadonlySignal<A> signal1,
   Future<T> Function(A value1) fn, {
@@ -51,7 +51,7 @@ FutureSignal<T> computedFrom1<T, A>(
   );
 }
 
-/// [computedFrom] for two elements.
+/// [computedFrom] for two signals.
 FutureSignal<T> computedFrom2<T, A, B>(
   ReadonlySignal<A> signal1,
   ReadonlySignal<B> signal2,
@@ -74,7 +74,7 @@ FutureSignal<T> computedFrom2<T, A, B>(
   );
 }
 
-/// [computedFrom] for three elements.
+/// [computedFrom] for three signals.
 FutureSignal<T> computedFrom3<T, A, B, C>(
   ReadonlySignal<A> signal1,
   ReadonlySignal<B> signal2,
@@ -99,7 +99,7 @@ FutureSignal<T> computedFrom3<T, A, B, C>(
   );
 }
 
-/// [computedFrom] for four elements.
+/// [computedFrom] for four signals.
 FutureSignal<T> computedFrom4<T, A, B, C, D>(
   ReadonlySignal<A> signal1,
   ReadonlySignal<B> signal2,
@@ -126,7 +126,7 @@ FutureSignal<T> computedFrom4<T, A, B, C, D>(
   );
 }
 
-/// [computedFrom] for five elements.
+/// [computedFrom] for five signals.
 FutureSignal<T> computedFrom5<T, A, B, C, D, E>(
   ReadonlySignal<A> signal1,
   ReadonlySignal<B> signal2,
diff --git a/packages/signals_flutter/lib/src/mixins/signals.dart b/packages/signals_flutter/lib/src/mixins/signals.dart
index a9c2d2b2..0bc3dc1f 100644
--- a/packages/signals_flutter/lib/src/mixins/signals.dart
+++ b/packages/signals_flutter/lib/src/mixins/signals.dart
@@ -125,7 +125,7 @@ mixin SignalsMixin<T extends StatefulWidget> on State<T> {
     ));
   }
 
-  /// [createComputedFrom] for one element.
+  /// [createComputedFrom] for one signal.
   FutureSignal<S> createComputedFrom1<S, A>(
     ReadonlySignal<A> signal1,
     Future<S> Function(A value1) fn, {
@@ -142,7 +142,7 @@ mixin SignalsMixin<T extends StatefulWidget> on State<T> {
     ));
   }
 
-  /// [createComputedFrom] for two elements.
+  /// [createComputedFrom] for two signals.
   FutureSignal<S> createComputedFrom2<S, A, B>(
     ReadonlySignal<A> signal1,
     ReadonlySignal<B> signal2,
@@ -161,7 +161,7 @@ mixin SignalsMixin<T extends StatefulWidget> on State<T> {
     ));
   }
 
-  /// [createComputedFrom] for three elements.
+  /// [createComputedFrom] for three signals.
   FutureSignal<S> createComputedFrom3<S, A, B, C>(
     ReadonlySignal<A> signal1,
     ReadonlySignal<B> signal2,
@@ -182,7 +182,7 @@ mixin SignalsMixin<T extends StatefulWidget> on State<T> {
     ));
   }
 
-  /// [createComputedFrom] for four elements.
+  /// [createComputedFrom] for four signals.
   FutureSignal<S> createComputedFrom4<S, A, B, C, D>(
     ReadonlySignal<A> signal1,
     ReadonlySignal<B> signal2,
@@ -205,7 +205,7 @@ mixin SignalsMixin<T extends StatefulWidget> on State<T> {
     ));
   }
 
-  /// [createComputedFrom] for five elements.
+  /// [createComputedFrom] for five signals.
   FutureSignal<S> createComputedFrom5<S, A, B, C, D, E>(
     ReadonlySignal<A> signal1,
     ReadonlySignal<B> signal2,