tc39/proposal-signals
Proposal Signals
This project is an ECMAScript proposal to introduce a native reactive state primitive to the JavaScript language. It defines a standard for fine-grained reactivity, providing a mechanism to track value dependencies and automatically propagate updates through a dependency graph.
The specification focuses on managing computed values and side effects based on granular changes to state. It enables the synchronization of state updates across a dependency graph and the tracking of relationships between values and their observers without manual subscriptions.
The proposal covers efficient value computation using lazy evaluation and memoization, as well as the ability to define custom equality logic to determine when state changes should trigger updates. It also includes capabilities for observing state changes and accessing values without registering dependencies.
Features
- ECMAScript Proposals - Implements a formal technical specification to introduce native reactive state primitives to the JavaScript language standard.
- Reactive State Primitives - Introduces a native reactive state primitive to the JavaScript language standard.
- Reactive Computed Values - Implements derived values that use lazy evaluation and caching within a reactivity system.
- Change Detection - Monitors application state to determine when dependency changes require re-evaluation.
- Dependency Tracking - Automatically identifies and tracks data dependencies in a reactive system without manual bookkeeping.
- Dirty Flagging Systems - Uses a dirty-flagging system to mark dependents as invalid when source signals change.
- Fine-Grained Dependency Tracking - Tracks precise signal-to-effect relationships to minimize updates for state synchronization.
- Memoized Computations - Provides lazy evaluation and memoization for derived values to optimize performance.
- Reactive Primitives - Introduces a fundamental signal primitive for tracking value dependencies and automatically propagating updates.
- Reactive State Management - Provides a system for managing application state using native reactive primitives.
- Fine-Grained Reactivity - Defines a standard for a reactivity engine that tracks data dependencies at a granular level for high-performance updates.
- Automatic Dependency Tracking - Implements a mechanism to implicitly detect and record reactive dependencies during execution.
- Non-Reactive Value Reads - Provides a way to retrieve a value without establishing a reactive subscription.
- Custom Equality Comparators - Allows developers to define custom equality logic to prevent unnecessary update propagation.
- Custom Comparison Logic - Supports user-defined comparison functions to determine if a value change should trigger updates.
- Custom Equality Definitions - Enables the definition of custom equality functions for specific data types within the reactive system.
- State Change Observers - Triggers registered callbacks via watchers when dependencies in the state tree are updated.
- Untracked Accessors - Enables reading signal values without registering a dependency to avoid accidental re-evaluations.
- Synchronous State Updates - Processes state updates synchronously across the dependency graph to prevent race conditions.
- Synchronous Dependency Propagation - Ensures state updates are applied synchronously and consistently across a complex dependency graph in JavaScript.
- Synchronous Propagation - Ensures that state updates propagate synchronously across the dependency graph to maintain consistency.
- Transient State Reads - Implements transient state reads that do not register dependencies or trigger re-renders.
Star history
How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.
