core library

Classes

ActionControl<T>
Provides specialized implementations of ObservableValue with distinct subscription behaviors.
BaseControl
A robust business logic model that ensures onInit is called only once.
BaseModel
A lightweight business logic model that prefers soft disposal by default.
BroadcastProvider
Provides static access to the default ControlBroadcast instance.
BroadcastSubscription<T>
Represents a subscription to a ControlBroadcast stream.
BroadcastSubscriptionArgs<T>
Arguments for creating a BroadcastSubscription.
Control
A static service locator for managing dependencies and initializing objects within an application.
ControlArgs
A flexible container for managing arguments passed between different parts of the application.
ControlBroadcast
Global stream to broadcast data and events. Stream is driven by keys and object types.
ControlFactory
The core implementation of the service locator and dependency injection container.
ControlModel
The foundational class for business logic models in the control framework.
ControlModule<T>
Defines a modular unit for organizing and registering dependencies within the control system.
ControlObservable<T>
The primary concrete implementation of an observable value.
ControlProvider
A basic, abstract implementation of ControlModule that provides itself as the module.
ControlSubscription<T>
Represents a subscription to an ObservableValue.
DelayBlock
A helper to ensure a block of asynchronous code takes a minimum amount of time to complete.
DisposableClient
The client-side part of a disposable resource management pattern.
DisposableToken
The token part of a disposable resource management pattern, used by the resource consumer.
FieldControl<T>
A Stream-based implementation of ObservableModel.
FieldSink<T>
A standard Sink for a FieldControl.
FieldSinkConverter<T>
An extended FieldSink that uses a converter. It converts the added data before passing it to the FieldControl.
FieldSubscription<T>
A ControlSubscription that also implements StreamSubscription.
FutureBlock
A utility class for creating a re-triggerable, cancellable delayed future.
Initializable
An interface for objects that can be initialized with arguments after construction.
LazyInitializer<T>
Lazily builds and caches a value. The value is created only once on the first access.
ListControl<T>
An extended version of FieldControl specialized for managing a List<T>.
LoadingControl
An extended FieldControl specialized for managing a LoadingStatus.
ObservableBase<T>
The fundamental interface for an observable object.
ObservableChannel
An observable that acts as a simple notification channel, without carrying a value.
ObservableGroup
A class that groups multiple observables into a single ObservableValue.
ObservableModel<T>
An abstract base class for creating a custom ObservableValue.
ObservableNotifier
An interface for objects that can be notified to propagate changes.
ObservableValue<T>
An observable that holds and notifies about changes to a single value.
Parse
A utility class with static methods for robust data parsing and type conversion.
ParseDecorator
A collection of decorators for string formatting with Parse.format.
ParseN
A utility class with static methods for parsing data types that can explicitly return null.
StackControl<T>
An observable stack that manages a list of values and notifies listeners about changes to the top of the stack.

Enums

LoadingStatus
Represents the status of an asynchronous operation.

Mixins

Disposable
A mixin that marks an object as having resources that need to be cleaned up.
DisposeHandler
A mixin that provides sophisticated control over an object's disposal logic.
DisposeObserver
A mixin for a ControlModel that allows it to manage the lifecycle of other Disposable objects.
EventComponent<T>
LateInit
A mixin that delays a piece of initialization logic until the main ControlFactory is fully initialized.
LazyControl
A mixin that automatically handles the removal of an object from the ControlFactory when it is disposed.
NotifierComponent
A mixin that adds ObservableChannel capabilities to a ControlModel.
ObservableComponent<T>
A mixin that adds ObservableValue capabilities to a ControlModel.
ReferenceCounter
A mixin that adds reference counting to a DisposeHandler.

Extensions

DisposableExt on Disposable
IterableExtension on Iterable
ListExt on List<E>
MapExtension on Map
ObservableBaseExt on ObservableBase
ObservableBoolExt on ObservableModel<bool>
An extension on ObservableModel<bool> providing convenience methods for working with boolean observables.
ObservableValuExt on ObservableValue

Functions

printAction(ValueGetter action) → void
printDebug(dynamic object) → void

Typedefs

DisposeMarker = dynamic Function()
Dump marker used to mark object for dispose.
EntryConverter<T> = T Function(dynamic key, dynamic value)
InitFactory<T> = T Function(dynamic args)
ParseDecoratorFormat = String Function(String input)
Predicate<T> = bool Function(T value)
ValueCallback<T> = void Function(T value)
ValueConverter<T> = T Function(dynamic value)

Exceptions / Errors

BroadcastSubscriptionException
Exception thrown when a BroadcastSubscription cannot be created.