zerobias/effector

Features

• Application State Management - Maintains reactive data stores that update automatically in response to events and asynchronous operations.
• Reactive State Management - Builds predictable application state by connecting events, stores, and side effects into declarative reactive data flows.
• Data Flow Definitions - Provides declarative specifications for routing data between sources and processing components in a stream pipeline.
• Data Flow Orchestrators - Connects events, stores, and effects using declarative operators to transform, filter, and route data updates through application logic.
• Event-Based Mutation Interfaces - Define explicit event-based interfaces for modifying data stores, centralizing logic for state transitions and preventing uncontrolled mutations.
• Execution Scopes - Automatically wraps state hooks to ensure events are executed within the correct context and prevent errors in non-scoped environments.
• Persistent Application State - Maintains persistent application data objects that update automatically based on defined logic.
• State Management Scopes - Enables isolated execution environments essential for server-side rendering and preventing cross-request data leakage.
• Application Context Isolators - Enables predictable testing and server-side rendering by managing state and logic lifecycles in independent environments.
• Application Event Systems - Records user interactions and system occurrences as discrete signals to describe application events.
• Component State Bindings - Binds application state and event triggers to UI components to ensure the view layer reflects data changes automatically.
• Reactive Data Stores - Implements reactive containers that track state transitions and provide hooks for components to subscribe to data updates.
• State Logic Containers - Organizes business logic into independent stores, events, and effects that decouple data from user interface components.
• Operation State Tracking - Tracks the progress and resolution of pending asynchronous operations via polling, blocking, or callbacks.
• Declarative Data Pipelines - Transfer data updates from a source unit to a target unit to establish reactive data flow between different parts of an application.
• Declarative Dataflow Graphs - Models application logic as a directed acyclic graph where state updates and side effects propagate automatically through declarative pipelines.
• Derived State Stores - Aggregates or transforms data from other primary stores into new reactive containers without altering the original state.
• Declarative Stream Logic - Links independent units of logic into automated data pipelines without requiring manual state management or imperative updates.
• Factory Patterns - Abstracts stateful logic into factory functions to ensure consistent behavior and prevent naming conflicts.
• Effect-Driven Store Initializers - Create a writable store that updates its value automatically whenever an asynchronous effect completes successfully, using the returned result as the new state.
• State Transition Event Triggers - Defines discrete events that act as signals to modify application state, decoupling the logic of state changes from the components that initiate them.
• Scoped Operation Execution - Trigger events and effects within a specific isolated context while tracking the completion of all resulting asynchronous operations.
• Framework Agnostic Interfaces - Decouples business logic from user interface layers by maintaining state in independent containers that communicate via standard interfaces.
• Frontend Data Flow Orchestrators - Coordinates complex asynchronous operations and state transitions across modular application architectures and multiple UI frameworks.
• Applicative Effect Handling - Connects events, stores, and effects into atomic data flows that trigger updates based on state changes.
• Isolated Scope Implementations - Encapsulates state and logic within independent containers to enable server-side rendering and prevent cross-request data leakage.
• Event-Driven Store Initializers - Create a writable store that updates its value automatically whenever a specific event is triggered or an asynchronous effect completes successfully.
• Reactive Event Orchestrators - Link events to state containers to define how data transforms and updates in response to user actions or system triggers.
• State Change Triggers - Dispatches events to modify store values, providing a predictable and modular way to handle user interactions and data updates.
• Side Effect Execution Encapsulation - Encapsulates asynchronous operations and external interactions into discrete, pure-value units that trigger state changes upon completion.
• Reactive State Composables - Links independent units of logic into declarative data flows for automated state management.
• Logic Decoupling - Decouples business logic from UI frameworks to enable code reuse across environments.
• View-Independent Logic Trees - Extracts business logic into framework-independent models to simplify debugging and reuse.
• Scoped State Containers - Isolates state within specific execution contexts to prevent data leakage and support server-side rendering.
• State-Synchronized Bindings - Automatically synchronizes UI elements with application state changes.
• Hydration-Stable Identifiers - Assigns consistent, unique identifiers to state units based on source code location to enable reliable data synchronization.
• Reactive State Management Libraries - Provides a framework-agnostic library for managing application state and side effects through declarative data flows and reactive units.
• Reactive Store Bindings - Provides optimized hooks to connect reactive state stores directly to user interface components for automatic view synchronization.
• Reactive View Updates - Executes logic or updates state in response to events, asynchronous effects, or changes in stored data values.
• Reactive State Containers - Holds application data in observable containers that strictly control state propagation.
• Reactive Frameworks - Integrates state containers with component-based frameworks for reactive data flow.
• State Hydration - Populates stores with pre-defined values within a specific domain to synchronize client-side state after server-side rendering.
• Reactive State Declarations - Retrieves current data from reactive stores using framework-specific hooks or declarative operators.
• Reactive Unit Definitions - Construct reactive units and their relationships at the module level to ensure persistent data structures and prevent memory leaks during application execution.
• Event-Driven State Handlers - Uses discrete events as the primary mechanism to trigger state transitions and initiate asynchronous side effects.
• Operation Cancellation Handlers - Terminates active background tasks or network requests when they are no longer relevant.
• Pending Operation Awaiters - Waits for all triggered effects and pending operations within a specific execution scope to finish before proceeding with further logic.
• Application Logic Architectures - Organizes application logic into namespaces and factories to ensure consistent behavior and prevent naming conflicts.
• Data Fetching and API - Handles remote API interactions through declarative queries and mutations with built-in caching and state management.
• Execution Lifecycle Monitors - Exposes events and stores that signal success, failure, completion, and pending status to monitor the progress of asynchronous operations.
• Solid Integrations - Binds state containers to reactive frameworks to synchronize data updates with component rendering cycles.
• Application State Synchronizations - Transfers application state from the server to the client during page rendering to ensure consistent data availability and prevent hydration mismatches.
• Application State Synchronization - Serializes application state from the server and hydrates it on the client to ensure consistent data availability during initial page loads.
• Unique Identifier Generators - Generates stable, unique identifiers for state units automatically during the build process.
• External Data Routing - Converts observable data sources into internal event streams to integrate external reactive data into the application flow.
• Domain Unit Groupings - Enables bulk management and centralized monitoring of state units across specific application modules.
• Atomic State Transitions - Calculates new state values based on previous data and incoming payloads while preventing unnecessary updates when values remain unchanged.
• Reactive Stream Processing - Applies utility functions to manage timing, conditional logic, and state transitions for complex event-driven reactive streams.
• Nested Model Accessors - Navigates into complex or nested data structures to retrieve specific state or interaction methods.
• State Slice Subscriptions - Tracks specific portions of a state container to trigger updates only when selected data changes.
• Reducer-Based Mutators - Creates event-bound mutators that update store state using provided reducer functions.
• Manual Computation Triggers - Executes logic within events, effects, or stores by manually invoking their internal computation processes.
• Runtime Compatibility Layers - Enables execution in various JavaScript runtimes by providing modular imports for different platform requirements.
• Reactive Logic Utilities - Provides utility functions for time-based operations, conditional state transitions, and logical predicates to simplify reactive workflows.
• State Serialization Exporters - Extract the current values of all stores within a specific execution scope into a serializable format for server-side rendering or state persistence.
• Event Filtering Logic - Applies conditional logic to incoming events to ensure functions only execute when specific data criteria are met.
• Execution Tracing - Records the sequence of preceding computations that triggered a specific event to assist in debugging complex state transitions.
• Hot Module Replacement - Cleans up subscriptions and side effects during development updates to prevent duplicate executions and memory leaks.
• Contextual Unit Bindings - Links application units to isolated instances to ensure they operate within the correct state container.
• Reactive State Debugging Tools - Monitors state changes and event triggers using specialized inspection tools or built-in observation methods to trace data updates.
• Scope-Bound Units - Connects logic units to specific application instances to ensure isolated state context.
• Input Transformers - Creates derived events that modify or filter data before or during the execution of a side effect to control input flow.
• Event Sequence Tracing - Records the sequence of events and operations that lead to a specific state change to assist in debugging complex logic chains.
• Reactive Unit Transformers - Integrates with build tools to automatically transform code and optimize the registration of reactive units.
• Module Lifecycle Events - Executes application logic by invoking events within a controlled scope to ensure dependent computations complete.
• Execution Status Monitoring - Monitors the progress of active operations through derived stores that indicate whether a task is currently running or how many instances are executing concurrently.
• Websocket Connection Managers - Maintains persistent bidirectional WebSocket connections by binding socket events to state updates and managing connection lifecycles.
• Conditional Routing - Directs incoming data to specific event handlers based on matching logic, pattern evaluation, or external state values.
• Asynchronous Flow Coordination - Coordinates sequences of dependent network requests and asynchronous operations.
• Reactive Type Enforcers - Enforces type safety across events, stores, and effects to improve developer experience and data consistency.
• State Type Definitions - Ensures type safety across the application by assigning specific data structures to stores, events, and effects.
• State Store Namespacing - Groups related events, stores, and effects into domains to manage application architecture and monitor state unit creation.
• Conditional Flow Execution - Executes specific logic or events only when a defined predicate function returns true or a source store holds a specific value.
• Factory Unit Scopers - Prevents naming collisions and maintains clear state boundaries in modular applications.
• Lifecycle Side Effects - Exposes reactive properties like pending status and completion events for asynchronous tasks.
• Component Data Bindings - Provides hooks to iterate over collections and inject entity-specific state and update methods into user interface components.
• Reactive State Triggers - Executes registered callback functions whenever a specific event is invoked, allowing for decoupled communication and side-effect management.
• Task Sequences - Chains asynchronous operations to ensure subsequent requests trigger only after preceding dependencies complete.
• Scope-Based Synchronization - Executes units within a specific scope and waits for all resulting side effects to complete before proceeding.
• Asynchronous Error Handling - Captures exceptions thrown during execution and routes them to dedicated failure events for centralized reporting.
• Reactive Event Dispatchers - Composes event-driven workflows that trigger state updates, transformations, and side effects based on application logic.
• Asynchronous Operation Execution - Encapsulates side effects and asynchronous logic into dedicated containers that track execution status and provide lifecycle events.
• Atomic State Batching - Organizes application data into small, independent stores to optimize reactive dependency updates.
• UI Component Lifecycle Bindings - Synchronizes the lifecycle of a user interface component with a state container, triggering updates or side effects when the component mounts, unmounts, or receives new properties.
• Chain of Responsibility Implementations - Connects the output of one operation to the input of another to automate sequences of data processing and state updates.
• Component State Synchronization - Tracks component mounting and unmounting to trigger data updates or conditional rendering logic based on the presence of specific properties.
• Atomic State Primitives - Organizes application data into small, indivisible units to optimize reactive dependency calculations.
• Asynchronous Task Execution - Triggers side effects like network requests and handles their completion or failure states to integrate external data.
• Effect Variants - Generate specialized copies of existing asynchronous operations to isolate execution logic and event subscriptions within specific application modules or components.
• Grid Data Flow Routing - Moves values and triggers directionally using movement operators and gates to control data propagation through a patch grid.
• Effect State Management - Binds state values directly to side-effect functions to simplify asynchronous logic execution.
• Effectful State Updates - Triggers state updates automatically upon the successful completion of an asynchronous operation by binding completion events to target stores.
• Event Aggregators - Creates a single event that triggers whenever any of the provided events, effects, or stores are invoked.
• Event Flow Control - Triggers specific actions or effects based on the occurrence of other events to automate logic sequences and state transitions.
• Event Stream Merging - Combines updates from multiple event sources into a single unified stream.
• Exception Logging - Captures and reports errors occurring within pure functions to prevent application crashes while maintaining a record of failed operations.
• Asynchronous Effect Cancellations - Terminates active asynchronous operations immediately to prevent unnecessary processing or state updates.
• Factory Scoping - Wraps unit creation in factories to automatically inject unique identifiers into nested state objects for modular architecture.
• Custom Effect Handlers - Replaces real network requests or side effects with custom handlers during tests to verify logic without triggering actual external dependencies.
• Imperative-to-Declarative Bridges - Implements complex conditional workflows using imperative patterns that integrate seamlessly with declarative state management.
• Stateful Component Wrappers - Connects reactive state stores to component lifecycles to ensure automatic UI updates.
• Manual Event Signaling - Triggers reactive data flows by signaling that specific actions or changes have occurred within the application.
• Orchestration Logic - Provides tools for orchestrating asynchronous operations and managing complex event chains as discrete, trackable units.
• Build Metadata Injection - Automatically assigns stable identifiers to reactive units during compilation to improve debugging and ensure consistent state tracking.
• Pure State Management - Executes pure functions before side effects to ensure predictable state updates during complex data processing.
• Reactive Unit Protocols - Expose internal state or events to UI framework bindings by implementing a protocol that maps custom entities to standard reactive units.
• Request-Isolated Translation Instances - Ensures data privacy by creating isolated execution contexts for concurrent server requests.
• Logic Reusability Patterns - Encapsulates recurring patterns into factory functions to standardize code structure.
• State Update Filters - Prevents a store from updating its value by evaluating incoming data against a custom predicate function.
• Asynchronous Side Effect Dispatchers - Executes asynchronous operations through dedicated units that integrate seamlessly with application state and event logic.
• Side Effect Management - Centralizes and isolates operations that modify global state or interact with external systems.
• Single State Trees - Derives new state from existing stores to manage complex data relationships.
• Modular Application Architectures - Enables organizing logic into modular namespaces and factories to ensure consistent behavior and prevent naming conflicts.
• Logic Namespaces - Organizes related events, stores, and effects into namespaces to enable bulk processing and consistent configuration.
• State Change Observers - Executes side effects in response to data changes or event triggers without modifying the underlying state.
• Attribute Change Observers - Subscribes to events and state changes during test execution to verify that specific actions were triggered the correct number of times.
• State Logic Orchestrators - Triggers actions and updates based on events or state changes using declarative sampling and routing rules.
• State Unit Identifiers - Facilitates dynamic handling of application data structures by identifying the type of state management unit.
• State Unit Lifecycle Management - Remove stores, events, effects, and domains from the application state, optionally clearing all associated computed values and dependencies to free up resources.
• Unit Initialization Observers - Execute callback functions automatically whenever a new event, store, effect, or nested domain is initialized within a specific domain container.
• Asynchronous State Transition Frameworks - Tracks the completion of events and effects within a controlled scope to ensure expected state transitions occur after asynchronous operations.
• Coordinated Mutation Handlers - Generates coordinated event handlers from configuration objects to perform atomic state updates.
• Static State Definitions - Provides a pattern for defining reactive state units at the module level to ensure consistent graph initialization.
• Subscription Lifecycle Management - Provides mechanisms to attach and detach listeners to data streams for reactive update control.
• Effect Dependency Composition - Enables the creation of new effects that automatically consume current state values as arguments for reusable logic.
• Lifecycle Unit Associations - Ensures all associated resources are automatically disposed of when the parent unit is cleared.
• Unit Lifecycle Trackers - Observes the creation and lifecycle of state units, factories, and regions to map the structural composition of the application.
• Workflow Triggers - Defines entry points for data streams that signal when specific actions occur to initiate subsequent reactive logic.
• Execution Context Tracking - Subscribes to state changes and event triggers within isolated contexts to verify that specific actions occur as expected during test runs.
• Internal Telemetry Monitors - Tracks and observes internal data changes and event flows across the application to facilitate debugging and performance monitoring.
• Computation Monitors - Tracks internal data transformations and event flows to provide visibility into how state changes propagate through the application.
• Reactive State Monitoring - Tracks and reports changes to reactive atoms to trigger immediate functions or logging during development.
• State Transition Logging - Tracks and records updates to state units, events, and side effects to facilitate debugging and state inspection.
• Side Effect Isolation - Creates isolated environments for application logic to prevent side-effect leakage.
• Asynchronous Data Fetching - Manages asynchronous data retrieval and synchronization with external services while tracking loading states within the application flow.
• Cross-Framework UI Libraries - Integrates with various frontend frameworks to bridge the gap between business logic and view layers in a framework-agnostic manner.
• Data-to-Component Mappings - Extracts specific slices of data from global stores to optimize component rendering performance.
• Event-to-Command Bindings - Links user interactions directly to state updates so that triggering an action automatically refreshes the interface.
• Scope-Bound Event Bindings - Connects asynchronous callbacks from external libraries to a specific application state instance.
• Logic-to-UI Bindings - Synchronizes component lifecycle events with application state to enable reactive data flow.
• Dynamic Component Rendering - Renders arbitrary components into designated placeholders within a layout to avoid passing deeply nested props.
• Form State Management - Coordinates form input values and validation status within reactive state containers.
• Component Lifecycle Management - Tracks component mounting and unmounting to trigger side effects or state updates.
• Effect Bindings - Injects current store values into effects automatically to simplify asynchronous data access.
• UI State Synchronization - Connects external interface elements to application state to ensure consistent data representation.
• External Stream Subscriptions - Creates events that trigger whenever external observable streams emit values, allowing integration with reactive libraries.
• Application Lifecycle Controls - Controls application lifecycle events to ensure predictable state transitions during initialization and shutdown.
• Application Lifecycle Managers - Manages application startup and state transitions through explicit event-driven lifecycle control.
• Lifecycle State Tracking - Monitors the lifecycle of asynchronous operations to trigger interface updates such as displaying progress indicators during data resolution.
• Change Observers - Provides mechanisms for monitoring reactive state and triggering side-effects automatically when signal values change.
• Asynchronous Data Handling - Encapsulates asynchronous logic into dedicated containers that track execution status and provide hooks for success, failure, and completion.
• Data Fetching Orchestrators - Orchestrates remote data fetching, caching, and mutations through standardized, framework-independent interfaces.
• Derived State - Combines multiple data sources into reactive units that update automatically when dependencies change.
• Execution Error Captures - Logs exceptions occurring during computation branches and halts execution to prevent corrupted state while providing diagnostic information.
• State Update Error Captures - Captures detailed stack information during the creation of stores and events to help diagnose complex serialization or configuration issues.
• External Side Effect Dispatching - Provides mechanisms to replace real external service calls with custom handlers during testing to validate logic without triggering actual network requests.
• Form Field State Management - Integrates reactive state units with form fields and validation schemas to manage complex form state and submission logic.
• Component-Based State Management - Manages complex application state by organizing business logic into isolated, lifecycle-scoped units that attach and detach in a tree hierarchy.
• Reactive Property Mappings - Merges store values into component properties to facilitate reactive data flow.
• UI State Synchronization - Connects interactive input components to application stores to ensure the interface reflects and updates the underlying data model.
• State Overrides - Injects custom starting values into isolated application instances to verify how logic behaves under specific data conditions.
• Unit Type Validators - Determines whether a provided value is a valid state management unit such as a store, event, effect, domain, or scope.
• Frontend Framework Integrations - Connects with various frontend libraries to provide consistent state management regardless of the underlying platform.
• Component Update Optimizations - Limits component re-renders by selecting specific slices of state so that updates only trigger when the relevant data changes.
• React State Bindings - Connects state containers to components using specialized hooks to trigger re-renders based on data changes.
• Reactive Debugging Utilities - Inspects state changes and event flows using specialized monitoring tools to trace data movement throughout the application.
• Request Contexts - Provides request-scoped data containers to prevent cross-request data leakage in server-side rendering environments.
• Router State Integration - Maintains reactive stores containing current application router instances to allow consistent access to navigation state.
• Client-Side State Synchronizers - Injects a shared data scope into the application to ensure state consistency between server-side rendering and client-side hydration.
• Controlled Input Synchronization - Synchronizes form input fields with reactive state to maintain a single source of truth.
• Synchronous State Updates - Triggers updates in a target unit using data from a source unit whenever a specific clock event occurs to ensure consistent state transitions.
• Clock-Based Synchronizers - Triggers conditional data routing only after specific clock events occur to ensure state changes happen in a predictable sequence.
• Computation Schedulers - Schedules pure computations to execute before side effects to ensure application state remains consistent during complex data processing.
• State Management - Fast, reactive state manager with framework-agnostic bindings.

Star history