@alwatr/signal 9.26.0 → 9.30.0

package/dist/core/signal-base.d.ts

@@ -1,100 +1,120 @@
 import type { Observer_, SubscribeOptions, SubscribeResult, ListenerCallback, SignalConfig } from '../type.js';
 import type { AlwatrLogger } from '@alwatr/logger';
 /**
- * An abstract base class for signal implementations.
- * It provides the core functionality for managing subscriptions (observers).
+ * An abstract base class for all signal implementations in the `@alwatr/signal` package.
  *
- * @template T The type of data that the signal holds or dispatches.
+ * It provides core subscription management capabilities, including priority observer queues,
+ * microtask/macrotask-friendly updates, type-safe unsubscribes, async promise resolution via `untilNext`,
+ * and safe destruction lifecycles to prevent memory leaks.
+ *
+ * @template T The type of data that the signal holds, dispatches, or streams.
  */
 export declare abstract class SignalBase<T> {
     protected config_: SignalConfig;
     /**
      * The unique identifier for this signal instance.
-     * Useful for debugging and logging.
+     * Highly useful for debugging, filtering logs, and tracing data flows.
      */
     readonly name: string;
     /**
      * The logger instance for this signal.
+     * Custom scoped logger based on the signal name and type.
+     *
      * @protected
      */
     protected abstract logger_: AlwatrLogger;
     /**
-     * The list of observers (listeners) subscribed to this signal.
+     * High-priority observers that are executed first during notifications.
+     * Allocated lazily upon the first priority subscription to guard heap memory.
+     *
+     * @protected
+     */
+    protected priorityObservers_?: Set<Observer_<T>>;
+    /**
+     * Standard-priority observers executed after priority observers.
+     * Allocated lazily upon the first standard subscription to guard heap memory.
+     *
      * @protected
      */
-    protected readonly priorityObservers_: Set<Observer_<T>>;
-    protected readonly observers_: Set<Observer_<T>>;
+    protected observers_?: Set<Observer_<T>>;
     /**
-     * A flag indicating whether the signal has been destroyed.
+     * Internal flag representing whether the signal has been destroyed.
+     *
      * @private
      */
     private isDestroyed__;
     /**
      * Indicates whether the signal has been destroyed.
-     * A destroyed signal cannot be used and will throw an error if interacted with.
+     * A destroyed signal cannot be subscribed to or dispatched to.
      *
      * @returns `true` if the signal is destroyed, `false` otherwise.
      */
     get isDestroyed(): boolean;
+    /**
+     * Creates a new instance of the signal base.
+     *
+     * @param config_ Configuration options including the unique signal name and cleanup hooks.
+     */
     constructor(config_: SignalConfig);
     /**
-     * Removes a specific observer from the observers list.
+     * Removes a specific observer from both the standard and priority observer queues.
      *
-     * @param observer The observer instance to remove.
+     * @param observer The observer wrapper object containing the callback and options to remove.
      * @protected
      */
     protected removeObserver_(observer: Observer_<T>): void;
     /**
      * Subscribes a listener function to this signal.
      *
-     * The listener will be called whenever the signal is notified (e.g., when `dispatch` or `set` is called).
+     * The listener will be called whenever the signal notifies its observers.
      *
-     * @param callback The function to be called when the signal is dispatched.
-     * @param options Subscription options to customize the behavior (e.g., `once`, `priority`).
-     * @returns A `SubscribeResult` object with an `unsubscribe` method to remove the listener.
+     * @param callback The function to invoke when the signal dispatches a new value.
+     * @param options Custom options to control priority, immediate callback, or single execution.
+     * @returns An object with an `unsubscribe` method to remove the subscription.
      */
     subscribe(callback: ListenerCallback<T>, options?: SubscribeOptions): SubscribeResult;
     /**
-     * Notifies all registered observers about a new value.
-     *
-     * This method iterates through a snapshot of the current observers to prevent issues
-     * with subscriptions changing during notification (e.g., an observer unsubscribing itself).
+     * Notifies all registered priority and standard observers with the given value.
+     * Iterates synchronously over current queues.
      *
-     * @param value The new value to notify observers about.
+     * @param value The value to pass to each observer's callback.
      * @protected
      */
     protected notify_(value: T): void;
     /**
-     * Executes a given observer's callback with the provided value, handling both synchronous and asynchronous callbacks.
+     * Executes a single observer's callback, handles auto-unsubscribing for `once` listeners,
+     * and wraps execution in a try-catch block to prevent observer exceptions from crashing the signal.
+     *
+     * @param observer The observer descriptor to execute.
+     * @param value The value to supply to the observer's callback.
+     * @private
      */
     private executeObserver__;
-    private pendingRejects__;
     /**
-     * Returns a Promise that resolves with the next value dispatched by the signal.
-     * This provides an elegant way to wait for a single, future event using `async/await`.
+     * Holds the promise rejection functions of any pending `untilNext` invocations
+     * to reject them if the signal is destroyed.
      *
-     * @returns A Promise that resolves with the next dispatched value.
+     * @private
+     */
+    private pendingRejects__?;
+    /**
+     * Returns a Promise that resolves with the next value/payload dispatched by the signal.
+     * Use this for async orchestration (e.g. `await signal.untilNext()`).
      *
-     * @example
-     * async function onButtonClick() {
-     *   console.log('Waiting for the next signal...');
-     *   const nextValue = await mySignal.untilNext();
-     *   console.log('Signal received:', nextValue);
-     * }
+     * @returns A Promise that resolves with the next value dispatched by the signal.
      */
     untilNext(): Promise<T>;
     /**
-     * Destroys the signal, clearing all its listeners and making it inactive.
-     *
-     * After destruction, any interaction with the signal (like `subscribe` or `untilNext`)
-     * will throw an error. This is crucial for preventing memory leaks by allowing
-     * garbage collection of the signal and its observers.
+     * Permanently destroys the signal instance.
+     * Clears all observers, rejects pending `untilNext` promises with a 'signal_destroyed' error,
+     * invokes the optional `onDestroy` config hook, and breaks internal references to facilitate GC.
      */
     destroy(): void;
     /**
-     * Throws an error if the signal has been destroyed.
-     * This is a safeguard to prevent interaction with a defunct signal.
+     * Checks if the signal has been destroyed. If so, throws an error and logs an accident.
+     *
      * @protected
+     * @throws {Error} If the signal has been destroyed.
      */
     protected checkDestroyed_(): void;
 }

package/dist/core/signal-base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"signal-base.d.ts","sourceRoot":"","sources":["../../src/core/signal-base.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,SAAS,EAAE,gBAAgB,EAAE,eAAe,EAAE,gBAAgB,EAAE,YAAY,EAAC,MAAM,YAAY,CAAC;AAC7G,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAEjD;;;;;GAKG;AACH,8BAAsB,UAAU,CAAC,CAAC;IAoCpB,SAAS,CAAC,OAAO,EAAE,YAAY;IAnC3C;;;OAGG;IACH,SAAgB,IAAI,EAAE,MAAM,CAAC;IAE7B;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;IAEzC;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,kBAAkB,oBAA2B;IAChE,SAAS,CAAC,QAAQ,CAAC,UAAU,oBAA2B;IAExD;;;OAGG;IACH,OAAO,CAAC,aAAa,CAAS;IAE9B;;;;;OAKG;IACH,IAAW,WAAW,IAAI,OAAO,CAEhC;gBAEqB,OAAO,EAAE,YAAY;IAI3C;;;;;OAKG;IACH,SAAS,CAAC,eAAe,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI;IAYvD;;;;;;;;OAQG;IACI,SAAS,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,eAAe;IAkB5F;;;;;;;;OAQG;IACH,SAAS,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI;IAiBjC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAczB,OAAO,CAAC,gBAAgB,CAAqC;IAE7D;;;;;;;;;;;;OAYG;IACI,SAAS,IAAI,OAAO,CAAC,CAAC,CAAC;IAmB9B;;;;;;OAMG;IACI,OAAO,IAAI,IAAI;IAqBtB;;;;OAIG;IACH,SAAS,CAAC,eAAe,IAAI,IAAI;CAMlC"}
+{"version":3,"file":"signal-base.d.ts","sourceRoot":"","sources":["../../src/core/signal-base.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,SAAS,EAAE,gBAAgB,EAAE,eAAe,EAAE,gBAAgB,EAAE,YAAY,EAAC,MAAM,YAAY,CAAC;AAC7G,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAEjD;;;;;;;;GAQG;AACH,8BAAsB,UAAU,CAAC,CAAC;IAqDpB,SAAS,CAAC,OAAO,EAAE,YAAY;IApD3C;;;OAGG;IACH,SAAgB,IAAI,EAAE,MAAM,CAAC;IAE7B;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;IAEzC;;;;;OAKG;IACH,SAAS,CAAC,kBAAkB,CAAC,EAAE,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;IAEjD;;;;;OAKG;IACH,SAAS,CAAC,UAAU,CAAC,EAAE,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;IAEzC;;;;OAIG;IACH,OAAO,CAAC,aAAa,CAAS;IAE9B;;;;;OAKG;IACH,IAAW,WAAW,IAAI,OAAO,CAEhC;IAED;;;;OAIG;gBACmB,OAAO,EAAE,YAAY;IAI3C;;;;;OAKG;IACH,SAAS,CAAC,eAAe,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI;IAqBvD;;;;;;;;OAQG;IACI,SAAS,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,eAAe;IAoB5F;;;;;;OAMG;IACH,SAAS,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI;IAuBjC;;;;;;;OAOG;IACH,OAAO,CAAC,iBAAiB;IAWzB;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB,CAAC,CAA8B;IAEvD;;;;;OAKG;IACI,SAAS,IAAI,OAAO,CAAC,CAAC,CAAC;IAoB9B;;;;OAIG;IACI,OAAO,IAAI,IAAI;IAsBtB;;;;;OAKG;IACH,SAAS,CAAC,eAAe,IAAI,IAAI;CAMlC"}

package/dist/core/state-signal.d.ts

@@ -37,39 +37,52 @@ import type { StateSignalConfig, ListenerCallback, SubscribeOptions, SubscribeRe
 export declare class StateSignal<T> extends SignalBase<T> implements IReadonlySignal<T> {
     /**
      * The current value of the signal.
+     *
      * @private
      */
     private value__;
     /**
      * The logger instance for this signal.
+     *
      * @protected
      */
     protected logger_: AlwatrLogger;
     /**
      * Indicates if a notification is already scheduled.
+     * Helps batch multiple synchronous `set` operations into a single microtask notification.
+     *
      * @private
      */
     private notifyPending__;
     /**
-     * The version of the last notification.
+     * The version of the last notification. Incrementing on every state update.
+     * Used to guard immediate subscriber execution when updates happen within the same tick.
+     *
      * @private
      */
     private notifyVersion__;
+    /**
+     * Creates a new StateSignal instance.
+     *
+     * @param config Configuration options including name, initialValue, and custom cleanup hooks.
+     */
     constructor(config: StateSignalConfig<T>);
     /**
      * Retrieves the current value of the signal.
      *
      * @returns The current value.
+     * @throws {Error} If the signal has been destroyed.
      *
      * @example
      * console.log(mySignal.get());
      */
     get(): T;
     /**
-     * Updates the signal's value and notifies all active listeners.
+     * Updates the signal's value and schedules notifications for all active listeners.
      *
-     * The notification is scheduled as a microtask, which means the update is deferred
-     * slightly to batch multiple synchronous changes.
+     * Primitives are comparison-checked via `Object.is`. If unchanged, the update is ignored.
+     * The notification is scheduled as a microtask, allowing multiple synchronous updates
+     * to be batched and executed once.
      *
      * @param newValue The new value to set.
      *
@@ -82,18 +95,18 @@ export declare class StateSignal<T> extends SignalBase<T> implements IReadonlySi
      */
     set(newValue: T): void;
     /**
-     * Notifies all listeners about the current value, even if it hasn't changed.
+     * Forcefully schedules a notification of the current value to all subscribers.
      *
-     * This method is useful when you change the value instance directly (e.g., mutating an object) and want to inform listeners about the change.
+     * Useful when mutating properties within object states directly without assigning a new reference.
+     * Notification is queued as a microtask for batching.
      */
     notifyChange(): void;
     /**
      * Updates the signal's value based on its previous value.
      *
-     * This method is particularly useful for state transitions that depend on the current value,
-     * especially for objects or arrays, as it promotes an immutable update pattern.
+     * A functional update pattern that retrieves the current value, computes the next, and sets it.
      *
-     * @param updater A function that receives the current value and returns the new value.
+     * @param updater A callback function that receives the current value and returns the new value.
      *
      * @example
      * // For a counter
@@ -104,21 +117,27 @@ export declare class StateSignal<T> extends SignalBase<T> implements IReadonlySi
      */
     update(updater: (previousValue: T) => T): void;
     /**
-     * Subscribes a listener to this signal.
+     * Subscribes a listener function to this state signal.
      *
      * By default, the listener is immediately called with the signal's current value (`receivePrevious: true`).
-     * This behavior can be customized via the `options` parameter.
+     * This immediate call is queued as a microtask to match the asynchronous flow of signals.
      *
-     * @param callback The function to be called when the signal's value changes.
-     * @param options Subscription options, including `receivePrevious` and `once`.
+     * @param callback The function to invoke when the state changes.
+     * @param options Custom options, such as `receivePrevious: false` to only listen to future updates.
      * @returns An object with an `unsubscribe` method to remove the listener.
      */
     subscribe(callback: ListenerCallback<T>, options?: SubscribeOptions): SubscribeResult;
     /**
      * Destroys the signal, clearing its value and all listeners.
-     * This is crucial for memory management to prevent leaks.
+     * Breaks references for garbage collection.
      */
     destroy(): void;
+    /**
+     * Returns this signal cast to the `IReadonlySignal<T>` interface.
+     * Limits access so external callers can only subscribe/read but not set/update state.
+     *
+     * @returns A readonly representation of this signal.
+     */
     asReadonly(): IReadonlySignal<T>;
 }
 //# sourceMappingURL=state-signal.d.ts.map

package/dist/core/state-signal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state-signal.d.ts","sourceRoot":"","sources":["../../src/core/state-signal.ts"],"names":[],"mappings":"AACA,OAAO,EAAe,KAAK,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAE/D,OAAO,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAE5C,OAAO,KAAK,EAAC,iBAAiB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,eAAe,EAAE,eAAe,EAAC,MAAM,YAAY,CAAC;AAExH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,qBAAa,WAAW,CAAC,CAAC,CAAE,SAAQ,UAAU,CAAC,CAAC,CAAE,YAAW,eAAe,CAAC,CAAC,CAAC;IAC7E;;;OAGG;IACH,OAAO,CAAC,OAAO,CAAI;IAEnB;;;OAGG;IACH,SAAS,CAAC,OAAO,EAAE,YAAY,CAAC;IAEhC;;;OAGG;IACH,OAAO,CAAC,eAAe,CAAS;IAEhC;;;OAGG;IACH,OAAO,CAAC,eAAe,CAAK;gBAEhB,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC;IAUxC;;;;;;;OAOG;IACI,GAAG,IAAI,CAAC;IAKf;;;;;;;;;;;;;;OAcG;IACI,GAAG,CAAC,QAAQ,EAAE,CAAC,GAAG,IAAI;IAa7B;;;;OAIG;IACI,YAAY,IAAI,IAAI;IAe3B;;;;;;;;;;;;;;OAcG;IACI,MAAM,CAAC,OAAO,EAAE,CAAC,aAAa,EAAE,CAAC,KAAK,CAAC,GAAG,IAAI;IAOrD;;;;;;;;;OASG;IACa,SAAS,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAAE,OAAO,GAAE,gBAAqB,GAAG,eAAe;IAyBzG;;;OAGG;IACa,OAAO,IAAI,IAAI;IAKxB,UAAU,IAAI,eAAe,CAAC,CAAC,CAAC;CAGxC"}
+{"version":3,"file":"state-signal.d.ts","sourceRoot":"","sources":["../../src/core/state-signal.ts"],"names":[],"mappings":"AACA,OAAO,EAAe,KAAK,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAC/D,OAAO,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAC5C,OAAO,KAAK,EAAC,iBAAiB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,eAAe,EAAE,eAAe,EAAC,MAAM,YAAY,CAAC;AAExH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,qBAAa,WAAW,CAAC,CAAC,CAAE,SAAQ,UAAU,CAAC,CAAC,CAAE,YAAW,eAAe,CAAC,CAAC,CAAC;IAC7E;;;;OAIG;IACH,OAAO,CAAC,OAAO,CAAI;IAEnB;;;;OAIG;IACH,SAAS,CAAC,OAAO,EAAE,YAAY,CAAC;IAEhC;;;;;OAKG;IACH,OAAO,CAAC,eAAe,CAAS;IAEhC;;;;;OAKG;IACH,OAAO,CAAC,eAAe,CAAK;IAE5B;;;;OAIG;gBACS,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC;IAUxC;;;;;;;;OAQG;IACI,GAAG,IAAI,CAAC;IAKf;;;;;;;;;;;;;;;OAeG;IACI,GAAG,CAAC,QAAQ,EAAE,CAAC,GAAG,IAAI;IAa7B;;;;;OAKG;IACI,YAAY,IAAI,IAAI;IAe3B;;;;;;;;;;;;;OAaG;IACI,MAAM,CAAC,OAAO,EAAE,CAAC,aAAa,EAAE,CAAC,KAAK,CAAC,GAAG,IAAI;IAOrD;;;;;;;;;OASG;IACa,SAAS,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAAE,OAAO,GAAE,gBAAqB,GAAG,eAAe;IA2BzG;;;OAGG;IACa,OAAO,IAAI,IAAI;IAK/B;;;;;OAKG;IACI,UAAU,IAAI,eAAe,CAAC,CAAC,CAAC;CAGxC"}

package/dist/creators/channel.d.ts

@@ -1,5 +1,5 @@
 import { ChannelSignal } from '../core/channel-signal.js';
-import type { ChannelSignalConfig } from '../core/channel-signal.js';
+import type { ChannelSignalConfig } from '../type.js';
 /**
  * Creates a stateless multi-channel signal that acts as a typed message bus.
  *

package/dist/creators/channel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"channel.d.ts","sourceRoot":"","sources":["../../src/creators/channel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,aAAa,EAAC,MAAM,2BAA2B,CAAC;AAExD,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,2BAA2B,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,SAAS,MAAM,EAAE,MAAM,EAAE,mBAAmB,GAAG,aAAa,CAAC,IAAI,CAAC,CAEzG"}
+{"version":3,"file":"channel.d.ts","sourceRoot":"","sources":["../../src/creators/channel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,aAAa,EAAC,MAAM,2BAA2B,CAAC;AACxD,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,YAAY,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,SAAS,MAAM,EAAE,MAAM,EAAE,mBAAmB,GAAG,aAAa,CAAC,IAAI,CAAC,CAEzG"}

package/dist/creators/derived.d.ts

@@ -0,0 +1,31 @@
+import { DerivedSignal } from '../core/derived-signal.js';
+import type { DerivedSignalConfig } from '../type.js';
+/**
+ * Creates a read-only signal mapping exactly 1-to-1 over a single upstream source.
+ *
+ * `createDerivedSignal` is a utility function to instantiate `DerivedSignal` without using the `new` keyword.
+ * A derived signal wraps a source signal and maps its value to a new representation using a projector function.
+ * It uses the "Cold Awakening Lifecycle" pattern, which avoids subscribing to the source signal until the derived
+ * signal has at least one subscriber of its own, saving processing cycles.
+ *
+ * @template S The type of the source signal's state.
+ * @template T The type of the projected derived state.
+ *
+ * @param config Configuration options including name, source, and projector.
+ * @returns A new, readonly derived signal.
+ *
+ * @example
+ * ```typescript
+ * const countSignal = createStateSignal({ name: 'count', initialValue: 5 });
+ *
+ * const isEvenSignal = createDerivedSignal({
+ *   name: 'is-even-signal',
+ *   source: countSignal,
+ *   projector: (count) => count % 2 === 0
+ * });
+ *
+ * console.log(isEvenSignal.get()); // false
+ * ```
+ */
+export declare function createDerivedSignal<S, T>(config: DerivedSignalConfig<S, T>): DerivedSignal<S, T>;
+//# sourceMappingURL=derived.d.ts.map

package/dist/creators/derived.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derived.d.ts","sourceRoot":"","sources":["../../src/creators/derived.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,aAAa,EAAC,MAAM,2BAA2B,CAAC;AAExD,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,YAAY,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CAEhG"}

package/dist/main.d.ts

@@ -2,6 +2,7 @@ export * from './core/signal-base.js';
 export * from './core/event-signal.js';
 export * from './core/state-signal.js';
 export * from './core/computed-signal.js';
+export * from './core/derived-signal.js';
 export * from './core/effect-signal.js';
 export * from './core/persistent-state-signal.js';
 export * from './core/session-state-signal.js';
@@ -9,12 +10,12 @@ export * from './core/channel-signal.js';
 export * from './creators/event.js';
 export * from './creators/state.js';
 export * from './creators/computed.js';
+export * from './creators/derived.js';
 export * from './creators/effect.js';
 export * from './creators/persistent-state.js';
 export * from './creators/session-state.js';
 export * from './creators/channel.js';
 export * from './operators/debounce.js';
 export * from './operators/filter.js';
-export * from './operators/map.js';
 export type * from './type.js';
 //# sourceMappingURL=main.d.ts.map

package/dist/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,yBAAyB,CAAC;AACxC,cAAc,mCAAmC,CAAC;AAClD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,0BAA0B,CAAC;AAEzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,uBAAuB,CAAC;AAEtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,oBAAoB,CAAC;AAEnC,mBAAmB,WAAW,CAAC"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mCAAmC,CAAC;AAClD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,0BAA0B,CAAC;AAEzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,uBAAuB,CAAC;AAEtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AAEtC,mBAAmB,WAAW,CAAC"}

package/dist/main.js

@@ -1,5 +1,5 @@
-/* 📦 @alwatr/signal v9.26.0 */
-class B{config_;name;priorityObservers_=new Set;observers_=new Set;isDestroyed__=!1;get isDestroyed(){return this.isDestroyed__}constructor(G){this.config_=G;this.name=G.name}removeObserver_(G){if(this.logger_.logMethod?.("removeObserver_"),this.isDestroyed__){this.logger_.incident?.("removeObserver_","remove_observer_on_destroyed_signal");return}this.priorityObservers_.delete(G),this.observers_.delete(G)}subscribe(G,H){this.logger_.logMethodArgs?.("subscribe.base",H),this.checkDestroyed_();let Q={callback:G,options:H};if(H?.priority)this.priorityObservers_.add(Q);else this.observers_.add(Q);return{unsubscribe:()=>this.removeObserver_(Q)}}notify_(G){if(this.logger_.logMethodArgs?.("notify_",G),this.isDestroyed__){this.logger_.incident?.("notify_","notify_on_destroyed_signal");return}for(let H of this.priorityObservers_)this.executeObserver__(H,G);for(let H of this.observers_)this.executeObserver__(H,G)}executeObserver__(G,H){if(G.options?.once)this.removeObserver_(G);try{let Q=G.callback(H);if(Q instanceof Promise)Q.catch((X)=>this.logger_.error("notify_","async_callback_failed",X,{observer:G}))}catch(Q){this.logger_.error("notify_","sync_callback_failed",Q)}}pendingRejects__=new Set;untilNext(){return this.logger_.logMethod?.("untilNext"),this.checkDestroyed_(),new Promise((G,H)=>{this.pendingRejects__.add(H),this.subscribe((Q)=>{this.pendingRejects__.delete(H),G(Q)},{once:!0,priority:!0,receivePrevious:!1})})}destroy(){if(this.logger_.logMethod?.("destroy"),this.isDestroyed__){this.logger_.incident?.("destroy_","double_destroy_attempt");return}if(this.isDestroyed__=!0,this.pendingRejects__.size){let G=Error("signal_destroyed");for(let H of this.pendingRejects__)H(G);this.pendingRejects__.clear()}this.priorityObservers_.clear(),this.observers_.clear(),this.config_.onDestroy?.(),this.config_=null}checkDestroyed_(){if(this.isDestroyed__)throw this.logger_.accident("checkDestroyed_","attempt_to_use_destroyed_signal"),Error(`Cannot interact with a destroyed signal (id: ${this.name})`)}}import{delay as E}from"@alwatr/delay";import{createLogger as x}from"@alwatr/logger";class R extends B{logger_;constructor(G){super(G);this.logger_=x(`event-signal:${this.name}`),this.logger_.logMethod?.("constructor")}dispatch(G){this.logger_.logMethodArgs?.("dispatch",{payload:G}),this.checkDestroyed_(),E.nextMicrotask().then(()=>this.notify_(G))}}import{delay as _}from"@alwatr/delay";import{createLogger as D}from"@alwatr/logger";class K extends B{value__;logger_;notifyPending__=!1;notifyVersion__=0;constructor(G){super({name:G.name,onDestroy:G.onDestroy});this.logger_=D(`state-signal:${this.name}`),this.value__=G.initialValue,this.logger_.logMethodArgs?.("constructor",{initialValue:this.value__})}get(){return this.checkDestroyed_(),this.value__}set(G){if(this.logger_.logMethodArgs?.("set",{newValue:G}),Object.is(this.value__,G)&&(typeof G!=="object"||G===null))return;this.value__=G,this.notifyChange()}notifyChange(){if(this.logger_.logMethod?.("notifyChange"),this.checkDestroyed_(),this.notifyVersion__++,this.notifyPending__)return;this.notifyPending__=!0,_.nextMicrotask().then(()=>{this.notifyPending__=!1,this.notify_(this.value__)})}update(G){this.checkDestroyed_();let H=G(this.value__);this.logger_.logMethodFull?.("update",this.value__,H),this.set(H)}subscribe(G,H={}){this.logger_.logMethodArgs?.("subscribe",H),this.checkDestroyed_();let Q=super.subscribe(G,H);if(H.receivePrevious===!1)return Q;if(this.notifyPending__)return Q;let X=this.notifyVersion__;return _.nextMicrotask().then(()=>{if(this.logger_.logStep?.("subscribe","immediate_callback"),this.notifyVersion__!==X)return;if(H.once)Q.unsubscribe();G(this.value__)}).catch((Y)=>this.logger_.error("subscribe","immediate_callback_failed",Y)),Q}destroy(){this.value__=null,super.destroy()}asReadonly(){return this}}import{delay as I}from"@alwatr/delay";import{createLogger as N}from"@alwatr/logger";class z{config_;name;logger_;internalSignal_;dependencySubscriptions__=[];isRecalculating__=!1;constructor(G){this.config_=G;this.name=G.name,this.logger_=N(`computed-signal:${this.name}`),this.recalculate_=this.recalculate_.bind(this),this.logger_.logMethod?.("constructor"),this.internalSignal_=new K({name:`compute-${this.name}_`,initialValue:this.config_.get()});for(let H of G.deps)this.logger_.logStep?.("constructor","subscribing_to_dependency",{signal:H.name}),this.dependencySubscriptions__.push(H.subscribe(this.recalculate_,{receivePrevious:!1}))}get(){return this.internalSignal_.get()}get isDestroyed(){return this.internalSignal_.isDestroyed}subscribe(G,H){return this.internalSignal_.subscribe(G,H)}untilNext(){return this.internalSignal_.untilNext()}destroy(){if(this.logger_.logMethod?.("destroy"),this.isDestroyed){this.logger_.incident?.("destroy","already_destroyed");return}for(let G of this.dependencySubscriptions__)G.unsubscribe();this.dependencySubscriptions__.length=0,this.internalSignal_.destroy(),this.config_.onDestroy?.(),this.config_=null}async recalculate_(){if(this.logger_.logMethod?.("recalculate_"),this.internalSignal_.isDestroyed){this.logger_.incident?.("recalculate_","recalculate_on_destroyed_signal");return}if(this.isRecalculating__){this.logger_.logStep?.("recalculate_","skipping_recalculation_already_scheduled");return}this.isRecalculating__=!0;try{if(await I.nextMacrotask(),this.isDestroyed){this.logger_.incident?.("recalculate_","destroyed_during_delay"),this.isRecalculating__=!1;return}this.logger_.logStep?.("recalculate_","recalculating_value"),this.internalSignal_.set(this.config_.get())}catch(G){this.logger_.error("recalculate_","recalculation_failed",G)}this.isRecalculating__=!1}}import{delay as A}from"@alwatr/delay";import{createLogger as k}from"@alwatr/logger";class L{config_;name;logger_;dependencySubscriptions__=[];isRunning__=!1;isDestroyed__=!1;get isDestroyed(){return this.isDestroyed__}constructor(G){this.config_=G;this.name=G.name??`[${G.deps.map((H)=>H.name).join(", ")}]`,this.logger_=k(`effect-signal:${this.name}`),this.scheduleExecution_=this.scheduleExecution_.bind(this),this.logger_.logMethod?.("constructor");for(let H of G.deps)this.logger_.logStep?.("constructor","subscribing_to_dependency",{signal:H.name}),this.dependencySubscriptions__.push(H.subscribe(this.scheduleExecution_,{receivePrevious:!1}));if(G.runImmediately===!0)this.logger_.logStep?.("constructor","scheduling_initial_execution"),this.scheduleExecution_()}async scheduleExecution_(){if(this.logger_.logMethod?.("scheduleExecution_"),this.isDestroyed__){this.logger_.incident?.("scheduleExecution_","schedule_execution_on_destroyed_signal");return}if(this.isRunning__){this.logger_.logStep?.("scheduleExecution_","skipped_because_already_running");return}this.isRunning__=!0;try{if(await A.nextMacrotask(),this.isDestroyed__){this.logger_.incident?.("scheduleExecution_","destroyed_during_delay"),this.isRunning__=!1;return}this.logger_.logStep?.("scheduleExecution_","executing_effect"),await this.config_.run()}catch(G){this.logger_.error("scheduleExecution_","effect_failed",G)}this.isRunning__=!1}destroy(){if(this.logger_.logMethod?.("destroy"),this.isDestroyed__){this.logger_.incident?.("destroy","already_destroyed");return}this.isDestroyed__=!0;for(let G of this.dependencySubscriptions__)G.unsubscribe();this.dependencySubscriptions__.length=0,this.config_.onDestroy?.(),this.config_=null}}import{createDebouncer as V}from"@alwatr/debounce";import{createLocalStorageProvider as j}from"@alwatr/local-storage";class O extends K{storageProvider__;storageDebouncer__;storageSyncSubscription__;windowPageHideListener_=()=>{this.storageDebouncer__.flush()};windowPageShowListener_=(G)=>{if(G.persisted){this.logger_.logMethod?.("windowPageShowListener_//restored_from_bfcache");let H=this.storageProvider__.read();if(H!==null)this.set(H)}};constructor(G){let{name:H,storageKey:Q=H,saveDebounceDelay:X=1000,initialValue:Y,onDestroy:Z,schemaVersion:q,parse:W,stringify:J}=G,P=j({name:Q,schemaVersion:q,parse:W,stringify:J});super({name:H,initialValue:P.read()??Y,onDestroy:Z});if(this.logger_.logMethodArgs?.("constructor",G),this.storageProvider__=P,this.storageDebouncer__=V({delay:X,leading:!1,trailing:!0,thisContext:this,func:this.syncStorage__}),this.storageSyncSubscription__=this.subscribe(this.storageDebouncer__.trigger,{receivePrevious:!1}),typeof globalThis.addEventListener==="function")globalThis.addEventListener("pagehide",this.windowPageHideListener_,{passive:!0}),globalThis.addEventListener("pageshow",this.windowPageShowListener_,{passive:!0})}syncStorage__(G){this.logger_.logMethodArgs?.("syncStorage__",G),this.storageProvider__.write(G)}remove(){this.checkDestroyed_(),this.logger_.logMethod?.("remove"),this.storageProvider__.remove()}destroy(){if(this.logger_.logMethod?.("destroy"),typeof globalThis.removeEventListener==="function")globalThis.removeEventListener("pagehide",this.windowPageHideListener_),globalThis.removeEventListener("pageshow",this.windowPageShowListener_);this.storageDebouncer__.flush(),this.storageSyncSubscription__.unsubscribe(),super.destroy()}}import{createDebouncer as C}from"@alwatr/debounce";import{createSessionStorageProvider as T}from"@alwatr/session-storage";class $ extends K{storageProvider__;storageDebouncer__;storageSyncSubscription__;windowPageHideListener__=()=>{this.storageDebouncer__.flush()};windowPageShowListener__=(G)=>{if(G.persisted){this.logger_.logMethod?.("windowPageShowListener__//restored_from_bfcache");let H=this.storageProvider__.read();if(H!==null)this.set(H)}};constructor(G){let{name:H,storageKey:Q=H,saveDebounceDelay:X=1000,initialValue:Y,onDestroy:Z,parse:q,stringify:W}=G,J=T({name:Q,parse:q,stringify:W});super({name:H,initialValue:J.read()??Y,onDestroy:Z});if(this.logger_.logMethodArgs?.("constructor",G),this.storageProvider__=J,this.storageDebouncer__=C({delay:X,leading:!1,trailing:!0,thisContext:this,func:this.syncStorage__}),this.storageSyncSubscription__=this.subscribe(this.storageDebouncer__.trigger,{receivePrevious:!1}),typeof globalThis.addEventListener==="function")globalThis.addEventListener("pagehide",this.windowPageHideListener__,{passive:!0}),globalThis.addEventListener("pageshow",this.windowPageShowListener__,{passive:!0})}syncStorage__(G){this.logger_.logMethodArgs?.("syncStorage__",G),this.storageProvider__.write(G)}remove(){this.checkDestroyed_(),this.logger_.logMethod?.("remove"),this.storageProvider__.remove()}destroy(){if(this.logger_.logMethod?.("destroy"),typeof globalThis.removeEventListener==="function")globalThis.removeEventListener("pagehide",this.windowPageHideListener__),globalThis.removeEventListener("pageshow",this.windowPageShowListener__);this.storageDebouncer__.flush(),this.storageSyncSubscription__.unsubscribe(),super.destroy()}}import{delay as w}from"@alwatr/delay";import{createLogger as b}from"@alwatr/logger";class M extends B{logger_;namedHandlers__=new Map;constructor(G){super(G);this.logger_=b(`channel-signal:${this.name}`),this.logger_.logMethod?.("constructor")}dispatch(...G){let[H,Q]=G;this.logger_.logMethodArgs?.("dispatch",{name:H,payload:Q}),this.checkDestroyed_(),w.nextMicrotask().then(()=>this.route__(H,Q))}on(G,H,Q){this.logger_.logMethodArgs?.("on",{name:G}),this.checkDestroyed_();let X=this.namedHandlers__.get(G);if(!X)X=new Set,this.namedHandlers__.set(G,X);let Y={handler:H,once:Q?.once??!1};return X.add(Y),{unsubscribe:()=>{if(X.delete(Y),X.size===0)this.namedHandlers__.delete(G)}}}subscribe(G,H){return this.logger_.logMethodArgs?.("subscribe",H),super.subscribe(G,H)}route__(G,H){if(this.isDestroyed)return;let Q=this.namedHandlers__.get(G);if(Q?.size)for(let X of Q){if(X.once){if(Q.delete(X),Q.size===0)this.namedHandlers__.delete(G)}try{let Y=X.handler(H);if(Y instanceof Promise)Y.catch((Z)=>this.logger_.error("route__","async_named_handler_failed",Z))}catch(Y){this.logger_.error("route__","sync_named_handler_failed",Y)}}this.notify_({name:G,payload:H})}destroy(){this.namedHandlers__.clear(),super.destroy()}}function qG(G){return new R(G)}function U(G){return new K(G)}function F(G){return new z(G)}function MG(G){return new L(G)}function UG(G){return new O(G)}function DG(G){return new $(G)}function AG(G){return new M(G)}import{createDebouncer as v}from"@alwatr/debounce";function TG(G,H){let Q=H.name??`${G.name}-debounced`,X=new K({name:`${Q}-internal`,initialValue:G.get()}),Y=v({...H,thisContext:X,func:X.set}),Z=G.subscribe(Y.trigger,{receivePrevious:!1});return F({name:Q,deps:[X],get:()=>X.get(),onDestroy:()=>{if(X.isDestroyed)return;Z.unsubscribe(),Y.cancel(),X.destroy(),H.onDestroy?.(),H=null}})}function yG(G,H,Q=`${G.name}-filtered`){let X=G.get(),Y=H(X)?X:void 0,Z=U({name:`${Q}-internal`,initialValue:Y}),q=G.subscribe((W)=>{if(H(W))Z.set(W)});return F({name:Q,deps:[Z],get:()=>Z.get(),onDestroy:()=>{q.unsubscribe(),Z.destroy()}})}function mG(G,H,Q=`${G.name}-mapped`){return F({name:Q,deps:[G],get:()=>H(G.get())})}export{U as createStateSignal,DG as createSessionStateSignal,UG as createPersistentStateSignal,mG as createMappedSignal,yG as createFilteredSignal,qG as createEventSignal,MG as createEffect,TG as createDebouncedSignal,F as createComputedSignal,AG as createChannelSignal,K as StateSignal,B as SignalBase,$ as SessionStateSignal,O as PersistentStateSignal,R as EventSignal,L as EffectSignal,z as ComputedSignal,M as ChannelSignal};
+/* 📦 @alwatr/signal v9.30.0 */
+class K{config_;name;priorityObservers_;observers_;isDestroyed__=!1;get isDestroyed(){return this.isDestroyed__}constructor(G){this.config_=G;this.name=G.name}removeObserver_(G){if(this.logger_.logMethod?.("removeObserver_"),this.isDestroyed__){this.logger_.incident?.("removeObserver_","remove_observer_on_destroyed_signal");return}if(G.options?.priority){if(this.priorityObservers_?.delete(G),this.priorityObservers_?.size===0)this.priorityObservers_=void 0}else if(this.observers_?.delete(G),this.observers_?.size===0)this.observers_=void 0}subscribe(G,H){this.logger_.logMethodArgs?.("subscribe.base",H),this.checkDestroyed_();let Q={callback:G,options:H};if(H?.priority)this.priorityObservers_??=new Set,this.priorityObservers_.add(Q);else this.observers_??=new Set,this.observers_.add(Q);return{unsubscribe:()=>this.removeObserver_(Q)}}notify_(G){if(this.logger_.logMethodArgs?.("notify_",G),this.isDestroyed__){this.logger_.incident?.("notify_","notify_on_destroyed_signal");return}if(this.priorityObservers_?.size)for(let H of this.priorityObservers_)this.executeObserver__(H,G);if(this.observers_?.size)for(let H of this.observers_)this.executeObserver__(H,G)}executeObserver__(G,H){if(G.options?.once)this.removeObserver_(G);try{G.callback(H)}catch(Q){this.logger_.error("notify_","sync_callback_failed",Q)}}pendingRejects__;untilNext(){return this.logger_.logMethod?.("untilNext"),this.checkDestroyed_(),new Promise((G,H)=>{this.pendingRejects__??=new Set,this.pendingRejects__.add(H),this.subscribe((Q)=>{this.pendingRejects__?.delete(H),G(Q)},{once:!0,priority:!0,receivePrevious:!1})})}destroy(){if(this.logger_.logMethod?.("destroy"),this.isDestroyed__){this.logger_.incident?.("destroy_","double_destroy_attempt");return}if(this.isDestroyed__=!0,this.pendingRejects__?.size){let G=Error("signal_destroyed");for(let H of this.pendingRejects__)H(G);this.pendingRejects__.clear()}this.priorityObservers_?.clear(),this.observers_?.clear(),this.config_.onDestroy?.(),this.config_=null}checkDestroyed_(){if(this.isDestroyed__)throw this.logger_.accident("checkDestroyed_","attempt_to_use_destroyed_signal"),Error(`Cannot interact with a destroyed signal (id: ${this.name})`)}}import{queueMicrotask as x}from"@alwatr/delay";import{createLogger as E}from"@alwatr/logger";class O extends K{logger_;constructor(G){super(G);this.logger_=E(`event_signal:${this.name}`),this.logger_.logMethod?.("constructor")}dispatch(G){this.logger_.logMethodArgs?.("dispatch",{payload:G}),this.checkDestroyed_(),x(()=>this.notify_(G))}}import{queueMicrotask as M}from"@alwatr/delay";import{createLogger as D}from"@alwatr/logger";class Z extends K{value__;logger_;notifyPending__=!1;notifyVersion__=0;constructor(G){super({name:G.name,onDestroy:G.onDestroy});this.logger_=D(`state_signal:${this.name}`),this.value__=G.initialValue,this.logger_.logMethodArgs?.("constructor",{initialValue:this.value__})}get(){return this.checkDestroyed_(),this.value__}set(G){if(this.logger_.logMethodArgs?.("set",{newValue:G}),Object.is(this.value__,G)&&(typeof G!=="object"||G===null))return;this.value__=G,this.notifyChange()}notifyChange(){if(this.logger_.logMethod?.("notifyChange"),this.checkDestroyed_(),this.notifyVersion__++,this.notifyPending__)return;this.notifyPending__=!0,M(()=>{this.notifyPending__=!1,this.notify_(this.value__)})}update(G){this.checkDestroyed_();let H=G(this.value__);this.logger_.logMethodFull?.("update",this.value__,H),this.set(H)}subscribe(G,H={}){this.logger_.logMethodArgs?.("subscribe",H),this.checkDestroyed_();let Q=super.subscribe(G,H);if(H.receivePrevious===!1)return Q;if(this.notifyPending__)return Q;let X=this.notifyVersion__;return M(()=>{if(this.logger_.logStep?.("subscribe","immediate_callback"),this.notifyVersion__!==X)return;if(H.once)Q.unsubscribe();try{G(this.value__)}catch(Y){this.logger_.error("subscribe","immediate_callback_failed",Y)}}),Q}destroy(){this.value__=null,super.destroy()}asReadonly(){return this}}import{queueMicrotask as N}from"@alwatr/delay";import{createLogger as I}from"@alwatr/logger";class R{config_;name;logger_;internalSignal_;dependencySubscriptions__=[];isRecalculating__=!1;constructor(G){this.config_=G;this.name=G.name,this.logger_=I(`computed_signal:${this.name}`),this.recalculate_=this.recalculate_.bind(this),this.logger_.logMethod?.("constructor"),this.internalSignal_=new Z({name:`compute_internal:${this.name}`,initialValue:this.config_.get()});for(let H=0;H<this.config_.deps.length;H++){let Q=this.config_.deps[H];this.logger_.logStep?.("constructor","subscribing_to_dependency",{signal:Q.name}),this.dependencySubscriptions__.push(Q.subscribe(this.recalculate_,{receivePrevious:!1}))}}get(){return this.internalSignal_.get()}get isDestroyed(){return this.internalSignal_.isDestroyed}subscribe(G,H){return this.internalSignal_.subscribe(G,H)}untilNext(){return this.internalSignal_.untilNext()}destroy(){if(this.logger_.logMethod?.("destroy"),this.isDestroyed){this.logger_.incident?.("destroy","already_destroyed");return}for(let G=0;G<this.dependencySubscriptions__.length;G++)this.dependencySubscriptions__[G].unsubscribe();this.dependencySubscriptions__.length=0,this.internalSignal_.destroy(),this.config_.onDestroy?.(),this.config_=null}recalculate_(){if(this.logger_.logMethod?.("recalculate_"),this.isRecalculating__){this.logger_.logStep?.("recalculate_","skipping_recalculation_already_scheduled");return}this.isRecalculating__=!0,N(()=>{if(this.isDestroyed){this.logger_.incident?.("recalculate_","destroyed_during_delay"),this.isRecalculating__=!1;return}this.logger_.logStep?.("recalculate_","recalculating_value");try{this.internalSignal_.set(this.config_.get())}catch(G){this.logger_.error("recalculate_","projection_evaluation_failed",G)}this.isRecalculating__=!1})}}import{createLogger as A}from"@alwatr/logger";class z{config_;name;logger_;internalSignal_;sourceSubscription__;activeConsumerCount__=0;constructor(G){this.config_=G;this.name=this.config_.name,this.logger_=A(`derived_signal:${this.name}`)}untilNext(){return this.logger_.logMethod?.("untilNext"),this.checkDestroyed__(),new Promise((G)=>{this.subscribe((H)=>{G(H)},{receivePrevious:!1,once:!0})})}get(){if(this.logger_.logMethod?.("get"),this.checkDestroyed__(),this.activeConsumerCount__===0)return this.config_.projector(this.config_.source.get());return this.internalSignal_.get()}get isDestroyed(){return this.config_===null}subscribe(G,H){if(this.logger_.logMethod?.("subscribe"),this.checkDestroyed__(),this.activeConsumerCount__++,this.activeConsumerCount__===1)this.logger_.logMethod?.("wakeUp_"),this.internalSignal_=new Z({name:`derived-internal:${this.name}`,initialValue:this.config_.projector(this.config_.source.get())}),this.sourceSubscription__=this.config_.source.subscribe((X)=>{this.internalSignal_.set(this.config_.projector(X))},{receivePrevious:!1});let Q=this.internalSignal_.subscribe(G,H);return{unsubscribe:()=>{if(this.logger_.logMethod?.("unsubscribe"),Q.unsubscribe(),this.activeConsumerCount__--,this.activeConsumerCount__===0&&this.sourceSubscription__)this.logger_.logMethod?.("sleepCleanup_"),this.sourceSubscription__.unsubscribe(),this.sourceSubscription__=void 0,this.internalSignal_?.destroy(),this.internalSignal_=void 0}}}destroy(){if(this.logger_.logMethod?.("destroy"),this.isDestroyed)return;if(this.sourceSubscription__)this.sourceSubscription__.unsubscribe(),this.sourceSubscription__=void 0;this.internalSignal_?.destroy(),this.config_.onDestroy?.(),this.config_=null}checkDestroyed__(){if(this.logger_.logMethod?.("checkDestroyed__"),this.isDestroyed)throw Error(`Cannot interact with a destroyed signal (id: ${this.name})`)}}import{delay as j}from"@alwatr/delay";import{createLogger as C}from"@alwatr/logger";class ${config_;name;logger_;dependencySubscriptions__=[];isRunning__=!1;isDestroyed__=!1;get isDestroyed(){return this.isDestroyed__}constructor(G){this.config_=G;this.name=G.name??`[${G.deps.map((H)=>H.name).join(", ")}]`,this.logger_=C(`effect-signal:${this.name}`),this.scheduleExecution_=this.scheduleExecution_.bind(this),this.logger_.logMethod?.("constructor");for(let H of G.deps)this.logger_.logStep?.("constructor","subscribing_to_dependency",{signal:H.name}),this.dependencySubscriptions__.push(H.subscribe(this.scheduleExecution_,{receivePrevious:!1}));if(G.runImmediately===!0)this.logger_.logStep?.("constructor","scheduling_initial_execution"),this.scheduleExecution_()}async scheduleExecution_(){if(this.logger_.logMethod?.("scheduleExecution_"),this.isDestroyed__){this.logger_.incident?.("scheduleExecution_","schedule_execution_on_destroyed_signal");return}if(this.isRunning__){this.logger_.logStep?.("scheduleExecution_","skipped_because_already_running");return}this.isRunning__=!0;try{if(await j.nextMicrotask(),this.isDestroyed__){this.logger_.incident?.("scheduleExecution_","destroyed_during_delay"),this.isRunning__=!1;return}this.logger_.logStep?.("scheduleExecution_","executing_effect"),this.config_.run()}catch(G){this.logger_.error("scheduleExecution_","effect_failed",G)}this.isRunning__=!1}destroy(){if(this.logger_.logMethod?.("destroy"),this.isDestroyed__){this.logger_.incident?.("destroy","already_destroyed");return}this.isDestroyed__=!0;for(let G of this.dependencySubscriptions__)G.unsubscribe();this.dependencySubscriptions__.length=0,this.config_.onDestroy?.(),this.config_=null}}import{createDebouncer as V}from"@alwatr/debounce";import{createLocalStorageProvider as T}from"@alwatr/local-storage";class q extends Z{storageProvider__;storageDebouncer__;storageSyncSubscription__;windowPageHideListener_=()=>{this.storageDebouncer__.flush()};windowPageShowListener_=(G)=>{if(G.persisted){this.logger_.logMethod?.("windowPageShowListener_//restored_from_bfcache");let H=this.storageProvider__.read();if(H!==null)this.set(H)}};constructor(G){let{name:H,storageKey:Q=H,saveDebounceDelay:X=1000,initialValue:Y,onDestroy:F,schemaVersion:B,parse:J,stringify:W}=G,P=T({name:Q,schemaVersion:B,parse:J,stringify:W});super({name:H,initialValue:P.read()??Y,onDestroy:F});if(this.logger_.logMethodArgs?.("constructor",G),this.storageProvider__=P,this.storageDebouncer__=V({delay:X,leading:!1,trailing:!0,thisContext:this,func:this.syncStorage__}),this.storageSyncSubscription__=this.subscribe(this.storageDebouncer__.trigger,{receivePrevious:!1}),typeof globalThis.addEventListener==="function")globalThis.addEventListener("pagehide",this.windowPageHideListener_,{passive:!0}),globalThis.addEventListener("pageshow",this.windowPageShowListener_,{passive:!0})}syncStorage__(G){this.logger_.logMethodArgs?.("syncStorage__",G),this.storageProvider__.write(G)}remove(){this.checkDestroyed_(),this.logger_.logMethod?.("remove"),this.storageProvider__.remove()}destroy(){if(this.logger_.logMethod?.("destroy"),typeof globalThis.removeEventListener==="function")globalThis.removeEventListener("pagehide",this.windowPageHideListener_),globalThis.removeEventListener("pageshow",this.windowPageShowListener_);this.storageDebouncer__.flush(),this.storageSyncSubscription__.unsubscribe(),super.destroy()}}import{createDebouncer as k}from"@alwatr/debounce";import{createSessionStorageProvider as w}from"@alwatr/session-storage";class _ extends Z{storageProvider__;storageDebouncer__;storageSyncSubscription__;windowPageHideListener__=()=>{this.storageDebouncer__.flush()};windowPageShowListener__=(G)=>{if(G.persisted){this.logger_.logMethod?.("windowPageShowListener__//restored_from_bfcache");let H=this.storageProvider__.read();if(H!==null)this.set(H)}};constructor(G){let{name:H,storageKey:Q=H,saveDebounceDelay:X=1000,initialValue:Y,onDestroy:F,parse:B,stringify:J}=G,W=w({name:Q,parse:B,stringify:J});super({name:H,initialValue:W.read()??Y,onDestroy:F});if(this.logger_.logMethodArgs?.("constructor",G),this.storageProvider__=W,this.storageDebouncer__=k({delay:X,leading:!1,trailing:!0,thisContext:this,func:this.syncStorage__}),this.storageSyncSubscription__=this.subscribe(this.storageDebouncer__.trigger,{receivePrevious:!1}),typeof globalThis.addEventListener==="function")globalThis.addEventListener("pagehide",this.windowPageHideListener__,{passive:!0}),globalThis.addEventListener("pageshow",this.windowPageShowListener__,{passive:!0})}syncStorage__(G){this.logger_.logMethodArgs?.("syncStorage__",G),this.storageProvider__.write(G)}remove(){this.checkDestroyed_(),this.logger_.logMethod?.("remove"),this.storageProvider__.remove()}destroy(){if(this.logger_.logMethod?.("destroy"),typeof globalThis.removeEventListener==="function")globalThis.removeEventListener("pagehide",this.windowPageHideListener__),globalThis.removeEventListener("pageshow",this.windowPageShowListener__);this.storageDebouncer__.flush(),this.storageSyncSubscription__.unsubscribe(),super.destroy()}}import{queueMicrotask as b}from"@alwatr/delay";import{createLogger as S}from"@alwatr/logger";class L extends K{logger_;namedHandlers__=new Map;constructor(G){super(G);this.logger_=S(`channel_signal:${this.name}`),this.logger_.logMethod?.("constructor")}dispatch(...G){let[H,Q]=G;this.logger_.logMethodArgs?.("dispatch",{name:H,payload:Q}),this.checkDestroyed_(),b(()=>this.route__(H,Q))}on(G,H,Q){this.logger_.logMethodArgs?.("on",{name:G}),this.checkDestroyed_();let X=this.namedHandlers__.get(G);if(!X)X=new Set,this.namedHandlers__.set(G,X);let Y={handler:H,once:Q?.once??!1};return X.add(Y),{unsubscribe:()=>{if(X.delete(Y),X.size===0)this.namedHandlers__.delete(G)}}}subscribe(G,H){return this.logger_.logMethodArgs?.("subscribe",H),super.subscribe(G,H)}route__(G,H){if(this.isDestroyed)return;let Q=this.namedHandlers__.get(G);if(Q?.size)for(let X of Q){if(X.once){if(Q.delete(X),Q.size===0)this.namedHandlers__.delete(G)}try{X.handler(H)}catch(Y){this.logger_.error("route__","sync_named_handler_failed",Y)}}this.notify_({name:G,payload:H})}destroy(){this.namedHandlers__.clear(),super.destroy()}}function $G(G){return new O(G)}function U(G){return new Z(G)}function MG(G){return new R(G)}function EG(G){return new z(G)}function IG(G){return new $(G)}function CG(G){return new q(G)}function kG(G){return new _(G)}function SG(G){return new L(G)}import{createDebouncer as v}from"@alwatr/debounce";function hG(G,H){let Q=H.name??`${G.name}_debounced`,X=new Z({name:Q,initialValue:G.get(),onDestroy(){F.unsubscribe(),Y.cancel(),H.onDestroy?.(),H=null}}),Y=v({...H,thisContext:X,func:X.set}),F=G.subscribe(Y.trigger,{receivePrevious:!1});return X}function dG(G,H,Q=`${G.name}_filtered`){let X=G.get(),Y=H(X)?X:void 0,F=U({name:Q,initialValue:Y,onDestroy(){B.unsubscribe()}}),B=G.subscribe((J)=>{if(H(J))F.set(J)});return F}export{U as createStateSignal,kG as createSessionStateSignal,CG as createPersistentStateSignal,dG as createFilteredSignal,$G as createEventSignal,IG as createEffect,EG as createDerivedSignal,hG as createDebouncedSignal,MG as createComputedSignal,SG as createChannelSignal,Z as StateSignal,K as SignalBase,_ as SessionStateSignal,q as PersistentStateSignal,O as EventSignal,$ as EffectSignal,z as DerivedSignal,R as ComputedSignal,L as ChannelSignal};
 
-//# debugId=B292A92FF8D8C98B64756E2164756E21
+//# debugId=2DB7724539464C7064756E2164756E21
 //# sourceMappingURL=main.js.map