@harborclient/sdk 0.6.17 → 0.7.0

package/dist/store.test.js

@@ -1,248 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, jest } from '@jest/globals';
-import { createExternalStore, createStorageStore, setIntervalDisposable, syncOnWindowFocus } from './runtime/store.js';
-/**
- * Builds an in-memory storage mock for store tests.
- *
- * @param initial - Seed values keyed by storage key.
- */
-function createMockStorage(initial = {}) {
-    const data = { ...initial };
-    const getMock = jest.fn(async (key) => data[key]);
-    const setMock = jest.fn(async (key, value) => {
-        data[key] = value;
-    });
-    return {
-        data,
-        get: getMock,
-        set: setMock,
-        getMock,
-        setMock
-    };
-}
-describe('createExternalStore', () => {
-    it('notifies subscribers when setState is called', () => {
-        const store = createExternalStore(0);
-        const listener = jest.fn();
-        store.subscribe(listener);
-        store.setState(1);
-        expect(listener).toHaveBeenCalledTimes(1);
-        expect(store.getSnapshot()).toBe(1);
-    });
-});
-describe('createStorageStore', () => {
-    it('starts from parse(undefined)', () => {
-        const storage = createMockStorage();
-        const store = createStorageStore({
-            storage,
-            key: 'items',
-            parse: (raw) => (Array.isArray(raw) ? raw : [])
-        });
-        expect(store.getSnapshot()).toEqual([]);
-    });
-    it('persists and updates the snapshot via set', async () => {
-        const storage = createMockStorage();
-        const store = createStorageStore({
-            storage,
-            key: 'items',
-            parse: (raw) => (Array.isArray(raw) ? raw : [])
-        });
-        const listener = jest.fn();
-        store.subscribe(listener);
-        await store.set(['a']);
-        expect(store.getSnapshot()).toEqual(['a']);
-        expect(storage.setMock).toHaveBeenCalledWith('items', ['a']);
-        expect(listener).toHaveBeenCalledTimes(1);
-    });
-    it('skips set when equals reports no change', async () => {
-        const storage = createMockStorage({ items: ['a'] });
-        const store = createStorageStore({
-            storage,
-            key: 'items',
-            parse: (raw) => (Array.isArray(raw) ? raw : [])
-        });
-        await store.reloadFromStorage();
-        const listener = jest.fn();
-        store.subscribe(listener);
-        await store.set(['a']);
-        expect(listener).not.toHaveBeenCalled();
-        expect(storage.setMock).not.toHaveBeenCalled();
-    });
-    it('reloadFromStorage applies parsed storage values', async () => {
-        const storage = createMockStorage({ count: 3 });
-        const store = createStorageStore({
-            storage,
-            key: 'count',
-            parse: (raw) => (typeof raw === 'number' ? raw : 0)
-        });
-        const listener = jest.fn();
-        store.subscribe(listener);
-        await store.reloadFromStorage();
-        expect(store.getSnapshot()).toBe(3);
-        expect(listener).toHaveBeenCalledTimes(1);
-    });
-    it('reloadFromStorage skips notify when parsed value is unchanged', async () => {
-        const storage = createMockStorage({ count: 2 });
-        const store = createStorageStore({
-            storage,
-            key: 'count',
-            parse: (raw) => (typeof raw === 'number' ? raw : 0)
-        });
-        await store.reloadFromStorage();
-        const listener = jest.fn();
-        store.subscribe(listener);
-        await store.reloadFromStorage();
-        expect(listener).not.toHaveBeenCalled();
-    });
-    it('uses a custom equals function', async () => {
-        const storage = createMockStorage();
-        const store = createStorageStore({
-            storage,
-            key: 'status',
-            parse: (raw) => raw && typeof raw === 'object' && 'running' in raw
-                ? raw
-                : { running: false },
-            equals: (a, b) => a.running === b.running
-        });
-        await store.set({ running: true });
-        const listener = jest.fn();
-        store.subscribe(listener);
-        storage.data.status = { running: true, port: 8080 };
-        await store.reloadFromStorage();
-        expect(listener).not.toHaveBeenCalled();
-        expect(store.getSnapshot()).toEqual({ running: true });
-    });
-    it('keeps the current snapshot when storage is missing and keepCurrentWhenMissing is true', async () => {
-        const storage = createMockStorage();
-        const store = createStorageStore({
-            storage,
-            key: 'status',
-            parse: () => ({ running: false }),
-            keepCurrentWhenMissing: true
-        });
-        await store.set({ running: true });
-        delete storage.data.status;
-        const listener = jest.fn();
-        store.subscribe(listener);
-        await store.reloadFromStorage();
-        expect(listener).not.toHaveBeenCalled();
-        expect(store.getSnapshot()).toEqual({ running: true });
-    });
-});
-describe('setIntervalDisposable', () => {
-    beforeEach(() => {
-        jest.useFakeTimers();
-    });
-    afterEach(() => {
-        jest.useRealTimers();
-    });
-    it('invokes the callback on an interval until disposed', () => {
-        const callback = jest.fn();
-        const disposable = setIntervalDisposable(callback, 100);
-        jest.advanceTimersByTime(250);
-        expect(callback).toHaveBeenCalledTimes(2);
-        disposable.dispose();
-        jest.advanceTimersByTime(200);
-        expect(callback).toHaveBeenCalledTimes(2);
-    });
-});
-describe('syncOnWindowFocus', () => {
-    const focusListeners = new Set();
-    const visibilityListeners = new Set();
-    const originalWindow = globalThis.window;
-    const originalDocument = globalThis.document;
-    beforeEach(() => {
-        jest.useFakeTimers();
-        focusListeners.clear();
-        visibilityListeners.clear();
-        globalThis.window = {
-            addEventListener: (type, listener) => {
-                if (type === 'focus' && typeof listener === 'function') {
-                    focusListeners.add(listener);
-                }
-            },
-            removeEventListener: (type, listener) => {
-                if (type === 'focus' && typeof listener === 'function') {
-                    focusListeners.delete(listener);
-                }
-            },
-            dispatchEvent: (event) => {
-                if (event.type === 'focus') {
-                    for (const listener of focusListeners) {
-                        listener(event);
-                    }
-                }
-                return true;
-            }
-        };
-        globalThis.document = {
-            addEventListener: (type, listener) => {
-                if (type === 'visibilitychange' && typeof listener === 'function') {
-                    visibilityListeners.add(listener);
-                }
-            },
-            removeEventListener: (type, listener) => {
-                if (type === 'visibilitychange' && typeof listener === 'function') {
-                    visibilityListeners.delete(listener);
-                }
-            },
-            dispatchEvent: (event) => {
-                if (event.type === 'visibilitychange') {
-                    for (const listener of visibilityListeners) {
-                        listener(event);
-                    }
-                }
-                return true;
-            }
-        };
-    });
-    afterEach(() => {
-        jest.useRealTimers();
-        globalThis.window = originalWindow;
-        globalThis.document = originalDocument;
-    });
-    it('reloads stores on focus, visibility change, mount, and interval', async () => {
-        const storage = createMockStorage({ count: 1 });
-        const store = createStorageStore({
-            storage,
-            key: 'count',
-            parse: (raw) => (typeof raw === 'number' ? raw : 0)
-        });
-        const reloadSpy = jest.spyOn(store, 'reloadFromStorage');
-        const disposable = syncOnWindowFocus(store, { intervalMs: 500 });
-        expect(reloadSpy).toHaveBeenCalledTimes(1);
-        storage.data.count = 2;
-        window.dispatchEvent(new Event('focus'));
-        expect(reloadSpy).toHaveBeenCalledTimes(2);
-        storage.data.count = 3;
-        document.dispatchEvent(new Event('visibilitychange'));
-        expect(reloadSpy).toHaveBeenCalledTimes(3);
-        storage.data.count = 4;
-        jest.advanceTimersByTime(500);
-        expect(reloadSpy).toHaveBeenCalledTimes(4);
-        disposable.dispose();
-        storage.data.count = 5;
-        window.dispatchEvent(new Event('focus'));
-        jest.advanceTimersByTime(500);
-        expect(reloadSpy).toHaveBeenCalledTimes(4);
-        await store.reloadFromStorage();
-        expect(store.getSnapshot()).toBe(5);
-    });
-    it('reloads multiple stores together', async () => {
-        const storage = createMockStorage();
-        const first = createStorageStore({
-            storage,
-            key: 'first',
-            parse: (raw) => (typeof raw === 'number' ? raw : 0)
-        });
-        const second = createStorageStore({
-            storage,
-            key: 'second',
-            parse: (raw) => (typeof raw === 'number' ? raw : 0)
-        });
-        const reloadFirst = jest.spyOn(first, 'reloadFromStorage');
-        const reloadSecond = jest.spyOn(second, 'reloadFromStorage');
-        syncOnWindowFocus([first, second]).dispose();
-        expect(reloadFirst).toHaveBeenCalledTimes(1);
-        expect(reloadSecond).toHaveBeenCalledTimes(1);
-    });
-});

package/tsconfig.base.json

@@ -1,15 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "jsx": "react-jsx",
-    "jsxImportSource": "@harborclient/sdk",
-    "strict": true,
-    "skipLibCheck": true,
-    "noEmit": true,
-    "isolatedModules": true,
-    "lib": ["ES2022", "DOM"],
-    "types": ["react"]
-  }
-}