@alwatr/signal 9.26.0 → 9.30.0

package/dist/type.d.ts

@@ -1,4 +1,3 @@
-import type { Awaitable } from '@alwatr/type-helper';
 import type { DebouncerConfig } from '@alwatr/debounce';
 import type { LocalStorageProviderConfig } from '@alwatr/local-storage';
 import type { SessionStorageProviderConfig } from '@alwatr/session-storage';
@@ -10,7 +9,7 @@ import type { SessionStorageProviderConfig } from '@alwatr/session-storage';
  *
  * @template T The type of the value that the signal holds or dispatches.
  */
-export type ListenerCallback<T> = (value: T) => Awaitable<void>;
+export type ListenerCallback<T> = (value: T) => void;
 /**
  * Options for fine-tuning the behavior of a subscription to a signal.
  */
@@ -205,6 +204,21 @@ export interface ComputedSignalConfig<T> extends SignalConfig {
      */
     get: () => T;
 }
+/**
+ * Configuration for creating a `DerivedSignal`.
+ * @template S The type of the source signal state.
+ * @template T The type of the projected derived state.
+ */
+export interface DerivedSignalConfig<S, T> extends SignalConfig {
+    /**
+     * The single upstream readonly source signal.
+     */
+    readonly source: IReadonlySignal<S>;
+    /**
+     * Projection mapping function transforming source S to derived T.
+     */
+    readonly projector: (value: S) => T;
+}
 /**
  * Configuration for creating an `EffectSignal`.
  */
@@ -236,7 +250,7 @@ export interface EffectSignalConfig {
      *   run: () => console.log(`The counter is now: ${counter.get()}`),
      * });
      */
-    run: () => Awaitable<void>;
+    run: () => void;
     /**
      * If `true`, the effect's `run` function will be executed once immediately upon initialization.
      * @default false
@@ -373,4 +387,55 @@ export interface SessionStateSignalConfig<T> extends StateSignalConfig<T>, Sessi
      */
     saveDebounceDelay?: number;
 }
+/**
+ * Determines whether the payload argument for a given channel message is
+ * required or optional, based solely on the declared type in `TMap`.
+ *
+ * - `void | undefined` → payload is optional (second arg may be omitted).
+ * - anything else      → payload is **required** (omitting it is a compile error).
+ *
+ * This is used to build the rest-parameter tuple for `dispatch()` so that
+ * TypeScript enforces the correct call signature at every dispatch site.
+ *
+ * @template TMap A record mapping message names to their payload types.
+ * @template K    The specific message name key.
+ *
+ * @example
+ * ```ts
+ * // ActionRecord: { 'logout': void; 'add-to-cart': {productId: number} }
+ * type A = DispatchArgs<ActionRecord, 'logout'>;       // [name: 'logout', payload?: void]
+ * type B = DispatchArgs<ActionRecord, 'add-to-cart'>;  // [name: 'add-to-cart', payload: {productId: number}]
+ * ```
+ */
+export type DispatchArgs<TMap extends object, K extends keyof TMap> = TMap[K] extends void | undefined ? [name: K, payload?: TMap[K]] : [name: K, payload: TMap[K]];
+/**
+ * A single message dispatched through a `ChannelSignal`.
+ *
+ * `name` identifies the message type (e.g. `'open-drawer'`, `'add-to-cart'`).
+ * `payload` carries the associated data, whose type is determined by the generic `TMap` based on the `name`.
+ *
+ * @template TMap A record mapping message names to their payload types.
+ * @template K    The specific message name key (inferred, not set manually).
+ */
+export type ChannelMessage<TMap extends object, K extends keyof TMap = keyof TMap> = {
+    name: K;
+    payload: TMap[K];
+};
+/**
+ * A typed handler for a specific named message on a `ChannelSignal`.
+ * Receives only the `payload` — the name is already known at subscription time.
+ *
+ * The payload type mirrors `DispatchArgs`: it is `TMap[K] | undefined` only
+ * when the declared type is `void | undefined`; otherwise it is exactly `TMap[K]`
+ * (non-optional) so handlers do not need unnecessary null-guards.
+ *
+ * @template TMap A record mapping message names to their payload types.
+ * @template K    The specific message name key.
+ */
+export type ChannelHandler<TMap extends object, K extends keyof TMap = keyof TMap> = (payload: TMap[K]) => void;
+/**
+ * Configuration for creating a `ChannelSignal`.
+ */
+export interface ChannelSignalConfig extends SignalConfig {
+}
 //# sourceMappingURL=type.d.ts.map

package/dist/type.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"type.d.ts","sourceRoot":"","sources":["../src/type.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"type.d.ts","sourceRoot":"","sources":["../src/type.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alwatr/signal",
-  "version": "9.26.0",
+  "version": "9.30.0",
   "description": "Alwatr Signal is a powerful, lightweight, and modern reactive programming library. It is inspired by the best concepts from major reactive libraries but engineered to be faster and more efficient than all of them. It provides a robust and elegant way to manage application state through a system of signals, offering fine-grained reactivity, predictability, and excellent performance.",
   "license": "MPL-2.0",
   "author": "S. Ali Mihandoost <ali.mihandoost@gmail.com> (https://ali.mihandoost.com)",
@@ -22,10 +22,10 @@
   "sideEffects": false,
   "dependencies": {
     "@alwatr/debounce": "9.26.0",
-    "@alwatr/delay": "9.25.0",
-    "@alwatr/local-storage": "9.25.0",
-    "@alwatr/logger": "9.25.0",
-    "@alwatr/session-storage": "9.25.0"
+    "@alwatr/delay": "9.30.0",
+    "@alwatr/local-storage": "9.29.0",
+    "@alwatr/logger": "9.29.0",
+    "@alwatr/session-storage": "9.29.0"
   },
   "devDependencies": {
     "@alwatr/nano-build": "9.25.0",
@@ -66,5 +66,5 @@
     "signal",
     "typescript"
   ],
-  "gitHead": "ef62969b649929413c640e69d241f4e99d6062e8"
+  "gitHead": "9ef1681df17bbf7c991631d800a2d4261e54b843"
 }

package/src/core/channel-signal.ts

@@ -1,61 +1,15 @@
-import type {Awaitable} from '@alwatr/type-helper';
-import {delay} from '@alwatr/delay';
+import {queueMicrotask} from '@alwatr/delay';
 import {createLogger, type AlwatrLogger} from '@alwatr/logger';
-
 import {SignalBase} from './signal-base.js';
-
-import type {SignalConfig, SubscribeOptions, SubscribeResult, ListenerCallback} from '../type.js';
-
-// ─── Types ────────────────────────────────────────────────────────────────────
-
-/**
- * Determines whether the payload argument for a given channel message is
- * required or optional, based solely on the declared type in `TMap`.
- *
- * - `void | undefined` → payload is optional (second arg may be omitted).
- * - anything else      → payload is **required** (omitting it is a compile error).
- *
- * This is used to build the rest-parameter tuple for `dispatch()` so that
- * TypeScript enforces the correct call signature at every dispatch site.
- *
- * @template TMap A record mapping message names to their payload types.
- * @template K    The specific message name key.
- *
- * @example
- * ```ts
- * // ActionRecord: { 'logout': void; 'add-to-cart': {productId: number} }
- * type A = DispatchArgs<ActionRecord, 'logout'>;       // [name: 'logout', payload?: void]
- * type B = DispatchArgs<ActionRecord, 'add-to-cart'>;  // [name: 'add-to-cart', payload: {productId: number}]
- * ```
- */
-export type DispatchArgs<TMap extends object, K extends keyof TMap> =
-  TMap[K] extends void | undefined ? [name: K, payload?: TMap[K]] : [name: K, payload: TMap[K]];
-
-/**
- * A single message dispatched through a `ChannelSignal`.
- *
- * `name` identifies the message type (e.g. `'open-drawer'`, `'add-to-cart'`).
- * `payload` carries the associated data, whose type is determined by the generic `TMap` based on the `name`.
- *
- * @template TMap A record mapping message names to their payload types.
- * @template K    The specific message name key (inferred, not set manually).
- */
-export type ChannelMessage<TMap extends object, K extends keyof TMap = keyof TMap> = {name: K; payload: TMap[K]};
-
-/**
- * A typed handler for a specific named message on a `ChannelSignal`.
- * Receives only the `payload` — the name is already known at subscription time.
- *
- * The payload type mirrors `DispatchArgs`: it is `TMap[K] | undefined` only
- * when the declared type is `void | undefined`; otherwise it is exactly `TMap[K]`
- * (non-optional) so handlers do not need unnecessary null-guards.
- *
- * @template TMap A record mapping message names to their payload types.
- * @template K    The specific message name key.
- */
-export type ChannelHandler<TMap extends object, K extends keyof TMap = keyof TMap> = (
-  payload: TMap[K],
-) => Awaitable<void>;
+import type {
+  SubscribeOptions,
+  SubscribeResult,
+  ListenerCallback,
+  ChannelHandler,
+  ChannelMessage,
+  ChannelSignalConfig,
+  DispatchArgs,
+} from '../type.js';
 
 /**
  * Internal handler type used inside `namedHandlers__`.
@@ -68,12 +22,7 @@ export type ChannelHandler<TMap extends object, K extends keyof TMap = keyof TMa
  *
  * @internal
  */
-type InternalHandler = (payload: unknown) => Awaitable<void>;
-
-/**
- * Configuration for creating a `ChannelSignal`.
- */
-export interface ChannelSignalConfig extends SignalConfig {}
+type InternalHandler = (payload: unknown) => void;
 
 // ─── Class ────────────────────────────────────────────────────────────────────
 
@@ -124,6 +73,7 @@ export interface ChannelSignalConfig extends SignalConfig {}
 export class ChannelSignal<TMap extends object> extends SignalBase<ChannelMessage<TMap>> {
   /**
    * The logger instance for this signal.
+   *
    * @protected
    */
   protected logger_: AlwatrLogger;
@@ -143,9 +93,14 @@ export class ChannelSignal<TMap extends object> extends SignalBase<ChannelMessag
    */
   private readonly namedHandlers__ = new Map<keyof TMap, Set<{handler: InternalHandler; once: boolean}>>();
 
+  /**
+   * Creates a new ChannelSignal instance.
+   *
+   * @param config Configuration options including the unique channel name and cleanup hook.
+   */
   constructor(config: ChannelSignalConfig) {
     super(config);
-    this.logger_ = createLogger(`channel-signal:${this.name}`);
+    this.logger_ = createLogger(`channel_signal:${this.name}`);
     this.logger_.logMethod?.('constructor');
   }
 
@@ -172,6 +127,7 @@ export class ChannelSignal<TMap extends object> extends SignalBase<ChannelMessag
    * channel.dispatch('logout', undefined);            // ✅ also fine
    * ```
    *
+   * @template K The specific message name key.
    * @param args Tuple of `[name, payload]` — payload optionality is enforced
    *             by `DispatchArgs<TMap, K>` based on the declared type.
    */
@@ -179,7 +135,7 @@ export class ChannelSignal<TMap extends object> extends SignalBase<ChannelMessag
     const [name, payload] = args;
     this.logger_.logMethodArgs?.('dispatch', {name, payload});
     this.checkDestroyed_();
-    delay.nextMicrotask().then(() => this.route__(name, payload));
+    queueMicrotask(() => this.route__(name, payload));
   }
 
   /**
@@ -192,6 +148,7 @@ export class ChannelSignal<TMap extends object> extends SignalBase<ChannelMessag
    * envelope) — since the name is already known at subscription time, passing
    * it again would be redundant.
    *
+   * @template K    The specific message name key.
    * @param name    The message name to listen for.
    * @param handler Callback invoked with the payload each time the named message
    *                is dispatched.
@@ -272,6 +229,9 @@ export class ChannelSignal<TMap extends object> extends SignalBase<ChannelMessag
    * 2. Invokes each handler, removing `once` entries after their first call.
    * 3. Notifies raw-stream subscribers via `SignalBase.notify_()`.
    *
+   * @template K The specific message name key.
+   * @param name The message name to route.
+   * @param payload The payload associated with the message name.
    * @private
    */
   private route__<K extends keyof TMap>(name: K, payload: TMap[K] | undefined): void {
@@ -285,10 +245,7 @@ export class ChannelSignal<TMap extends object> extends SignalBase<ChannelMessag
           if (handlerSet.size === 0) this.namedHandlers__.delete(name);
         }
         try {
-          const result = entry.handler(payload);
-          if (result instanceof Promise) {
-            result.catch((err) => this.logger_.error('route__', 'async_named_handler_failed', err));
-          }
+          entry.handler(payload);
         } catch (err) {
           this.logger_.error('route__', 'sync_named_handler_failed', err);
         }

package/src/core/computed-signal.ts

@@ -1,9 +1,13 @@
-import { delay } from '@alwatr/delay';
-import { createLogger, type AlwatrLogger } from '@alwatr/logger';
-
-import { StateSignal } from './state-signal.js';
-
-import type { ComputedSignalConfig, IReadonlySignal, SubscribeResult, SubscribeOptions } from '../type.js';
+import {queueMicrotask} from '@alwatr/delay';
+import {createLogger, type AlwatrLogger} from '@alwatr/logger';
+import {StateSignal} from './state-signal.js';
+import type {
+  ComputedSignalConfig,
+  IReadonlySignal,
+  SubscribeOptions,
+  SubscribeResult,
+  ListenerCallback,
+} from '../type.js';
 
 /**
  * A read-only signal that derives its value from a set of dependency signals.
@@ -16,32 +20,6 @@ import type { ComputedSignalConfig, IReadonlySignal, SubscribeResult, SubscribeO
  * needed to prevent memory leaks from its subscriptions to dependency signals.
  *
  * @template T The type of the computed value.
- *
- * @example
- * // --- Create dependency signals ---
- * const firstName = new StateSignal({ name: 'firstName', initialValue: 'John' });
- * const lastName = new StateSignal({ name: 'lastName', initialValue: 'Doe' });
- *
- * // --- Create a computed signal ---
- * const fullName = new ComputedSignal({
- *   name: 'fullName',
- *   deps: [firstName, lastName],
- *   get: () => `${firstName.get()} ${lastName.get()}`,
- * });
- *
- * console.log(fullName.get()); // Outputs: "John Doe"
- *
- * // --- Subscribe to the computed value ---
- * fullName.subscribe(newFullName => {
- *   console.log(`Name changed to: ${newFullName}`);
- * });
- *
- * // --- Update a dependency ---
- * lastName.set('Smith'); // Recalculates and logs: "Name changed to: John Smith"
- * console.log(fullName.get()); // Outputs: "John Smith"
- *
- * // --- IMPORTANT: Clean up when done ---
- * fullName.destroy();
  */
 export class ComputedSignal<T> implements IReadonlySignal<T> {
   /**
@@ -51,6 +29,7 @@ export class ComputedSignal<T> implements IReadonlySignal<T> {
 
   /**
    * The logger instance for this signal.
+   *
    * @protected
    */
   protected readonly logger_: AlwatrLogger;
@@ -58,39 +37,51 @@ export class ComputedSignal<T> implements IReadonlySignal<T> {
   /**
    * The internal `StateSignal` that holds the computed value.
    * This is how the computed signal provides `.get()` and `.subscribe()` methods.
+   * Enforces COMPOSITION over inheritance.
+   *
    * @protected
    */
   protected readonly internalSignal_: StateSignal<T>;
 
   /**
    * A list of subscriptions to dependency signals.
+   * Used to unsubscribe from dependencies when this signal is destroyed.
+   *
    * @private
    */
-
   private readonly dependencySubscriptions__: SubscribeResult[] = [];
 
   /**
    * A flag to prevent concurrent recalculations.
+   * Avoids queuing multiple updates in the event loop.
+   *
    * @private
    */
   private isRecalculating__ = false;
 
+  /**
+   * Creates a new ComputedSignal instance.
+   * Subscribes to all dependency signals to trigger recalculations.
+   *
+   * @param config_ Configuration options including dependencies, evaluation getter, and cleanup hook.
+   */
   constructor(protected config_: ComputedSignalConfig<T>) {
     this.name = config_.name;
-    this.logger_ = createLogger(`computed-signal:${this.name}`);
+    this.logger_ = createLogger(`computed_signal:${this.name}`);
     this.recalculate_ = this.recalculate_.bind(this);
 
     this.logger_.logMethod?.('constructor');
 
     this.internalSignal_ = new StateSignal<T>({
-      name: `compute-${this.name}_`,
+      name: `compute_internal:${this.name}`,
       initialValue: this.config_.get(),
     });
 
     // Subscribe to all dependencies to trigger recalculation on change.
-    for (const signal of config_.deps) {
-      this.logger_.logStep?.('constructor', 'subscribing_to_dependency', { signal: signal.name });
-      this.dependencySubscriptions__.push(signal.subscribe(this.recalculate_, { receivePrevious: false }));
+    for (let i = 0; i < this.config_.deps.length; i++) {
+      const signal = this.config_.deps[i];
+      this.logger_.logStep?.('constructor', 'subscribing_to_dependency', {signal: signal.name});
+      this.dependencySubscriptions__.push(signal.subscribe(this.recalculate_, {receivePrevious: false}));
     }
   }
 
@@ -108,6 +99,7 @@ export class ComputedSignal<T> implements IReadonlySignal<T> {
   /**
    * Indicates whether the computed signal has been destroyed.
    * A destroyed signal cannot be used and will throw an error if interacted with.
+   *
    * @returns `true` if the signal is destroyed, `false` otherwise.
    */
   public get isDestroyed(): boolean {
@@ -122,7 +114,7 @@ export class ComputedSignal<T> implements IReadonlySignal<T> {
    * @param options Subscription options.
    * @returns A `SubscribeResult` object with an `unsubscribe` method.
    */
-  public subscribe(callback: (value: T) => void, options?: SubscribeOptions): SubscribeResult {
+  public subscribe(callback: ListenerCallback<T>, options?: SubscribeOptions): SubscribeResult {
     return this.internalSignal_.subscribe(callback, options);
   }
 
@@ -146,42 +138,30 @@ export class ComputedSignal<T> implements IReadonlySignal<T> {
    */
   public destroy(): void {
     this.logger_.logMethod?.('destroy');
-    /**
-     * If already destroyed, log an incident and return early.
-     */
     if (this.isDestroyed) {
       this.logger_.incident?.('destroy', 'already_destroyed');
       return;
     }
 
-    // Unsubscribe from all upstream dependencies.
-    for (const subscription of this.dependencySubscriptions__) {
-      subscription.unsubscribe();
+    for (let i = 0; i < this.dependencySubscriptions__.length; i++) {
+      this.dependencySubscriptions__[i].unsubscribe();
     }
-    this.dependencySubscriptions__.length = 0; // Clear the array of subscriptions.
+    this.dependencySubscriptions__.length = 0;
 
-    this.internalSignal_.destroy(); // Destroy the internal signal.
-    this.config_.onDestroy?.(); // Call the optional onDestroy callback.
-    this.config_ = null as unknown as ComputedSignalConfig<T>; // Release config closure.
+    this.internalSignal_.destroy();
+    this.config_.onDestroy?.();
+    this.config_ = null as unknown as ComputedSignalConfig<T>;
   }
 
   /**
-   * Schedules a recalculation of the signal's value.
+   * Recalculates the derived value.
+   * Centralized microtask batcher coordination avoids internal loop crashes.
    *
-   * This method batches updates using a macrotask (`delay.nextMacrotask`) to ensure the
-   * `get` function runs only once per event loop tick, even if multiple dependencies
-   * change in the same synchronous block of code.
    * @protected
    */
-  protected async recalculate_(): Promise<void> {
+  protected recalculate_(): void {
     this.logger_.logMethod?.('recalculate_');
 
-    if (this.internalSignal_.isDestroyed) {
-      // This check is important in case a dependency fires after this signal is destroyed.
-      this.logger_.incident?.('recalculate_', 'recalculate_on_destroyed_signal');
-      return;
-    }
-
     if (this.isRecalculating__) {
       // If a recalculation is already scheduled, do nothing.
       this.logger_.logStep?.('recalculate_', 'skipping_recalculation_already_scheduled');
@@ -190,11 +170,7 @@ export class ComputedSignal<T> implements IReadonlySignal<T> {
 
     this.isRecalculating__ = true;
 
-    try {
-      // Wait for the next macrotask to start the recalculation.
-      // This batches all synchronous dependency updates in the current event loop.
-      await delay.nextMacrotask();
-
+    queueMicrotask(() => {
       if (this.isDestroyed) {
         this.logger_.incident?.('recalculate_', 'destroyed_during_delay');
         this.isRecalculating__ = false;
@@ -202,15 +178,15 @@ export class ComputedSignal<T> implements IReadonlySignal<T> {
       }
 
       this.logger_.logStep?.('recalculate_', 'recalculating_value');
+      try {
+        // Set the new value on the internal signal, which will notify our subscribers.
+        this.internalSignal_.set(this.config_.get());
+      } catch (err) {
+        this.logger_.error('recalculate_', 'projection_evaluation_failed', err);
+      }
 
-      // Set the new value on the internal signal, which will notify our subscribers.
-      this.internalSignal_.set(this.config_.get());
-    }
-    catch (err) {
-      this.logger_.error('recalculate_', 'recalculation_failed', err);
-    }
-
-    // Allow the next recalculation to be scheduled.
-    this.isRecalculating__ = false;
+      // Allow the next recalculation to be scheduled.
+      this.isRecalculating__ = false;
+    });
   }
 }