@praxisjs/core 0.4.2 → 1.1.0

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

@@ -148,4 +148,47 @@ describe("persistedSignal", () => {
     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

@@ -53,6 +53,13 @@ describe("when", () => {
     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 ----------
@@ -70,6 +77,15 @@ describe("until", () => {
     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 ----------
@@ -125,6 +141,22 @@ describe("debounced", () => {
     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 ----------
@@ -242,4 +274,31 @@ describe("history", () => {
     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.test.ts

@@ -73,6 +73,19 @@ describe("resource", () => {
     expect(r.status()).toBe("idle");
   });
 
+  it("cancel() before rejection ignores the stale error (catch stale path)", async () => {
+    let reject!: (e: Error) => void;
+    const r = resource(
+      () => new Promise<number>((_res, rej) => { reject = rej; }),
+    );
+    r.cancel();
+    expect(r.status()).toBe("idle");
+    reject(new Error("cancelled error"));
+    await new Promise((res) => setTimeout(res, 10));
+    expect(r.status()).toBe("idle");
+    expect(r.error()).toBeNull();
+  });
+
   it("keepPreviousData=true preserves old data during refetch", async () => {
     let call = 0;
     const r = resource(() => Promise.resolve(++call), { keepPreviousData: true });
@@ -95,3 +108,58 @@ describe("createResource", () => {
     expect(fetcher).toHaveBeenCalledTimes(2);
   });
 });
+
+describe("resource — additional cases", () => {
+  it("two concurrent refetch() calls — last result wins, stale result is discarded", async () => {
+    let resolveFirst!: (v: string) => void;
+    let resolveSecond!: (v: string) => void;
+
+    let call = 0;
+    const r = resource(
+      () => {
+        call++;
+        if (call === 1) return new Promise<string>((res) => { resolveFirst = res; });
+        return new Promise<string>((res) => { resolveSecond = res; });
+      },
+      { immediate: false },
+    );
+
+    r.refetch(); // call 1
+    r.refetch(); // call 2 — supersedes call 1
+
+    resolveSecond("second");
+    resolveFirst("first"); // stale
+
+    await vi.waitFor(() => r.status() === "success");
+    expect(r.data()).toBe("second");
+  });
+
+  it("fetcher() throws synchronously — error is captured, does not crash", async () => {
+    const r = resource(() => {
+      throw new Error("sync throw");
+    });
+    await vi.waitFor(() => r.status() === "error");
+    expect((r.error() as Error).message).toBe("sync throw");
+  });
+
+  it("keepPreviousData: true — data is preserved while refetching", async () => {
+    let call = 0;
+    let resolve!: (v: number) => void;
+    const r = resource(
+      () => {
+        call++;
+        if (call === 1) return Promise.resolve(1);
+        return new Promise<number>((res) => { resolve = res; });
+      },
+      { keepPreviousData: true },
+    );
+
+    await vi.waitFor(() => r.data() === 1);
+    r.refetch();
+    // During refetch with keepPreviousData, old data is preserved
+    expect(r.data()).toBe(1);
+    expect(r.status()).toBe("pending");
+    resolve(2);
+    await vi.waitFor(() => r.data() === 2);
+  });
+});

package/src/__tests__/signal.test.ts

@@ -106,4 +106,35 @@ describe("signal", () => {
     expect(a).toContain(7);
     expect(b).toContain(7);
   });
+
+  it("subscriber B still fires when subscriber A throws", () => {
+    const s = signal(0);
+    const received: number[] = [];
+    s.subscribe((v) => { if (v !== 0) throw new Error("sub A throws"); });
+    s.subscribe((v) => received.push(v));
+    expect(() => s.set(1)).toThrow("sub A throws");
+    expect(received).toContain(1);
+  });
+
+  it("unsubscribe during notification does not crash", () => {
+    const s = signal(0);
+    let unsub: (() => void) | undefined;
+    unsub = s.subscribe(() => {
+      unsub?.();
+    });
+    expect(() => s.set(1)).not.toThrow();
+  });
+
+  it("set() with mutated object reference (same ref) does NOT notify — Object.is semantics", () => {
+    const obj = { count: 0 };
+    const s = signal(obj);
+    const calls: unknown[] = [];
+    s.subscribe((v) => calls.push(v));
+    const before = calls.length;
+    // Mutate the object in-place and set the same reference
+    obj.count = 99;
+    s.set(obj);
+    // Object.is(obj, obj) === true, so no notification
+    expect(calls.length).toBe(before);
+  });
 });

package/src/async/resource.ts

@@ -59,12 +59,23 @@ export function resource<T>(
   }
 
   function execute() {
-    _execute(fetcher());
+    try {
+      _execute(fetcher());
+    } catch (err: unknown) {
+      _runId++;
+      _error.set(err instanceof Error ? err : new Error(String(err)));
+      _status.set("error");
+    }
   }
 
   if (immediate) {
     effect(() => {
-      _execute(fetcher());
+      try {
+        _execute(fetcher());
+      } catch (err: unknown) {
+        _error.set(err instanceof Error ? err : new Error(String(err)));
+        _status.set("error");
+      }
     });
   }
 

package/src/component/composable.ts

@@ -0,0 +1,5 @@
+export abstract class Composable {
+  abstract setup(): Record<string, unknown>;
+  onMount?(): void;
+  onUnmount?(): void;
+}

package/src/component/index.ts

@@ -1,3 +1,4 @@
 export { StatefulComponent } from "./stateful";
 export { StatelessComponent } from "./stateless";
 export { RootComponent } from "./base";
+export { Composable } from "./composable";

package/src/index.ts

@@ -1,8 +1 @@
-export { StatefulComponent, StatelessComponent } from "./component";
-export {
-  resource,
-  createResource,
-  type ResourceStatus,
-  type Resource,
-  type ResourceOptions,
-} from "./async/resource";
+export { StatefulComponent, StatelessComponent, Composable } from "./component";

package/src/internal.ts

@@ -15,3 +15,10 @@ export {
   type PersistedSignalOptions,
 } from "./signal";
 export { RootComponent } from "./component";
+export {
+  resource,
+  createResource,
+  type ResourceStatus,
+  type Resource,
+  type ResourceOptions,
+} from "./async/resource";

package/src/reactive/reactive.ts

@@ -43,14 +43,23 @@ export function debounced<T>(source: Signal<T> | Computed<T>, ms: number) {
   const current = signal<T>(source());
   let timeout: ReturnType<typeof setTimeout> | undefined;
 
-  effect(() => {
+  const stop = effect(() => {
     const value = source();
     if (timeout) clearTimeout(timeout);
     timeout = setTimeout(() => {
       current.set(value);
       timeout = undefined;
     }, ms);
+    return () => {
+      if (timeout) {
+        clearTimeout(timeout);
+        timeout = undefined;
+      }
+    };
   });
 
-  return current;
+  const debouncedSignal = current as Signal<T> & { stop: () => void };
+  debouncedSignal.stop = stop;
+
+  return debouncedSignal;
 }

package/src/signal/batch.ts

@@ -2,13 +2,26 @@ import type { Effect } from "./effect";
 
 let batchQueue: Set<Effect> | null = null;
 
+export function isBatching(): boolean {
+  return batchQueue !== null;
+}
+
+export function enqueueEffect(effect: Effect): void {
+  batchQueue?.add(effect);
+}
+
 export function batch(fn: () => void) {
-  batchQueue = new Set();
+  const isOuter = batchQueue === null;
+  if (isOuter) {
+    batchQueue = new Set();
+  }
   try {
     fn();
   } finally {
-    const effectsToRun = batchQueue;
-    batchQueue = null;
-    effectsToRun.forEach((eff) => { eff(); });
+    if (isOuter) {
+      const effectsToRun = batchQueue ?? new Set<Effect>();
+      batchQueue = null;
+      effectsToRun.forEach((eff) => { eff(); });
+    }
   }
 }

package/src/signal/computed.ts

@@ -22,9 +22,12 @@ export function computed<T>(computeFn: () => T): Computed<T> {
     if (dirty) {
       const prevEffect = activeEffect;
       runEffect(recompute);
-      cachedValue = computeFn();
-      dirty = false;
-      runEffect(prevEffect);
+      try {
+        cachedValue = computeFn();
+        dirty = false;
+      } finally {
+        runEffect(prevEffect);
+      }
     }
 
     return cachedValue;

package/src/signal/signal.ts

@@ -1,5 +1,6 @@
 import type { Signal } from "@praxisjs/shared";
 
+import { isBatching, enqueueEffect } from "./batch";
 import { activeEffect, type Effect } from "./effect";
 
 export function signal<T>(initialValue: T): Signal<T> {
@@ -16,9 +17,19 @@ export function signal<T>(initialValue: T): Signal<T> {
   function set(newValue: T) {
     if (Object.is(value, newValue)) return;
     value = newValue;
+    if (isBatching()) {
+      [...subscribers].forEach((sub) => { enqueueEffect(sub); });
+      return;
+    }
+    const errors: unknown[] = [];
     [...subscribers].forEach((sub) => {
-      sub();
+      try {
+        sub();
+      } catch (e) {
+        errors.push(e);
+      }
     });
+    if (errors.length > 0) throw errors[errors.length - 1];
   }
 
   function update(fn: (prev: T) => T) {