@praxisjs/core 1.0.0 → 1.2.0

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

@@ -108,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/index.ts

@@ -1 +1,2 @@
 export { StatefulComponent, StatelessComponent, Composable } from "./component";
+export { peek, untrack } from "./signal";

package/src/internal.ts

@@ -12,6 +12,7 @@ export {
   computed,
   batch,
   effect,
+  untrack,
   type PersistedSignalOptions,
 } from "./signal";
 export { RootComponent } from "./component";

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/effect.ts

@@ -19,6 +19,16 @@ export function runEffect(effect: Effect | null) {
   activeEffect = effect;
 }
 
+export function untrack<T>(fn: () => T): T {
+  const prev = activeEffect;
+  activeEffect = null;
+  try {
+    return fn();
+  } finally {
+    activeEffect = prev;
+  }
+}
+
 // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
 type Cleanup = (() => void) | void;
 

package/src/signal/index.ts

@@ -3,4 +3,4 @@ export { peek } from "./peek";
 export { signal } from "./signal";
 export { computed } from "./computed";
 export { type PersistedSignalOptions, persistedSignal } from "./persisted";
-export { effect } from "./effect";
+export { effect, untrack } from "./effect";

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) {