live_cells 0.32.0

live_cells: ^0.32.0 copied to clipboard

• New Widgets:

  • LiveRadioGroup
  • LiveTextFormField

• Changes

  • Upgraded minimum Flutter version to 3.35.0.

New features:

• New extension methods on cells holding Lists:

  • add - Adds an item to the end of the list
  • insert - Inserts an item at a given index

• mapIndexed extension method on cells holding Iterables.

Changes:

• intl dependency upgraded to 0.20.2 for compatibility with new Flutter versions.

New features: #

• New widgets:

  • LiveFloatingActionButton
  • LiveIconButton
  • LiveInkWell
  • LiveInteractiveViewer

Fixes #

• Fix issue with setState being called after the CellWidget is unmounted
• Add key to .combined extension property on List<ValueCell<void>>

New Features #

• Live widget wrappers now provide every constructor that is provided by the wrapped Flutter widgets.

  For example, the LiveFilledButton widget, which is a wrapper over Flutter's FilledButton now also provides the .icon and .tonal constructors in addition to the default constructor:

  LiveFilledButton.icon(
    icon: Icon(...),
    label: Text(...),
    
    press: pressActionCell
  )
  

Breaking Changes #

• Removed StaticWidget

  Reason: Doesn't interact well with inherited widgets

  Replacement: CellWidget

• Removed CellHooks mixin

  Reason:: It's obsolete since cells can be defined directly in the build method of a CellWidget

  Replacement: Define cells and watch functions directly in the build method/function of a CellWidget

• Removed bind methods provided by Live widgets

  Reason: There are few use cases for it and it is difficult to implement for widgets that provide multiple constructors

  Replacement: Create a new widget constructor

• Live button widgets (LiveFilledButton, LiveElevatedButton, etc.) now take ActionCells for the press and longPress arguments instead of MetaCell<void>.

  Reason: This makes the button widgets easier to use

• Renamed InactiveMetaCelLError to InactiveMetaCellError.

• Minimum required Flutter version is now 3.29.3

• Fix issue with widgets not updating if triggered by cell changes during build phase.

New features:

• CellExtension now also generates comparator and hash functions for an annotated class:

  @CellExtension()
  class Point {
    final int x;
    final int y;
    
    ...
    
    @override
    bool operator ==(Object other) =>
      _$PointEquals(this, other);
    
    @override
    int get hashCode => _$PointHashCode(this); 
  }
  

  Additionally the DataClass annotation can be used to generate comparator and hash functions for a class without generating a cell extension.

Breaking Changes:

• The live_cells_ui library now requires at least Flutter 32.29.2

Breaking Changes:

• Remove deprecated live_cell_widgets library

New features:

• .exception() method for creating a cell that throws the exception held in its value:

  final e = MutableCell(Exception('An exception!'));
  final exceptionCell = e.exception();
    
  // Throws Exception('An exception!')
  e();
  

• Mutable variants of .contains() and .containsAll() extension methods

  .contains() and .containsAll() now return mutable cells when called on mutable cells containing sets.

  When the value of the contains(...) cell is set to true the item is added to the set, and when set to false the item is removed from the set:

  final set = MutableCell({1, 2, 3, 4});
    
  // contains1 is now a MutableCell
  final contains1 = set.contains(1.cell);
    
  // Setting its value to false removes 1 from [set].
  contains1.value = false;
    
  print(contains1.value); // Prints 2, 3, 4
    
  // Setting its value to true adds the element to the [set].
  contains1.value = true;
    
  print(contains1.value); // Prints 1, 2, 3, 4
  

  Similarly when the value of the .containsAll cell is set, the items in the iterable passed to it are added/removed from the set.

• .removeAt() method on cells holding lists:

  final l = MutableCell([1, 2, 3, 4]);
    
  // Remove the element at index 2
  l.removeAt(2);
    
  print(l.value); // Prints 1, 2, 4
    
  l.removeAt(0);
  print(l.value); // 2, 4 
  

• UniqueCellKey, which can be used as a cell key to specify that a cell is not functionally equivalent to any other cell.

  This is useful to prevent a cell from being assigned a key contexts, such as within the build method of a CellWidget, where a key is automatically assigned to a cell if it isn't explicitly provided during the construction of the cell.

New features:

• New format argument on mutableString() extension methods.

  Example:

  final germanFormat = NumberFormat("#,##0.00", "de_DE");
    
  final a = MutableCell(1.0);
  final strA = a.mutableString(format: germanFormat);
    
  a.value = 2.5;
  print(strA.value); // 2,50
    
  strA.value = '12,30';
  print(a.value); // 12.3
  

New features:

• coalesce extension method on MutableCells.

  When coalesce is called on a MutableCell, a MutableCell is now returned. This allows assigning the value of the cell on which the method is called via the cell returned by coalesce.

  Example:

  final a = MutableCell<int?>(null);
  final b = MutableCell(-1);
    
  // c is a MutableCell
  final c = a.coalesce(b);
    
  ValueCell.watch(() {
    print('A = ${a()}');
  });
    
  ValueCell.watch(() {
    print('C = ${c()}');
  });
    
  b.value = 1; // Prints 'A = 1' and 'C = 1'
    
  // Assigning value of 'c' assigns value of 'a'
  c.value = 2; // Prints 'A = 2' and 'C = 2'
    
  // Doesn't print anything since the value of 'a' is not null
  b.value = 3;
  

• Fix issue with cell state restoration in widgets.

Update examples in readme.

Add missing Changelog entry for 0.25.0.

Breaking changes:

• The minimum Flutter version has been increased to 3.24.3.

• The live_cells_widgets library is deprecated. Use the live_cells_ui library.

• The live_cells_ui library provides the same functionality as live_cells_widgets with the following differences:

  • The widgets are prefixed with Live instead of Cell, e.g. LiveTextField from live_cells_ui is the equivalent to CellTextField from live_cell_widgets

  • Only those properties which represent user input are cells, the rest are regular values. For example in LiveSwitch only the value and enabled properties are cells.

  • live_cells_ui does not provide wrappers for widgets which do not take input from the user, for example there is no LiveText equivalent to CellText. Wrap a regular Text widget in a CellWidget.builder or a CellWidget subclass for reactivity.

New features:

• reset parameter in MutableCell constructor.

  This allows the value of a shared state mutable cell to be reset to the initial value when a new cell is created.

  Example:

  final myKey = MyKey();
    
  final a = MutableCell(1, key: myKey);
    
  ValueCell.watch(() {
    print(a.value);
  }); // Prints 1
    
  // Create a new shared state cell and reset the value of all
  // cells with key 'myKey' to 2
    
  final b = MutableCell(2, 
    key: myKey,
    reset: true
  );
  print(a.value); // Prints 2
  print(b.value); // Prints 2
  

New features:

• .transform<...>() for casting a cell's value type

  Example:

  ValueCell<Base> base = ...;
  final derived = base.transform<Derived>();
  

Bug fixes:

• Fix edge case bug in mutableApply.

Other changes:

• Update widget wrappers to Flutter 3.24.3

• Fix issue with return type of MutableCell.notNull extension method

New features:

• .notNull extension method on MutableCell

• Fix issue with mutable computed cell dependency tracking.

• Update homepage URL

Debugging Improvements:

• Exceptions held in a Maybe are now rethrown with the stack trace of the exception, when the Maybe is unwrapped with Maybe.unwrap.

New widgets:

• CellCheckboxMenuButton
• CellCheckboxTheme
• CellChipTheme
• CellColoredBox
• CellColoredFilter
• CellCheckedPopupMenuItem
• CellChoiceChip
• CellCloseButton
• CellContraintsTransformBox

New features:

• Watch function keys.

  Watch functions can now be identified by keys, like cells, provided in the ValueCell.watch and Watch constructor.

  final w1 = ValueCell.watch(() { ... }, key: 'key1');
  final w2 = ValueCell.watch(() { ... }, key: 'key2');
    
  w1 == w2; // true
    
  // Stops both w1 and w2 since they have the same keys
  w1.stop();
  

• Watch functions can now be defined directly in the build method of a CellWidget without CellHooks:

  CellWidget.builder((_) {
    final cell = MutableCell(...);
    
    ValueCell.watch(() {
      final c = cell();
      ...
    })
    ...
  });
  

Breaking Changes:

• ValueCell.observe no longer returns the value of the cell. Additionally, this eliminates the need to catch exceptions originating from the cell when the caller is only interested in being notified when the value of the cell changes, but is not interested in the actual value.

New widgets:

• CellPageView

  A PageView with the current page controlled by a page cell:

  final page = MutableCell(0);
    
  return CellPageView(
    page: page,
    animate: true.cell
    duration: Duration(milliseconds: 100).cell,
    curves: Curves.easeIn.cell
      
    children: [
       Page1(),
       Page2(),
       ...
    ].cell
  );
  

  The current page can be changed by setting the page cell.

  page.value = 2;
  

  The current page can also be observed by observing the same page cell.

New Features:

• Watch

  Registers a watch function that has access to its own handle.

  This can be used to 1) stop a watch function directly from within the watch function and 2) prevent code from running on the first call of the watch function.

  final watch = Watch((state) {
    final value = a();
      
    state.afterInit();
    
    // The following is only run after the first call
    print('A = $value');
      
    if (value > 10) {
      state.stop();
    }
  });
  

• Fix bug in AsyncState comparison.

New features:

• .asyncState for creating a cell that evaluates to the state of a cell holding a Future.

  .asyncState evaluates to an AsyncState which is a sealed union of:

  • AsyncStateLoading
  • AsyncStateData
  • AsyncStateError

Changes:

• Convert Maybe to a sealed union of:

  • MaybeValue
  • MaybeError

  This change does not break existing code.

• Fixed bug with deferred cell initialization not happening in MetaCell:

  Sometimes a cell was not initialized when it is injected in a MetaCell. This update ensures, that every every cell injected in a MetaCell is properly initialized.

• Fixed bug in .coalesce(): If coalesce value cell throws an exception it is propagated regardless of whether the cell, on which the method is called, is null or not.

• Improvements to cell updating algorithm.
• Fixed bug in awaited cells.

New features:

• MutableMetaCell and ActionMetaCell, which allow MutableCells to have their values set, and ActionCells to be triggered from MetaCells.

Minor changes:

• The .chain(...) method can now be called on ValueCell<void>. Previously it could only be called on an ActionCell.

New features:

• SelfCell

  A computed cell which can access it's own value via the self argument:

  final increment = ActionCell();
  final cell = SelfCell((self) {
    increment.observe();
    return self() + 1;
  });
  

• Action cell chaining with .chain(...)

  .chain(...) creates an action cell that calls a user provided function when triggered. This function can decide whether to trigger the chained action or not.

• Null checking utilities:

  • .notNull

    Returns a cell with a value guaranteed to be non-null. If the value of the cell, on which the property is used, is null, a NullCellError exception is thrown.

  • .coalesce(...)

    Returns a cell that replaces null values in the cell, on which the method is used, with the value of another cell.

New widgets:

• CellBanner
• CellBlockSemantics
• CellVisibility

New features:

• Effect Cells

  These can be created with .effect() on an action cell (ValueCell<void>). An effect cell is guaranteed to only be run once per trigger of the action cell on which the .effect() method is called. This is useful for running side effects, while still being able to observe the result of the effect as a cell.

  Example:

  final result = action.effect(() async {
  return await submitForm();
  });
  

• Combining Action Cells:

  Multiple action cells can now be combined into a single cell, which notifies its observers, whenever any of the actions trigger, using List.combined

  Example:

  final a1 = ActionCell();
  final a2 = ActionCell();
    
  final all = [a1, a2].combined;
  

Breaking Changes:

• Async cells created with .wait, .waitLast, .awaited now throw an PendingAsyncValueError instead of UninitializedCellError when the cell value is referenced while the future is pending.

  This does not affect code which uses .initialValue to handle these errors.

• Renamed onPressed and onLongPress of cell Material buttons to press and longPress, respectively.

  The purpose of this change, is to later allow callback based event handlers to be added using onPressed and onLongPress

Other Changes:

• Computed cells no longer run the computation function on initialization. Instead the first run of the computation function is deferred to the first time the cell value is referenced.

  NOTE: This changes slightly the semantics of computed cells, especially dynamic computed cells which are now dormant until their value is referenced at least once.

• Clarify semantics of ValueCell.none:

  If a null default value is given and ValueCell.none is used during the computation of the initial value of a cell, UninitializedCellError is thrown.

• Bug fix: Unhandled exceptions in a ValueCell.watch no longer propagate out of the watch function.

• Improve action cell example.

• Add example of action cells to example project.

• Allow setting cell values in watch functions.

Additions from core:

• Add .whenReady property on MetaCells.

  This property creates a cell that evaluates to ValueCell.none while the meta cell is empty.

• Add MetaCell.inject method as an alias for MetaCell.setCell.

• Allow watch functions to be terminated using ValueCell.none() like compute functions.

New features from core:

• Meta Cells

  A meta cell (MetaCell) is a cell that points to another cell. The value of a meta cell is the value of the pointed to cell, and its observers are notified when the pointed to cell's value changes.

  The pointed to cell can be changed multiple times.

  Example:

  final a = MutableCell(0);
  final b = MutableCell(1);
    
  final meta = MetaCell<int>();
    
  meta.setCell(a);
  print(meta.value); // 0
    
  meta.setCell(b);
  print(meta.value); // 1
  

• A .hold() method for keeping a cell active until it is released with .release()

  final a = MutableCell(0, key: aKey);
    
  // Ensure that a is active
  final hold = a.hold();
  ...
  // Allow a to be disposed
  hold.release();
  

New widgets:

• CellElevatedButton
• CellFilledButton
• CellOutlinedButton
• CellTextButton

Breaking Changes:

• Removed dispose() method from MutableCell interface.

• Reading/writing the value of a keyed MutableCell while it is inactive now throws an InactivePersistentStatefulCellError.

  Use .hold() to ensure a keyed MutableCell is active before using it.

New features:

• Automatic key generation for unkeyed cells defined in the build method of CellWidget and CellWidget.builder.

  This allows cells local to a CellWidget to be defined directly in the build method/function without having to use .cell(() => ...)

  With version 0.4.0:

  class Example extends CellWidget with CellInitializer {
    @override
    Widget build(BuildContext context) {
      final count = cell(() => MutableCell(0));
      ...
    }
  }
  

  This can now be simplified to the following with version 0.5.0:

  class Example extends CellWidget {
    @override
    Widget build(BuildContext context) {
      final count = MutableCell(0);
      ...
    }
  }
  

Breaking Changes:

• CellInitializer has been renamed to CellHooks

• .cell() and .watch() have been moved from BuildContext to CellHookContext.

  This will not affect code that uses CellWidget.builder.

• State restoration options have been removed from .cell(). Use .restore() instead.

Changes from core:

• Add exception handling to initial cell watch function calls.
• Improve unhandled exception notices.

• Fix typos in Changelog.

New features from core:

• and(), or() and not() now return keyed cells.

• The following methods for waiting for changes in cell values:

  • .nextChange()
  • .untilValue()
  • .untilTrue()
  • .untilFalse()

• ActionCell

  A cell without a value, used solely to represent actions and events.

New widgets:

• CellAbsorbPointer
• CellAnimatedCrossFade
• CellAnimatedFractionallySizedBox
• CellAnimatedPositionedDirectional
• CellAnimatedRotation
• CellAnimatedScale
• CellAnimatedSlide
• CellAnimatedSwitcher
• CellAnnotatedRegion

Other changes:

• Removed deprecated computeCell and computeWidget extension methods on List
• Removed deprecated RestorableCellWidget

• Fix issue with .isCompleted having incorrect value when Future completes with an error.

New features from core:

• .awaited property on cells holding a Future.

  Returns a cell which evaluates to the value of the Future when completed, throws an UninitializedCellError when it is pending.

• .isCompleted property on cells holding a Future.

  Returns a cell which evaluates to true when the Future is complete, false while it is pending.

• .initialValue(...) which returns a cell with takes on the value of the given cell until it is initialized.

• Fix async examples in README.

Minor additions from core:

• .waitLast property which is the same as .wait but if a new Future is received before the previous one has completed, the previous future is dropped.

New features for asynchronous cells:

• .wait property for creating a cell that awaits a Future held in another cell.
• .delayed for creating a cell that takes the value of another cell but only notifies its observers after a given delay.

Breaking changes:

• Removed DelayCell.

• .cell extension property is now available on all types

• Additions to Iterable cell extension:

  • cast<E>() method
  • map() method

• Additions to List cell extension:

  • cast<E>() method
  • mapCells() method

• Improvements to CellWidget:

  • Unused dependencies are untracked.
  • Widget properties can now be bound to different cells between builds.

• Increase live_cells_core dependency version to 0.12.3
• Increase live_cell_widgets dependency version to 0.2.2

New features in core:

New features:

• Record extension methods for creating lightweight computed (and mutable computed) cells:

  (a, b).apply((a,b) => a + b);
  (a, b).mutableApply((a,b) => a + b, (v) {...});
  

• changesOnly option in cell constructors. When this option is set to true, the cell only notifies its observers when its value has actually changed.

• Relaxed restriction that MutableCellView only accept a single argument

• Extensions which allow Iterable, List, Map and Set methods and properties to be used directly on cells:

New features in widgets library:

• Simplified state restoration:

  • No need to use RestorableCellWidget
  • Add restorationId directly on CellWidget / StaticWidget.
  • Added .restore() method for cell state restoration in StaticWidget

• New Widgets:

  • CellRow
  • CellColumn

Bump live_cell_widgets dependency version to 0.1.1:

• Fix bug in StaticWidget.builder.

Move documentation to: https://alex-gutev.github.io/live_cells/docs/intro

This release divides the functionality of this package among component packages:

• live_cell_core
• live_cell_widgets

Additionally the full documentation is now available at: https://docs.page/alex-gutev/live_cells.

New Features:

• Wrapper classes for more widgets
• .peek property for accessing the value of a cell without triggering a recomputation

Breaking Changes:

• Minimum SDK version increased to 3.0.0
• All properties of the widgets provided by live_cell_widgets are now cells

• Change live_cell_annotations version to 0.2.0.

• Fix bug: Handle exceptions thrown during computation of the initial values of cells.

• Move annotations into separate package: https://pub.flutter-io.cn/packages/live_cell_annotations.

New features:

• Keyed cells, cells with the same key reference a shared state.
• Lightweight mutable computed cells.
• CellExtension annotation for automatically generating ValueCell accessors for classes, using the live_cell_extension package (which will be released soon).

This release also comes with major changes to the implementation. These changes are only breaking to code which creates user-defined ValueCell subclasses:

• Removed the following internal implementation classes and mixins from the public API:
  • EqCell
  • NeqCell
  • NotifierCell
  • CellEquality
  • CellListeners
  • ObserverCell

• Fixed bug with accessing previous cell values

New features:

• Constant bool, null, Enum and Duration cells can now be created with the cell property, e.g. true.cell.
• Utilities for working with cells holding a Duration.
• CellObserverModel for creating classes which observe one or more cells
• Add selection cell parameter to CellTextField constructor for observing and controlling the field's selection.

• Correct typos and errors in readme examples

New features:

• Ability to access the previous values of cells with .previous
• Ability to abort a cell value update with ValueCell.none()
• and, or, not and select methods on bool cells
• Exception handling using onError and error
• Clarified how exceptions are propagated between cells

New features:

• ValueCell.watch and CellInitializer.watch for calling a function whenever the values of cells change.
• State restoration of cells with RestorableCellWidget

• Fix potential issues
• Fix typos and improve README

New features:

• Maybe type and MaybeCell for error handling
• errorValue argument of mutableString method to control value in case of errors during parsing
• Remove restriction that arguments of mutable computed cells be mutable cells

Breaking changes:

• Add shouldNotifyAlways property to CellObserver interface

Improvements and bug fixes:

• Simplify implementation of CellInitializer.cell
• Allow updated cell value to be accessed even when the cell has no observers
• Fix bug in BuildContext.cell method
• Fix bug in CellTextField

• Fix potential issues

• Fix typos and bugs in examples in README

New features:

• ValueCell.computed constructor for creating computed cells with dynamic dependencies
• MutableCell.computed constructor for creating mutable computed cells with dynamic dependencies
• CellWidget can now also track the cells it depends on at runtime
• mutableString extension method on MutableCell's holding an int, double, num or string

Breaking changes:

• CellWidget.cell method has been moved to CellListeners mixin
• CellWidgetBuilder has been removed in favour of CellWidget.builder constructor

Improvements:

• Simplified examples demonstrating core concepts only
• Simplified and streamlined API
• Improved README
• Bug fixes

• Bug fixes

• Simplify implementation of CellWidget. Subclasses now override build instead of buildChild.

• Bug fixes

New features:

• Mutable computational cells
• Batch updates
• CellWidget base class for creating widgets make use of cells
• CellWidgetBuilder for creating CellWidget's without subclassing
• New widgets in widgets library:
  • CellCheckbox
  • CellCheckboxListTile
  • CellRadio
  • CellRadioListTile
  • CellSlider
  • CellSwitch
  • CellSwitchListTile
• Shorthand List.computeWidget method for creating widgets which depend on multiple cells

Breaking changes:

• MutableCell is now an interface with a factory constructor
• CellObserver interface methods now take observed cell as arguments
• Removed CellBuilder

• Fix issue with CellTextField

• Fix issue with List.computeCell method
• Fix issues with unit tests

• Fix issues with examples in README

New features:

• Stronger guarantees that a StoreCell will not hold an outdated value
• Shorthand .cell property for creating constant value cells
• Shorthand List.computeCell method for creating multi-argument computational cells
• Arithmetic and comparison operator overloads to create computational cells directly using expressions such as a + b

Breaking changes:

• ValueCell is no longer a ValueListenable
• ValueCell.addListener and ValueCell.removeListener are replaced with addObserver and removeObserver
• New CellObserver interface for observing changes to the values of cells
• ValueCell.listenable property provided to use ValueCell as a ValueListenable

• Fix dart doc issues

• Fix package directory structure

• Initial release.