LogoSignals.dart
Copy Markdown
rodydavis/signals.dart ★9999⑂99

StreamSignalMixin

A mixin that implements the standard **Stream** interface for a ReadonlySignal.

A mixin that implements the standard Stream interface for a ReadonlySignal.

This mixin allows you to treat a read-only or writable signal as a standard asynchronous Stream, where updates to the signal's value are pushed as stream events. This provides out-of-the-box compatibility with the entire asynchronous Dart SDK, such as stream transformers, await for loops, and Flutter's StreamBuilder.

Example Usage#

import 'package:signals/signals.dart';

class MyStreamSignal extends Signal<int> with StreamSignalMixin<int> {
  MyStreamSignal(super.internalValue);
}

void main() async {
  final counter = MyStreamSignal(0);

  // Standard stream subscription
  final subscription = counter.listen((val) {
    print('Stream emitted: $val');
  }); // Prints: "Stream emitted: 0" (if listened immediately)

  counter.value = 1; // Prints: "Stream emitted: 1"
  counter.value = 2; // Prints: "Stream emitted: 2"

  await subscription.cancel();
}

Flutter StreamBuilder Example# 

import 'package:flutter/material.dart';
import 'package:signals/signals_flutter.dart';

class CounterSignal extends Signal<int> with StreamSignalMixin<int> {
  CounterSignal(int value) : super(value);
}

final counter = CounterSignal(0);

Widget build(BuildContext context) {
  return StreamBuilder<int>(
    stream: counter,
    builder: (context, snapshot) {
      return Text('Count: ${snapshot.data}');
    },
  );
}
Since [StreamSignalMixin](/packages/signals/mixins/stream) creates an internal broadcast **StreamController**, multiple listeners can subscribe simultaneously. All subscriptions are closed and resources are released automatically when the signal is disposed.

Methods#

View Methods
Future<bool> any(bool Function(T element) test)
Stream<T> asBroadcastStream({void Function(StreamSubscription<T> subscription)? onListen, void Function(StreamSubscription<T> subscription)? onCancel})
Stream<E> asyncExpand(Stream<E>? Function(T event) convert)
Stream<E> asyncMap(FutureOr<E> Function(T event) convert)
Stream<R> cast()
Future<bool> contains(Object? needle)
Stream<T> distinct([bool Function(T previous, T next)? equals])
Future<E> drain([E? futureValue])
Future<T> elementAt(int index)
Future<bool> every(bool Function(T element) test)
Stream<S> expand(Iterable<S> Function(T element) convert)
Future<T> first
Future<T> firstWhere(bool Function(T element) test, {T Function()? orElse})
Future<S> fold(S initialValue, S Function(S previous, T element) combine)
Future<void> forEach(void Function(T element) action)
Stream<T> handleError(Function onError, {bool Function(dynamic error)? test})
bool isBroadcast
Future<bool> isEmpty
Future<String> join([String separator = ""])
Future<T> last
Future<T> lastWhere(bool Function(T element) test, {T Function()? orElse})
Future<int> length
StreamSubscription<T> listen(void Function(T event)? onData, {Function? onError, void Function()? onDone, bool? cancelOnError})
Stream<S> map(S Function(T event) convert)
Future pipe(StreamConsumer<T> streamConsumer)
Future<T> reduce(T Function(T previous, T element) combine)
Future<T> single
Future<T> singleWhere(bool Function(T element) test, {T Function()? orElse})
Stream<T> skip(int count)
Stream<T> skipWhile(bool Function(T element) test)
Stream<T> take(int count)
Stream<T> takeWhile(bool Function(T element) test)
Stream<T> timeout(Duration timeLimit, {void Function(EventSink<T> sink)? onTimeout})
Future<List<T>> toList()
Future<Set<T>> toSet()
Stream<S> transform(StreamTransformer<T, S> streamTransformer)
Stream<T> where(bool Function(T event) test)