@storve/core 1.0.0

package/tests/integration/persist.integration.test.ts

@@ -0,0 +1,258 @@
+// @vitest-environment jsdom
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { createStore } from '../../src/store'
+import { compose } from '../../src/compose'
+import { withPersist } from '../../src/persist/index'
+import { memoryAdapter } from '../../src/persist/adapters/memory'
+import { localStorageAdapter } from '../../src/persist/adapters/localStorage'
+
+describe('Persist Integration', () => {
+  beforeEach(() => {
+    vi.useFakeTimers({ now: Date.now() })
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+    vi.restoreAllMocks()
+    vi.unstubAllGlobals()
+    if (typeof localStorage !== 'undefined') localStorage.clear()
+  })
+
+  describe('compose + withPersist', () => {
+    it('compose(createStore({count:0}), withPersist({key:\'a\', adapter: memoryAdapter(), debounce:0})) works correctly', async () => {
+      const adapter = memoryAdapter()
+      const store = compose(
+        createStore({ count: 0 }),
+        withPersist({ key: 'a', adapter, debounce: 0 })
+      )
+      expect(store.hydrated).toBeInstanceOf(Promise)
+      await store.hydrated
+      expect(store.getState()).toEqual({ count: 0 })
+    })
+
+    it('setState on composed store writes to adapter', async () => {
+      const adapter = memoryAdapter()
+      const store = compose(
+        createStore({ count: 0 }),
+        withPersist({ key: 'a', adapter, debounce: 0 })
+      )
+      await store.hydrated
+      store.setState({ count: 1 })
+      
+      const raw = await adapter.getItem('a')
+      expect(raw).toContain('"count":1')
+    })
+
+    it('hydration restores state on a new composed store using the same adapter instance', async () => {
+      const adapter = memoryAdapter()
+      const store1 = compose(
+        createStore({ count: 0 }),
+        withPersist({ key: 'a', adapter, debounce: 0 })
+      )
+      await store1.hydrated
+      store1.setState({ count: 99 })
+      
+      const store2 = compose(
+        createStore({ count: 0 }),
+        withPersist({ key: 'a', adapter, debounce: 0 })
+      )
+      await store2.hydrated
+      expect(store2.getState()).toEqual({ count: 99 })
+    })
+  })
+
+  describe('Full round-trip', () => {
+    it('create store → setState → create new store with same adapter → await hydrated → getState matches', async () => {
+      const adapter = memoryAdapter()
+      const storeA = withPersist(createStore({ val: 'first' }), { key: 'a', adapter, debounce: 0 })
+      await storeA.hydrated
+      storeA.setState({ val: 'updated' })
+      
+      const storeB = withPersist(createStore({ val: 'default' }), { key: 'a', adapter, debounce: 0 })
+      await storeB.hydrated
+      
+      expect(storeB.getState()).toEqual({ val: 'updated' })
+    })
+  })
+
+  describe('Multiple stores', () => {
+    it('two stores persisting to same adapter with different keys do not interfere', async () => {
+      const adapter = memoryAdapter()
+      const storeX = withPersist(createStore({ x: 0 }), { key: 'X', adapter, debounce: 0 })
+      const storeY = withPersist(createStore({ y: 0 }), { key: 'Y', adapter, debounce: 0 })
+      
+      await storeX.hydrated
+      await storeY.hydrated
+      
+      storeX.setState({ x: 1 })
+      storeY.setState({ y: 2 })
+      
+      const rawX = await adapter.getItem('X')
+      const rawY = await adapter.getItem('Y')
+      
+      expect(rawX).toContain('"x":1')
+      expect(rawY).toContain('"y":2')
+      expect(rawX).not.toContain('"y":2')
+      expect(rawY).not.toContain('"x":1')
+    })
+
+    it('updating store A does not affect store B\'s persisted data', async () => {
+      vi.useRealTimers()
+      const adapter = memoryAdapter()
+      const storeA = withPersist(createStore({ a: 1 }), { key: 'A', adapter, debounce: 0 })
+      const storeB = withPersist(createStore({ b: 0 }), { key: 'B', adapter, debounce: 0 })
+      
+      await storeA.hydrated
+      await storeB.hydrated
+      
+      storeB.setState({ b: 1 })
+      await Promise.resolve()
+      await Promise.resolve()
+      
+      storeA.setState({ a: 99 })
+      await Promise.resolve()
+      await Promise.resolve()
+      
+      const storeBRehydrated = withPersist(createStore({ b: 0 }), { key: 'B', adapter, debounce: 0 })
+      await storeBRehydrated.hydrated
+      expect(storeBRehydrated.getState()).toEqual({ b: 1 }) // unchanged
+    })
+
+    it('stores are fully isolated with different adapters', async () => {
+      const storeA = withPersist(createStore({ a: 1 }), { key: 'key', adapter: memoryAdapter(), debounce: 0 })
+      const storeB = withPersist(createStore({ b: 2 }), { key: 'key', adapter: memoryAdapter(), debounce: 0 })
+      
+      await storeA.hydrated
+      await storeB.hydrated
+      
+      storeA.setState({ a: 99 })
+      storeB.setState({ b: 88 })
+      
+      expect(storeA.getState()).toEqual({ a: 99 })
+      expect(storeB.getState()).toEqual({ b: 88 })
+    })
+  })
+
+  describe('Normal API behaviour', () => {
+    it('subscriber is notified on setState', async () => {
+      const store = withPersist(createStore({ count: 0 }), { key: 'a', adapter: memoryAdapter(), debounce: 0 })
+      await store.hydrated
+      
+      const sub = vi.fn()
+      store.subscribe(sub)
+      
+      store.setState({ count: 5 })
+      expect(sub).toHaveBeenCalled()
+    })
+
+    it('subscriber receives correct new state', async () => {
+      const store = withPersist(createStore({ count: 0 }), { key: 'a', adapter: memoryAdapter(), debounce: 0 })
+      await store.hydrated
+      
+      const sub = vi.fn()
+      store.subscribe(sub)
+      
+      store.setState({ count: 10 })
+      expect(sub).toHaveBeenCalledWith({ count: 10 })
+    })
+  })
+
+  describe('pick isolation', () => {
+    it('setting a non-picked key does not write anything to adapter', async () => {
+      const adapter = memoryAdapter()
+      const store = withPersist(createStore({ a: 1, secret: 'x' }), { key: 'a', adapter, pick: ['a'], debounce: 0 })
+      await store.hydrated
+      
+      const spySet = vi.spyOn(adapter, 'setItem')
+      store.setState({ secret: 'y' })
+      expect(spySet).not.toHaveBeenCalled()
+    })
+
+    it('setting a picked key writes only picked keys', async () => {
+      const adapter = memoryAdapter()
+      const store = withPersist(createStore({ a: 1, secret: 'x' }), { key: 'a', adapter, pick: ['a'], debounce: 0 })
+      await store.hydrated
+      
+      store.setState({ a: 2, secret: 'y' })
+      const raw = await adapter.getItem('a')
+      const parsed = JSON.parse(raw!)
+      expect(parsed.a).toBe(2)
+      expect(parsed.secret).toBeUndefined()
+    })
+  })
+
+  describe('Debounce integration', () => {
+    it('rapid setStates result in single adapter write (use vi.useFakeTimers)', async () => {
+      const adapter = memoryAdapter()
+      const store = withPersist(createStore({ count: 0 }), { key: 'a', adapter, debounce: 100 })
+      await store.hydrated
+      
+      const spySet = vi.spyOn(adapter, 'setItem')
+      
+      store.setState({ count: 1 })
+      vi.advanceTimersByTime(50)
+      store.setState({ count: 2 })
+      vi.advanceTimersByTime(50)
+      store.setState({ count: 3 })
+      vi.advanceTimersByTime(100)
+      
+      expect(spySet).toHaveBeenCalledTimes(1)
+    })
+
+    it('adapter write contains the latest state, not an intermediate one', async () => {
+      const adapter = memoryAdapter()
+      const store = withPersist(createStore({ count: 0 }), { key: 'a', adapter, debounce: 100 })
+      await store.hydrated
+      
+      store.setState({ count: 1 })
+      store.setState({ count: 2 })
+      store.setState({ count: 3 })
+      vi.advanceTimersByTime(100)
+      
+      const raw = await adapter.getItem('a')
+      expect(raw).toContain('"count":3')
+    })
+  })
+
+  describe('Hydration timing', () => {
+    it('store.getState() before hydration contains default state', () => {
+      const adapter = memoryAdapter()
+      // artificially mock getItem to be slow
+      vi.spyOn(adapter, 'getItem').mockReturnValue(new Promise(resolve => setTimeout(() => resolve('{"count":42,"__version":1}'), 100)))
+      
+      const store = withPersist(createStore({ count: 0 }), { key: 'a', adapter })
+      expect(store.getState()).toEqual({ count: 0 })
+    })
+
+    it('store.getState() after awaiting store.hydrated contains persisted state', async () => {
+      const adapter = memoryAdapter()
+      vi.spyOn(adapter, 'getItem').mockReturnValue(new Promise(resolve => setTimeout(() => resolve('{"count":42,"__version":1}'), 100)))
+      
+      const store = withPersist(createStore({ count: 0 }), { key: 'a', adapter })
+      vi.advanceTimersByTime(100)
+      await store.hydrated
+      expect(store.getState()).toEqual({ count: 42 })
+    })
+  })
+
+  describe('localStorage adapter integration', () => {
+    it('withPersist + localStorageAdapter writes to window.localStorage correctly', async () => {
+      const adapter = localStorageAdapter()
+      const store = withPersist(createStore({ num: 0 }), { key: 'storage-key', adapter, debounce: 0 })
+      await store.hydrated
+      
+      store.setState({ num: 99 })
+      const raw = localStorage.getItem('storage-key')
+      expect(raw).toContain('"num":99')
+    })
+
+    it('SSR scenario: localStorageAdapter with window undefined — withPersist completes without error, store uses defaults', async () => {
+      vi.stubGlobal('window', undefined)
+      const adapter = localStorageAdapter()
+      
+      const store = withPersist(createStore({ num: 10 }), { key: 'ssr-key', adapter, debounce: 0 })
+      await expect(store.hydrated).resolves.toBeUndefined()
+      expect(store.getState()).toEqual({ num: 10 })
+    })
+  })
+})

package/tests/integration/signals.integration.test.ts

@@ -0,0 +1,309 @@
+import { describe, it, expect, vi } from 'vitest';
+import { createStore } from '../../src/store';
+import type { Store } from '../../src/types';
+import { signal } from '../../src/signals/createSignal';
+import { withPersist } from '../../src/persist/index';
+import { memoryAdapter } from '../../src/persist/adapters/memory';
+import { compose } from '../../src/compose';
+
+describe('signals integration', () => {
+    interface State {
+        count: number;
+        name: string;
+        secret: string;
+    }
+
+    describe('signal + plain store', () => {
+        it('signal.get() returns correct initial value', () => {
+            const store = createStore<State>({ count: 0, name: 'alice', secret: 'shh' });
+            const sig = signal(store, 'count');
+            expect(sig.get()).toBe(0);
+        });
+
+        it('signal.set(value) updates store and signal.get() reflects new value immediately', () => {
+            const store = createStore<State>({ count: 0, name: 'alice', secret: 'shh' });
+            const sig = signal(store, 'count');
+            sig.set(10);
+            expect(store.getState().count).toBe(10);
+            expect(sig.get()).toBe(10);
+        });
+
+        it('signal.set(fn) updater form works correctly', () => {
+            const store = createStore<State>({ count: 5, name: 'alice', secret: 'shh' });
+            const sig = signal(store, 'count');
+            sig.set((prev) => prev + 5);
+            expect(store.getState().count).toBe(10);
+        });
+
+        it('signal.subscribe() fires when store.setState changes the key', () => {
+            const store = createStore<State>({ count: 0, name: 'alice', secret: 'shh' });
+            const sig = signal(store, 'count');
+            const listener = vi.fn();
+            sig.subscribe(listener);
+            store.setState({ count: 1 });
+            expect(listener).toHaveBeenCalledWith(1);
+        });
+
+        it('signal.subscribe() does NOT fire when store.setState changes unrelated key', () => {
+            const store = createStore<State>({ count: 0, name: 'alice', secret: 'shh' });
+            const sig = signal(store, 'count');
+            const listener = vi.fn();
+            sig.subscribe(listener);
+            store.setState({ name: 'bob' });
+            expect(listener).not.toHaveBeenCalled();
+        });
+
+        it('two signals on same store are fully independent', () => {
+            const store = createStore<State>({ count: 0, name: 'alice', secret: 'shh' });
+            const sigA = signal(store, 'count');
+            const sigB = signal(store, 'name');
+            const listenerB = vi.fn();
+            sigB.subscribe(listenerB);
+            
+            sigA.set(1);
+            expect(listenerB).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('signal + withPersist', () => {
+        it('signal.set(5) causes the store key to be persisted to adapter', async () => {
+            const adapter = memoryAdapter();
+            const store = withPersist(
+                createStore<State>({ count: 0, name: 'alice', secret: 'shh' }),
+                { key: 'test-store', adapter, debounce: 0 }
+            );
+            const sig = signal(store, 'count');
+            
+            sig.set(42);
+            await Promise.resolve(); // wait for microtasks/persist
+            
+            const saved = await adapter.getItem('test-store');
+            expect(JSON.parse(saved!).count).toBe(42);
+        });
+
+        it('after rehydration on new store: signal.get() reflects the persisted value', async () => {
+            const adapter = memoryAdapter();
+            const initialState = { count: 0, name: 'alice', secret: 'shh' };
+            
+            // Store A sets value
+            const storeA = withPersist(createStore<State>(initialState), { key: 'x', adapter, debounce: 0 });
+            const sigA = signal(storeA, 'count');
+            sigA.set(42);
+            await Promise.resolve();
+            
+            // Store B rehydrates
+            const storeB = withPersist(createStore<State>(initialState), { key: 'x', adapter, debounce: 0 });
+            const sigB = signal(storeB, 'count');
+            await storeB.hydrated;
+            
+            expect(sigB.get()).toBe(42);
+        });
+
+        it('signal.subscribe() fires after hydration completes with the persisted value', async () => {
+            const adapter = memoryAdapter();
+            const initialState = { count: 0, name: 'alice', secret: 'shh' };
+            
+            // Persist value 99
+            await adapter.setItem('y', JSON.stringify({ count: 99, __version: 1 }));
+            
+            const store = withPersist(createStore<State>(initialState), { key: 'y', adapter, debounce: 0 });
+            const sig = signal(store, 'count');
+            const listener = vi.fn();
+            sig.subscribe(listener);
+            
+            await store.hydrated;
+            expect(listener).toHaveBeenCalledWith(99);
+            expect(sig.get()).toBe(99);
+        });
+    });
+
+    describe('signal + compose', () => {
+        it('signal works correctly on a store created with compose', () => {
+            const adapter = memoryAdapter();
+            const store = compose(
+                createStore<State>({ count: 0, name: 'a', secret: 's' }),
+                (s) => withPersist(s, { key: 'composed', adapter, debounce: 0 })
+            ) as Store<State>;
+            
+            const sig = signal(store, 'count');
+            sig.set(123);
+            expect(store.getState().count).toBe(123);
+        });
+
+        it('signal.set() on composed store writes through all enhancers', async () => {
+            const adapter = memoryAdapter();
+            const store = compose(
+                createStore<State>({ count: 0, name: 'a', secret: 's' }),
+                (s) => withPersist(s as Store<State>, { key: 'composed-write', adapter, debounce: 0 })
+            ) as Store<State>;
+            
+            const sig = signal(store, 'count');
+            sig.set(500);
+            await Promise.resolve();
+            
+            const saved = await adapter.getItem('composed-write');
+            expect(JSON.parse(saved!).count).toBe(500);
+        });
+
+        it('signal.get() reads through all enhancers correctly', async () => {
+            const adapter = memoryAdapter();
+            await adapter.setItem('composed-read', JSON.stringify({ count: 777, __version: 1 }));
+            
+            const store = compose(
+                createStore<State>({ count: 0, name: 'a', secret: 's' }),
+                (s) => withPersist(s as Store<State>, { key: 'composed-read', adapter, debounce: 0 })
+            ) as Store<State> & { hydrated: Promise<void> };
+            
+            const sig = signal(store, 'count');
+            await store.hydrated;
+            expect(sig.get()).toBe(777);
+        });
+    });
+
+    describe('derived signal + withPersist', () => {
+        it('derived signal reflects persisted base value after hydration', async () => {
+            const adapter = memoryAdapter();
+            await adapter.setItem('derived-persist', JSON.stringify({ count: 10, __version: 1 }));
+            
+            const store = withPersist(
+                createStore<State>({ count: 0, name: 'a', secret: 's' }),
+                { key: 'derived-persist', adapter, debounce: 0 }
+            );
+            const derivedSig = signal(store, 'count', (v) => v * 2);
+            
+            await store.hydrated;
+            expect(derivedSig.get()).toBe(20);
+        });
+
+        it('derived signal subscriber fires after hydration with correct transformed value', async () => {
+            const adapter = memoryAdapter();
+            await adapter.setItem('derived-sub', JSON.stringify({ count: 5, __version: 1 }));
+            
+            const store = withPersist(
+                createStore<State>({ count: 0, name: 'a', secret: 's' }),
+                { key: 'derived-sub', adapter, debounce: 0 }
+            );
+            const derivedSig = signal(store, 'count', (v) => v + 100);
+            const listener = vi.fn();
+            derivedSig.subscribe(listener);
+            
+            await store.hydrated;
+            expect(listener).toHaveBeenCalledWith(105);
+        });
+
+        it('derived signal set() still throws even on persisted store', () => {
+            const adapter = memoryAdapter();
+            const store = withPersist(
+                createStore<State>({ count: 0, name: 'a', secret: 's' }),
+                { key: 'p', adapter, debounce: 0 }
+            );
+            const derivedSig = signal(store, 'count', (v) => v);
+            expect(() => (derivedSig as unknown as { set: (v: number) => void }).set(1)).toThrow('Storve: cannot call set() on a derived signal. Derived signals are read-only.');
+        });
+    });
+
+    describe('pick filter interaction', () => {
+        it('signal.set() on a NON-picked key does NOT write to adapter', async () => {
+            const adapter = memoryAdapter();
+            const store = withPersist(
+                createStore<State>({ count: 1, secret: 'x' } as State),
+                { key: 'pick-test', adapter, pick: ['count'], debounce: 0 }
+            );
+            await (store as Store<State> & { hydrated: Promise<void> }).hydrated;
+
+            // First write a picked key so adapter has data
+            const countSig = signal(store, 'count');
+            countSig.set(5);
+            await Promise.resolve();
+
+            // Now spy on setItem and set a non-picked key
+            const spySet = vi.spyOn(adapter, 'setItem');
+            const secretSig = signal(store, 'secret');
+            secretSig.set('y');
+            await Promise.resolve();
+
+            // setItem should NOT have been called for the non-picked key change
+            expect(spySet).not.toHaveBeenCalled();
+
+            // Adapter should still only have count, not secret
+            const saved = await adapter.getItem('pick-test');
+            expect(JSON.parse(saved!).secret).toBeUndefined();
+            expect(JSON.parse(saved!).count).toBe(5);
+        });
+
+        it('signal.set() on a PICKED key DOES write to adapter', async () => {
+            const adapter = memoryAdapter();
+            const store = withPersist(
+                createStore<State>({ count: 0, name: 'alice', secret: 'shh' }),
+                { key: 'pick-test', adapter, debounce: 0, pick: ['count'] }
+            );
+            const sig = signal(store, 'count');
+            
+            sig.set(42);
+            await Promise.resolve();
+            
+            const saved = await adapter.getItem('pick-test');
+            expect(JSON.parse(saved!).count).toBe(42);
+        });
+    });
+
+    describe('Multiple signals, shared adapter', () => {
+        it('signals on storeA (key \'A\') and storeB (key \'B\') with same adapter — fully isolated', async () => {
+            const adapter = memoryAdapter();
+            const storeA = withPersist(createStore<State>({ count: 0 } as State), { key: 'A', adapter, debounce: 0 });
+            const storeB = withPersist(createStore<State>({ count: 0 } as State), { key: 'B', adapter, debounce: 0 });
+            
+            const sigA = signal(storeA, 'count');
+            const sigB = signal(storeB, 'count');
+            
+            sigA.set(1);
+            await Promise.resolve();
+            
+            expect(sigB.get()).toBe(0);
+            const savedA = await adapter.getItem('A');
+            const savedB = await adapter.getItem('B');
+            expect(JSON.parse(savedA!).count).toBe(1);
+            expect(savedB).toBeNull();
+        });
+    });
+
+    describe('Memory management', () => {
+        it('unsubscribing from signal prevents callbacks even after store changes', () => {
+            const store = createStore<State>({ count: 0, name: 'a', secret: 's' });
+            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 from sigA does not affect sigB on same store', () => {
+            const store = createStore<State>({ count: 0, name: 'a', secret: 's' });
+            const sigA = signal(store, 'count');
+            const sigB = signal(store, 'count');
+            const lA = vi.fn();
+            const lB = vi.fn();
+            const unsubA = sigA.subscribe(lA);
+            sigB.subscribe(lB);
+            
+            unsubA();
+            store.setState({ count: 1 });
+            expect(lA).not.toHaveBeenCalled();
+            expect(lB).toHaveBeenCalled();
+        });
+
+        it('after store is garbage collected (no references), signal.subscribe callback does not throw', () => {
+            // This is mostly a conceptual test, hard to force GC in JS.
+            // But we ensure no dangling strong references that would cause crashes.
+            let store: Store<State> | null = createStore<State>({ count: 0, name: 'a', secret: 's' });
+            const sig = signal(store, 'count');
+            sig.subscribe(() => {});
+            store = null;
+            // No references to store remain except through signal's closure
+            // We're checking for no obvious leaks/dangling pointer issues.
+            expect(true).toBe(true);
+        });
+    });
+});