@alwatr/signal 5.2.1 → 5.2.2

package/CHANGELOG.md

@@ -3,6 +3,24 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [5.2.2](https://github.com/Alwatr/flux/compare/v5.2.1...v5.2.2) (2025-09-15)
+
+### 🐛 Bug Fixes
+
+* update subscription to prevent receiving previous value in debounced signal ([044780d](https://github.com/Alwatr/flux/commit/044780d35427a97711788224e60e209fb53dea53))
+* update subscription to trigger debouncer with value from source signal ([a7e8eff](https://github.com/Alwatr/flux/commit/a7e8effd7e963aaf905afae08a652d7abe222c3a))
+
+### 🔨 Code Refactoring
+
+* improve logging in subscribe method to pass options directly ([e026dbf](https://github.com/Alwatr/flux/commit/e026dbf74ca96ec6d878bd5fb08f4939c46d08f2))
+* simplify signalId assignment using nullish coalescing operator ([0578c85](https://github.com/Alwatr/flux/commit/0578c854677df2fe0a62e5fbbfa017856d82b611))
+* update logging in subscribe method to pass options directly ([a7e32f2](https://github.com/Alwatr/flux/commit/a7e32f20df6b12c1c9dd06feaf01fca8170a5346))
+
+### 🧹 Miscellaneous Chores
+
+* update @alwatr/debounce dependency to version 1.1.1 ([c2e2ae4](https://github.com/Alwatr/flux/commit/c2e2ae4fe54f8fdd482bd53b598f5e88570a26f2))
+* update package dependencies to latest versions ([a517c82](https://github.com/Alwatr/flux/commit/a517c82b99073a65a8470da428dfd288080b7ea5))
+
 ## [5.2.1](https://github.com/Alwatr/flux/compare/v5.2.0...v5.2.1) (2025-09-15)
 
 ### ⚡ Performance Improvements

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,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC;IAmCnD;;;;;;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,SAA2F;IAEnH;;;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.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;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"}
+{"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;IA2BzG;;;OAGG;IACa,OAAO,IAAI,IAAI;CAIhC"}

package/dist/main.cjs

@@ -1,622 +1,3 @@
-/* @alwatr/signal v5.2.1 */
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/main.ts
-var main_exports = {};
-__export(main_exports, {
-  ComputedSignal: () => ComputedSignal,
-  EffectSignal: () => EffectSignal,
-  EventSignal: () => EventSignal,
-  SignalBase: () => SignalBase,
-  StateSignal: () => StateSignal,
-  createComputedSignal: () => createComputedSignal,
-  createDebouncedSignal: () => createDebouncedSignal,
-  createEffect: () => createEffect,
-  createEventSignal: () => createEventSignal,
-  createStateSignal: () => createStateSignal
-});
-module.exports = __toCommonJS(main_exports);
-
-// src/core/signal-base.ts
-var SignalBase = class {
-  constructor(config_) {
-    this.config_ = config_;
-    /**
-     * The unique identifier for this signal instance.
-     * Useful for debugging and logging.
-     */
-    this.signalId = this.config_.signalId;
-    /**
-     * The list of observers (listeners) subscribed to this signal.
-     * @protected
-     */
-    this.observers_ = [];
-    /**
-     * A flag indicating whether the signal has been destroyed.
-     * @private
-     */
-    this.isDestroyed__ = false;
-  }
-  /**
-   * Indicates whether the signal has been destroyed.
-   * A destroyed signal cannot be used and will throw an error if interacted with.
-   *
-   * @returns `true` if the signal is destroyed, `false` otherwise.
-   */
-  get isDestroyed() {
-    return this.isDestroyed__;
-  }
-  /**
-   * Removes a specific observer from the observers list.
-   *
-   * @param observer The observer instance to remove.
-   * @protected
-   */
-  removeObserver_(observer) {
-    this.logger_.logMethod?.("removeObserver_");
-    if (this.isDestroyed__) {
-      this.logger_.incident?.("removeObserver_", "remove_observer_on_destroyed_signal");
-      return;
-    }
-    const index = this.observers_.indexOf(observer);
-    if (index !== -1) {
-      this.observers_.splice(index, 1);
-    }
-  }
-  /**
-   * Subscribes a listener function to this signal.
-   *
-   * The listener will be called whenever the signal is notified (e.g., when `dispatch` or `set` is called).
-   *
-   * @param callback The function to be called when the signal is dispatched.
-   * @param options Subscription options to customize the behavior (e.g., `once`, `priority`).
-   * @returns A `SubscribeResult` object with an `unsubscribe` method to remove the listener.
-   */
-  subscribe(callback, options) {
-    this.logger_.logMethodArgs?.("subscribe.base", { options });
-    this.checkDestroyed_();
-    const observer = { callback, options };
-    if (options?.priority) {
-      this.observers_.unshift(observer);
-    } else {
-      this.observers_.push(observer);
-    }
-    return {
-      unsubscribe: () => this.removeObserver_(observer)
-    };
-  }
-  /**
-   * Notifies all registered observers about a new value.
-   *
-   * This method iterates through a snapshot of the current observers to prevent issues
-   * with subscriptions changing during notification (e.g., an observer unsubscribing itself).
-   *
-   * @param value The new value to notify observers about.
-   * @protected
-   */
-  notify_(value) {
-    this.logger_.logMethodArgs?.("notify_", value);
-    if (this.isDestroyed__) {
-      this.logger_.incident?.("notify_", "notify_on_destroyed_signal");
-      return;
-    }
-    const currentObservers = [...this.observers_];
-    for (const observer of currentObservers) {
-      if (observer.options?.once) {
-        this.removeObserver_(observer);
-      }
-      try {
-        const result = observer.callback(value);
-        if (result instanceof Promise) {
-          result.catch((err) => this.logger_.error("notify_", "async_callback_failed", err, { observer }));
-        }
-      } catch (err) {
-        this.logger_.error("notify_", "sync_callback_failed", err);
-      }
-    }
-  }
-  /**
-   * Returns a Promise that resolves with the next value dispatched by the signal.
-   * This provides an elegant way to wait for a single, future event using `async/await`.
-   *
-   * @returns A Promise that resolves with the next dispatched value.
-   *
-   * @example
-   * async function onButtonClick() {
-   *   console.log('Waiting for the next signal...');
-   *   const nextValue = await mySignal.untilNext();
-   *   console.log('Signal received:', nextValue);
-   * }
-   */
-  untilNext() {
-    this.logger_.logMethod?.("untilNext");
-    this.checkDestroyed_();
-    return new Promise((resolve) => {
-      this.subscribe(resolve, {
-        once: true,
-        priority: true,
-        // Resolve the promise before other listeners are called.
-        receivePrevious: false
-        // We only want the *next* value, not the current one.
-      });
-    });
-  }
-  /**
-   * Destroys the signal, clearing all its listeners and making it inactive.
-   *
-   * After destruction, any interaction with the signal (like `subscribe` or `untilNext`)
-   * will throw an error. This is crucial for preventing memory leaks by allowing
-   * garbage collection of the signal and its observers.
-   */
-  destroy() {
-    this.logger_.logMethod?.("destroy");
-    if (this.isDestroyed__) {
-      this.logger_.incident?.("destroy_", "double_destroy_attempt");
-      return;
-    }
-    this.isDestroyed__ = true;
-    this.observers_.length = 0;
-    this.config_.onDestroy?.();
-    this.config_ = null;
-  }
-  /**
-   * Throws an error if the signal has been destroyed.
-   * This is a safeguard to prevent interaction with a defunct signal.
-   * @protected
-   */
-  checkDestroyed_() {
-    if (this.isDestroyed__) {
-      this.logger_.accident("checkDestroyed_", "attempt_to_use_destroyed_signal");
-      throw new Error(`Cannot interact with a destroyed signal (id: ${this.signalId})`);
-    }
-  }
-};
-
-// src/core/event-signal.ts
-var import_delay = require("@alwatr/delay");
-var import_logger = require("@alwatr/logger");
-var EventSignal = class extends SignalBase {
-  constructor(config) {
-    super(config);
-    /**
-     * The logger instance for this signal.
-     * @protected
-     */
-    this.logger_ = (0, import_logger.createLogger)(`event-signal: ${this.signalId}`);
-    this.logger_.logMethod?.("constructor");
-  }
-  /**
-   * Dispatches an event with an optional payload to all active listeners.
-   * The notification is scheduled as a microtask to prevent blocking and ensure
-   * a consistent, non-blocking flow.
-   *
-   * @param payload The data to send with the event.
-   */
-  dispatch(payload) {
-    this.logger_.logMethodArgs?.("dispatch", { payload });
-    this.checkDestroyed_();
-    import_delay.delay.nextMicrotask().then(() => this.notify_(payload));
-  }
-};
-
-// src/core/state-signal.ts
-var import_delay2 = require("@alwatr/delay");
-var import_logger2 = require("@alwatr/logger");
-var StateSignal = class extends SignalBase {
-  constructor(config) {
-    super(config);
-    /**
-     * The logger instance for this signal.
-     * @protected
-     */
-    this.logger_ = (0, import_logger2.createLogger)(`state-signal: ${this.signalId}`);
-    this.value__ = config.initialValue;
-    this.logger_.logMethodArgs?.("constructor", { initialValue: this.value__ });
-  }
-  /**
-   * Retrieves the current value of the signal.
-   *
-   * @returns The current value.
-   *
-   * @example
-   * console.log(mySignal.get());
-   */
-  get() {
-    this.checkDestroyed_();
-    return this.value__;
-  }
-  /**
-   * Updates the signal's value and notifies all active listeners.
-   *
-   * The notification is scheduled as a microtask, which means the update is deferred
-   * slightly to batch multiple synchronous changes.
-   *
-   * @param newValue The new value to set.
-   *
-   * @example
-   * // For primitive types
-   * mySignal.set(42);
-   *
-   * // For object types, it's best practice to set an immutable new object.
-   * mySignal.set({ ...mySignal.get(), property: 'new-value' });
-   */
-  set(newValue) {
-    this.logger_.logMethodArgs?.("set", { newValue });
-    this.checkDestroyed_();
-    if (Object.is(this.value__, newValue) && (typeof newValue !== "object" || newValue === null)) {
-      return;
-    }
-    this.value__ = newValue;
-    import_delay2.delay.nextMicrotask().then(() => this.notify_(newValue));
-  }
-  /**
-   * Updates the signal's value based on its previous value.
-   *
-   * This method is particularly useful for state transitions that depend on the current value,
-   * especially for objects or arrays, as it promotes an immutable update pattern.
-   *
-   * @param updater A function that receives the current value and returns the new value.
-   *
-   * @example
-   * // For a counter
-   * counterSignal.update(current => current + 1);
-   *
-   * // For an object state
-   * userSignal.update(currentUser => ({ ...currentUser, loggedIn: true }));
-   */
-  update(updater) {
-    this.logger_.logMethod?.("update");
-    this.checkDestroyed_();
-    this.set(updater(this.value__));
-  }
-  /**
-   * Subscribes a listener to this signal.
-   *
-   * By default, the listener is immediately called with the signal's current value (`receivePrevious: true`).
-   * This behavior can be customized via the `options` parameter.
-   *
-   * @param callback The function to be called when the signal's value changes.
-   * @param options Subscription options, including `receivePrevious` and `once`.
-   * @returns An object with an `unsubscribe` method to remove the listener.
-   */
-  subscribe(callback, options = {}) {
-    this.logger_.logMethodArgs?.("subscribe", { options });
-    this.checkDestroyed_();
-    if (options.receivePrevious !== false) {
-      import_delay2.delay.nextMicrotask().then(() => callback(this.value__)).catch((err) => this.logger_.error("subscribe", "immediate_callback_failed", err));
-      if (options.once) {
-        return { unsubscribe: () => {
-        } };
-      }
-    }
-    return super.subscribe(callback, options);
-  }
-  /**
-   * Destroys the signal, clearing its value and all listeners.
-   * This is crucial for memory management to prevent leaks.
-   */
-  destroy() {
-    this.value__ = null;
-    super.destroy();
-  }
-};
-
-// src/core/computed-signal.ts
-var import_delay3 = require("@alwatr/delay");
-var import_logger3 = require("@alwatr/logger");
-var ComputedSignal = class {
-  constructor(config_) {
-    this.config_ = config_;
-    /**
-     * The unique identifier for this signal instance.
-     */
-    this.signalId = this.config_.signalId;
-    /**
-     * The logger instance for this signal.
-     * @protected
-     */
-    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 `.get()` and `.subscribe()` methods.
-     * @protected
-     */
-    this.internalSignal_ = new StateSignal({
-      signalId: `${this.signalId}-internal`,
-      initialValue: this.config_.get()
-    });
-    /**
-     * A list of subscriptions to dependency signals.
-     * @private
-     */
-    this.dependencySubscriptions__ = [];
-    /**
-     * A flag to prevent concurrent recalculations.
-     * @private
-     */
-    this.isRecalculating__ = false;
-    this.logger_.logMethod?.("constructor");
-    this.recalculate_ = this.recalculate_.bind(this);
-    for (const signal of config_.deps) {
-      this.dependencySubscriptions__.push(signal.subscribe(this.recalculate_, { receivePrevious: false }));
-    }
-  }
-  /**
-   * The current value of the computed signal.
-   * Accessing this property returns the memoized value and does not trigger a recalculation.
-   *
-   * @returns The current computed value.
-   * @throws {Error} If accessed after the signal has been destroyed.
-   */
-  get() {
-    return this.internalSignal_.get();
-  }
-  /**
-   * Indicates whether the computed signal has been destroyed.
-   * A destroyed signal cannot be used and will throw an error if interacted with.
-   * @returns `true` if the signal is destroyed, `false` otherwise.
-   */
-  get isDestroyed() {
-    return this.internalSignal_.isDestroyed;
-  }
-  /**
-   * Subscribes a listener to this signal.
-   * The listener will be called whenever the computed value changes.
-   *
-   * @param callback The function to be called with the new value.
-   * @param options Subscription options.
-   * @returns A `SubscribeResult` object with an `unsubscribe` method.
-   */
-  subscribe(callback, options) {
-    return this.internalSignal_.subscribe(callback, options);
-  }
-  /**
-   * Returns a Promise that resolves with the next computed value.
-   *
-   * @returns A Promise that resolves with the next value.
-   */
-  untilNext() {
-    return this.internalSignal_.untilNext();
-  }
-  /**
-   * Permanently disposes of the computed signal.
-   *
-   * This is a critical cleanup step. It unsubscribes from all dependency signals,
-   * 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 `.get()` or `.subscribe()` will throw an error.
-   */
-  destroy() {
-    this.logger_.logMethod?.("destroy");
-    if (this.isDestroyed) {
-      this.logger_.incident?.("destroy", "already_destroyed");
-      return;
-    }
-    for (const subscription of this.dependencySubscriptions__) {
-      subscription.unsubscribe();
-    }
-    this.dependencySubscriptions__.length = 0;
-    this.internalSignal_.destroy();
-    this.config_.onDestroy?.();
-    this.config_ = null;
-  }
-  /**
-   * Schedules a recalculation of the signal's value.
-   *
-   * This method batches updates using a macrotask (`delay.nextMacrotask`) to ensure the
-   * `get` function runs only once per event loop tick, even if multiple dependencies
-   * change in the same synchronous block of code.
-   * @protected
-   */
-  async recalculate_() {
-    this.logger_.logMethod?.("recalculate_");
-    if (this.internalSignal_.isDestroyed) {
-      this.logger_.incident?.("recalculate_", "recalculate_on_destroyed_signal");
-      return;
-    }
-    if (this.isRecalculating__) {
-      this.logger_.logStep?.("recalculate_", "skipping_recalculation_already_scheduled");
-      return;
-    }
-    this.isRecalculating__ = true;
-    try {
-      await import_delay3.delay.nextMacrotask();
-      if (this.isDestroyed) {
-        this.logger_.incident?.("recalculate_", "destroyed_during_delay");
-        this.isRecalculating__ = false;
-        return;
-      }
-      this.logger_.logStep?.("recalculate_", "recalculating_value");
-      this.internalSignal_.set(this.config_.get());
-    } catch (err) {
-      this.logger_.error("recalculate_", "recalculation_failed", err);
-    }
-    this.isRecalculating__ = false;
-  }
-};
-
-// src/core/effect-signal.ts
-var import_delay4 = require("@alwatr/delay");
-var import_logger4 = require("@alwatr/logger");
-var EffectSignal = class {
-  constructor(config_) {
-    this.config_ = config_;
-    /**
-     * The unique identifier for this signal instance.
-     */
-    this.signalId = this.config_.signalId ? this.config_.signalId : `[${this.config_.deps.map((dep) => dep.signalId).join(", ")}]`;
-    /**
-     * The logger instance for this signal.
-     * @protected
-     */
-    this.logger_ = (0, import_logger4.createLogger)(`effect-signal: ${this.signalId}`);
-    /**
-     * A list of subscriptions to dependency signals.
-     * @private
-     */
-    this.dependencySubscriptions__ = [];
-    /**
-     * A flag to prevent concurrent executions of the effect.
-     * @private
-     */
-    this.isRunning__ = false;
-    /**
-     * A flag indicating whether the effect has been destroyed.
-     * @private
-     */
-    this.isDestroyed__ = false;
-    this.logger_.logMethod?.("constructor");
-    this.scheduleExecution_ = this.scheduleExecution_.bind(this);
-    for (const signal of config_.deps) {
-      this.dependencySubscriptions__.push(signal.subscribe(this.scheduleExecution_, { receivePrevious: false }));
-    }
-    if (config_.runImmediately === true) {
-      void this.scheduleExecution_();
-    }
-  }
-  /**
-   * Indicates whether the effect signal has been destroyed.
-   * A destroyed signal will no longer execute its effect and cannot be reused.
-   *
-   * @returns `true` if the signal is destroyed, `false` otherwise.
-   */
-  get isDestroyed() {
-    return this.isDestroyed__;
-  }
-  /**
-   * Schedules the execution of the effect's `run` function.
-   *
-   * This method batches updates using a macrotask (`delay.nextMacrotask`) to ensure the
-   * `run` function executes only once per event loop tick, even if multiple
-   * dependencies change simultaneously.
-   * @protected
-   */
-  async scheduleExecution_() {
-    this.logger_.logMethod?.("scheduleExecution_");
-    if (this.isDestroyed__) {
-      this.logger_.incident?.("scheduleExecution_", "schedule_execution_on_destroyed_signal");
-      return;
-    }
-    if (this.isRunning__) {
-      this.logger_.logStep?.("scheduleExecution_", "skipped_because_already_running");
-      return;
-    }
-    this.isRunning__ = true;
-    try {
-      await import_delay4.delay.nextMacrotask();
-      if (this.isDestroyed__) {
-        this.logger_.incident?.("scheduleExecution_", "destroyed_during_delay");
-        this.isRunning__ = false;
-        return;
-      }
-      this.logger_.logStep?.("scheduleExecution_", "executing_effect");
-      await this.config_.run();
-    } catch (err) {
-      this.logger_.error("scheduleExecution_", "effect_failed", err);
-    }
-    this.isRunning__ = false;
-  }
-  /**
-   * Permanently disposes of the effect signal.
-   *
-   * This is a critical cleanup step. It unsubscribes from all dependency signals,
-   * stopping any future executions of the effect and allowing it to be garbage collected.
-   * Failure to call `destroy()` will result in memory leaks and potentially unwanted side effects.
-   */
-  destroy() {
-    this.logger_.logMethod?.("destroy");
-    if (this.isDestroyed__) {
-      this.logger_.incident?.("destroy", "already_destroyed");
-      return;
-    }
-    this.isDestroyed__ = true;
-    for (const subscription of this.dependencySubscriptions__) {
-      subscription.unsubscribe();
-    }
-    this.dependencySubscriptions__.length = 0;
-    this.config_.onDestroy?.();
-    this.config_ = null;
-  }
-};
-
-// src/creators/event.ts
-function createEventSignal(config) {
-  return new EventSignal(config);
-}
-
-// src/creators/state.ts
-function createStateSignal(config) {
-  return new StateSignal(config);
-}
-
-// src/creators/computed.ts
-function createComputedSignal(config) {
-  return new ComputedSignal(config);
-}
-
-// src/creators/effect.ts
-function createEffect(config) {
-  return new EffectSignal(config);
-}
-
-// src/operators/debounce.ts
-var import_debounce = require("@alwatr/debounce");
-function createDebouncedSignal(sourceSignal, config) {
-  const signalId = config.signalId ?? `${sourceSignal.signalId}-debounced`;
-  const internalSignal = new StateSignal({
-    signalId: `${signalId}-internal`,
-    initialValue: sourceSignal.get()
-  });
-  const debouncer = (0, import_debounce.createDebouncer)({
-    ...config,
-    func: (value) => {
-      internalSignal.set(value);
-    }
-  });
-  const subscription = sourceSignal.subscribe(debouncer.trigger);
-  return createComputedSignal({
-    signalId,
-    deps: [internalSignal],
-    get: () => internalSignal.get(),
-    onDestroy: () => {
-      if (internalSignal.isDestroyed) return;
-      subscription.unsubscribe();
-      debouncer.cancel();
-      internalSignal.destroy();
-      config.onDestroy?.();
-      config = null;
-    }
-  });
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ComputedSignal,
-  EffectSignal,
-  EventSignal,
-  SignalBase,
-  StateSignal,
-  createComputedSignal,
-  createDebouncedSignal,
-  createEffect,
-  createEventSignal,
-  createStateSignal
-});
+/* @alwatr/signal v5.2.2 */
+"use strict";var __defProp=Object.defineProperty;var __getOwnPropDesc=Object.getOwnPropertyDescriptor;var __getOwnPropNames=Object.getOwnPropertyNames;var __hasOwnProp=Object.prototype.hasOwnProperty;var __export=(target,all)=>{for(var name in all)__defProp(target,name,{get:all[name],enumerable:true})};var __copyProps=(to,from,except,desc)=>{if(from&&typeof from==="object"||typeof from==="function"){for(let key of __getOwnPropNames(from))if(!__hasOwnProp.call(to,key)&&key!==except)__defProp(to,key,{get:()=>from[key],enumerable:!(desc=__getOwnPropDesc(from,key))||desc.enumerable})}return to};var __toCommonJS=mod=>__copyProps(__defProp({},"__esModule",{value:true}),mod);var main_exports={};__export(main_exports,{ComputedSignal:()=>ComputedSignal,EffectSignal:()=>EffectSignal,EventSignal:()=>EventSignal,SignalBase:()=>SignalBase,StateSignal:()=>StateSignal,createComputedSignal:()=>createComputedSignal,createDebouncedSignal:()=>createDebouncedSignal,createEffect:()=>createEffect,createEventSignal:()=>createEventSignal,createStateSignal:()=>createStateSignal});module.exports=__toCommonJS(main_exports);var SignalBase=class{constructor(config_){this.config_=config_;this.signalId=this.config_.signalId;this.observers_=[];this.isDestroyed__=false}get isDestroyed(){return this.isDestroyed__}removeObserver_(observer){this.logger_.logMethod?.("removeObserver_");if(this.isDestroyed__){this.logger_.incident?.("removeObserver_","remove_observer_on_destroyed_signal");return}const index=this.observers_.indexOf(observer);if(index!==-1){this.observers_.splice(index,1)}}subscribe(callback,options){this.logger_.logMethodArgs?.("subscribe.base",options);this.checkDestroyed_();const observer={callback,options};if(options?.priority){this.observers_.unshift(observer)}else{this.observers_.push(observer)}return{unsubscribe:()=>this.removeObserver_(observer)}}notify_(value){this.logger_.logMethodArgs?.("notify_",value);if(this.isDestroyed__){this.logger_.incident?.("notify_","notify_on_destroyed_signal");return}const currentObservers=[...this.observers_];for(const observer of currentObservers){if(observer.options?.once){this.removeObserver_(observer)}try{const result=observer.callback(value);if(result instanceof Promise){result.catch(err=>this.logger_.error("notify_","async_callback_failed",err,{observer}))}}catch(err){this.logger_.error("notify_","sync_callback_failed",err)}}}untilNext(){this.logger_.logMethod?.("untilNext");this.checkDestroyed_();return new Promise(resolve=>{this.subscribe(resolve,{once:true,priority:true,receivePrevious:false})})}destroy(){this.logger_.logMethod?.("destroy");if(this.isDestroyed__){this.logger_.incident?.("destroy_","double_destroy_attempt");return}this.isDestroyed__=true;this.observers_.length=0;this.config_.onDestroy?.();this.config_=null}checkDestroyed_(){if(this.isDestroyed__){this.logger_.accident("checkDestroyed_","attempt_to_use_destroyed_signal");throw new Error(`Cannot interact with a destroyed signal (id: ${this.signalId})`)}}};var import_delay=require("@alwatr/delay");var import_logger=require("@alwatr/logger");var EventSignal=class extends SignalBase{constructor(config){super(config);this.logger_=(0,import_logger.createLogger)(`event-signal: ${this.signalId}`);this.logger_.logMethod?.("constructor")}dispatch(payload){this.logger_.logMethodArgs?.("dispatch",{payload});this.checkDestroyed_();import_delay.delay.nextMicrotask().then(()=>this.notify_(payload))}};var import_delay2=require("@alwatr/delay");var import_logger2=require("@alwatr/logger");var StateSignal=class extends SignalBase{constructor(config){super(config);this.logger_=(0,import_logger2.createLogger)(`state-signal: ${this.signalId}`);this.value__=config.initialValue;this.logger_.logMethodArgs?.("constructor",{initialValue:this.value__})}get(){this.checkDestroyed_();return this.value__}set(newValue){this.logger_.logMethodArgs?.("set",{newValue});this.checkDestroyed_();if(Object.is(this.value__,newValue)&&(typeof newValue!=="object"||newValue===null)){return}this.value__=newValue;import_delay2.delay.nextMicrotask().then(()=>this.notify_(newValue))}update(updater){this.logger_.logMethod?.("update");this.checkDestroyed_();this.set(updater(this.value__))}subscribe(callback,options={}){this.logger_.logMethodArgs?.("subscribe",options);this.checkDestroyed_();if(options.receivePrevious!==false){import_delay2.delay.nextMicrotask().then(()=>{this.logger_.logStep?.("subscribe","immediate_callback");callback(this.value__)}).catch(err=>this.logger_.error("subscribe","immediate_callback_failed",err));if(options.once){return{unsubscribe:()=>{}}}}return super.subscribe(callback,options)}destroy(){this.value__=null;super.destroy()}};var import_delay3=require("@alwatr/delay");var import_logger3=require("@alwatr/logger");var ComputedSignal=class{constructor(config_){this.config_=config_;this.signalId=this.config_.signalId;this.logger_=(0,import_logger3.createLogger)(`computed-signal: ${this.signalId}`);this.internalSignal_=new StateSignal({signalId:`${this.signalId}-internal`,initialValue:this.config_.get()});this.dependencySubscriptions__=[];this.isRecalculating__=false;this.logger_.logMethod?.("constructor");this.recalculate_=this.recalculate_.bind(this);for(const signal of config_.deps){this.dependencySubscriptions__.push(signal.subscribe(this.recalculate_,{receivePrevious:false}))}}get(){return this.internalSignal_.get()}get isDestroyed(){return this.internalSignal_.isDestroyed}subscribe(callback,options){return this.internalSignal_.subscribe(callback,options)}untilNext(){return this.internalSignal_.untilNext()}destroy(){this.logger_.logMethod?.("destroy");if(this.isDestroyed){this.logger_.incident?.("destroy","already_destroyed");return}for(const subscription of this.dependencySubscriptions__){subscription.unsubscribe()}this.dependencySubscriptions__.length=0;this.internalSignal_.destroy();this.config_.onDestroy?.();this.config_=null}async recalculate_(){this.logger_.logMethod?.("recalculate_");if(this.internalSignal_.isDestroyed){this.logger_.incident?.("recalculate_","recalculate_on_destroyed_signal");return}if(this.isRecalculating__){this.logger_.logStep?.("recalculate_","skipping_recalculation_already_scheduled");return}this.isRecalculating__=true;try{await import_delay3.delay.nextMacrotask();if(this.isDestroyed){this.logger_.incident?.("recalculate_","destroyed_during_delay");this.isRecalculating__=false;return}this.logger_.logStep?.("recalculate_","recalculating_value");this.internalSignal_.set(this.config_.get())}catch(err){this.logger_.error("recalculate_","recalculation_failed",err)}this.isRecalculating__=false}};var import_delay4=require("@alwatr/delay");var import_logger4=require("@alwatr/logger");var EffectSignal=class{constructor(config_){this.config_=config_;this.signalId=this.config_.signalId??`[${this.config_.deps.map(dep=>dep.signalId).join(", ")}]`;this.logger_=(0,import_logger4.createLogger)(`effect-signal: ${this.signalId}`);this.dependencySubscriptions__=[];this.isRunning__=false;this.isDestroyed__=false;this.logger_.logMethod?.("constructor");this.scheduleExecution_=this.scheduleExecution_.bind(this);for(const signal of config_.deps){this.dependencySubscriptions__.push(signal.subscribe(this.scheduleExecution_,{receivePrevious:false}))}if(config_.runImmediately===true){void this.scheduleExecution_()}}get isDestroyed(){return this.isDestroyed__}async scheduleExecution_(){this.logger_.logMethod?.("scheduleExecution_");if(this.isDestroyed__){this.logger_.incident?.("scheduleExecution_","schedule_execution_on_destroyed_signal");return}if(this.isRunning__){this.logger_.logStep?.("scheduleExecution_","skipped_because_already_running");return}this.isRunning__=true;try{await import_delay4.delay.nextMacrotask();if(this.isDestroyed__){this.logger_.incident?.("scheduleExecution_","destroyed_during_delay");this.isRunning__=false;return}this.logger_.logStep?.("scheduleExecution_","executing_effect");await this.config_.run()}catch(err){this.logger_.error("scheduleExecution_","effect_failed",err)}this.isRunning__=false}destroy(){this.logger_.logMethod?.("destroy");if(this.isDestroyed__){this.logger_.incident?.("destroy","already_destroyed");return}this.isDestroyed__=true;for(const subscription of this.dependencySubscriptions__){subscription.unsubscribe()}this.dependencySubscriptions__.length=0;this.config_.onDestroy?.();this.config_=null}};function createEventSignal(config){return new EventSignal(config)}function createStateSignal(config){return new StateSignal(config)}function createComputedSignal(config){return new ComputedSignal(config)}function createEffect(config){return new EffectSignal(config)}var import_debounce=require("@alwatr/debounce");function createDebouncedSignal(sourceSignal,config){const signalId=config.signalId??`${sourceSignal.signalId}-debounced`;const internalSignal=new StateSignal({signalId:`${signalId}-internal`,initialValue:sourceSignal.get()});const debouncer=(0,import_debounce.createDebouncer)({...config,func:value=>{internalSignal.set(value)}});const subscription=sourceSignal.subscribe(value=>debouncer.trigger(value),{receivePrevious:false});return createComputedSignal({signalId,deps:[internalSignal],get:()=>internalSignal.get(),onDestroy:()=>{if(internalSignal.isDestroyed)return;subscription.unsubscribe();debouncer.cancel();internalSignal.destroy();config.onDestroy?.();config=null}})}0&&(module.exports={ComputedSignal,EffectSignal,EventSignal,SignalBase,StateSignal,createComputedSignal,createDebouncedSignal,createEffect,createEventSignal,createStateSignal});
 //# sourceMappingURL=main.cjs.map