@praxisjs/core 1.4.1 → 1.6.0

package/dist/signal/index.js

@@ -3,5 +3,6 @@ export { peek } from "./peek";
 export { signal } from "./signal";
 export { computed } from "./computed";
 export { persistedSignal } from "./persisted";
+export { syncedSignal } from "./synced";
 export { effect, untrack } from "./effect";
 //# sourceMappingURL=index.js.map

package/dist/signal/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/signal/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAA+B,eAAe,EAAE,MAAM,aAAa,CAAC;AAC3E,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/signal/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAA+B,eAAe,EAAE,MAAM,aAAa,CAAC;AAC3E,OAAO,EAAqB,YAAY,EAAE,MAAM,UAAU,CAAC;AAC3D,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC"}

package/dist/signal/signal.d.ts

@@ -1,3 +1,12 @@
 import type { Signal } from "@praxisjs/shared";
+import { type Effect } from "./effect";
+export type SubList = Effect | Effect[] | null;
+export declare function addSub(holder: {
+    subs: SubList;
+}, eff: Effect): void;
+export declare function removeSub(holder: {
+    subs: SubList;
+}, eff: Effect): void;
+export declare function notifySubs(subs: Exclude<SubList, null>, batching: boolean): void;
 export declare function signal<T>(initialValue: T): Signal<T>;
 //# sourceMappingURL=signal.d.ts.map

package/dist/signal/signal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"signal.d.ts","sourceRoot":"","sources":["../../src/signal/signal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAK/C,wBAAgB,MAAM,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAiDpD"}
+{"version":3,"file":"signal.d.ts","sourceRoot":"","sources":["../../src/signal/signal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAG/C,OAAO,EAAgB,KAAK,MAAM,EAAE,MAAM,UAAU,CAAC;AAErD,MAAM,MAAM,OAAO,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI,CAAC;AAE/C,wBAAgB,MAAM,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CASnE;AAED,wBAAgB,SAAS,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAStE;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,EAAE,QAAQ,EAAE,OAAO,GAAG,IAAI,CAoBhF;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CA4BpD"}

package/dist/signal/signal.js

@@ -1,50 +1,84 @@
 import { isBatching, enqueueEffect } from "./batch";
 import { activeEffect } from "./effect";
+export function addSub(holder, eff) {
+    const subs = holder.subs;
+    if (subs === null) {
+        holder.subs = eff;
+    }
+    else if (typeof subs === "function") {
+        if (subs !== eff)
+            holder.subs = [subs, eff];
+    }
+    else {
+        if (!subs.includes(eff))
+            subs.push(eff);
+    }
+}
+export function removeSub(holder, eff) {
+    const subs = holder.subs;
+    if (subs === null)
+        return;
+    if (typeof subs === "function") {
+        if (subs === eff)
+            holder.subs = null;
+    }
+    else {
+        const idx = subs.indexOf(eff);
+        if (idx >= 0)
+            subs.splice(idx, 1);
+    }
+}
+export function notifySubs(subs, batching) {
+    if (typeof subs === "function") {
+        if (batching)
+            enqueueEffect(subs);
+        else
+            subs();
+        return;
+    }
+    if (batching) {
+        for (const sub of subs)
+            enqueueEffect(sub);
+        return;
+    }
+    let lastError;
+    let hasError = false;
+    for (const sub of subs) {
+        try {
+            sub();
+        }
+        catch (e) {
+            lastError = e;
+            hasError = true;
+        }
+    }
+    if (hasError)
+        throw lastError;
+}
 export function signal(initialValue) {
     let value = initialValue;
-    const subscribers = new Set();
+    const holder = { subs: null };
     function read() {
-        if (activeEffect) {
-            subscribers.add(activeEffect);
-        }
+        if (activeEffect !== null)
+            addSub(holder, activeEffect);
         return value;
     }
-    function set(newValue) {
+    const s = read;
+    s.set = (newValue) => {
         if (Object.is(value, newValue))
             return;
         value = newValue;
-        if (isBatching()) {
-            [...subscribers].forEach((sub) => { enqueueEffect(sub); });
-            return;
-        }
-        const errors = [];
-        [...subscribers].forEach((sub) => {
-            try {
-                sub();
-            }
-            catch (e) {
-                errors.push(e);
-            }
-        });
-        if (errors.length > 0)
-            throw errors[errors.length - 1];
-    }
-    function update(fn) {
-        set(fn(value));
-    }
-    function subscribe(fn) {
-        const wrapped = () => {
-            fn(value);
-        };
-        subscribers.add(wrapped);
+        if (holder.subs !== null)
+            notifySubs(holder.subs, isBatching());
+    };
+    s.update = (fn) => { s.set(fn(value)); };
+    s.subscribe = (fn) => {
+        const wrapped = () => { fn(value); };
+        addSub(holder, wrapped);
         wrapped();
-        return () => subscribers.delete(wrapped);
-    }
-    const signal = read;
-    signal.set = set;
-    signal.update = update;
-    signal.subscribe = subscribe;
-    signal.__isSignal = true;
-    return signal;
+        return () => { removeSub(holder, wrapped); };
+    };
+    s.__isSignal = true;
+    return s;
 }
 //# sourceMappingURL=signal.js.map

package/dist/signal/signal.js.map

@@ -1 +1 @@
-{"version":3,"file":"signal.js","sourceRoot":"","sources":["../../src/signal/signal.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACpD,OAAO,EAAE,YAAY,EAAe,MAAM,UAAU,CAAC;AAErD,MAAM,UAAU,MAAM,CAAI,YAAe;IACvC,IAAI,KAAK,GAAG,YAAY,CAAC;IACzB,MAAM,WAAW,GAAG,IAAI,GAAG,EAAU,CAAC;IAEtC,SAAS,IAAI;QACX,IAAI,YAAY,EAAE,CAAC;YACjB,WAAW,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;QAChC,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,SAAS,GAAG,CAAC,QAAW;QACtB,IAAI,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,CAAC;YAAE,OAAO;QACvC,KAAK,GAAG,QAAQ,CAAC;QACjB,IAAI,UAAU,EAAE,EAAE,CAAC;YACjB,CAAC,GAAG,WAAW,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC3D,OAAO;QACT,CAAC;QACD,MAAM,MAAM,GAAc,EAAE,CAAC;QAC7B,CAAC,GAAG,WAAW,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE;YAC/B,IAAI,CAAC;gBACH,GAAG,EAAE,CAAC;YACR,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACX,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACjB,CAAC;QACH,CAAC,CAAC,CAAC;QACH,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC;YAAE,MAAM,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACzD,CAAC;IAED,SAAS,MAAM,CAAC,EAAkB;QAChC,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;IACjB,CAAC;IAED,SAAS,SAAS,CAAC,EAAsB;QACvC,MAAM,OAAO,GAAG,GAAG,EAAE;YACnB,EAAE,CAAC,KAAK,CAAC,CAAC;QACZ,CAAC,CAAC;QACF,WAAW,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QACzB,OAAO,EAAE,CAAC;QACV,OAAO,GAAG,EAAE,CAAC,WAAW,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAC3C,CAAC;IAED,MAAM,MAAM,GAAG,IAAiB,CAAC;IACjC,MAAM,CAAC,GAAG,GAAG,GAAG,CAAC;IACjB,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,MAAM,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7B,MAAM,CAAC,UAAU,GAAG,IAAI,CAAC;IAEzB,OAAO,MAAM,CAAC;AAChB,CAAC"}
+{"version":3,"file":"signal.js","sourceRoot":"","sources":["../../src/signal/signal.ts"],"names":[],"mappings":"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"}

package/dist/signal/synced.d.ts

@@ -0,0 +1,6 @@
+import type { Signal } from "@praxisjs/shared";
+export interface SyncedSignal<T> extends Signal<T> {
+    close(): void;
+}
+export declare function syncedSignal<T>(channelName: string, initialValue: T): SyncedSignal<T>;
+//# sourceMappingURL=synced.d.ts.map

package/dist/signal/synced.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"synced.d.ts","sourceRoot":"","sources":["../../src/signal/synced.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAI/C,MAAM,WAAW,YAAY,CAAC,CAAC,CAAE,SAAQ,MAAM,CAAC,CAAC,CAAC;IAChD,KAAK,IAAI,IAAI,CAAC;CACf;AAED,wBAAgB,YAAY,CAAC,CAAC,EAC5B,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,CAAC,GACd,YAAY,CAAC,CAAC,CAAC,CA4CjB"}

package/dist/signal/synced.js

@@ -0,0 +1,43 @@
+import { signal } from "./signal";
+export function syncedSignal(channelName, initialValue) {
+    const inner = signal(initialValue);
+    const channel = new BroadcastChannel(channelName);
+    let posting = false;
+    channel.onmessage = (event) => {
+        if (posting)
+            return;
+        try {
+            inner.set(JSON.parse(String(event.data)));
+        }
+        catch {
+            // ignore malformed messages
+        }
+    };
+    function read() {
+        return inner();
+    }
+    function set(value) {
+        posting = true;
+        try {
+            inner.set(value);
+            channel.postMessage(JSON.stringify(value));
+        }
+        finally {
+            posting = false;
+        }
+    }
+    function update(fn) {
+        set(fn(inner()));
+    }
+    function close() {
+        channel.close();
+    }
+    const source = read;
+    source.set = set;
+    source.update = update;
+    source.subscribe = inner.subscribe.bind(inner);
+    source.__isSignal = true;
+    source.close = close;
+    return source;
+}
+//# sourceMappingURL=synced.js.map

package/dist/signal/synced.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"synced.js","sourceRoot":"","sources":["../../src/signal/synced.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAMlC,MAAM,UAAU,YAAY,CAC1B,WAAmB,EACnB,YAAe;IAEf,MAAM,KAAK,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC;IACnC,MAAM,OAAO,GAAG,IAAI,gBAAgB,CAAC,WAAW,CAAC,CAAC;IAClD,IAAI,OAAO,GAAG,KAAK,CAAC;IAEpB,OAAO,CAAC,SAAS,GAAG,CAAC,KAAmB,EAAE,EAAE;QAC1C,IAAI,OAAO;YAAE,OAAO;QACpB,IAAI,CAAC;YACH,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAM,CAAC,CAAC;QACjD,CAAC;QAAC,MAAM,CAAC;YACP,4BAA4B;QAC9B,CAAC;IACH,CAAC,CAAC;IAEF,SAAS,IAAI;QACX,OAAO,KAAK,EAAE,CAAC;IACjB,CAAC;IAED,SAAS,GAAG,CAAC,KAAQ;QACnB,OAAO,GAAG,IAAI,CAAC;QACf,IAAI,CAAC;YACH,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;YACjB,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;QAC7C,CAAC;gBAAS,CAAC;YACT,OAAO,GAAG,KAAK,CAAC;QAClB,CAAC;IACH,CAAC;IAED,SAAS,MAAM,CAAC,EAAkB;QAChC,GAAG,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IACnB,CAAC;IAED,SAAS,KAAK;QACZ,OAAO,CAAC,KAAK,EAAE,CAAC;IAClB,CAAC;IAED,MAAM,MAAM,GAAG,IAAuB,CAAC;IACvC,MAAM,CAAC,GAAG,GAAG,GAAG,CAAC;IACjB,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,MAAM,CAAC,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC/C,MAAM,CAAC,UAAU,GAAG,IAAI,CAAC;IACzB,MAAM,CAAC,KAAK,GAAG,KAAK,CAAC;IAErB,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@praxisjs/core",
-  "version": "1.4.1",
+  "version": "1.6.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/__tests__/resource.test.ts

@@ -109,6 +109,48 @@ describe("createResource", () => {
   });
 });
 
+describe("resource — execute() sync throw via refetch()", () => {
+  it("refetch() captures a synchronous throw from the fetcher", async () => {
+    const r = resource(() => Promise.resolve(1), { immediate: false });
+    let calls = 0;
+    const r2 = resource(
+      () => {
+        calls++;
+        if (calls >= 2) throw new Error("sync in refetch");
+        return Promise.resolve(1);
+      },
+      { immediate: false },
+    );
+    r2.refetch(); // first call succeeds
+    await vi.waitFor(() => r2.status() === "success");
+    r2.refetch(); // second call throws synchronously
+    await vi.waitFor(() => r2.status() === "error");
+    expect((r2.error() as Error).message).toBe("sync in refetch");
+    void r;
+  });
+
+  it("refetch() wraps non-Error sync throws in Error", async () => {
+    let calls = 0;
+    const r = resource(
+      () => {
+        calls++;
+        if (calls >= 2) {
+          // eslint-disable-next-line @typescript-eslint/only-throw-error
+          throw "plain string sync";
+        }
+        return Promise.resolve(1);
+      },
+      { immediate: false },
+    );
+    r.refetch();
+    await vi.waitFor(() => r.status() === "success");
+    r.refetch();
+    await vi.waitFor(() => r.status() === "error");
+    expect(r.error()).toBeInstanceOf(Error);
+    expect((r.error() as Error).message).toBe("plain string sync");
+  });
+});
+
 describe("resource — additional cases", () => {
   it("two concurrent refetch() calls — last result wins, stale result is discarded", async () => {
     let resolveFirst!: (v: string) => void;

package/src/__tests__/synced.test.ts

@@ -0,0 +1,173 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+import { syncedSignal } from "../signal/synced";
+import { effect } from "../signal/effect";
+
+// BroadcastChannel mock
+class MockBroadcastChannel {
+  static instances: MockBroadcastChannel[] = [];
+  static byChannel: Map<string, MockBroadcastChannel[]> = new Map();
+
+  onmessage: ((event: MessageEvent) => void) | null = null;
+  readonly name: string;
+  closed = false;
+
+  constructor(name: string) {
+    this.name = name;
+    MockBroadcastChannel.instances.push(this);
+    if (!MockBroadcastChannel.byChannel.has(name)) {
+      MockBroadcastChannel.byChannel.set(name, []);
+    }
+    MockBroadcastChannel.byChannel.get(name)!.push(this);
+  }
+
+  postMessage(data: unknown) {
+    // Deliver to all OTHER instances on same channel
+    MockBroadcastChannel.byChannel.get(this.name)?.forEach((ch) => {
+      if (ch !== this && ch.onmessage) {
+        ch.onmessage(new MessageEvent("message", { data }));
+      }
+    });
+  }
+
+  close() {
+    this.closed = true;
+    const list = MockBroadcastChannel.byChannel.get(this.name);
+    if (list) {
+      const idx = list.indexOf(this);
+      if (idx !== -1) list.splice(idx, 1);
+    }
+    MockBroadcastChannel.instances.splice(
+      MockBroadcastChannel.instances.indexOf(this),
+      1,
+    );
+  }
+}
+
+beforeEach(() => {
+  MockBroadcastChannel.instances = [];
+  MockBroadcastChannel.byChannel = new Map();
+  vi.stubGlobal("BroadcastChannel", MockBroadcastChannel);
+});
+
+describe("syncedSignal", () => {
+  it("reads initial value", () => {
+    const s = syncedSignal("ch", 42);
+    expect(s()).toBe(42);
+    s.close();
+  });
+
+  it("set() updates the signal value", () => {
+    const s = syncedSignal("ch", 0);
+    s.set(10);
+    expect(s()).toBe(10);
+    s.close();
+  });
+
+  it("update() applies a transform", () => {
+    const s = syncedSignal("ch", 5);
+    s.update((v) => v * 2);
+    expect(s()).toBe(10);
+    s.close();
+  });
+
+  it("set() posts a JSON message to the channel", () => {
+    const s = syncedSignal("ch", 0);
+    const postSpy = vi.spyOn(
+      MockBroadcastChannel.instances[0],
+      "postMessage",
+    );
+    s.set(99);
+    expect(postSpy).toHaveBeenCalledWith(JSON.stringify(99));
+    s.close();
+  });
+
+  it("receiving a message from another tab updates the signal", () => {
+    const s = syncedSignal("ch", 0);
+    const channel = MockBroadcastChannel.instances[0];
+
+    channel.onmessage!(new MessageEvent("message", { data: JSON.stringify(7) }));
+    expect(s()).toBe(7);
+    s.close();
+  });
+
+  it("does not echo own set() back to itself", () => {
+    const s = syncedSignal("ch", 0);
+
+    // Simulate two instances on the same channel
+    const s2 = syncedSignal("ch", 0);
+    const received: number[] = [];
+    effect(() => { received.push(s2()); });
+
+    s.set(5);
+    // s2 should receive the message because it came from a different instance
+    expect(s2()).toBe(5);
+
+    // s itself should NOT trigger its own onmessage handler (no echo)
+    const channel = MockBroadcastChannel.instances[0];
+    const receivedBySelf: number[] = [];
+    effect(() => { receivedBySelf.push(s()); });
+    const beforeCount = receivedBySelf.length;
+    // Manually simulate echo — should be ignored because posting=false after set
+    channel.onmessage!(new MessageEvent("message", { data: JSON.stringify(5) }));
+    // The value stays 5 (no spurious extra notification tested via subscribe count)
+    expect(s()).toBe(5);
+    expect(receivedBySelf.length).toBe(beforeCount); // no extra effect run (Object.is equality)
+
+    s.close();
+    s2.close();
+  });
+
+  it("subscribe fires immediately then on each remote change", () => {
+    const s = syncedSignal("ch", 0);
+    const channel = MockBroadcastChannel.instances[0];
+    const received: number[] = [];
+    s.subscribe((v) => received.push(v));
+
+    expect(received).toEqual([0]);
+
+    channel.onmessage!(new MessageEvent("message", { data: JSON.stringify(3) }));
+    expect(received).toEqual([0, 3]);
+    s.close();
+  });
+
+  it("close() shuts down the BroadcastChannel", () => {
+    const s = syncedSignal("ch", 0);
+    const channel = MockBroadcastChannel.instances[0];
+    expect(channel.closed).toBe(false);
+    s.close();
+    expect(channel.closed).toBe(true);
+  });
+
+  it("has __isSignal marker", () => {
+    const s = syncedSignal("ch", 0);
+    expect(s.__isSignal).toBe(true);
+    s.close();
+  });
+
+  it("does not update value when onmessage fires while posting (posting guard)", () => {
+    // Use a self-delivering channel that echoes to itself during postMessage.
+    // This covers the `if (posting) return;` branch in synced.ts.
+    class SelfEchoChannel {
+      onmessage: ((e: MessageEvent) => void) | null = null;
+      postMessage(data: unknown) {
+        this.onmessage?.(new MessageEvent("message", { data }));
+      }
+      close() {}
+    }
+    vi.stubGlobal("BroadcastChannel", SelfEchoChannel);
+
+    const s = syncedSignal("echo-ch", 0);
+    const received: number[] = [];
+    s.subscribe((v) => received.push(v));
+
+    // set() triggers postMessage → onmessage fires → posting=true → early return
+    // Inner value should not be double-set
+    s.set(42);
+    expect(s()).toBe(42);
+    // Only two notifications: initial (0) + the set (42), no echo re-set
+    expect(received).toEqual([0, 42]);
+
+    s.close();
+  });
+});

package/src/internal.ts

@@ -8,12 +8,14 @@ export {
 export {
   signal,
   persistedSignal,
+  syncedSignal,
   peek,
   computed,
   batch,
   effect,
   untrack,
   type PersistedSignalOptions,
+  type SyncedSignal,
 } from "./signal";
 export { RootComponent } from "./component";
 export {

package/src/signal/batch.ts

@@ -1,27 +1,25 @@
 import type { Effect } from "./effect";
 
-let batchQueue: Set<Effect> | null = null;
+const batchEffects: Effect[] = [];
+let batchDepth = 0;
 
 export function isBatching(): boolean {
-  return batchQueue !== null;
+  return batchDepth > 0;
 }
 
 export function enqueueEffect(effect: Effect): void {
-  batchQueue?.add(effect);
+  if (!batchEffects.includes(effect)) batchEffects.push(effect);
 }
 
 export function batch(fn: () => void) {
-  const isOuter = batchQueue === null;
-  if (isOuter) {
-    batchQueue = new Set();
-  }
+  batchDepth++;
   try {
     fn();
   } finally {
-    if (isOuter) {
-      const effectsToRun = batchQueue ?? new Set<Effect>();
-      batchQueue = null;
-      effectsToRun.forEach((eff) => { eff(); });
+    if (--batchDepth === 0) {
+      const n = batchEffects.length;
+      for (let i = 0; i < n; i++) batchEffects[i]();
+      batchEffects.length = 0;
     }
   }
 }

package/src/signal/computed.ts

@@ -1,69 +1,72 @@
 import type { Computed } from "@praxisjs/shared";
 
 import { activeEffect, runEffect, type Effect } from "./effect";
+import { addSub, removeSub, notifySubs, type SubList } from "./signal";
 
 type ComputedRecompute = Effect & { __isComputedRecompute: true };
 
-export function computed<T>(computeFn: () => T): Computed<T> {
-  let cachedValue: T;
+function isComputedRecompute(eff: Effect): boolean {
+  return (eff as Partial<ComputedRecompute>).__isComputedRecompute === true;
+}
+
+export function computed<T>(getter: () => T): Computed<T> {
+  let cachedValue: T | undefined;
   let dirty = true;
-  const subscribers = new Set<Effect>();
+
+  const computedHolder = { subs: null as SubList };
+  const leafHolder = { subs: null as SubList };
   let scheduled = false;
 
-  const recompute: ComputedRecompute = Object.assign(
-    () => {
+  let recompute: ComputedRecompute | null = null;
+
+  function getRecompute(): ComputedRecompute {
+    if (recompute !== null) return recompute;
+    recompute = function markDirty(): void {
+      if (dirty) return;
       dirty = true;
-      for (const sub of [...subscribers]) {
-        if ((sub as Partial<ComputedRecompute>).__isComputedRecompute) {
-          sub(); // propagate dirty synchronously through computed chain
-        }
-      }
-      if (!scheduled) {
+      if (computedHolder.subs !== null) notifySubs(computedHolder.subs, false);
+      if (leafHolder.subs !== null && !scheduled) {
         scheduled = true;
         queueMicrotask(() => {
           scheduled = false;
-          for (const sub of [...subscribers]) {
-            if (!(sub as Partial<ComputedRecompute>).__isComputedRecompute) {
-              sub(); // notify leaf effects (DOM, @Watch, subscribe)
-            }
-          }
+          if (leafHolder.subs !== null) notifySubs(leafHolder.subs, false);
         });
       }
-    },
-    { __isComputedRecompute: true as const },
-  );
+    } as ComputedRecompute;
+    recompute.__isComputedRecompute = true;
+    return recompute;
+  }
 
-  function read() {
-    if (activeEffect) {
-      subscribers.add(activeEffect);
+  function read(): T {
+    if (activeEffect !== null) {
+      if (isComputedRecompute(activeEffect)) {
+        addSub(computedHolder, activeEffect);
+      } else {
+        addSub(leafHolder, activeEffect);
+      }
     }
-
     if (dirty) {
       const prevEffect = activeEffect;
-      runEffect(recompute);
+      runEffect(getRecompute());
       try {
-        cachedValue = computeFn();
+        cachedValue = getter();
         dirty = false;
       } finally {
         runEffect(prevEffect);
       }
     }
-
-    return cachedValue;
+    return cachedValue as T;
   }
 
-  function subscribe(fn: (value: T) => void) {
-    const wrappedEffect = () => {
-      fn(read());
-    };
-    subscribers.add(wrappedEffect);
-    wrappedEffect();
-    return () => subscribers.delete(wrappedEffect);
-  }
+  const c = read as Computed<T>;
 
-  const computedSignal = read as Computed<T>;
-  computedSignal.subscribe = subscribe;
-  computedSignal.__isComputed = true;
+  c.subscribe = (fn: (value: T) => void) => {
+    const wrapped: Effect = () => { fn(read()); };
+    addSub(leafHolder, wrapped);
+    wrapped();
+    return () => { removeSub(leafHolder, wrapped); };
+  };
 
-  return computedSignal;
+  c.__isComputed = true;
+  return c;
 }