mosaic library

Classes

AsyncSignal<T>
A signal that handles asynchronous operations with built-in loading states.
AsyncStatus<T>
Represents the state of an asynchronous operation.
ConsoleDispatcher
DependencyInjector
A dependency injection container that manages object lifecycles and provides type-safe dependency resolution.
EventContext<T>
Contains information passed to a listener when an event is emitted.
EventListener<T>
Supports dynamic patterns using special characters:
Events
Global event manager with support for dynamic channels.
FileLoggerDispatcher
FileLoggerDispatcher is used to log in files The goal of this logger dispatcher is to write logs in different files splitted per tags. By default it writes all logs in one file and one file per tags Allowing to write a log in multiple files. For now it saves the file with the following format by defalt: tagyearmonth_day.log Such that there's one file (for the same tag) per day. But its format is defined by the fileNameRole that you can pass in the constructor.
Imc
ImcContext
InternalAutoQueue
A thread-safe auto-retry queue for asynchronous operations.
InternalQueueNode<T>
Represents a single operation in the queue with its completion mechanism.
InternalRoute<T>
Represents an entry in the module's internal navigation stack.
InternalRouter
ListSignal<T>
Logger
A production-ready logging system with advanced features.
LoggerDispatcher
LoggerDispatcher is the abstract class for log in different mode. It is used by the Logger class when it dispatch a log. When the log function of logger is called it execute secureCall that it cannot be overrided.
LoggerWrapper
ModularExtension
Extensions class
ModularState<T extends ModularStatefulWidget>
ModularStatefulWidget
Stateful Modular extension should have the
Module
Base class for application modules with comprehensive lifecycle management.
ModuleManager
Manages all modules in the application and provides centralized control over module lifecycle, error handling, and state management.
MosaicContainer
MosaicScope
MultipleWatch
Mutex<T>
Mutex is used to protect modification at the same time across multi threads The api is very simple:
RouteHistoryEntry<T>
RouteNode
RouteTransitionContext<T>
Segment
Base class for building event topic paths with chaining support.
Semaphore
A counting semaphore for controlling access to a resource pool.
Signal<T>
A reactive state container that notifies listeners when its value changes.
UIInjector
Watch<T>
Watches a Signal and rebuilds when its value changes.

Enums

LogLevel
Hierarchical log levels for filtering messages by importance.
LogType
The type of log message being recorded.
ModuleLifecycleState
Lifecycle states for module management.

Mixins

Admissible<T extends StatefulWidget>
Handles Event subscription automatically.
Id
Mixin that adds ID-based path building to segments.
Loggable
A mixin that provides convenient logging methods for classes.
MosaicServices
Param
Mixin that adds multi-parameter path building to segments.
StatefulSignal<T extends StatefulWidget>

Properties

mosaic → MosaicContainer
final

Typedefs

EventCallback<T> = void Function(EventContext<T>)
Type for a callback function that receives an event context.
ImcCallback = FutureOr Function(ImcContext)
InternalQueueAction<T> = Future<T> Function()
A function type that represents an asynchronous operation in the queue.
LoggerWrapperCallback = String Function(String, LogType, List<String>)
ModularExtensionBuilder = Widget Function(BuildContext)
Type for the builder function type for extensions
RouteNodeBuilder = Widget Function(BuildContext, RouteTransitionContext)
SignalCallback<T> = void Function(T)
SignalListener = Object
UIInjectorCallback = EventCallback<ModularExtension>
UIInjectorListener = EventListener<ModularExtension>