built_redux

Info

Build: (waiting for build to complete)
Skynet Results: (waiting for Skynet results)
Pipeline: (waiting for pipeline to start)
This patch release includes the following changes:

Miscellaneous

• #178 Allow analyzer 6

Notes created on Monday, November 04 04:27 PM UTC

• restrict analyzer to 5.x

• open analyzer range to 5

• reopen analyzer range

• only use nndb in generator if nndb feature is enabled. prevents build issues for non nndb consumers

• updated analyzer range to allow 2.x.x
• add gh action workflow

• updated analyzer, source_gen, build, build_test dependency ranges
• fix nnbd issues in generator
• set sdk range lower bound to 2.12.0

• add tests that generate actions with nullable generics
• fixed issue where ++ does not work on builder value
• address deprecations in generator
• Breaking changes:
  • The argements to ActionDispatcher.call are no longer optional. when dispatching an action a payload a value must be provided. if the payload type is nullable null must be explicitly provided. append a ? to the ActionDispatcher type parameter for any actions that can be dispatched with a null payload, e.g. ActionDispatcher<int?>.
  • Remove previously deprecated test method

• allow analyzer 0.39.0
• make dispatcher name public
• fix documentation typo

• add workiva_analysis_options
• remove usage of new keyword in code and examples
• bump various dependencies lower bounds

• add type_annotate_public_apis lint ignore to generated files

• rework generator to lift analyzer version constraint.
• open analyzer range
• generator now uses source parsing to resolve action generic types which allows any unresolved type to be used as an action payload.
• generated actions classes now use type inference.
• bump built_value lower bound to 6.1.4 since it is impossible for pub to resolve to anything lower due to the build dependency constraint.

open built value range restrict analyzer to less than 0.38.3, issue was introduced in 0.38.3 patch

add dart2js:noInline annotations

update analyzer dependency to allow '>=0.33.0 <0.39.0'

update analyzer dependency to allow '>=0.33.0 <0.37.0' fix type in built_redux_test_utils.dart

update analyzer dependency to allow '>=0.33.0 <0.36.0'

update analyzer dependency to allow ^0.33.0

update build dependencies

• allow 4.x.x of built_collection
• added combineReducerBuilder to NestedReducerBuilder
• added a NestedMiddlewareBuilder

• open sdk range to dart 2!
• update built_value and source_gen dependencies
• use SharedPartBuilder rather than PartBuilder in the generator

update generator to use typedef names in actiondispatcher generics

• update dependency range on analyzer
• update dependency range on test
• fix broken test caused by dart 2's new asyc behavior

• add lint ignores to generated files

• fix cast issues around store changes in dart 2
• open analyzer version range

• open sourc-gen range
• run tests on the dev compiler

• add built_redux_test_utils library - exposes an expectDispatched function for expecting a given action gets dispatched asynchronously
• add combine to MiddlewareBuilder class - lets you combine middleware builders
• add toString to Action class
• add example
• add docs

• add build.yaml and build.dart to comply with build_runner 0.7.x

With the dev tag you can consume the latest versions of built_value, build, and build_runner that are only compatable with dart 2.

In order to migrate:

• remove your old build scripts
• update your pubspec to include

  build_runner: ^0.7.9

• add a build.yaml to the root of your repo that contains the following:

targets:
  $default:
    builders:
      built_value_generator|built_value:
        enabled: false

• run pub run build_runner build.

The build script is only a temporary measure until https://github.com/dart-lang/source_gen/issues/319 is resolved.

• add changelog
• update readme to include link to todoMVC repo

• open dependency range on the build package

• open dependency range on the built_collection package

• dispose is now awaitable

• Added actionStream stream to the store api so one can listen to changes resulting from a specific action name.
• Fixed issues called out my adding implicit-dynamic and implicit-cast rules.

• Added reducer builders for all collection types in built_collection. This means you can now write reducers that rebuild just a collection. Examples: https://github.com/davidmarne/built_redux/blob/master/test/unit/collection_models.dart
• The action generator now supports inheritance, meaning one can now have action classes extend one another. AbstractReducerBuilder was added as means of merging a reducer builder defined to rebuild the abstract pieces of state. Examples: https://github.com/davidmarne/built_redux/blob/7.1.0/test/unit/inheritance_test_models.dart for examples

• Breaking changes:
  • A breaking change in behavior was made to action dispatchers. Before action dispatchers executed the middleware/reducers asynchronously, but they now execute synchronously.

For example you may have:

int getCount(store) {
  print(store.state.count); // prints 0
  store.actions.increment(1);
  print(store.state.count); // would print 1 if actions were sync, 0 if async
  return store.state.count; // would return 1 if actions were sync, 0 if async
}

Before this function would return 0 because the state update that occurs from actions.increment would be processed in a future task. Now this function will return 1 because the state update that occurs from actions.increment is processed in the current task

Removes the BuiltReducer interface and the generated BuiltReducer implementation in favor of building a reducer function and passing it to the store at instantiation.

• Breaking changes:
  • Store now takes a reducer
  • Nested reducers need to be built with the NestedReducerBuilder and merged wth the main ReducerBuilder using ReducerBuilder.addNestedReducer
  • Models no longer implement BuiltReducer
    • Remove references to the reducer on your models
  • Renamed ActionDispatcher.syncWithStore to setDispatcher
  • Renamed SubStateChange to SubstateChange

Reasoning:

• Decouples your models and reducers.
• Requires less generated code.
• Reducing requires less map look ups. Previously N map look ups were required where N was the number of BuiltReducers in your state tree. Now only 1 map look up is required per action dispatched.

Examples:

• Example model change. Remove the generated BuiltReducer mixin and the reducer getter

Before:

  abstract class Counter extends Object
     with CounterReducer
     implements Built<Counter, CounterBuilder> {
   int get count;

   get reducer => _reducer;

   Counter._();
   factory BaseCounter() => new _$BaseCounter._(count: 1);
 }

After:

  abstract class Counter implements Built<Counter, CounterBuilder> {
   int get count;

   Counter._();
   factory BaseCounter() => new _$BaseCounter._(count: 1);
 }

• Example nested reducer change. Change NestedCounter's reducer builder to a NestedReducerBuilder. Pass the NestedReducerBuilder mapper functions from the main state/builder to the nested state/builder.

Before

// Built Reducer
abstract class BaseCounter extends Object
    with BaseCounterReducer
    implements Built<BaseCounter, BaseCounterBuilder> {
  int get count;

  BuiltList<int> get indexOutOfRangeList;

  NestedCounter get nestedCounter;

  @override
  get reducer => _baseReducer;

  // Built value constructor
  BaseCounter._();
  factory BaseCounter() => new _$BaseCounter._(
        count: 1,
        nestedCounter: new NestedCounter(),
      );
}

final _baseReducer = (new ReducerBuilder<BaseCounter, BaseCounterBuilder>()
      ..add(BaseCounterActionsNames.increment, _baseIncrement)
      ..add(BaseCounterActionsNames.decrement, _baseDecrement))
    .build();

abstract class NestedCounter extends Object
    with NestedCounterReducer
    implements Built<NestedCounter, NestedCounterBuilder> {
  int get count;

  get reducer => _nestedReducer;

  // Built value constructor
  NestedCounter._();
  factory NestedCounter() => new _$NestedCounter._(count: 1);
}

final _nestedReducer =  (new ReducerBuilder<NestedCounter, NestedCounterBuilder>()
          ..add(NestedCounterActionsNames.increment, _nestedIncrement)
          ..add(NestedCounterActionsNames.decrement, _nestedDecrement))
        .build();

After

abstract class BaseCounter implements Built<BaseCounter, BaseCounterBuilder> {
  int get count;

  NestedCounter get nestedCounter;

  BaseCounter._();
  factory BaseCounter() => new _$BaseCounter._(
        count: 1,
        nestedCounter: new NestedCounter(),
      );
}

// the reducer passed to the store
final reducer = (new ReducerBuilder<BaseCounter, BaseCounterBuilder>()
      ..add(BaseCounterActionsNames.increment, _baseIncrement)
      ..add(BaseCounterActionsNames.decrement, _baseDecrement)
      ..combineNested(_nestedReducer))
    .build();

abstract class NestedCounter implements Built<NestedCounter, NestedCounterBuilder> {
  int get count;

  // Built value constructor
  NestedCounter._();
  factory NestedCounter() => new _$NestedCounter._(count: 1);
}

final _nestedReducer = new NestedReducerBuilder<BaseCounter, BaseCounterBuilder,
    NestedCounter, NestedCounterBuilder>(
  (state) => state.nestedCounter,
  (builder) => builder.nestedCounter,
)
  ..add(NestedCounterActionsNames.increment, _nestedIncrement)
  ..add(NestedCounterActionsNames.decrement, _nestedDecrement);