@alwatr/signal 9.33.0 → 9.35.0

package/src/core/derived-signal.ts

@@ -47,7 +47,7 @@ export class DerivedSignal<S, T> implements IReadonlySignal<T> {
   }
 
   untilNext(): Promise<T> {
-    this.logger_.logMethod?.('untilNext');
+    DEV_MODE && this.logger_.logMethod?.('untilNext');
     this.checkDestroyed__();
     return new Promise<T>((resolve) => {
       this.subscribe(
@@ -68,7 +68,7 @@ export class DerivedSignal<S, T> implements IReadonlySignal<T> {
    * @returns The current projected value.
    */
   public get(): T {
-    this.logger_.logMethod?.('get');
+    DEV_MODE && this.logger_.logMethod?.('get');
     this.checkDestroyed__();
     if (this.activeConsumerCount__ === 0) {
       return this.config_.projector(this.config_.source.get());
@@ -94,13 +94,13 @@ export class DerivedSignal<S, T> implements IReadonlySignal<T> {
    * @returns Unsubscribe handle object.
    */
   public subscribe(callback: ListenerCallback<T>, options?: SubscribeOptions): SubscribeResult {
-    this.logger_.logMethod?.('subscribe');
+    DEV_MODE && this.logger_.logMethod?.('subscribe');
     this.checkDestroyed__();
     this.activeConsumerCount__++;
 
     // Wake-up phase: if this is the first active consumer, dynamically clamp to the upstream core source
     if (this.activeConsumerCount__ === 1) {
-      this.logger_.logMethod?.('wakeUp_');
+      DEV_MODE && this.logger_.logMethod?.('wakeUp_');
       this.internalSignal_ = new StateSignal<T>({
         name: `derived-internal:${this.name}`,
         initialValue: this.config_.projector(this.config_.source.get()),
@@ -117,14 +117,14 @@ export class DerivedSignal<S, T> implements IReadonlySignal<T> {
 
     return {
       unsubscribe: () => {
-        this.logger_.logMethod?.('unsubscribe');
+        DEV_MODE && this.logger_.logMethod?.('unsubscribe');
 
         sub.unsubscribe();
         this.activeConsumerCount__--;
 
         // Hibernation phase: unlink tracking dependencies when view elements clear out to preserve processing cycles
         if (this.activeConsumerCount__ === 0 && this.sourceSubscription__) {
-          this.logger_.logMethod?.('sleepCleanup_');
+          DEV_MODE && this.logger_.logMethod?.('sleepCleanup_');
           this.sourceSubscription__.unsubscribe();
           this.sourceSubscription__ = undefined;
           this.internalSignal_?.destroy();
@@ -138,7 +138,7 @@ export class DerivedSignal<S, T> implements IReadonlySignal<T> {
    * Destroys the derived signal and unsubscribes from the source signal if currently awake.
    */
   public destroy(): void {
-    this.logger_.logMethod?.('destroy');
+    DEV_MODE && this.logger_.logMethod?.('destroy');
     if (this.isDestroyed) return;
 
     if (this.sourceSubscription__) {
@@ -158,7 +158,7 @@ export class DerivedSignal<S, T> implements IReadonlySignal<T> {
    * @throws {Error} If destroyed.
    */
   private checkDestroyed__(): void {
-    this.logger_.logMethod?.('checkDestroyed__');
+    DEV_MODE && this.logger_.logMethod?.('checkDestroyed__');
     if (this.isDestroyed) {
       throw new Error(`Cannot interact with a destroyed signal (id: ${this.name})`);
     }

package/src/core/effect-signal.ts

@@ -98,18 +98,18 @@ export class EffectSignal implements IEffectSignal {
     this.logger_ = createLogger(`effect-signal:${this.name}`);
     this.scheduleExecution_ = this.scheduleExecution_.bind(this);
 
-    this.logger_.logMethod?.('constructor');
+    DEV_MODE && this.logger_.logMethod?.('constructor');
 
     // Subscribe to all dependencies. We don't need the previous value,
     // as the `runImmediately` option controls the initial execution.
     for (const signal of config_.deps) {
-      this.logger_.logStep?.('constructor', 'subscribing_to_dependency', {signal: signal.name});
+      DEV_MODE && this.logger_.logStep?.('constructor', 'subscribing_to_dependency', {signal: signal.name});
       this.dependencySubscriptions__.push(signal.subscribe(this.scheduleExecution_, {receivePrevious: false}));
     }
 
     // Run the effect immediately if requested.
     if (config_.runImmediately === true) {
-      this.logger_.logStep?.('constructor', 'scheduling_initial_execution');
+      DEV_MODE && this.logger_.logStep?.('constructor', 'scheduling_initial_execution');
       // We don't need to await this, let it run in the background.
       void this.scheduleExecution_();
     }
@@ -126,15 +126,15 @@ export class EffectSignal implements IEffectSignal {
    * @returns A promise that resolves when the execution schedules or runs.
    */
   protected async scheduleExecution_(): Promise<void> {
-    this.logger_.logMethod?.('scheduleExecution_');
+    DEV_MODE && this.logger_.logMethod?.('scheduleExecution_');
 
     if (this.isDestroyed__) {
-      this.logger_.incident?.('scheduleExecution_', 'schedule_execution_on_destroyed_signal');
+      DEV_MODE && this.logger_.incident?.('scheduleExecution_', 'schedule_execution_on_destroyed_signal');
       return;
     }
     if (this.isRunning__) {
       // If an execution is already scheduled, do nothing.
-      this.logger_.logStep?.('scheduleExecution_', 'skipped_because_already_running');
+      DEV_MODE && this.logger_.logStep?.('scheduleExecution_', 'skipped_because_already_running');
       return;
     }
 
@@ -144,12 +144,12 @@ export class EffectSignal implements IEffectSignal {
       // Wait for the next macrotask to batch simultaneous updates.
       await delay.nextMicrotask();
       if (this.isDestroyed__) {
-        this.logger_.incident?.('scheduleExecution_', 'destroyed_during_delay');
+        DEV_MODE && this.logger_.incident?.('scheduleExecution_', 'destroyed_during_delay');
         this.isRunning__ = false;
         return;
       }
 
-      this.logger_.logStep?.('scheduleExecution_', 'executing_effect');
+      DEV_MODE && this.logger_.logStep?.('scheduleExecution_', 'executing_effect');
       this.config_.run();
     } catch (err) {
       this.logger_.error('scheduleExecution_', 'effect_failed', err);
@@ -167,10 +167,10 @@ export class EffectSignal implements IEffectSignal {
    * Failure to call `destroy()` will result in memory leaks and potentially unwanted side effects.
    */
   public destroy(): void {
-    this.logger_.logMethod?.('destroy');
+    DEV_MODE && this.logger_.logMethod?.('destroy');
 
     if (this.isDestroyed__) {
-      this.logger_.incident?.('destroy', 'already_destroyed');
+      DEV_MODE && this.logger_.incident?.('destroy', 'already_destroyed');
       return;
     }
 

package/src/core/event-signal.ts

@@ -46,7 +46,7 @@ export class EventSignal<T = void> extends SignalBase<T> implements IBaseSignal<
   constructor(config: SignalConfig) {
     super(config);
     this.logger_ = createLogger(`event_signal:${this.name}`);
-    this.logger_.logMethod?.('constructor');
+    DEV_MODE && this.logger_.logMethod?.('constructor');
   }
 
   /**
@@ -58,7 +58,7 @@ export class EventSignal<T = void> extends SignalBase<T> implements IBaseSignal<
    * @param payload The data payload to send with the event.
    */
   public dispatch(payload: T): void {
-    this.logger_.logMethodArgs?.('dispatch', {payload});
+    DEV_MODE && this.logger_.logMethodArgs?.('dispatch', {payload});
     this.checkDestroyed_();
     // Dispatch as a microtask to ensure consistent, non-blocking behavior.
     queueMicrotask(() => this.notify_(payload));

package/src/core/persistent-state-signal.ts

@@ -89,7 +89,7 @@ export class PersistentStateSignal<T> extends StateSignal<T> {
    */
   private readonly windowPageShowListener_ = (event: PageTransitionEvent): void => {
     if (event.persisted) {
-      this.logger_.logMethod?.('windowPageShowListener_//restored_from_bfcache');
+      DEV_MODE && this.logger_.logMethod?.('windowPageShowListener_//restored_from_bfcache');
       const value = this.storageProvider__.read();
       if (value !== null) {
         this.set(value);
@@ -129,7 +129,7 @@ export class PersistentStateSignal<T> extends StateSignal<T> {
       onDestroy,
     });
 
-    this.logger_.logMethodArgs?.('constructor', config);
+    DEV_MODE && this.logger_.logMethodArgs?.('constructor', config);
 
     this.storageProvider__ = storageProvider;
 
@@ -157,7 +157,7 @@ export class PersistentStateSignal<T> extends StateSignal<T> {
    * @private
    */
   private syncStorage__(newValue: T): void {
-    this.logger_.logMethodArgs?.('syncStorage__', newValue);
+    DEV_MODE && this.logger_.logMethodArgs?.('syncStorage__', newValue);
     this.storageProvider__.write(newValue);
   }
 
@@ -167,7 +167,7 @@ export class PersistentStateSignal<T> extends StateSignal<T> {
    */
   public remove(): void {
     this.checkDestroyed_();
-    this.logger_.logMethod?.('remove');
+    DEV_MODE && this.logger_.logMethod?.('remove');
     // Remove from storage.
     this.storageProvider__.remove();
   }
@@ -176,7 +176,7 @@ export class PersistentStateSignal<T> extends StateSignal<T> {
    * Overrides the destroy method to also clean up the storage sync subscription and event listeners.
    */
   public override destroy(): void {
-    this.logger_.logMethod?.('destroy');
+    DEV_MODE && this.logger_.logMethod?.('destroy');
     if (typeof globalThis.removeEventListener === 'function') {
       globalThis.removeEventListener('pagehide', this.windowPageHideListener_);
       globalThis.removeEventListener('pageshow', this.windowPageShowListener_);

package/src/core/session-state-signal.ts

@@ -99,7 +99,7 @@ export class SessionStateSignal<T> extends StateSignal<T> {
    */
   private readonly windowPageShowListener__ = (event: PageTransitionEvent): void => {
     if (event.persisted) {
-      this.logger_.logMethod?.('windowPageShowListener__//restored_from_bfcache');
+      DEV_MODE && this.logger_.logMethod?.('windowPageShowListener__//restored_from_bfcache');
       const value = this.storageProvider__.read();
       if (value !== null) {
         this.set(value);
@@ -129,7 +129,7 @@ export class SessionStateSignal<T> extends StateSignal<T> {
       onDestroy,
     });
 
-    this.logger_.logMethodArgs?.('constructor', config);
+    DEV_MODE && this.logger_.logMethodArgs?.('constructor', config);
 
     this.storageProvider__ = storageProvider;
 
@@ -157,7 +157,7 @@ export class SessionStateSignal<T> extends StateSignal<T> {
    * @private
    */
   private syncStorage__(newValue: T): void {
-    this.logger_.logMethodArgs?.('syncStorage__', newValue);
+    DEV_MODE && this.logger_.logMethodArgs?.('syncStorage__', newValue);
     this.storageProvider__.write(newValue);
   }
 
@@ -175,7 +175,7 @@ export class SessionStateSignal<T> extends StateSignal<T> {
    */
   public remove(): void {
     this.checkDestroyed_();
-    this.logger_.logMethod?.('remove');
+    DEV_MODE && this.logger_.logMethod?.('remove');
     this.storageProvider__.remove();
   }
 
@@ -192,7 +192,7 @@ export class SessionStateSignal<T> extends StateSignal<T> {
    * ```
    */
   public override destroy(): void {
-    this.logger_.logMethod?.('destroy');
+    DEV_MODE && this.logger_.logMethod?.('destroy');
     if (typeof globalThis.removeEventListener === 'function') {
       globalThis.removeEventListener('pagehide', this.windowPageHideListener__);
       globalThis.removeEventListener('pageshow', this.windowPageShowListener__);

package/src/core/signal-base.ts

@@ -74,10 +74,10 @@ export abstract class SignalBase<T> {
    * @protected
    */
   protected removeObserver_(observer: Observer_<T>): void {
-    this.logger_.logMethod?.('removeObserver_');
+    DEV_MODE && this.logger_.logMethod?.('removeObserver_');
 
     if (this.isDestroyed__) {
-      this.logger_.incident?.('removeObserver_', 'remove_observer_on_destroyed_signal');
+      DEV_MODE && this.logger_.incident?.('removeObserver_', 'remove_observer_on_destroyed_signal');
       return;
     }
 
@@ -104,7 +104,7 @@ export abstract class SignalBase<T> {
    * @returns An object with an `unsubscribe` method to remove the subscription.
    */
   public subscribe(callback: ListenerCallback<T>, options?: SubscribeOptions): SubscribeResult {
-    this.logger_.logMethodArgs?.('subscribe.base', options);
+    DEV_MODE && this.logger_.logMethodArgs?.('subscribe.base', options);
     this.checkDestroyed_();
 
     const observer: Observer_<T> = {callback, options};
@@ -131,10 +131,10 @@ export abstract class SignalBase<T> {
    * @protected
    */
   protected notify_(value: T): void {
-    this.logger_.logMethodArgs?.('notify_', value);
+    DEV_MODE && this.logger_.logMethodArgs?.('notify_', value);
 
     if (this.isDestroyed__) {
-      this.logger_.incident?.('notify_', 'notify_on_destroyed_signal');
+      DEV_MODE && this.logger_.incident?.('notify_', 'notify_on_destroyed_signal');
       return;
     }
 
@@ -187,7 +187,7 @@ export abstract class SignalBase<T> {
    * @returns A Promise that resolves with the next value dispatched by the signal.
    */
   public untilNext(): Promise<T> {
-    this.logger_.logMethod?.('untilNext');
+    DEV_MODE && this.logger_.logMethod?.('untilNext');
     this.checkDestroyed_();
     return new Promise((resolve, reject) => {
       this.pendingRejects__ ??= new Set();
@@ -212,9 +212,9 @@ export abstract class SignalBase<T> {
    * invokes the optional `onDestroy` config hook, and breaks internal references to facilitate GC.
    */
   public destroy(): void {
-    this.logger_.logMethod?.('destroy');
+    DEV_MODE && this.logger_.logMethod?.('destroy');
     if (this.isDestroyed__) {
-      this.logger_.incident?.('destroy_', 'double_destroy_attempt');
+      DEV_MODE && this.logger_.incident?.('destroy_', 'double_destroy_attempt');
       return;
     }
     this.isDestroyed__ = true;
@@ -241,7 +241,7 @@ export abstract class SignalBase<T> {
    */
   protected checkDestroyed_(): void {
     if (this.isDestroyed__) {
-      this.logger_.accident('checkDestroyed_', 'attempt_to_use_destroyed_signal');
+      DEV_MODE && this.logger_.accident('checkDestroyed_', 'attempt_to_use_destroyed_signal');
       throw new Error(`Cannot interact with a destroyed signal (id: ${this.name})`);
     }
   }

package/src/core/state-signal.ts

@@ -79,7 +79,7 @@ export class StateSignal<T> extends SignalBase<T> implements IReadonlySignal<T>
     });
     this.logger_ = createLogger(`state_signal:${this.name}`);
     this.value__ = config.initialValue;
-    this.logger_.logMethodArgs?.('constructor', {initialValue: this.value__});
+    DEV_MODE && this.logger_.logMethodArgs?.('constructor', {initialValue: this.value__});
   }
 
   /**
@@ -113,7 +113,7 @@ export class StateSignal<T> extends SignalBase<T> implements IReadonlySignal<T>
    * mySignal.set({ ...mySignal.get(), property: 'new-value' });
    */
   public set(newValue: T): void {
-    this.logger_.logMethodArgs?.('set', {newValue});
+    DEV_MODE && this.logger_.logMethodArgs?.('set', {newValue});
 
     // For primitives (including null), do not notify if the value is the same.
     if (Object.is(this.value__, newValue) && (typeof newValue !== 'object' || newValue === null)) {
@@ -132,7 +132,7 @@ export class StateSignal<T> extends SignalBase<T> implements IReadonlySignal<T>
    * Notification is queued as a microtask for batching.
    */
   public notifyChange(): void {
-    this.logger_.logMethod?.('notifyChange');
+    DEV_MODE && this.logger_.logMethod?.('notifyChange');
     this.checkDestroyed_();
 
     this.notifyVersion__++;
@@ -163,7 +163,7 @@ export class StateSignal<T> extends SignalBase<T> implements IReadonlySignal<T>
   public update(updater: (previousValue: T) => T): void {
     this.checkDestroyed_();
     const newValue = updater(this.value__);
-    this.logger_.logMethodFull?.('update', this.value__, newValue);
+    DEV_MODE && this.logger_.logMethodFull?.('update', this.value__, newValue);
     this.set(newValue);
   }
 
@@ -178,7 +178,7 @@ export class StateSignal<T> extends SignalBase<T> implements IReadonlySignal<T>
    * @returns An object with an `unsubscribe` method to remove the listener.
    */
   public override subscribe(callback: ListenerCallback<T>, options: SubscribeOptions = {}): SubscribeResult {
-    this.logger_.logMethodArgs?.('subscribe', options);
+    DEV_MODE && this.logger_.logMethodArgs?.('subscribe', options);
     this.checkDestroyed_();
 
     const result = super.subscribe(callback, options);
@@ -189,7 +189,7 @@ export class StateSignal<T> extends SignalBase<T> implements IReadonlySignal<T>
     const subscribeVersion = this.notifyVersion__;
 
     queueMicrotask((): void => {
-      this.logger_.logStep?.('subscribe', 'immediate_callback');
+      DEV_MODE && this.logger_.logStep?.('subscribe', 'immediate_callback');
       if (this.notifyVersion__ !== subscribeVersion) return; // A notification occurred after subscribing, so skip the immediate callback.
       if (options.once) {
         result.unsubscribe();