mobxjs/mobx-state-tree

Features

• State Model Definitions - Defines the core typed state models with properties, actions, and lifecycle hooks that structure the entire library.
• Tree-Based State Containers - Provides a structured, tree-based reactive state container with typed models, actions, and snapshot support.
• Tree-Wide - Marks properties as immutable identifiers unique across the entire tree for reconciliation and reference resolution.
• Data Modeling Types - Defines application state as typed models with properties and actions, enforcing runtime type safety.
• Mutation Protection - Locks models so only actions can modify state, preventing accidental direct mutations.
• State Tree Model Linkers - Links model instances via lightweight identifier references for efficient cross-entity relationships.
• State Snapshots - Updates a model tree and all its descendants to match a previously captured plain-object snapshot.
• Reference-Based Denormalization - Keeps data normalized internally while allowing interaction through denormalized references.
• Reference-Based Data Normalization - Links related models via lightweight identifier references for normalized data management.
• JSON Patching - Applies JSON Patch operations to model instances to modify their state.
• Patch Stream Change Tracking - Emits JSON Patch streams for every mutation, enabling fine-grained observation and replay of state changes.
• State Snapshots - Restores a model instance's state from a previously captured plain-object snapshot.
• Snapshot-Based State Restoration - Recreates a model instance or applies a snapshot to restore a previous state.
• Application State Persistences - Provides snapshot and patch mechanisms for saving and restoring application state to storage backends.
• Model Action Definitions - Defines custom behaviors and operational logic for data models through collocated action functions.
• Collocated Action and View Definitions - Defines models with collocated actions, computed views, and lifecycle hooks for predictable state mutations.
• Model Instantiation - Instantiates observable state tree models from plain data, enabling reactive state management.
• State Tree Model Instance Linkers - Links model instances by identifier references for efficient relationships without embedding full objects.
• State Tree Reference Creators - Creates identifier-based references between models for normalized data relationships within the state tree.
• Class Instance to Plain Object Converters - Converts a model tree into an immutable plain JavaScript object for transport or serialization.
• Identifier-Based Model Linkers - Stores identifiers to link related models, enabling efficient relationships without data duplication.
• Identifier-Based Model References - Links related data entities across a state tree using lightweight identifier references for normalized data management.
• Identifier-Based Model References - Links related models via lightweight identifier references for normalized data management and cross-tree lookups.
• Undo-Redo State History - Reverses applied patches to revert state changes, supporting undo/redo patterns without manual state tracking.
• Time-Travel Debuggers - Records state snapshots and replays them to move forward or backward through state history.
• Asynchronous Generator Runners - Provides utilities that execute generator functions by treating yielded promises as sequential steps.
• Reactive State Typing - Manages application state using typed models that enforce structure and provide runtime validation without boilerplate code.
• Generator-Based Async Flows - Ships generator-based async flows that yield promises for clean asynchronous state mutations.
• Runtime Type Validation - Checks property assignments against defined runtime types, preventing accidental data type mismatches.
• State Tree Node Resolvers by Identifier - Resolves state tree nodes by their declared identifier, enabling cross-tree lookups and references.
• Type Checking - Validates values against runtime type definitions to ensure data conforms to model schemas.
• Typed Property Declarations - Declares typed properties with defaults for state models, a fundamental part of model definition.
• Action Interceptors - Provides action interceptors that capture and process action objects before they reach the state reducer.
• Asynchronous Action Handling - Implements patterns for wrapping asynchronous operations to track pending states and manage errors during state transitions.
• Generator-Based Async Actions - Defines asynchronous actions using generator functions that yield promises for clean async state mutations.
• Action Dispatch Middleware - Provides interceptors that wrap the action dispatch process to handle side effects and logging.
• Action Lifecycle Middleware - Hooks into action execution to log, modify, or cancel state changes for auditing, validation, or cross-cutting concerns.
• Action Interception Patterns - Implements event-driven patterns that intercept and block pending actions before they execute.
• Subtree Action Interceptions - Provides middleware hooks to intercept actions on any subtree of the state tree.
• State Snapshots - Produces plain JSON snapshots of the entire state tree for time-travel debugging and state persistence.
• Patch Stream Change Trackings - Generates immutable snapshots and JSON Patch streams for time-travel debugging, undo/redo, and state persistence.
• Type-Safe Model Definitions - Defines state shape using runtime type annotations that also generate TypeScript types for compile-time safety.
• Reactive Computed Values - Declares read-only computed properties that automatically recompute when their observed dependencies change.
• State Tree Cross-Tree Reference Resolvers - Looks up referenced nodes by identifier type across the entire state tree to link related data.
• Action-Driven State Mutations - Implements action-driven state mutations where state changes are triggered by processing discrete event objects.
• Direct Mutation Actions - Replaces reducer dispatch with callable functions that directly mutate state, simplifying state change logic.
• State Modeling - Defines reactive, tree-like state models with mutable but protected data for safe state management.
• Model Type Compositions - Provides model composition as a core mechanism for building complex state models from simpler ones.
• Running Action Contexts - Provides a built-in mechanism to retrieve the context of the currently executing action for introspection.
• State Tree Node Resolvers by Path - Resolves state tree nodes by their JSON path, enabling programmatic navigation and access.
• Time-Travel Debuggings - Ships snapshot and patch streams enabling time-travel debugging and state history inspection.
• MobX Implementations - Leverages MobX's observable system to automatically track dependencies and re-render only when observed data changes.
• Custom Data Types - Creates custom immutable types with serializable representations for values like dates or decimals.
• Enumeration Types - Creates string-based enumeration types from a list of allowed values.
• State Tree Node Detachments - Ships a detach function that removes a node from its parent and turns it into an independent tree.
• JSON Patch Recorders - Captures all JSON Patch operations applied to a subtree for later replay or inspection.
• JSON Patch Replayers - Replays recorded JSON Patch operations onto a model to restore or modify its state.
• Deep Class Instance Cloning - Creates deep independent copies of state tree nodes as new standalone trees.
• Lazy Type Definitions - Defines lazily evaluated types for recursive or circular type definitions.
• Static Type Inference - Infers TypeScript types from runtime type definitions to gain compile-time type safety automatically.
• Literal Type Definitions - Defines types that accept only a single specific value.
• Action Replay Mechanisms - Provides systems for re-dispatching historical sequences of actions to recreate specific state transitions.
• Environment Dependency Injections - Provides environment dependency injection into the state tree, accessible to all models via getEnv.
• Multiple Middleware Handlers - Supports attaching multiple middleware handlers to a single node for action interception.
• Immutable Data Storage - Stores serializable JSON values as immutable data that snapshots as-is and ignores internal changes.
• State Tree Node Destructions - Provides a destroy function that removes nodes from the state tree and marks them as unusable.
• Observable State Management - Watches state tree changes and automatically re-renders components to keep the user interface in sync.
• TypeScript Type Synthesis - Derives TypeScript types from model definitions for auto-completion and static analysis without manual annotations.
• Action Description Recorders - Captures all actions invoked on a subtree as serializable action call descriptions for replay.
• Snapshot Serialization Customizations - Applies custom transformations when generating or applying snapshots using a dedicated processor type.
• Selective Re-rendering - Splits observer components so each re-renders only when its specific observed data changes.
• Parameterized State Views - Defines reusable, read-only parameterized views that filter or transform state data on demand.
• Model Action Call Listeners - Provides a notification system for model action invocations with serializable argument payloads.
• Subtree Action Listeners - Ships a listener subscription mechanism that fires on any action invocation within a subtree.
• JSON Patch Listeners - Provides a listener that fires on every JSON Patch applied to a subtree for change tracking.
• Change Observers - Triggers re-renders or snapshot listeners automatically when observed model properties are modified.
• Runtime - Supports defining union types that are validated at runtime within the state tree.
• Side Effect Management Libraries - Manages complex asynchronous side effects directly within the state container without separate effect hooks.

Star history