zero-query 0.6.3 → 0.7.5

package/tests/store.test.js

@@ -0,0 +1,253 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createStore, getStore } from '../src/store.js';
+
+
+// ---------------------------------------------------------------------------
+// Store creation
+// ---------------------------------------------------------------------------
+
+describe('Store — creation', () => {
+  it('creates a store with initial state', () => {
+    const store = createStore('test-create', {
+      state: { count: 0, name: 'Tony' },
+    });
+    expect(store.state.count).toBe(0);
+    expect(store.state.name).toBe('Tony');
+  });
+
+  it('supports state as a factory function', () => {
+    const store = createStore('test-fn', {
+      state: () => ({ items: [] }),
+    });
+    expect(store.state.items).toEqual([]);
+  });
+
+  it('getStore retrieves by name', () => {
+    const store = createStore('named-store', { state: { x: 1 } });
+    expect(getStore('named-store')).toBe(store);
+  });
+
+  it('getStore returns null for unknown stores', () => {
+    expect(getStore('nonexistent')).toBeNull();
+  });
+
+  it('defaults to "default" when no name is provided', () => {
+    const store = createStore({ state: { val: 42 } });
+    expect(getStore('default')).toBe(store);
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// Dispatch & actions
+// ---------------------------------------------------------------------------
+
+describe('Store — dispatch', () => {
+  it('dispatches a named action', () => {
+    const store = createStore('dispatch-1', {
+      state: { count: 0 },
+      actions: {
+        increment(state) { state.count++; },
+      },
+    });
+    store.dispatch('increment');
+    expect(store.state.count).toBe(1);
+  });
+
+  it('passes payload to action', () => {
+    const store = createStore('dispatch-2', {
+      state: { count: 0 },
+      actions: {
+        add(state, amount) { state.count += amount; },
+      },
+    });
+    store.dispatch('add', 5);
+    expect(store.state.count).toBe(5);
+  });
+
+  it('reports error for unknown actions', () => {
+    const store = createStore('dispatch-unknown', {
+      state: {},
+      actions: {},
+    });
+    // Should not throw if action doesn't exist
+    expect(() => store.dispatch('nonexistent')).not.toThrow();
+  });
+
+  it('records action in history', () => {
+    const store = createStore('dispatch-hist', {
+      state: { x: 0 },
+      actions: { inc(state) { state.x++; } },
+    });
+    store.dispatch('inc');
+    store.dispatch('inc');
+    expect(store.history.length).toBe(2);
+    expect(store.history[0].action).toBe('inc');
+  });
+
+  it('does not crash when action throws', () => {
+    const store = createStore('dispatch-throw', {
+      state: {},
+      actions: {
+        bad() { throw new Error('action error'); },
+      },
+    });
+    expect(() => store.dispatch('bad')).not.toThrow();
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// Subscriptions
+// ---------------------------------------------------------------------------
+
+describe('Store — subscribe', () => {
+  it('notifies key-specific subscribers', () => {
+    const store = createStore('sub-1', {
+      state: { count: 0 },
+      actions: { inc(state) { state.count++; } },
+    });
+    const fn = vi.fn();
+    store.subscribe('count', fn);
+    store.dispatch('inc');
+    expect(fn).toHaveBeenCalledWith(1, 0, 'count');
+  });
+
+  it('wildcard subscriber gets all changes', () => {
+    const store = createStore('sub-2', {
+      state: { a: 0, b: 0 },
+      actions: {
+        setA(state, v) { state.a = v; },
+        setB(state, v) { state.b = v; },
+      },
+    });
+    const fn = vi.fn();
+    store.subscribe(fn);
+    store.dispatch('setA', 1);
+    store.dispatch('setB', 2);
+    expect(fn).toHaveBeenCalledTimes(2);
+  });
+
+  it('unsubscribe stops notifications', () => {
+    const store = createStore('sub-3', {
+      state: { x: 0 },
+      actions: { inc(state) { state.x++; } },
+    });
+    const fn = vi.fn();
+    const unsub = store.subscribe('x', fn);
+    store.dispatch('inc');
+    expect(fn).toHaveBeenCalledOnce();
+    unsub();
+    store.dispatch('inc');
+    expect(fn).toHaveBeenCalledOnce();
+  });
+
+  it('does not crash when subscriber throws', () => {
+    const store = createStore('sub-throw', {
+      state: { x: 0 },
+      actions: { inc(state) { state.x++; } },
+    });
+    store.subscribe('x', () => { throw new Error('subscriber error'); });
+    expect(() => store.dispatch('inc')).not.toThrow();
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// Getters
+// ---------------------------------------------------------------------------
+
+describe('Store — getters', () => {
+  it('computes values from state', () => {
+    const store = createStore('getters-1', {
+      state: { count: 5 },
+      getters: {
+        doubled: (state) => state.count * 2,
+      },
+    });
+    expect(store.getters.doubled).toBe(10);
+  });
+
+  it('updates when state changes', () => {
+    const store = createStore('getters-2', {
+      state: { count: 1 },
+      actions: { inc(state) { state.count++; } },
+      getters: { doubled: (state) => state.count * 2 },
+    });
+    store.dispatch('inc');
+    expect(store.getters.doubled).toBe(4);
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// Middleware
+// ---------------------------------------------------------------------------
+
+describe('Store — middleware', () => {
+  it('calls middleware before action', () => {
+    const log = vi.fn();
+    const store = createStore('mw-1', {
+      state: { x: 0 },
+      actions: { inc(state) { state.x++; } },
+    });
+    store.use((name, args, state) => { log(name); });
+    store.dispatch('inc');
+    expect(log).toHaveBeenCalledWith('inc');
+  });
+
+  it('blocks action when middleware returns false', () => {
+    const store = createStore('mw-block', {
+      state: { x: 0 },
+      actions: { inc(state) { state.x++; } },
+    });
+    store.use(() => false);
+    store.dispatch('inc');
+    expect(store.state.x).toBe(0);
+  });
+
+  it('does not crash when middleware throws', () => {
+    const store = createStore('mw-throw', {
+      state: { x: 0 },
+      actions: { inc(state) { state.x++; } },
+    });
+    store.use(() => { throw new Error('middleware error'); });
+    expect(() => store.dispatch('inc')).not.toThrow();
+    // Action should NOT have run (middleware threw → dispatch returns)
+    expect(store.state.x).toBe(0);
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// Snapshot & replaceState
+// ---------------------------------------------------------------------------
+
+describe('Store — snapshot & replaceState', () => {
+  it('snapshot returns plain object copy', () => {
+    const store = createStore('snap-1', { state: { a: 1, b: { c: 2 } } });
+    const snap = store.snapshot();
+    expect(snap).toEqual({ a: 1, b: { c: 2 } });
+    snap.a = 99;
+    expect(store.state.a).toBe(1); // original unchanged
+  });
+
+  it('replaceState replaces entire state', () => {
+    const store = createStore('replace-1', { state: { x: 1, y: 2 } });
+    store.replaceState({ x: 10, z: 30 });
+    expect(store.state.x).toBe(10);
+    expect(store.state.z).toBe(30);
+  });
+
+  it('reset replaces state and clears history', () => {
+    const store = createStore('reset-1', {
+      state: { count: 0 },
+      actions: { inc(state) { state.count++; } },
+    });
+    store.dispatch('inc');
+    store.dispatch('inc');
+    store.reset({ count: 0 });
+    expect(store.state.count).toBe(0);
+    expect(store.history.length).toBe(0);
+  });
+});

package/tests/utils.test.js

@@ -0,0 +1,353 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+  debounce, throttle, pipe, once, sleep,
+  escapeHtml, trust, uuid, camelCase, kebabCase,
+  deepClone, deepMerge, isEqual, param, parseQuery,
+  bus,
+} from '../src/utils.js';
+
+
+// ---------------------------------------------------------------------------
+// Function utilities
+// ---------------------------------------------------------------------------
+
+describe('debounce', () => {
+  beforeEach(() => { vi.useFakeTimers(); });
+
+  it('delays execution until after ms of inactivity', () => {
+    const fn = vi.fn();
+    const debounced = debounce(fn, 100);
+    debounced('a');
+    debounced('b');
+    expect(fn).not.toHaveBeenCalled();
+    vi.advanceTimersByTime(100);
+    expect(fn).toHaveBeenCalledOnce();
+    expect(fn).toHaveBeenCalledWith('b');
+  });
+
+  it('uses default 250ms delay', () => {
+    const fn = vi.fn();
+    const debounced = debounce(fn);
+    debounced();
+    vi.advanceTimersByTime(249);
+    expect(fn).not.toHaveBeenCalled();
+    vi.advanceTimersByTime(1);
+    expect(fn).toHaveBeenCalledOnce();
+  });
+
+  it('cancel() stops pending execution', () => {
+    const fn = vi.fn();
+    const debounced = debounce(fn, 100);
+    debounced();
+    debounced.cancel();
+    vi.advanceTimersByTime(200);
+    expect(fn).not.toHaveBeenCalled();
+  });
+
+  it('resets timer on subsequent calls', () => {
+    const fn = vi.fn();
+    const debounced = debounce(fn, 100);
+    debounced();
+    vi.advanceTimersByTime(80);
+    debounced();
+    vi.advanceTimersByTime(80);
+    expect(fn).not.toHaveBeenCalled();
+    vi.advanceTimersByTime(20);
+    expect(fn).toHaveBeenCalledOnce();
+  });
+});
+
+
+describe('throttle', () => {
+  beforeEach(() => { vi.useFakeTimers(); });
+
+  it('fires immediately on first call', () => {
+    const fn = vi.fn();
+    const throttled = throttle(fn, 100);
+    throttled('a');
+    expect(fn).toHaveBeenCalledWith('a');
+  });
+
+  it('delays subsequent calls within the window', () => {
+    const fn = vi.fn();
+    const throttled = throttle(fn, 100);
+    throttled('a');
+    throttled('b');
+    expect(fn).toHaveBeenCalledTimes(1);
+    vi.advanceTimersByTime(100);
+    expect(fn).toHaveBeenCalledTimes(2);
+    expect(fn).toHaveBeenLastCalledWith('b');
+  });
+});
+
+
+describe('pipe', () => {
+  it('composes functions left-to-right', () => {
+    const add1 = x => x + 1;
+    const double = x => x * 2;
+    expect(pipe(add1, double)(3)).toBe(8);
+  });
+
+  it('handles a single function', () => {
+    const identity = x => x;
+    expect(pipe(identity)(42)).toBe(42);
+  });
+
+  it('handles no functions', () => {
+    expect(pipe()(10)).toBe(10);
+  });
+});
+
+
+describe('once', () => {
+  it('only calls function once', () => {
+    const fn = vi.fn(() => 42);
+    const onceFn = once(fn);
+    expect(onceFn()).toBe(42);
+    expect(onceFn()).toBe(42);
+    expect(fn).toHaveBeenCalledOnce();
+  });
+
+  it('passes arguments to the first call', () => {
+    const fn = vi.fn((a, b) => a + b);
+    const onceFn = once(fn);
+    expect(onceFn(1, 2)).toBe(3);
+    expect(onceFn(10, 20)).toBe(3);
+  });
+});
+
+
+describe('sleep', () => {
+  it('returns a promise that resolves after ms', async () => {
+    vi.useFakeTimers();
+    const p = sleep(100);
+    vi.advanceTimersByTime(100);
+    await expect(p).resolves.toBeUndefined();
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// String utilities
+// ---------------------------------------------------------------------------
+
+describe('escapeHtml', () => {
+  it('escapes &, <, >, ", \'', () => {
+    expect(escapeHtml('&<>"\'')).toBe('&amp;&lt;&gt;&quot;&#39;');
+  });
+
+  it('converts non-strings to string', () => {
+    expect(escapeHtml(42)).toBe('42');
+    expect(escapeHtml(null)).toBe('null');
+  });
+
+  it('handles empty string', () => {
+    expect(escapeHtml('')).toBe('');
+  });
+});
+
+
+describe('trust', () => {
+  it('returns a TrustedHTML instance', () => {
+    const t = trust('<b>bold</b>');
+    expect(t.toString()).toBe('<b>bold</b>');
+  });
+});
+
+
+describe('uuid', () => {
+  it('returns a string', () => {
+    expect(typeof uuid()).toBe('string');
+  });
+
+  it('returns different values on successive calls', () => {
+    const a = uuid();
+    const b = uuid();
+    expect(a).not.toBe(b);
+  });
+
+  it('has valid UUID v4 format', () => {
+    expect(uuid()).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/);
+  });
+});
+
+
+describe('camelCase', () => {
+  it('converts kebab-case to camelCase', () => {
+    expect(camelCase('my-component')).toBe('myComponent');
+    expect(camelCase('a-b-c')).toBe('aBC');
+  });
+
+  it('handles no hyphens', () => {
+    expect(camelCase('hello')).toBe('hello');
+  });
+});
+
+
+describe('kebabCase', () => {
+  it('converts camelCase to kebab-case', () => {
+    expect(kebabCase('myComponent')).toBe('my-component');
+    expect(kebabCase('fooBarBaz')).toBe('foo-bar-baz');
+  });
+
+  it('handles already kebab-case', () => {
+    expect(kebabCase('hello')).toBe('hello');
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// Object utilities
+// ---------------------------------------------------------------------------
+
+describe('deepClone', () => {
+  it('creates an independent copy', () => {
+    const obj = { a: 1, b: { c: 2 } };
+    const clone = deepClone(obj);
+    clone.b.c = 99;
+    expect(obj.b.c).toBe(2);
+  });
+
+  it('handles arrays', () => {
+    const arr = [1, [2, 3]];
+    const clone = deepClone(arr);
+    clone[1][0] = 99;
+    expect(arr[1][0]).toBe(2);
+  });
+});
+
+
+describe('deepMerge', () => {
+  it('deeply merges objects', () => {
+    const a = { x: 1, nested: { y: 2 } };
+    const b = { nested: { z: 3 }, w: 4 };
+    const result = deepMerge(a, b);
+    expect(result).toEqual({ x: 1, nested: { y: 2, z: 3 }, w: 4 });
+  });
+
+  it('overwrites non-object values', () => {
+    const result = deepMerge({ a: 1 }, { a: 2 });
+    expect(result.a).toBe(2);
+  });
+
+  it('handles arrays by replacing them', () => {
+    const result = deepMerge({ a: [1, 2] }, { a: [3, 4] });
+    expect(result.a).toEqual([3, 4]);
+  });
+});
+
+
+describe('isEqual', () => {
+  it('returns true for equal primitives', () => {
+    expect(isEqual(1, 1)).toBe(true);
+    expect(isEqual('a', 'a')).toBe(true);
+    expect(isEqual(null, null)).toBe(true);
+  });
+
+  it('returns false for different primitives', () => {
+    expect(isEqual(1, 2)).toBe(false);
+    expect(isEqual('a', 'b')).toBe(false);
+  });
+
+  it('returns true for deeply equal objects', () => {
+    expect(isEqual({ a: { b: 1 } }, { a: { b: 1 } })).toBe(true);
+  });
+
+  it('returns false for objects with different keys', () => {
+    expect(isEqual({ a: 1 }, { b: 1 })).toBe(false);
+  });
+
+  it('returns false for objects with different lengths', () => {
+    expect(isEqual({ a: 1 }, { a: 1, b: 2 })).toBe(false);
+  });
+
+  it('handles null comparisons', () => {
+    expect(isEqual(null, {})).toBe(false);
+    expect(isEqual({}, null)).toBe(false);
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// URL utilities
+// ---------------------------------------------------------------------------
+
+describe('param', () => {
+  it('serializes object to query string', () => {
+    expect(param({ a: '1', b: '2' })).toBe('a=1&b=2');
+  });
+
+  it('handles empty object', () => {
+    expect(param({})).toBe('');
+  });
+});
+
+
+describe('parseQuery', () => {
+  it('parses query string to object', () => {
+    expect(parseQuery('a=1&b=2')).toEqual({ a: '1', b: '2' });
+  });
+
+  it('handles leading ?', () => {
+    expect(parseQuery('?foo=bar')).toEqual({ foo: 'bar' });
+  });
+
+  it('handles empty string', () => {
+    expect(parseQuery('')).toEqual({});
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// Event bus
+// ---------------------------------------------------------------------------
+
+describe('bus (EventBus)', () => {
+  beforeEach(() => { bus.clear(); });
+
+  it('on/emit — fires handler for matching events', () => {
+    const fn = vi.fn();
+    bus.on('test', fn);
+    bus.emit('test', 42);
+    expect(fn).toHaveBeenCalledWith(42);
+  });
+
+  it('off — removes handler', () => {
+    const fn = vi.fn();
+    bus.on('test', fn);
+    bus.off('test', fn);
+    bus.emit('test');
+    expect(fn).not.toHaveBeenCalled();
+  });
+
+  it('on() returns unsubscribe function', () => {
+    const fn = vi.fn();
+    const unsub = bus.on('test', fn);
+    unsub();
+    bus.emit('test');
+    expect(fn).not.toHaveBeenCalled();
+  });
+
+  it('once — fires handler only once', () => {
+    const fn = vi.fn();
+    bus.once('test', fn);
+    bus.emit('test', 'a');
+    bus.emit('test', 'b');
+    expect(fn).toHaveBeenCalledOnce();
+    expect(fn).toHaveBeenCalledWith('a');
+  });
+
+  it('clear — removes all handlers', () => {
+    const fn = vi.fn();
+    bus.on('a', fn);
+    bus.on('b', fn);
+    bus.clear();
+    bus.emit('a');
+    bus.emit('b');
+    expect(fn).not.toHaveBeenCalled();
+  });
+
+  it('emit with no handlers does not throw', () => {
+    expect(() => bus.emit('nonexistent')).not.toThrow();
+  });
+});