zero-query 0.7.5 → 0.8.6

package/tests/expression.test.js

@@ -332,3 +332,151 @@ describe('expression parser — multi-scope', () => {
     expect(safeEval('y', [{ x: 1 }, { y: 2 }])).toBe(2);
   });
 });
+
+
+// ---------------------------------------------------------------------------
+// in operator
+// ---------------------------------------------------------------------------
+
+describe('expression parser — in operator', () => {
+  it('checks property existence', () => {
+    expect(eval_("'x' in obj", { obj: { x: 1 } })).toBe(true);
+    expect(eval_("'y' in obj", { obj: { x: 1 } })).toBe(false);
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// instanceof operator
+// ---------------------------------------------------------------------------
+
+describe('expression parser — instanceof', () => {
+  it('checks instanceOf', () => {
+    expect(eval_('arr instanceof Array', { arr: [1, 2] })).toBe(true);
+    expect(eval_('obj instanceof Array', { obj: {} })).toBe(false);
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// Nested ternary
+// ---------------------------------------------------------------------------
+
+describe('expression parser — nested ternary', () => {
+  it('evaluates simple ternary correctly', () => {
+    expect(eval_("x > 10 ? 'big' : 'small'", { x: 12 })).toBe('big');
+    expect(eval_("x > 10 ? 'big' : 'small'", { x: 2 })).toBe('small');
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// Chained method calls
+// ---------------------------------------------------------------------------
+
+describe('expression parser — chained calls', () => {
+  it('chains array methods', () => {
+    expect(eval_('items.filter(x => x > 1).map(x => x * 2)', { items: [1, 2, 3] })).toEqual([4, 6]);
+  });
+
+  it('chains string methods', () => {
+    expect(eval_("name.trim().toUpperCase()", { name: ' hello ' })).toBe('HELLO');
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// Spread operator
+// ---------------------------------------------------------------------------
+
+describe('expression parser — spread / rest', () => {
+  it('spread is not supported — returns gracefully', () => {
+    // The parser does not support spread syntax; verify it doesn't throw
+    const result = eval_('[...items, 4]', { items: [1, 2, 3] });
+    expect(result).toBeDefined();
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// Destructuring assignment in arrow body
+// ---------------------------------------------------------------------------
+
+describe('expression parser — complex arrow', () => {
+  it('arrow as callback in array method', () => {
+    const items = [{ n: 'a' }, { n: 'b' }];
+    expect(eval_('items.map(x => x.n)', { items })).toEqual(['a', 'b']);
+  });
+
+  it('arrow with ternary body', () => {
+    const fn = eval_('x => x > 0 ? "pos" : "neg"');
+    expect(fn(1)).toBe('pos');
+    expect(fn(-1)).toBe('neg');
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// Bitwise operators
+// ---------------------------------------------------------------------------
+
+describe('expression parser — bitwise', () => {
+  it('bitwise operators are not supported — does not throw', () => {
+    // The expression parser does not implement bitwise operators
+    // Verify graceful fallback rather than crashes
+    expect(() => eval_('5 | 3')).not.toThrow();
+    expect(() => eval_('5 & 3')).not.toThrow();
+    expect(() => eval_('5 ^ 3')).not.toThrow();
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// Comma expressions
+// ---------------------------------------------------------------------------
+
+describe('expression parser — comma', () => {
+  it('comma expressions are not supported — does not throw', () => {
+    // The parser does not support comma expressions
+    expect(() => eval_('(1, 2, 3)')).not.toThrow();
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// Edge cases
+// ---------------------------------------------------------------------------
+
+describe('expression parser — edge cases', () => {
+  it('handles very long dot chains', () => {
+    const data = { a: { b: { c: { d: { e: 42 } } } } };
+    expect(eval_('a.b.c.d.e', data)).toBe(42);
+  });
+
+  it('handles numeric string keys in bracket access', () => {
+    expect(eval_("items['0']", { items: ['a', 'b'] })).toBe('a');
+  });
+
+  it('handles conditional access chains', () => {
+    expect(eval_('a?.b?.c', { a: null })).toBe(undefined);
+    expect(eval_('a?.b?.c', { a: { b: { c: 1 } } })).toBe(1);
+  });
+
+  it('handles string with special characters', () => {
+    expect(eval_("'hello\\nworld'")).toContain('hello');
+  });
+
+  it('handles negative numbers in expressions', () => {
+    expect(eval_('-1 + -2')).toBe(-3);
+  });
+
+  it('exponentiation ** is not supported — does not throw', () => {
+    // The parser does not implement ** operator
+    expect(() => eval_('2 ** 3')).not.toThrow();
+  });
+
+  it('handles empty array/object', () => {
+    expect(eval_('[]')).toEqual([]);
+    expect(eval_('{}')).toEqual({});
+  });
+});

package/tests/http.test.js

@@ -179,3 +179,111 @@ describe('http — text response', () => {
     expect(result.data).toBe('Hello World');
   });
 });
+
+
+// ---------------------------------------------------------------------------
+// Interceptors
+// ---------------------------------------------------------------------------
+
+describe('http — interceptors', () => {
+  it('request interceptor via onRequest', async () => {
+    http.configure({ baseURL: '' });
+    http.onRequest((fetchOpts, url) => {
+      fetchOpts.headers['X-Custom'] = 'test';
+    });
+    mockFetch({});
+    await http.get('https://api.test.com/data');
+    const opts = fetchSpy.mock.calls[0][1];
+    expect(opts.headers['X-Custom']).toBe('test');
+  });
+
+  it('response interceptor via onResponse', async () => {
+    http.onResponse((result) => {
+      result.intercepted = true;
+    });
+    mockFetch({ x: 1 });
+    const result = await http.get('https://api.test.com/data');
+    expect(result.intercepted).toBe(true);
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// Timeout / abort
+// ---------------------------------------------------------------------------
+
+describe('http — abort signal', () => {
+  it('passes signal through options', async () => {
+    const controller = new AbortController();
+    mockFetch({});
+    await http.get('https://api.test.com/data', null, { signal: controller.signal });
+    const opts = fetchSpy.mock.calls[0][1];
+    expect(opts.signal).toBe(controller.signal);
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// Blob response
+// ---------------------------------------------------------------------------
+
+describe('http — blob response', () => {
+  it('can request blob responses', async () => {
+    mockFetch('binary data');
+    const result = await http.get('https://api.test.com/file', null, { responseType: 'blob' });
+    // Should have a data field (blob or fallback text)
+    expect(result.data).toBeDefined();
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// HEAD and OPTIONS methods
+// ---------------------------------------------------------------------------
+
+describe('http — raw fetch pass-through', () => {
+  it('raw() delegates to native fetch', async () => {
+    mockFetch({ ok: true });
+    await http.raw('https://api.test.com/ping', { method: 'HEAD' });
+    expect(fetchSpy).toHaveBeenCalledWith('https://api.test.com/ping', { method: 'HEAD' });
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// Request with custom headers
+// ---------------------------------------------------------------------------
+
+describe('http — custom per-request headers', () => {
+  it('merges per-request headers', async () => {
+    mockFetch({});
+    await http.get('https://api.test.com/data', null, {
+      headers: { 'X-Request-Id': '123' },
+    });
+    const opts = fetchSpy.mock.calls[0][1];
+    expect(opts.headers['X-Request-Id']).toBe('123');
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// Response metadata
+// ---------------------------------------------------------------------------
+
+describe('http — response metadata', () => {
+  it('includes status and ok in result', async () => {
+    mockFetch({ data: 'yes' }, true, 200);
+    const result = await http.get('https://api.test.com/data');
+    expect(result.ok).toBe(true);
+    expect(result.status).toBe(200);
+  });
+
+  it('includes statusText in error', async () => {
+    mockFetch({ error: 'bad' }, false, 500);
+    try {
+      await http.get('https://api.test.com/fail');
+    } catch (err) {
+      expect(err.message).toContain('500');
+    }
+  });
+});

package/tests/reactive.test.js

@@ -188,4 +188,152 @@ describe('effect()', () => {
       effect(() => { throw new Error('fail'); });
     }).not.toThrow();
   });
+
+  it('dispose stops re-running on signal change', () => {
+    const s = signal(0);
+    const log = vi.fn();
+    const dispose = effect(() => { log(s.value); });
+    expect(log).toHaveBeenCalledTimes(1);
+    dispose();
+    s.value = 1;
+    expect(log).toHaveBeenCalledTimes(1); // no additional call
+  });
+
+  it('dispose removes effect from signal subscribers', () => {
+    const s = signal(0);
+    const log = vi.fn();
+    const dispose = effect(() => { log(s.value); });
+    dispose();
+    // After disposing, the signal should not hold a reference to the effect
+    s.value = 99;
+    expect(log).toHaveBeenCalledTimes(1); // only the initial run
+  });
+
+  it('tracks multiple signals', () => {
+    const a = signal(1);
+    const b = signal(2);
+    const log = vi.fn();
+    effect(() => { log(a.value + b.value); });
+    expect(log).toHaveBeenCalledWith(3);
+    a.value = 10;
+    expect(log).toHaveBeenCalledWith(12);
+    b.value = 20;
+    expect(log).toHaveBeenCalledWith(30);
+    expect(log).toHaveBeenCalledTimes(3);
+  });
+
+  it('handles conditional dependency tracking', () => {
+    const toggle = signal(true);
+    const a = signal('A');
+    const b = signal('B');
+    const log = vi.fn();
+    effect(() => {
+      log(toggle.value ? a.value : b.value);
+    });
+    expect(log).toHaveBeenCalledWith('A');
+    // Change b — should NOT re-run because b is not tracked when toggle=true
+    b.value = 'B2';
+    // After toggle switches, b becomes tracked
+    toggle.value = false;
+    expect(log).toHaveBeenCalledWith('B2');
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// reactive — array mutations
+// ---------------------------------------------------------------------------
+
+describe('reactive — arrays', () => {
+  it('detects push on a reactive array', () => {
+    const fn = vi.fn();
+    const obj = reactive({ items: [1, 2, 3] }, fn);
+    obj.items.push(4);
+    expect(fn).toHaveBeenCalled();
+  });
+
+  it('detects index assignment', () => {
+    const fn = vi.fn();
+    const obj = reactive({ items: ['a', 'b'] }, fn);
+    obj.items[0] = 'z';
+    expect(fn).toHaveBeenCalledWith('0', 'z', 'a');
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// computed — advanced
+// ---------------------------------------------------------------------------
+
+describe('computed — advanced', () => {
+  it('chains computed signals', () => {
+    const count = signal(2);
+    const doubled = computed(() => count.value * 2);
+    const quadrupled = computed(() => doubled.value * 2);
+    expect(quadrupled.value).toBe(8);
+    count.value = 3;
+    expect(quadrupled.value).toBe(12);
+  });
+
+  it('does not recompute when dependencies unchanged (diamond)', () => {
+    const s = signal(1);
+    const a = computed(() => s.value + 1);
+    const b = computed(() => s.value + 2);
+    const spy = vi.fn(() => a.value + b.value);
+    const c = computed(spy);
+    expect(c.value).toBe(5); // (1+1)+(1+2)
+    spy.mockClear();
+    s.value = 10;
+    expect(c.value).toBe(23); // (10+1)+(10+2)
+  });
+
+  it('peek does not create dependency', () => {
+    const s = signal(0);
+    const log = vi.fn();
+    effect(() => {
+      log(s.peek());
+    });
+    expect(log).toHaveBeenCalledWith(0);
+    s.value = 1;
+    // peek doesn't track, so effect should NOT re-run
+    expect(log).toHaveBeenCalledTimes(1);
+  });
+});
+
+
+// ---------------------------------------------------------------------------
+// Signal — batch behavior
+// ---------------------------------------------------------------------------
+
+describe('Signal — multiple subscribers', () => {
+  it('notifies all subscribers', () => {
+    const s = signal(0);
+    const fn1 = vi.fn();
+    const fn2 = vi.fn();
+    s.subscribe(fn1);
+    s.subscribe(fn2);
+    s.value = 1;
+    expect(fn1).toHaveBeenCalledOnce();
+    expect(fn2).toHaveBeenCalledOnce();
+  });
+
+  it('unsubscribing one does not affect others', () => {
+    const s = signal(0);
+    const fn1 = vi.fn();
+    const fn2 = vi.fn();
+    const unsub1 = s.subscribe(fn1);
+    s.subscribe(fn2);
+    unsub1();
+    s.value = 1;
+    expect(fn1).not.toHaveBeenCalled();
+    expect(fn2).toHaveBeenCalledOnce();
+  });
+
+  it('handles rapid sequential updates', () => {
+    const s = signal(0);
+    const log = vi.fn();
+    s.subscribe(log);
+    for (let i = 1; i <= 10; i++) s.value = i;
+    expect(log).toHaveBeenCalledTimes(10);
+  });
 });