wavesurfer.js 7.11.1 → 7.12.1

package/dist/reactive/__tests__/render-scheduler.test.js

@@ -0,0 +1,216 @@
+import { RenderScheduler } from '../render-scheduler';
+describe('RenderScheduler', () => {
+    let scheduler;
+    let renderFn;
+    beforeEach(() => {
+        scheduler = new RenderScheduler();
+        renderFn = jest.fn();
+        jest.useFakeTimers();
+    });
+    afterEach(() => {
+        scheduler.cancelRender();
+        jest.restoreAllMocks();
+        jest.useRealTimers();
+    });
+    describe('scheduleRender', () => {
+        it('should schedule a render on next frame', () => {
+            scheduler.scheduleRender(renderFn);
+            expect(renderFn).not.toHaveBeenCalled();
+            // Advance to next frame
+            jest.advanceTimersByTime(16);
+            expect(renderFn).toHaveBeenCalledTimes(1);
+        });
+        it('should batch multiple render requests into one', () => {
+            scheduler.scheduleRender(renderFn);
+            scheduler.scheduleRender(renderFn);
+            scheduler.scheduleRender(renderFn);
+            expect(renderFn).not.toHaveBeenCalled();
+            jest.advanceTimersByTime(16);
+            expect(renderFn).toHaveBeenCalledTimes(1);
+        });
+        it('should allow new render after previous completes', () => {
+            scheduler.scheduleRender(renderFn);
+            jest.advanceTimersByTime(16);
+            expect(renderFn).toHaveBeenCalledTimes(1);
+            scheduler.scheduleRender(renderFn);
+            jest.advanceTimersByTime(16);
+            expect(renderFn).toHaveBeenCalledTimes(2);
+        });
+        it('should execute high priority renders immediately', () => {
+            scheduler.scheduleRender(renderFn, 'high');
+            expect(renderFn).toHaveBeenCalledTimes(1);
+            // No additional call on next frame
+            jest.advanceTimersByTime(16);
+            expect(renderFn).toHaveBeenCalledTimes(1);
+        });
+        it('should cancel batched render when high priority render is called', () => {
+            const batchedRender = jest.fn();
+            const highPriorityRender = jest.fn();
+            scheduler.scheduleRender(batchedRender, 'normal');
+            expect(batchedRender).not.toHaveBeenCalled();
+            scheduler.scheduleRender(highPriorityRender, 'high');
+            expect(highPriorityRender).toHaveBeenCalledTimes(1);
+            // Batched render should still execute
+            jest.advanceTimersByTime(16);
+            expect(batchedRender).not.toHaveBeenCalled();
+        });
+        it('should handle low priority same as normal', () => {
+            scheduler.scheduleRender(renderFn, 'low');
+            expect(renderFn).not.toHaveBeenCalled();
+            jest.advanceTimersByTime(16);
+            expect(renderFn).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('cancelRender', () => {
+        it('should cancel pending render', () => {
+            scheduler.scheduleRender(renderFn);
+            scheduler.cancelRender();
+            jest.advanceTimersByTime(16);
+            expect(renderFn).not.toHaveBeenCalled();
+        });
+        it('should allow scheduling after cancel', () => {
+            scheduler.scheduleRender(renderFn);
+            scheduler.cancelRender();
+            scheduler.scheduleRender(renderFn);
+            jest.advanceTimersByTime(16);
+            expect(renderFn).toHaveBeenCalledTimes(1);
+        });
+        it('should be safe to call multiple times', () => {
+            scheduler.scheduleRender(renderFn);
+            scheduler.cancelRender();
+            scheduler.cancelRender();
+            scheduler.cancelRender();
+            jest.advanceTimersByTime(16);
+            expect(renderFn).not.toHaveBeenCalled();
+        });
+        it('should be safe to call when no render is pending', () => {
+            expect(() => scheduler.cancelRender()).not.toThrow();
+        });
+    });
+    describe('flushRender', () => {
+        it('should execute render immediately', () => {
+            scheduler.flushRender(renderFn);
+            expect(renderFn).toHaveBeenCalledTimes(1);
+        });
+        it('should cancel pending batched render', () => {
+            const batchedRender = jest.fn();
+            const flushRender = jest.fn();
+            scheduler.scheduleRender(batchedRender);
+            scheduler.flushRender(flushRender);
+            expect(flushRender).toHaveBeenCalledTimes(1);
+            expect(batchedRender).not.toHaveBeenCalled();
+            jest.advanceTimersByTime(16);
+            expect(batchedRender).not.toHaveBeenCalled();
+        });
+        it('should work for testing scenarios', () => {
+            let renderCount = 0;
+            const testRender = () => renderCount++;
+            // Simulate multiple state changes
+            scheduler.scheduleRender(testRender);
+            scheduler.scheduleRender(testRender);
+            scheduler.scheduleRender(testRender);
+            // Force immediate render for assertion
+            scheduler.flushRender(testRender);
+            expect(renderCount).toBe(1);
+            // No additional render on next frame
+            jest.advanceTimersByTime(16);
+            expect(renderCount).toBe(1);
+        });
+    });
+    describe('isPending', () => {
+        it('should return false initially', () => {
+            expect(scheduler.isPending()).toBe(false);
+        });
+        it('should return true when render is scheduled', () => {
+            scheduler.scheduleRender(renderFn);
+            expect(scheduler.isPending()).toBe(true);
+        });
+        it('should return false after render executes', () => {
+            scheduler.scheduleRender(renderFn);
+            jest.advanceTimersByTime(16);
+            expect(scheduler.isPending()).toBe(false);
+        });
+        it('should return false after cancel', () => {
+            scheduler.scheduleRender(renderFn);
+            scheduler.cancelRender();
+            expect(scheduler.isPending()).toBe(false);
+        });
+        it('should return false after flush', () => {
+            scheduler.scheduleRender(renderFn);
+            scheduler.flushRender(renderFn);
+            expect(scheduler.isPending()).toBe(false);
+        });
+        it('should return false for high priority renders', () => {
+            scheduler.scheduleRender(renderFn, 'high');
+            expect(scheduler.isPending()).toBe(false);
+        });
+    });
+    describe('real-world scenarios', () => {
+        it('should batch rapid state changes', () => {
+            let renderCount = 0;
+            const render = () => renderCount++;
+            // Simulate rapid state changes (e.g., during animation)
+            for (let i = 0; i < 100; i++) {
+                scheduler.scheduleRender(render);
+            }
+            expect(renderCount).toBe(0);
+            jest.advanceTimersByTime(16);
+            expect(renderCount).toBe(1);
+        });
+        it('should handle mixed priority renders', () => {
+            const normalRenders = [];
+            const highRenders = [];
+            scheduler.scheduleRender(() => normalRenders.push(1), 'normal');
+            scheduler.scheduleRender(() => highRenders.push(1), 'high');
+            scheduler.scheduleRender(() => normalRenders.push(2), 'normal');
+            scheduler.scheduleRender(() => highRenders.push(2), 'high');
+            expect(highRenders).toEqual([1, 2]);
+            expect(normalRenders).toEqual([]);
+            jest.advanceTimersByTime(16);
+            expect(normalRenders).toEqual([]);
+        });
+        it('should handle errors in render function', () => {
+            const errorRender = () => {
+                throw new Error('Render error');
+            };
+            const successRender = jest.fn();
+            scheduler.scheduleRender(errorRender);
+            expect(() => {
+                jest.advanceTimersByTime(16);
+            }).toThrow('Render error');
+            // After error, scheduler is no longer pending
+            expect(scheduler.isPending()).toBe(false);
+            // Should be able to schedule after error
+            scheduler.scheduleRender(successRender);
+            expect(scheduler.isPending()).toBe(true);
+            jest.advanceTimersByTime(16);
+            expect(successRender).toHaveBeenCalledTimes(1);
+        });
+        it('should support cleanup on unmount', () => {
+            scheduler.scheduleRender(renderFn);
+            expect(scheduler.isPending()).toBe(true);
+            // Simulate component unmount
+            scheduler.cancelRender();
+            expect(scheduler.isPending()).toBe(false);
+            jest.advanceTimersByTime(100);
+            expect(renderFn).not.toHaveBeenCalled();
+        });
+    });
+    describe('performance', () => {
+        it('should handle thousands of schedule calls efficiently', () => {
+            const start = performance.now();
+            for (let i = 0; i < 10000; i++) {
+                scheduler.scheduleRender(renderFn);
+            }
+            const duration = performance.now() - start;
+            expect(duration).toBeLessThan(10); // Should be near-instant
+        });
+        it('should not leak memory with repeated scheduling', () => {
+            for (let i = 0; i < 1000; i++) {
+                scheduler.scheduleRender(renderFn);
+                scheduler.cancelRender();
+            }
+            expect(scheduler.isPending()).toBe(false);
+        });
+    });
+});

package/dist/reactive/__tests__/scroll-stream.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/reactive/__tests__/scroll-stream.test.js

@@ -0,0 +1,191 @@
+import { createScrollStream, createScrollStreamWithAction, calculateScrollPercentages, calculateScrollBounds, } from '../scroll-stream';
+describe('scroll-stream', () => {
+    describe('calculateScrollPercentages', () => {
+        it('should calculate percentages for basic scroll', () => {
+            const data = {
+                scrollLeft: 100,
+                scrollWidth: 1000,
+                clientWidth: 200,
+            };
+            const result = calculateScrollPercentages(data);
+            expect(result.startX).toBe(0.1);
+            expect(result.endX).toBe(0.3);
+        });
+        it('should handle zero scroll width', () => {
+            const data = {
+                scrollLeft: 0,
+                scrollWidth: 0,
+                clientWidth: 200,
+            };
+            const result = calculateScrollPercentages(data);
+            expect(result.startX).toBe(0);
+            expect(result.endX).toBe(1);
+        });
+        it('should handle scroll at start', () => {
+            const data = {
+                scrollLeft: 0,
+                scrollWidth: 1000,
+                clientWidth: 200,
+            };
+            const result = calculateScrollPercentages(data);
+            expect(result.startX).toBe(0);
+            expect(result.endX).toBe(0.2);
+        });
+        it('should handle scroll at end', () => {
+            const data = {
+                scrollLeft: 800,
+                scrollWidth: 1000,
+                clientWidth: 200,
+            };
+            const result = calculateScrollPercentages(data);
+            expect(result.startX).toBe(0.8);
+            expect(result.endX).toBe(1);
+        });
+        it('should clamp values to 0-1 range', () => {
+            const data = {
+                scrollLeft: -10,
+                scrollWidth: 1000,
+                clientWidth: 200,
+            };
+            const result = calculateScrollPercentages(data);
+            expect(result.startX).toBeGreaterThanOrEqual(0);
+            expect(result.endX).toBeLessThanOrEqual(1);
+        });
+    });
+    describe('calculateScrollBounds', () => {
+        it('should calculate scroll bounds', () => {
+            const data = {
+                scrollLeft: 100,
+                scrollWidth: 1000,
+                clientWidth: 200,
+            };
+            const result = calculateScrollBounds(data);
+            expect(result.left).toBe(100);
+            expect(result.right).toBe(300);
+        });
+        it('should handle zero scroll', () => {
+            const data = {
+                scrollLeft: 0,
+                scrollWidth: 1000,
+                clientWidth: 200,
+            };
+            const result = calculateScrollBounds(data);
+            expect(result.left).toBe(0);
+            expect(result.right).toBe(200);
+        });
+    });
+    describe('createScrollStream', () => {
+        let element;
+        beforeEach(() => {
+            element = document.createElement('div');
+            document.body.appendChild(element);
+            // Mock scroll properties
+            Object.defineProperties(element, {
+                scrollLeft: { value: 100, writable: true, configurable: true },
+                scrollWidth: { value: 1000, writable: true, configurable: true },
+                clientWidth: { value: 200, writable: true, configurable: true },
+            });
+        });
+        afterEach(() => {
+            document.body.removeChild(element);
+        });
+        it('should create a scroll stream', () => {
+            const stream = createScrollStream(element);
+            expect(stream.scrollData).toBeDefined();
+            expect(stream.percentages).toBeDefined();
+            expect(stream.bounds).toBeDefined();
+            expect(stream.cleanup).toBeDefined();
+            stream.cleanup();
+        });
+        it('should initialize with current scroll values', () => {
+            const stream = createScrollStream(element);
+            expect(stream.scrollData.value).toEqual({
+                scrollLeft: 100,
+                scrollWidth: 1000,
+                clientWidth: 200,
+            });
+            stream.cleanup();
+        });
+        it('should compute percentages', () => {
+            const stream = createScrollStream(element);
+            expect(stream.percentages.value.startX).toBe(0.1);
+            expect(stream.percentages.value.endX).toBe(0.3);
+            stream.cleanup();
+        });
+        it('should compute bounds', () => {
+            const stream = createScrollStream(element);
+            expect(stream.bounds.value.left).toBe(100);
+            expect(stream.bounds.value.right).toBe(300);
+            stream.cleanup();
+        });
+        it('should update on scroll event', () => {
+            const stream = createScrollStream(element);
+            // Update scroll position
+            Object.defineProperty(element, 'scrollLeft', {
+                value: 200,
+                writable: true,
+                configurable: true,
+            });
+            // Dispatch scroll event
+            element.dispatchEvent(new Event('scroll'));
+            expect(stream.scrollData.value.scrollLeft).toBe(200);
+            expect(stream.percentages.value.startX).toBe(0.2);
+            expect(stream.percentages.value.endX).toBe(0.4);
+            stream.cleanup();
+        });
+        it('should cleanup event listeners', () => {
+            const stream = createScrollStream(element);
+            const addSpy = jest.spyOn(element, 'addEventListener');
+            const removeSpy = jest.spyOn(element, 'removeEventListener');
+            stream.cleanup();
+            expect(removeSpy).toHaveBeenCalledWith('scroll', expect.any(Function));
+            addSpy.mockRestore();
+            removeSpy.mockRestore();
+        });
+    });
+    describe('createScrollStreamWithAction', () => {
+        let element;
+        beforeEach(() => {
+            element = document.createElement('div');
+            document.body.appendChild(element);
+            Object.defineProperties(element, {
+                scrollLeft: { value: 100, writable: true, configurable: true },
+                scrollWidth: { value: 1000, writable: true, configurable: true },
+                clientWidth: { value: 200, writable: true, configurable: true },
+            });
+        });
+        afterEach(() => {
+            document.body.removeChild(element);
+        });
+        it('should call action on scroll', () => {
+            const onScrollChange = jest.fn();
+            const stream = createScrollStreamWithAction(element, onScrollChange);
+            // Initial call from effect
+            expect(onScrollChange).toHaveBeenCalledWith(100);
+            // Update scroll
+            Object.defineProperty(element, 'scrollLeft', {
+                value: 200,
+                writable: true,
+                configurable: true,
+            });
+            element.dispatchEvent(new Event('scroll'));
+            expect(onScrollChange).toHaveBeenCalledWith(200);
+            stream.cleanup();
+        });
+        it('should cleanup action effect', () => {
+            const onScrollChange = jest.fn();
+            const stream = createScrollStreamWithAction(element, onScrollChange);
+            const callCount = onScrollChange.mock.calls.length;
+            stream.cleanup();
+            // Update scroll after cleanup
+            Object.defineProperty(element, 'scrollLeft', {
+                value: 300,
+                writable: true,
+                configurable: true,
+            });
+            element.dispatchEvent(new Event('scroll'));
+            // Should not be called again
+            expect(onScrollChange).toHaveBeenCalledTimes(callCount);
+        });
+    });
+});

package/dist/reactive/__tests__/state-event-emitter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/reactive/__tests__/state-event-emitter.test.js

@@ -0,0 +1,234 @@
+import { setupStateEventEmission, setupSignalEventEmission, setupDebouncedEventEmission, setupConditionalEventEmission, } from '../state-event-emitter';
+import { createWaveSurferState } from '../../state/wavesurfer-state';
+import { signal } from '../store';
+describe('state-event-emitter', () => {
+    let emitter;
+    beforeEach(() => {
+        emitter = { emit: jest.fn() };
+        jest.useFakeTimers();
+    });
+    afterEach(() => {
+        jest.useRealTimers();
+    });
+    describe('setupStateEventEmission', () => {
+        it('should emit play event when isPlaying becomes true', () => {
+            const { state, actions } = createWaveSurferState();
+            const cleanup = setupStateEventEmission(state, emitter);
+            // Initial state triggers pause (isPlaying starts false)
+            expect(emitter.emit).toHaveBeenCalledWith('pause');
+            emitter.emit.mockClear();
+            actions.setPlaying(true);
+            expect(emitter.emit).toHaveBeenCalledWith('play');
+            cleanup();
+        });
+        it('should emit pause event when isPlaying becomes false', () => {
+            const { state, actions } = createWaveSurferState();
+            actions.setPlaying(true);
+            emitter.emit.mockClear();
+            const cleanup = setupStateEventEmission(state, emitter);
+            actions.setPlaying(false);
+            expect(emitter.emit).toHaveBeenCalledWith('pause');
+            cleanup();
+        });
+        it('should emit timeupdate when currentTime changes', () => {
+            const { state, actions } = createWaveSurferState();
+            const cleanup = setupStateEventEmission(state, emitter);
+            emitter.emit.mockClear();
+            actions.setCurrentTime(42);
+            expect(emitter.emit).toHaveBeenCalledWith('timeupdate', 42);
+            cleanup();
+        });
+        it('should emit audioprocess when playing and time changes', () => {
+            const { state, actions } = createWaveSurferState();
+            actions.setPlaying(true);
+            const cleanup = setupStateEventEmission(state, emitter);
+            emitter.emit.mockClear();
+            actions.setCurrentTime(10);
+            expect(emitter.emit).toHaveBeenCalledWith('timeupdate', 10);
+            expect(emitter.emit).toHaveBeenCalledWith('audioprocess', 10);
+            cleanup();
+        });
+        it('should not emit audioprocess when paused', () => {
+            const { state, actions } = createWaveSurferState();
+            actions.setPlaying(false);
+            const cleanup = setupStateEventEmission(state, emitter);
+            emitter.emit.mockClear();
+            actions.setCurrentTime(10);
+            expect(emitter.emit).toHaveBeenCalledWith('timeupdate', 10);
+            expect(emitter.emit).not.toHaveBeenCalledWith('audioprocess', expect.anything());
+            cleanup();
+        });
+        it('should emit seeking event when isSeeking becomes true', () => {
+            const { state, actions } = createWaveSurferState();
+            actions.setCurrentTime(50);
+            const cleanup = setupStateEventEmission(state, emitter);
+            emitter.emit.mockClear();
+            actions.setSeeking(true);
+            expect(emitter.emit).toHaveBeenCalledWith('seeking', 50);
+            cleanup();
+        });
+        it('should emit ready event when state becomes ready', () => {
+            const { state, actions } = createWaveSurferState();
+            const cleanup = setupStateEventEmission(state, emitter);
+            emitter.emit.mockClear();
+            // Set duration and audio buffer to make state ready
+            actions.setDuration(100);
+            // Create a mock AudioBuffer since jsdom doesn't support it
+            const mockAudioBuffer = {
+                duration: 100,
+                length: 44100,
+                sampleRate: 44100,
+                numberOfChannels: 2,
+            };
+            actions.setAudioBuffer(mockAudioBuffer);
+            expect(emitter.emit).toHaveBeenCalledWith('ready', 100);
+            cleanup();
+        });
+        it('should only emit ready event once', () => {
+            const { state, actions } = createWaveSurferState();
+            const cleanup = setupStateEventEmission(state, emitter);
+            // Make ready
+            actions.setDuration(100);
+            const mockAudioBuffer = {
+                duration: 100,
+                length: 44100,
+                sampleRate: 44100,
+                numberOfChannels: 2,
+            };
+            actions.setAudioBuffer(mockAudioBuffer);
+            const readyCallCount = emitter.emit.mock.calls.filter((call) => call[0] === 'ready').length;
+            emitter.emit.mockClear();
+            // Change duration again
+            actions.setDuration(150);
+            // Should not emit ready again
+            expect(emitter.emit).not.toHaveBeenCalledWith('ready', expect.anything());
+            expect(readyCallCount).toBe(1);
+            cleanup();
+        });
+        it('should emit zoom event when zoom changes', () => {
+            const { state, actions } = createWaveSurferState();
+            const cleanup = setupStateEventEmission(state, emitter);
+            emitter.emit.mockClear();
+            actions.setZoom(2);
+            expect(emitter.emit).toHaveBeenCalledWith('zoom', 2);
+            cleanup();
+        });
+        it('should not emit zoom event for zoom=0', () => {
+            const { state, actions } = createWaveSurferState();
+            const cleanup = setupStateEventEmission(state, emitter);
+            emitter.emit.mockClear();
+            actions.setZoom(0);
+            expect(emitter.emit).not.toHaveBeenCalledWith('zoom', 0);
+            cleanup();
+        });
+        it('should cleanup all subscriptions', () => {
+            const { state, actions } = createWaveSurferState();
+            const cleanup = setupStateEventEmission(state, emitter);
+            cleanup();
+            emitter.emit.mockClear();
+            // These should not trigger events after cleanup
+            actions.setPlaying(true);
+            actions.setCurrentTime(42);
+            actions.setZoom(2);
+            expect(emitter.emit).not.toHaveBeenCalled();
+        });
+    });
+    describe('setupSignalEventEmission', () => {
+        it('should emit custom events from signal changes', () => {
+            const volumeSignal = signal(1);
+            const cleanup = setupSignalEventEmission(volumeSignal, emitter, (vol) => ['volume', vol]);
+            // Initial emission
+            expect(emitter.emit).toHaveBeenCalledWith('volume', 1);
+            emitter.emit.mockClear();
+            volumeSignal.set(0.5);
+            expect(emitter.emit).toHaveBeenCalledWith('volume', 0.5);
+            cleanup();
+        });
+        it('should cleanup subscription', () => {
+            const testSignal = signal(0);
+            const cleanup = setupSignalEventEmission(testSignal, emitter, (val) => ['test', val]);
+            cleanup();
+            emitter.emit.mockClear();
+            testSignal.set(1);
+            expect(emitter.emit).not.toHaveBeenCalled();
+        });
+    });
+    describe('setupDebouncedEventEmission', () => {
+        it('should debounce event emission', () => {
+            const scrollSignal = signal(0);
+            const cleanup = setupDebouncedEventEmission(scrollSignal, emitter, (pos) => ['scroll', pos], 100);
+            // Initial emission should be debounced
+            emitter.emit.mockClear();
+            scrollSignal.set(10);
+            expect(emitter.emit).not.toHaveBeenCalled();
+            scrollSignal.set(20);
+            expect(emitter.emit).not.toHaveBeenCalled();
+            scrollSignal.set(30);
+            expect(emitter.emit).not.toHaveBeenCalled();
+            // Fast forward time
+            jest.advanceTimersByTime(100);
+            // Should emit only the last value
+            expect(emitter.emit).toHaveBeenCalledTimes(1);
+            expect(emitter.emit).toHaveBeenCalledWith('scroll', 30);
+            cleanup();
+        });
+        it('should restart debounce timer on each change', () => {
+            const testSignal = signal(0);
+            const cleanup = setupDebouncedEventEmission(testSignal, emitter, (val) => ['test', val], 100);
+            emitter.emit.mockClear();
+            testSignal.set(1);
+            jest.advanceTimersByTime(50);
+            testSignal.set(2);
+            jest.advanceTimersByTime(50);
+            // Should not have emitted yet (timer restarted)
+            expect(emitter.emit).not.toHaveBeenCalled();
+            jest.advanceTimersByTime(50);
+            // Now should emit
+            expect(emitter.emit).toHaveBeenCalledWith('test', 2);
+            cleanup();
+        });
+        it('should cleanup pending timeout', () => {
+            const testSignal = signal(0);
+            const cleanup = setupDebouncedEventEmission(testSignal, emitter, (val) => ['test', val], 100);
+            emitter.emit.mockClear();
+            testSignal.set(1);
+            cleanup();
+            jest.advanceTimersByTime(100);
+            // Should not emit after cleanup
+            expect(emitter.emit).not.toHaveBeenCalled();
+        });
+    });
+    describe('setupConditionalEventEmission', () => {
+        it('should only emit when condition is true', () => {
+            const stateSignal = signal(0);
+            const cleanup = setupConditionalEventEmission(stateSignal, emitter, (val) => val > 5, (val) => ['threshold', val]);
+            emitter.emit.mockClear();
+            stateSignal.set(3);
+            expect(emitter.emit).not.toHaveBeenCalled();
+            stateSignal.set(7);
+            expect(emitter.emit).toHaveBeenCalledWith('threshold', 7);
+            cleanup();
+        });
+        it('should re-evaluate condition on each change', () => {
+            const testSignal = signal(false);
+            const cleanup = setupConditionalEventEmission(testSignal, emitter, (val) => val === true, () => ['activated']);
+            emitter.emit.mockClear();
+            testSignal.set(false);
+            expect(emitter.emit).not.toHaveBeenCalled();
+            testSignal.set(true);
+            expect(emitter.emit).toHaveBeenCalledWith('activated');
+            emitter.emit.mockClear();
+            testSignal.set(false);
+            expect(emitter.emit).not.toHaveBeenCalled();
+            cleanup();
+        });
+        it('should cleanup subscription', () => {
+            const testSignal = signal(0);
+            const cleanup = setupConditionalEventEmission(testSignal, emitter, (val) => val > 0, (val) => ['test', val]);
+            cleanup();
+            emitter.emit.mockClear();
+            testSignal.set(10);
+            expect(emitter.emit).not.toHaveBeenCalled();
+        });
+    });
+});

package/dist/reactive/__tests__/store.test.d.ts

@@ -0,0 +1 @@
+export {};