@alwatr/signal 5.2.1 → 6.0.0

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

@@ -5,23 +5,37 @@ import {delay} from '@alwatr/delay';
 describe('StateSignal', () => {
   /** @type {StateSignal<number>} */
   let signal;
-  const signalId = 'test-state-signal';
+  const name = 'test-state-signal';
 
   beforeEach(() => {
-    signal = new StateSignal({signalId, initialValue: 0});
+    signal = new StateSignal({name, initialValue: 0});
   });
 
   afterEach(() => {
     signal.destroy();
   });
 
-  it('should be defined and have the correct signalId and initial value', () => {
+  it('should be defined and have the correct name and initial value', () => {
     expect(StateSignal).toBeDefined();
     expect(signal).toBeInstanceOf(StateSignal);
-    expect(signal.signalId).toBe(signalId);
+    expect(signal.name).toBe(name);
     expect(signal.get()).toBe(0);
   });
 
+  it('should notify subscriber with receivePrevious', async () => {
+    const callback = jest.fn();
+    const newValue = 42;
+
+    signal.subscribe(callback);
+    await delay.nextMacrotask();
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith(0);
+    signal.set(newValue);
+    await delay.nextMacrotask();
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenCalledWith(newValue);
+  });
+
   it('should notify subscribers when value changes', async () => {
     const callback = jest.fn();
     const newValue = 42;
@@ -140,7 +154,7 @@ describe('StateSignal', () => {
   it('should notify subscribers multiple times for object values when they change', async () => {
     const callback = jest.fn();
     const value = {a: 1};
-    const signal = new StateSignal({signalId: 'object-signal', initialValue: value});
+    const signal = new StateSignal({name: 'object-signal', initialValue: value});
     
     signal.subscribe(callback, {receivePrevious: false});
 
@@ -193,11 +207,12 @@ describe('StateSignal', () => {
 
     signal.subscribe(errorCallback, {receivePrevious: false});
     signal.subscribe(normalCallback, {receivePrevious: false});
-    signal.set(1);
-
+    signal.set(5);
+    signal.set(10);
     await delay.nextMacrotask();
-    expect(errorCallback).toHaveBeenCalledTimes(1);
-    expect(normalCallback).toHaveBeenCalledTimes(1);
+    expect(errorCallback).toHaveBeenCalledTimes(2);
+    expect(normalCallback).toHaveBeenCalledTimes(2);
+    expect(normalCallback).toHaveBeenCalledWith(10)
   });
 
   describe('destroyed signal', () => {
@@ -206,23 +221,23 @@ describe('StateSignal', () => {
     });
 
     it('should throw an error when set is called on a destroyed signal', () => {
-      expect(() => signal.set(1)).toThrow(`Cannot interact with a destroyed signal (id: ${signalId})`);
+      expect(() => signal.set(1)).toThrow(`Cannot interact with a destroyed signal (id: ${name})`);
     });
 
     it('should throw an error when subscribe is called on a destroyed signal', () => {
-      expect(() => signal.subscribe(jest.fn())).toThrow(`Cannot interact with a destroyed signal (id: ${signalId})`);
+      expect(() => signal.subscribe(jest.fn())).toThrow(`Cannot interact with a destroyed signal (id: ${name})`);
     });
 
     it('should throw an error when untilNext is called on a destroyed signal', () => {
-      expect(() => signal.untilNext()).toThrow(`Cannot interact with a destroyed signal (id: ${signalId})`);
+      expect(() => signal.untilNext()).toThrow(`Cannot interact with a destroyed signal (id: ${name})`);
     });
 
     it('should throw an error when accessing value on a destroyed signal', () => {
-      expect(() => signal.get()).toThrow(`Cannot interact with a destroyed signal (id: ${signalId})`);
+      expect(() => signal.get()).toThrow(`Cannot interact with a destroyed signal (id: ${name})`);
     });
 
     it('should not notify any listeners after being destroyed', async () => {
-      const localSignal = new StateSignal({signalId: 'local', initialValue: 0});
+      const localSignal = new StateSignal({name: 'local', initialValue: 0});
       const callback = jest.fn();
       localSignal.subscribe(callback, {receivePrevious: false});
 

package/src/operators/debounce.test.js

@@ -0,0 +1,206 @@
+import {describe, beforeEach, afterEach, it, expect, jest} from '@jest/globals';
+import {ComputedSignal, createDebouncedSignal, StateSignal} from '@alwatr/signal';
+
+describe('createDebouncedSignal', () => {
+  /** @type {ComputedSignal<number>} */
+  let debouncedSignal;
+  /** @type {StateSignal<number>} */
+  let sourceSignal;
+  const name = 'test-debounce-signal';
+  /**
+   * @type {import("jest-mock").Mock<import("jest-mock").UnknownFunction>}
+   */
+  let mockFunc;
+
+  beforeEach(() => {
+    mockFunc = jest.fn();
+    jest.useFakeTimers();
+    sourceSignal = new StateSignal({name, initialValue: 0});
+  });
+
+  afterEach(() => {
+    jest.clearAllTimers();
+    jest.useRealTimers();
+    sourceSignal?.destroy();
+    debouncedSignal?.destroy();
+  });
+
+  it('should create a debounced signal with default config', () => {
+    debouncedSignal = createDebouncedSignal(sourceSignal, {delay: 100});
+    expect(debouncedSignal.get()).toBe(0);
+    expect(debouncedSignal.name).toBe(`${name}-debounced`);
+  });
+
+  it('should debounce updates with trailing edge', async () => {
+    debouncedSignal = createDebouncedSignal(sourceSignal, {delay: 100});
+    await jest.advanceTimersByTimeAsync(1);
+    sourceSignal.set(1);
+    sourceSignal.set(2);
+    expect(debouncedSignal.get()).toBe(0);
+    await jest.advanceTimersByTimeAsync(110);
+    expect(debouncedSignal.get()).toBe(2);
+  });
+
+  it('should support leading edge', async () => {
+    debouncedSignal = createDebouncedSignal(sourceSignal, {delay: 100, leading: true});
+    await jest.advanceTimersByTimeAsync(1);
+    sourceSignal.set(1);
+    await jest.advanceTimersByTimeAsync(1);
+    expect(debouncedSignal.get()).toBe(1);
+    sourceSignal.set(2);
+    await jest.advanceTimersByTimeAsync(10);
+    expect(debouncedSignal.get()).toBe(1);
+    await jest.advanceTimersByTimeAsync(100);
+    expect(debouncedSignal.get()).toBe(2);
+  });
+
+  it('should support trailing edge', async () => {
+    debouncedSignal = createDebouncedSignal(sourceSignal, {delay: 100, trailing: true});
+    await jest.advanceTimersByTimeAsync(1);
+    sourceSignal.set(1);
+    sourceSignal.set(2);
+    await jest.advanceTimersByTimeAsync(1);
+    expect(debouncedSignal.get()).toBe(0);
+    await jest.advanceTimersByTimeAsync(100);
+    expect(debouncedSignal.get()).toBe(2);
+  });
+
+  it('should cancel debounced updates on destroy', async () => {
+    debouncedSignal = createDebouncedSignal(sourceSignal, {delay: 100});
+    await jest.advanceTimersByTimeAsync(1);
+    sourceSignal.set(1);
+    await jest.advanceTimersByTimeAsync(1);
+    debouncedSignal.destroy();
+    expect(() => debouncedSignal.get()).toThrow(); // Should throw on access after
+  });
+
+  it('should call onDestroy callback if provided', () => {
+    const onDestroyMock = jest.fn();
+    debouncedSignal = createDebouncedSignal(sourceSignal, {delay: 100, onDestroy: onDestroyMock});
+    debouncedSignal.destroy();
+    expect(onDestroyMock).toHaveBeenCalled();
+  });
+
+  it('should use custom name if provided', () => {
+    debouncedSignal = createDebouncedSignal(sourceSignal, {delay: 100, name: 'custom-debounced'});
+    expect(debouncedSignal.name).toBe('custom-debounced');
+  });
+
+  it('should handle multiple rapid updates correctly', async () => {
+    debouncedSignal = createDebouncedSignal(sourceSignal, {delay: 100});
+    await jest.advanceTimersByTimeAsync(1);
+    sourceSignal.set(1);
+    await jest.advanceTimersByTimeAsync(50);
+    sourceSignal.set(2);
+    await jest.advanceTimersByTimeAsync(50);
+    sourceSignal.set(3);
+    expect(debouncedSignal.get()).toBe(0);
+    await jest.advanceTimersByTimeAsync(110);
+    expect(debouncedSignal.get()).toBe(3);
+  });
+
+    it('should notify subscriber with receivePrevious', async () => {
+    debouncedSignal = createDebouncedSignal(sourceSignal, {delay: 100});
+    const callback = jest.fn();
+    debouncedSignal.subscribe(callback);
+    await jest.advanceTimersByTimeAsync(1);
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith(0);
+  });
+
+  it('should notify subscribers when debounced value changes', async () => {
+    debouncedSignal = createDebouncedSignal(sourceSignal, {delay: 100});
+    const callback = jest.fn();
+    debouncedSignal.subscribe(callback, {receivePrevious: false});
+    sourceSignal.set(1);
+    await jest.advanceTimersByTimeAsync(110);
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith(1);
+  });
+
+  it('should not notify if debounced value does not change', async () => {
+    debouncedSignal = createDebouncedSignal(sourceSignal, {delay: 100});
+    const callback = jest.fn();
+    debouncedSignal.subscribe(callback, {receivePrevious: false});
+    sourceSignal.set(0); // Same as initial
+    await jest.advanceTimersByTimeAsync(110);
+    expect(callback).not.toHaveBeenCalled();
+  });
+
+  it('should notify multiple subscribers', async () => {
+    debouncedSignal = createDebouncedSignal(sourceSignal, {delay: 100});
+    const callback1 = jest.fn();
+    const callback2 = jest.fn();
+    debouncedSignal.subscribe(callback1, {receivePrevious: false});
+    debouncedSignal.subscribe(callback2, {receivePrevious: false});
+    sourceSignal.set(5);
+    await jest.advanceTimersByTimeAsync(110);
+    expect(callback1).toHaveBeenCalledTimes(1);
+    expect(callback1).toHaveBeenCalledWith(5);
+    expect(callback2).toHaveBeenCalledTimes(1);
+    expect(callback2).toHaveBeenCalledWith(5);
+  });
+
+  it('should not notify unsubscribed listeners', async () => {
+    debouncedSignal = createDebouncedSignal(sourceSignal, {delay: 100});
+    const callback = jest.fn();
+    const subscription = debouncedSignal.subscribe(callback, {receivePrevious: false});
+    subscription.unsubscribe();
+    sourceSignal.set(10);
+    await jest.advanceTimersByTimeAsync(110);
+    expect(callback).not.toHaveBeenCalled();
+  });
+
+  it('should handle subscriptions with the "once" option', async () => {
+    debouncedSignal = createDebouncedSignal(sourceSignal, {delay: 100});
+    const callback = jest.fn();
+    debouncedSignal.subscribe(callback, {once: true, receivePrevious: false});
+    sourceSignal.set(10);
+    await jest.advanceTimersByTimeAsync(110);
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith(10);
+    sourceSignal.set(20);
+    await jest.advanceTimersByTimeAsync(110);
+    expect(callback).toHaveBeenCalledTimes(1); // Should not be called again
+  });
+
+  it('should resolve untilNext() with the next debounced value', async () => {
+    debouncedSignal = createDebouncedSignal(sourceSignal, {delay: 100});
+    const untilNextPromise = debouncedSignal.untilNext();
+    sourceSignal.set(5);
+    await jest.advanceTimersByTimeAsync(110);
+    await expect(untilNextPromise).resolves.toBe(5);
+  });
+
+  it('should continue notifying other subscribers if one callback throws an error', async () => {
+    debouncedSignal = createDebouncedSignal(sourceSignal, {delay: 100});
+    const callback1 = jest.fn(() => {
+      throw new Error('Test error');
+    });
+    const callback2 = jest.fn();
+    debouncedSignal.subscribe(callback1, {receivePrevious: false});
+    debouncedSignal.subscribe(callback2, {receivePrevious: false});
+    sourceSignal.set(10);
+    await jest.advanceTimersByTimeAsync(110);
+    expect(callback1).toHaveBeenCalledTimes(1);
+    expect(callback2).toHaveBeenCalledTimes(1);
+  });
+
+  it('should update without any subscribers', async () => {
+    debouncedSignal = createDebouncedSignal(sourceSignal, {delay: 100});
+    expect(debouncedSignal.get()).toBe(0);
+    sourceSignal.set(7);
+    await jest.advanceTimersByTimeAsync(110);
+    expect(debouncedSignal.get()).toBe(7);
+  });
+
+  it('should not notify after destroy', async () => {
+    debouncedSignal = createDebouncedSignal(sourceSignal, {delay: 100});
+    const callback = jest.fn();
+    debouncedSignal.subscribe(callback, {receivePrevious: false});
+    debouncedSignal.destroy();
+    sourceSignal.set(10);
+    await jest.advanceTimersByTimeAsync(110);
+    expect(callback).not.toHaveBeenCalled();
+  });
+});