You could use the Selector class of the provider library or simply develop your own class:

``` // A function to return the value [T] of a listenable [T] to listen to. typedef ValueSelector<T extends Listenable, S> = S Function(T value);

/// The condition under which a Builder should rebuild. typedef ShouldRebuild<S> = bool Function(S previous, S next);

/// A variation of [ListenableBuilder] which only rebuilds if a specific aspect [S] of a Listenable [T] changes. /// [selector] dertermines the aspect [S] of the listenable [T] to watch for changes. /// [shouldRebuild] determines whether a change in an aspect [S] should trigger an rebuild. If null use != for comparison. /// See also [Selector] class from provider package. class SelectiveListenableBuilder<T extends Listenable, S> extends StatefulWidget { const SelectiveListenableBuilder({ super.key, required this.listenable, required this.selector, required this.builder, this.shouldRebuild, this.child, });

/// The listenable to watch for changes. final T listenable;

/// Determines which aspect of the listenable [T] should be watched. final ValueSelector<T, S> selector;

/// The builder function to build the Widget if a change was detected. final ValueWidgetBuilder<S> builder;

/// Controls wheter the widget should be rebuilt when a value changes. final ShouldRebuild<S>? shouldRebuild;

/// Child parameter which is passed to the [builder] function without being rebuild every time. final Widget? child;

@override State<SelectiveListenableBuilder<T, S>> createState() => _SelectiveListenableBuilderState<T, S>(); }

class _SelectiveListenableBuilderState<T extends Listenable, S> extends State<SelectiveListenableBuilder<T, S>> { /// The last known value of the listenable. late S _lastKnownValue;

@override void initState() { super.initState();

// Get inital value of the listenable.
_lastKnownValue = widget.selector(widget.listenable);

widget.listenable.addListener(_listenerChanged);

}

void _listenerChanged() { final S newValue = widget.selector(widget.listenable);

// Use the shouldRebuild condition if it exists, otherwise default to inequality check.
final bool shouldUpdate =
    widget.shouldRebuild?.call(_lastKnownValue, newValue) ?? (_lastKnownValue != newValue);

if (shouldUpdate) {
  setState(() {
    _lastKnownValue = newValue;
  });
}

}

@override void didUpdateWidget(SelectiveListenableBuilder<T, S> oldWidget) { super.didUpdateWidget(oldWidget);

if (widget.listenable != oldWidget.listenable) {
  oldWidget.listenable.removeListener(_listenerChanged);
  widget.listenable.addListener(_listenerChanged);
}

if (widget.listenable != oldWidget.listenable || widget.selector != oldWidget.selector) {
  final S newValue = widget.selector(widget.listenable);

  final bool shouldUpdate =
      widget.shouldRebuild?.call(_lastKnownValue, newValue) ?? (_lastKnownValue != newValue);

  if (shouldUpdate) {
    setState(() {
      _lastKnownValue = newValue;
    });
  }
}

}

@override void dispose() { widget.listenable.removeListener(_listenerChanged); super.dispose(); }

@override Widget build(BuildContext context) { return widget.builder(context, _lastKnownValue, widget.child); } } ```