feat: Add computedFrom convenience functions

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,129 @@ FutureSignal<T> computedFrom<T, A>(
   );
 }
 
+/// [computedFrom] for one signal.
+FutureSignal<T> computedFrom1<T, A>(
+  ReadonlySignal<A> signal1,
+  Future<T> Function(A value1) fn, {
+  T? initialValue,
+  String? debugLabel,
+  bool autoDispose = false,
+  bool lazy = true,
+}) {
+  return FutureSignal<T>(
+    () => fn(signal1()),
+    dependencies: [signal1],
+    initialValue: initialValue,
+    debugLabel: debugLabel,
+    autoDispose: autoDispose,
+    lazy: lazy,
+  );
+}
+
+/// [computedFrom] for two signals.
+FutureSignal<T> computedFrom2<T, A, B>(
+  ReadonlySignal<A> signal1,
+  ReadonlySignal<B> signal2,
+  Future<T> Function(
+    A value1,
+    B value2,
+  ) fn, {
+  T? initialValue,
+  String? debugLabel,
+  bool autoDispose = false,
+  bool lazy = true,
+}) {
+  return FutureSignal<T>(
+    () => fn(signal1(), signal2()),
+    dependencies: [signal1, signal2],
+    initialValue: initialValue,
+    debugLabel: debugLabel,
+    autoDispose: autoDispose,
+    lazy: lazy,
+  );
+}
+
+/// [computedFrom] for three signals.
+FutureSignal<T> computedFrom3<T, A, B, C>(
+  ReadonlySignal<A> signal1,
+  ReadonlySignal<B> signal2,
+  ReadonlySignal<C> signal3,
+  Future<T> Function(
+    A value1,
+    B value2,
+    C value3,
+  ) fn, {
+  T? initialValue,
+  String? debugLabel,
+  bool autoDispose = false,
+  bool lazy = true,
+}) {
+  return FutureSignal<T>(
+    () => fn(signal1(), signal2(), signal3()),
+    dependencies: [signal1, signal2, signal3],
+    initialValue: initialValue,
+    debugLabel: debugLabel,
+    autoDispose: autoDispose,
+    lazy: lazy,
+  );
+}
+
+/// [computedFrom] for four signals.
+FutureSignal<T> computedFrom4<T, A, B, C, D>(
+  ReadonlySignal<A> signal1,
+  ReadonlySignal<B> signal2,
+  ReadonlySignal<C> signal3,
+  ReadonlySignal<D> signal4,
+  Future<T> Function(
+    A value1,
+    B value2,
+    C value3,
+    D value4,
+  ) fn, {
+  T? initialValue,
+  String? debugLabel,
+  bool autoDispose = false,
+  bool lazy = true,
+}) {
+  return FutureSignal<T>(
+    () => fn(signal1(), signal2(), signal3(), signal4()),
+    dependencies: [signal1, signal2, signal3, signal4],
+    initialValue: initialValue,
+    debugLabel: debugLabel,
+    autoDispose: autoDispose,
+    lazy: lazy,
+  );
+}
+
+/// [computedFrom] for five signals.
+FutureSignal<T> computedFrom5<T, A, B, C, D, E>(
+  ReadonlySignal<A> signal1,
+  ReadonlySignal<B> signal2,
+  ReadonlySignal<C> signal3,
+  ReadonlySignal<D> signal4,
+  ReadonlySignal<E> signal5,
+  Future<T> Function(
+    A value1,
+    B value2,
+    C value3,
+    D value4,
+    E value5,
+  ) fn, {
+  T? initialValue,
+  String? debugLabel,
+  bool autoDispose = false,
+  bool lazy = true,
+}) {
+  return FutureSignal<T>(
+    () => fn(signal1(), signal2(), signal3(), signal4(), signal5()),
+    dependencies: [signal1, signal2, signal3, signal4, signal5],
+    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._

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();

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,111 @@ mixin SignalsMixin<T extends StatefulWidget> on State<T> {
     ));
   }
 
+  /// [createComputedFrom] for one signal.
+  FutureSignal<S> createComputedFrom1<S, A>(
+    ReadonlySignal<A> signal1,
+    Future<S> Function(A value1) fn, {
+    S? initialValue,
+    String? debugLabel,
+    bool lazy = true,
+  }) {
+    return _bindLocal(computedFrom1<S, A>(
+      signal1,
+      fn,
+      initialValue: initialValue,
+      debugLabel: debugLabel,
+      lazy: lazy,
+    ));
+  }
+
+  /// [createComputedFrom] for two signals.
+  FutureSignal<S> createComputedFrom2<S, A, B>(
+    ReadonlySignal<A> signal1,
+    ReadonlySignal<B> signal2,
+    Future<S> Function(A value1, B value2) fn, {
+    S? initialValue,
+    String? debugLabel,
+    bool lazy = true,
+  }) {
+    return _bindLocal(computedFrom2<S, A, B>(
+      signal1,
+      signal2,
+      fn,
+      initialValue: initialValue,
+      debugLabel: debugLabel,
+      lazy: lazy,
+    ));
+  }
+
+  /// [createComputedFrom] for three signals.
+  FutureSignal<S> createComputedFrom3<S, A, B, C>(
+    ReadonlySignal<A> signal1,
+    ReadonlySignal<B> signal2,
+    ReadonlySignal<C> signal3,
+    Future<S> Function(A value1, B value2, C value3) fn, {
+    S? initialValue,
+    String? debugLabel,
+    bool lazy = true,
+  }) {
+    return _bindLocal(computedFrom3<S, A, B, C>(
+      signal1,
+      signal2,
+      signal3,
+      fn,
+      initialValue: initialValue,
+      debugLabel: debugLabel,
+      lazy: lazy,
+    ));
+  }
+
+  /// [createComputedFrom] for four signals.
+  FutureSignal<S> createComputedFrom4<S, A, B, C, D>(
+    ReadonlySignal<A> signal1,
+    ReadonlySignal<B> signal2,
+    ReadonlySignal<C> signal3,
+    ReadonlySignal<D> signal4,
+    Future<S> Function(A value1, B value2, C value3, D value4) fn, {
+    S? initialValue,
+    String? debugLabel,
+    bool lazy = true,
+  }) {
+    return _bindLocal(computedFrom4<S, A, B, C, D>(
+      signal1,
+      signal2,
+      signal3,
+      signal4,
+      fn,
+      initialValue: initialValue,
+      debugLabel: debugLabel,
+      lazy: lazy,
+    ));
+  }
+
+  /// [createComputedFrom] for five signals.
+  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 value1, B value2, C value3, D value, E value5) fn, {
+    S? initialValue,
+    String? debugLabel,
+    bool lazy = true,
+  }) {
+    return _bindLocal(computedFrom5<S, A, B, C, D, E>(
+      signal1,
+      signal2,
+      signal3,
+      signal4,
+      signal5,
+      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._