fixing signal state

packages/preact_signals/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.3.2
+
+- Fixing generics for `FutureSignal`, `StreamSignal` via `SignalState`
+
 ## 0.3.1
 
 - Fixing generics for `FutureSignal`, `StreamSignal`, `IterableSignal`, `ListSignal`, `MapSignal` and `SetSignal`

packages/preact_signals/lib/src/future_signal.dart

@@ -14,12 +14,12 @@ import 'package:preact_signals/preact_signals.dart';
 ///   SignalLoading _ => print('loading'),
 /// });
 /// ```
-class FutureSignal<T> extends Signal<SignalState> {
+class FutureSignal<T> extends Signal<SignalState<T>> {
   /// Future [Duration] to wait before timing out
   final Duration? timeout;
 
   /// Creates a [FutureSignal] that wraps a [Future]
-  FutureSignal(this._getFuture, {this.timeout}) : super(SignalLoading()) {
+  FutureSignal(this._getFuture, {this.timeout}) : super(SignalLoading<T>()) {
     _init();
   }
 
@@ -31,8 +31,8 @@ class FutureSignal<T> extends Signal<SignalState> {
   }
 
   void _init() {
-    if (peek() is! SignalLoading) {
-      value = SignalLoading();
+    if (peek() is! SignalLoading<T>) {
+      value = SignalLoading<T>();
     }
     var f = _getFuture();
     if (timeout != null) {
@@ -41,12 +41,12 @@ class FutureSignal<T> extends Signal<SignalState> {
       });
     }
     f.then((value) {
-      this.value = SignalValue(value);
+      this.value = SignalValue<T>(value);
     }).catchError((error) {
-      if (error is SignalTimeout) {
+      if (error is SignalTimeout<T>) {
         value = error;
       } else {
-        value = SignalError(error);
+        value = SignalError<T, Object>(error);
       }
     });
   }
@@ -57,5 +57,8 @@ FutureSignal<T> futureSignal<T>(
   Future<T> Function() compute, {
   Duration? timeout,
 }) {
-  return FutureSignal(compute, timeout: timeout);
+  return FutureSignal<T>(
+    compute,
+    timeout: timeout,
+  );
 }

packages/preact_signals/lib/src/signal_state.dart

@@ -1,18 +1,46 @@
 /// To react to the various states you can use a switch statement:
 ///
 /// ```dart
-/// final SignalState state = ...;
+/// final SignalState<T> state = ...;
 /// final result = (switch(state) {
 ///   SignalValue result => print('value: ${result.value}'),
 ///   SignalTimeout _ => print('timeout error'),
 ///   SignalError result => print('error: ${result.error}'),
 ///   SignalLoading _ => print('loading'),
 /// });
 /// ```
-sealed class SignalState {}
+sealed class SignalState<T> {
+  /// Returns true if the signal is in a loading state
+  bool get isLoading => this is SignalLoading<T>;
+
+  /// Returns true if the signal is in an error state
+  bool get isTimeout => this is SignalTimeout<T>;
+
+  /// Returns true if the signal is in an error state
+  bool get hasError => this is SignalError<T, Object>;
+
+  /// Returns true if the signal is in a value state
+  bool get hasValue => this is SignalValue<T>;
+
+  /// Returns the value of the signal or null if not a value
+  T? get valueOrNull {
+    if (this is SignalValue<T>) {
+      return (this as SignalValue<T>).value;
+    }
+    return null;
+  }
+
+  /// Returns the error of the signal or null if not an error
+  Object? get errorOrNull {
+    if (this is SignalError<T, Object>) {
+      return (this as SignalError<T, Object>).value;
+    }
+    return null;
+  }
+}
 
 /// Successful state for a signal
-class SignalValue<T> extends SignalState {
+class SignalValue<T> extends SignalState<T> {
   /// Value of the signal
   final T value;
 
@@ -21,19 +49,19 @@ class SignalValue<T> extends SignalState {
 }
 
 /// Error state for a signal
-class SignalError extends SignalState {
+class SignalError<T, E extends Object> extends SignalState<T> {
   /// Error of the exception
-  final Object? value;
+  final E? value;
 
   /// Error value result
   SignalError(this.value);
 }
 
 /// Timeout exception for a signal
-class SignalTimeout extends SignalError {
+class SignalTimeout<T> extends SignalError<T, Object> {
   /// Timeout error result
   SignalTimeout() : super(null);
 }
 
 /// Loading state of the signal
-class SignalLoading extends SignalState {}
+class SignalLoading<T> extends SignalState<T> {}

packages/preact_signals/lib/src/stream_signal.dart

@@ -15,15 +15,15 @@ import 'package:preact_signals/preact_signals.dart';
 ///   SignalLoading _ => print('loading'),
 /// });
 /// ```
-class StreamSignal<T> extends Signal<SignalState> {
+class StreamSignal<T> extends Signal<SignalState<T>> {
   /// If true then the stream will be cancelled on error
   final bool? cancelOnError;
 
   /// Creates a [StreamSignal] that wraps a [Stream]
   StreamSignal(
     this._getStream, {
     this.cancelOnError,
-  }) : super(SignalLoading()) {
+  }) : super(SignalLoading<T>()) {
     _init();
   }
 
@@ -42,19 +42,19 @@ class StreamSignal<T> extends Signal<SignalState> {
   }
 
   void _init() {
-    if (peek() is! SignalLoading) {
-      value = SignalLoading();
+    if (peek() is! SignalLoading<T>) {
+      value = SignalLoading<T>();
     }
     var s = _getStream();
     _subscription = s.listen(
       (value) {
-        this.value = SignalValue(value);
+        this.value = SignalValue<T>(value);
       },
       onError: (error) {
-        if (error is SignalTimeout) {
+        if (error is SignalTimeout<T>) {
           value = error;
         } else {
-          value = SignalError(error);
+          value = SignalError<T, Object>(error);
         }
       },
       cancelOnError: cancelOnError,
@@ -67,5 +67,8 @@ StreamSignal<T> streamSignal<T>(
   Stream<T> Function() stream, {
   bool? cancelOnError,
 }) {
-  return StreamSignal(stream, cancelOnError: cancelOnError);
+  return StreamSignal<T>(
+    stream,
+    cancelOnError: cancelOnError,
+  );
 }

packages/preact_signals/pubspec.yaml

@@ -1,6 +1,6 @@
 name: preact_signals
 description: Signal, Computed and Effect built with dart
-version: 0.3.1
+version: 0.3.2
 repository: https://github.com/rodydavis/preact_signals.dart
 
 environment:

packages/preact_signals/test/future_test.dart

@@ -13,7 +13,7 @@ void main() {
       final completer = Completer<int>();
       effect(() {
         final state = signal.value;
-        if (state is SignalValue) {
+        if (state is SignalValue<int>) {
           completer.complete(state.value);
         }
       });
@@ -30,7 +30,7 @@ void main() {
       final completer = Completer<int>();
       effect(() {
         final state = signal.value;
-        if (state is SignalValue) {
+        if (state is SignalValue<int>) {
           completer.complete(state.value);
         }
       });

packages/preact_signals/test/stream_test.dart

@@ -13,7 +13,7 @@ void main() {
       final completer = Completer();
       effect(() {
         final state = signal.value;
-        if (state is SignalValue) {
+        if (state is SignalValue<int>) {
           completer.complete(state.value);
         }
       });
@@ -30,7 +30,7 @@ void main() {
       final completer = Completer<int>();
       effect(() {
         final state = signal.value;
-        if (state is SignalValue) {
+        if (state is SignalValue<int>) {
           completer.complete(state.value);
         }
       });