@alwatr/signal 5.2.0 → 5.2.1

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [5.2.1](https://github.com/Alwatr/flux/compare/v5.2.0...v5.2.1) (2025-09-15)
+
+### ⚡ Performance Improvements
+
+* To improve readability and avoid calling sourceSignal.get() twice, used temporary variable before using it. ([2aaa3bd](https://github.com/Alwatr/flux/commit/2aaa3bdd06745885495ca64a71c4040b9ec57cea))
+
+### 🔨 Code Refactoring
+
+* change the `signal.value` to `signal.get()` ([fcdcb6c](https://github.com/Alwatr/flux/commit/fcdcb6caf82747b8e6d7ad846d6babead385c603))
+* rename run_ method to scheduleExecution_ for clarity in EffectSignal ([402af2f](https://github.com/Alwatr/flux/commit/402af2f7b84357ade4f79b33611d6968ec6b8efd))
+
 ## [5.2.0](https://github.com/Alwatr/flux/compare/v5.1.0...v5.2.0) (2025-09-15)
 
 ### ✨ Features

package/README.md

@@ -69,10 +69,10 @@ import {ComputedSignal} from '@alwatr/signal';
 const fullName = new ComputedSignal<string>({
   signalId: 'user-fullName',
   deps: [firstName], // This computed signal depends on firstName.
-  get: () => `User: ${firstName.value}`,
+  get: () => `User: ${firstName.get()}`,
 });
 
-console.log(fullName.value); // Outputs: "User: John"
+console.log(fullName.get()); // Outputs: "User: John"
 ```
 
 ### 4. Create an Effect Signal
@@ -85,7 +85,7 @@ import {EffectSignal} from '@alwatr/signal';
 const loggerEffect = new EffectSignal({
   deps: [fullName, counter], // This effect depends on fullName and counter.
   run: () => {
-    console.log(`${fullName.value} has clicked ${counter.value} times.`);
+    console.log(`${fullName.get()} has clicked ${counter.get()} times.`);
   },
 });
 ```
@@ -134,7 +134,7 @@ Signals that depend on other signals (like `ComputedSignal` and `EffectSignal`)
 // Create a computed signal
 const isEven = new ComputedSignal({
   deps: [counter],
-  get: () => counter.value % 2 === 0,
+  get: () => counter.get() % 2 === 0,
 });
 
 // ... use it for a while ...
@@ -167,7 +167,7 @@ The `subscribe` method accepts an optional second argument to customize its beha
 - **`constructor(config)`**: Creates a new state signal.
   - `config.signalId`: `string`
   - `config.initialValue`: `T`
-- **`.value`**: `T` - Gets the current value.
+- **`.get()`**: `T` - Gets the current value.
 - **`.set(newValue: T)`**: Sets a new value and notifies listeners.
 
 ### `ComputedSignal<T>`
@@ -176,7 +176,7 @@ The `subscribe` method accepts an optional second argument to customize its beha
   - `config.signalId`: `string`
   - `config.deps`: `IReadonlySignal<unknown>[]` - Array of dependency signals.
   - `config.get`: `() => T` - The function to compute the value.
-- **`.value`**: `T` - Gets the current (memoized) value.
+- **`.get()`**: `T` - Gets the current (memoized) value.
 - **`.destroy()`**: Cleans up the signal's subscriptions. **(Important!)**
 
 ### `EffectSignal`
@@ -284,10 +284,10 @@ import {ComputedSignal} from '@alwatr/signal';
 const fullName = new ComputedSignal<string>({
   signalId: 'user-fullName',
   deps: [firstName], // این سیگنال محاسباتی به firstName وابسته است
-  get: () => `User: ${firstName.value}`,
+  get: () => `User: ${firstName.get()}`,
 });
 
-console.log(fullName.value); // خروجی: "User: John"
+console.log(fullName.get()); // خروجی: "User: John"
 ```
 
 ### ۴. ایجاد `EffectSignal`
@@ -300,7 +300,7 @@ import {EffectSignal} from '@alwatr/signal';
 const loggerEffect = new EffectSignal({
   deps: [fullName, counter], // این افکت به fullName و counter وابسته است
   run: () => {
-    console.log(`${fullName.value} has clicked ${counter.value} times.`);
+    console.log(`${fullName.get()} has clicked ${counter.get()} times.`);
   },
 });
 ```
@@ -349,7 +349,7 @@ User: Jane has clicked 1 times.
 // یک سیگنال محاسباتی ایجاد کنید
 const isEven = new ComputedSignal({
   deps: [counter],
-  get: () => counter.value % 2 === 0,
+  get: () => counter.get() % 2 === 0,
 });
 
 // ... مدتی از آن استفاده کنید ...
@@ -382,7 +382,7 @@ Alwatr Signal از یک مدل ناهمزمان قابل پیش‌بینی بر
 - **`constructor(config)`**: یک سیگنال وضعیت جدید ایجاد می‌کند.
   - `config.signalId`: `string`
   - `config.initialValue`: `T`
-- **`.value`**: `T` - مقدار فعلی را دریافت می‌کند.
+- **`.get()`**: `T` - مقدار فعلی را دریافت می‌کند.
 - **`.set(newValue: T)`**: مقدار جدیدی را تنظیم کرده و شنوندگان را مطلع می‌کند.
 
 ### `ComputedSignal<T>`
@@ -391,7 +391,7 @@ Alwatr Signal از یک مدل ناهمزمان قابل پیش‌بینی بر
   - `config.signalId`: `string`
   - `config.deps`: `IReadonlySignal<unknown>[]` - آرایه‌ای از سیگنال‌های وابسته.
   - `config.get`: `() => T` - تابعی برای محاسبه مقدار.
-- **`.value`**: `T` - مقدار فعلی (کش شده) را دریافت می‌کند.
+- **`.get()`**: `T` - مقدار فعلی (کش شده) را دریافت می‌کند.
 - **`.destroy()`**: اشتراک‌های سیگنال را پاک‌سازی می‌کند. **(مهم!)**
 
 ### `EffectSignal`

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

@@ -21,10 +21,10 @@ import type { ComputedSignalConfig, IReadonlySignal, SubscribeResult, SubscribeO
  * const fullName = new ComputedSignal({
  *   signalId: 'fullName',
  *   deps: [firstName, lastName],
- *   get: () => `${firstName.value} ${lastName.value}`,
+ *   get: () => `${firstName.get()} ${lastName.get()}`,
  * });
  *
- * console.log(fullName.value); // Outputs: "John Doe"
+ * console.log(fullName.get()); // Outputs: "John Doe"
  *
  * // --- Subscribe to the computed value ---
  * fullName.subscribe(newFullName => {
@@ -33,7 +33,7 @@ import type { ComputedSignalConfig, IReadonlySignal, SubscribeResult, SubscribeO
  *
  * // --- Update a dependency ---
  * lastName.set('Smith'); // Recalculates and logs: "Name changed to: John Smith"
- * console.log(fullName.value); // Outputs: "John Smith"
+ * console.log(fullName.get()); // Outputs: "John Smith"
  *
  * // --- IMPORTANT: Clean up when done ---
  * fullName.destroy();
@@ -51,7 +51,7 @@ export declare class ComputedSignal<T> implements IReadonlySignal<T> {
     protected readonly logger_: import("@alwatr/logger").AlwatrLogger;
     /**
      * The internal `StateSignal` that holds the computed value.
-     * This is how the computed signal provides `.value` and `.subscribe()` methods.
+     * This is how the computed signal provides `.get()` and `.subscribe()` methods.
      * @protected
      */
     protected readonly internalSignal_: StateSignal<T>;
@@ -73,7 +73,7 @@ export declare class ComputedSignal<T> implements IReadonlySignal<T> {
      * @returns The current computed value.
      * @throws {Error} If accessed after the signal has been destroyed.
      */
-    get value(): T;
+    get(): T;
     /**
      * Indicates whether the computed signal has been destroyed.
      * A destroyed signal cannot be used and will throw an error if interacted with.
@@ -102,7 +102,7 @@ export declare class ComputedSignal<T> implements IReadonlySignal<T> {
      * stopping future recalculations and allowing the signal to be garbage collected.
      * Failure to call `destroy()` will result in memory leaks.
      *
-     * After `destroy()` is called, any attempt to access `.value` or `.subscribe()` will throw an error.
+     * After `destroy()` is called, any attempt to access `.get()` or `.subscribe()` will throw an error.
      */
     destroy(): void;
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"computed-signal.d.ts","sourceRoot":"","sources":["../../src/core/computed-signal.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,WAAW,EAAC,MAAM,mBAAmB,CAAC;AAE9C,OAAO,KAAK,EAAC,oBAAoB,EAAE,eAAe,EAAE,eAAe,EAAE,gBAAgB,EAAC,MAAM,YAAY,CAAC;AAEzG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,qBAAa,cAAc,CAAC,CAAC,CAAE,YAAW,eAAe,CAAC,CAAC,CAAC;IAmCvC,SAAS,CAAC,OAAO,EAAE,oBAAoB,CAAC,CAAC,CAAC;IAlC7D;;OAEG;IACH,SAAgB,QAAQ,SAAyB;IAEjD;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,OAAO,wCAAqD;IAE/E;;;;OAIG;IACH,SAAS,CAAC,QAAQ,CAAC,eAAe,iBAG/B;IAEH;;;OAGG;IAEH,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAAyB;IAEnE;;;OAGG;IACH,OAAO,CAAC,iBAAiB,CAAS;gBAEL,OAAO,EAAE,oBAAoB,CAAC,CAAC,CAAC;IAU7D;;;;;;OAMG;IACH,IAAW,KAAK,IAAI,CAAC,CAEpB;IAED;;;;OAIG;IACH,IAAW,WAAW,IAAI,OAAO,CAEhC;IAED;;;;;;;OAOG;IACI,SAAS,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,eAAe;IAI3F;;;;OAIG;IACI,SAAS,IAAI,OAAO,CAAC,CAAC,CAAC;IAI9B;;;;;;;;OAQG;IACI,OAAO,IAAI,IAAI;IAqBtB;;;;;;;OAOG;cACa,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;CAwC9C"}
+{"version":3,"file":"computed-signal.d.ts","sourceRoot":"","sources":["../../src/core/computed-signal.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,WAAW,EAAC,MAAM,mBAAmB,CAAC;AAE9C,OAAO,KAAK,EAAC,oBAAoB,EAAE,eAAe,EAAE,eAAe,EAAE,gBAAgB,EAAC,MAAM,YAAY,CAAC;AAEzG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,qBAAa,cAAc,CAAC,CAAC,CAAE,YAAW,eAAe,CAAC,CAAC,CAAC;IAmCvC,SAAS,CAAC,OAAO,EAAE,oBAAoB,CAAC,CAAC,CAAC;IAlC7D;;OAEG;IACH,SAAgB,QAAQ,SAAyB;IAEjD;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,OAAO,wCAAqD;IAE/E;;;;OAIG;IACH,SAAS,CAAC,QAAQ,CAAC,eAAe,iBAG/B;IAEH;;;OAGG;IAEH,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAAyB;IAEnE;;;OAGG;IACH,OAAO,CAAC,iBAAiB,CAAS;gBAEL,OAAO,EAAE,oBAAoB,CAAC,CAAC,CAAC;IAU7D;;;;;;OAMG;IACI,GAAG,IAAI,CAAC;IAIf;;;;OAIG;IACH,IAAW,WAAW,IAAI,OAAO,CAEhC;IAED;;;;;;;OAOG;IACI,SAAS,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,eAAe;IAI3F;;;;OAIG;IACI,SAAS,IAAI,OAAO,CAAC,CAAC,CAAC;IAI9B;;;;;;;;OAQG;IACI,OAAO,IAAI,IAAI;IAqBtB;;;;;;;OAOG;cACa,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;CAwC9C"}

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

@@ -22,7 +22,7 @@ import type { EffectSignalConfig, IEffectSignal } from '../type.js';
  *   signalId: 'analytics-effect',
  *   deps: [counter, user],
  *   run: () => {
- *     console.log(`Analytics: User '${user.value}' clicked ${counter.value} times.`);
+ *     console.log(`Analytics: User '${user.get()}' clicked ${counter.get()} times.`);
  *   },
  *   runImmediately: true, // Optional: run once on creation
  * });
@@ -80,7 +80,7 @@ export declare class EffectSignal implements IEffectSignal {
      * dependencies change simultaneously.
      * @protected
      */
-    protected run_(): Promise<void>;
+    protected scheduleExecution_(): Promise<void>;
     /**
      * Permanently disposes of the effect signal.
      *

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

@@ -1 +1 @@
-{"version":3,"file":"effect-signal.d.ts","sourceRoot":"","sources":["../../src/core/effect-signal.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,kBAAkB,EAAE,aAAa,EAAkB,MAAM,YAAY,CAAC;AAEnF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,qBAAa,YAAa,YAAW,aAAa;IAwC7B,SAAS,CAAC,OAAO,EAAE,kBAAkB;IAvCxD;;OAEG;IACH,SAAgB,QAAQ,SAAkH;IAE1I;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,OAAO,wCAAmD;IAE7E;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAAyB;IAEnE;;;OAGG;IACH,OAAO,CAAC,WAAW,CAAS;IAE5B;;;OAGG;IACH,OAAO,CAAC,aAAa,CAAS;IAE9B;;;;;OAKG;IACH,IAAW,WAAW,IAAI,OAAO,CAEhC;gBAE4B,OAAO,EAAE,kBAAkB;IAiBxD;;;;;;;OAOG;cACa,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAmCrC;;;;;;OAMG;IACI,OAAO,IAAI,IAAI;CAmBvB"}
+{"version":3,"file":"effect-signal.d.ts","sourceRoot":"","sources":["../../src/core/effect-signal.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,kBAAkB,EAAE,aAAa,EAAkB,MAAM,YAAY,CAAC;AAEnF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,qBAAa,YAAa,YAAW,aAAa;IAwC7B,SAAS,CAAC,OAAO,EAAE,kBAAkB;IAvCxD;;OAEG;IACH,SAAgB,QAAQ,SAAkH;IAE1I;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,OAAO,wCAAmD;IAE7E;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAAyB;IAEnE;;;OAGG;IACH,OAAO,CAAC,WAAW,CAAS;IAE5B;;;OAGG;IACH,OAAO,CAAC,aAAa,CAAS;IAE9B;;;;;OAKG;IACH,IAAW,WAAW,IAAI,OAAO,CAEhC;gBAE4B,OAAO,EAAE,kBAAkB;IAiBxD;;;;;;;OAOG;cACa,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC;IAmCnD;;;;;;OAMG;IACI,OAAO,IAAI,IAAI;CAmBvB"}

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

@@ -17,7 +17,7 @@ import type { StateSignalConfig, ListenerCallback, SubscribeOptions, SubscribeRe
  * });
  *
  * // Get the current value.
- * console.log(counter.value); // Outputs: 0
+ * console.log(counter.get()); // Outputs: 0
  *
  * // Subscribe to changes.
  * const subscription = counter.subscribe(newValue => {
@@ -51,9 +51,9 @@ export declare class StateSignal<T> extends SignalBase<T> implements IReadonlySi
      * @returns The current value.
      *
      * @example
-     * console.log(mySignal.value);
+     * console.log(mySignal.get());
      */
-    get value(): T;
+    get(): T;
     /**
      * Updates the signal's value and notifies all active listeners.
      *
@@ -67,7 +67,7 @@ export declare class StateSignal<T> extends SignalBase<T> implements IReadonlySi
      * mySignal.set(42);
      *
      * // For object types, it's best practice to set an immutable new object.
-     * mySignal.set({ ...mySignal.value, property: 'new-value' });
+     * mySignal.set({ ...mySignal.get(), property: 'new-value' });
      */
     set(newValue: T): void;
     /**

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":"AAGA,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,wCAAkD;gBAEhD,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC;IAM/C;;;;;;;OAOG;IACH,IAAW,KAAK,IAAI,CAAC,CAGpB;IAED;;;;;;;;;;;;;;OAcG;IACI,GAAG,CAAC,QAAQ,EAAE,CAAC,GAAG,IAAI;IAe7B;;;;;;;;;;;;;;OAcG;IACI,MAAM,CAAC,OAAO,EAAE,CAAC,aAAa,EAAE,CAAC,KAAK,CAAC,GAAG,IAAI;IAQrD;;;;;;;;;OASG;IACa,SAAS,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAAE,OAAO,GAAE,gBAAqB,GAAG,eAAe;IAwBzG;;;OAGG;IACa,OAAO,IAAI,IAAI;CAIhC"}
+{"version":3,"file":"state-signal.d.ts","sourceRoot":"","sources":["../../src/core/state-signal.ts"],"names":[],"mappings":"AAGA,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,wCAAkD;gBAEhD,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC;IAM/C;;;;;;;OAOG;IACI,GAAG,IAAI,CAAC;IAKf;;;;;;;;;;;;;;OAcG;IACI,GAAG,CAAC,QAAQ,EAAE,CAAC,GAAG,IAAI;IAe7B;;;;;;;;;;;;;;OAcG;IACI,MAAM,CAAC,OAAO,EAAE,CAAC,aAAa,EAAE,CAAC,KAAK,CAAC,GAAG,IAAI;IAQrD;;;;;;;;;OASG;IACa,SAAS,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAAE,OAAO,GAAE,gBAAqB,GAAG,eAAe;IAwBzG;;;OAGG;IACa,OAAO,IAAI,IAAI;CAIhC"}

package/dist/creators/computed.d.ts

@@ -22,10 +22,10 @@ import type { ComputedSignalConfig } from '../type.js';
  * const fullName = createComputedSignal({
  *   signalId: 'fullName',
  *   deps: [firstName, lastName],
- *   get: () => `${firstName.value} ${lastName.value}`,
+ *   get: () => `${firstName.get()} ${lastName.get()}`,
  * });
  *
- * console.log(fullName.value); // "John Doe"
+ * console.log(fullName.get()); // "John Doe"
  *
  * // IMPORTANT: Always destroy a computed signal when no longer needed.
  * // fullName.destroy();

package/dist/creators/effect.d.ts

@@ -23,7 +23,7 @@ import type { EffectSignalConfig } from '../type.js';
  * const analyticsEffect = createEffect({
  *   deps: [counter, user],
  *   run: () => {
- *     console.log(`Analytics: User '${user.value}' clicked ${counter.value} times.`);
+ *     console.log(`Analytics: User '${user.get()}' clicked ${counter.get()} times.`);
  *   },
  *   runImmediately: true, // Optional: run once on creation
  * });

package/dist/creators/state.d.ts

@@ -17,9 +17,9 @@ import type { StateSignalConfig } from '../type.js';
  *   initialValue: 0,
  * });
  *
- * console.log(counter.value); // Outputs: 0
+ * console.log(counter.get()); // Outputs: 0
  * counter.set(1);
- * console.log(counter.value); // Outputs: 1
+ * console.log(counter.get()); // Outputs: 1
  */
 export declare function createStateSignal<T>(config: StateSignalConfig<T>): StateSignal<T>;
 //# sourceMappingURL=state.d.ts.map

package/dist/main.cjs

@@ -1,4 +1,4 @@
-/* @alwatr/signal v5.2.0 */
+/* @alwatr/signal v5.2.1 */
 "use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -236,9 +236,9 @@ var StateSignal = class extends SignalBase {
    * @returns The current value.
    *
    * @example
-   * console.log(mySignal.value);
+   * console.log(mySignal.get());
    */
-  get value() {
+  get() {
     this.checkDestroyed_();
     return this.value__;
   }
@@ -255,7 +255,7 @@ var StateSignal = class extends SignalBase {
    * mySignal.set(42);
    *
    * // For object types, it's best practice to set an immutable new object.
-   * mySignal.set({ ...mySignal.value, property: 'new-value' });
+   * mySignal.set({ ...mySignal.get(), property: 'new-value' });
    */
   set(newValue) {
     this.logger_.logMethodArgs?.("set", { newValue });
@@ -335,7 +335,7 @@ var ComputedSignal = class {
     this.logger_ = (0, import_logger3.createLogger)(`computed-signal: ${this.signalId}`);
     /**
      * The internal `StateSignal` that holds the computed value.
-     * This is how the computed signal provides `.value` and `.subscribe()` methods.
+     * This is how the computed signal provides `.get()` and `.subscribe()` methods.
      * @protected
      */
     this.internalSignal_ = new StateSignal({
@@ -365,8 +365,8 @@ var ComputedSignal = class {
    * @returns The current computed value.
    * @throws {Error} If accessed after the signal has been destroyed.
    */
-  get value() {
-    return this.internalSignal_.value;
+  get() {
+    return this.internalSignal_.get();
   }
   /**
    * Indicates whether the computed signal has been destroyed.
@@ -402,7 +402,7 @@ var ComputedSignal = class {
    * stopping future recalculations and allowing the signal to be garbage collected.
    * Failure to call `destroy()` will result in memory leaks.
    *
-   * After `destroy()` is called, any attempt to access `.value` or `.subscribe()` will throw an error.
+   * After `destroy()` is called, any attempt to access `.get()` or `.subscribe()` will throw an error.
    */
   destroy() {
     this.logger_.logMethod?.("destroy");
@@ -484,12 +484,12 @@ var EffectSignal = class {
      */
     this.isDestroyed__ = false;
     this.logger_.logMethod?.("constructor");
-    this.run_ = this.run_.bind(this);
+    this.scheduleExecution_ = this.scheduleExecution_.bind(this);
     for (const signal of config_.deps) {
-      this.dependencySubscriptions__.push(signal.subscribe(this.run_, { receivePrevious: false }));
+      this.dependencySubscriptions__.push(signal.subscribe(this.scheduleExecution_, { receivePrevious: false }));
     }
     if (config_.runImmediately === true) {
-      void this.run_();
+      void this.scheduleExecution_();
     }
   }
   /**
@@ -509,28 +509,28 @@ var EffectSignal = class {
    * dependencies change simultaneously.
    * @protected
    */
-  async run_() {
-    this.logger_.logMethod?.("run_");
+  async scheduleExecution_() {
+    this.logger_.logMethod?.("scheduleExecution_");
     if (this.isDestroyed__) {
-      this.logger_.incident?.("run_", "run_on_destroyed_signal");
+      this.logger_.incident?.("scheduleExecution_", "schedule_execution_on_destroyed_signal");
       return;
     }
     if (this.isRunning__) {
-      this.logger_.logStep?.("run_", "skipped_because_already_running");
+      this.logger_.logStep?.("scheduleExecution_", "skipped_because_already_running");
       return;
     }
     this.isRunning__ = true;
     try {
       await import_delay4.delay.nextMacrotask();
       if (this.isDestroyed__) {
-        this.logger_.incident?.("run_", "destroyed_during_delay");
+        this.logger_.incident?.("scheduleExecution_", "destroyed_during_delay");
         this.isRunning__ = false;
         return;
       }
-      this.logger_.logStep?.("run_", "executing_effect");
+      this.logger_.logStep?.("scheduleExecution_", "executing_effect");
       await this.config_.run();
     } catch (err) {
-      this.logger_.error("run_", "effect_failed", err);
+      this.logger_.error("scheduleExecution_", "effect_failed", err);
     }
     this.isRunning__ = false;
   }
@@ -583,7 +583,7 @@ function createDebouncedSignal(sourceSignal, config) {
   const signalId = config.signalId ?? `${sourceSignal.signalId}-debounced`;
   const internalSignal = new StateSignal({
     signalId: `${signalId}-internal`,
-    initialValue: sourceSignal.value
+    initialValue: sourceSignal.get()
   });
   const debouncer = (0, import_debounce.createDebouncer)({
     ...config,
@@ -595,7 +595,7 @@ function createDebouncedSignal(sourceSignal, config) {
   return createComputedSignal({
     signalId,
     deps: [internalSignal],
-    get: () => internalSignal.value,
+    get: () => internalSignal.get(),
     onDestroy: () => {
       if (internalSignal.isDestroyed) return;
       subscription.unsubscribe();

package/dist/main.cjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/main.ts", "../src/core/signal-base.ts", "../src/core/event-signal.ts", "../src/core/state-signal.ts", "../src/core/computed-signal.ts", "../src/core/effect-signal.ts", "../src/creators/event.ts", "../src/creators/state.ts", "../src/creators/computed.ts", "../src/creators/effect.ts", "../src/operators/debounce.ts"],
-  "sourcesContent": ["export * from './core/signal-base.js';\nexport * from './core/event-signal.js';\nexport * from './core/state-signal.js';\nexport * from './core/computed-signal.js';\nexport * from './core/effect-signal.js';\n\nexport * from './creators/event.js';\nexport * from './creators/state.js';\nexport * from './creators/computed.js';\nexport * from './creators/effect.js';\n\nexport * from './operators/debounce.js';\n\nexport type * from './type.js';\n", "import type {Observer_, SubscribeOptions, SubscribeResult, ListenerCallback, SignalConfig} from '../type.js';\nimport type {AlwatrLogger} from '@alwatr/logger';\nimport type {} from '@alwatr/nano-build';\n\n/**\n * An abstract base class for signal implementations.\n * It provides the core functionality for managing subscriptions (observers).\n *\n * @template T The type of data that the signal holds or dispatches.\n */\nexport abstract class SignalBase<T> {\n  /**\n   * The unique identifier for this signal instance.\n   * Useful for debugging and logging.\n   */\n  public readonly signalId = this.config_.signalId;\n\n  /**\n   * The logger instance for this signal.\n   * @protected\n   */\n  protected abstract logger_: AlwatrLogger;\n\n  /**\n   * The list of observers (listeners) subscribed to this signal.\n   * @protected\n   */\n  protected readonly observers_: Observer_<T>[] = [];\n\n  /**\n   * A flag indicating whether the signal has been destroyed.\n   * @private\n   */\n  private isDestroyed__ = false;\n\n  /**\n   * Indicates whether the signal has been destroyed.\n   * A destroyed signal cannot be used and will throw an error if interacted with.\n   *\n   * @returns `true` if the signal is destroyed, `false` otherwise.\n   */\n  public get isDestroyed(): boolean {\n    return this.isDestroyed__;\n  }\n\n  public constructor(protected config_: SignalConfig) {}\n\n  /**\n   * Removes a specific observer from the observers list.\n   *\n   * @param observer The observer instance to remove.\n   * @protected\n   */\n  protected removeObserver_(observer: Observer_<T>): void {\n    this.logger_.logMethod?.('removeObserver_');\n\n    if (this.isDestroyed__) {\n      this.logger_.incident?.('removeObserver_', 'remove_observer_on_destroyed_signal');\n      return;\n    }\n\n    const index = this.observers_.indexOf(observer);\n    if (index !== -1) {\n      this.observers_.splice(index, 1);\n    }\n  }\n\n  /**\n   * Subscribes a listener function to this signal.\n   *\n   * The listener will be called whenever the signal is notified (e.g., when `dispatch` or `set` is called).\n   *\n   * @param callback The function to be called when the signal is dispatched.\n   * @param options Subscription options to customize the behavior (e.g., `once`, `priority`).\n   * @returns A `SubscribeResult` object with an `unsubscribe` method to remove the listener.\n   */\n  public subscribe(callback: ListenerCallback<T>, options?: SubscribeOptions): SubscribeResult {\n    this.logger_.logMethodArgs?.('subscribe.base', {options});\n    this.checkDestroyed_();\n\n    const observer: Observer_<T> = {callback, options};\n\n    if (options?.priority) {\n      // High-priority observers are added to the front of the queue.\n      this.observers_.unshift(observer);\n    }\n    else {\n      this.observers_.push(observer);\n    }\n\n    // The returned unsubscribe function is a closure that calls the internal removal method.\n    return {\n      unsubscribe: (): void => this.removeObserver_(observer),\n    };\n  }\n\n  /**\n   * Notifies all registered observers about a new value.\n   *\n   * This method iterates through a snapshot of the current observers to prevent issues\n   * with subscriptions changing during notification (e.g., an observer unsubscribing itself).\n   *\n   * @param value The new value to notify observers about.\n   * @protected\n   */\n  protected notify_(value: T): void {\n    this.logger_.logMethodArgs?.('notify_', value);\n\n    if (this.isDestroyed__) {\n      this.logger_.incident?.('notify_', 'notify_on_destroyed_signal');\n      return;\n    }\n\n    // Create a snapshot of the observers array to iterate over.\n    // This prevents issues if the observers_ array is modified during the loop.\n    const currentObservers = [...this.observers_];\n\n    for (const observer of currentObservers) {\n      if (observer.options?.once) {\n        this.removeObserver_(observer);\n      }\n\n      try {\n        const result = observer.callback(value);\n        if (result instanceof Promise) {\n          result.catch((err) => this.logger_.error('notify_', 'async_callback_failed', err, {observer}));\n        }\n      }\n      catch (err) {\n        this.logger_.error('notify_', 'sync_callback_failed', err);\n      }\n    }\n  }\n\n  /**\n   * Returns a Promise that resolves with the next value dispatched by the signal.\n   * This provides an elegant way to wait for a single, future event using `async/await`.\n   *\n   * @returns A Promise that resolves with the next dispatched value.\n   *\n   * @example\n   * async function onButtonClick() {\n   *   console.log('Waiting for the next signal...');\n   *   const nextValue = await mySignal.untilNext();\n   *   console.log('Signal received:', nextValue);\n   * }\n   */\n  public untilNext(): Promise<T> {\n    this.logger_.logMethod?.('untilNext');\n    this.checkDestroyed_();\n    return new Promise((resolve) => {\n      this.subscribe(resolve, {\n        once: true,\n        priority: true, // Resolve the promise before other listeners are called.\n        receivePrevious: false, // We only want the *next* value, not the current one.\n      });\n    });\n  }\n\n  /**\n   * Destroys the signal, clearing all its listeners and making it inactive.\n   *\n   * After destruction, any interaction with the signal (like `subscribe` or `untilNext`)\n   * will throw an error. This is crucial for preventing memory leaks by allowing\n   * garbage collection of the signal and its observers.\n   */\n  public destroy(): void {\n    this.logger_.logMethod?.('destroy');\n    if (this.isDestroyed__) {\n      this.logger_.incident?.('destroy_', 'double_destroy_attempt');\n      return;\n    }\n    this.isDestroyed__ = true;\n    this.observers_.length = 0; // Clear all observers.\n    this.config_.onDestroy?.(); // Call the optional onDestroy callback.\n    this.config_ = null as unknown as SignalConfig; // Help GC by breaking references.\n  }\n\n  /**\n   * Throws an error if the signal has been destroyed.\n   * This is a safeguard to prevent interaction with a defunct signal.\n   * @protected\n   */\n  protected checkDestroyed_(): void {\n    if (this.isDestroyed__) {\n      this.logger_.accident('checkDestroyed_', 'attempt_to_use_destroyed_signal');\n      throw new Error(`Cannot interact with a destroyed signal (id: ${this.signalId})`);\n    }\n  }\n}\n", "import {delay} from '@alwatr/delay';\nimport {createLogger} from '@alwatr/logger';\n\nimport {SignalBase} from './signal-base.js';\n\nimport type {SignalConfig} from '../type.js';\n\n/**\n * A stateless signal for dispatching transient events.\n *\n * `EventSignal` is ideal for broadcasting events that do not have a persistent state.\n * Unlike `StateSignal`, it does not hold a value. Listeners are only notified of new\n * events as they are dispatched. This makes it suitable for modeling user interactions,\n * system notifications, or any one-off message.\n *\n * @template T The type of the payload for the events. Defaults to `void` for events without a payload.\n *\n * @example\n * // Create a signal for user click events.\n * const onUserClick = new EventSignal<{ x: number, y: number }>({ signalId: 'on-user-click' });\n *\n * // Subscribe to the event.\n * onUserClick.subscribe(clickPosition => {\n *   console.log(`User clicked at: ${clickPosition.x}, ${clickPosition.y}`);\n * });\n *\n * // Dispatch an event.\n * onUserClick.dispatch({ x: 100, y: 250 }); // Notifies the listener.\n *\n * // --- Example with no payload ---\n * const onAppReady = new EventSignal({ signalId: 'on-app-ready' });\n * onAppReady.subscribe(() => console.log('Application is ready!'));\n * onAppReady.dispatch(); // Notifies the listener.\n */\nexport class EventSignal<T = void> extends SignalBase<T> {\n  /**\n   * The logger instance for this signal.\n   * @protected\n   */\n  protected logger_ = createLogger(`event-signal: ${this.signalId}`);\n\n  public constructor(config: SignalConfig) {\n    super(config);\n    this.logger_.logMethod?.('constructor');\n  }\n\n  /**\n   * Dispatches an event with an optional payload to all active listeners.\n   * The notification is scheduled as a microtask to prevent blocking and ensure\n   * a consistent, non-blocking flow.\n   *\n   * @param payload The data to send with the event.\n   */\n  public dispatch(payload: T): void {\n    this.logger_.logMethodArgs?.('dispatch', {payload});\n    this.checkDestroyed_();\n    // Dispatch as a microtask to ensure consistent, non-blocking behavior.\n    delay.nextMicrotask().then(() => this.notify_(payload));\n  }\n}\n", "import {delay} from '@alwatr/delay';\nimport {createLogger} from '@alwatr/logger';\n\nimport {SignalBase} from './signal-base.js';\n\nimport type {StateSignalConfig, ListenerCallback, SubscribeOptions, SubscribeResult, IReadonlySignal} from '../type.js';\n\n/**\n * A stateful signal that holds a value and notifies listeners when the value changes.\n *\n * `StateSignal` is the core of the signal library, representing a piece of mutable state.\n * It always has a value, and new subscribers immediately receive the current value by default.\n *\n * @template T The type of the state it holds.\n * @implements {IReadonlySignal<T>}\n *\n * @example\n * // Create a new state signal with an initial value.\n * const counter = new StateSignal<number>({\n *   signalId: 'counter-signal',\n *   initialValue: 0,\n * });\n *\n * // Get the current value.\n * console.log(counter.value); // Outputs: 0\n *\n * // Subscribe to changes.\n * const subscription = counter.subscribe(newValue => {\n *   console.log(`Counter changed to: ${newValue}`);\n * });\n *\n * // Set a new value, which triggers the notification.\n * counter.set(1); // Outputs: \"Counter changed to: 1\"\n *\n * // Update value based on the previous value.\n * counter.update(current => current + 1); // Outputs: \"Counter changed to: 2\"\n *\n * // Unsubscribe when no longer needed.\n * subscription.unsubscribe();\n */\nexport class StateSignal<T> extends SignalBase<T> implements IReadonlySignal<T> {\n  /**\n   * The current value of the signal.\n   * @private\n   */\n  private value__: T;\n\n  /**\n   * The logger instance for this signal.\n   * @protected\n   */\n  protected logger_ = createLogger(`state-signal: ${this.signalId}`);\n\n  public constructor(config: StateSignalConfig<T>) {\n    super(config);\n    this.value__ = config.initialValue;\n    this.logger_.logMethodArgs?.('constructor', {initialValue: this.value__});\n  }\n\n  /**\n   * Retrieves the current value of the signal.\n   *\n   * @returns The current value.\n   *\n   * @example\n   * console.log(mySignal.value);\n   */\n  public get value(): T {\n    this.checkDestroyed_();\n    return this.value__;\n  }\n\n  /**\n   * Updates the signal's value and notifies all active listeners.\n   *\n   * The notification is scheduled as a microtask, which means the update is deferred\n   * slightly to batch multiple synchronous changes.\n   *\n   * @param newValue The new value to set.\n   *\n   * @example\n   * // For primitive types\n   * mySignal.set(42);\n   *\n   * // For object types, it's best practice to set an immutable new object.\n   * mySignal.set({ ...mySignal.value, property: 'new-value' });\n   */\n  public set(newValue: T): void {\n    this.logger_.logMethodArgs?.('set', {newValue});\n    this.checkDestroyed_();\n\n    // For primitives (including null), do not notify if the value is the same.\n    if (Object.is(this.value__, newValue) && (typeof newValue !== 'object' || newValue === null)) {\n      return;\n    }\n\n    this.value__ = newValue;\n\n    // Dispatch as a microtask to ensure consistent, non-blocking behavior.\n    delay.nextMicrotask().then(() => this.notify_(newValue));\n  }\n\n  /**\n   * Updates the signal's value based on its previous value.\n   *\n   * This method is particularly useful for state transitions that depend on the current value,\n   * especially for objects or arrays, as it promotes an immutable update pattern.\n   *\n   * @param updater A function that receives the current value and returns the new value.\n   *\n   * @example\n   * // For a counter\n   * counterSignal.update(current => current + 1);\n   *\n   * // For an object state\n   * userSignal.update(currentUser => ({ ...currentUser, loggedIn: true }));\n   */\n  public update(updater: (previousValue: T) => T): void {\n    this.logger_.logMethod?.('update');\n    this.checkDestroyed_();\n    // The updater function is called with the current value to compute the new value,\n    // which is then passed to the `set` method.\n    this.set(updater(this.value__));\n  }\n\n  /**\n   * Subscribes a listener to this signal.\n   *\n   * By default, the listener is immediately called with the signal's current value (`receivePrevious: true`).\n   * This behavior can be customized via the `options` parameter.\n   *\n   * @param callback The function to be called when the signal's value changes.\n   * @param options Subscription options, including `receivePrevious` and `once`.\n   * @returns An object with an `unsubscribe` method to remove the listener.\n   */\n  public override subscribe(callback: ListenerCallback<T>, options: SubscribeOptions = {}): SubscribeResult {\n    this.logger_.logMethodArgs?.('subscribe', {options});\n    this.checkDestroyed_();\n\n    // By default, new subscribers to a StateSignal should receive the current value.\n    if (options.receivePrevious !== false) {\n      // Immediately (but asynchronously) call the listener with the current value.\n      // This is done in a microtask to ensure it happens after the subscription is fully registered.\n      delay\n        .nextMicrotask()\n        .then(() => callback(this.value__))\n        .catch((err) => this.logger_.error('subscribe', 'immediate_callback_failed', err));\n\n      // If it's a 'once' subscription that receives the previous value, it's now fulfilled.\n      // We don't need to add it to the observers list for future updates.\n      if (options.once) {\n        // eslint-disable-next-line @typescript-eslint/no-empty-function\n        return {unsubscribe: () => {}};\n      }\n    }\n\n    return super.subscribe(callback, options);\n  }\n\n  /**\n   * Destroys the signal, clearing its value and all listeners.\n   * This is crucial for memory management to prevent leaks.\n   */\n  public override destroy(): void {\n    this.value__ = null as T; // Clear the value to allow for garbage collection.\n    super.destroy();\n  }\n}\n", "import {delay} from '@alwatr/delay';\nimport {createLogger} from '@alwatr/logger';\n\nimport {StateSignal} from './state-signal.js';\n\nimport type {ComputedSignalConfig, IReadonlySignal, SubscribeResult, SubscribeOptions} from '../type.js';\n\n/**\n * A read-only signal that derives its value from a set of dependency signals.\n *\n * `ComputedSignal` is a powerful tool for creating values that reactively update when their underlying\n * data sources change. Its value is memoized, meaning the `get` function is only re-evaluated when\n * one of its dependencies has actually changed.\n *\n * A key feature is its lifecycle management: a `ComputedSignal` **must** be destroyed when no longer\n * needed to prevent memory leaks from its subscriptions to dependency signals.\n *\n * @template T The type of the computed value.\n *\n * @example\n * // --- Create dependency signals ---\n * const firstName = new StateSignal({ signalId: 'firstName', initialValue: 'John' });\n * const lastName = new StateSignal({ signalId: 'lastName', initialValue: 'Doe' });\n *\n * // --- Create a computed signal ---\n * const fullName = new ComputedSignal({\n *   signalId: 'fullName',\n *   deps: [firstName, lastName],\n *   get: () => `${firstName.value} ${lastName.value}`,\n * });\n *\n * console.log(fullName.value); // Outputs: \"John Doe\"\n *\n * // --- Subscribe to the computed value ---\n * fullName.subscribe(newFullName => {\n *   console.log(`Name changed to: ${newFullName}`);\n * });\n *\n * // --- Update a dependency ---\n * lastName.set('Smith'); // Recalculates and logs: \"Name changed to: John Smith\"\n * console.log(fullName.value); // Outputs: \"John Smith\"\n *\n * // --- IMPORTANT: Clean up when done ---\n * fullName.destroy();\n */\nexport class ComputedSignal<T> implements IReadonlySignal<T> {\n  /**\n   * The unique identifier for this signal instance.\n   */\n  public readonly signalId = this.config_.signalId;\n\n  /**\n   * The logger instance for this signal.\n   * @protected\n   */\n  protected readonly logger_ = createLogger(`computed-signal: ${this.signalId}`);\n\n  /**\n   * The internal `StateSignal` that holds the computed value.\n   * This is how the computed signal provides `.value` and `.subscribe()` methods.\n   * @protected\n   */\n  protected readonly internalSignal_ = new StateSignal<T>({\n    signalId: `${this.signalId}-internal`,\n    initialValue: this.config_.get(),\n  });\n\n  /**\n   * A list of subscriptions to dependency signals.\n   * @private\n   */\n\n  private readonly dependencySubscriptions__: SubscribeResult[] = [];\n\n  /**\n   * A flag to prevent concurrent recalculations.\n   * @private\n   */\n  private isRecalculating__ = false;\n\n  public constructor(protected config_: ComputedSignalConfig<T>) {\n    this.logger_.logMethod?.('constructor');\n    this.recalculate_ = this.recalculate_.bind(this);\n\n    // Subscribe to all dependencies to trigger recalculation on change.\n    for (const signal of config_.deps) {\n      this.dependencySubscriptions__.push(signal.subscribe(this.recalculate_, {receivePrevious: false}));\n    }\n  }\n\n  /**\n   * The current value of the computed signal.\n   * Accessing this property returns the memoized value and does not trigger a recalculation.\n   *\n   * @returns The current computed value.\n   * @throws {Error} If accessed after the signal has been destroyed.\n   */\n  public get value(): T {\n    return this.internalSignal_.value;\n  }\n\n  /**\n   * Indicates whether the computed signal has been destroyed.\n   * A destroyed signal cannot be used and will throw an error if interacted with.\n   * @returns `true` if the signal is destroyed, `false` otherwise.\n   */\n  public get isDestroyed(): boolean {\n    return this.internalSignal_.isDestroyed;\n  }\n\n  /**\n   * Subscribes a listener to this signal.\n   * The listener will be called whenever the computed value changes.\n   *\n   * @param callback The function to be called with the new value.\n   * @param options Subscription options.\n   * @returns A `SubscribeResult` object with an `unsubscribe` method.\n   */\n  public subscribe(callback: (value: T) => void, options?: SubscribeOptions): SubscribeResult {\n    return this.internalSignal_.subscribe(callback, options);\n  }\n\n  /**\n   * Returns a Promise that resolves with the next computed value.\n   *\n   * @returns A Promise that resolves with the next value.\n   */\n  public untilNext(): Promise<T> {\n    return this.internalSignal_.untilNext();\n  }\n\n  /**\n   * Permanently disposes of the computed signal.\n   *\n   * This is a critical cleanup step. It unsubscribes from all dependency signals,\n   * stopping future recalculations and allowing the signal to be garbage collected.\n   * Failure to call `destroy()` will result in memory leaks.\n   *\n   * After `destroy()` is called, any attempt to access `.value` or `.subscribe()` will throw an error.\n   */\n  public destroy(): void {\n    this.logger_.logMethod?.('destroy');\n    /**\n     * If already destroyed, log an incident and return early.\n     */\n    if (this.isDestroyed) {\n      this.logger_.incident?.('destroy', 'already_destroyed');\n      return;\n    }\n\n    // Unsubscribe from all upstream dependencies.\n    for (const subscription of this.dependencySubscriptions__) {\n      subscription.unsubscribe();\n    }\n    this.dependencySubscriptions__.length = 0; // Clear the array of subscriptions.\n\n    this.internalSignal_.destroy(); // Destroy the internal signal.\n    this.config_.onDestroy?.(); // Call the optional onDestroy callback.\n    this.config_ = null as unknown as ComputedSignalConfig<T>; // Release config closure.\n  }\n\n  /**\n   * Schedules a recalculation of the signal's value.\n   *\n   * This method batches updates using a macrotask (`delay.nextMacrotask`) to ensure the\n   * `get` function runs only once per event loop tick, even if multiple dependencies\n   * change in the same synchronous block of code.\n   * @protected\n   */\n  protected async recalculate_(): Promise<void> {\n    this.logger_.logMethod?.('recalculate_');\n\n    if (this.internalSignal_.isDestroyed) {\n      // This check is important in case a dependency fires after this signal is destroyed.\n      this.logger_.incident?.('recalculate_', 'recalculate_on_destroyed_signal');\n      return;\n    }\n\n    if (this.isRecalculating__) {\n      // If a recalculation is already scheduled, do nothing.\n      this.logger_.logStep?.('recalculate_', 'skipping_recalculation_already_scheduled');\n      return;\n    }\n\n    this.isRecalculating__ = true;\n\n    try {\n      // Wait for the next macrotask to start the recalculation.\n      // This batches all synchronous dependency updates in the current event loop.\n      await delay.nextMacrotask();\n      \n      if (this.isDestroyed) {\n        this.logger_.incident?.('recalculate_', 'destroyed_during_delay');\n        this.isRecalculating__ = false;\n        return;\n      }\n\n      this.logger_.logStep?.('recalculate_', 'recalculating_value');\n\n      // Set the new value on the internal signal, which will notify our subscribers.\n      this.internalSignal_.set(this.config_.get());\n    }\n    catch (err) {\n      this.logger_.error('recalculate_', 'recalculation_failed', err);\n    }\n\n    // Allow the next recalculation to be scheduled.\n    this.isRecalculating__ = false;\n  }\n}\n", "import {delay} from '@alwatr/delay';\nimport {createLogger} from '@alwatr/logger';\n\nimport type {EffectSignalConfig, IEffectSignal, SubscribeResult} from '../type.js';\n\n/**\n * Manages a side-effect that runs in response to changes in dependency signals.\n *\n * `EffectSignal` is designed for running logic that interacts with the \"outside world\"—such as\n * logging, network requests, or DOM manipulation—whenever its dependencies are updated.\n * It encapsulates the subscription and cleanup logic, providing a robust and memory-safe\n * way to handle reactive side-effects.\n *\n * A key feature is its lifecycle management: an `EffectSignal` **must** be destroyed when no longer\n * needed to prevent memory leaks and stop the effect from running unnecessarily.\n *\n * @implements {IEffectSignal}\n *\n * @example\n * // --- Create dependency signals ---\n * const counter = new StateSignal({ initialValue: 0, signalId: 'counter' });\n * const user = new StateSignal({ initialValue: 'guest', signalId: 'user' });\n *\n * // --- Create an effect ---\n * const analyticsEffect = new EffectSignal({\n *   signalId: 'analytics-effect',\n *   deps: [counter, user],\n *   run: () => {\n *     console.log(`Analytics: User '${user.value}' clicked ${counter.value} times.`);\n *   },\n *   runImmediately: true, // Optional: run once on creation\n * });\n * // Immediately logs: \"Analytics: User 'guest' clicked 0 times.\"\n *\n * // --- Trigger the effect by updating a dependency ---\n * counter.set(1);\n * // After a macrotask, logs: \"Analytics: User 'guest' clicked 1 times.\"\n *\n * // --- IMPORTANT: Clean up when the effect is no longer needed ---\n * analyticsEffect.destroy();\n *\n * // Further updates will not trigger the effect.\n * counter.set(2); // Nothing is logged.\n */\nexport class EffectSignal implements IEffectSignal {\n  /**\n   * The unique identifier for this signal instance.\n   */\n  public readonly signalId = this.config_.signalId ? this.config_.signalId : `[${this.config_.deps.map((dep) => dep.signalId).join(', ')}]`;\n\n  /**\n   * The logger instance for this signal.\n   * @protected\n   */\n  protected readonly logger_ = createLogger(`effect-signal: ${this.signalId}`);\n\n  /**\n   * A list of subscriptions to dependency signals.\n   * @private\n   */\n  private readonly dependencySubscriptions__: SubscribeResult[] = [];\n\n  /**\n   * A flag to prevent concurrent executions of the effect.\n   * @private\n   */\n  private isRunning__ = false;\n\n  /**\n   * A flag indicating whether the effect has been destroyed.\n   * @private\n   */\n  private isDestroyed__ = false;\n\n  /**\n   * Indicates whether the effect signal has been destroyed.\n   * A destroyed signal will no longer execute its effect and cannot be reused.\n   *\n   * @returns `true` if the signal is destroyed, `false` otherwise.\n   */\n  public get isDestroyed(): boolean {\n    return this.isDestroyed__;\n  }\n\n  public constructor(protected config_: EffectSignalConfig) {\n    this.logger_.logMethod?.('constructor');\n    this.run_ = this.run_.bind(this);\n\n    // Subscribe to all dependencies. We don't need the previous value,\n    // as the `runImmediately` option controls the initial execution.\n    for (const signal of config_.deps) {\n      this.dependencySubscriptions__.push(signal.subscribe(this.run_, {receivePrevious: false}));\n    }\n\n    // Run the effect immediately if requested.\n    if (config_.runImmediately === true) {\n      // We don't need to await this, let it run in the background.\n      void this.run_();\n    }\n  }\n\n  /**\n   * Schedules the execution of the effect's `run` function.\n   *\n   * This method batches updates using a macrotask (`delay.nextMacrotask`) to ensure the\n   * `run` function executes only once per event loop tick, even if multiple\n   * dependencies change simultaneously.\n   * @protected\n   */\n  protected async run_(): Promise<void> {\n    this.logger_.logMethod?.('run_');\n\n    if (this.isDestroyed__) {\n      this.logger_.incident?.('run_', 'run_on_destroyed_signal');\n      return;\n    }\n    if (this.isRunning__) {\n      // If an execution is already scheduled, do nothing.\n      this.logger_.logStep?.('run_', 'skipped_because_already_running');\n      return;\n    }\n\n    this.isRunning__ = true;\n\n    try {\n      // Wait for the next macrotask to batch simultaneous updates.\n      await delay.nextMacrotask();\n      if (this.isDestroyed__) {\n        this.logger_.incident?.('run_', 'destroyed_during_delay');\n        this.isRunning__ = false;\n        return;\n      }\n\n      this.logger_.logStep?.('run_', 'executing_effect');\n      await this.config_.run();\n    }\n    catch (err) {\n      this.logger_.error('run_', 'effect_failed', err);\n    }\n\n    // Reset the flag after the current execution is complete.\n    this.isRunning__ = false;\n  }\n\n  /**\n   * Permanently disposes of the effect signal.\n   *\n   * This is a critical cleanup step. It unsubscribes from all dependency signals,\n   * stopping any future executions of the effect and allowing it to be garbage collected.\n   * Failure to call `destroy()` will result in memory leaks and potentially unwanted side effects.\n   */\n  public destroy(): void {\n    this.logger_.logMethod?.('destroy');\n\n    if (this.isDestroyed__) {\n      this.logger_.incident?.('destroy', 'already_destroyed');\n      return;\n    }\n\n    this.isDestroyed__ = true;\n\n    // Unsubscribe from all upstream dependencies.\n    for (const subscription of this.dependencySubscriptions__) {\n      subscription.unsubscribe();\n    }\n    this.dependencySubscriptions__.length = 0; // Clear the array of subscriptions.\n\n    this.config_.onDestroy?.(); // Call the optional onDestroy callback.\n    this.config_ = null as unknown as EffectSignalConfig; // Release config closure.\n  }\n}\n", "import {EventSignal} from '../core/event-signal.js';\n\nimport type {SignalConfig} from '../type.js';\n\n/**\n * Creates a stateless signal for dispatching transient events.\n *\n * `EventSignal` is ideal for broadcasting events that do not have a persistent state.\n * Unlike `StateSignal`, it does not hold a value. Listeners are only notified of new\n * events as they are dispatched. This makes it suitable for modeling user interactions,\n * system notifications, or any one-off message.\n *\n * @template T The type of the payload for the events.\n *\n * @param config The configuration for the event signal.\n * @returns A new instance of EventSignal.\n *\n * @example\n * const onUserClick = createEventSignal<{ x: number, y: number }>({\n *   signalId: 'on-user-click'\n * });\n *\n * onUserClick.subscribe(pos => {\n *   console.log(`User clicked at: ${pos.x}, ${pos.y}`);\n * });\n *\n * onUserClick.dispatch({ x: 100, y: 250 });\n */\nexport function createEventSignal<T = void>(config: SignalConfig): EventSignal<T> {\n  return new EventSignal<T>(config);\n}\n", "import {StateSignal} from '../core/state-signal.js';\n\nimport type {StateSignalConfig} from '../type.js';\n\n/**\n * Creates a stateful signal that holds a value and notifies listeners when the value changes.\n *\n * `StateSignal` is the core of the signal library, representing a piece of mutable state.\n * It always has a value, and new subscribers immediately receive the current value by default.\n *\n * @template T The type of the state it holds.\n *\n * @param config The configuration for the state signal.\n * @returns A new instance of StateSignal.\n *\n * @example\n * const counter = createStateSignal({\n *   signalId: 'counter-signal',\n *   initialValue: 0,\n * });\n *\n * console.log(counter.value); // Outputs: 0\n * counter.set(1);\n * console.log(counter.value); // Outputs: 1\n */\nexport function createStateSignal<T>(config: StateSignalConfig<T>): StateSignal<T> {\n  return new StateSignal(config);\n}\n", "import {ComputedSignal} from '../core/computed-signal.js';\n\nimport type {ComputedSignalConfig} from '../type.js';\n\n/**\n * Creates a read-only signal that derives its value from a set of dependency signals.\n *\n * `ComputedSignal` is a powerful tool for creating values that reactively update when their underlying\n * data sources change. Its value is memoized, meaning the `get` function is only re-evaluated when\n * one of its dependencies has actually changed.\n *\n * A key feature is its lifecycle management: a `ComputedSignal` **must** be destroyed when no longer\n * needed to prevent memory leaks from its subscriptions to dependency signals.\n *\n * @template T The type of the computed value.\n *\n * @param config The configuration for the computed signal.\n * @returns A new, read-only computed signal.\n *\n * @example\n * const firstName = createStateSignal({ signalId: 'firstName', initialValue: 'John' });\n * const lastName = createStateSignal({ signalId: 'lastName', initialValue: 'Doe' });\n *\n * const fullName = createComputedSignal({\n *   signalId: 'fullName',\n *   deps: [firstName, lastName],\n *   get: () => `${firstName.value} ${lastName.value}`,\n * });\n *\n * console.log(fullName.value); // \"John Doe\"\n *\n * // IMPORTANT: Always destroy a computed signal when no longer needed.\n * // fullName.destroy();\n */\nexport function createComputedSignal<T>(config: ComputedSignalConfig<T>): ComputedSignal<T> {\n  return new ComputedSignal(config);\n}\n", "import {EffectSignal} from '../core/effect-signal.js';\n\nimport type {EffectSignalConfig} from '../type.js';\n\n/**\n * Creates a side-effect that runs in response to changes in dependency signals.\n *\n * `EffectSignal` is designed for running logic that interacts with the \"outside world\"—such as\n * logging, network requests, or DOM manipulation—whenever its dependencies are updated.\n * It encapsulates the subscription and cleanup logic, providing a robust and memory-safe\n * way to handle reactive side-effects.\n *\n * A key feature is its lifecycle management: an `EffectSignal` **must** be destroyed when no longer\n * needed to prevent memory leaks and stop the effect from running unnecessarily.\n *\n * @param config The configuration for the effect.\n * @returns An object with a `destroy` method to stop the effect.\n *\n * @example\n * // --- Create dependency signals ---\n * const counter = createStateSignal({ initialValue: 0, signalId: 'counter' });\n * const user = createStateSignal({ initialValue: 'guest', signalId: 'user' });\n *\n * // --- Create an effect ---\n * const analyticsEffect = createEffect({\n *   deps: [counter, user],\n *   run: () => {\n *     console.log(`Analytics: User '${user.value}' clicked ${counter.value} times.`);\n *   },\n *   runImmediately: true, // Optional: run once on creation\n * });\n * // Immediately logs: \"Analytics: User 'guest' clicked 0 times.\"\n *\n * // --- Trigger the effect by updating a dependency ---\n * counter.set(1);\n * // After a macrotask, logs: \"Analytics: User 'guest' clicked 1 times.\"\n *\n * // --- IMPORTANT: Clean up when the effect is no longer needed ---\n * analyticsEffect.destroy();\n *\n * // Further updates will not trigger the effect.\n * counter.set(2); // Nothing is logged.\n */\nexport function createEffect(config: EffectSignalConfig): EffectSignal {\n  return new EffectSignal(config);\n}\n", "import {createDebouncer} from '@alwatr/debounce';\n\nimport {StateSignal} from '../core/state-signal.js';\nimport {createComputedSignal} from '../creators/computed.js';\n\nimport type {ComputedSignal} from '../core/computed-signal.js';\nimport type {IReadonlySignal, DebounceSignalConfig} from '../type.js';\n\n/**\n * Creates a new computed signal that debounces updates from a source signal.\n *\n * The returned signal is a `ComputedSignal`, meaning it is read-only and its value is\n * derived from the source. It only updates its value after a specified period of\n * inactivity from the source signal.\n *\n * This operator is essential for handling high-frequency events, such as user input\n * in a search box, resizing a window, or any other event that fires rapidly.\n * By debouncing, you can ensure that expensive operations (like API calls or heavy\n * computations) are only executed once the events have settled.\n *\n * @template T The type of the signal's value.\n *\n * @param {IReadonlySignal<T>} sourceSignal The original signal to debounce.\n * It can be a `StateSignal`, `ComputedSignal`, or any signal implementing `IReadonlySignal`.\n * @param {DebounceSignalConfig} config Configuration object for the debouncer,\n * including `delay`, `leading`, and `trailing` options from `@alwatr/debounce`.\n *\n * @returns {IComputedSignal<T>} A new, read-only computed signal that emits debounced values.\n * Crucially, you **must** call `.destroy()` on this signal when it's no longer\n * needed to prevent memory leaks by cleaning up internal subscriptions and timers.\n *\n * @example\n * ```typescript\n * // Create a source signal for user input.\n * const searchInput = createStateSignal({\n *   signalId: 'search-input',\n *   initialValue: '',\n * });\n *\n * // Create a debounced signal that waits 300ms after the user stops typing.\n * const debouncedSearch = createDebouncedSignal(searchInput, { delay: 300 });\n *\n * // Use an effect to react to the debounced value.\n * createEffect({\n *   deps: [debouncedSearch],\n *   run: () => {\n *     if (debouncedSearch.value) {\n *       console.log(`🚀 Sending API request for: \"${debouncedSearch.value}\"`);\n *     }\n *   },\n * });\n *\n * searchInput.set('Alwatr');\n * searchInput.set('Alwatr Signal');\n * // (after 300ms of inactivity)\n * // Logs: \"🚀 Sending API request for: \"Alwatr Signal\"\"\n *\n * // IMPORTANT: Clean up when the component unmounts.\n * // debouncedSearch.destroy();\n * ```\n */\nexport function createDebouncedSignal<T>(sourceSignal: IReadonlySignal<T>, config: DebounceSignalConfig): ComputedSignal<T> {\n  const signalId = config.signalId ?? `${sourceSignal.signalId}-debounced`;\n\n  const internalSignal = new StateSignal<T>({\n    signalId: `${signalId}-internal`,\n    initialValue: sourceSignal.value,\n  });\n\n  const debouncer = createDebouncer({\n    ...config,\n    func: (value: T): void => {\n      internalSignal.set(value);\n    },\n  });\n\n  const subscription = sourceSignal.subscribe(debouncer.trigger);\n\n  return createComputedSignal({\n    signalId,\n    deps: [internalSignal],\n    get: () => internalSignal.value,\n    onDestroy: () => {\n      if (internalSignal.isDestroyed) return;\n      subscription.unsubscribe();\n      debouncer.cancel();\n      internalSignal.destroy();\n      config.onDestroy?.();\n      config = null as unknown as DebounceSignalConfig;\n    },\n  });\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACUO,IAAe,aAAf,MAA6B;AAAA,EAmC3B,YAAsB,SAAuB;AAAvB;AA9B7B;AAAA;AAAA;AAAA;AAAA,SAAgB,WAAW,KAAK,QAAQ;AAYxC;AAAA;AAAA;AAAA;AAAA,SAAmB,aAA6B,CAAC;AAMjD;AAAA;AAAA;AAAA;AAAA,SAAQ,gBAAgB;AAAA,EAY6B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAJrD,IAAW,cAAuB;AAChC,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUU,gBAAgB,UAA8B;AACtD,SAAK,QAAQ,YAAY,iBAAiB;AAE1C,QAAI,KAAK,eAAe;AACtB,WAAK,QAAQ,WAAW,mBAAmB,qCAAqC;AAChF;AAAA,IACF;AAEA,UAAM,QAAQ,KAAK,WAAW,QAAQ,QAAQ;AAC9C,QAAI,UAAU,IAAI;AAChB,WAAK,WAAW,OAAO,OAAO,CAAC;AAAA,IACjC;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWO,UAAU,UAA+B,SAA6C;AAC3F,SAAK,QAAQ,gBAAgB,kBAAkB,EAAC,QAAO,CAAC;AACxD,SAAK,gBAAgB;AAErB,UAAM,WAAyB,EAAC,UAAU,QAAO;AAEjD,QAAI,SAAS,UAAU;AAErB,WAAK,WAAW,QAAQ,QAAQ;AAAA,IAClC,OACK;AACH,WAAK,WAAW,KAAK,QAAQ;AAAA,IAC/B;AAGA,WAAO;AAAA,MACL,aAAa,MAAY,KAAK,gBAAgB,QAAQ;AAAA,IACxD;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWU,QAAQ,OAAgB;AAChC,SAAK,QAAQ,gBAAgB,WAAW,KAAK;AAE7C,QAAI,KAAK,eAAe;AACtB,WAAK,QAAQ,WAAW,WAAW,4BAA4B;AAC/D;AAAA,IACF;AAIA,UAAM,mBAAmB,CAAC,GAAG,KAAK,UAAU;AAE5C,eAAW,YAAY,kBAAkB;AACvC,UAAI,SAAS,SAAS,MAAM;AAC1B,aAAK,gBAAgB,QAAQ;AAAA,MAC/B;AAEA,UAAI;AACF,cAAM,SAAS,SAAS,SAAS,KAAK;AACtC,YAAI,kBAAkB,SAAS;AAC7B,iBAAO,MAAM,CAAC,QAAQ,KAAK,QAAQ,MAAM,WAAW,yBAAyB,KAAK,EAAC,SAAQ,CAAC,CAAC;AAAA,QAC/F;AAAA,MACF,SACO,KAAK;AACV,aAAK,QAAQ,MAAM,WAAW,wBAAwB,GAAG;AAAA,MAC3D;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAeO,YAAwB;AAC7B,SAAK,QAAQ,YAAY,WAAW;AACpC,SAAK,gBAAgB;AACrB,WAAO,IAAI,QAAQ,CAAC,YAAY;AAC9B,WAAK,UAAU,SAAS;AAAA,QACtB,MAAM;AAAA,QACN,UAAU;AAAA;AAAA,QACV,iBAAiB;AAAA;AAAA,MACnB,CAAC;AAAA,IACH,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,UAAgB;AACrB,SAAK,QAAQ,YAAY,SAAS;AAClC,QAAI,KAAK,eAAe;AACtB,WAAK,QAAQ,WAAW,YAAY,wBAAwB;AAC5D;AAAA,IACF;AACA,SAAK,gBAAgB;AACrB,SAAK,WAAW,SAAS;AACzB,SAAK,QAAQ,YAAY;AACzB,SAAK,UAAU;AAAA,EACjB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOU,kBAAwB;AAChC,QAAI,KAAK,eAAe;AACtB,WAAK,QAAQ,SAAS,mBAAmB,iCAAiC;AAC1E,YAAM,IAAI,MAAM,gDAAgD,KAAK,QAAQ,GAAG;AAAA,IAClF;AAAA,EACF;AACF;;;AC7LA,mBAAoB;AACpB,oBAA2B;AAiCpB,IAAM,cAAN,cAAoC,WAAc;AAAA,EAOhD,YAAY,QAAsB;AACvC,UAAM,MAAM;AAHd;AAAA;AAAA;AAAA;AAAA,SAAU,cAAU,4BAAa,iBAAiB,KAAK,QAAQ,EAAE;AAI/D,SAAK,QAAQ,YAAY,aAAa;AAAA,EACxC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,SAAS,SAAkB;AAChC,SAAK,QAAQ,gBAAgB,YAAY,EAAC,QAAO,CAAC;AAClD,SAAK,gBAAgB;AAErB,uBAAM,cAAc,EAAE,KAAK,MAAM,KAAK,QAAQ,OAAO,CAAC;AAAA,EACxD;AACF;;;AC3DA,IAAAA,gBAAoB;AACpB,IAAAC,iBAA2B;AAuCpB,IAAM,cAAN,cAA6B,WAA4C;AAAA,EAavE,YAAY,QAA8B;AAC/C,UAAM,MAAM;AAHd;AAAA;AAAA;AAAA;AAAA,SAAU,cAAU,6BAAa,iBAAiB,KAAK,QAAQ,EAAE;AAI/D,SAAK,UAAU,OAAO;AACtB,SAAK,QAAQ,gBAAgB,eAAe,EAAC,cAAc,KAAK,QAAO,CAAC;AAAA,EAC1E;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,IAAW,QAAW;AACpB,SAAK,gBAAgB;AACrB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiBO,IAAI,UAAmB;AAC5B,SAAK,QAAQ,gBAAgB,OAAO,EAAC,SAAQ,CAAC;AAC9C,SAAK,gBAAgB;AAGrB,QAAI,OAAO,GAAG,KAAK,SAAS,QAAQ,MAAM,OAAO,aAAa,YAAY,aAAa,OAAO;AAC5F;AAAA,IACF;AAEA,SAAK,UAAU;AAGf,wBAAM,cAAc,EAAE,KAAK,MAAM,KAAK,QAAQ,QAAQ,CAAC;AAAA,EACzD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiBO,OAAO,SAAwC;AACpD,SAAK,QAAQ,YAAY,QAAQ;AACjC,SAAK,gBAAgB;AAGrB,SAAK,IAAI,QAAQ,KAAK,OAAO,CAAC;AAAA,EAChC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYgB,UAAU,UAA+B,UAA4B,CAAC,GAAoB;AACxG,SAAK,QAAQ,gBAAgB,aAAa,EAAC,QAAO,CAAC;AACnD,SAAK,gBAAgB;AAGrB,QAAI,QAAQ,oBAAoB,OAAO;AAGrC,0BACG,cAAc,EACd,KAAK,MAAM,SAAS,KAAK,OAAO,CAAC,EACjC,MAAM,CAAC,QAAQ,KAAK,QAAQ,MAAM,aAAa,6BAA6B,GAAG,CAAC;AAInF,UAAI,QAAQ,MAAM;AAEhB,eAAO,EAAC,aAAa,MAAM;AAAA,QAAC,EAAC;AAAA,MAC/B;AAAA,IACF;AAEA,WAAO,MAAM,UAAU,UAAU,OAAO;AAAA,EAC1C;AAAA;AAAA;AAAA;AAAA;AAAA,EAMgB,UAAgB;AAC9B,SAAK,UAAU;AACf,UAAM,QAAQ;AAAA,EAChB;AACF;;;ACvKA,IAAAC,gBAAoB;AACpB,IAAAC,iBAA2B;AA4CpB,IAAM,iBAAN,MAAsD;AAAA,EAmCpD,YAAsB,SAAkC;AAAlC;AA/B7B;AAAA;AAAA;AAAA,SAAgB,WAAW,KAAK,QAAQ;AAMxC;AAAA;AAAA;AAAA;AAAA,SAAmB,cAAU,6BAAa,oBAAoB,KAAK,QAAQ,EAAE;AAO7E;AAAA;AAAA;AAAA;AAAA;AAAA,SAAmB,kBAAkB,IAAI,YAAe;AAAA,MACtD,UAAU,GAAG,KAAK,QAAQ;AAAA,MAC1B,cAAc,KAAK,QAAQ,IAAI;AAAA,IACjC,CAAC;AAOD;AAAA;AAAA;AAAA;AAAA,SAAiB,4BAA+C,CAAC;AAMjE;AAAA;AAAA;AAAA;AAAA,SAAQ,oBAAoB;AAG1B,SAAK,QAAQ,YAAY,aAAa;AACtC,SAAK,eAAe,KAAK,aAAa,KAAK,IAAI;AAG/C,eAAW,UAAU,QAAQ,MAAM;AACjC,WAAK,0BAA0B,KAAK,OAAO,UAAU,KAAK,cAAc,EAAC,iBAAiB,MAAK,CAAC,CAAC;AAAA,IACnG;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,IAAW,QAAW;AACpB,WAAO,KAAK,gBAAgB;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,IAAW,cAAuB;AAChC,WAAO,KAAK,gBAAgB;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUO,UAAU,UAA8B,SAA6C;AAC1F,WAAO,KAAK,gBAAgB,UAAU,UAAU,OAAO;AAAA,EACzD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,YAAwB;AAC7B,WAAO,KAAK,gBAAgB,UAAU;AAAA,EACxC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWO,UAAgB;AACrB,SAAK,QAAQ,YAAY,SAAS;AAIlC,QAAI,KAAK,aAAa;AACpB,WAAK,QAAQ,WAAW,WAAW,mBAAmB;AACtD;AAAA,IACF;AAGA,eAAW,gBAAgB,KAAK,2BAA2B;AACzD,mBAAa,YAAY;AAAA,IAC3B;AACA,SAAK,0BAA0B,SAAS;AAExC,SAAK,gBAAgB,QAAQ;AAC7B,SAAK,QAAQ,YAAY;AACzB,SAAK,UAAU;AAAA,EACjB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,MAAgB,eAA8B;AAC5C,SAAK,QAAQ,YAAY,cAAc;AAEvC,QAAI,KAAK,gBAAgB,aAAa;AAEpC,WAAK,QAAQ,WAAW,gBAAgB,iCAAiC;AACzE;AAAA,IACF;AAEA,QAAI,KAAK,mBAAmB;AAE1B,WAAK,QAAQ,UAAU,gBAAgB,0CAA0C;AACjF;AAAA,IACF;AAEA,SAAK,oBAAoB;AAEzB,QAAI;AAGF,YAAM,oBAAM,cAAc;AAE1B,UAAI,KAAK,aAAa;AACpB,aAAK,QAAQ,WAAW,gBAAgB,wBAAwB;AAChE,aAAK,oBAAoB;AACzB;AAAA,MACF;AAEA,WAAK,QAAQ,UAAU,gBAAgB,qBAAqB;AAG5D,WAAK,gBAAgB,IAAI,KAAK,QAAQ,IAAI,CAAC;AAAA,IAC7C,SACO,KAAK;AACV,WAAK,QAAQ,MAAM,gBAAgB,wBAAwB,GAAG;AAAA,IAChE;AAGA,SAAK,oBAAoB;AAAA,EAC3B;AACF;;;ACjNA,IAAAC,gBAAoB;AACpB,IAAAC,iBAA2B;AA2CpB,IAAM,eAAN,MAA4C;AAAA,EAwC1C,YAAsB,SAA6B;AAA7B;AApC7B;AAAA;AAAA;AAAA,SAAgB,WAAW,KAAK,QAAQ,WAAW,KAAK,QAAQ,WAAW,IAAI,KAAK,QAAQ,KAAK,IAAI,CAAC,QAAQ,IAAI,QAAQ,EAAE,KAAK,IAAI,CAAC;AAMtI;AAAA;AAAA;AAAA;AAAA,SAAmB,cAAU,6BAAa,kBAAkB,KAAK,QAAQ,EAAE;AAM3E;AAAA;AAAA;AAAA;AAAA,SAAiB,4BAA+C,CAAC;AAMjE;AAAA;AAAA;AAAA;AAAA,SAAQ,cAAc;AAMtB;AAAA;AAAA;AAAA;AAAA,SAAQ,gBAAgB;AAatB,SAAK,QAAQ,YAAY,aAAa;AACtC,SAAK,OAAO,KAAK,KAAK,KAAK,IAAI;AAI/B,eAAW,UAAU,QAAQ,MAAM;AACjC,WAAK,0BAA0B,KAAK,OAAO,UAAU,KAAK,MAAM,EAAC,iBAAiB,MAAK,CAAC,CAAC;AAAA,IAC3F;AAGA,QAAI,QAAQ,mBAAmB,MAAM;AAEnC,WAAK,KAAK,KAAK;AAAA,IACjB;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAnBA,IAAW,cAAuB;AAChC,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA2BA,MAAgB,OAAsB;AACpC,SAAK,QAAQ,YAAY,MAAM;AAE/B,QAAI,KAAK,eAAe;AACtB,WAAK,QAAQ,WAAW,QAAQ,yBAAyB;AACzD;AAAA,IACF;AACA,QAAI,KAAK,aAAa;AAEpB,WAAK,QAAQ,UAAU,QAAQ,iCAAiC;AAChE;AAAA,IACF;AAEA,SAAK,cAAc;AAEnB,QAAI;AAEF,YAAM,oBAAM,cAAc;AAC1B,UAAI,KAAK,eAAe;AACtB,aAAK,QAAQ,WAAW,QAAQ,wBAAwB;AACxD,aAAK,cAAc;AACnB;AAAA,MACF;AAEA,WAAK,QAAQ,UAAU,QAAQ,kBAAkB;AACjD,YAAM,KAAK,QAAQ,IAAI;AAAA,IACzB,SACO,KAAK;AACV,WAAK,QAAQ,MAAM,QAAQ,iBAAiB,GAAG;AAAA,IACjD;AAGA,SAAK,cAAc;AAAA,EACrB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,UAAgB;AACrB,SAAK,QAAQ,YAAY,SAAS;AAElC,QAAI,KAAK,eAAe;AACtB,WAAK,QAAQ,WAAW,WAAW,mBAAmB;AACtD;AAAA,IACF;AAEA,SAAK,gBAAgB;AAGrB,eAAW,gBAAgB,KAAK,2BAA2B;AACzD,mBAAa,YAAY;AAAA,IAC3B;AACA,SAAK,0BAA0B,SAAS;AAExC,SAAK,QAAQ,YAAY;AACzB,SAAK,UAAU;AAAA,EACjB;AACF;;;AC9IO,SAAS,kBAA4B,QAAsC;AAChF,SAAO,IAAI,YAAe,MAAM;AAClC;;;ACLO,SAAS,kBAAqB,QAA8C;AACjF,SAAO,IAAI,YAAY,MAAM;AAC/B;;;ACOO,SAAS,qBAAwB,QAAoD;AAC1F,SAAO,IAAI,eAAe,MAAM;AAClC;;;ACOO,SAAS,aAAa,QAA0C;AACrE,SAAO,IAAI,aAAa,MAAM;AAChC;;;AC7CA,sBAA8B;AA6DvB,SAAS,sBAAyB,cAAkC,QAAiD;AAC1H,QAAM,WAAW,OAAO,YAAY,GAAG,aAAa,QAAQ;AAE5D,QAAM,iBAAiB,IAAI,YAAe;AAAA,IACxC,UAAU,GAAG,QAAQ;AAAA,IACrB,cAAc,aAAa;AAAA,EAC7B,CAAC;AAED,QAAM,gBAAY,iCAAgB;AAAA,IAChC,GAAG;AAAA,IACH,MAAM,CAAC,UAAmB;AACxB,qBAAe,IAAI,KAAK;AAAA,IAC1B;AAAA,EACF,CAAC;AAED,QAAM,eAAe,aAAa,UAAU,UAAU,OAAO;AAE7D,SAAO,qBAAqB;AAAA,IAC1B;AAAA,IACA,MAAM,CAAC,cAAc;AAAA,IACrB,KAAK,MAAM,eAAe;AAAA,IAC1B,WAAW,MAAM;AACf,UAAI,eAAe,YAAa;AAChC,mBAAa,YAAY;AACzB,gBAAU,OAAO;AACjB,qBAAe,QAAQ;AACvB,aAAO,YAAY;AACnB,eAAS;AAAA,IACX;AAAA,EACF,CAAC;AACH;",
+  "sourcesContent": ["export * from './core/signal-base.js';\nexport * from './core/event-signal.js';\nexport * from './core/state-signal.js';\nexport * from './core/computed-signal.js';\nexport * from './core/effect-signal.js';\n\nexport * from './creators/event.js';\nexport * from './creators/state.js';\nexport * from './creators/computed.js';\nexport * from './creators/effect.js';\n\nexport * from './operators/debounce.js';\n\nexport type * from './type.js';\n", "import type {Observer_, SubscribeOptions, SubscribeResult, ListenerCallback, SignalConfig} from '../type.js';\nimport type {AlwatrLogger} from '@alwatr/logger';\nimport type {} from '@alwatr/nano-build';\n\n/**\n * An abstract base class for signal implementations.\n * It provides the core functionality for managing subscriptions (observers).\n *\n * @template T The type of data that the signal holds or dispatches.\n */\nexport abstract class SignalBase<T> {\n  /**\n   * The unique identifier for this signal instance.\n   * Useful for debugging and logging.\n   */\n  public readonly signalId = this.config_.signalId;\n\n  /**\n   * The logger instance for this signal.\n   * @protected\n   */\n  protected abstract logger_: AlwatrLogger;\n\n  /**\n   * The list of observers (listeners) subscribed to this signal.\n   * @protected\n   */\n  protected readonly observers_: Observer_<T>[] = [];\n\n  /**\n   * A flag indicating whether the signal has been destroyed.\n   * @private\n   */\n  private isDestroyed__ = false;\n\n  /**\n   * Indicates whether the signal has been destroyed.\n   * A destroyed signal cannot be used and will throw an error if interacted with.\n   *\n   * @returns `true` if the signal is destroyed, `false` otherwise.\n   */\n  public get isDestroyed(): boolean {\n    return this.isDestroyed__;\n  }\n\n  public constructor(protected config_: SignalConfig) {}\n\n  /**\n   * Removes a specific observer from the observers list.\n   *\n   * @param observer The observer instance to remove.\n   * @protected\n   */\n  protected removeObserver_(observer: Observer_<T>): void {\n    this.logger_.logMethod?.('removeObserver_');\n\n    if (this.isDestroyed__) {\n      this.logger_.incident?.('removeObserver_', 'remove_observer_on_destroyed_signal');\n      return;\n    }\n\n    const index = this.observers_.indexOf(observer);\n    if (index !== -1) {\n      this.observers_.splice(index, 1);\n    }\n  }\n\n  /**\n   * Subscribes a listener function to this signal.\n   *\n   * The listener will be called whenever the signal is notified (e.g., when `dispatch` or `set` is called).\n   *\n   * @param callback The function to be called when the signal is dispatched.\n   * @param options Subscription options to customize the behavior (e.g., `once`, `priority`).\n   * @returns A `SubscribeResult` object with an `unsubscribe` method to remove the listener.\n   */\n  public subscribe(callback: ListenerCallback<T>, options?: SubscribeOptions): SubscribeResult {\n    this.logger_.logMethodArgs?.('subscribe.base', {options});\n    this.checkDestroyed_();\n\n    const observer: Observer_<T> = {callback, options};\n\n    if (options?.priority) {\n      // High-priority observers are added to the front of the queue.\n      this.observers_.unshift(observer);\n    }\n    else {\n      this.observers_.push(observer);\n    }\n\n    // The returned unsubscribe function is a closure that calls the internal removal method.\n    return {\n      unsubscribe: (): void => this.removeObserver_(observer),\n    };\n  }\n\n  /**\n   * Notifies all registered observers about a new value.\n   *\n   * This method iterates through a snapshot of the current observers to prevent issues\n   * with subscriptions changing during notification (e.g., an observer unsubscribing itself).\n   *\n   * @param value The new value to notify observers about.\n   * @protected\n   */\n  protected notify_(value: T): void {\n    this.logger_.logMethodArgs?.('notify_', value);\n\n    if (this.isDestroyed__) {\n      this.logger_.incident?.('notify_', 'notify_on_destroyed_signal');\n      return;\n    }\n\n    // Create a snapshot of the observers array to iterate over.\n    // This prevents issues if the observers_ array is modified during the loop.\n    const currentObservers = [...this.observers_];\n\n    for (const observer of currentObservers) {\n      if (observer.options?.once) {\n        this.removeObserver_(observer);\n      }\n\n      try {\n        const result = observer.callback(value);\n        if (result instanceof Promise) {\n          result.catch((err) => this.logger_.error('notify_', 'async_callback_failed', err, {observer}));\n        }\n      }\n      catch (err) {\n        this.logger_.error('notify_', 'sync_callback_failed', err);\n      }\n    }\n  }\n\n  /**\n   * Returns a Promise that resolves with the next value dispatched by the signal.\n   * This provides an elegant way to wait for a single, future event using `async/await`.\n   *\n   * @returns A Promise that resolves with the next dispatched value.\n   *\n   * @example\n   * async function onButtonClick() {\n   *   console.log('Waiting for the next signal...');\n   *   const nextValue = await mySignal.untilNext();\n   *   console.log('Signal received:', nextValue);\n   * }\n   */\n  public untilNext(): Promise<T> {\n    this.logger_.logMethod?.('untilNext');\n    this.checkDestroyed_();\n    return new Promise((resolve) => {\n      this.subscribe(resolve, {\n        once: true,\n        priority: true, // Resolve the promise before other listeners are called.\n        receivePrevious: false, // We only want the *next* value, not the current one.\n      });\n    });\n  }\n\n  /**\n   * Destroys the signal, clearing all its listeners and making it inactive.\n   *\n   * After destruction, any interaction with the signal (like `subscribe` or `untilNext`)\n   * will throw an error. This is crucial for preventing memory leaks by allowing\n   * garbage collection of the signal and its observers.\n   */\n  public destroy(): void {\n    this.logger_.logMethod?.('destroy');\n    if (this.isDestroyed__) {\n      this.logger_.incident?.('destroy_', 'double_destroy_attempt');\n      return;\n    }\n    this.isDestroyed__ = true;\n    this.observers_.length = 0; // Clear all observers.\n    this.config_.onDestroy?.(); // Call the optional onDestroy callback.\n    this.config_ = null as unknown as SignalConfig; // Help GC by breaking references.\n  }\n\n  /**\n   * Throws an error if the signal has been destroyed.\n   * This is a safeguard to prevent interaction with a defunct signal.\n   * @protected\n   */\n  protected checkDestroyed_(): void {\n    if (this.isDestroyed__) {\n      this.logger_.accident('checkDestroyed_', 'attempt_to_use_destroyed_signal');\n      throw new Error(`Cannot interact with a destroyed signal (id: ${this.signalId})`);\n    }\n  }\n}\n", "import {delay} from '@alwatr/delay';\nimport {createLogger} from '@alwatr/logger';\n\nimport {SignalBase} from './signal-base.js';\n\nimport type {SignalConfig} from '../type.js';\n\n/**\n * A stateless signal for dispatching transient events.\n *\n * `EventSignal` is ideal for broadcasting events that do not have a persistent state.\n * Unlike `StateSignal`, it does not hold a value. Listeners are only notified of new\n * events as they are dispatched. This makes it suitable for modeling user interactions,\n * system notifications, or any one-off message.\n *\n * @template T The type of the payload for the events. Defaults to `void` for events without a payload.\n *\n * @example\n * // Create a signal for user click events.\n * const onUserClick = new EventSignal<{ x: number, y: number }>({ signalId: 'on-user-click' });\n *\n * // Subscribe to the event.\n * onUserClick.subscribe(clickPosition => {\n *   console.log(`User clicked at: ${clickPosition.x}, ${clickPosition.y}`);\n * });\n *\n * // Dispatch an event.\n * onUserClick.dispatch({ x: 100, y: 250 }); // Notifies the listener.\n *\n * // --- Example with no payload ---\n * const onAppReady = new EventSignal({ signalId: 'on-app-ready' });\n * onAppReady.subscribe(() => console.log('Application is ready!'));\n * onAppReady.dispatch(); // Notifies the listener.\n */\nexport class EventSignal<T = void> extends SignalBase<T> {\n  /**\n   * The logger instance for this signal.\n   * @protected\n   */\n  protected logger_ = createLogger(`event-signal: ${this.signalId}`);\n\n  public constructor(config: SignalConfig) {\n    super(config);\n    this.logger_.logMethod?.('constructor');\n  }\n\n  /**\n   * Dispatches an event with an optional payload to all active listeners.\n   * The notification is scheduled as a microtask to prevent blocking and ensure\n   * a consistent, non-blocking flow.\n   *\n   * @param payload The data to send with the event.\n   */\n  public dispatch(payload: T): void {\n    this.logger_.logMethodArgs?.('dispatch', {payload});\n    this.checkDestroyed_();\n    // Dispatch as a microtask to ensure consistent, non-blocking behavior.\n    delay.nextMicrotask().then(() => this.notify_(payload));\n  }\n}\n", "import {delay} from '@alwatr/delay';\nimport {createLogger} from '@alwatr/logger';\n\nimport {SignalBase} from './signal-base.js';\n\nimport type {StateSignalConfig, ListenerCallback, SubscribeOptions, SubscribeResult, IReadonlySignal} from '../type.js';\n\n/**\n * A stateful signal that holds a value and notifies listeners when the value changes.\n *\n * `StateSignal` is the core of the signal library, representing a piece of mutable state.\n * It always has a value, and new subscribers immediately receive the current value by default.\n *\n * @template T The type of the state it holds.\n * @implements {IReadonlySignal<T>}\n *\n * @example\n * // Create a new state signal with an initial value.\n * const counter = new StateSignal<number>({\n *   signalId: 'counter-signal',\n *   initialValue: 0,\n * });\n *\n * // Get the current value.\n * console.log(counter.get()); // Outputs: 0\n *\n * // Subscribe to changes.\n * const subscription = counter.subscribe(newValue => {\n *   console.log(`Counter changed to: ${newValue}`);\n * });\n *\n * // Set a new value, which triggers the notification.\n * counter.set(1); // Outputs: \"Counter changed to: 1\"\n *\n * // Update value based on the previous value.\n * counter.update(current => current + 1); // Outputs: \"Counter changed to: 2\"\n *\n * // Unsubscribe when no longer needed.\n * subscription.unsubscribe();\n */\nexport class StateSignal<T> extends SignalBase<T> implements IReadonlySignal<T> {\n  /**\n   * The current value of the signal.\n   * @private\n   */\n  private value__: T;\n\n  /**\n   * The logger instance for this signal.\n   * @protected\n   */\n  protected logger_ = createLogger(`state-signal: ${this.signalId}`);\n\n  public constructor(config: StateSignalConfig<T>) {\n    super(config);\n    this.value__ = config.initialValue;\n    this.logger_.logMethodArgs?.('constructor', {initialValue: this.value__});\n  }\n\n  /**\n   * Retrieves the current value of the signal.\n   *\n   * @returns The current value.\n   *\n   * @example\n   * console.log(mySignal.get());\n   */\n  public get(): T {\n    this.checkDestroyed_();\n    return this.value__;\n  }\n\n  /**\n   * Updates the signal's value and notifies all active listeners.\n   *\n   * The notification is scheduled as a microtask, which means the update is deferred\n   * slightly to batch multiple synchronous changes.\n   *\n   * @param newValue The new value to set.\n   *\n   * @example\n   * // For primitive types\n   * mySignal.set(42);\n   *\n   * // For object types, it's best practice to set an immutable new object.\n   * mySignal.set({ ...mySignal.get(), property: 'new-value' });\n   */\n  public set(newValue: T): void {\n    this.logger_.logMethodArgs?.('set', {newValue});\n    this.checkDestroyed_();\n\n    // For primitives (including null), do not notify if the value is the same.\n    if (Object.is(this.value__, newValue) && (typeof newValue !== 'object' || newValue === null)) {\n      return;\n    }\n\n    this.value__ = newValue;\n\n    // Dispatch as a microtask to ensure consistent, non-blocking behavior.\n    delay.nextMicrotask().then(() => this.notify_(newValue));\n  }\n\n  /**\n   * Updates the signal's value based on its previous value.\n   *\n   * This method is particularly useful for state transitions that depend on the current value,\n   * especially for objects or arrays, as it promotes an immutable update pattern.\n   *\n   * @param updater A function that receives the current value and returns the new value.\n   *\n   * @example\n   * // For a counter\n   * counterSignal.update(current => current + 1);\n   *\n   * // For an object state\n   * userSignal.update(currentUser => ({ ...currentUser, loggedIn: true }));\n   */\n  public update(updater: (previousValue: T) => T): void {\n    this.logger_.logMethod?.('update');\n    this.checkDestroyed_();\n    // The updater function is called with the current value to compute the new value,\n    // which is then passed to the `set` method.\n    this.set(updater(this.value__));\n  }\n\n  /**\n   * Subscribes a listener to this signal.\n   *\n   * By default, the listener is immediately called with the signal's current value (`receivePrevious: true`).\n   * This behavior can be customized via the `options` parameter.\n   *\n   * @param callback The function to be called when the signal's value changes.\n   * @param options Subscription options, including `receivePrevious` and `once`.\n   * @returns An object with an `unsubscribe` method to remove the listener.\n   */\n  public override subscribe(callback: ListenerCallback<T>, options: SubscribeOptions = {}): SubscribeResult {\n    this.logger_.logMethodArgs?.('subscribe', {options});\n    this.checkDestroyed_();\n\n    // By default, new subscribers to a StateSignal should receive the current value.\n    if (options.receivePrevious !== false) {\n      // Immediately (but asynchronously) call the listener with the current value.\n      // This is done in a microtask to ensure it happens after the subscription is fully registered.\n      delay\n        .nextMicrotask()\n        .then(() => callback(this.value__))\n        .catch((err) => this.logger_.error('subscribe', 'immediate_callback_failed', err));\n\n      // If it's a 'once' subscription that receives the previous value, it's now fulfilled.\n      // We don't need to add it to the observers list for future updates.\n      if (options.once) {\n        // eslint-disable-next-line @typescript-eslint/no-empty-function\n        return {unsubscribe: () => {}};\n      }\n    }\n\n    return super.subscribe(callback, options);\n  }\n\n  /**\n   * Destroys the signal, clearing its value and all listeners.\n   * This is crucial for memory management to prevent leaks.\n   */\n  public override destroy(): void {\n    this.value__ = null as T; // Clear the value to allow for garbage collection.\n    super.destroy();\n  }\n}\n", "import {delay} from '@alwatr/delay';\nimport {createLogger} from '@alwatr/logger';\n\nimport {StateSignal} from './state-signal.js';\n\nimport type {ComputedSignalConfig, IReadonlySignal, SubscribeResult, SubscribeOptions} from '../type.js';\n\n/**\n * A read-only signal that derives its value from a set of dependency signals.\n *\n * `ComputedSignal` is a powerful tool for creating values that reactively update when their underlying\n * data sources change. Its value is memoized, meaning the `get` function is only re-evaluated when\n * one of its dependencies has actually changed.\n *\n * A key feature is its lifecycle management: a `ComputedSignal` **must** be destroyed when no longer\n * needed to prevent memory leaks from its subscriptions to dependency signals.\n *\n * @template T The type of the computed value.\n *\n * @example\n * // --- Create dependency signals ---\n * const firstName = new StateSignal({ signalId: 'firstName', initialValue: 'John' });\n * const lastName = new StateSignal({ signalId: 'lastName', initialValue: 'Doe' });\n *\n * // --- Create a computed signal ---\n * const fullName = new ComputedSignal({\n *   signalId: 'fullName',\n *   deps: [firstName, lastName],\n *   get: () => `${firstName.get()} ${lastName.get()}`,\n * });\n *\n * console.log(fullName.get()); // Outputs: \"John Doe\"\n *\n * // --- Subscribe to the computed value ---\n * fullName.subscribe(newFullName => {\n *   console.log(`Name changed to: ${newFullName}`);\n * });\n *\n * // --- Update a dependency ---\n * lastName.set('Smith'); // Recalculates and logs: \"Name changed to: John Smith\"\n * console.log(fullName.get()); // Outputs: \"John Smith\"\n *\n * // --- IMPORTANT: Clean up when done ---\n * fullName.destroy();\n */\nexport class ComputedSignal<T> implements IReadonlySignal<T> {\n  /**\n   * The unique identifier for this signal instance.\n   */\n  public readonly signalId = this.config_.signalId;\n\n  /**\n   * The logger instance for this signal.\n   * @protected\n   */\n  protected readonly logger_ = createLogger(`computed-signal: ${this.signalId}`);\n\n  /**\n   * The internal `StateSignal` that holds the computed value.\n   * This is how the computed signal provides `.get()` and `.subscribe()` methods.\n   * @protected\n   */\n  protected readonly internalSignal_ = new StateSignal<T>({\n    signalId: `${this.signalId}-internal`,\n    initialValue: this.config_.get(),\n  });\n\n  /**\n   * A list of subscriptions to dependency signals.\n   * @private\n   */\n\n  private readonly dependencySubscriptions__: SubscribeResult[] = [];\n\n  /**\n   * A flag to prevent concurrent recalculations.\n   * @private\n   */\n  private isRecalculating__ = false;\n\n  public constructor(protected config_: ComputedSignalConfig<T>) {\n    this.logger_.logMethod?.('constructor');\n    this.recalculate_ = this.recalculate_.bind(this);\n\n    // Subscribe to all dependencies to trigger recalculation on change.\n    for (const signal of config_.deps) {\n      this.dependencySubscriptions__.push(signal.subscribe(this.recalculate_, {receivePrevious: false}));\n    }\n  }\n\n  /**\n   * The current value of the computed signal.\n   * Accessing this property returns the memoized value and does not trigger a recalculation.\n   *\n   * @returns The current computed value.\n   * @throws {Error} If accessed after the signal has been destroyed.\n   */\n  public get(): T {\n    return this.internalSignal_.get();\n  }\n\n  /**\n   * Indicates whether the computed signal has been destroyed.\n   * A destroyed signal cannot be used and will throw an error if interacted with.\n   * @returns `true` if the signal is destroyed, `false` otherwise.\n   */\n  public get isDestroyed(): boolean {\n    return this.internalSignal_.isDestroyed;\n  }\n\n  /**\n   * Subscribes a listener to this signal.\n   * The listener will be called whenever the computed value changes.\n   *\n   * @param callback The function to be called with the new value.\n   * @param options Subscription options.\n   * @returns A `SubscribeResult` object with an `unsubscribe` method.\n   */\n  public subscribe(callback: (value: T) => void, options?: SubscribeOptions): SubscribeResult {\n    return this.internalSignal_.subscribe(callback, options);\n  }\n\n  /**\n   * Returns a Promise that resolves with the next computed value.\n   *\n   * @returns A Promise that resolves with the next value.\n   */\n  public untilNext(): Promise<T> {\n    return this.internalSignal_.untilNext();\n  }\n\n  /**\n   * Permanently disposes of the computed signal.\n   *\n   * This is a critical cleanup step. It unsubscribes from all dependency signals,\n   * stopping future recalculations and allowing the signal to be garbage collected.\n   * Failure to call `destroy()` will result in memory leaks.\n   *\n   * After `destroy()` is called, any attempt to access `.get()` or `.subscribe()` will throw an error.\n   */\n  public destroy(): void {\n    this.logger_.logMethod?.('destroy');\n    /**\n     * If already destroyed, log an incident and return early.\n     */\n    if (this.isDestroyed) {\n      this.logger_.incident?.('destroy', 'already_destroyed');\n      return;\n    }\n\n    // Unsubscribe from all upstream dependencies.\n    for (const subscription of this.dependencySubscriptions__) {\n      subscription.unsubscribe();\n    }\n    this.dependencySubscriptions__.length = 0; // Clear the array of subscriptions.\n\n    this.internalSignal_.destroy(); // Destroy the internal signal.\n    this.config_.onDestroy?.(); // Call the optional onDestroy callback.\n    this.config_ = null as unknown as ComputedSignalConfig<T>; // Release config closure.\n  }\n\n  /**\n   * Schedules a recalculation of the signal's value.\n   *\n   * This method batches updates using a macrotask (`delay.nextMacrotask`) to ensure the\n   * `get` function runs only once per event loop tick, even if multiple dependencies\n   * change in the same synchronous block of code.\n   * @protected\n   */\n  protected async recalculate_(): Promise<void> {\n    this.logger_.logMethod?.('recalculate_');\n\n    if (this.internalSignal_.isDestroyed) {\n      // This check is important in case a dependency fires after this signal is destroyed.\n      this.logger_.incident?.('recalculate_', 'recalculate_on_destroyed_signal');\n      return;\n    }\n\n    if (this.isRecalculating__) {\n      // If a recalculation is already scheduled, do nothing.\n      this.logger_.logStep?.('recalculate_', 'skipping_recalculation_already_scheduled');\n      return;\n    }\n\n    this.isRecalculating__ = true;\n\n    try {\n      // Wait for the next macrotask to start the recalculation.\n      // This batches all synchronous dependency updates in the current event loop.\n      await delay.nextMacrotask();\n      \n      if (this.isDestroyed) {\n        this.logger_.incident?.('recalculate_', 'destroyed_during_delay');\n        this.isRecalculating__ = false;\n        return;\n      }\n\n      this.logger_.logStep?.('recalculate_', 'recalculating_value');\n\n      // Set the new value on the internal signal, which will notify our subscribers.\n      this.internalSignal_.set(this.config_.get());\n    }\n    catch (err) {\n      this.logger_.error('recalculate_', 'recalculation_failed', err);\n    }\n\n    // Allow the next recalculation to be scheduled.\n    this.isRecalculating__ = false;\n  }\n}\n", "import {delay} from '@alwatr/delay';\nimport {createLogger} from '@alwatr/logger';\n\nimport type {EffectSignalConfig, IEffectSignal, SubscribeResult} from '../type.js';\n\n/**\n * Manages a side-effect that runs in response to changes in dependency signals.\n *\n * `EffectSignal` is designed for running logic that interacts with the \"outside world\"—such as\n * logging, network requests, or DOM manipulation—whenever its dependencies are updated.\n * It encapsulates the subscription and cleanup logic, providing a robust and memory-safe\n * way to handle reactive side-effects.\n *\n * A key feature is its lifecycle management: an `EffectSignal` **must** be destroyed when no longer\n * needed to prevent memory leaks and stop the effect from running unnecessarily.\n *\n * @implements {IEffectSignal}\n *\n * @example\n * // --- Create dependency signals ---\n * const counter = new StateSignal({ initialValue: 0, signalId: 'counter' });\n * const user = new StateSignal({ initialValue: 'guest', signalId: 'user' });\n *\n * // --- Create an effect ---\n * const analyticsEffect = new EffectSignal({\n *   signalId: 'analytics-effect',\n *   deps: [counter, user],\n *   run: () => {\n *     console.log(`Analytics: User '${user.get()}' clicked ${counter.get()} times.`);\n *   },\n *   runImmediately: true, // Optional: run once on creation\n * });\n * // Immediately logs: \"Analytics: User 'guest' clicked 0 times.\"\n *\n * // --- Trigger the effect by updating a dependency ---\n * counter.set(1);\n * // After a macrotask, logs: \"Analytics: User 'guest' clicked 1 times.\"\n *\n * // --- IMPORTANT: Clean up when the effect is no longer needed ---\n * analyticsEffect.destroy();\n *\n * // Further updates will not trigger the effect.\n * counter.set(2); // Nothing is logged.\n */\nexport class EffectSignal implements IEffectSignal {\n  /**\n   * The unique identifier for this signal instance.\n   */\n  public readonly signalId = this.config_.signalId ? this.config_.signalId : `[${this.config_.deps.map((dep) => dep.signalId).join(', ')}]`;\n\n  /**\n   * The logger instance for this signal.\n   * @protected\n   */\n  protected readonly logger_ = createLogger(`effect-signal: ${this.signalId}`);\n\n  /**\n   * A list of subscriptions to dependency signals.\n   * @private\n   */\n  private readonly dependencySubscriptions__: SubscribeResult[] = [];\n\n  /**\n   * A flag to prevent concurrent executions of the effect.\n   * @private\n   */\n  private isRunning__ = false;\n\n  /**\n   * A flag indicating whether the effect has been destroyed.\n   * @private\n   */\n  private isDestroyed__ = false;\n\n  /**\n   * Indicates whether the effect signal has been destroyed.\n   * A destroyed signal will no longer execute its effect and cannot be reused.\n   *\n   * @returns `true` if the signal is destroyed, `false` otherwise.\n   */\n  public get isDestroyed(): boolean {\n    return this.isDestroyed__;\n  }\n\n  public constructor(protected config_: EffectSignalConfig) {\n    this.logger_.logMethod?.('constructor');\n    this.scheduleExecution_ = this.scheduleExecution_.bind(this);\n\n    // Subscribe to all dependencies. We don't need the previous value,\n    // as the `runImmediately` option controls the initial execution.\n    for (const signal of config_.deps) {\n      this.dependencySubscriptions__.push(signal.subscribe(this.scheduleExecution_, {receivePrevious: false}));\n    }\n\n    // Run the effect immediately if requested.\n    if (config_.runImmediately === true) {\n      // We don't need to await this, let it run in the background.\n      void this.scheduleExecution_();\n    }\n  }\n\n  /**\n   * Schedules the execution of the effect's `run` function.\n   *\n   * This method batches updates using a macrotask (`delay.nextMacrotask`) to ensure the\n   * `run` function executes only once per event loop tick, even if multiple\n   * dependencies change simultaneously.\n   * @protected\n   */\n  protected async scheduleExecution_(): Promise<void> {\n    this.logger_.logMethod?.('scheduleExecution_');\n\n    if (this.isDestroyed__) {\n      this.logger_.incident?.('scheduleExecution_', 'schedule_execution_on_destroyed_signal');\n      return;\n    }\n    if (this.isRunning__) {\n      // If an execution is already scheduled, do nothing.\n      this.logger_.logStep?.('scheduleExecution_', 'skipped_because_already_running');\n      return;\n    }\n\n    this.isRunning__ = true;\n\n    try {\n      // Wait for the next macrotask to batch simultaneous updates.\n      await delay.nextMacrotask();\n      if (this.isDestroyed__) {\n        this.logger_.incident?.('scheduleExecution_', 'destroyed_during_delay');\n        this.isRunning__ = false;\n        return;\n      }\n\n      this.logger_.logStep?.('scheduleExecution_', 'executing_effect');\n      await this.config_.run();\n    }\n    catch (err) {\n      this.logger_.error('scheduleExecution_', 'effect_failed', err);\n    }\n\n    // Reset the flag after the current execution is complete.\n    this.isRunning__ = false;\n  }\n\n  /**\n   * Permanently disposes of the effect signal.\n   *\n   * This is a critical cleanup step. It unsubscribes from all dependency signals,\n   * stopping any future executions of the effect and allowing it to be garbage collected.\n   * Failure to call `destroy()` will result in memory leaks and potentially unwanted side effects.\n   */\n  public destroy(): void {\n    this.logger_.logMethod?.('destroy');\n\n    if (this.isDestroyed__) {\n      this.logger_.incident?.('destroy', 'already_destroyed');\n      return;\n    }\n\n    this.isDestroyed__ = true;\n\n    // Unsubscribe from all upstream dependencies.\n    for (const subscription of this.dependencySubscriptions__) {\n      subscription.unsubscribe();\n    }\n    this.dependencySubscriptions__.length = 0; // Clear the array of subscriptions.\n\n    this.config_.onDestroy?.(); // Call the optional onDestroy callback.\n    this.config_ = null as unknown as EffectSignalConfig; // Release config closure.\n  }\n}\n", "import {EventSignal} from '../core/event-signal.js';\n\nimport type {SignalConfig} from '../type.js';\n\n/**\n * Creates a stateless signal for dispatching transient events.\n *\n * `EventSignal` is ideal for broadcasting events that do not have a persistent state.\n * Unlike `StateSignal`, it does not hold a value. Listeners are only notified of new\n * events as they are dispatched. This makes it suitable for modeling user interactions,\n * system notifications, or any one-off message.\n *\n * @template T The type of the payload for the events.\n *\n * @param config The configuration for the event signal.\n * @returns A new instance of EventSignal.\n *\n * @example\n * const onUserClick = createEventSignal<{ x: number, y: number }>({\n *   signalId: 'on-user-click'\n * });\n *\n * onUserClick.subscribe(pos => {\n *   console.log(`User clicked at: ${pos.x}, ${pos.y}`);\n * });\n *\n * onUserClick.dispatch({ x: 100, y: 250 });\n */\nexport function createEventSignal<T = void>(config: SignalConfig): EventSignal<T> {\n  return new EventSignal<T>(config);\n}\n", "import {StateSignal} from '../core/state-signal.js';\n\nimport type {StateSignalConfig} from '../type.js';\n\n/**\n * Creates a stateful signal that holds a value and notifies listeners when the value changes.\n *\n * `StateSignal` is the core of the signal library, representing a piece of mutable state.\n * It always has a value, and new subscribers immediately receive the current value by default.\n *\n * @template T The type of the state it holds.\n *\n * @param config The configuration for the state signal.\n * @returns A new instance of StateSignal.\n *\n * @example\n * const counter = createStateSignal({\n *   signalId: 'counter-signal',\n *   initialValue: 0,\n * });\n *\n * console.log(counter.get()); // Outputs: 0\n * counter.set(1);\n * console.log(counter.get()); // Outputs: 1\n */\nexport function createStateSignal<T>(config: StateSignalConfig<T>): StateSignal<T> {\n  return new StateSignal(config);\n}\n", "import {ComputedSignal} from '../core/computed-signal.js';\n\nimport type {ComputedSignalConfig} from '../type.js';\n\n/**\n * Creates a read-only signal that derives its value from a set of dependency signals.\n *\n * `ComputedSignal` is a powerful tool for creating values that reactively update when their underlying\n * data sources change. Its value is memoized, meaning the `get` function is only re-evaluated when\n * one of its dependencies has actually changed.\n *\n * A key feature is its lifecycle management: a `ComputedSignal` **must** be destroyed when no longer\n * needed to prevent memory leaks from its subscriptions to dependency signals.\n *\n * @template T The type of the computed value.\n *\n * @param config The configuration for the computed signal.\n * @returns A new, read-only computed signal.\n *\n * @example\n * const firstName = createStateSignal({ signalId: 'firstName', initialValue: 'John' });\n * const lastName = createStateSignal({ signalId: 'lastName', initialValue: 'Doe' });\n *\n * const fullName = createComputedSignal({\n *   signalId: 'fullName',\n *   deps: [firstName, lastName],\n *   get: () => `${firstName.get()} ${lastName.get()}`,\n * });\n *\n * console.log(fullName.get()); // \"John Doe\"\n *\n * // IMPORTANT: Always destroy a computed signal when no longer needed.\n * // fullName.destroy();\n */\nexport function createComputedSignal<T>(config: ComputedSignalConfig<T>): ComputedSignal<T> {\n  return new ComputedSignal(config);\n}\n", "import {EffectSignal} from '../core/effect-signal.js';\n\nimport type {EffectSignalConfig} from '../type.js';\n\n/**\n * Creates a side-effect that runs in response to changes in dependency signals.\n *\n * `EffectSignal` is designed for running logic that interacts with the \"outside world\"—such as\n * logging, network requests, or DOM manipulation—whenever its dependencies are updated.\n * It encapsulates the subscription and cleanup logic, providing a robust and memory-safe\n * way to handle reactive side-effects.\n *\n * A key feature is its lifecycle management: an `EffectSignal` **must** be destroyed when no longer\n * needed to prevent memory leaks and stop the effect from running unnecessarily.\n *\n * @param config The configuration for the effect.\n * @returns An object with a `destroy` method to stop the effect.\n *\n * @example\n * // --- Create dependency signals ---\n * const counter = createStateSignal({ initialValue: 0, signalId: 'counter' });\n * const user = createStateSignal({ initialValue: 'guest', signalId: 'user' });\n *\n * // --- Create an effect ---\n * const analyticsEffect = createEffect({\n *   deps: [counter, user],\n *   run: () => {\n *     console.log(`Analytics: User '${user.get()}' clicked ${counter.get()} times.`);\n *   },\n *   runImmediately: true, // Optional: run once on creation\n * });\n * // Immediately logs: \"Analytics: User 'guest' clicked 0 times.\"\n *\n * // --- Trigger the effect by updating a dependency ---\n * counter.set(1);\n * // After a macrotask, logs: \"Analytics: User 'guest' clicked 1 times.\"\n *\n * // --- IMPORTANT: Clean up when the effect is no longer needed ---\n * analyticsEffect.destroy();\n *\n * // Further updates will not trigger the effect.\n * counter.set(2); // Nothing is logged.\n */\nexport function createEffect(config: EffectSignalConfig): EffectSignal {\n  return new EffectSignal(config);\n}\n", "import {createDebouncer} from '@alwatr/debounce';\n\nimport {StateSignal} from '../core/state-signal.js';\nimport {createComputedSignal} from '../creators/computed.js';\n\nimport type {ComputedSignal} from '../core/computed-signal.js';\nimport type {IReadonlySignal, DebounceSignalConfig} from '../type.js';\n\n/**\n * Creates a new computed signal that debounces updates from a source signal.\n *\n * The returned signal is a `ComputedSignal`, meaning it is read-only and its value is\n * derived from the source. It only updates its value after a specified period of\n * inactivity from the source signal.\n *\n * This operator is essential for handling high-frequency events, such as user input\n * in a search box, resizing a window, or any other event that fires rapidly.\n * By debouncing, you can ensure that expensive operations (like API calls or heavy\n * computations) are only executed once the events have settled.\n *\n * @template T The type of the signal's value.\n *\n * @param {IReadonlySignal<T>} sourceSignal The original signal to debounce.\n * It can be a `StateSignal`, `ComputedSignal`, or any signal implementing `IReadonlySignal`.\n * @param {DebounceSignalConfig} config Configuration object for the debouncer,\n * including `delay`, `leading`, and `trailing` options from `@alwatr/debounce`.\n *\n * @returns {IComputedSignal<T>} A new, read-only computed signal that emits debounced values.\n * Crucially, you **must** call `.destroy()` on this signal when it's no longer\n * needed to prevent memory leaks by cleaning up internal subscriptions and timers.\n *\n * @example\n * ```typescript\n * // Create a source signal for user input.\n * const searchInput = createStateSignal({\n *   signalId: 'search-input',\n *   initialValue: '',\n * });\n *\n * // Create a debounced signal that waits 300ms after the user stops typing.\n * const debouncedSearch = createDebouncedSignal(searchInput, { delay: 300 });\n *\n * // Use an effect to react to the debounced value.\n * createEffect({\n *   deps: [debouncedSearch],\n *   run: () => {\n *     if (debouncedSearch.get()) {\n *       console.log(`🚀 Sending API request for: \"${debouncedSearch.get()}\"`);\n *     }\n *   },\n * });\n *\n * searchInput.set('Alwatr');\n * searchInput.set('Alwatr Signal');\n * // (after 300ms of inactivity)\n * // Logs: \"🚀 Sending API request for: \"Alwatr Signal\"\"\n *\n * // IMPORTANT: Clean up when the component unmounts.\n * // debouncedSearch.destroy();\n * ```\n */\nexport function createDebouncedSignal<T>(sourceSignal: IReadonlySignal<T>, config: DebounceSignalConfig): ComputedSignal<T> {\n  const signalId = config.signalId ?? `${sourceSignal.signalId}-debounced`;\n\n  const internalSignal = new StateSignal<T>({\n    signalId: `${signalId}-internal`,\n    initialValue: sourceSignal.get(),\n  });\n\n  const debouncer = createDebouncer({\n    ...config,\n    func: (value: T): void => {\n      internalSignal.set(value);\n    },\n  });\n\n  const subscription = sourceSignal.subscribe(debouncer.trigger);\n\n  return createComputedSignal({\n    signalId,\n    deps: [internalSignal],\n    get: () => internalSignal.get(),\n    onDestroy: () => {\n      if (internalSignal.isDestroyed) return;\n      subscription.unsubscribe();\n      debouncer.cancel();\n      internalSignal.destroy();\n      config.onDestroy?.();\n      config = null as unknown as DebounceSignalConfig;\n    },\n  });\n}\n"],
+  "mappings": "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",
   "names": ["import_delay", "import_logger", "import_delay", "import_logger", "import_delay", "import_logger"]
 }

package/dist/main.mjs

@@ -1,4 +1,4 @@
-/* @alwatr/signal v5.2.0 */
+/* @alwatr/signal v5.2.1 */
 
 // src/core/signal-base.ts
 var SignalBase = class {
@@ -202,9 +202,9 @@ var StateSignal = class extends SignalBase {
    * @returns The current value.
    *
    * @example
-   * console.log(mySignal.value);
+   * console.log(mySignal.get());
    */
-  get value() {
+  get() {
     this.checkDestroyed_();
     return this.value__;
   }
@@ -221,7 +221,7 @@ var StateSignal = class extends SignalBase {
    * mySignal.set(42);
    *
    * // For object types, it's best practice to set an immutable new object.
-   * mySignal.set({ ...mySignal.value, property: 'new-value' });
+   * mySignal.set({ ...mySignal.get(), property: 'new-value' });
    */
   set(newValue) {
     this.logger_.logMethodArgs?.("set", { newValue });
@@ -301,7 +301,7 @@ var ComputedSignal = class {
     this.logger_ = createLogger3(`computed-signal: ${this.signalId}`);
     /**
      * The internal `StateSignal` that holds the computed value.
-     * This is how the computed signal provides `.value` and `.subscribe()` methods.
+     * This is how the computed signal provides `.get()` and `.subscribe()` methods.
      * @protected
      */
     this.internalSignal_ = new StateSignal({
@@ -331,8 +331,8 @@ var ComputedSignal = class {
    * @returns The current computed value.
    * @throws {Error} If accessed after the signal has been destroyed.
    */
-  get value() {
-    return this.internalSignal_.value;
+  get() {
+    return this.internalSignal_.get();
   }
   /**
    * Indicates whether the computed signal has been destroyed.
@@ -368,7 +368,7 @@ var ComputedSignal = class {
    * stopping future recalculations and allowing the signal to be garbage collected.
    * Failure to call `destroy()` will result in memory leaks.
    *
-   * After `destroy()` is called, any attempt to access `.value` or `.subscribe()` will throw an error.
+   * After `destroy()` is called, any attempt to access `.get()` or `.subscribe()` will throw an error.
    */
   destroy() {
     this.logger_.logMethod?.("destroy");
@@ -450,12 +450,12 @@ var EffectSignal = class {
      */
     this.isDestroyed__ = false;
     this.logger_.logMethod?.("constructor");
-    this.run_ = this.run_.bind(this);
+    this.scheduleExecution_ = this.scheduleExecution_.bind(this);
     for (const signal of config_.deps) {
-      this.dependencySubscriptions__.push(signal.subscribe(this.run_, { receivePrevious: false }));
+      this.dependencySubscriptions__.push(signal.subscribe(this.scheduleExecution_, { receivePrevious: false }));
     }
     if (config_.runImmediately === true) {
-      void this.run_();
+      void this.scheduleExecution_();
     }
   }
   /**
@@ -475,28 +475,28 @@ var EffectSignal = class {
    * dependencies change simultaneously.
    * @protected
    */
-  async run_() {
-    this.logger_.logMethod?.("run_");
+  async scheduleExecution_() {
+    this.logger_.logMethod?.("scheduleExecution_");
     if (this.isDestroyed__) {
-      this.logger_.incident?.("run_", "run_on_destroyed_signal");
+      this.logger_.incident?.("scheduleExecution_", "schedule_execution_on_destroyed_signal");
       return;
     }
     if (this.isRunning__) {
-      this.logger_.logStep?.("run_", "skipped_because_already_running");
+      this.logger_.logStep?.("scheduleExecution_", "skipped_because_already_running");
       return;
     }
     this.isRunning__ = true;
     try {
       await delay4.nextMacrotask();
       if (this.isDestroyed__) {
-        this.logger_.incident?.("run_", "destroyed_during_delay");
+        this.logger_.incident?.("scheduleExecution_", "destroyed_during_delay");
         this.isRunning__ = false;
         return;
       }
-      this.logger_.logStep?.("run_", "executing_effect");
+      this.logger_.logStep?.("scheduleExecution_", "executing_effect");
       await this.config_.run();
     } catch (err) {
-      this.logger_.error("run_", "effect_failed", err);
+      this.logger_.error("scheduleExecution_", "effect_failed", err);
     }
     this.isRunning__ = false;
   }
@@ -549,7 +549,7 @@ function createDebouncedSignal(sourceSignal, config) {
   const signalId = config.signalId ?? `${sourceSignal.signalId}-debounced`;
   const internalSignal = new StateSignal({
     signalId: `${signalId}-internal`,
-    initialValue: sourceSignal.value
+    initialValue: sourceSignal.get()
   });
   const debouncer = createDebouncer({
     ...config,
@@ -561,7 +561,7 @@ function createDebouncedSignal(sourceSignal, config) {
   return createComputedSignal({
     signalId,
     deps: [internalSignal],
-    get: () => internalSignal.value,
+    get: () => internalSignal.get(),
     onDestroy: () => {
       if (internalSignal.isDestroyed) return;
       subscription.unsubscribe();

package/dist/main.mjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/core/signal-base.ts", "../src/core/event-signal.ts", "../src/core/state-signal.ts", "../src/core/computed-signal.ts", "../src/core/effect-signal.ts", "../src/creators/event.ts", "../src/creators/state.ts", "../src/creators/computed.ts", "../src/creators/effect.ts", "../src/operators/debounce.ts"],
-  "sourcesContent": ["import type {Observer_, SubscribeOptions, SubscribeResult, ListenerCallback, SignalConfig} from '../type.js';\nimport type {AlwatrLogger} from '@alwatr/logger';\nimport type {} from '@alwatr/nano-build';\n\n/**\n * An abstract base class for signal implementations.\n * It provides the core functionality for managing subscriptions (observers).\n *\n * @template T The type of data that the signal holds or dispatches.\n */\nexport abstract class SignalBase<T> {\n  /**\n   * The unique identifier for this signal instance.\n   * Useful for debugging and logging.\n   */\n  public readonly signalId = this.config_.signalId;\n\n  /**\n   * The logger instance for this signal.\n   * @protected\n   */\n  protected abstract logger_: AlwatrLogger;\n\n  /**\n   * The list of observers (listeners) subscribed to this signal.\n   * @protected\n   */\n  protected readonly observers_: Observer_<T>[] = [];\n\n  /**\n   * A flag indicating whether the signal has been destroyed.\n   * @private\n   */\n  private isDestroyed__ = false;\n\n  /**\n   * Indicates whether the signal has been destroyed.\n   * A destroyed signal cannot be used and will throw an error if interacted with.\n   *\n   * @returns `true` if the signal is destroyed, `false` otherwise.\n   */\n  public get isDestroyed(): boolean {\n    return this.isDestroyed__;\n  }\n\n  public constructor(protected config_: SignalConfig) {}\n\n  /**\n   * Removes a specific observer from the observers list.\n   *\n   * @param observer The observer instance to remove.\n   * @protected\n   */\n  protected removeObserver_(observer: Observer_<T>): void {\n    this.logger_.logMethod?.('removeObserver_');\n\n    if (this.isDestroyed__) {\n      this.logger_.incident?.('removeObserver_', 'remove_observer_on_destroyed_signal');\n      return;\n    }\n\n    const index = this.observers_.indexOf(observer);\n    if (index !== -1) {\n      this.observers_.splice(index, 1);\n    }\n  }\n\n  /**\n   * Subscribes a listener function to this signal.\n   *\n   * The listener will be called whenever the signal is notified (e.g., when `dispatch` or `set` is called).\n   *\n   * @param callback The function to be called when the signal is dispatched.\n   * @param options Subscription options to customize the behavior (e.g., `once`, `priority`).\n   * @returns A `SubscribeResult` object with an `unsubscribe` method to remove the listener.\n   */\n  public subscribe(callback: ListenerCallback<T>, options?: SubscribeOptions): SubscribeResult {\n    this.logger_.logMethodArgs?.('subscribe.base', {options});\n    this.checkDestroyed_();\n\n    const observer: Observer_<T> = {callback, options};\n\n    if (options?.priority) {\n      // High-priority observers are added to the front of the queue.\n      this.observers_.unshift(observer);\n    }\n    else {\n      this.observers_.push(observer);\n    }\n\n    // The returned unsubscribe function is a closure that calls the internal removal method.\n    return {\n      unsubscribe: (): void => this.removeObserver_(observer),\n    };\n  }\n\n  /**\n   * Notifies all registered observers about a new value.\n   *\n   * This method iterates through a snapshot of the current observers to prevent issues\n   * with subscriptions changing during notification (e.g., an observer unsubscribing itself).\n   *\n   * @param value The new value to notify observers about.\n   * @protected\n   */\n  protected notify_(value: T): void {\n    this.logger_.logMethodArgs?.('notify_', value);\n\n    if (this.isDestroyed__) {\n      this.logger_.incident?.('notify_', 'notify_on_destroyed_signal');\n      return;\n    }\n\n    // Create a snapshot of the observers array to iterate over.\n    // This prevents issues if the observers_ array is modified during the loop.\n    const currentObservers = [...this.observers_];\n\n    for (const observer of currentObservers) {\n      if (observer.options?.once) {\n        this.removeObserver_(observer);\n      }\n\n      try {\n        const result = observer.callback(value);\n        if (result instanceof Promise) {\n          result.catch((err) => this.logger_.error('notify_', 'async_callback_failed', err, {observer}));\n        }\n      }\n      catch (err) {\n        this.logger_.error('notify_', 'sync_callback_failed', err);\n      }\n    }\n  }\n\n  /**\n   * Returns a Promise that resolves with the next value dispatched by the signal.\n   * This provides an elegant way to wait for a single, future event using `async/await`.\n   *\n   * @returns A Promise that resolves with the next dispatched value.\n   *\n   * @example\n   * async function onButtonClick() {\n   *   console.log('Waiting for the next signal...');\n   *   const nextValue = await mySignal.untilNext();\n   *   console.log('Signal received:', nextValue);\n   * }\n   */\n  public untilNext(): Promise<T> {\n    this.logger_.logMethod?.('untilNext');\n    this.checkDestroyed_();\n    return new Promise((resolve) => {\n      this.subscribe(resolve, {\n        once: true,\n        priority: true, // Resolve the promise before other listeners are called.\n        receivePrevious: false, // We only want the *next* value, not the current one.\n      });\n    });\n  }\n\n  /**\n   * Destroys the signal, clearing all its listeners and making it inactive.\n   *\n   * After destruction, any interaction with the signal (like `subscribe` or `untilNext`)\n   * will throw an error. This is crucial for preventing memory leaks by allowing\n   * garbage collection of the signal and its observers.\n   */\n  public destroy(): void {\n    this.logger_.logMethod?.('destroy');\n    if (this.isDestroyed__) {\n      this.logger_.incident?.('destroy_', 'double_destroy_attempt');\n      return;\n    }\n    this.isDestroyed__ = true;\n    this.observers_.length = 0; // Clear all observers.\n    this.config_.onDestroy?.(); // Call the optional onDestroy callback.\n    this.config_ = null as unknown as SignalConfig; // Help GC by breaking references.\n  }\n\n  /**\n   * Throws an error if the signal has been destroyed.\n   * This is a safeguard to prevent interaction with a defunct signal.\n   * @protected\n   */\n  protected checkDestroyed_(): void {\n    if (this.isDestroyed__) {\n      this.logger_.accident('checkDestroyed_', 'attempt_to_use_destroyed_signal');\n      throw new Error(`Cannot interact with a destroyed signal (id: ${this.signalId})`);\n    }\n  }\n}\n", "import {delay} from '@alwatr/delay';\nimport {createLogger} from '@alwatr/logger';\n\nimport {SignalBase} from './signal-base.js';\n\nimport type {SignalConfig} from '../type.js';\n\n/**\n * A stateless signal for dispatching transient events.\n *\n * `EventSignal` is ideal for broadcasting events that do not have a persistent state.\n * Unlike `StateSignal`, it does not hold a value. Listeners are only notified of new\n * events as they are dispatched. This makes it suitable for modeling user interactions,\n * system notifications, or any one-off message.\n *\n * @template T The type of the payload for the events. Defaults to `void` for events without a payload.\n *\n * @example\n * // Create a signal for user click events.\n * const onUserClick = new EventSignal<{ x: number, y: number }>({ signalId: 'on-user-click' });\n *\n * // Subscribe to the event.\n * onUserClick.subscribe(clickPosition => {\n *   console.log(`User clicked at: ${clickPosition.x}, ${clickPosition.y}`);\n * });\n *\n * // Dispatch an event.\n * onUserClick.dispatch({ x: 100, y: 250 }); // Notifies the listener.\n *\n * // --- Example with no payload ---\n * const onAppReady = new EventSignal({ signalId: 'on-app-ready' });\n * onAppReady.subscribe(() => console.log('Application is ready!'));\n * onAppReady.dispatch(); // Notifies the listener.\n */\nexport class EventSignal<T = void> extends SignalBase<T> {\n  /**\n   * The logger instance for this signal.\n   * @protected\n   */\n  protected logger_ = createLogger(`event-signal: ${this.signalId}`);\n\n  public constructor(config: SignalConfig) {\n    super(config);\n    this.logger_.logMethod?.('constructor');\n  }\n\n  /**\n   * Dispatches an event with an optional payload to all active listeners.\n   * The notification is scheduled as a microtask to prevent blocking and ensure\n   * a consistent, non-blocking flow.\n   *\n   * @param payload The data to send with the event.\n   */\n  public dispatch(payload: T): void {\n    this.logger_.logMethodArgs?.('dispatch', {payload});\n    this.checkDestroyed_();\n    // Dispatch as a microtask to ensure consistent, non-blocking behavior.\n    delay.nextMicrotask().then(() => this.notify_(payload));\n  }\n}\n", "import {delay} from '@alwatr/delay';\nimport {createLogger} from '@alwatr/logger';\n\nimport {SignalBase} from './signal-base.js';\n\nimport type {StateSignalConfig, ListenerCallback, SubscribeOptions, SubscribeResult, IReadonlySignal} from '../type.js';\n\n/**\n * A stateful signal that holds a value and notifies listeners when the value changes.\n *\n * `StateSignal` is the core of the signal library, representing a piece of mutable state.\n * It always has a value, and new subscribers immediately receive the current value by default.\n *\n * @template T The type of the state it holds.\n * @implements {IReadonlySignal<T>}\n *\n * @example\n * // Create a new state signal with an initial value.\n * const counter = new StateSignal<number>({\n *   signalId: 'counter-signal',\n *   initialValue: 0,\n * });\n *\n * // Get the current value.\n * console.log(counter.value); // Outputs: 0\n *\n * // Subscribe to changes.\n * const subscription = counter.subscribe(newValue => {\n *   console.log(`Counter changed to: ${newValue}`);\n * });\n *\n * // Set a new value, which triggers the notification.\n * counter.set(1); // Outputs: \"Counter changed to: 1\"\n *\n * // Update value based on the previous value.\n * counter.update(current => current + 1); // Outputs: \"Counter changed to: 2\"\n *\n * // Unsubscribe when no longer needed.\n * subscription.unsubscribe();\n */\nexport class StateSignal<T> extends SignalBase<T> implements IReadonlySignal<T> {\n  /**\n   * The current value of the signal.\n   * @private\n   */\n  private value__: T;\n\n  /**\n   * The logger instance for this signal.\n   * @protected\n   */\n  protected logger_ = createLogger(`state-signal: ${this.signalId}`);\n\n  public constructor(config: StateSignalConfig<T>) {\n    super(config);\n    this.value__ = config.initialValue;\n    this.logger_.logMethodArgs?.('constructor', {initialValue: this.value__});\n  }\n\n  /**\n   * Retrieves the current value of the signal.\n   *\n   * @returns The current value.\n   *\n   * @example\n   * console.log(mySignal.value);\n   */\n  public get value(): T {\n    this.checkDestroyed_();\n    return this.value__;\n  }\n\n  /**\n   * Updates the signal's value and notifies all active listeners.\n   *\n   * The notification is scheduled as a microtask, which means the update is deferred\n   * slightly to batch multiple synchronous changes.\n   *\n   * @param newValue The new value to set.\n   *\n   * @example\n   * // For primitive types\n   * mySignal.set(42);\n   *\n   * // For object types, it's best practice to set an immutable new object.\n   * mySignal.set({ ...mySignal.value, property: 'new-value' });\n   */\n  public set(newValue: T): void {\n    this.logger_.logMethodArgs?.('set', {newValue});\n    this.checkDestroyed_();\n\n    // For primitives (including null), do not notify if the value is the same.\n    if (Object.is(this.value__, newValue) && (typeof newValue !== 'object' || newValue === null)) {\n      return;\n    }\n\n    this.value__ = newValue;\n\n    // Dispatch as a microtask to ensure consistent, non-blocking behavior.\n    delay.nextMicrotask().then(() => this.notify_(newValue));\n  }\n\n  /**\n   * Updates the signal's value based on its previous value.\n   *\n   * This method is particularly useful for state transitions that depend on the current value,\n   * especially for objects or arrays, as it promotes an immutable update pattern.\n   *\n   * @param updater A function that receives the current value and returns the new value.\n   *\n   * @example\n   * // For a counter\n   * counterSignal.update(current => current + 1);\n   *\n   * // For an object state\n   * userSignal.update(currentUser => ({ ...currentUser, loggedIn: true }));\n   */\n  public update(updater: (previousValue: T) => T): void {\n    this.logger_.logMethod?.('update');\n    this.checkDestroyed_();\n    // The updater function is called with the current value to compute the new value,\n    // which is then passed to the `set` method.\n    this.set(updater(this.value__));\n  }\n\n  /**\n   * Subscribes a listener to this signal.\n   *\n   * By default, the listener is immediately called with the signal's current value (`receivePrevious: true`).\n   * This behavior can be customized via the `options` parameter.\n   *\n   * @param callback The function to be called when the signal's value changes.\n   * @param options Subscription options, including `receivePrevious` and `once`.\n   * @returns An object with an `unsubscribe` method to remove the listener.\n   */\n  public override subscribe(callback: ListenerCallback<T>, options: SubscribeOptions = {}): SubscribeResult {\n    this.logger_.logMethodArgs?.('subscribe', {options});\n    this.checkDestroyed_();\n\n    // By default, new subscribers to a StateSignal should receive the current value.\n    if (options.receivePrevious !== false) {\n      // Immediately (but asynchronously) call the listener with the current value.\n      // This is done in a microtask to ensure it happens after the subscription is fully registered.\n      delay\n        .nextMicrotask()\n        .then(() => callback(this.value__))\n        .catch((err) => this.logger_.error('subscribe', 'immediate_callback_failed', err));\n\n      // If it's a 'once' subscription that receives the previous value, it's now fulfilled.\n      // We don't need to add it to the observers list for future updates.\n      if (options.once) {\n        // eslint-disable-next-line @typescript-eslint/no-empty-function\n        return {unsubscribe: () => {}};\n      }\n    }\n\n    return super.subscribe(callback, options);\n  }\n\n  /**\n   * Destroys the signal, clearing its value and all listeners.\n   * This is crucial for memory management to prevent leaks.\n   */\n  public override destroy(): void {\n    this.value__ = null as T; // Clear the value to allow for garbage collection.\n    super.destroy();\n  }\n}\n", "import {delay} from '@alwatr/delay';\nimport {createLogger} from '@alwatr/logger';\n\nimport {StateSignal} from './state-signal.js';\n\nimport type {ComputedSignalConfig, IReadonlySignal, SubscribeResult, SubscribeOptions} from '../type.js';\n\n/**\n * A read-only signal that derives its value from a set of dependency signals.\n *\n * `ComputedSignal` is a powerful tool for creating values that reactively update when their underlying\n * data sources change. Its value is memoized, meaning the `get` function is only re-evaluated when\n * one of its dependencies has actually changed.\n *\n * A key feature is its lifecycle management: a `ComputedSignal` **must** be destroyed when no longer\n * needed to prevent memory leaks from its subscriptions to dependency signals.\n *\n * @template T The type of the computed value.\n *\n * @example\n * // --- Create dependency signals ---\n * const firstName = new StateSignal({ signalId: 'firstName', initialValue: 'John' });\n * const lastName = new StateSignal({ signalId: 'lastName', initialValue: 'Doe' });\n *\n * // --- Create a computed signal ---\n * const fullName = new ComputedSignal({\n *   signalId: 'fullName',\n *   deps: [firstName, lastName],\n *   get: () => `${firstName.value} ${lastName.value}`,\n * });\n *\n * console.log(fullName.value); // Outputs: \"John Doe\"\n *\n * // --- Subscribe to the computed value ---\n * fullName.subscribe(newFullName => {\n *   console.log(`Name changed to: ${newFullName}`);\n * });\n *\n * // --- Update a dependency ---\n * lastName.set('Smith'); // Recalculates and logs: \"Name changed to: John Smith\"\n * console.log(fullName.value); // Outputs: \"John Smith\"\n *\n * // --- IMPORTANT: Clean up when done ---\n * fullName.destroy();\n */\nexport class ComputedSignal<T> implements IReadonlySignal<T> {\n  /**\n   * The unique identifier for this signal instance.\n   */\n  public readonly signalId = this.config_.signalId;\n\n  /**\n   * The logger instance for this signal.\n   * @protected\n   */\n  protected readonly logger_ = createLogger(`computed-signal: ${this.signalId}`);\n\n  /**\n   * The internal `StateSignal` that holds the computed value.\n   * This is how the computed signal provides `.value` and `.subscribe()` methods.\n   * @protected\n   */\n  protected readonly internalSignal_ = new StateSignal<T>({\n    signalId: `${this.signalId}-internal`,\n    initialValue: this.config_.get(),\n  });\n\n  /**\n   * A list of subscriptions to dependency signals.\n   * @private\n   */\n\n  private readonly dependencySubscriptions__: SubscribeResult[] = [];\n\n  /**\n   * A flag to prevent concurrent recalculations.\n   * @private\n   */\n  private isRecalculating__ = false;\n\n  public constructor(protected config_: ComputedSignalConfig<T>) {\n    this.logger_.logMethod?.('constructor');\n    this.recalculate_ = this.recalculate_.bind(this);\n\n    // Subscribe to all dependencies to trigger recalculation on change.\n    for (const signal of config_.deps) {\n      this.dependencySubscriptions__.push(signal.subscribe(this.recalculate_, {receivePrevious: false}));\n    }\n  }\n\n  /**\n   * The current value of the computed signal.\n   * Accessing this property returns the memoized value and does not trigger a recalculation.\n   *\n   * @returns The current computed value.\n   * @throws {Error} If accessed after the signal has been destroyed.\n   */\n  public get value(): T {\n    return this.internalSignal_.value;\n  }\n\n  /**\n   * Indicates whether the computed signal has been destroyed.\n   * A destroyed signal cannot be used and will throw an error if interacted with.\n   * @returns `true` if the signal is destroyed, `false` otherwise.\n   */\n  public get isDestroyed(): boolean {\n    return this.internalSignal_.isDestroyed;\n  }\n\n  /**\n   * Subscribes a listener to this signal.\n   * The listener will be called whenever the computed value changes.\n   *\n   * @param callback The function to be called with the new value.\n   * @param options Subscription options.\n   * @returns A `SubscribeResult` object with an `unsubscribe` method.\n   */\n  public subscribe(callback: (value: T) => void, options?: SubscribeOptions): SubscribeResult {\n    return this.internalSignal_.subscribe(callback, options);\n  }\n\n  /**\n   * Returns a Promise that resolves with the next computed value.\n   *\n   * @returns A Promise that resolves with the next value.\n   */\n  public untilNext(): Promise<T> {\n    return this.internalSignal_.untilNext();\n  }\n\n  /**\n   * Permanently disposes of the computed signal.\n   *\n   * This is a critical cleanup step. It unsubscribes from all dependency signals,\n   * stopping future recalculations and allowing the signal to be garbage collected.\n   * Failure to call `destroy()` will result in memory leaks.\n   *\n   * After `destroy()` is called, any attempt to access `.value` or `.subscribe()` will throw an error.\n   */\n  public destroy(): void {\n    this.logger_.logMethod?.('destroy');\n    /**\n     * If already destroyed, log an incident and return early.\n     */\n    if (this.isDestroyed) {\n      this.logger_.incident?.('destroy', 'already_destroyed');\n      return;\n    }\n\n    // Unsubscribe from all upstream dependencies.\n    for (const subscription of this.dependencySubscriptions__) {\n      subscription.unsubscribe();\n    }\n    this.dependencySubscriptions__.length = 0; // Clear the array of subscriptions.\n\n    this.internalSignal_.destroy(); // Destroy the internal signal.\n    this.config_.onDestroy?.(); // Call the optional onDestroy callback.\n    this.config_ = null as unknown as ComputedSignalConfig<T>; // Release config closure.\n  }\n\n  /**\n   * Schedules a recalculation of the signal's value.\n   *\n   * This method batches updates using a macrotask (`delay.nextMacrotask`) to ensure the\n   * `get` function runs only once per event loop tick, even if multiple dependencies\n   * change in the same synchronous block of code.\n   * @protected\n   */\n  protected async recalculate_(): Promise<void> {\n    this.logger_.logMethod?.('recalculate_');\n\n    if (this.internalSignal_.isDestroyed) {\n      // This check is important in case a dependency fires after this signal is destroyed.\n      this.logger_.incident?.('recalculate_', 'recalculate_on_destroyed_signal');\n      return;\n    }\n\n    if (this.isRecalculating__) {\n      // If a recalculation is already scheduled, do nothing.\n      this.logger_.logStep?.('recalculate_', 'skipping_recalculation_already_scheduled');\n      return;\n    }\n\n    this.isRecalculating__ = true;\n\n    try {\n      // Wait for the next macrotask to start the recalculation.\n      // This batches all synchronous dependency updates in the current event loop.\n      await delay.nextMacrotask();\n      \n      if (this.isDestroyed) {\n        this.logger_.incident?.('recalculate_', 'destroyed_during_delay');\n        this.isRecalculating__ = false;\n        return;\n      }\n\n      this.logger_.logStep?.('recalculate_', 'recalculating_value');\n\n      // Set the new value on the internal signal, which will notify our subscribers.\n      this.internalSignal_.set(this.config_.get());\n    }\n    catch (err) {\n      this.logger_.error('recalculate_', 'recalculation_failed', err);\n    }\n\n    // Allow the next recalculation to be scheduled.\n    this.isRecalculating__ = false;\n  }\n}\n", "import {delay} from '@alwatr/delay';\nimport {createLogger} from '@alwatr/logger';\n\nimport type {EffectSignalConfig, IEffectSignal, SubscribeResult} from '../type.js';\n\n/**\n * Manages a side-effect that runs in response to changes in dependency signals.\n *\n * `EffectSignal` is designed for running logic that interacts with the \"outside world\"—such as\n * logging, network requests, or DOM manipulation—whenever its dependencies are updated.\n * It encapsulates the subscription and cleanup logic, providing a robust and memory-safe\n * way to handle reactive side-effects.\n *\n * A key feature is its lifecycle management: an `EffectSignal` **must** be destroyed when no longer\n * needed to prevent memory leaks and stop the effect from running unnecessarily.\n *\n * @implements {IEffectSignal}\n *\n * @example\n * // --- Create dependency signals ---\n * const counter = new StateSignal({ initialValue: 0, signalId: 'counter' });\n * const user = new StateSignal({ initialValue: 'guest', signalId: 'user' });\n *\n * // --- Create an effect ---\n * const analyticsEffect = new EffectSignal({\n *   signalId: 'analytics-effect',\n *   deps: [counter, user],\n *   run: () => {\n *     console.log(`Analytics: User '${user.value}' clicked ${counter.value} times.`);\n *   },\n *   runImmediately: true, // Optional: run once on creation\n * });\n * // Immediately logs: \"Analytics: User 'guest' clicked 0 times.\"\n *\n * // --- Trigger the effect by updating a dependency ---\n * counter.set(1);\n * // After a macrotask, logs: \"Analytics: User 'guest' clicked 1 times.\"\n *\n * // --- IMPORTANT: Clean up when the effect is no longer needed ---\n * analyticsEffect.destroy();\n *\n * // Further updates will not trigger the effect.\n * counter.set(2); // Nothing is logged.\n */\nexport class EffectSignal implements IEffectSignal {\n  /**\n   * The unique identifier for this signal instance.\n   */\n  public readonly signalId = this.config_.signalId ? this.config_.signalId : `[${this.config_.deps.map((dep) => dep.signalId).join(', ')}]`;\n\n  /**\n   * The logger instance for this signal.\n   * @protected\n   */\n  protected readonly logger_ = createLogger(`effect-signal: ${this.signalId}`);\n\n  /**\n   * A list of subscriptions to dependency signals.\n   * @private\n   */\n  private readonly dependencySubscriptions__: SubscribeResult[] = [];\n\n  /**\n   * A flag to prevent concurrent executions of the effect.\n   * @private\n   */\n  private isRunning__ = false;\n\n  /**\n   * A flag indicating whether the effect has been destroyed.\n   * @private\n   */\n  private isDestroyed__ = false;\n\n  /**\n   * Indicates whether the effect signal has been destroyed.\n   * A destroyed signal will no longer execute its effect and cannot be reused.\n   *\n   * @returns `true` if the signal is destroyed, `false` otherwise.\n   */\n  public get isDestroyed(): boolean {\n    return this.isDestroyed__;\n  }\n\n  public constructor(protected config_: EffectSignalConfig) {\n    this.logger_.logMethod?.('constructor');\n    this.run_ = this.run_.bind(this);\n\n    // Subscribe to all dependencies. We don't need the previous value,\n    // as the `runImmediately` option controls the initial execution.\n    for (const signal of config_.deps) {\n      this.dependencySubscriptions__.push(signal.subscribe(this.run_, {receivePrevious: false}));\n    }\n\n    // Run the effect immediately if requested.\n    if (config_.runImmediately === true) {\n      // We don't need to await this, let it run in the background.\n      void this.run_();\n    }\n  }\n\n  /**\n   * Schedules the execution of the effect's `run` function.\n   *\n   * This method batches updates using a macrotask (`delay.nextMacrotask`) to ensure the\n   * `run` function executes only once per event loop tick, even if multiple\n   * dependencies change simultaneously.\n   * @protected\n   */\n  protected async run_(): Promise<void> {\n    this.logger_.logMethod?.('run_');\n\n    if (this.isDestroyed__) {\n      this.logger_.incident?.('run_', 'run_on_destroyed_signal');\n      return;\n    }\n    if (this.isRunning__) {\n      // If an execution is already scheduled, do nothing.\n      this.logger_.logStep?.('run_', 'skipped_because_already_running');\n      return;\n    }\n\n    this.isRunning__ = true;\n\n    try {\n      // Wait for the next macrotask to batch simultaneous updates.\n      await delay.nextMacrotask();\n      if (this.isDestroyed__) {\n        this.logger_.incident?.('run_', 'destroyed_during_delay');\n        this.isRunning__ = false;\n        return;\n      }\n\n      this.logger_.logStep?.('run_', 'executing_effect');\n      await this.config_.run();\n    }\n    catch (err) {\n      this.logger_.error('run_', 'effect_failed', err);\n    }\n\n    // Reset the flag after the current execution is complete.\n    this.isRunning__ = false;\n  }\n\n  /**\n   * Permanently disposes of the effect signal.\n   *\n   * This is a critical cleanup step. It unsubscribes from all dependency signals,\n   * stopping any future executions of the effect and allowing it to be garbage collected.\n   * Failure to call `destroy()` will result in memory leaks and potentially unwanted side effects.\n   */\n  public destroy(): void {\n    this.logger_.logMethod?.('destroy');\n\n    if (this.isDestroyed__) {\n      this.logger_.incident?.('destroy', 'already_destroyed');\n      return;\n    }\n\n    this.isDestroyed__ = true;\n\n    // Unsubscribe from all upstream dependencies.\n    for (const subscription of this.dependencySubscriptions__) {\n      subscription.unsubscribe();\n    }\n    this.dependencySubscriptions__.length = 0; // Clear the array of subscriptions.\n\n    this.config_.onDestroy?.(); // Call the optional onDestroy callback.\n    this.config_ = null as unknown as EffectSignalConfig; // Release config closure.\n  }\n}\n", "import {EventSignal} from '../core/event-signal.js';\n\nimport type {SignalConfig} from '../type.js';\n\n/**\n * Creates a stateless signal for dispatching transient events.\n *\n * `EventSignal` is ideal for broadcasting events that do not have a persistent state.\n * Unlike `StateSignal`, it does not hold a value. Listeners are only notified of new\n * events as they are dispatched. This makes it suitable for modeling user interactions,\n * system notifications, or any one-off message.\n *\n * @template T The type of the payload for the events.\n *\n * @param config The configuration for the event signal.\n * @returns A new instance of EventSignal.\n *\n * @example\n * const onUserClick = createEventSignal<{ x: number, y: number }>({\n *   signalId: 'on-user-click'\n * });\n *\n * onUserClick.subscribe(pos => {\n *   console.log(`User clicked at: ${pos.x}, ${pos.y}`);\n * });\n *\n * onUserClick.dispatch({ x: 100, y: 250 });\n */\nexport function createEventSignal<T = void>(config: SignalConfig): EventSignal<T> {\n  return new EventSignal<T>(config);\n}\n", "import {StateSignal} from '../core/state-signal.js';\n\nimport type {StateSignalConfig} from '../type.js';\n\n/**\n * Creates a stateful signal that holds a value and notifies listeners when the value changes.\n *\n * `StateSignal` is the core of the signal library, representing a piece of mutable state.\n * It always has a value, and new subscribers immediately receive the current value by default.\n *\n * @template T The type of the state it holds.\n *\n * @param config The configuration for the state signal.\n * @returns A new instance of StateSignal.\n *\n * @example\n * const counter = createStateSignal({\n *   signalId: 'counter-signal',\n *   initialValue: 0,\n * });\n *\n * console.log(counter.value); // Outputs: 0\n * counter.set(1);\n * console.log(counter.value); // Outputs: 1\n */\nexport function createStateSignal<T>(config: StateSignalConfig<T>): StateSignal<T> {\n  return new StateSignal(config);\n}\n", "import {ComputedSignal} from '../core/computed-signal.js';\n\nimport type {ComputedSignalConfig} from '../type.js';\n\n/**\n * Creates a read-only signal that derives its value from a set of dependency signals.\n *\n * `ComputedSignal` is a powerful tool for creating values that reactively update when their underlying\n * data sources change. Its value is memoized, meaning the `get` function is only re-evaluated when\n * one of its dependencies has actually changed.\n *\n * A key feature is its lifecycle management: a `ComputedSignal` **must** be destroyed when no longer\n * needed to prevent memory leaks from its subscriptions to dependency signals.\n *\n * @template T The type of the computed value.\n *\n * @param config The configuration for the computed signal.\n * @returns A new, read-only computed signal.\n *\n * @example\n * const firstName = createStateSignal({ signalId: 'firstName', initialValue: 'John' });\n * const lastName = createStateSignal({ signalId: 'lastName', initialValue: 'Doe' });\n *\n * const fullName = createComputedSignal({\n *   signalId: 'fullName',\n *   deps: [firstName, lastName],\n *   get: () => `${firstName.value} ${lastName.value}`,\n * });\n *\n * console.log(fullName.value); // \"John Doe\"\n *\n * // IMPORTANT: Always destroy a computed signal when no longer needed.\n * // fullName.destroy();\n */\nexport function createComputedSignal<T>(config: ComputedSignalConfig<T>): ComputedSignal<T> {\n  return new ComputedSignal(config);\n}\n", "import {EffectSignal} from '../core/effect-signal.js';\n\nimport type {EffectSignalConfig} from '../type.js';\n\n/**\n * Creates a side-effect that runs in response to changes in dependency signals.\n *\n * `EffectSignal` is designed for running logic that interacts with the \"outside world\"—such as\n * logging, network requests, or DOM manipulation—whenever its dependencies are updated.\n * It encapsulates the subscription and cleanup logic, providing a robust and memory-safe\n * way to handle reactive side-effects.\n *\n * A key feature is its lifecycle management: an `EffectSignal` **must** be destroyed when no longer\n * needed to prevent memory leaks and stop the effect from running unnecessarily.\n *\n * @param config The configuration for the effect.\n * @returns An object with a `destroy` method to stop the effect.\n *\n * @example\n * // --- Create dependency signals ---\n * const counter = createStateSignal({ initialValue: 0, signalId: 'counter' });\n * const user = createStateSignal({ initialValue: 'guest', signalId: 'user' });\n *\n * // --- Create an effect ---\n * const analyticsEffect = createEffect({\n *   deps: [counter, user],\n *   run: () => {\n *     console.log(`Analytics: User '${user.value}' clicked ${counter.value} times.`);\n *   },\n *   runImmediately: true, // Optional: run once on creation\n * });\n * // Immediately logs: \"Analytics: User 'guest' clicked 0 times.\"\n *\n * // --- Trigger the effect by updating a dependency ---\n * counter.set(1);\n * // After a macrotask, logs: \"Analytics: User 'guest' clicked 1 times.\"\n *\n * // --- IMPORTANT: Clean up when the effect is no longer needed ---\n * analyticsEffect.destroy();\n *\n * // Further updates will not trigger the effect.\n * counter.set(2); // Nothing is logged.\n */\nexport function createEffect(config: EffectSignalConfig): EffectSignal {\n  return new EffectSignal(config);\n}\n", "import {createDebouncer} from '@alwatr/debounce';\n\nimport {StateSignal} from '../core/state-signal.js';\nimport {createComputedSignal} from '../creators/computed.js';\n\nimport type {ComputedSignal} from '../core/computed-signal.js';\nimport type {IReadonlySignal, DebounceSignalConfig} from '../type.js';\n\n/**\n * Creates a new computed signal that debounces updates from a source signal.\n *\n * The returned signal is a `ComputedSignal`, meaning it is read-only and its value is\n * derived from the source. It only updates its value after a specified period of\n * inactivity from the source signal.\n *\n * This operator is essential for handling high-frequency events, such as user input\n * in a search box, resizing a window, or any other event that fires rapidly.\n * By debouncing, you can ensure that expensive operations (like API calls or heavy\n * computations) are only executed once the events have settled.\n *\n * @template T The type of the signal's value.\n *\n * @param {IReadonlySignal<T>} sourceSignal The original signal to debounce.\n * It can be a `StateSignal`, `ComputedSignal`, or any signal implementing `IReadonlySignal`.\n * @param {DebounceSignalConfig} config Configuration object for the debouncer,\n * including `delay`, `leading`, and `trailing` options from `@alwatr/debounce`.\n *\n * @returns {IComputedSignal<T>} A new, read-only computed signal that emits debounced values.\n * Crucially, you **must** call `.destroy()` on this signal when it's no longer\n * needed to prevent memory leaks by cleaning up internal subscriptions and timers.\n *\n * @example\n * ```typescript\n * // Create a source signal for user input.\n * const searchInput = createStateSignal({\n *   signalId: 'search-input',\n *   initialValue: '',\n * });\n *\n * // Create a debounced signal that waits 300ms after the user stops typing.\n * const debouncedSearch = createDebouncedSignal(searchInput, { delay: 300 });\n *\n * // Use an effect to react to the debounced value.\n * createEffect({\n *   deps: [debouncedSearch],\n *   run: () => {\n *     if (debouncedSearch.value) {\n *       console.log(`🚀 Sending API request for: \"${debouncedSearch.value}\"`);\n *     }\n *   },\n * });\n *\n * searchInput.set('Alwatr');\n * searchInput.set('Alwatr Signal');\n * // (after 300ms of inactivity)\n * // Logs: \"🚀 Sending API request for: \"Alwatr Signal\"\"\n *\n * // IMPORTANT: Clean up when the component unmounts.\n * // debouncedSearch.destroy();\n * ```\n */\nexport function createDebouncedSignal<T>(sourceSignal: IReadonlySignal<T>, config: DebounceSignalConfig): ComputedSignal<T> {\n  const signalId = config.signalId ?? `${sourceSignal.signalId}-debounced`;\n\n  const internalSignal = new StateSignal<T>({\n    signalId: `${signalId}-internal`,\n    initialValue: sourceSignal.value,\n  });\n\n  const debouncer = createDebouncer({\n    ...config,\n    func: (value: T): void => {\n      internalSignal.set(value);\n    },\n  });\n\n  const subscription = sourceSignal.subscribe(debouncer.trigger);\n\n  return createComputedSignal({\n    signalId,\n    deps: [internalSignal],\n    get: () => internalSignal.value,\n    onDestroy: () => {\n      if (internalSignal.isDestroyed) return;\n      subscription.unsubscribe();\n      debouncer.cancel();\n      internalSignal.destroy();\n      config.onDestroy?.();\n      config = null as unknown as DebounceSignalConfig;\n    },\n  });\n}\n"],
-  "mappings": "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",
+  "sourcesContent": ["import type {Observer_, SubscribeOptions, SubscribeResult, ListenerCallback, SignalConfig} from '../type.js';\nimport type {AlwatrLogger} from '@alwatr/logger';\nimport type {} from '@alwatr/nano-build';\n\n/**\n * An abstract base class for signal implementations.\n * It provides the core functionality for managing subscriptions (observers).\n *\n * @template T The type of data that the signal holds or dispatches.\n */\nexport abstract class SignalBase<T> {\n  /**\n   * The unique identifier for this signal instance.\n   * Useful for debugging and logging.\n   */\n  public readonly signalId = this.config_.signalId;\n\n  /**\n   * The logger instance for this signal.\n   * @protected\n   */\n  protected abstract logger_: AlwatrLogger;\n\n  /**\n   * The list of observers (listeners) subscribed to this signal.\n   * @protected\n   */\n  protected readonly observers_: Observer_<T>[] = [];\n\n  /**\n   * A flag indicating whether the signal has been destroyed.\n   * @private\n   */\n  private isDestroyed__ = false;\n\n  /**\n   * Indicates whether the signal has been destroyed.\n   * A destroyed signal cannot be used and will throw an error if interacted with.\n   *\n   * @returns `true` if the signal is destroyed, `false` otherwise.\n   */\n  public get isDestroyed(): boolean {\n    return this.isDestroyed__;\n  }\n\n  public constructor(protected config_: SignalConfig) {}\n\n  /**\n   * Removes a specific observer from the observers list.\n   *\n   * @param observer The observer instance to remove.\n   * @protected\n   */\n  protected removeObserver_(observer: Observer_<T>): void {\n    this.logger_.logMethod?.('removeObserver_');\n\n    if (this.isDestroyed__) {\n      this.logger_.incident?.('removeObserver_', 'remove_observer_on_destroyed_signal');\n      return;\n    }\n\n    const index = this.observers_.indexOf(observer);\n    if (index !== -1) {\n      this.observers_.splice(index, 1);\n    }\n  }\n\n  /**\n   * Subscribes a listener function to this signal.\n   *\n   * The listener will be called whenever the signal is notified (e.g., when `dispatch` or `set` is called).\n   *\n   * @param callback The function to be called when the signal is dispatched.\n   * @param options Subscription options to customize the behavior (e.g., `once`, `priority`).\n   * @returns A `SubscribeResult` object with an `unsubscribe` method to remove the listener.\n   */\n  public subscribe(callback: ListenerCallback<T>, options?: SubscribeOptions): SubscribeResult {\n    this.logger_.logMethodArgs?.('subscribe.base', {options});\n    this.checkDestroyed_();\n\n    const observer: Observer_<T> = {callback, options};\n\n    if (options?.priority) {\n      // High-priority observers are added to the front of the queue.\n      this.observers_.unshift(observer);\n    }\n    else {\n      this.observers_.push(observer);\n    }\n\n    // The returned unsubscribe function is a closure that calls the internal removal method.\n    return {\n      unsubscribe: (): void => this.removeObserver_(observer),\n    };\n  }\n\n  /**\n   * Notifies all registered observers about a new value.\n   *\n   * This method iterates through a snapshot of the current observers to prevent issues\n   * with subscriptions changing during notification (e.g., an observer unsubscribing itself).\n   *\n   * @param value The new value to notify observers about.\n   * @protected\n   */\n  protected notify_(value: T): void {\n    this.logger_.logMethodArgs?.('notify_', value);\n\n    if (this.isDestroyed__) {\n      this.logger_.incident?.('notify_', 'notify_on_destroyed_signal');\n      return;\n    }\n\n    // Create a snapshot of the observers array to iterate over.\n    // This prevents issues if the observers_ array is modified during the loop.\n    const currentObservers = [...this.observers_];\n\n    for (const observer of currentObservers) {\n      if (observer.options?.once) {\n        this.removeObserver_(observer);\n      }\n\n      try {\n        const result = observer.callback(value);\n        if (result instanceof Promise) {\n          result.catch((err) => this.logger_.error('notify_', 'async_callback_failed', err, {observer}));\n        }\n      }\n      catch (err) {\n        this.logger_.error('notify_', 'sync_callback_failed', err);\n      }\n    }\n  }\n\n  /**\n   * Returns a Promise that resolves with the next value dispatched by the signal.\n   * This provides an elegant way to wait for a single, future event using `async/await`.\n   *\n   * @returns A Promise that resolves with the next dispatched value.\n   *\n   * @example\n   * async function onButtonClick() {\n   *   console.log('Waiting for the next signal...');\n   *   const nextValue = await mySignal.untilNext();\n   *   console.log('Signal received:', nextValue);\n   * }\n   */\n  public untilNext(): Promise<T> {\n    this.logger_.logMethod?.('untilNext');\n    this.checkDestroyed_();\n    return new Promise((resolve) => {\n      this.subscribe(resolve, {\n        once: true,\n        priority: true, // Resolve the promise before other listeners are called.\n        receivePrevious: false, // We only want the *next* value, not the current one.\n      });\n    });\n  }\n\n  /**\n   * Destroys the signal, clearing all its listeners and making it inactive.\n   *\n   * After destruction, any interaction with the signal (like `subscribe` or `untilNext`)\n   * will throw an error. This is crucial for preventing memory leaks by allowing\n   * garbage collection of the signal and its observers.\n   */\n  public destroy(): void {\n    this.logger_.logMethod?.('destroy');\n    if (this.isDestroyed__) {\n      this.logger_.incident?.('destroy_', 'double_destroy_attempt');\n      return;\n    }\n    this.isDestroyed__ = true;\n    this.observers_.length = 0; // Clear all observers.\n    this.config_.onDestroy?.(); // Call the optional onDestroy callback.\n    this.config_ = null as unknown as SignalConfig; // Help GC by breaking references.\n  }\n\n  /**\n   * Throws an error if the signal has been destroyed.\n   * This is a safeguard to prevent interaction with a defunct signal.\n   * @protected\n   */\n  protected checkDestroyed_(): void {\n    if (this.isDestroyed__) {\n      this.logger_.accident('checkDestroyed_', 'attempt_to_use_destroyed_signal');\n      throw new Error(`Cannot interact with a destroyed signal (id: ${this.signalId})`);\n    }\n  }\n}\n", "import {delay} from '@alwatr/delay';\nimport {createLogger} from '@alwatr/logger';\n\nimport {SignalBase} from './signal-base.js';\n\nimport type {SignalConfig} from '../type.js';\n\n/**\n * A stateless signal for dispatching transient events.\n *\n * `EventSignal` is ideal for broadcasting events that do not have a persistent state.\n * Unlike `StateSignal`, it does not hold a value. Listeners are only notified of new\n * events as they are dispatched. This makes it suitable for modeling user interactions,\n * system notifications, or any one-off message.\n *\n * @template T The type of the payload for the events. Defaults to `void` for events without a payload.\n *\n * @example\n * // Create a signal for user click events.\n * const onUserClick = new EventSignal<{ x: number, y: number }>({ signalId: 'on-user-click' });\n *\n * // Subscribe to the event.\n * onUserClick.subscribe(clickPosition => {\n *   console.log(`User clicked at: ${clickPosition.x}, ${clickPosition.y}`);\n * });\n *\n * // Dispatch an event.\n * onUserClick.dispatch({ x: 100, y: 250 }); // Notifies the listener.\n *\n * // --- Example with no payload ---\n * const onAppReady = new EventSignal({ signalId: 'on-app-ready' });\n * onAppReady.subscribe(() => console.log('Application is ready!'));\n * onAppReady.dispatch(); // Notifies the listener.\n */\nexport class EventSignal<T = void> extends SignalBase<T> {\n  /**\n   * The logger instance for this signal.\n   * @protected\n   */\n  protected logger_ = createLogger(`event-signal: ${this.signalId}`);\n\n  public constructor(config: SignalConfig) {\n    super(config);\n    this.logger_.logMethod?.('constructor');\n  }\n\n  /**\n   * Dispatches an event with an optional payload to all active listeners.\n   * The notification is scheduled as a microtask to prevent blocking and ensure\n   * a consistent, non-blocking flow.\n   *\n   * @param payload The data to send with the event.\n   */\n  public dispatch(payload: T): void {\n    this.logger_.logMethodArgs?.('dispatch', {payload});\n    this.checkDestroyed_();\n    // Dispatch as a microtask to ensure consistent, non-blocking behavior.\n    delay.nextMicrotask().then(() => this.notify_(payload));\n  }\n}\n", "import {delay} from '@alwatr/delay';\nimport {createLogger} from '@alwatr/logger';\n\nimport {SignalBase} from './signal-base.js';\n\nimport type {StateSignalConfig, ListenerCallback, SubscribeOptions, SubscribeResult, IReadonlySignal} from '../type.js';\n\n/**\n * A stateful signal that holds a value and notifies listeners when the value changes.\n *\n * `StateSignal` is the core of the signal library, representing a piece of mutable state.\n * It always has a value, and new subscribers immediately receive the current value by default.\n *\n * @template T The type of the state it holds.\n * @implements {IReadonlySignal<T>}\n *\n * @example\n * // Create a new state signal with an initial value.\n * const counter = new StateSignal<number>({\n *   signalId: 'counter-signal',\n *   initialValue: 0,\n * });\n *\n * // Get the current value.\n * console.log(counter.get()); // Outputs: 0\n *\n * // Subscribe to changes.\n * const subscription = counter.subscribe(newValue => {\n *   console.log(`Counter changed to: ${newValue}`);\n * });\n *\n * // Set a new value, which triggers the notification.\n * counter.set(1); // Outputs: \"Counter changed to: 1\"\n *\n * // Update value based on the previous value.\n * counter.update(current => current + 1); // Outputs: \"Counter changed to: 2\"\n *\n * // Unsubscribe when no longer needed.\n * subscription.unsubscribe();\n */\nexport class StateSignal<T> extends SignalBase<T> implements IReadonlySignal<T> {\n  /**\n   * The current value of the signal.\n   * @private\n   */\n  private value__: T;\n\n  /**\n   * The logger instance for this signal.\n   * @protected\n   */\n  protected logger_ = createLogger(`state-signal: ${this.signalId}`);\n\n  public constructor(config: StateSignalConfig<T>) {\n    super(config);\n    this.value__ = config.initialValue;\n    this.logger_.logMethodArgs?.('constructor', {initialValue: this.value__});\n  }\n\n  /**\n   * Retrieves the current value of the signal.\n   *\n   * @returns The current value.\n   *\n   * @example\n   * console.log(mySignal.get());\n   */\n  public get(): T {\n    this.checkDestroyed_();\n    return this.value__;\n  }\n\n  /**\n   * Updates the signal's value and notifies all active listeners.\n   *\n   * The notification is scheduled as a microtask, which means the update is deferred\n   * slightly to batch multiple synchronous changes.\n   *\n   * @param newValue The new value to set.\n   *\n   * @example\n   * // For primitive types\n   * mySignal.set(42);\n   *\n   * // For object types, it's best practice to set an immutable new object.\n   * mySignal.set({ ...mySignal.get(), property: 'new-value' });\n   */\n  public set(newValue: T): void {\n    this.logger_.logMethodArgs?.('set', {newValue});\n    this.checkDestroyed_();\n\n    // For primitives (including null), do not notify if the value is the same.\n    if (Object.is(this.value__, newValue) && (typeof newValue !== 'object' || newValue === null)) {\n      return;\n    }\n\n    this.value__ = newValue;\n\n    // Dispatch as a microtask to ensure consistent, non-blocking behavior.\n    delay.nextMicrotask().then(() => this.notify_(newValue));\n  }\n\n  /**\n   * Updates the signal's value based on its previous value.\n   *\n   * This method is particularly useful for state transitions that depend on the current value,\n   * especially for objects or arrays, as it promotes an immutable update pattern.\n   *\n   * @param updater A function that receives the current value and returns the new value.\n   *\n   * @example\n   * // For a counter\n   * counterSignal.update(current => current + 1);\n   *\n   * // For an object state\n   * userSignal.update(currentUser => ({ ...currentUser, loggedIn: true }));\n   */\n  public update(updater: (previousValue: T) => T): void {\n    this.logger_.logMethod?.('update');\n    this.checkDestroyed_();\n    // The updater function is called with the current value to compute the new value,\n    // which is then passed to the `set` method.\n    this.set(updater(this.value__));\n  }\n\n  /**\n   * Subscribes a listener to this signal.\n   *\n   * By default, the listener is immediately called with the signal's current value (`receivePrevious: true`).\n   * This behavior can be customized via the `options` parameter.\n   *\n   * @param callback The function to be called when the signal's value changes.\n   * @param options Subscription options, including `receivePrevious` and `once`.\n   * @returns An object with an `unsubscribe` method to remove the listener.\n   */\n  public override subscribe(callback: ListenerCallback<T>, options: SubscribeOptions = {}): SubscribeResult {\n    this.logger_.logMethodArgs?.('subscribe', {options});\n    this.checkDestroyed_();\n\n    // By default, new subscribers to a StateSignal should receive the current value.\n    if (options.receivePrevious !== false) {\n      // Immediately (but asynchronously) call the listener with the current value.\n      // This is done in a microtask to ensure it happens after the subscription is fully registered.\n      delay\n        .nextMicrotask()\n        .then(() => callback(this.value__))\n        .catch((err) => this.logger_.error('subscribe', 'immediate_callback_failed', err));\n\n      // If it's a 'once' subscription that receives the previous value, it's now fulfilled.\n      // We don't need to add it to the observers list for future updates.\n      if (options.once) {\n        // eslint-disable-next-line @typescript-eslint/no-empty-function\n        return {unsubscribe: () => {}};\n      }\n    }\n\n    return super.subscribe(callback, options);\n  }\n\n  /**\n   * Destroys the signal, clearing its value and all listeners.\n   * This is crucial for memory management to prevent leaks.\n   */\n  public override destroy(): void {\n    this.value__ = null as T; // Clear the value to allow for garbage collection.\n    super.destroy();\n  }\n}\n", "import {delay} from '@alwatr/delay';\nimport {createLogger} from '@alwatr/logger';\n\nimport {StateSignal} from './state-signal.js';\n\nimport type {ComputedSignalConfig, IReadonlySignal, SubscribeResult, SubscribeOptions} from '../type.js';\n\n/**\n * A read-only signal that derives its value from a set of dependency signals.\n *\n * `ComputedSignal` is a powerful tool for creating values that reactively update when their underlying\n * data sources change. Its value is memoized, meaning the `get` function is only re-evaluated when\n * one of its dependencies has actually changed.\n *\n * A key feature is its lifecycle management: a `ComputedSignal` **must** be destroyed when no longer\n * needed to prevent memory leaks from its subscriptions to dependency signals.\n *\n * @template T The type of the computed value.\n *\n * @example\n * // --- Create dependency signals ---\n * const firstName = new StateSignal({ signalId: 'firstName', initialValue: 'John' });\n * const lastName = new StateSignal({ signalId: 'lastName', initialValue: 'Doe' });\n *\n * // --- Create a computed signal ---\n * const fullName = new ComputedSignal({\n *   signalId: 'fullName',\n *   deps: [firstName, lastName],\n *   get: () => `${firstName.get()} ${lastName.get()}`,\n * });\n *\n * console.log(fullName.get()); // Outputs: \"John Doe\"\n *\n * // --- Subscribe to the computed value ---\n * fullName.subscribe(newFullName => {\n *   console.log(`Name changed to: ${newFullName}`);\n * });\n *\n * // --- Update a dependency ---\n * lastName.set('Smith'); // Recalculates and logs: \"Name changed to: John Smith\"\n * console.log(fullName.get()); // Outputs: \"John Smith\"\n *\n * // --- IMPORTANT: Clean up when done ---\n * fullName.destroy();\n */\nexport class ComputedSignal<T> implements IReadonlySignal<T> {\n  /**\n   * The unique identifier for this signal instance.\n   */\n  public readonly signalId = this.config_.signalId;\n\n  /**\n   * The logger instance for this signal.\n   * @protected\n   */\n  protected readonly logger_ = createLogger(`computed-signal: ${this.signalId}`);\n\n  /**\n   * The internal `StateSignal` that holds the computed value.\n   * This is how the computed signal provides `.get()` and `.subscribe()` methods.\n   * @protected\n   */\n  protected readonly internalSignal_ = new StateSignal<T>({\n    signalId: `${this.signalId}-internal`,\n    initialValue: this.config_.get(),\n  });\n\n  /**\n   * A list of subscriptions to dependency signals.\n   * @private\n   */\n\n  private readonly dependencySubscriptions__: SubscribeResult[] = [];\n\n  /**\n   * A flag to prevent concurrent recalculations.\n   * @private\n   */\n  private isRecalculating__ = false;\n\n  public constructor(protected config_: ComputedSignalConfig<T>) {\n    this.logger_.logMethod?.('constructor');\n    this.recalculate_ = this.recalculate_.bind(this);\n\n    // Subscribe to all dependencies to trigger recalculation on change.\n    for (const signal of config_.deps) {\n      this.dependencySubscriptions__.push(signal.subscribe(this.recalculate_, {receivePrevious: false}));\n    }\n  }\n\n  /**\n   * The current value of the computed signal.\n   * Accessing this property returns the memoized value and does not trigger a recalculation.\n   *\n   * @returns The current computed value.\n   * @throws {Error} If accessed after the signal has been destroyed.\n   */\n  public get(): T {\n    return this.internalSignal_.get();\n  }\n\n  /**\n   * Indicates whether the computed signal has been destroyed.\n   * A destroyed signal cannot be used and will throw an error if interacted with.\n   * @returns `true` if the signal is destroyed, `false` otherwise.\n   */\n  public get isDestroyed(): boolean {\n    return this.internalSignal_.isDestroyed;\n  }\n\n  /**\n   * Subscribes a listener to this signal.\n   * The listener will be called whenever the computed value changes.\n   *\n   * @param callback The function to be called with the new value.\n   * @param options Subscription options.\n   * @returns A `SubscribeResult` object with an `unsubscribe` method.\n   */\n  public subscribe(callback: (value: T) => void, options?: SubscribeOptions): SubscribeResult {\n    return this.internalSignal_.subscribe(callback, options);\n  }\n\n  /**\n   * Returns a Promise that resolves with the next computed value.\n   *\n   * @returns A Promise that resolves with the next value.\n   */\n  public untilNext(): Promise<T> {\n    return this.internalSignal_.untilNext();\n  }\n\n  /**\n   * Permanently disposes of the computed signal.\n   *\n   * This is a critical cleanup step. It unsubscribes from all dependency signals,\n   * stopping future recalculations and allowing the signal to be garbage collected.\n   * Failure to call `destroy()` will result in memory leaks.\n   *\n   * After `destroy()` is called, any attempt to access `.get()` or `.subscribe()` will throw an error.\n   */\n  public destroy(): void {\n    this.logger_.logMethod?.('destroy');\n    /**\n     * If already destroyed, log an incident and return early.\n     */\n    if (this.isDestroyed) {\n      this.logger_.incident?.('destroy', 'already_destroyed');\n      return;\n    }\n\n    // Unsubscribe from all upstream dependencies.\n    for (const subscription of this.dependencySubscriptions__) {\n      subscription.unsubscribe();\n    }\n    this.dependencySubscriptions__.length = 0; // Clear the array of subscriptions.\n\n    this.internalSignal_.destroy(); // Destroy the internal signal.\n    this.config_.onDestroy?.(); // Call the optional onDestroy callback.\n    this.config_ = null as unknown as ComputedSignalConfig<T>; // Release config closure.\n  }\n\n  /**\n   * Schedules a recalculation of the signal's value.\n   *\n   * This method batches updates using a macrotask (`delay.nextMacrotask`) to ensure the\n   * `get` function runs only once per event loop tick, even if multiple dependencies\n   * change in the same synchronous block of code.\n   * @protected\n   */\n  protected async recalculate_(): Promise<void> {\n    this.logger_.logMethod?.('recalculate_');\n\n    if (this.internalSignal_.isDestroyed) {\n      // This check is important in case a dependency fires after this signal is destroyed.\n      this.logger_.incident?.('recalculate_', 'recalculate_on_destroyed_signal');\n      return;\n    }\n\n    if (this.isRecalculating__) {\n      // If a recalculation is already scheduled, do nothing.\n      this.logger_.logStep?.('recalculate_', 'skipping_recalculation_already_scheduled');\n      return;\n    }\n\n    this.isRecalculating__ = true;\n\n    try {\n      // Wait for the next macrotask to start the recalculation.\n      // This batches all synchronous dependency updates in the current event loop.\n      await delay.nextMacrotask();\n      \n      if (this.isDestroyed) {\n        this.logger_.incident?.('recalculate_', 'destroyed_during_delay');\n        this.isRecalculating__ = false;\n        return;\n      }\n\n      this.logger_.logStep?.('recalculate_', 'recalculating_value');\n\n      // Set the new value on the internal signal, which will notify our subscribers.\n      this.internalSignal_.set(this.config_.get());\n    }\n    catch (err) {\n      this.logger_.error('recalculate_', 'recalculation_failed', err);\n    }\n\n    // Allow the next recalculation to be scheduled.\n    this.isRecalculating__ = false;\n  }\n}\n", "import {delay} from '@alwatr/delay';\nimport {createLogger} from '@alwatr/logger';\n\nimport type {EffectSignalConfig, IEffectSignal, SubscribeResult} from '../type.js';\n\n/**\n * Manages a side-effect that runs in response to changes in dependency signals.\n *\n * `EffectSignal` is designed for running logic that interacts with the \"outside world\"—such as\n * logging, network requests, or DOM manipulation—whenever its dependencies are updated.\n * It encapsulates the subscription and cleanup logic, providing a robust and memory-safe\n * way to handle reactive side-effects.\n *\n * A key feature is its lifecycle management: an `EffectSignal` **must** be destroyed when no longer\n * needed to prevent memory leaks and stop the effect from running unnecessarily.\n *\n * @implements {IEffectSignal}\n *\n * @example\n * // --- Create dependency signals ---\n * const counter = new StateSignal({ initialValue: 0, signalId: 'counter' });\n * const user = new StateSignal({ initialValue: 'guest', signalId: 'user' });\n *\n * // --- Create an effect ---\n * const analyticsEffect = new EffectSignal({\n *   signalId: 'analytics-effect',\n *   deps: [counter, user],\n *   run: () => {\n *     console.log(`Analytics: User '${user.get()}' clicked ${counter.get()} times.`);\n *   },\n *   runImmediately: true, // Optional: run once on creation\n * });\n * // Immediately logs: \"Analytics: User 'guest' clicked 0 times.\"\n *\n * // --- Trigger the effect by updating a dependency ---\n * counter.set(1);\n * // After a macrotask, logs: \"Analytics: User 'guest' clicked 1 times.\"\n *\n * // --- IMPORTANT: Clean up when the effect is no longer needed ---\n * analyticsEffect.destroy();\n *\n * // Further updates will not trigger the effect.\n * counter.set(2); // Nothing is logged.\n */\nexport class EffectSignal implements IEffectSignal {\n  /**\n   * The unique identifier for this signal instance.\n   */\n  public readonly signalId = this.config_.signalId ? this.config_.signalId : `[${this.config_.deps.map((dep) => dep.signalId).join(', ')}]`;\n\n  /**\n   * The logger instance for this signal.\n   * @protected\n   */\n  protected readonly logger_ = createLogger(`effect-signal: ${this.signalId}`);\n\n  /**\n   * A list of subscriptions to dependency signals.\n   * @private\n   */\n  private readonly dependencySubscriptions__: SubscribeResult[] = [];\n\n  /**\n   * A flag to prevent concurrent executions of the effect.\n   * @private\n   */\n  private isRunning__ = false;\n\n  /**\n   * A flag indicating whether the effect has been destroyed.\n   * @private\n   */\n  private isDestroyed__ = false;\n\n  /**\n   * Indicates whether the effect signal has been destroyed.\n   * A destroyed signal will no longer execute its effect and cannot be reused.\n   *\n   * @returns `true` if the signal is destroyed, `false` otherwise.\n   */\n  public get isDestroyed(): boolean {\n    return this.isDestroyed__;\n  }\n\n  public constructor(protected config_: EffectSignalConfig) {\n    this.logger_.logMethod?.('constructor');\n    this.scheduleExecution_ = this.scheduleExecution_.bind(this);\n\n    // Subscribe to all dependencies. We don't need the previous value,\n    // as the `runImmediately` option controls the initial execution.\n    for (const signal of config_.deps) {\n      this.dependencySubscriptions__.push(signal.subscribe(this.scheduleExecution_, {receivePrevious: false}));\n    }\n\n    // Run the effect immediately if requested.\n    if (config_.runImmediately === true) {\n      // We don't need to await this, let it run in the background.\n      void this.scheduleExecution_();\n    }\n  }\n\n  /**\n   * Schedules the execution of the effect's `run` function.\n   *\n   * This method batches updates using a macrotask (`delay.nextMacrotask`) to ensure the\n   * `run` function executes only once per event loop tick, even if multiple\n   * dependencies change simultaneously.\n   * @protected\n   */\n  protected async scheduleExecution_(): Promise<void> {\n    this.logger_.logMethod?.('scheduleExecution_');\n\n    if (this.isDestroyed__) {\n      this.logger_.incident?.('scheduleExecution_', 'schedule_execution_on_destroyed_signal');\n      return;\n    }\n    if (this.isRunning__) {\n      // If an execution is already scheduled, do nothing.\n      this.logger_.logStep?.('scheduleExecution_', 'skipped_because_already_running');\n      return;\n    }\n\n    this.isRunning__ = true;\n\n    try {\n      // Wait for the next macrotask to batch simultaneous updates.\n      await delay.nextMacrotask();\n      if (this.isDestroyed__) {\n        this.logger_.incident?.('scheduleExecution_', 'destroyed_during_delay');\n        this.isRunning__ = false;\n        return;\n      }\n\n      this.logger_.logStep?.('scheduleExecution_', 'executing_effect');\n      await this.config_.run();\n    }\n    catch (err) {\n      this.logger_.error('scheduleExecution_', 'effect_failed', err);\n    }\n\n    // Reset the flag after the current execution is complete.\n    this.isRunning__ = false;\n  }\n\n  /**\n   * Permanently disposes of the effect signal.\n   *\n   * This is a critical cleanup step. It unsubscribes from all dependency signals,\n   * stopping any future executions of the effect and allowing it to be garbage collected.\n   * Failure to call `destroy()` will result in memory leaks and potentially unwanted side effects.\n   */\n  public destroy(): void {\n    this.logger_.logMethod?.('destroy');\n\n    if (this.isDestroyed__) {\n      this.logger_.incident?.('destroy', 'already_destroyed');\n      return;\n    }\n\n    this.isDestroyed__ = true;\n\n    // Unsubscribe from all upstream dependencies.\n    for (const subscription of this.dependencySubscriptions__) {\n      subscription.unsubscribe();\n    }\n    this.dependencySubscriptions__.length = 0; // Clear the array of subscriptions.\n\n    this.config_.onDestroy?.(); // Call the optional onDestroy callback.\n    this.config_ = null as unknown as EffectSignalConfig; // Release config closure.\n  }\n}\n", "import {EventSignal} from '../core/event-signal.js';\n\nimport type {SignalConfig} from '../type.js';\n\n/**\n * Creates a stateless signal for dispatching transient events.\n *\n * `EventSignal` is ideal for broadcasting events that do not have a persistent state.\n * Unlike `StateSignal`, it does not hold a value. Listeners are only notified of new\n * events as they are dispatched. This makes it suitable for modeling user interactions,\n * system notifications, or any one-off message.\n *\n * @template T The type of the payload for the events.\n *\n * @param config The configuration for the event signal.\n * @returns A new instance of EventSignal.\n *\n * @example\n * const onUserClick = createEventSignal<{ x: number, y: number }>({\n *   signalId: 'on-user-click'\n * });\n *\n * onUserClick.subscribe(pos => {\n *   console.log(`User clicked at: ${pos.x}, ${pos.y}`);\n * });\n *\n * onUserClick.dispatch({ x: 100, y: 250 });\n */\nexport function createEventSignal<T = void>(config: SignalConfig): EventSignal<T> {\n  return new EventSignal<T>(config);\n}\n", "import {StateSignal} from '../core/state-signal.js';\n\nimport type {StateSignalConfig} from '../type.js';\n\n/**\n * Creates a stateful signal that holds a value and notifies listeners when the value changes.\n *\n * `StateSignal` is the core of the signal library, representing a piece of mutable state.\n * It always has a value, and new subscribers immediately receive the current value by default.\n *\n * @template T The type of the state it holds.\n *\n * @param config The configuration for the state signal.\n * @returns A new instance of StateSignal.\n *\n * @example\n * const counter = createStateSignal({\n *   signalId: 'counter-signal',\n *   initialValue: 0,\n * });\n *\n * console.log(counter.get()); // Outputs: 0\n * counter.set(1);\n * console.log(counter.get()); // Outputs: 1\n */\nexport function createStateSignal<T>(config: StateSignalConfig<T>): StateSignal<T> {\n  return new StateSignal(config);\n}\n", "import {ComputedSignal} from '../core/computed-signal.js';\n\nimport type {ComputedSignalConfig} from '../type.js';\n\n/**\n * Creates a read-only signal that derives its value from a set of dependency signals.\n *\n * `ComputedSignal` is a powerful tool for creating values that reactively update when their underlying\n * data sources change. Its value is memoized, meaning the `get` function is only re-evaluated when\n * one of its dependencies has actually changed.\n *\n * A key feature is its lifecycle management: a `ComputedSignal` **must** be destroyed when no longer\n * needed to prevent memory leaks from its subscriptions to dependency signals.\n *\n * @template T The type of the computed value.\n *\n * @param config The configuration for the computed signal.\n * @returns A new, read-only computed signal.\n *\n * @example\n * const firstName = createStateSignal({ signalId: 'firstName', initialValue: 'John' });\n * const lastName = createStateSignal({ signalId: 'lastName', initialValue: 'Doe' });\n *\n * const fullName = createComputedSignal({\n *   signalId: 'fullName',\n *   deps: [firstName, lastName],\n *   get: () => `${firstName.get()} ${lastName.get()}`,\n * });\n *\n * console.log(fullName.get()); // \"John Doe\"\n *\n * // IMPORTANT: Always destroy a computed signal when no longer needed.\n * // fullName.destroy();\n */\nexport function createComputedSignal<T>(config: ComputedSignalConfig<T>): ComputedSignal<T> {\n  return new ComputedSignal(config);\n}\n", "import {EffectSignal} from '../core/effect-signal.js';\n\nimport type {EffectSignalConfig} from '../type.js';\n\n/**\n * Creates a side-effect that runs in response to changes in dependency signals.\n *\n * `EffectSignal` is designed for running logic that interacts with the \"outside world\"—such as\n * logging, network requests, or DOM manipulation—whenever its dependencies are updated.\n * It encapsulates the subscription and cleanup logic, providing a robust and memory-safe\n * way to handle reactive side-effects.\n *\n * A key feature is its lifecycle management: an `EffectSignal` **must** be destroyed when no longer\n * needed to prevent memory leaks and stop the effect from running unnecessarily.\n *\n * @param config The configuration for the effect.\n * @returns An object with a `destroy` method to stop the effect.\n *\n * @example\n * // --- Create dependency signals ---\n * const counter = createStateSignal({ initialValue: 0, signalId: 'counter' });\n * const user = createStateSignal({ initialValue: 'guest', signalId: 'user' });\n *\n * // --- Create an effect ---\n * const analyticsEffect = createEffect({\n *   deps: [counter, user],\n *   run: () => {\n *     console.log(`Analytics: User '${user.get()}' clicked ${counter.get()} times.`);\n *   },\n *   runImmediately: true, // Optional: run once on creation\n * });\n * // Immediately logs: \"Analytics: User 'guest' clicked 0 times.\"\n *\n * // --- Trigger the effect by updating a dependency ---\n * counter.set(1);\n * // After a macrotask, logs: \"Analytics: User 'guest' clicked 1 times.\"\n *\n * // --- IMPORTANT: Clean up when the effect is no longer needed ---\n * analyticsEffect.destroy();\n *\n * // Further updates will not trigger the effect.\n * counter.set(2); // Nothing is logged.\n */\nexport function createEffect(config: EffectSignalConfig): EffectSignal {\n  return new EffectSignal(config);\n}\n", "import {createDebouncer} from '@alwatr/debounce';\n\nimport {StateSignal} from '../core/state-signal.js';\nimport {createComputedSignal} from '../creators/computed.js';\n\nimport type {ComputedSignal} from '../core/computed-signal.js';\nimport type {IReadonlySignal, DebounceSignalConfig} from '../type.js';\n\n/**\n * Creates a new computed signal that debounces updates from a source signal.\n *\n * The returned signal is a `ComputedSignal`, meaning it is read-only and its value is\n * derived from the source. It only updates its value after a specified period of\n * inactivity from the source signal.\n *\n * This operator is essential for handling high-frequency events, such as user input\n * in a search box, resizing a window, or any other event that fires rapidly.\n * By debouncing, you can ensure that expensive operations (like API calls or heavy\n * computations) are only executed once the events have settled.\n *\n * @template T The type of the signal's value.\n *\n * @param {IReadonlySignal<T>} sourceSignal The original signal to debounce.\n * It can be a `StateSignal`, `ComputedSignal`, or any signal implementing `IReadonlySignal`.\n * @param {DebounceSignalConfig} config Configuration object for the debouncer,\n * including `delay`, `leading`, and `trailing` options from `@alwatr/debounce`.\n *\n * @returns {IComputedSignal<T>} A new, read-only computed signal that emits debounced values.\n * Crucially, you **must** call `.destroy()` on this signal when it's no longer\n * needed to prevent memory leaks by cleaning up internal subscriptions and timers.\n *\n * @example\n * ```typescript\n * // Create a source signal for user input.\n * const searchInput = createStateSignal({\n *   signalId: 'search-input',\n *   initialValue: '',\n * });\n *\n * // Create a debounced signal that waits 300ms after the user stops typing.\n * const debouncedSearch = createDebouncedSignal(searchInput, { delay: 300 });\n *\n * // Use an effect to react to the debounced value.\n * createEffect({\n *   deps: [debouncedSearch],\n *   run: () => {\n *     if (debouncedSearch.get()) {\n *       console.log(`🚀 Sending API request for: \"${debouncedSearch.get()}\"`);\n *     }\n *   },\n * });\n *\n * searchInput.set('Alwatr');\n * searchInput.set('Alwatr Signal');\n * // (after 300ms of inactivity)\n * // Logs: \"🚀 Sending API request for: \"Alwatr Signal\"\"\n *\n * // IMPORTANT: Clean up when the component unmounts.\n * // debouncedSearch.destroy();\n * ```\n */\nexport function createDebouncedSignal<T>(sourceSignal: IReadonlySignal<T>, config: DebounceSignalConfig): ComputedSignal<T> {\n  const signalId = config.signalId ?? `${sourceSignal.signalId}-debounced`;\n\n  const internalSignal = new StateSignal<T>({\n    signalId: `${signalId}-internal`,\n    initialValue: sourceSignal.get(),\n  });\n\n  const debouncer = createDebouncer({\n    ...config,\n    func: (value: T): void => {\n      internalSignal.set(value);\n    },\n  });\n\n  const subscription = sourceSignal.subscribe(debouncer.trigger);\n\n  return createComputedSignal({\n    signalId,\n    deps: [internalSignal],\n    get: () => internalSignal.get(),\n    onDestroy: () => {\n      if (internalSignal.isDestroyed) return;\n      subscription.unsubscribe();\n      debouncer.cancel();\n      internalSignal.destroy();\n      config.onDestroy?.();\n      config = null as unknown as DebounceSignalConfig;\n    },\n  });\n}\n"],
+  "mappings": "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",
   "names": ["delay", "createLogger", "createLogger", "delay", "delay", "createLogger", "createLogger", "delay", "delay", "createLogger"]
 }

package/dist/operators/debounce.d.ts

@@ -38,8 +38,8 @@ import type { IReadonlySignal, DebounceSignalConfig } from '../type.js';
  * createEffect({
  *   deps: [debouncedSearch],
  *   run: () => {
- *     if (debouncedSearch.value) {
- *       console.log(`🚀 Sending API request for: "${debouncedSearch.value}"`);
+ *     if (debouncedSearch.get()) {
+ *       console.log(`🚀 Sending API request for: "${debouncedSearch.get()}"`);
  *     }
  *   },
  * });

package/dist/operators/filter.d.ts

@@ -32,8 +32,8 @@ import type { IReadonlySignal } from '../type.js';
  * run: () => {
  * // This effect only runs for even numbers.
  * // The value can be `undefined` on the first run if initialValue is not even.
- * if (evenNumberSignal.value !== undefined) {
- * console.log(`Even number detected: ${evenNumberSignal.value}`);
+ * if (evenNumberSignal.get() !== undefined) {
+ * console.log(`Even number detected: ${evenNumberSignal.get()}`);
  * }
  * },
  * runImmediately: true,

package/dist/operators/filter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../src/operators/filter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,4BAA4B,CAAC;AAC/D,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,YAAY,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EACpC,YAAY,EAAE,eAAe,CAAC,CAAC,CAAC,EAChC,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,EAChC,QAAQ,SAAsC,GAC7C,cAAc,CAAC,CAAC,GAAG,SAAS,CAAC,CAuB/B"}
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../src/operators/filter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,4BAA4B,CAAC;AAC/D,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,YAAY,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EACpC,YAAY,EAAE,eAAe,CAAC,CAAC,CAAC,EAChC,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,EAChC,QAAQ,SAAsC,GAC7C,cAAc,CAAC,CAAC,GAAG,SAAS,CAAC,CAwB/B"}

package/dist/operators/map.d.ts

@@ -27,10 +27,10 @@ import type { IReadonlySignal } from '../type.js';
  *   (user) => user.name,
  * );
  *
- * console.log(userNameSignal.value); // Outputs: "John"
+ * console.log(userNameSignal.get()); // Outputs: "John"
  * // in next macro-task ...
  * userSignal.set({ name: 'Jane', age: 32 });
- * console.log(userNameSignal.value); // Outputs: "Jane"
+ * console.log(userNameSignal.get()); // Outputs: "Jane"
  */
 export declare function createMappedSignal<T, R>(sourceSignal: IReadonlySignal<T>, projectFunction: (value: T) => R, signalId?: string): ComputedSignal<R>;
 //# sourceMappingURL=map.d.ts.map

package/dist/type.d.ts

@@ -126,7 +126,7 @@ export interface IReadonlySignal<T> {
     /**
      * The current value of the signal.
      */
-    readonly value: T;
+    get: () => T;
     /**
      * Indicates whether the signal has been destroyed.
      * A destroyed signal cannot be used and will throw an error if interacted with.
@@ -189,7 +189,7 @@ export interface ComputedSignalConfig<T> extends SignalConfig {
      * const counter = new StateSignal({initialValue: 0});
      * const isEven = new ComputedSignal({
      *   deps: [counter],
-     *   get: () => counter.value % 2 === 0,
+     *   get: () => counter.get() % 2 === 0,
      * });
      */
     get: () => T;
@@ -222,7 +222,7 @@ export interface EffectSignalConfig {
      * const counter = new StateSignal({initialValue: 0});
      * new EffectSignal({
      *   deps: [counter],
-     *   run: () => console.log(`The counter is now: ${counter.value}`),
+     *   run: () => console.log(`The counter is now: ${counter.get()}`),
      * });
      */
     run: () => Awaitable<void>;

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,7 +1,7 @@
 {
   "name": "@alwatr/signal",
   "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.",
-  "version": "5.2.0",
+  "version": "5.2.1",
   "author": "S. Ali Mihandoost <ali.mihandoost@gmail.com>",
   "bugs": "https://github.com/Alwatr/flux/issues",
   "dependencies": {
@@ -68,5 +68,5 @@
   },
   "type": "module",
   "types": "./dist/main.d.ts",
-  "gitHead": "2a7bbc2e804356aaa24736bd3d79e3800f549056"
+  "gitHead": "f7e5cd521b2f961f1fa0efe236d7008fbc199c05"
 }

package/src/core/computed-signal.test.js

@@ -17,7 +17,7 @@ describe('ComputedSignal', () => {
     signal = new ComputedSignal({
       signalId,
       deps: [dep1, dep2],
-      get: () => dep1.value + dep2.value,
+      get: () => dep1.get() + dep2.get(),
     });
   });
 
@@ -31,14 +31,14 @@ describe('ComputedSignal', () => {
     expect(ComputedSignal).toBeDefined();
     expect(signal).toBeInstanceOf(ComputedSignal);
     expect(signal.signalId).toBe(signalId);
-    expect(signal.value).toBe(3); // 1 + 2
+    expect(signal.get()).toBe(3); // 1 + 2
   });
 
   it('should compute value from dependencies', async () => {
-    expect(signal.value).toBe(3);
+    expect(signal.get()).toBe(3);
     dep1.set(5);
     await signal.untilNext();
-    expect(signal.value).toBe(7); // 5 + 2
+    expect(signal.get()).toBe(7); // 5 + 2
   });
 
   it('should notify subscribers when computed value changes', async () => {
@@ -115,7 +115,7 @@ describe('ComputedSignal', () => {
       deps: [],
       get: () => 42,
     });
-    expect(noDepSignal.value).toBe(42);
+    expect(noDepSignal.get()).toBe(42);
     noDepSignal.destroy();
   });
 
@@ -135,7 +135,7 @@ describe('ComputedSignal', () => {
   describe('destroyed signal', () => {
     it('should throw error when accessing value after destroy', () => {
       signal.destroy();
-      expect(() => signal.value).toThrow();
+      expect(() => signal.get()).toThrow();
     });
 
     it('should not notify after destroy', async () => {

package/src/core/state-signal.test.js

@@ -19,7 +19,7 @@ describe('StateSignal', () => {
     expect(StateSignal).toBeDefined();
     expect(signal).toBeInstanceOf(StateSignal);
     expect(signal.signalId).toBe(signalId);
-    expect(signal.value).toBe(0);
+    expect(signal.get()).toBe(0);
   });
 
   it('should notify subscribers when value changes', async () => {
@@ -218,7 +218,7 @@ describe('StateSignal', () => {
     });
 
     it('should throw an error when accessing value on a destroyed signal', () => {
-      expect(() => signal.value).toThrow(`Cannot interact with a destroyed signal (id: ${signalId})`);
+      expect(() => signal.get()).toThrow(`Cannot interact with a destroyed signal (id: ${signalId})`);
     });
 
     it('should not notify any listeners after being destroyed', async () => {