native-document 1.0.16 → 1.0.17-1.2

package/tests/unit/core/observable-resource.test.js

@@ -0,0 +1,323 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Observable } from '../../../src/core/data/Observable';
+import ObservableResource from '../../../src/core/data/ObservableResource';
+import ObservableItem from '../../../src/core/data/ObservableItem';
+
+const resource = (fn, deps = [], config = {}) =>
+    new ObservableResource(fn, deps, config);
+
+const resolved = (value) => () => Promise.resolve(value);
+const rejected = (err)   => () => Promise.reject(err);
+
+describe('ObservableResource', () => {
+
+    // -- initial state --------------------------------------------------------
+
+    describe('initial state', () => {
+        it('state is unresolved before any fetch', () => {
+            const r = resource(resolved('data'), []);
+            expect(r.state.val()).toBe('unresolved');
+        });
+
+        it('data is null before any fetch', () => {
+            const r = resource(resolved('data'), []);
+            expect(r.data.val()).toBeNull();
+        });
+
+        it('isUnresolved() returns true before first fetch', () => {
+            const r = resource(resolved('data'), []);
+            expect(r.isUnresolved().val()).toBe(true);
+        });
+
+        it('loading is false before any fetch', () => {
+            const r = resource(resolved('data'), []);
+            expect(r.loading.val()).toBe(false);
+        });
+    });
+
+    // -- fetch() --------------------------------------------------------------
+
+    describe('fetch()', () => {
+        it('transitions to pending then ready', async () => {
+            const r = resource(resolved('hello'), []);
+            r.fetch();
+            expect(r.state.val()).toBe('pending');
+            await new Promise((res) => setTimeout(res, 0));
+            expect(r.state.val()).toBe('ready');
+        });
+
+        it('sets data on success', async () => {
+            const r = resource(resolved({ id: 1 }), []);
+            r.fetch();
+            await new Promise((res) => setTimeout(res, 0));
+            expect(r.data.val()).toEqual({ id: 1 });
+        });
+
+        it('sets error on failure', async () => {
+            const err = new Error('Network error');
+            const r   = resource(rejected(err), []);
+            r.fetch();
+            await new Promise((res) => setTimeout(res, 0));
+            expect(r.state.val()).toBe('errored');
+            expect(r.error.val()).toBe(err);
+        });
+
+        it('clears error on successful re-fetch', async () => {
+            const r = resource(rejected(new Error('fail')), []);
+            r.fetch();
+            await new Promise((res) => setTimeout(res, 0));
+            r.$fn = resolved('ok');
+            r.fetch();
+            await new Promise((res) => setTimeout(res, 0));
+            expect(r.error.val()).toBeNull();
+        });
+
+        it('state is pending while fetching', async () => {
+            let resolve;
+            // fn must declare signal param so $run uses AbortController path (async)
+            const fn = (_signal) => new Promise((r) => { resolve = r; });
+            const r  = resource(fn, []);
+            r.fetch();
+            expect(r.state.val()).toBe('pending');
+            resolve('done');
+            await new Promise((res) => setTimeout(res, 0));
+            expect(r.state.val()).toBe('ready');
+        });
+
+        it('isReady() returns true after success', async () => {
+            const r = resource(resolved('ok'), []);
+            r.fetch();
+            await new Promise((res) => setTimeout(res, 0));
+            expect(r.isReady().val()).toBe(true);
+        });
+
+        it('isErrored() returns true after failure', async () => {
+            const r = resource(rejected(new Error('fail')), []);
+            r.fetch();
+            await new Promise((res) => setTimeout(res, 0));
+            expect(r.isErrored().val()).toBe(true);
+        });
+    });
+
+    // -- refetch() ------------------------------------------------------------
+
+    describe('refetch()', () => {
+        it('transitions to refreshing when data already exists', async () => {
+            const r = resource(resolved('first'), []);
+            r.fetch();
+            await new Promise((res) => setTimeout(res, 0));
+
+            let capturedState = null;
+            r.state.subscribe((state) => { capturedState = state; });
+            r.refetch();
+            expect(capturedState).toBe('refreshing');
+        });
+
+        it('updates data on success', async () => {
+            const r = resource(resolved('first'), []);
+            r.fetch();
+            await new Promise((res) => setTimeout(res, 0));
+
+            r.$fn = resolved('second');
+            r.refetch();
+            await new Promise((res) => setTimeout(res, 0));
+            expect(r.data.val()).toBe('second');
+        });
+    });
+
+    // -- mutate() -------------------------------------------------------------
+
+    describe('mutate()', () => {
+        it('updates data without triggering a fetch', () => {
+            const fn = vi.fn(resolved('original'));
+            const r  = resource(fn, []);
+            r.mutate('overridden');
+            expect(r.data.val()).toBe('overridden');
+            expect(fn).not.toHaveBeenCalled();
+        });
+
+        it('sets state to ready', () => {
+            const r = resource(resolved('data'), []);
+            r.mutate('value');
+            expect(r.state.val()).toBe('ready');
+        });
+
+        it('notifies data subscribers', () => {
+            const r  = resource(resolved('data'), []);
+            const cb = vi.fn();
+            r.data.subscribe(cb);
+            r.mutate('new');
+            expect(cb).toHaveBeenCalledOnce();
+        });
+    });
+
+    // -- abort() --------------------------------------------------------------
+
+    describe('abort via AbortController', () => {
+        it('does not update data after abort', async () => {
+            let externalResolve;
+            const fn = (_signal) => new Promise((res) => { externalResolve = res; });
+            const r  = resource(fn, []);
+            r.fetch();
+            r.$abort();
+            externalResolve('late data');
+            await new Promise((res) => setTimeout(res, 0));
+            expect(r.data.val()).toBeNull();
+        });
+    });
+
+    // -- auto fetch with deps -------------------------------------------------
+
+    describe('auto fetch with deps', () => {
+        it('fetches automatically when { auto: true } and no deps', async () => {
+            const r = resource(resolved('auto'), [], { auto: true });
+            await new Promise((res) => setTimeout(res, 0));
+            expect(r.data.val()).toBe('auto');
+        });
+
+        it('re-fetches when a dependency changes', async () => {
+            const dep = Observable(1);
+            const fn  = vi.fn((val) => Promise.resolve(val * 10));
+            const r   = resource(fn, [dep], { auto: true });
+            await new Promise((res) => setTimeout(res, 0));
+            expect(r.data.val()).toBe(10);
+
+            dep.set(2);
+            await new Promise((res) => setTimeout(res, 0));
+            expect(r.data.val()).toBe(20);
+        });
+
+        it('does not fetch immediately when { lazy: true }', async () => {
+            const dep = Observable(1);
+            const fn  = vi.fn(resolved('data'));
+            resource(fn, [dep], { auto: true, lazy: true });
+            await new Promise((res) => setTimeout(res, 0));
+            expect(fn).not.toHaveBeenCalled();
+        });
+
+        it('fetches after dep change when { lazy: true }', async () => {
+            const dep = Observable(1);
+            const fn  = vi.fn(resolved('data'));
+            resource(fn, [dep], { auto: true, lazy: true });
+            dep.set(2);
+            await new Promise((res) => setTimeout(res, 0));
+            expect(fn).toHaveBeenCalledOnce();
+        });
+    });
+
+    // -- onSuccess() / onError() ----------------------------------------------
+
+    describe('onSuccess() / onError()', () => {
+        it('onSuccess fires after successful fetch', async () => {
+            // fn must declare _signal to use async path
+            const r = resource((_signal) => Promise.resolve('ok'), []);
+            r.fetch();
+            await new Promise((res) => setTimeout(res, 0));
+            expect(r.state.val()).toBe('ready');
+            expect(r.data.val()).toBe('ok');
+        });
+
+        it('onError fires after failed fetch', async () => {
+            const err = new Error('fail');
+            const cb  = vi.fn();
+            const r   = resource(rejected(err), []);
+            r.onError(cb);
+            r.fetch();
+            await new Promise((res) => setTimeout(res, 0));
+            expect(cb).toHaveBeenCalledWith(err);
+        });
+    });
+
+    // -- into() ---------------------------------------------------------------
+
+    describe('into()', () => {
+        it('writes result into provided observable', async () => {
+            const target = Observable(null);
+            const r      = resource(resolved('result'), []);
+            r.into(target);
+            r.fetch();
+            await new Promise((res) => setTimeout(res, 0));
+            expect(target.val()).toBe('result');
+        });
+
+        it('this.data points to the target observable', () => {
+            const target = Observable(null);
+            const r      = resource(resolved('data'), []);
+            r.into(target);
+            expect(r.data).toBe(target);
+        });
+    });
+
+    // -- apply() --------------------------------------------------------------
+
+    describe('apply()', () => {
+        it('transforms data with provided function', async () => {
+            const r = resource(resolved({ items: [1, 2, 3] }), []);
+            r.apply((result, data) => data.set(result.items));
+            r.fetch();
+            await new Promise((res) => setTimeout(res, 0));
+            expect(r.data.val()).toEqual([1, 2, 3]);
+        });
+    });
+
+    // -- destroy() ------------------------------------------------------------
+
+    describe('destroy()', () => {
+        it('aborts in-flight request', () => {
+            let resolve;
+            const fn = (_signal) => new Promise((r) => { resolve = r; });
+            const r  = resource(fn, []);
+            r.fetch();
+            const controller = r.$controller;
+            r.destroy();
+            expect(controller.signal.aborted).toBe(true);
+        });
+
+        it('unsubscribes from all dependencies', () => {
+            const dep = Observable(1);
+            const fn  = vi.fn(resolved('data'));
+            const r   = resource(fn, [dep], { auto: true });
+            r.destroy();
+            const callCount = fn.mock.calls.length;
+            dep.set(2);
+            expect(fn.mock.calls.length).toBe(callCount);
+        });
+    });
+
+    // -- race condition -------------------------------------------------------
+
+    describe('race condition', () => {
+        it('last fetch call wins — stale response is ignored', async () => {
+            let resolveFirst;
+            let resolveSecond;
+
+            // Wrapper with explicit signal param — forces AbortController path
+            const makePromise = () => {
+                let res;
+                const p = new Promise((r) => { res = r; });
+                return { promise: p, resolve: res };
+            };
+
+            const p1 = makePromise();
+            const p2 = makePromise();
+            let call = 0;
+
+            // fn.length must be > 0 to trigger AbortController path
+            const fn = function(_signal) {
+                call++;
+                return call === 1 ? p1.promise : p2.promise;
+            };
+
+            const r = resource(fn, []);
+            r.fetch(); // first — will be aborted by second fetch
+            r.fetch(); // second — wins
+
+            p2.resolve('second');
+            p1.resolve('first'); // aborted, ignored
+
+            await new Promise((res) => setTimeout(res, 0));
+            expect(r.data.val()).toBe('second');
+        });
+    });
+
+});

package/tests/unit/core/store.test.js

@@ -0,0 +1,347 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// DebugManager is an empty object when NODE_ENV is not 'development' or 'production'
+// Mock it before importing Store to avoid 'warn is not a function' errors
+vi.mock('../../../src/core/utils/debug-manager', () => ({
+    default: {
+        log:     vi.fn(),
+        warn:    vi.fn(),
+        error:   vi.fn(),
+        disable: vi.fn(),
+    },
+}));
+
+import { StoreFactory } from '../../../src/core/data/Store';
+
+// Each test uses a fresh isolated store to avoid name collisions
+let Store;
+
+beforeEach(() => {
+    Store = StoreFactory();
+});
+
+describe('Store', () => {
+
+    // -- create() -------------------------------------------------------------
+
+    describe('create()', () => {
+        it('creates a store and returns an observable', () => {
+            const obs = Store.create('count', 0);
+            expect(obs.val()).toBe(0);
+        });
+
+        it('creates a store with an array value', () => {
+            const obs = Store.create('items', [1, 2, 3]);
+            expect(obs.val()).toEqual([1, 2, 3]);
+        });
+
+        it('creates a store with an object value', () => {
+            const obs = Store.create('user', { name: 'John' });
+            expect(obs.get('name')).toBe('John');
+        });
+
+        it('throws if store name already exists', () => {
+            Store.create('x', 1);
+            expect(() => Store.create('x', 2)).toThrow();
+        });
+
+        it('two stores are fully independent', () => {
+            const a = Store.create('a', 1);
+            const b = Store.create('b', 2);
+            a.set(99);
+            expect(b.val()).toBe(2);
+        });
+    });
+
+    // -- createResettable() ---------------------------------------------------
+
+    describe('createResettable()', () => {
+        it('creates a resettable store', () => {
+            const obs = Store.createResettable('theme', 'light');
+            obs.set('dark');
+            Store.reset('theme');
+            expect(obs.val()).toBe('light');
+        });
+
+        it('throws if store name already exists', () => {
+            Store.createResettable('x', 1);
+            expect(() => Store.createResettable('x', 2)).toThrow();
+        });
+    });
+
+    // -- createComposed() -----------------------------------------------------
+
+    describe('createComposed()', () => {
+        it('creates a computed store derived from other stores', async () => {
+            Store.create('a', 2);
+            Store.create('b', 3);
+            const comp = Store.createComposed('sum', () => {
+                return Store.get('a').val() + Store.get('b').val();
+            }, ['a', 'b']);
+            expect(comp.val()).toBe(5);
+        });
+
+        it('updates when a dependency changes', async () => {
+            Store.create('x', 10);
+            const comp = Store.createComposed('doubled', () => Store.get('x').val() * 2, ['x']);
+            Store.get('x').set(20);
+            await new Promise((r) => setTimeout(r, 0));
+            expect(comp.val()).toBe(40);
+        });
+
+        it('throws if computation is not a function', () => {
+            expect(() => Store.createComposed('bad', 'not-a-fn', ['x'])).toThrow();
+        });
+
+        it('throws if dependencies is empty', () => {
+            expect(() => Store.createComposed('bad', () => {}, [])).toThrow();
+        });
+
+        it('throws if dependency store does not exist', () => {
+            expect(() => Store.createComposed('bad', () => {}, ['missing'])).toThrow();
+        });
+    });
+
+    // -- has() ----------------------------------------------------------------
+
+    describe('has()', () => {
+        it('returns true for existing store', () => {
+            Store.create('x', 1);
+            expect(Store.has('x')).toBe(true);
+        });
+
+        it('returns false for unknown store', () => {
+            expect(Store.has('unknown')).toBe(false);
+        });
+    });
+
+    // -- get() ----------------------------------------------------------------
+
+    describe('get()', () => {
+        it('returns the raw observable', () => {
+            const obs = Store.create('count', 42);
+            expect(Store.get('count')).toBe(obs);
+        });
+
+        it('returns null for unknown store', () => {
+            expect(Store.get('unknown')).toBeNull();
+        });
+    });
+
+    // -- use() ----------------------------------------------------------------
+
+    describe('use()', () => {
+        it('returns a two-way synchronized follower', () => {
+            Store.create('count', 0);
+            const follower = Store.use('count');
+            expect(follower.val()).toBe(0);
+        });
+
+        it('follower reflects store changes', () => {
+            Store.create('count', 0);
+            const follower = Store.use('count');
+            Store.get('count').set(5);
+            expect(follower.val()).toBe(5);
+        });
+
+        it('store reflects follower changes', () => {
+            Store.create('count', 0);
+            const follower = Store.use('count');
+            follower.set(10);
+            expect(Store.get('count').val()).toBe(10);
+        });
+
+        it('destroy() unsubscribes the follower', () => {
+            Store.create('count', 0);
+            const follower = Store.use('count');
+            const cb = vi.fn();
+            follower.subscribe(cb);
+            follower.destroy();
+            Store.get('count').set(99);
+            // After destroy, follower is cleaned up and no longer notified
+            expect(cb).not.toHaveBeenCalled();
+        });
+
+        it('throws for a composed store', () => {
+            Store.create('dep', 1);
+            Store.createComposed('comp', () => 1, ['dep']);
+            expect(() => Store.use('comp')).toThrow();
+        });
+    });
+
+    // -- follow() -------------------------------------------------------------
+
+    describe('follow()', () => {
+        it('returns a read-only follower', () => {
+            Store.create('count', 0);
+            const follower = Store.follow('count');
+            expect(follower.val()).toBe(0);
+        });
+
+        it('follower reflects store changes', () => {
+            Store.create('count', 0);
+            const follower = Store.follow('count');
+            Store.get('count').set(5);
+            expect(follower.val()).toBe(5);
+        });
+
+        it('set() on follower throws', () => {
+            Store.create('count', 0);
+            const follower = Store.follow('count');
+            expect(() => follower.set(99)).toThrow();
+        });
+
+        it('toggle() on follower throws', () => {
+            Store.create('active', false);
+            const follower = Store.follow('active');
+            expect(() => follower.toggle()).toThrow();
+        });
+
+        it('destroy() unsubscribes the follower', () => {
+            Store.create('count', 0);
+            const follower = Store.follow('count');
+            const original = follower.val();
+            follower.destroy();
+            Store.get('count').set(99);
+            // After destroy, follower is no longer tracking the store
+            expect(original).toBe(0);
+        });
+    });
+
+    // -- reset() --------------------------------------------------------------
+
+    describe('reset()', () => {
+        it('resets a resettable store to initial value', () => {
+            Store.createResettable('count', 0);
+            Store.get('count').set(99);
+            Store.reset('count');
+            expect(Store.get('count').val()).toBe(0);
+        });
+
+        it('throws for a non-resettable store', () => {
+            Store.create('count', 0);
+            expect(() => Store.reset('count')).toThrow();
+        });
+
+        it('throws for a composed store', () => {
+            Store.create('dep', 1);
+            Store.createComposed('comp', () => 1, ['dep']);
+            expect(() => Store.reset('comp')).toThrow();
+        });
+
+        it('throws for unknown store', () => {
+            expect(() => Store.reset('unknown')).toThrow();
+        });
+    });
+
+    // -- delete() -------------------------------------------------------------
+
+    describe('delete()', () => {
+        it('removes a store', () => {
+            Store.create('temp', 1);
+            Store.delete('temp');
+            expect(Store.has('temp')).toBe(false);
+        });
+
+        it('destroys all followers on delete', () => {
+            Store.create('count', 0);
+            const follower = Store.use('count');
+            Store.delete('count');
+            expect(follower.$listeners?.length ?? 0).toBe(0);
+        });
+
+        it('does nothing for unknown store', () => {
+            expect(() => Store.delete('unknown')).not.toThrow();
+        });
+    });
+
+    // -- group() --------------------------------------------------------------
+
+    describe('group()', () => {
+        it('creates an isolated store namespace', () => {
+            const GroupStore = Store.group('test', (g) => {
+                g.create('count', 0);
+            });
+            expect(GroupStore.has('count')).toBe(true);
+            expect(Store.has('count')).toBe(false);
+        });
+
+        it('accepts a callback without a name', () => {
+            const GroupStore = Store.group((g) => {
+                g.create('x', 1);
+            });
+            expect(GroupStore.has('x')).toBe(true);
+        });
+
+        it('two groups are independent', () => {
+            const A = Store.group((g) => g.create('count', 0));
+            const B = Store.group((g) => g.create('count', 99));
+            expect(A.get('count').val()).toBe(0);
+            expect(B.get('count').val()).toBe(99);
+        });
+    });
+
+    // -- protected() ----------------------------------------------------------
+
+    describe('protected()', () => {
+        it('returns a read-only proxy', () => {
+            Store.create('count', 0);
+            const ReadOnly = Store.protected();
+            expect(() => ReadOnly.create('x', 1)).toThrow();
+            expect(() => ReadOnly.use('count')).toThrow();
+            expect(() => ReadOnly.get('count')).toThrow();
+        });
+
+        it('follow() and has() are still accessible', () => {
+            Store.create('count', 0);
+            const ReadOnly = Store.protected();
+            expect(ReadOnly.has('count')).toBe(true);
+            const follower = ReadOnly.follow('count');
+            expect(follower.val()).toBe(0);
+        });
+
+        it('property access returns a read-only follower', () => {
+            Store.create('theme', 'light');
+            const ReadOnly = Store.protected();
+            const follower = ReadOnly.theme;
+            expect(follower.val()).toBe('light');
+            expect(() => follower.set('dark')).toThrow();
+        });
+    });
+
+    // -- createPersistent() ---------------------------------------------------
+
+    describe('createPersistent()', () => {
+        it('saves to localStorage on change', () => {
+            Store.createPersistent('theme', 'light');
+            Store.get('theme').set('dark');
+            expect(localStorage.getItem('theme')).toBeTruthy();
+        });
+
+        it('restores from localStorage on init', () => {
+            // $getFromStorage uses LocalStorage.get() for strings (no JSON.parse)
+            localStorage.setItem('lang', 'fr');
+            Store.createPersistent('lang', 'en');
+            expect(Store.get('lang').val()).toBe('fr');
+            localStorage.removeItem('lang');
+        });
+    });
+
+    // -- Proxy property access ------------------------------------------------
+
+    describe('Proxy property access', () => {
+        it('Store.storeName returns a follower', () => {
+            Store.create('count', 42);
+            const follower = Store.count;
+            expect(follower.val()).toBe(42);
+        });
+
+        it('returns same follower on repeated access (cache)', () => {
+            Store.create('count', 0);
+            const f1 = Store.count;
+            const f2 = Store.count;
+            expect(f1).toBe(f2);
+        });
+    });
+
+});