@praxisjs/core 2.2.0 → 2.3.0

package/src/__tests__/signal.test.ts

@@ -1,291 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import { batch } from "../signal/batch";
-import { SUBS_SET_THRESHOLD } from "../signal/effect";
-import { effect } from "../signal/effect";
-import { signal, addSub, removeSub, type SubList } from "../signal/signal";
-import type { Effect } from "../signal/effect";
-
-describe("signal", () => {
-  it("returns initial value", () => {
-    const s = signal(42);
-    expect(s()).toBe(42);
-  });
-
-  it("updates value with set", () => {
-    const s = signal(0);
-    s.set(10);
-    expect(s()).toBe(10);
-  });
-
-  it("updates value with update fn", () => {
-    const s = signal(5);
-    s.update((v) => v * 2);
-    expect(s()).toBe(10);
-  });
-
-  it("skips update when value is identical", () => {
-    const s = signal(1);
-    const calls: number[] = [];
-    s.subscribe((v) => calls.push(v));
-    const before = calls.length;
-    s.set(1); // same value
-    expect(calls.length).toBe(before);
-  });
-
-  it("subscribe fires immediately with current value", () => {
-    const s = signal("hello");
-    const received: string[] = [];
-    s.subscribe((v) => received.push(v));
-    expect(received).toEqual(["hello"]);
-  });
-
-  it("subscribe fires on subsequent updates", () => {
-    const s = signal(0);
-    const received: number[] = [];
-    s.subscribe((v) => received.push(v));
-    s.set(1);
-    s.set(2);
-    expect(received).toEqual([0, 1, 2]);
-  });
-
-  it("unsubscribe stops receiving updates", () => {
-    const s = signal(0);
-    const received: number[] = [];
-    const unsub = s.subscribe((v) => received.push(v));
-    unsub();
-    s.set(99);
-    expect(received).toEqual([0]);
-  });
-
-  it("marks __isSignal = true", () => {
-    const s = signal(0);
-    expect(s.__isSignal).toBe(true);
-  });
-
-  it("supports object values", () => {
-    const s = signal<{ name: string }>({ name: "Alice" });
-    s.set({ name: "Bob" });
-    expect(s().name).toBe("Bob");
-  });
-
-  it("supports null and undefined", () => {
-    const s = signal<null | number>(null);
-    expect(s()).toBeNull();
-    s.set(5);
-    expect(s()).toBe(5);
-  });
-
-  it("NaN is considered equal to NaN — no notification", () => {
-    const s = signal(NaN);
-    const calls: unknown[] = [];
-    s.subscribe((v) => calls.push(v));
-    const before = calls.length;
-    s.set(NaN);
-    expect(calls.length).toBe(before);
-  });
-
-  it("-0 and +0 are considered different — notification fires", () => {
-    const s = signal<number>(-0);
-    const calls: number[] = [];
-    s.subscribe((v) => calls.push(v));
-    const before = calls.length;
-    s.set(+0);
-    expect(calls.length).toBe(before + 1);
-  });
-
-  it("update() fn that throws does not update the value", () => {
-    const s = signal(5);
-    expect(() => s.update(() => { throw new Error("fn error"); })).toThrow("fn error");
-    expect(s()).toBe(5);
-  });
-
-  it("multiple subscribers all receive the update", () => {
-    const s = signal(0);
-    const a: number[] = [];
-    const b: number[] = [];
-    s.subscribe((v) => a.push(v));
-    s.subscribe((v) => b.push(v));
-    s.set(7);
-    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("unsubscribing one of multiple subscribers removes only that subscriber", () => {
-    const s = signal(0);
-    const a: number[] = [];
-    const b: number[] = [];
-    const unsubA = s.subscribe((v) => a.push(v));
-    s.subscribe((v) => b.push(v));
-    // subs is now an array — hits removeSub else branch
-    unsubA();
-    s.set(1);
-    expect(a).toEqual([0]); // A stopped after initial fire
-    expect(b).toEqual([0, 1]); // B still receives
-  });
-
-  it("unsubscribing a non-existent subscriber from array subs is a no-op", () => {
-    const s = signal(0);
-    const a: number[] = [];
-    const b: number[] = [];
-    s.subscribe((v) => a.push(v));
-    const unsubB = s.subscribe((v) => b.push(v));
-    unsubB(); // remove B, subs becomes array without B
-    unsubB(); // call again — idx will be -1, splice not called
-    expect(() => s.set(1)).not.toThrow();
-    expect(a).toContain(1);
-  });
-
-  it("batch defers notifications for multiple array subscribers", () => {
-    const s = signal(0);
-    const a: number[] = [];
-    const b: number[] = [];
-    s.subscribe((v) => a.push(v));
-    s.subscribe((v) => b.push(v));
-    // subs is an array; inside batch, notifySubs hits the batching=true array path
-    batch(() => {
-      s.set(1);
-      expect(a).toEqual([0]); // not yet fired
-      expect(b).toEqual([0]);
-    });
-    expect(a).toContain(1);
-    expect(b).toContain(1);
-  });
-
-  it("removeSub with non-matching single-function subscriber is a no-op", () => {
-    // When subs is a single function and we try to remove a different function,
-    // the holder must remain unchanged (subs !== eff → false branch).
-    const holder: { subs: SubList } = { subs: null };
-    const fn1: Effect = () => {};
-    const fn2: Effect = () => {};
-    addSub(holder, fn1); // subs = fn1 (single function)
-    removeSub(holder, fn2); // fn2 !== fn1 → no-op
-    expect(holder.subs).toBe(fn1);
-  });
-
-  it("addSub does not add a duplicate subscriber to an array holder", () => {
-    const fn1: Effect = () => {};
-    const fn2: Effect = () => {};
-    const holder: { subs: SubList } = { subs: [fn1, fn2] };
-
-    addSub(holder, fn2);
-
-    expect(holder.subs).toEqual([fn1, fn2]);
-  });
-
-  it("removeSub normalizes an emptied array holder back to null", () => {
-    const fn: Effect = () => {};
-    const holder: { subs: SubList } = { subs: [fn] };
-
-    removeSub(holder, fn);
-
-    expect(holder.subs).toBeNull();
-  });
-
-  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);
-  });
-});
-
-describe("large subscriber lists", () => {
-  function fns(count: number): Array<() => void> {
-    return Array.from({ length: count }, () => () => {});
-  }
-
-  it("keeps an array up to the threshold and promotes to a Set past it, preserving order", () => {
-    const holder: { subs: SubList } = { subs: null };
-    const list = fns(SUBS_SET_THRESHOLD);
-    for (const fn of list) addSub(holder, fn);
-    expect(Array.isArray(holder.subs)).toBe(true);
-
-    const extra = () => {};
-    addSub(holder, extra);
-    expect(holder.subs).toBeInstanceOf(Set);
-    expect([...(holder.subs as Set<() => void>)]).toEqual([...list, extra]);
-  });
-
-  it("addSub on a Set holder adds new subscribers and ignores duplicates", () => {
-    const list = fns(SUBS_SET_THRESHOLD + 1);
-    const holder: { subs: SubList } = { subs: new Set(list) };
-    addSub(holder, list[0]);
-    expect((holder.subs as Set<() => void>).size).toBe(list.length);
-    const extra = () => {};
-    addSub(holder, extra);
-    expect((holder.subs as Set<() => void>).size).toBe(list.length + 1);
-  });
-
-  it("removeSub on a Set holder removes one subscriber, ignores unknown ones, and normalizes to null when emptied", () => {
-    const [a, b, stranger] = fns(3);
-    const holder: { subs: SubList } = { subs: new Set([a, b]) };
-    removeSub(holder, stranger);
-    expect((holder.subs as Set<() => void>).size).toBe(2);
-    removeSub(holder, a);
-    expect([...(holder.subs as Set<() => void>)]).toEqual([b]);
-    removeSub(holder, b);
-    expect(holder.subs).toBeNull();
-  });
-
-  it("many effects on one signal all re-run once per change, in subscription order", () => {
-    const count = SUBS_SET_THRESHOLD * 3;
-    const s = signal(0);
-    const order: number[] = [];
-    const stops = Array.from({ length: count }, (_, i) =>
-      effect(() => {
-        void s();
-        order.push(i);
-      }),
-    );
-    order.length = 0;
-    s.set(1);
-    expect(order).toEqual(Array.from({ length: count }, (_, i) => i));
-    order.length = 0;
-    s.set(2);
-    expect(order).toEqual(Array.from({ length: count }, (_, i) => i));
-    stops.forEach((stop) => { stop(); });
-    order.length = 0;
-    s.set(3);
-    expect(order).toEqual([]);
-  });
-
-  it("an effect stopped while the signal holds a Set no longer runs, the others still do", () => {
-    const s = signal(0);
-    const runs = new Map<number, number>();
-    const stops = Array.from({ length: SUBS_SET_THRESHOLD + 4 }, (_, i) =>
-      effect(() => {
-        void s();
-        runs.set(i, (runs.get(i) ?? 0) + 1);
-      }),
-    );
-    stops[2]();
-    s.set(1);
-    expect(runs.get(2)).toBe(1);
-    expect(runs.get(3)).toBe(2);
-  });
-});

package/src/__tests__/synced.test.ts

@@ -1,173 +0,0 @@
-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/__tests__/track.test.ts

@@ -1,61 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-
-import { track, runEffect, activeEffect } from "../signal/effect";
-import { signal } from "../signal/signal";
-
-describe("track", () => {
-  it("runs the effect immediately", () => {
-    const fn = vi.fn();
-    track(fn);
-    expect(fn).toHaveBeenCalledOnce();
-  });
-
-  it("sets activeEffect during execution, resets after", () => {
-    let during: unknown = "not-set";
-    track(() => {
-      during = activeEffect;
-    });
-    expect(during).toBeTypeOf("function");
-    expect(activeEffect).toBeNull();
-  });
-
-  it("supports nested track calls — restores outer effect", () => {
-    const outer = vi.fn();
-    const inner = vi.fn();
-    let outerActive: unknown;
-    let innerActive: unknown;
-
-    track(() => {
-      outer();
-      outerActive = activeEffect;
-      track(() => {
-        inner();
-        innerActive = activeEffect;
-      });
-      // after inner track, activeEffect should be back to outer
-      expect(activeEffect).toBe(outerActive);
-    });
-
-    expect(outer).toHaveBeenCalledOnce();
-    expect(inner).toHaveBeenCalledOnce();
-    expect(innerActive).not.toBe(outerActive);
-  });
-
-  it("subscribes the tracked effect to signals read inside it", () => {
-    const s = signal(1);
-    const values: number[] = [];
-    track(() => values.push(s()));
-    s.set(2);
-    expect(values).toEqual([1, 2]);
-  });
-});
-
-describe("runEffect", () => {
-  it("sets activeEffect to the given value", () => {
-    const fn = () => {};
-    runEffect(fn);
-    expect(activeEffect).toBe(fn);
-    runEffect(null);
-    expect(activeEffect).toBeNull();
-  });
-});

package/tsconfig.json

@@ -1,8 +0,0 @@
-{
-  "extends": "../../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "./src"
-  },
-  "include": ["src"]
-}