support nullable action

Author: hoc081098

lib/src/redux_store_stream_transformer.dart

@@ -106,15 +106,15 @@ class ReduxStoreStreamTransformer<A, S> extends StreamTransformerBase<A, S> {
         final currentState = state;
 
         // add initial state
-        if (identical(type, ActionType.initial)) {
+        if (identical(wrapper, WrapperAction.initial)) {
           final message = '\n'
               '  ⟶ Action       : $type\n'
               '  ⟹ Current state: $currentState';
           _logger?.call(message);
           return controller.add(currentState);
         }
 
-        final action = wrapper.action!;
+        final action = wrapper.action;
         try {
           final newState = _reducer(currentState, action);
           controller.add(newState);
@@ -151,20 +151,19 @@ class ReduxStoreStreamTransformer<A, S> extends StreamTransformerBase<A, S> {
           actionController.stream.listen(onDataActually);
 
       // Add initial action
-      actionController.add(WrapperAction(null, ActionType.initial));
+      actionController.add(WrapperAction.initial);
 
       // Listening to upstream actions
-      final subscriptionUpstream = stream
-          .map((action) => WrapperAction(action, ActionType.external))
-          .listen(
-            actionController.add,
-            onError: controller.addError,
-            onDone: controller.close,
-          );
+      final subscriptionUpstream =
+          stream.map((action) => WrapperAction.external(action)).listen(
+                actionController.add,
+                onError: controller.addError,
+                onDone: controller.close,
+              );
 
       final getState = () => state;
       final actionStream = actionController.stream
-          .map((wrapper) => wrapper.action!)
+          .map((wrapper) => wrapper.action)
           .asBroadcastStream(onCancel: (s) => s.cancel());
 
       subscriptions = [
@@ -220,9 +219,8 @@ class ReduxStoreStreamTransformer<A, S> extends StreamTransformerBase<A, S> {
           actions = Stream.error(e, s);
         }
 
-        final sideEffectAction = ActionType.sideEffect(index);
         return actions
-            .map((action) => WrapperAction(action, sideEffectAction))
+            .map((action) => WrapperAction.sideEffect(action, index))
             .listen(
               actionController.add,
               onError: stateController.addError,

lib/src/store.dart

@@ -213,7 +213,7 @@ extension DispatchToExtension<A> on A {
   void dispatchTo<S>(RxReduxStore<A, S> store) => store.dispatch(this);
 }
 
-/// /// Dispatch this actions [Stream] to [store].
+/// Dispatch this actions [Stream] to [store].
 extension DispatchToStreamExtension<A> on Stream<A> {
   /// Dispatch this actions [Stream] to [store].
   /// See [RxReduxStore.dispatchMany].

lib/src/wrapper_action.dart

@@ -4,12 +4,20 @@ import 'package:meta/meta.dart';
 
 @sealed
 abstract class ActionType {
-  const ActionType.empty();
+  const ActionType._empty();
 
-  static final initial = _Initial();
-  static final external = _External();
+  static const _initial = _Initial();
+  static const _external = _External();
 
-  factory ActionType.sideEffect(int index) = _SideEffect;
+  static final _sideEffects = <int, _SideEffect>{};
+
+  factory ActionType._sideEffect(int index) {
+    final sideEffect = _sideEffects[index];
+    if (sideEffect != null) {
+      return sideEffect;
+    }
+    return _sideEffects[index] = _SideEffect(index);
+  }
 
   @override
   String toString() {
@@ -24,22 +32,37 @@ abstract class ActionType {
 }
 
 class _Initial extends ActionType {
-  _Initial() : super.empty();
+  const _Initial() : super._empty();
 }
 
 class _External extends ActionType {
-  _External() : super.empty();
+  const _External() : super._empty();
 }
 
 class _SideEffect extends ActionType {
   final int index;
 
-  _SideEffect(this.index) : super.empty();
+  _SideEffect(this.index) : super._empty();
 }
 
 class WrapperAction<A> {
-  final A? action;
+  final dynamic _action;
   final ActionType type;
 
-  WrapperAction(this.action, this.type);
+  const WrapperAction._(this._action, this.type);
+
+  factory WrapperAction.external(A action) =>
+      WrapperAction._(action, ActionType._external);
+
+  factory WrapperAction.sideEffect(A action, int index) =>
+      WrapperAction._(action, ActionType._sideEffect(index));
+
+  static const initial = WrapperAction<Never>._(null, ActionType._initial);
+
+  A get action {
+    if (identical(this, initial)) {
+      throw StateError('Cannot get action from WrapperAction.initial');
+    }
+    return _action as A;
+  }
 }

test/store_test.dart

@@ -380,5 +380,47 @@ void main() {
       expect(store.state, 3);
       await store.dispose();
     });
+
+    test('Nullable action', () async {
+      final store = RxReduxStore<int?, String>(
+        initialState: '0',
+        sideEffects: [(actions, getState) => Stream.empty()],
+        reducer: (s, a) => s + a.toString(),
+      );
+
+      // ignore: unnecessary_cast
+      (1 as int?).dispatchTo(store);
+      store.dispatch(2);
+      await delay(100);
+      expect(store.state, '012');
+
+      store.dispatch(null);
+      // ignore: unnecessary_cast
+      (null as int?).dispatchTo(store);
+      await delay(100);
+      expect(store.state, '012nullnull');
+
+      await store.dispose();
+    });
+
+    test('Nullable state', () async {
+      final store = RxReduxStore<int, String?>(
+        initialState: null,
+        sideEffects: [(actions, getState) => Stream.empty()],
+        reducer: (s, a) => a == 1 ? '1' : null,
+      );
+
+      expect(store.state, null);
+
+      1.dispatchTo(store);
+      await delay(100);
+      expect(store.state, '1');
+
+      2.dispatchTo(store);
+      await delay(100);
+      expect(store.state, null);
+
+      await store.dispose();
+    });
   });
 }