@praxisjs/core 2.1.0 → 2.3.0

package/src/__tests__/persisted-signal.test.ts

@@ -1,194 +0,0 @@
-// @vitest-environment jsdom
-import { describe, it, expect, beforeEach, vi } from "vitest";
-
-import { persistedSignal } from "../signal/persisted";
-
-beforeEach(() => {
-  localStorage.clear();
-});
-
-describe("persistedSignal", () => {
-  it("returns initialValue when nothing is stored", () => {
-    const s = persistedSignal("key1", 42);
-    expect(s()).toBe(42);
-  });
-
-  it("reads existing value from localStorage", () => {
-    localStorage.setItem("key2", "99");
-    const s = persistedSignal("key2", 0);
-    expect(s()).toBe(99);
-  });
-
-  it("persists set() to localStorage", () => {
-    const s = persistedSignal("key3", 0);
-    s.set(7);
-    expect(localStorage.getItem("key3")).toBe("7");
-    expect(s()).toBe(7);
-  });
-
-  it("persists update() to localStorage", () => {
-    const s = persistedSignal("key4", 10);
-    s.update((v) => v + 5);
-    expect(localStorage.getItem("key4")).toBe("15");
-    expect(s()).toBe(15);
-  });
-
-  it("removes the key when set to null", () => {
-    const s = persistedSignal<string | null>("key5", "hello");
-    s.set(null);
-    expect(localStorage.getItem("key5")).toBeNull();
-  });
-
-  it("marks __isSignal = true", () => {
-    const s = persistedSignal("key6", 0);
-    expect(s.__isSignal).toBe(true);
-  });
-
-  it("supports custom serialize/deserialize", () => {
-    const s = persistedSignal("key7", { x: 1 }, {
-      serialize: (v) => JSON.stringify(v),
-      deserialize: (raw) => JSON.parse(raw) as { x: number },
-    });
-    s.set({ x: 99 });
-    expect(localStorage.getItem("key7")).toBe('{"x":99}');
-    const s2 = persistedSignal("key7", { x: 0 }, {
-      serialize: JSON.stringify,
-      deserialize: (raw) => JSON.parse(raw) as { x: number },
-    });
-    expect(s2().x).toBe(99);
-  });
-
-  it("falls back to initialValue when deserialization fails", () => {
-    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-    localStorage.setItem("key8", "{ bad json");
-    const s = persistedSignal("key8", 42);
-    expect(s()).toBe(42);
-    warn.mockRestore();
-  });
-
-  it("syncs from storage event on other tab", () => {
-    const s = persistedSignal("key9", 1);
-    window.dispatchEvent(
-      new StorageEvent("storage", {
-        key: "key9",
-        newValue: "55",
-        storageArea: localStorage,
-      }),
-    );
-    expect(s()).toBe(55);
-  });
-
-  it("syncTabs=false does not add storage listener", () => {
-    const s = persistedSignal("key10", 1, { syncTabs: false });
-    s.set(5);
-    // Just verify it works without errors
-    expect(s()).toBe(5);
-  });
-
-  it("warns and falls back to initialValue when serialize throws on set", () => {
-    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-    const s = persistedSignal("key11", { x: 1 }, {
-      serialize: () => { throw new Error("serialize fail"); },
-      deserialize: JSON.parse as (v: string) => { x: number },
-    });
-    expect(() => s.set({ x: 2 })).not.toThrow();
-    expect(warn).toHaveBeenCalledWith(expect.stringContaining("Failed to serialize"), expect.any(Error));
-    warn.mockRestore();
-  });
-
-  it("syncs to initialValue when storage event has newValue=null (key removed)", () => {
-    const s = persistedSignal("key12", 42);
-    s.set(99);
-
-    window.dispatchEvent(
-      new StorageEvent("storage", {
-        key: "key12",
-        newValue: null, // key removed in another tab
-        storageArea: localStorage,
-      }),
-    );
-    expect(s()).toBe(42); // falls back to initialValue
-  });
-
-  it("warns and falls back to initialValue when storage event deserialization fails", () => {
-    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-    const s = persistedSignal("key13", 0, {
-      deserialize: () => { throw new Error("bad"); },
-    });
-
-    window.dispatchEvent(
-      new StorageEvent("storage", {
-        key: "key13",
-        newValue: "invalid",
-        storageArea: localStorage,
-      }),
-    );
-    expect(s()).toBe(0);
-    expect(warn).toHaveBeenCalledWith(
-      expect.stringContaining("Failed to deserialize"),
-      expect.any(Error),
-    );
-    warn.mockRestore();
-  });
-
-  it("ignores storage events from other keys", () => {
-    const s = persistedSignal("key14", 1);
-    window.dispatchEvent(
-      new StorageEvent("storage", {
-        key: "other-key",
-        newValue: "999",
-        storageArea: localStorage,
-      }),
-    );
-    expect(s()).toBe(1);
-  });
-
-  it("set(undefined) removes the key from localStorage", () => {
-    const s = persistedSignal<number | undefined>("key15", 5);
-    s.set(undefined);
-    expect(localStorage.getItem("key15")).toBeNull();
-  });
-
-  it("localStorage.setItem throws QuotaExceededError — signal state is updated but no crash", () => {
-    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-    const setItemSpy = vi.spyOn(Storage.prototype, "setItem").mockImplementation(() => {
-      const err = new DOMException("QuotaExceededError", "QuotaExceededError");
-      throw err;
-    });
-
-    const s = persistedSignal("key16", 0);
-    expect(() => s.set(42)).not.toThrow();
-    // The in-memory signal value is still updated despite storage failure
-    expect(s()).toBe(42);
-
-    setItemSpy.mockRestore();
-    warn.mockRestore();
-  });
-
-  it("syncTabs=true — storage event with empty string newValue is handled", () => {
-    const s = persistedSignal("key17", 99);
-    window.dispatchEvent(
-      new StorageEvent("storage", {
-        key: "key17",
-        newValue: "",
-        storageArea: localStorage,
-      }),
-    );
-    // Empty string is falsy, so falls back to initialValue
-    expect(s()).toBe(99);
-  });
-
-  it("syncTabs=true — storage event from sessionStorage is ignored", () => {
-    const s = persistedSignal("key18", 10);
-    s.set(20);
-    window.dispatchEvent(
-      new StorageEvent("storage", {
-        key: "key18",
-        newValue: "999",
-        storageArea: sessionStorage,
-      }),
-    );
-    // Should stay at 20 since the event is from sessionStorage, not localStorage
-    expect(s()).toBe(20);
-  });
-});

package/src/__tests__/reactive.test.ts

@@ -1,305 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-
-import { history } from "../reactive/history";
-import { when, until, debounced } from "../reactive/reactive";
-import { computed } from "../signal/computed";
-import { signal } from "../signal/signal";
-
-// ---------- when ----------
-
-describe("when", () => {
-  it("calls fn immediately when source is already truthy", () => {
-    const s = signal<number>(5);
-    const fn = vi.fn();
-    when(s, fn);
-    expect(fn).toHaveBeenCalledWith(5);
-  });
-
-  it("calls fn once the source becomes truthy", () => {
-    const s = signal<number>(0);
-    const fn = vi.fn();
-    when(s, fn);
-    expect(fn).not.toHaveBeenCalled();
-    s.set(1);
-    expect(fn).toHaveBeenCalledWith(1);
-  });
-
-  it("only fires once, even if source changes again", () => {
-    const s = signal(0);
-    const fn = vi.fn();
-    when(s, fn);
-    s.set(1);
-    s.set(2);
-    expect(fn).toHaveBeenCalledTimes(1);
-  });
-
-  it("does not re-fire after immediate truthy source changes again", () => {
-    // Regression: when source is truthy on first run, stop?.() was a no-op
-    // because `stop` hadn't been assigned yet. The effect must be cancelled
-    // after firing so further source changes do not re-trigger fn.
-    const s = signal(1); // immediately truthy
-    const fn = vi.fn();
-    when(s, fn);
-    expect(fn).toHaveBeenCalledTimes(1);
-    s.set(2);
-    s.set(3);
-    expect(fn).toHaveBeenCalledTimes(1); // must still be 1
-  });
-
-  it("does not call fn when source stays falsy", () => {
-    const s = signal<number>(0);
-    const fn = vi.fn();
-    when(s, fn);
-    s.set(0);
-    expect(fn).not.toHaveBeenCalled();
-  });
-
-  it("with source that fires immediately on subscription does not crash", () => {
-    const s = signal(1); // immediately truthy
-    const fn = vi.fn();
-    expect(() => when(s, fn)).not.toThrow();
-    expect(fn).toHaveBeenCalledWith(1);
-  });
-});
-
-// ---------- until ----------
-
-describe("until", () => {
-  it("resolves immediately when source is already truthy", async () => {
-    const s = signal(42);
-    const value = await until(s);
-    expect(value).toBe(42);
-  });
-
-  it("resolves when source becomes truthy", async () => {
-    const s = signal<number>(0);
-    const promise = until(s);
-    s.set(7);
-    expect(await promise).toBe(7);
-  });
-
-  it("the promise remains pending if source is always falsy (no-timeout behavior)", async () => {
-    const s = signal<number>(0);
-    let resolved = false;
-    until(s).then(() => { resolved = true; });
-    // Never set a truthy value
-    await new Promise((res) => setTimeout(res, 10));
-    expect(resolved).toBe(false);
-  });
-});
-
-// ---------- debounced ----------
-
-describe("debounced", () => {
-  it("returns initial value immediately", () => {
-    vi.useFakeTimers();
-    const s = signal(1);
-    const d = debounced(s, 100);
-    expect(d()).toBe(1);
-    vi.useRealTimers();
-  });
-
-  it("debounces rapid updates", () => {
-    vi.useFakeTimers();
-    const s = signal(1);
-    const d = debounced(s, 100);
-
-    s.set(2);
-    s.set(3);
-    s.set(4);
-
-    expect(d()).toBe(1); // not yet updated
-
-    vi.advanceTimersByTime(100);
-    expect(d()).toBe(4); // settled on last value
-    vi.useRealTimers();
-  });
-
-  it("emits each value when updates are spaced apart", () => {
-    vi.useFakeTimers();
-    const s = signal(0);
-    const d = debounced(s, 50);
-
-    s.set(1);
-    vi.advanceTimersByTime(50);
-    expect(d()).toBe(1);
-
-    s.set(2);
-    vi.advanceTimersByTime(50);
-    expect(d()).toBe(2);
-    vi.useRealTimers();
-  });
-
-  it("delay=0 fires synchronously after setTimeout(0)", () => {
-    vi.useFakeTimers();
-    const s = signal("a");
-    const d = debounced(s, 0);
-
-    s.set("b");
-    expect(d()).toBe("a"); // not yet
-    vi.advanceTimersByTime(0);
-    expect(d()).toBe("b");
-    vi.useRealTimers();
-  });
-
-  it("the inner effect is cleaned up when stop is called (no leak)", () => {
-    vi.useFakeTimers();
-    const s = signal(0);
-    const d = debounced(s, 100);
-
-    s.set(1);
-    // Stop the debounced effect before the timer fires
-    d.stop();
-
-    // Advance time — the timer should not fire and update the signal
-    vi.advanceTimersByTime(200);
-    expect(d()).toBe(0); // still initial value, effect was stopped
-
-    vi.useRealTimers();
-  });
-});
-
-// ---------- history ----------
-
-describe("history", () => {
-  it("current reflects signal value", () => {
-    const s = signal("a");
-    const h = history(s);
-    expect(h.current()).toBe("a");
-  });
-
-  it("canUndo is false initially", () => {
-    const s = signal(0);
-    const h = history(s);
-    expect(h.canUndo()).toBe(false);
-  });
-
-  it("canUndo becomes true after a change", () => {
-    const s = signal(0);
-    const h = history(s);
-    s.set(1);
-    expect(h.canUndo()).toBe(true);
-  });
-
-  it("undo reverts to previous value", () => {
-    const s = signal(0);
-    const h = history(s);
-    s.set(1);
-    s.set(2);
-    h.undo();
-    expect(h.current()).toBe(1);
-    expect(s()).toBe(1);
-  });
-
-  it("redo re-applies reverted value", () => {
-    const s = signal(0);
-    const h = history(s);
-    s.set(1);
-    h.undo();
-    expect(h.canRedo()).toBe(true);
-    h.redo();
-    expect(h.current()).toBe(1);
-    expect(s()).toBe(1);
-  });
-
-  it("values() returns full timeline", () => {
-    const s = signal("a");
-    const h = history(s);
-    s.set("b");
-    s.set("c");
-    expect(h.values()).toEqual(["a", "b", "c"]);
-  });
-
-  it("clear removes past and future", () => {
-    const s = signal(0);
-    const h = history(s);
-    s.set(1);
-    s.set(2);
-    h.clear();
-    expect(h.canUndo()).toBe(false);
-    expect(h.canRedo()).toBe(false);
-  });
-
-  it("undo does nothing when there is no history", () => {
-    const s = signal(5);
-    const h = history(s);
-    h.undo();
-    expect(h.current()).toBe(5);
-  });
-
-  it("redo does nothing when there is no future", () => {
-    const s = signal(5);
-    const h = history(s);
-    s.set(10);
-    h.redo();
-    expect(h.current()).toBe(10);
-  });
-
-  it("works with computed source (read-only — no signal.set)", async () => {
-    const s = signal(1);
-    const c = computed(() => s() * 2);
-    const h = history(c);
-    s.set(2);
-    await Promise.resolve();
-    expect(h.current()).toBe(4);
-    expect(h.canUndo()).toBe(true);
-  });
-
-  it("respects limit — oldest entries are dropped", () => {
-    const s = signal(0);
-    const h = history(s, 3);
-    for (let i = 1; i <= 5; i++) s.set(i);
-    // past holds at most 3, plus current = 4 values total
-    expect(h.values().length).toBeLessThanOrEqual(4);
-  });
-
-  it("limit=1 allows only one past entry", () => {
-    const s = signal(0);
-    const h = history(s, 1);
-    s.set(1);
-    s.set(2);
-    s.set(3);
-    // values = [past(1 entry max), current] → at most 2 entries
-    expect(h.values().length).toBeLessThanOrEqual(2);
-    expect(h.current()).toBe(3);
-  });
-
-  it("clear() after undo removes both past and future", () => {
-    const s = signal(0);
-    const h = history(s);
-    s.set(1);
-    s.set(2);
-    h.undo();
-    expect(h.canRedo()).toBe(true);
-    h.clear();
-    expect(h.canUndo()).toBe(false);
-    expect(h.canRedo()).toBe(false);
-  });
-
-  it("undo() called more times than history entries — state stays consistent", () => {
-    const s = signal(0);
-    const h = history(s);
-    s.set(1);
-    h.undo();
-    // No more history — undo is a no-op
-    h.undo();
-    h.undo();
-    expect(h.current()).toBe(0);
-    expect(h.canUndo()).toBe(false);
-  });
-
-  it("values() returns a snapshot — each call after source change yields a fresh array", () => {
-    const s = signal("a");
-    const h = history(s);
-    s.set("b");
-    s.set("c");
-    const snapshot1 = h.values();
-    expect(snapshot1).toEqual(["a", "b", "c"]);
-    // Trigger a change so the computed re-evaluates on next read
-    s.set("d");
-    const snapshot2 = h.values();
-    expect(snapshot2).toEqual(["a", "b", "c", "d"]);
-    // snapshot1 and snapshot2 are different array instances
-    expect(snapshot1).not.toBe(snapshot2);
-  });
-});

package/src/__tests__/resource-focus.test.ts

@@ -1,61 +0,0 @@
-// @vitest-environment jsdom
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-import { resource } from "../async/resource";
-import { _clearCache } from "../async/resource-cache";
-
-describe("resource — refetchOnFocus", () => {
-  beforeEach(() => { _clearCache(); });
-
-  it("refetches when document becomes visible", async () => {
-    let call = 0;
-    const fetcher = vi.fn(() => Promise.resolve(++call));
-    const r = resource(fetcher, { refetchOnFocus: true });
-    await vi.waitFor(() => r.status() === "success");
-    expect(fetcher).toHaveBeenCalledTimes(1);
-
-    Object.defineProperty(document, "visibilityState", {
-      configurable: true,
-      get: () => "visible",
-    });
-    document.dispatchEvent(new Event("visibilitychange"));
-
-    await vi.waitFor(() => r.data() === 2);
-    expect(fetcher).toHaveBeenCalledTimes(2);
-    r.destroy();
-  });
-
-  it("does not refetch when document becomes hidden", async () => {
-    const fetcher = vi.fn(() => Promise.resolve(1));
-    const r = resource(fetcher, { refetchOnFocus: true });
-    await vi.waitFor(() => r.status() === "success");
-
-    Object.defineProperty(document, "visibilityState", {
-      configurable: true,
-      get: () => "hidden",
-    });
-    document.dispatchEvent(new Event("visibilitychange"));
-    await new Promise((res) => setTimeout(res, 10));
-
-    expect(fetcher).toHaveBeenCalledTimes(1);
-    r.destroy();
-  });
-
-  it("destroy() removes the visibilitychange listener", async () => {
-    let call = 0;
-    const fetcher = vi.fn(() => Promise.resolve(++call));
-    const r = resource(fetcher, { refetchOnFocus: true });
-    await vi.waitFor(() => r.status() === "success");
-
-    r.destroy();
-
-    Object.defineProperty(document, "visibilityState", {
-      configurable: true,
-      get: () => "visible",
-    });
-    document.dispatchEvent(new Event("visibilitychange"));
-    await new Promise((res) => setTimeout(res, 10));
-
-    expect(fetcher).toHaveBeenCalledTimes(1); // no refetch after destroy
-  });
-});

package/src/__tests__/resource-server-pass.test.ts

@@ -1,90 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-
-import { flushPendingResources, resource } from "../async/resource";
-import { _clearCache, getPendingResources } from "../async/resource-cache";
-import { setServerRenderPass, isServerRenderPass } from "../async/server-mode";
-
-describe("server render pass — flushPendingResources", () => {
-  beforeEach(() => { _clearCache(); });
-  afterEach(() => { setServerRenderPass(false); });
-
-  it("is a no-op when no server pass is active", async () => {
-    setServerRenderPass(false);
-    const r = resource(() => new Promise<string>(() => {}));
-    expect(getPendingResources().size).toBe(0);
-    await flushPendingResources();
-    // Untouched — resource() never settled and flush didn't wait for it.
-    expect(r.status()).toBe("pending");
-  });
-
-  it("resolves immediately when nothing is pending", async () => {
-    setServerRenderPass(true);
-    await expect(flushPendingResources()).resolves.toBeUndefined();
-  });
-
-  it("tracks isServerRenderPass() state via the setter", () => {
-    expect(isServerRenderPass()).toBe(false);
-    setServerRenderPass(true);
-    expect(isServerRenderPass()).toBe(true);
-  });
-
-  it("awaits an unkeyed resource() (e.g. @Collection) before returning", async () => {
-    setServerRenderPass(true);
-    const r = resource(() => new Promise<string>((res) => { setTimeout(() => { res("content"); }, 5); }));
-    await flushPendingResources();
-    expect(r.status()).toBe("success");
-    expect(r.data()).toBe("content");
-  });
-
-  it("awaits a keyed resource() too", async () => {
-    setServerRenderPass(true);
-    const r = resource(() => Promise.resolve("keyed-value"), { key: "ssg-key" });
-    await flushPendingResources();
-    expect(r.status()).toBe("success");
-    expect(r.data()).toBe("keyed-value");
-  });
-
-  it("awaits multiple concurrently pending resources", async () => {
-    setServerRenderPass(true);
-    const r1 = resource(() => new Promise<number>((res) => { setTimeout(() => { res(1); }, 5); }));
-    const r2 = resource(() => new Promise<number>((res) => { setTimeout(() => { res(2); }, 10); }));
-    await flushPendingResources();
-    expect(r1.data()).toBe(1);
-    expect(r2.data()).toBe(2);
-  });
-
-  it("fixed-point loop: awaits a resource created while an earlier one settles", async () => {
-    setServerRenderPass(true);
-    let second: ReturnType<typeof resource> | undefined;
-
-    // Simulates a component that, upon its first resource resolving, creates a
-    // second resource (e.g. a detail page fetching related content) — the new
-    // promise must still be picked up even though it didn't exist yet when
-    // flushPendingResources() started its first pass.
-    const first = resource(() => new Promise<string>((res) => {
-      setTimeout(() => {
-        res("first");
-        second = resource(() => new Promise<string>((res2) => { setTimeout(() => { res2("second"); }, 5); }));
-      }, 5);
-    }));
-
-    await flushPendingResources();
-    expect(first.status()).toBe("success");
-    expect(second?.status()).toBe("success");
-    expect(second?.data()).toBe("second");
-  });
-
-  it("does not leave stale entries after resources settle", async () => {
-    setServerRenderPass(true);
-    resource(() => Promise.resolve("done"));
-    await flushPendingResources();
-    expect(getPendingResources().size).toBe(0);
-  });
-
-  it("a rejected resource does not hang the flush", async () => {
-    setServerRenderPass(true);
-    const r = resource(() => Promise.reject(new Error("boom")));
-    await expect(flushPendingResources()).resolves.toBeUndefined();
-    expect(r.status()).toBe("error");
-  });
-});