@storve/core 1.0.1 → 1.0.3

package/tests/signals/signal.test.ts

@@ -1,348 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { createStore } from '../../src/store';
-import { signal } from '../../src/signals/createSignal';
-import type { Store } from '../../src/types';
-
-describe('signal() factory', () => {
-    interface State {
-        count: number;
-        name: string;
-        active: boolean;
-        meta: { id: string };
-        items: number[];
-    }
-
-    let store: Store<State>;
-    let unsubscribes: (() => void)[] = [];
-
-    beforeEach(() => {
-        store = createStore<State>({
-            count: 0,
-            name: 'initial',
-            active: false,
-            meta: { id: '1' },
-            items: [1, 2, 3],
-        });
-        unsubscribes = [];
-    });
-
-    afterEach(() => {
-        unsubscribes.forEach((unsub) => unsub());
-    });
-
-    describe('get()', () => {
-        it('returns the correct initial value for the specified key', () => {
-            const sig = signal(store, 'count');
-            expect(sig.get()).toBe(0);
-        });
-
-        it('returns the updated value after store.setState changes that key', () => {
-            const sig = signal(store, 'count');
-            store.setState({ count: 1 });
-            expect(sig.get()).toBe(1);
-        });
-
-        it('reflects store changes immediately — no stale reads', () => {
-            const sig = signal(store, 'count');
-            store.setState({ count: 5 });
-            expect(sig.get()).toBe(5);
-            store.setState({ count: 10 });
-            expect(sig.get()).toBe(10);
-        });
-
-        it('works correctly for string keys', () => {
-            const sig = signal(store, 'name');
-            expect(sig.get()).toBe('initial');
-            store.setState({ name: 'updated' });
-            expect(sig.get()).toBe('updated');
-        });
-
-        it('works correctly for boolean keys', () => {
-            const sig = signal(store, 'active');
-            expect(sig.get()).toBe(false);
-            store.setState({ active: true });
-            expect(sig.get()).toBe(true);
-        });
-
-        it('works correctly for object keys (returns reference)', () => {
-            const sig = signal(store, 'meta');
-            const initialMeta = store.getState().meta;
-            expect(sig.get()).toBe(initialMeta);
-            expect(sig.get()).toEqual({ id: '1' });
-        });
-
-        it('works correctly for array keys (returns reference)', () => {
-            const sig = signal(store, 'items');
-            const initialItems = store.getState().items;
-            expect(sig.get()).toBe(initialItems);
-            expect(sig.get()).toEqual([1, 2, 3]);
-        });
-    });
-
-    describe('set() — standard signal', () => {
-        it('updates the store state correctly', () => {
-            const sig = signal(store, 'count');
-            sig.set(42);
-            expect(store.getState().count).toBe(42);
-        });
-
-        it('set(fn) updater form receives current value and updates correctly', () => {
-            const sig = signal(store, 'count');
-            sig.set((prev) => prev + 1);
-            expect(store.getState().count).toBe(1);
-        });
-
-        it('set() triggers store subscribers', () => {
-            const sig = signal(store, 'count');
-            const listener = vi.fn();
-            unsubscribes.push(store.subscribe(listener));
-            sig.set(100);
-            expect(listener).toHaveBeenCalled();
-        });
-
-        it('set() triggers signal\'s own subscribers', () => {
-            const sig = signal(store, 'count');
-            const listener = vi.fn();
-            unsubscribes.push(sig.subscribe(listener));
-            sig.set(100);
-            expect(listener).toHaveBeenCalledWith(100);
-        });
-
-        it('set(sameValue) with Object.is equal value still updates store (store behaviour)', () => {
-            const sig = signal(store, 'count');
-            const listener = vi.fn();
-            unsubscribes.push(store.subscribe(listener));
-            sig.set(0); // initial is 0
-            expect(listener).toHaveBeenCalled();
-        });
-    });
-
-    describe('set() — derived signal', () => {
-        it('throws with EXACT message when calling set() on a derived signal', () => {
-            const derivedSig = signal(store, 'count', (v) => v * 2);
-            expect(() => derivedSig.set(10 as unknown as number)).toThrow(
-                'Storve: cannot call set() on a derived signal. Derived signals are read-only.'
-            );
-        });
-    });
-
-    describe('subscribe() — notification correctness', () => {
-        it('calls listener with the new value when signal\'s key changes via store.setState', () => {
-            const sig = signal(store, 'count');
-            const listener = vi.fn();
-            unsubscribes.push(sig.subscribe(listener));
-            store.setState({ count: 1 });
-            expect(listener).toHaveBeenCalledWith(1);
-        });
-
-        it('calls listener with the new value when signal\'s key changes via signal.set()', () => {
-            const sig = signal(store, 'count');
-            const listener = vi.fn();
-            unsubscribes.push(sig.subscribe(listener));
-            sig.set(1);
-            expect(listener).toHaveBeenCalledWith(1);
-        });
-
-        it('does NOT call listener when an unrelated key changes', () => {
-            const sig = signal(store, 'count');
-            const listener = vi.fn();
-            unsubscribes.push(sig.subscribe(listener));
-            store.setState({ name: 'updated' });
-            expect(listener).not.toHaveBeenCalled();
-        });
-
-        it('does NOT call listener when setState sets the same primitive value (Object.is equality)', () => {
-            const sig = signal(store, 'count');
-            const listener = vi.fn();
-            unsubscribes.push(sig.subscribe(listener));
-            store.setState({ count: 0 }); // already 0
-            expect(listener).not.toHaveBeenCalled();
-        });
-
-        it('DOES call listener when value changes from 0 to 1', () => {
-            const sig = signal(store, 'count');
-            const listener = vi.fn();
-            unsubscribes.push(sig.subscribe(listener));
-            store.setState({ count: 1 });
-            expect(listener).toHaveBeenCalledWith(1);
-        });
-
-        it('DOES call listener when value changes from null to an object', () => {
-            interface NullableState { data: { a: number } | null }
-            const nStore = createStore<NullableState>({ data: null });
-            const sig = signal(nStore, 'data');
-            const listener = vi.fn();
-            unsubscribes.push(sig.subscribe(listener));
-            nStore.setState({ data: { a: 1 } });
-            expect(listener).toHaveBeenCalledWith({ a: 1 });
-        });
-
-        it('DOES call listener when array reference changes (even if contents look same)', () => {
-            const sig = signal(store, 'items');
-            const listener = vi.fn();
-            unsubscribes.push(sig.subscribe(listener));
-            store.setState({ items: [1, 2, 3] }); // new reference
-            expect(listener).toHaveBeenCalled();
-        });
-
-        it('calls listener exactly once per relevant setState — never multiple times', () => {
-            const sig = signal(store, 'count');
-            const listener = vi.fn();
-            unsubscribes.push(sig.subscribe(listener));
-            store.setState({ count: 1 });
-            expect(listener).toHaveBeenCalledTimes(1);
-        });
-    });
-
-    describe('subscribe() — multiple subscribers', () => {
-        it('two subscribers on same signal both receive updates', () => {
-            const sig = signal(store, 'count');
-            const l1 = vi.fn();
-            const l2 = vi.fn();
-            unsubscribes.push(sig.subscribe(l1));
-            unsubscribes.push(sig.subscribe(l2));
-            sig.set(1);
-            expect(l1).toHaveBeenCalledWith(1);
-            expect(l2).toHaveBeenCalledWith(1);
-        });
-
-        it('removing one subscriber does not affect the other', () => {
-            const sig = signal(store, 'count');
-            const l1 = vi.fn();
-            const l2 = vi.fn();
-            const unsub1 = sig.subscribe(l1);
-            unsubscribes.push(sig.subscribe(l2));
-            unsub1();
-            sig.set(1);
-            expect(l1).not.toHaveBeenCalled();
-            expect(l2).toHaveBeenCalledWith(1);
-        });
-
-        it('three subscribers all fire independently', () => {
-            const sig = signal(store, 'count');
-            const l1 = vi.fn();
-            const l2 = vi.fn();
-            const l3 = vi.fn();
-            unsubscribes.push(sig.subscribe(l1));
-            unsubscribes.push(sig.subscribe(l2));
-            unsubscribes.push(sig.subscribe(l3));
-            sig.set(5);
-            expect(l1).toHaveBeenCalledWith(5);
-            expect(l2).toHaveBeenCalledWith(5);
-            expect(l3).toHaveBeenCalledWith(5);
-        });
-    });
-
-    describe('subscribe() — unsubscribe', () => {
-        it('returned unsubscribe function stops future notifications', () => {
-            const sig = signal(store, 'count');
-            const listener = vi.fn();
-            const unsub = sig.subscribe(listener);
-            unsub();
-            sig.set(1);
-            expect(listener).not.toHaveBeenCalled();
-        });
-
-        it('after unsubscribe, store changes do not call the listener', () => {
-            const sig = signal(store, 'count');
-            const listener = vi.fn();
-            const unsub = sig.subscribe(listener);
-            unsub();
-            store.setState({ count: 1 });
-            expect(listener).not.toHaveBeenCalled();
-        });
-
-        it('unsubscribing twice does not throw', () => {
-            const sig = signal(store, 'count');
-            const unsub = sig.subscribe(() => {});
-            unsub();
-            expect(() => unsub()).not.toThrow();
-        });
-
-        it('unsubscribing cleans up the underlying store subscription', () => {
-            // This is hard to test directly without exposing store internals,
-            // but we rely on the fact that signal uses store.subscribe.
-            const sig = signal(store, 'count');
-            const listener = vi.fn();
-            const unsub = sig.subscribe(listener);
-            unsub();
-            store.setState({ count: 1 });
-            expect(listener).not.toHaveBeenCalled();
-        });
-    });
-
-    describe('subscribe() — listener arguments', () => {
-        it('listener receives the new value, not the old value', () => {
-            const sig = signal(store, 'count');
-            const listener = vi.fn();
-            unsubscribes.push(sig.subscribe(listener));
-            sig.set(100);
-            expect(listener).toHaveBeenCalledWith(100);
-        });
-
-        it('listener receives the raw value, not the store state object', () => {
-            const sig = signal(store, 'count');
-            const listener = vi.fn();
-            unsubscribes.push(sig.subscribe(listener));
-            sig.set(42);
-            expect(listener).toHaveBeenCalledWith(42);
-            expect(listener).not.toHaveBeenCalledWith(expect.objectContaining({ count: 42 }));
-        });
-    });
-
-    describe('_derived flag', () => {
-        it('is false on standard signal (no transform)', () => {
-            const sig = signal(store, 'count');
-            expect(sig._derived).toBe(false);
-        });
-
-        it('is true on derived signal (with transform)', () => {
-            const sig = signal(store, 'count', (v) => v * 2);
-            expect(sig._derived).toBe(true);
-        });
-
-        it('_derived cannot be set from outside (readonly)', () => {
-            const sig = signal(store, 'count');
-            // @ts-expect-error - _derived is readonly
-            sig._derived = true;
-            // Assignment silently fails — value remains false
-            expect(sig._derived).toBe(false);
-        });
-    });
-
-    describe('store integrity', () => {
-        it('signal.set() does not break other store subscribers', () => {
-            const sig = signal(store, 'count');
-            const listener = vi.fn();
-            unsubscribes.push(store.subscribe(listener));
-            sig.set(1);
-            expect(listener).toHaveBeenCalled();
-            expect(store.getState().count).toBe(1);
-        });
-
-        it('multiple signals on same store do not interfere with each other', () => {
-            const sigA = signal(store, 'count');
-            const sigB = signal(store, 'name');
-            sigA.set(10);
-            sigB.set('hello');
-            expect(store.getState().count).toBe(10);
-            expect(store.getState().name).toBe('hello');
-        });
-
-        it('signal on key A and signal on key B are fully independent', () => {
-            const sigA = signal(store, 'count');
-            const sigB = signal(store, 'name');
-            const lA = vi.fn();
-            const lB = vi.fn();
-            unsubscribes.push(sigA.subscribe(lA));
-            unsubscribes.push(sigB.subscribe(lB));
-            
-            sigA.set(1);
-            expect(lA).toHaveBeenCalled();
-            expect(lB).not.toHaveBeenCalled();
-            
-            sigB.set('hi');
-            expect(lB).toHaveBeenCalled();
-        });
-    });
-});

package/tests/signals/useSignal.test.tsx

@@ -1,275 +0,0 @@
-/**
- * @vitest-environment jsdom
- */
-import React from 'react';
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { render, screen, cleanup, act } from '@testing-library/react';
-import { createStore } from '../../src/store';
-import { signal } from '../../src/signals/createSignal';
-import { useSignal } from '../../src/signals/useSignal';
-import type { Signal } from '../../src/signals/index';
-
-function makeCounter() {
-    let count = 0;
-    return {
-        increment: () => count++,
-        get: () => count,
-        reset: () => { count = 0; }
-    };
-}
-
-function makeTestComponent<T>(sig: Signal<T>, counter: ReturnType<typeof makeCounter>) {
-    return function TestComponent() {
-        counter.increment();
-        const value = useSignal(sig);
-        return <div data-testid="value">{String(value)}</div>;
-    };
-}
-
-describe('useSignal() hook', () => {
-    let store: ReturnType<typeof createStore<{ count: number; name: string; active: boolean }>>;
-    let counter: ReturnType<typeof makeCounter>;
-
-    beforeEach(() => {
-        store = createStore({ count: 0, name: 'alice', active: false as boolean });
-        counter = makeCounter();
-        counter.reset();
-    });
-
-    afterEach(() => {
-        cleanup();
-    });
-
-    describe('Basic rendering', () => {
-        it('renders the correct initial value from signal', () => {
-            const sig = signal(store, 'count');
-            const TestComp = makeTestComponent(sig, counter);
-            render(<TestComp />);
-            expect(screen.getByTestId('value').textContent).toBe('0');
-        });
-
-        it('renders the correct initial value for a string signal', () => {
-            const sig = signal(store, 'name');
-            const TestComp = makeTestComponent(sig, counter);
-            render(<TestComp />);
-            expect(screen.getByTestId('value').textContent).toBe('alice');
-        });
-
-        it('renders the correct initial value for a boolean signal', () => {
-            const sig = signal(store, 'active');
-            const TestComp = makeTestComponent(sig, counter);
-            render(<TestComp />);
-            expect(screen.getByTestId('value').textContent).toBe('false');
-        });
-
-        it('renders the correct initial value for a derived signal', () => {
-            const sig = signal(store, 'count', (v) => v * 2);
-            const TestComp = makeTestComponent(sig, counter);
-            render(<TestComp />);
-            expect(screen.getByTestId('value').textContent).toBe('0');
-        });
-
-        it('updates the rendered value when signal\'s store key changes via store.setState', () => {
-            const sig = signal(store, 'count');
-            const TestComp = makeTestComponent(sig, counter);
-            render(<TestComp />);
-            act(() => { store.setState({ count: 1 }); });
-            expect(screen.getByTestId('value').textContent).toBe('1');
-        });
-
-        it('updates the rendered value when signal\'s store key changes via signal.set()', () => {
-            const sig = signal(store, 'count');
-            const TestComp = makeTestComponent(sig, counter);
-            render(<TestComp />);
-            act(() => { sig.set(42); });
-            expect(screen.getByTestId('value').textContent).toBe('42');
-        });
-
-        it('updates the rendered value for a derived signal when base key changes', () => {
-            const sig = signal(store, 'count', (v) => v + 10);
-            const TestComp = makeTestComponent(sig, counter);
-            render(<TestComp />);
-            act(() => { store.setState({ count: 5 }); });
-            expect(screen.getByTestId('value').textContent).toBe('15');
-        });
-    });
-
-    describe('Re-render correctness', () => {
-        it('component re-renders exactly once on initial mount', () => {
-            const sig = signal(store, 'count');
-            const TestComp = makeTestComponent(sig, counter);
-            render(<TestComp />);
-            expect(counter.get()).toBe(1);
-        });
-
-        it('component re-renders exactly once when signal value changes', () => {
-            const sig = signal(store, 'count');
-            const TestComp = makeTestComponent(sig, counter);
-            render(<TestComp />);
-            // Reseting counter because mount is 1 render
-            counter.reset();
-            act(() => { sig.set(1); });
-            expect(counter.get()).toBe(1);
-        });
-
-        it('component does NOT re-render when an unrelated store key changes', () => {
-            const sig = signal(store, 'count');
-            const TestComp = makeTestComponent(sig, counter);
-            render(<TestComp />);
-            expect(counter.get()).toBe(1);
-            act(() => { store.setState({ name: 'bob' }); });
-            expect(counter.get()).toBe(1);
-        });
-
-        it('component does NOT re-render when signal is set to Object.is equal value', () => {
-            const sig = signal(store, 'count');
-            const TestComp = makeTestComponent(sig, counter);
-            render(<TestComp />);
-            expect(counter.get()).toBe(1);
-            act(() => { sig.set(0); });
-            expect(counter.get()).toBe(1);
-        });
-
-        it('component re-renders only once even after multiple rapid store changes', () => {
-            const sig = signal(store, 'count');
-            const TestComp = makeTestComponent(sig, counter);
-            render(<TestComp />);
-            counter.reset();
-            act(() => {
-                store.setState({ count: 1 });
-                store.setState({ count: 2 });
-                store.setState({ count: 3 });
-            });
-            expect(counter.get()).toBe(1);
-            expect(screen.getByTestId('value').textContent).toBe('3');
-        });
-
-        it('two components using different signals — only the relevant one re-renders', () => {
-            const sigA = signal(store, 'count');
-            const sigB = signal(store, 'name');
-            const counterA = makeCounter();
-            const counterB = makeCounter();
-            const CompA = makeTestComponent(sigA, counterA);
-            const CompB = makeTestComponent(sigB, counterB);
-            
-            render(<>
-                <CompA />
-                <CompB />
-            </>);
-            
-            expect(counterA.get()).toBe(1);
-            expect(counterB.get()).toBe(1);
-            
-            act(() => { sigA.set(5); });
-            expect(counterA.get()).toBe(2);
-            expect(counterB.get()).toBe(1);
-        });
-
-        it('component using derived signal does NOT re-render when transform output is unchanged even if underlying key changed', () => {
-            const sig = signal(store, 'count', (v) => v > 10);
-            const TestComp = makeTestComponent(sig, counter);
-            render(<TestComp />);
-            expect(counter.get()).toBe(1);
-            
-            act(() => { store.setState({ count: 5 }); }); // false -> false
-            expect(counter.get()).toBe(1);
-            
-            act(() => { store.setState({ count: 15 }); }); // false -> true
-            expect(counter.get()).toBe(2);
-        });
-    });
-
-    describe('Subscription lifecycle', () => {
-        it('subscribes to signal on mount', () => {
-            // Signal subscribe is called by useSyncExternalStore
-            // Hard to check internal signal listener count without exposing it,
-            // but we can check if it updates.
-            const sig = signal(store, 'count');
-            const TestComp = makeTestComponent(sig, counter);
-            render(<TestComp />);
-            act(() => { sig.set(1); });
-            expect(screen.getByTestId('value').textContent).toBe('1');
-        });
-
-        it('unsubscribes from signal on unmount', () => {
-            const sig = signal(store, 'count');
-            const TestComp = makeTestComponent(sig, counter);
-            const { unmount } = render(<TestComp />);
-            unmount();
-            act(() => { sig.set(1); });
-            // No errors should occur
-        });
-
-        it('re-mounting the component re-subscribes correctly', () => {
-            const sig = signal(store, 'count');
-            const TestComp = makeTestComponent(sig, counter);
-            const { unmount } = render(<TestComp />);
-            unmount();
-            render(<TestComp />);
-            act(() => { sig.set(5); });
-            expect(screen.getByTestId('value').textContent).toBe('5');
-        });
-    });
-
-    describe('React.StrictMode safety', () => {
-        it('component renders correctly inside React.StrictMode', () => {
-            const sig = signal(store, 'count');
-            const TestComp = makeTestComponent(sig, counter);
-            render(
-                <React.StrictMode>
-                    <TestComp />
-                </React.StrictMode>
-            );
-            expect(screen.getByTestId('value').textContent).toBe('0');
-        });
-
-        it('no duplicate subscriptions leak after StrictMode double-invoke', () => {
-            const sig = signal(store, 'count');
-            const TestComp = makeTestComponent(sig, counter);
-            render(
-                <React.StrictMode>
-                    <TestComp />
-                </React.StrictMode>
-            );
-            // Even if double-invoked, setting value should result in stable behavior
-            act(() => { sig.set(1); });
-            expect(screen.getByTestId('value').textContent).toBe('1');
-        });
-    });
-
-    describe('Multiple components', () => {
-        it('two components each using their own signal update independently', () => {
-            const sigCount = signal(store, 'count');
-            const sigName = signal(store, 'name');
-            const counterCount = makeCounter();
-            const counterName = makeCounter();
-            const CompCount = makeTestComponent(sigCount, counterCount);
-            const CompName = makeTestComponent(sigName, counterName);
-            
-            render(<>
-                <CompCount />
-                <CompName />
-            </>);
-            
-            act(() => { sigCount.set(10); });
-            expect(screen.getAllByTestId('value')[0].textContent).toBe('10');
-            expect(screen.getAllByTestId('value')[1].textContent).toBe('alice');
-            expect(counterCount.get()).toBe(2);
-            expect(counterName.get()).toBe(1);
-        });
-
-        it('10 components all subscribed to same signal — all update when signal changes', () => {
-            const sig = signal(store, 'count');
-            const counters = Array.from({ length: 10 }, () => makeCounter());
-            const Components = counters.map((c) => makeTestComponent(sig, c));
-            
-            render(<>{Components.map((Comp, i) => <Comp key={i} />)}</>);
-            
-            act(() => { sig.set(99); });
-            const values = screen.getAllByTestId('value');
-            expect(values).toHaveLength(10);
-            values.forEach((v) => expect(v.textContent).toBe('99'));
-            counters.forEach((c) => expect(c.get()).toBe(2));
-        });
-    });
-});