transform<R> method

SignalsWatch<R> transform<R>(
  1. R transform(
    1. T
    ), {
  2. Key? key,
  3. required Widget builder(
    1. R
    ),
  4. void onInit(
    1. R value
    )?,
  5. Function? onValueUpdated,
  6. void onAfterBuild(
    1. R value
    )?,
  7. void onDispose(
    1. R value
    )?,
  8. bool shouldRebuild(
    1. R newValue,
    2. R oldValue
    )?,
  9. bool shouldNotify(
    1. R newValue,
    2. R oldValue
    )?,
  10. bool equals(
    1. R a,
    2. R b
    )?,
  11. Duration? debounce,
  12. Duration? throttle,
  13. void onError(
    1. Object error,
    2. StackTrace stack
    )?,
  14. Widget errorBuilder(
    1. Object error
    )?,
  15. Widget loadingBuilder()?,
  16. String? debugLabel,
  17. bool debugPrint = false,
})

Transform this signal's value and observe the result with error handling.

This is perfect for transformations that might throw exceptions, such as validation, parsing, or computed values that can fail.

Example:

final numberSignal = SignalsWatch.signal(5);

numberSignal.transform(
  (value) {
    if (value < 0) throw Exception('Negative!');
    return value * 2;
  },
  builder: (doubled) => Text('$doubled'),
  onError: (error, stack) => logError(error, stack),
  errorBuilder: (error) => ErrorCard(error: error),
)

Implementation

SignalsWatch<R> transform<R>(
  R Function(T) transform, {
  Key? key,
  required Widget Function(R) builder,
  void Function(R value)? onInit,
  Function? onValueUpdated,
  void Function(R value)? onAfterBuild,
  void Function(R value)? onDispose,
  bool Function(R newValue, R oldValue)? shouldRebuild,
  bool Function(R newValue, R oldValue)? shouldNotify,
  bool Function(R a, R b)? equals,
  Duration? debounce,
  Duration? throttle,
  void Function(Object error, StackTrace stack)? onError,
  Widget Function(Object error)? errorBuilder,
  Widget Function()? loadingBuilder,
  String? debugLabel,
  bool debugPrint = false,
}) {
  return SignalsWatch<R>(
    key: key,
    read: () => transform(value),
    builder: builder,
    onInit: onInit,
    onValueUpdated: onValueUpdated,
    onAfterBuild: onAfterBuild,
    onDispose: onDispose,
    shouldRebuild: shouldRebuild,
    shouldNotify: shouldNotify,
    equals: equals,
    debounce: debounce,
    throttle: throttle,
    onError: onError,
    errorBuilder: errorBuilder,
    loadingBuilder: loadingBuilder,
    debugLabel: debugLabel,
    debugPrint: debugPrint,
  );
}