Type: SignalsMixin

API reference and details for SignalsMixin from signals.dart.

SignalsMixin deprecated#

Kind: mixin | Package: package:signals_flutter | deprecated

Mixin: SignalsMixin deprecated#

A State mixin that automatically handles subscription and cleanup of signals and effects created locally within a StatefulWidget.

DEPRECATED: This mixin is deprecated. While fully supported for backward compatibility, it adds extra stateful widget lifecycle overhead and manual binding.

For superior, self-contained reactivity without mixin overhead, migrate to modern, high-performance APIs:

Use SignalWidget for stateless reactive widgets.
Use SignalStatefulWidget for stateful reactive widgets.
Use SignalBuilder for surgical, localized rebuilding.

Legacy Usage Example#

class CounterWidget extends StatefulWidget {
  const CounterWidget({super.key});

  @override
  State<CounterWidget> createState() => _CounterWidgetState();
}

class _CounterWidgetState extends State<CounterWidget> with SignalsMixin {
  late final count = createSignal(0);
  late final doubled = createComputed(() => count.value * 2);

  @override
  void initState() {
    super.initState();
    createEffect(() {
      print('Count: ${count.value}, Doubled: ${doubled.value}');
    });
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children: [
        Text('Count: ${count.value}'),
        Text('Doubled: ${doubled.value}'),
        ElevatedButton(
          onPressed: () => count.value++,
          child: const Text('Increment'),
        ),
      ],
    );
  }
}

Modern Migration Example#

// Modern alternative using SignalStatefulWidget:
class CounterWidget extends SignalStatefulWidget {
  const CounterWidget({super.key});

  @override
  State<CounterWidget> createState() => _CounterWidgetState();
}

class _CounterWidgetState extends State<CounterWidget> {
  final count = signal(0);
  late final doubled = computed(() => count.value * 2);

  @override
  void initState() {
    super.initState();
    // For non-widget effects, use the standard `effect` function:
    effect(() {
      print('Count: ${count.value}, Doubled: ${doubled.value}');
    });
  }

  @override
  Widget build(BuildContext context) {
    // Implicitly tracks both signals and rebuilds on change:
    return Column(
      children: [
        Text('Count: ${count.value}'),
        Text('Doubled: ${doubled.value}'),
        ElevatedButton(
          onPressed: () => count.value++,
          child: const Text('Increment'),
        ),
      ],
    );
  }
}

Members of SignalsMixin#

Member	Type	Signature	Description
disposeSignal	`method`	`dart void disposeSignal(int id)`	Dispose and remove signal
createComputedFrom	`method`	`dart FutureSignal createComputedFrom(List<ReadonlySignal> signals, Future Function(List args) fn, {S? initialValue, String? debugLabel, bool lazy = true})`	Async Computed is syntax sugar around FutureSignal.
createComputedAsync	`method`	`dart FutureSignal createComputedAsync(Future Function() fn, {S? initialValue, String? debugLabel, List<ReadonlySignal> dependencies = const [], bool lazy = true})`	Async Computed is syntax sugar around FutureSignal.
createFutureSignal	`method`	`dart FutureSignal createFutureSignal(Future Function() fn, {S? initialValue, String? debugLabel, List<ReadonlySignal> dependencies = const [], bool lazy = true})`	Create a signal from a future
createStreamSignal	`method`	`dart StreamSignal createStreamSignal(Stream Function() callback, {S? initialValue, String? debugLabel, List<ReadonlySignal> dependencies = const [], void Function()? onDone, bool? cancelOnError, bool lazy = true})`	Create a signals from a stream
createAsyncSignal	`method`	`dart AsyncSignal createAsyncSignal(AsyncState value, {String? debugLabel})`	Create a signal holding an async value
createSignal	`method`	`dart FlutterSignal createSignal(V val, {String? debugLabel})`	Create a `signal` and watch for changes
createListSignal	`method`	`dart ListSignal createListSignal(List list, {String? debugLabel})`	Create a ListSignal and watch for changes
createSetSignal	`method`	`dart SetSignal createSetSignal(Set set, {String? debugLabel})`	Create a SetSignal and watch for changes
createQueueSignal	`method`	`dart QueueSignal createQueueSignal(Queue queue, {String? debugLabel})`	Create a QueueSignal and watch for changes
createMapSignal	`method`	`dart MapSignal<K, V> createMapSignal(Map<K, V> value, {String? debugLabel})`	Create a MapSignal `<K, V>` and watch for changes
createComputed	`method`	`dart FlutterComputed createComputed(V Function() cb, {String? debugLabel})`	Create a `computed` and watch for changes
bindSignal	`method`	`dart S bindSignal(S val)`	Bind an existing `signal` and watch for changes
unbindSignal	`method`	`dart S unbindSignal(S val)`	Unbind an existing `signal` changes
watchSignal	`method`	`dart V watchSignal(S val)`	Watch signal value
unwatchSignal	`method`	`dart V unwatchSignal(S val)`	Unwatch an existing `signal` value changes
listenSignal	`method`	`dart void listenSignal(ReadonlySignal target, void Function() callback, {String? debugLabel})`	Watch signal value
unlistenSignal	`method`	`dart void unlistenSignal(ReadonlySignal target, void Function() callback)`	Stop listening to a signal value
createEffect	`method`	`dart EffectCleanup createEffect(dynamic Function() cb, {String? debugLabel, dynamic Function()? onDispose})`	Create a effect.
clearSignalsAndEffects	`method`	`dart void clearSignalsAndEffects()`	Reset all stored signals and effects
dispose	`method`	`dart void dispose()`

References#

The SignalsMixin type is referenced and used in the following pages:

SignalsMixin (signals_flutter/mixins)
SignalStatefulWidget (signals_flutter/extensions)
signals_flutter
SignalsAvoidDeprecatedSignalsMixin (signals_lint/flutter)
MigrateSignalsMixinToSignalStatefulWidget (signals_lint/flutter)
SignalsMixin (signals/mixins)
SignalStatefulWidget (signals/extensions)
signals