@alwatr/signal 6.2.0 → 9.1.0

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

@@ -1,150 +0,0 @@
-import {describe, beforeEach, afterEach, it, expect, jest} from '@jest/globals';
-import {EffectSignal, StateSignal} from '@alwatr/signal';
-import {delay} from '@alwatr/delay';
-
-describe('EffectSignal', () => {
-  /** @type {StateSignal<number>} */
-  let depSignal;
-  /** @type {EffectSignal} */
-  let effectSignal;
-
-  beforeEach(() => {
-    depSignal = new StateSignal({name: 'dep', initialValue: 0});
-  });
-
-  afterEach(() => {
-    if (effectSignal && !effectSignal.isDestroyed) {
-      effectSignal.destroy();
-    }
-    depSignal.destroy();
-  });
-
-  it('should be defined', () => {
-    const runFn = jest.fn();
-    effectSignal = new EffectSignal({
-      deps: [depSignal],
-      run: runFn,
-    });
-    expect(EffectSignal).toBeDefined();
-    expect(effectSignal).toBeInstanceOf(EffectSignal);
-  });
-
-  it('should run the effect immediately if runImmediately is true', async () => {
-    const runFn = jest.fn();
-    effectSignal = new EffectSignal({
-      deps: [depSignal],
-      run: runFn,
-      runImmediately: true,
-    });
-    await delay.by(5);
-    expect(runFn).toHaveBeenCalledTimes(1);
-  });
-
-  it('should not run the effect immediately if runImmediately is false or undefined', async () => {
-    const runFn = jest.fn();
-    effectSignal = new EffectSignal({
-      deps: [depSignal],
-      run: runFn,
-    });
-    await delay.by(5);
-    expect(runFn).not.toHaveBeenCalled();
-  });
-
-  it('should run the effect when a dependency changes', async () => {
-    const runFn = jest.fn();
-    effectSignal = new EffectSignal({
-      deps: [depSignal],
-      run: runFn,
-    });
-    await delay.by(5);
-    expect(runFn).not.toHaveBeenCalled();
-    depSignal.set(1);
-    await delay.by(5);
-    expect(runFn).toHaveBeenCalledTimes(1);
-  });
-
-  it('should run the effect for each dependency change', async () => {
-    const runFn = jest.fn();
-    effectSignal = new EffectSignal({
-      deps: [depSignal],
-      run: runFn,
-    });
-    depSignal.set(1);
-    await delay.by(5);
-
-    depSignal.set(2);
-    await delay.by(5);
-
-    expect(runFn).toHaveBeenCalledTimes(2);
-  });
-
-  it('should handle multiple dependencies', async () => {
-    const depSignal2 = new StateSignal({name: 'dep2', initialValue: 'a'});
-    const runFn = jest.fn();
-    effectSignal = new EffectSignal({
-      deps: [depSignal, depSignal2],
-      run: runFn,
-    });
-    depSignal.set(1);
-    await delay.by(5);
-
-    expect(runFn).toHaveBeenCalledTimes(1);
-    depSignal2.set('b');
-    await delay.by(5);
-
-    expect(runFn).toHaveBeenCalledTimes(2);
-    depSignal2.destroy();
-  });
-
-  it('should not run the effect after destroy', async () => {
-    const runFn = jest.fn();
-    effectSignal = new EffectSignal({
-      deps: [depSignal],
-      run: runFn,
-    });
-    effectSignal.destroy();
-    depSignal.set(1);
-    await delay.by(5);
-
-    expect(runFn).not.toHaveBeenCalled();
-  });
-
-  it('should handle async run functions', async () => {
-    const runFn = jest.fn().mockResolvedValue(undefined);
-    effectSignal = new EffectSignal({
-      deps: [depSignal],
-      run: runFn,
-    });
-    depSignal.set(1);
-    await delay.by(5);
-
-    expect(runFn).toHaveBeenCalledTimes(1);
-  });
-
-  it('should not run if dependencies do not change', async () => {
-    const runFn = jest.fn();
-    effectSignal = new EffectSignal({
-      deps: [depSignal],
-      run: runFn,
-    });
-    depSignal.set(0); // Same value
-    await delay.by(5);
-
-    expect(runFn).not.toHaveBeenCalled();
-  });
-
-  describe('destroyed signal', () => {
-    it('should not run effect after destroy', async () => {
-      const runFn = jest.fn();
-      effectSignal = new EffectSignal({
-        deps: [depSignal],
-        run: runFn,
-      });
-      effectSignal.destroy();
-      depSignal.set(1);
-      await delay.by(5);
-
-      expect(runFn).not.toHaveBeenCalled();
-    });
-  });
-});

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

@@ -1,210 +0,0 @@
-import {describe, beforeEach, afterEach, it, expect, jest} from '@jest/globals';
-import {EventSignal} from '@alwatr/signal';
-import {delay} from '@alwatr/delay';
-
-describe('EventSignal', () => {
-  /** @type {EventSignal<unknown>} */
-  let signal;
-  const name = 'test-event-signal';
-
-  beforeEach(() => {
-    signal = new EventSignal({name});
-  });
-
-  afterEach(() => {
-    signal.destroy();
-  });
-
-  it('should be defined and have the correct name', () => {
-    expect(EventSignal).toBeDefined();
-    expect(signal).toBeInstanceOf(EventSignal);
-    expect(signal.name).toBe(name);
-  });
-
-  it('should dispatch an event and notify a subscriber with the correct payload', async () => {
-    const callback = jest.fn();
-    const payload = {data: 'test'};
-
-    signal.subscribe(callback);
-    signal.dispatch(payload);
-
-    expect(callback).not.toHaveBeenCalled(); // Should be async
-    await delay.nextMacrotask();
-    expect(callback).toHaveBeenCalledTimes(1);
-    expect(callback).toHaveBeenCalledWith(payload);
-  });
-
-  it('should notify multiple subscribers', async () => {
-    const callback1 = jest.fn();
-    const callback2 = jest.fn();
-    const payload = 'event-data';
-
-    signal.subscribe(callback1);
-    signal.subscribe(callback2);
-    signal.dispatch(payload);
-
-    await delay.nextMacrotask();
-    expect(callback1).toHaveBeenCalledTimes(1);
-    expect(callback1).toHaveBeenCalledWith(payload);
-    expect(callback2).toHaveBeenCalledTimes(1);
-    expect(callback2).toHaveBeenCalledWith(payload);
-  });
-
-  it('should not notify unsubscribed listeners', async () => {
-    const callback = jest.fn();
-    const subscription = signal.subscribe(callback);
-
-    subscription.unsubscribe();
-    signal.dispatch('some-data');
-
-    await delay.nextMacrotask();
-    expect(callback).not.toHaveBeenCalled();
-  });
-
-  it('should handle subscriptions with the "once" option', async () => {
-    const callback = jest.fn();
-    signal.subscribe(callback, {once: true});
-
-    signal.dispatch('first-dispatch');
-    await delay.nextMacrotask();
-    expect(callback).toHaveBeenCalledTimes(1);
-    expect(callback).toHaveBeenCalledWith('first-dispatch');
-
-    signal.dispatch('second-dispatch');
-    await delay.nextMacrotask();
-    expect(callback).toHaveBeenCalledTimes(1); // Should not be called again
-  });
-
-  it('should resolve untilNext() with the next dispatched payload', async () => {
-    const payload = {value: 42};
-    const untilNextPromise = signal.untilNext();
-
-    signal.dispatch(payload);
-
-    await expect(untilNextPromise).resolves.toBe(payload);
-  });
-
-  it('should handle dispatching without a payload (void)', async () => {
-    const voidSignal = new EventSignal({name: 'void-signal'});
-    const callback = jest.fn();
-    voidSignal.subscribe(callback);
-
-    voidSignal.dispatch();
-
-    await delay.nextMacrotask();
-    expect(callback).toHaveBeenCalledTimes(1);
-    expect(callback).toHaveBeenCalledWith(undefined);
-    voidSignal.destroy();
-  });
-
-  it('should handle dispatching with undefined payload explicitly', async () => {
-    const callback = jest.fn();
-    signal.subscribe(callback);
-
-    signal.dispatch(undefined);
-
-    await delay.nextMacrotask();
-    expect(callback).toHaveBeenCalledTimes(1);
-    expect(callback).toHaveBeenCalledWith(undefined);
-  });
-
-  it('should notify high-priority subscribers first', async () => {
-    const callOrder = [];
-    const callback1 = jest.fn(() => callOrder.push('normal'));
-    const callback2 = jest.fn(() => callOrder.push('priority'));
-
-    signal.subscribe(callback1); // Normal priority
-    signal.subscribe(callback2, {priority: true}); // High priority
-    signal.dispatch('test');
-
-    await delay.nextMacrotask();
-    expect(callOrder).toEqual(['priority', 'normal']);
-  });
-
-  it('should handle async callbacks correctly', async () => {
-    const callback = jest.fn(async () => {
-      await delay.nextMacrotask();
-      return 'done';
-    });
-
-    signal.subscribe(callback);
-    signal.dispatch('test');
-
-    // Dispatch should not be awaited, but we need to wait for the microtask queue to be processed.
-    await delay.nextMacrotask();
-    expect(callback).toHaveBeenCalledTimes(1);
-  });
-
-  it('should continue notifying other subscribers if one callback throws an error', async () => {
-    const errorCallback = jest.fn(() => {
-      throw new Error('Test error');
-    });
-    const normalCallback = jest.fn();
-
-    signal.subscribe(errorCallback);
-    signal.subscribe(normalCallback);
-    signal.dispatch('test');
-
-    await delay.nextMacrotask();
-    expect(errorCallback).toHaveBeenCalledTimes(1);
-    expect(normalCallback).toHaveBeenCalledTimes(1);
-  });
-
-  it('should resolve multiple untilNext() calls with the same dispatched payload', async () => {
-    const firstPromise = signal.untilNext();
-    const secondPromise = signal.untilNext();
-
-    const payload = 'test-payload';
-    signal.dispatch(payload);
-
-    // Both promises should resolve with the same payload
-    await expect(firstPromise).resolves.toBe(payload);
-    await expect(secondPromise).resolves.toBe(payload);
-  });
-
-  it('should multiple dispatch calls notify subscribers each time', async () => {
-    const callback = jest.fn();
-    signal.subscribe(callback);
-
-    signal.dispatch(1);
-    signal.dispatch(2);
-    signal.dispatch(3);
-
-    await delay.nextMacrotask();
-
-    expect(callback).toHaveBeenCalledTimes(3);
-    expect(callback).toHaveBeenNthCalledWith(1, 1);
-    expect(callback).toHaveBeenNthCalledWith(2, 2);
-    expect(callback).toHaveBeenNthCalledWith(3, 3);
-  });
-
-  describe('destroyed signal', () => {
-    beforeEach(() => {
-      signal.destroy();
-    });
-
-    it('should throw an error when dispatch is called on a destroyed signal', () => {
-      expect(() => signal.dispatch('test')).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: ${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: ${name})`);
-    });
-
-    it('should not notify any listeners after being destroyed', async () => {
-      const localSignal = new EventSignal({name: 'local'});
-      const callback = jest.fn();
-      localSignal.subscribe(callback);
-
-      localSignal.destroy();
-      expect(() => localSignal.dispatch()).toThrow();
-
-      await delay.nextMacrotask();
-      expect(callback).not.toHaveBeenCalled();
-    });
-  });
-});

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

@@ -1,251 +0,0 @@
-import {describe, beforeEach, afterEach, it, expect, jest} from '@jest/globals';
-import {StateSignal} from '@alwatr/signal';
-import {delay} from '@alwatr/delay';
-
-describe('StateSignal', () => {
-  /** @type {StateSignal<number>} */
-  let signal;
-  const name = 'test-state-signal';
-
-  beforeEach(() => {
-    signal = new StateSignal({name, initialValue: 0});
-  });
-
-  afterEach(() => {
-    signal.destroy();
-  });
-
-  it('should be defined and have the correct name and initial value', () => {
-    expect(StateSignal).toBeDefined();
-    expect(signal).toBeInstanceOf(StateSignal);
-    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;
-
-    signal.subscribe(callback, {receivePrevious: false});
-    signal.set(newValue);
-
-    expect(callback).not.toHaveBeenCalled(); // Should be async
-    await delay.nextMacrotask();
-    expect(callback).toHaveBeenCalledTimes(1);
-    expect(callback).toHaveBeenCalledWith(newValue);
-  });
-
-  it('should not notify subscribers if value does not change', async () => {
-    const callback = jest.fn();
-
-    signal.subscribe(callback, {receivePrevious: false});
-    signal.set(0); // Same as initial
-
-    await delay.nextMacrotask();
-    expect(callback).not.toHaveBeenCalled();
-  });
-
-  it('should notify multiple subscribers', async () => {
-    const callback1 = jest.fn();
-    const callback2 = jest.fn();
-    const newValue = 100;
-
-    signal.subscribe(callback1, {receivePrevious: false});
-    signal.subscribe(callback2, {receivePrevious: false});
-    signal.set(newValue);
-
-    await delay.nextMacrotask();
-    expect(callback1).toHaveBeenCalledTimes(1);
-    expect(callback1).toHaveBeenCalledWith(newValue);
-    expect(callback2).toHaveBeenCalledTimes(1);
-    expect(callback2).toHaveBeenCalledWith(newValue);
-  });
-
-  it('should not notify unsubscribed listeners', async () => {
-    const callback = jest.fn();
-    const subscription = signal.subscribe(callback, {receivePrevious: false});
-
-    subscription.unsubscribe();
-    signal.set(50);
-
-    await delay.nextMacrotask();
-    expect(callback).not.toHaveBeenCalled();
-  });
-
-  it('should handle subscriptions with the "once" option', async () => {
-    const callback = jest.fn();
-    signal.subscribe(callback, {once: true});
-
-    signal.set(10);
-    await delay.nextMacrotask();
-    expect(callback).toHaveBeenCalledTimes(1);
-    expect(callback).toHaveBeenCalledWith(10);
-
-    signal.set(20);
-    await delay.nextMacrotask();
-    expect(callback).toHaveBeenCalledTimes(1); // Should not be called again
-  });
-
-  it('should immediately notify new subscribers with current value by default', async () => {
-    const callback = jest.fn();
-
-    signal.set(5);
-    await delay.nextMacrotask();
-
-    signal.subscribe(callback);
-
-    await delay.nextMacrotask();
-    expect(callback).toHaveBeenCalledTimes(1);
-    expect(callback).toHaveBeenCalledWith(5);
-  });
-
-  it('should not immediately notify new subscribers if receivePrevious is false', async () => {
-    const callback = jest.fn();
-
-    signal.set(5);
-    await delay.nextMacrotask();
-
-    signal.subscribe(callback, {receivePrevious: false});
-
-    await delay.nextMacrotask();
-    expect(callback).not.toHaveBeenCalled();
-
-    signal.set(10);
-    await delay.nextMacrotask();
-    expect(callback).toHaveBeenCalledTimes(1);
-    expect(callback).toHaveBeenCalledWith(10);
-  });
-
-  it('should resolve untilNext() with the next set value', async () => {
-    const newValue = 99;
-    const untilNextPromise = signal.untilNext();
-
-    signal.set(newValue);
-
-    await expect(untilNextPromise).resolves.toBe(newValue);
-  });
-
-  it('should handle setting the same value multiple times without notifying', async () => {
-    const callback = jest.fn();
-
-    signal.subscribe(callback, {receivePrevious: false});
-    signal.set(0);
-    signal.set(0);
-    signal.set(0);
-
-    await delay.nextMacrotask();
-    expect(callback).not.toHaveBeenCalled();
-  });
-
-  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({name: 'object-signal', initialValue: value});
-    
-    signal.subscribe(callback, {receivePrevious: false});
-
-    value.a++;
-    signal.set(value);
-
-    await delay.nextMacrotask();
-    expect(callback).toHaveBeenCalledTimes(1);
-    expect(callback).toHaveBeenCalledWith(value);
-
-    signal.set(value);
-    await delay.nextMacrotask();
-    expect(callback).toHaveBeenCalledTimes(2);
-    expect(callback).toHaveBeenCalledWith(value);
-  });
-
-  it('should notify high-priority subscribers first', async () => {
-    /** @type {Array<string>} */
-    const callOrder = [];
-    const callback1 = jest.fn(() => callOrder.push('normal'));
-    const callback2 = jest.fn(() => callOrder.push('priority'));
-
-    signal.subscribe(callback1, {receivePrevious: false}); // Normal priority
-    signal.subscribe(callback2, {priority: true, receivePrevious: false}); // High priority
-    signal.set(1);
-
-    await delay.nextMacrotask();
-    expect(callOrder).toEqual(['priority', 'normal']);
-  });
-
-  it('should handle async callbacks correctly', async () => {
-    const callback = jest.fn(async () => {
-      await delay.nextMacrotask();
-      return 'done';
-    });
-
-    signal.subscribe(callback);
-    signal.set(1);
-
-    // Set should not be awaited, but we need to wait for the microtask queue to be processed.
-    await delay.nextMacrotask();
-    expect(callback).toHaveBeenCalledTimes(2);
-  });
-
-  it('should continue notifying other subscribers if one callback throws an error', async () => {
-    const errorCallback = jest.fn(() => {
-      throw new Error('Test error');
-    });
-    const normalCallback = jest.fn();
-
-    signal.subscribe(errorCallback, {receivePrevious: false});
-    signal.subscribe(normalCallback, {receivePrevious: false});
-    signal.set(5);
-    signal.set(10);
-    await delay.nextMacrotask();
-    expect(errorCallback).toHaveBeenCalledTimes(2);
-    expect(normalCallback).toHaveBeenCalledTimes(2);
-    expect(normalCallback).toHaveBeenCalledWith(10)
-  });
-
-  describe('destroyed signal', () => {
-    beforeEach(() => {
-      signal.destroy();
-    });
-
-    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: ${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: ${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: ${name})`);
-    });
-
-    it('should throw an error when accessing value on a destroyed signal', () => {
-      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({name: 'local', initialValue: 0});
-      const callback = jest.fn();
-      localSignal.subscribe(callback, {receivePrevious: false});
-
-      localSignal.destroy();
-      expect(() => localSignal.set(1)).toThrow();
-
-      await delay.nextMacrotask();
-      expect(callback).not.toHaveBeenCalled();
-    });
-  });
-});