Merge pull request #8 from hoc081098/null_safety

null_safety!

Author: hoc081098

.github/workflows/dart.yml

@@ -12,7 +12,7 @@ jobs:
     runs-on: ubuntu-latest
 
     container:
-      image:  google/dart:latest
+      image:  google/dart:2.12-beta
 
     steps:
     - uses: actions/checkout@v2

.travis.yml

@@ -1,7 +1,7 @@
 language: dart
 dart:
-  - stable
   - dev
+  - beta
 script:
   - dartanalyzer --fatal-infos --fatal-warnings ./lib ./test
   - dartfmt -n ./lib --set-exit-if-changed

CHANGELOG.md

@@ -1,3 +1,10 @@
+## 2.2.0-nullsafety.1 - Nov 30, 2020
+-   Fixed: support nullable action.
+
+## 2.2.0-nullsafety.0 - Nov 28, 2020
+-   Migrate this package to null safety.
+-   Sdk constraints: `>=2.12.0-0 <3.0.0` based on beta release guidelines.
+
 ## 2.1.1 - Oct 30, 2020
 
 -   Add `RxReduxStore.dispatchMany(Stream<A>)`: Dispatch a `Stream` of actions to store.

example/counter.dart

@@ -38,11 +38,11 @@ void main() async {
 
   store.stateStream.listen(print);
 
-  await Stream.periodic(const Duration(seconds: 1), (i) => i + 1)
+  Stream.periodic(const Duration(milliseconds: 500), (i) => i + 1)
       .take(10)
       .map((i) => i.isEven ? Increment(i) : Decrement(i))
-      .forEach(store.dispatch);
+      .dispatchTo(store);
 
-  await Future(() {});
+  await Future<void>.delayed(const Duration(seconds: 6));
   await store.dispose();
 }

lib/rx_redux.dart

@@ -4,5 +4,6 @@ export 'src/logger.dart';
 export 'src/reducer.dart';
 export 'src/reducer_exception.dart';
 export 'src/redux_store_stream_transformer.dart';
+export 'src/selectors.dart';
 export 'src/side_effect.dart';
 export 'src/store.dart';

lib/src/reducer.dart

@@ -7,5 +7,4 @@
 /// * Param [currentState] [S] The type of the state
 /// * Param [newAction] [A] The type of the Actions
 ///
-
 typedef Reducer<A, S> = S Function(S currentState, A newAction);

lib/src/reducer_exception.dart

@@ -1,5 +1,3 @@
-import 'package:meta/meta.dart';
-
 /// Exception thrown by reducer
 class ReducerException<A, S> implements Exception {
   /// Action passed into reducer
@@ -16,10 +14,10 @@ class ReducerException<A, S> implements Exception {
 
   /// Construct a [ReducerException]
   const ReducerException({
-    @required this.action,
-    @required this.state,
-    @required this.error,
-    this.stackTrace,
+    required this.action,
+    required this.state,
+    required this.error,
+    required this.stackTrace,
   });
 
   @override

lib/src/redux_store_stream_transformer.dart

@@ -1,7 +1,5 @@
 import 'dart:async';
 
-import 'package:meta/meta.dart';
-
 import 'logger.dart';
 import 'reducer.dart';
 import 'reducer_exception.dart';
@@ -34,10 +32,10 @@ extension ReduxStoreExt<Action> on Stream<Action> {
   /// * Param [State] The type of the State
   /// * Param [Action] The type of the Actions
   Stream<State> reduxStore<State>({
-    @required State Function() initialStateSupplier,
-    @required Iterable<SideEffect<Action, State>> sideEffects,
-    @required Reducer<Action, State> reducer,
-    RxReduxLogger logger,
+    required State Function() initialStateSupplier,
+    required Iterable<SideEffect<Action, State>> sideEffects,
+    required Reducer<Action, State> reducer,
+    RxReduxLogger? logger,
   }) =>
       transform(
         ReduxStoreStreamTransformer(
@@ -66,7 +64,7 @@ class ReduxStoreStreamTransformer<A, S> extends StreamTransformerBase<A, S> {
   final S Function() _initialStateSupplier;
   final Iterable<SideEffect<A, S>> _sideEffects;
   final Reducer<A, S> _reducer;
-  final RxReduxLogger _logger;
+  final RxReduxLogger? _logger;
 
   /// * Param [initialStateSupplier]  A function that computes the initial state. The computation is
   /// * done lazily once an observer subscribes. The computed initial state will be emitted directly
@@ -77,26 +75,20 @@ class ReduxStoreStreamTransformer<A, S> extends StreamTransformerBase<A, S> {
   /// * Param [S] The type of the State
   /// * Param [A] The type of the Actions
   ReduxStoreStreamTransformer({
-    @required S Function() initialStateSupplier,
-    @required Iterable<SideEffect<A, S>> sideEffects,
-    @required Reducer<A, S> reducer,
-    RxReduxLogger logger,
-  })  : assert(initialStateSupplier != null,
-            'initialStateSupplier cannot be null'),
-        assert(sideEffects != null, 'sideEffects cannot be null'),
-        assert(sideEffects.every((sideEffect) => sideEffect != null),
-            'All sideEffects must be not null'),
-        assert(reducer != null, 'reducer cannot be null'),
-        _initialStateSupplier = initialStateSupplier,
+    required S Function() initialStateSupplier,
+    required Iterable<SideEffect<A, S>> sideEffects,
+    required Reducer<A, S> reducer,
+    RxReduxLogger? logger,
+  })  : _initialStateSupplier = initialStateSupplier,
         _sideEffects = sideEffects,
         _reducer = reducer,
         _logger = logger;
 
   @override
   Stream<S> bind(Stream<A> stream) {
-    StreamController<S> controller;
-    List<StreamSubscription<dynamic>> subscriptions;
-    StreamController<WrapperAction<A>> actionController;
+    late StreamController<S> controller;
+    List<StreamSubscription<Object?>>? subscriptions;
+    StreamController<WrapperAction>? _actionController;
 
     void onListen() {
       S state;
@@ -109,20 +101,20 @@ class ReduxStoreStreamTransformer<A, S> extends StreamTransformerBase<A, S> {
         return;
       }
 
-      void onDataActually(WrapperAction<A> wrapper) {
-        final action = wrapper.action;
+      void onDataActually(WrapperAction wrapper) {
         final type = wrapper.type;
         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<A>();
         try {
           final newState = _reducer(currentState, action);
           controller.add(newState);
@@ -151,35 +143,39 @@ class ReduxStoreStreamTransformer<A, S> extends StreamTransformerBase<A, S> {
         }
       }
 
-      actionController = StreamController<WrapperAction<A>>.broadcast();
+      final actionController =
+          _actionController = StreamController<WrapperAction>.broadcast();
 
       // Call reducer on each action.
       final subscriptionActionController =
           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<A>())
+          .asBroadcastStream(onCancel: (s) => s.cancel());
 
       subscriptions = [
-        ..._listenSideEffects(actionController, getState, controller),
+        ..._listenSideEffects(
+            actionController, getState, controller, actionStream),
         subscriptionUpstream,
-        subscriptionActionController
+        subscriptionActionController,
       ];
     }
 
     Future<void> onCancel() async {
-      final future = actionController?.close();
+      final future = _actionController?.close();
       final cancelFutures = subscriptions?.map((s) => s.cancel());
       final futures = [...?cancelFutures, if (future != null) future];
 
@@ -199,38 +195,35 @@ class ReduxStoreStreamTransformer<A, S> extends StreamTransformerBase<A, S> {
       controller = StreamController<S>(
         sync: true,
         onListen: onListen,
-        onPause: () => subscriptions.forEach((s) => s.pause()),
-        onResume: () => subscriptions.forEach((s) => s.resume()),
+        onPause: () => subscriptions?.forEach((s) => s.pause()),
+        onResume: () => subscriptions?.forEach((s) => s.resume()),
         onCancel: onCancel,
       );
     }
 
     return controller.stream;
   }
 
-  Iterable<StreamSubscription<dynamic>> _listenSideEffects(
-    StreamController<WrapperAction<A>> actionController,
+  Iterable<StreamSubscription<Object?>> _listenSideEffects(
+    StreamController<WrapperAction> actionController,
     GetState<S> getState,
-    StreamController<S> controller,
+    StreamController<S> stateController,
+    Stream<A> actionStream,
   ) {
     return _sideEffects.mapIndexed(
       (index, sideEffect) {
         Stream<A> actions;
         try {
-          actions = sideEffect(
-            actionController.stream.map((wrapper) => wrapper.action),
-            getState,
-          );
+          actions = sideEffect(actionStream, getState);
         } catch (e, s) {
           actions = Stream.error(e, s);
         }
 
         return actions
-            .map(
-                (action) => WrapperAction(action, ActionType.sideEffect(index)))
+            .map((action) => WrapperAction.sideEffect(action, index))
             .listen(
               actionController.add,
-              onError: controller.addError,
+              onError: stateController.addError,
               // Swallow onDone because just if one SideEffect reaches onDone
               // we don't want to make everything incl. ReduxStore and other SideEffects reach onDone
             );