SignalsMixin<T extends StatefulWidget> mixin

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

:::caution 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'),
        ),
      ],
    );
  }
}

Superclass constraints

State<T>

@Deprecated('Use SignalWidget, SignalStatefulWidget, or Watch/SignalBuilder instead for superior, self-contained reactivity without stateful mixin overhead.')

Properties

context → BuildContext: The location in the tree where this widget builds.
no setterinherited
hashCode → int: The hash code for this object.
no setterinherited
mounted → bool: Whether this State object is currently in a tree.
no setterinherited
runtimeType → Type: A representation of the runtime type of the object.
no setterinherited
widget → T: The current configuration.
no setterinherited

Methods

activate() → void: Called when this object is reinserted into the tree after having been removed via deactivate.
inherited
bindSignal<V, S extends ReadonlySignal<V>>(S val) → S: Bind an existing signal<T> and watch for changes
build(BuildContext context) → Widget: Describes the part of the user interface represented by this widget.
inherited
clearSignalsAndEffects() → void: Reset all stored signals and effects
createAsyncSignal<S>(AsyncState<S> value, {String? debugLabel}) → AsyncSignal<S>: Create a signal holding an async value
createComputed<V>(V cb(), {String? debugLabel}) → FlutterComputed<V>: Create a computed<T> and watch for changes
createComputedAsync<S>(Future<S> fn(), {S? initialValue, String? debugLabel, List<ReadonlySignal> dependencies = const [], bool lazy = true}) → FutureSignal<S>: Async Computed is syntax sugar around FutureSignal.
createComputedFrom<S, A>(List<ReadonlySignal<A>> signals, Future<S> fn(List<A> args), {S? initialValue, String? debugLabel, bool lazy = true}) → FutureSignal<S>: Async Computed is syntax sugar around FutureSignal.
createEffect(dynamic cb(), {String? debugLabel, dynamic onDispose()?}) → EffectCleanup: Create a effect.
createFutureSignal<S>(Future<S> fn(), {S? initialValue, String? debugLabel, List<ReadonlySignal> dependencies = const [], bool lazy = true}) → FutureSignal<S>: Create a signal from a future
createListSignal<V>(List<V> list, {String? debugLabel}) → ListSignal<V>: Create a ListSignal <T> and watch for changes
createMapSignal<K, V>(Map<K, V> value, {String? debugLabel}) → MapSignal<K, V>: Create a MapSignal <K, V> and watch for changes
createQueueSignal<V>(Queue<V> queue, {String? debugLabel}) → QueueSignal<V>: Create a QueueSignal <T> and watch for changes
createSetSignal<V>(Set<V> set, {String? debugLabel}) → SetSignal<V>: Create a SetSignal <T> and watch for changes
createSignal<V>(V val, {String? debugLabel}) → FlutterSignal<V>: Create a signal<T> and watch for changes
createStreamSignal<S>(Stream<S> callback(), {S? initialValue, String? debugLabel, List<ReadonlySignal> dependencies = const [], void onDone()?, bool? cancelOnError, bool lazy = true}) → StreamSignal<S>: Create a signals from a stream
deactivate() → void: Called when this object is removed from the tree.
inherited
debugFillProperties(DiagnosticPropertiesBuilder properties) → void: Add additional properties associated with the node.
inherited
didChangeDependencies() → void: Called when a dependency of this State object changes.
inherited
didUpdateWidget(covariant T oldWidget) → void: Called whenever the widget configuration changes.
inherited
dispose() → void: Called when this object is removed from the tree permanently.
override
disposeSignal(int id) → void: Dispose and remove signal
initState() → void: Called when this object is inserted into the tree.
inherited
listenSignal(ReadonlySignal target, void callback(), {String? debugLabel}) → void: Watch signal value
noSuchMethod(Invocation invocation) → dynamic: Invoked when a nonexistent method or property is accessed.
inherited
reassemble() → void: Called whenever the application is reassembled during debugging, for example during hot reload.
inherited
setState(VoidCallback fn) → void: Notify the framework that the internal state of this object has changed.
inherited
toDiagnosticsNode({String? name, DiagnosticsTreeStyle? style}) → DiagnosticsNode: Returns a debug representation of the object that is used by debugging tools and by DiagnosticsNode.toStringDeep.
inherited
toString({DiagnosticLevel minLevel = DiagnosticLevel.info}) → String: A string representation of this object.
inherited
toStringShort() → String: A brief description of this object, usually just the runtimeType and the hashCode.
inherited
unbindSignal<V, S extends ReadonlySignal<V>>(S val) → S: Unbind an existing signal<T> changes
unlistenSignal(ReadonlySignal target, void callback()) → void: Stop listening to a signal value
unwatchSignal<V, S extends ReadonlySignal<V>>(S val) → V: Unwatch an existing signal<T> value changes
watchSignal<V, S extends ReadonlySignal<V>>(S val) → V: Watch signal value

Operators

operator ==(Object other) → bool: The equality operator.
inherited