@praxisjs/core 2.1.0 → 2.3.0

package/src/__tests__/computed.test.ts

@@ -1,290 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-
-import { computed, writableComputed } from "../signal/computed";
-import { signal } from "../signal/signal";
-
-describe("computed", () => {
-  it("derives value from signal", () => {
-    const s = signal(4);
-    const doubled = computed(() => s() * 2);
-    expect(doubled()).toBe(8);
-  });
-
-  it("updates when source signal changes", () => {
-    const s = signal(3);
-    const triple = computed(() => s() * 3);
-    s.set(5);
-    expect(triple()).toBe(15);
-  });
-
-  it("is lazy — does not recompute until accessed", () => {
-    const s = signal(1);
-    const fn = vi.fn(() => s() + 1);
-    const c = computed(fn);
-    expect(fn).not.toHaveBeenCalled();
-    c();
-    expect(fn).toHaveBeenCalledOnce();
-  });
-
-  it("caches value between reads when source has not changed", () => {
-    const s = signal(2);
-    const fn = vi.fn(() => s() * 10);
-    const c = computed(fn);
-    c();
-    c();
-    expect(fn).toHaveBeenCalledOnce();
-  });
-
-  it("recomputes after source change", () => {
-    const s = signal(1);
-    const fn = vi.fn(() => s() + 100);
-    const c = computed(fn);
-    c();
-    s.set(2);
-    c();
-    expect(fn).toHaveBeenCalledTimes(2);
-  });
-
-  it("marks __isComputed = true", () => {
-    const c = computed(() => 42);
-    expect(c.__isComputed).toBe(true);
-  });
-
-  it("chained computed values update correctly", () => {
-    const s = signal(1);
-    const doubled = computed(() => s() * 2);
-    const quadrupled = computed(() => doubled() * 2);
-    expect(quadrupled()).toBe(4);
-    s.set(3);
-    expect(quadrupled()).toBe(12);
-  });
-
-  it("coalesces subscriber notifications when multiple dependencies change in the same tick", async () => {
-    const first = signal("John");
-    const last = signal("Doe");
-    const fullName = computed(() => `${first()} ${last()}`);
-
-    const calls: string[] = [];
-    fullName.subscribe((v) => calls.push(v));
-    expect(calls).toEqual(["John Doe"]); // immediate on subscribe
-
-    first.set("Jane");
-    last.set("Smith");
-    await Promise.resolve();
-
-    // Both changes in the same tick → single notification with final value
-    expect(calls).toEqual(["John Doe", "Jane Smith"]);
-  });
-
-  it("subscribe fires immediately with computed value", () => {
-    const s = signal(5);
-    const c = computed(() => s() + 1);
-    const received: number[] = [];
-    c.subscribe((v) => received.push(v));
-    expect(received).toEqual([6]);
-  });
-
-  it("subscribe fires when source changes", async () => {
-    const s = signal(0);
-    const c = computed(() => s() * 3);
-    const received: number[] = [];
-    c.subscribe((v) => received.push(v));
-    s.set(2);
-    await Promise.resolve();
-    s.set(4);
-    await Promise.resolve();
-    expect(received).toEqual([0, 6, 12]);
-  });
-
-  it("unsubscribe stops receiving updates", () => {
-    const s = signal(0);
-    const c = computed(() => s() + 1);
-    const received: number[] = [];
-    const unsub = c.subscribe((v) => received.push(v));
-    unsub();
-    s.set(10);
-    expect(received).toEqual([1]);
-  });
-
-  it("computeFn that throws propagates the error on read", () => {
-    const s = signal(true);
-    const c = computed(() => {
-      if (s()) throw new Error("compute error");
-      return 0;
-    });
-    expect(() => c()).toThrow("compute error");
-  });
-
-  it("dynamic dependency: switches tracked signal based on condition", () => {
-    const toggle = signal(true);
-    const a = signal(10);
-    const b = signal(20);
-    const c = computed(() => (toggle() ? a() : b()));
-
-    expect(c()).toBe(10);
-    a.set(11);
-    expect(c()).toBe(11);
-
-    toggle.set(false);
-    expect(c()).toBe(20);
-    b.set(21);
-    expect(c()).toBe(21);
-  });
-
-  it("dynamic dependency: stale branch changes do not dirty the computed", () => {
-    const toggle = signal(true);
-    const a = signal(10);
-    const b = signal(20);
-    const fn = vi.fn(() => (toggle() ? a() : b()));
-    const c = computed(fn);
-
-    expect(c()).toBe(10);
-    toggle.set(false);
-    expect(c()).toBe(20);
-    expect(fn).toHaveBeenCalledTimes(2);
-
-    a.set(11);
-    expect(c()).toBe(20);
-    expect(fn).toHaveBeenCalledTimes(2);
-
-    b.set(21);
-    expect(c()).toBe(21);
-    expect(fn).toHaveBeenCalledTimes(3);
-  });
-
-  it("unsubscribe then re-subscribe works correctly", async () => {
-    const s = signal(1);
-    const c = computed(() => s() * 3);
-    const received: number[] = [];
-
-    const unsub = c.subscribe((v) => received.push(v));
-    unsub();
-
-    // Re-subscribe
-    c.subscribe((v) => received.push(v));
-    s.set(2);
-    await Promise.resolve();
-    expect(received).toContain(6);
-  });
-
-  it("dirty remains true after computeFn throws — next read recomputes instead of returning stale cache", () => {
-    const s = signal(true);
-    const fn = vi.fn(() => {
-      if (s()) throw new Error("compute error");
-      return 42;
-    });
-    const c = computed(fn);
-    // First read — throws, dirty stays true
-    expect(() => c()).toThrow("compute error");
-    expect(fn).toHaveBeenCalledTimes(1);
-    // Second read while still throwing — must recompute, not return stale
-    expect(() => c()).toThrow("compute error");
-    expect(fn).toHaveBeenCalledTimes(2);
-    // Fix the source and read — should now succeed
-    s.set(false);
-    expect(c()).toBe(42);
-    expect(fn).toHaveBeenCalledTimes(3);
-  });
-
-  it("circular dependency between two computed values throws or does not hang", () => {
-    // This test documents behavior: circular deps must not cause infinite loops
-    // We use a signal to break potential infinite recursion via dirty flag
-    const s = signal(0);
-    let aVal = 0;
-    let bVal = 0;
-    const a: ReturnType<typeof computed<number>> = computed(() => {
-      s(); // track signal to make dirty
-      return bVal + 1;
-    });
-    const b: ReturnType<typeof computed<number>> = computed(() => {
-      s(); // track signal to make dirty
-      return aVal + 1;
-    });
-    // Manually reading without cross-dependency reads to avoid true circularity
-    aVal = a();
-    bVal = b();
-    expect(aVal).toBeGreaterThanOrEqual(1);
-    expect(bVal).toBeGreaterThanOrEqual(1);
-  });
-
-  it("microtask guard: skips notifySubs when leaf subscriber unsubscribes before microtask fires", async () => {
-    const s = signal(0);
-    const c = computed(() => s() * 2);
-    const results: number[] = [];
-    const unsub = c.subscribe((v) => results.push(v));
-    // results = [0]
-
-    s.set(1); // markDirty: queues microtask (scheduled = true)
-    unsub();  // removes leaf subscriber BEFORE microtask fires → leafHolder.subs = null
-
-    await Promise.resolve(); // microtask: if (leafHolder.subs !== null) → FALSE → no notify
-    expect(results).toEqual([0]); // no update received after unsubscribe
-  });
-
-  it("skips re-scheduling leaf notification when already scheduled (!scheduled false branch)", async () => {
-    const s = signal(0);
-    const c = computed(() => s() * 2);
-    const results: number[] = [];
-    c.subscribe((v) => results.push(v));
-    // results = [0] after initial subscribe
-
-    s.set(1); // markDirty: scheduled = true, microtask queued
-    c();      // re-computes: dirty = false (scheduled still true)
-    s.set(2); // markDirty: dirty=false → proceeds, but !scheduled is false → no second microtask
-
-    await Promise.resolve(); // microtask runs, subscriber notified with current value
-    expect(results).toContain(4); // 2 * 2
-  });
-
-  it("double unsubscribe on computed does not crash", () => {
-    const s = signal(1);
-    const c = computed(() => s() + 1);
-    const unsub = c.subscribe(() => {});
-    expect(() => {
-      unsub();
-      unsub();
-    }).not.toThrow();
-  });
-});
-
-describe("writableComputed", () => {
-  it("read returns the getter value", () => {
-    const s = signal(5);
-    const wc = writableComputed(() => s() * 2, (_v) => { /* no-op */ });
-    expect(wc()).toBe(10);
-  });
-
-  it("set calls the setter", () => {
-    const s = signal(0);
-    const wc = writableComputed(() => s(), (v) => { s.set(v); });
-    wc.set(42);
-    expect(s()).toBe(42);
-    expect(wc()).toBe(42);
-  });
-
-  it("update applies the updater and calls the setter", () => {
-    const s = signal(10);
-    const wc = writableComputed(() => s(), (v) => { s.set(v); });
-    wc.update((current) => current + 5);
-    expect(s()).toBe(15);
-    expect(wc()).toBe(15);
-  });
-
-  it("marks __isWritableComputed = true", () => {
-    const wc = writableComputed(() => 1, (_v) => { /* no-op */ });
-    expect(wc.__isWritableComputed).toBe(true);
-  });
-
-  it("inherits __isComputed = true from computed", () => {
-    const wc = writableComputed(() => 1, (_v) => { /* no-op */ });
-    expect(wc.__isComputed).toBe(true);
-  });
-
-  it("recomputes when underlying signal changes", () => {
-    const s = signal(3);
-    const wc = writableComputed(() => s() * 2, (_v) => { /* no-op */ });
-    expect(wc()).toBe(6);
-    s.set(7);
-    expect(wc()).toBe(14);
-  });
-});

package/src/__tests__/effect.test.ts

@@ -1,226 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-
-import {
-  effect,
-  track,
-  activeEffect,
-  cleanupEffectDeps,
-  recordDependency,
-  type SubscriberHolder,
-} from "../signal/effect";
-import { batch } from "../signal/batch";
-import { signal } from "../signal/signal";
-
-describe("effect", () => {
-  it("runs immediately on creation", () => {
-    const ran = vi.fn();
-    effect(ran);
-    expect(ran).toHaveBeenCalledOnce();
-  });
-
-  it("re-runs when a tracked signal changes", () => {
-    const s = signal(1);
-    const values: number[] = [];
-    effect(() => {
-      values.push(s());
-    });
-    s.set(2);
-    s.set(3);
-    expect(values).toEqual([1, 2, 3]);
-  });
-
-  it("stop() calls the cleanup function", () => {
-    const cleanupFn = vi.fn();
-    const stop = effect(() => cleanupFn);
-    stop();
-    expect(cleanupFn).toHaveBeenCalledOnce();
-  });
-
-  it("calls cleanup function before re-run", () => {
-    const s = signal(0);
-    const order: string[] = [];
-    effect(() => {
-      const v = s();
-      order.push(`run:${v}`);
-      return () => order.push(`cleanup`);
-    });
-    s.set(1);
-    expect(order).toEqual(["run:0", "cleanup", "run:1"]);
-  });
-
-  it("tracks multiple signals", () => {
-    const a = signal(1);
-    const b = signal(10);
-    const sums: number[] = [];
-    effect(() => {
-      sums.push(a() + b());
-    });
-    a.set(2);
-    b.set(20);
-    expect(sums).toEqual([11, 12, 22]);
-  });
-
-  it("stop() prevents future re-runs", () => {
-    const s = signal(0);
-    const values: number[] = [];
-    const stop = effect(() => {
-      values.push(s());
-    });
-    stop();
-    s.set(99);
-    expect(values).toEqual([0]); // only initial run
-  });
-
-  it("drops dependencies that are no longer read", () => {
-    const useA = signal(true);
-    const a = signal(1);
-    const b = signal(10);
-    const values: number[] = [];
-
-    effect(() => {
-      values.push(useA() ? a() : b());
-    });
-
-    useA.set(false);
-    expect(values).toEqual([1, 10]);
-
-    a.set(2);
-    expect(values).toEqual([1, 10]);
-
-    b.set(20);
-    expect(values).toEqual([1, 10, 20]);
-  });
-
-  it("does not skip other subscribers when one effect changes subscriptions while notifying", () => {
-    const useOther = signal(false);
-    const source = signal(0);
-    const other = signal(100);
-    const first = vi.fn();
-    const second = vi.fn();
-
-    effect(() => {
-      first(useOther() ? other() : source());
-    });
-    effect(() => {
-      second(source());
-    });
-
-    useOther.set(true);
-    first.mockClear();
-    second.mockClear();
-
-    source.set(1);
-
-    expect(first).not.toHaveBeenCalled();
-    expect(second).toHaveBeenCalledWith(1);
-  });
-
-  it("effect with no reactive dependencies runs once only", () => {
-    const ran = vi.fn();
-    effect(() => {
-      ran(); // no signal reads
-    });
-    expect(ran).toHaveBeenCalledTimes(1);
-    // No signal changes possible — just verify it doesn't re-run spontaneously
-    expect(ran).toHaveBeenCalledTimes(1);
-  });
-
-  it("stop() with no cleanup function does not throw", () => {
-    const stop = effect(() => { /* no return value */ });
-    expect(() => stop()).not.toThrow();
-  });
-
-  it("cleanup is re-invoked before each re-run", () => {
-    const s = signal(0);
-    const cleanupCount = { n: 0 };
-    effect(() => {
-      s(); // track
-      return () => { cleanupCount.n++; };
-    });
-    s.set(1);
-    s.set(2);
-    // cleanup called once before second run, once before third run
-    expect(cleanupCount.n).toBe(2);
-  });
-
-  it("stop() called multiple times does not crash or double-clean", () => {
-    const cleanupFn = vi.fn();
-    const stop = effect(() => cleanupFn);
-    expect(() => {
-      stop();
-      stop();
-      stop();
-    }).not.toThrow();
-    // cleanup is only called once (on first stop)
-    expect(cleanupFn).toHaveBeenCalledTimes(1);
-  });
-
-  it("ignores a queued run after the effect was stopped", () => {
-    const s = signal(0);
-    const values: number[] = [];
-    const stop = effect(() => {
-      values.push(s());
-    });
-
-    batch(() => {
-      s.set(1);
-      stop();
-    });
-
-    expect(values).toEqual([0]);
-  });
-
-  it("cleanupEffectDeps handles empty, single, and array dependency holders", () => {
-    const tracked = vi.fn();
-    const other = vi.fn();
-    const emptyHolder: SubscriberHolder = { subs: null };
-    const singleHolder: SubscriberHolder = { subs: tracked };
-    const arrayHolder: SubscriberHolder = { subs: [tracked, other] };
-    const unmatchedSingleHolder: SubscriberHolder = { subs: other };
-    const unmatchedArrayHolder: SubscriberHolder = { subs: [other] };
-
-    recordDependency(tracked, emptyHolder);
-    recordDependency(tracked, singleHolder);
-    recordDependency(tracked, arrayHolder);
-    recordDependency(tracked, unmatchedSingleHolder);
-    recordDependency(tracked, unmatchedArrayHolder);
-
-    cleanupEffectDeps(tracked);
-
-    expect(emptyHolder.subs).toBeNull();
-    expect(singleHolder.subs).toBeNull();
-    expect(arrayHolder.subs).toEqual([other]);
-    expect(unmatchedSingleHolder.subs).toBe(other);
-    expect(unmatchedArrayHolder.subs).toEqual([other]);
-  });
-
-  it("exception inside nested track() restores outer activeEffect", () => {
-    const s = signal(0);
-    const outer = vi.fn();
-    let outerEffectRef: unknown;
-
-    effect(() => {
-      outer();
-      s(); // track
-      outerEffectRef = activeEffect;
-    });
-
-    // Now do a track that throws — outer activeEffect must be restored
-    try {
-      track(() => { throw new Error("inner throws"); });
-    } catch {
-      // expected
-    }
-
-    expect(activeEffect).toBeNull();
-  });
-
-  it("activeEffect is null after a track() that throws", () => {
-    try {
-      track(() => { throw new Error("boom"); });
-    } catch {
-      // expected
-    }
-    expect(activeEffect).toBeNull();
-  });
-});

package/src/__tests__/peek.test.ts

@@ -1,31 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import { computed } from "../signal/computed";
-import { effect } from "../signal/effect";
-import { peek } from "../signal/peek";
-import { signal } from "../signal/signal";
-
-describe("peek", () => {
-  it("returns the current value without tracking", () => {
-    const s = signal(42);
-    expect(peek(s)).toBe(42);
-  });
-
-  it("does not subscribe the active effect when peeked", () => {
-    const s = signal(1);
-    const runs: number[] = [];
-
-    effect(() => {
-      runs.push(peek(s)); // peek — should not subscribe
-    });
-
-    s.set(99); // should NOT trigger re-run
-    expect(runs).toEqual([1]);
-  });
-
-  it("works with computed values", () => {
-    const s = signal(5);
-    const c = computed(() => s() * 2);
-    expect(peek(c)).toBe(10);
-  });
-});