@alloy-js/core 0.23.0-dev.8 → 0.23.0-dev.9

package/test/lazy-isempty.test.tsx

@@ -0,0 +1,106 @@
+import { ref } from "@vue/reactivity";
+import { describe, expect, it } from "vitest";
+import { Show } from "../src/components/Show.jsx";
+import { createContentSlot } from "../src/content-slot.jsx";
+import { Context, ensureIsEmpty, getContext } from "../src/reactivity.js";
+import { printTree, renderTree } from "../src/render.js";
+import "../testing/extend-expect.js";
+
+describe("lazy isEmpty / _lastEmpty", () => {
+  it("context starts without isEmpty ref allocated", () => {
+    let ctx: Context | null = null;
+
+    function Capture() {
+      ctx = getContext()!;
+      return "content";
+    }
+
+    renderTree(<Capture />);
+
+    // The isEmpty ref should NOT be allocated unless someone observes it.
+    expect(ctx).not.toBeNull();
+    expect(ctx!.isEmpty).toBeUndefined();
+    expect(ctx!._lastEmpty).toBe(false);
+  });
+
+  it("ensureIsEmpty lazily allocates the isEmpty ref", () => {
+    let ctx: Context | null = null;
+
+    function Capture() {
+      ctx = getContext()!;
+      return "content";
+    }
+
+    renderTree(<Capture />);
+
+    expect(ctx!.isEmpty).toBeUndefined();
+    const isEmptyRef = ensureIsEmpty(ctx!);
+    expect(ctx!.isEmpty).toBeDefined();
+    expect(isEmptyRef).toBe(ctx!.isEmpty);
+  });
+
+  it("_lastEmpty is true for empty component, false for non-empty", () => {
+    let emptyCtx: Context | null = null;
+    let fullCtx: Context | null = null;
+
+    function EmptyCapture() {
+      emptyCtx = getContext()!;
+      return false;
+    }
+
+    function FullCapture() {
+      fullCtx = getContext()!;
+      return "has content";
+    }
+
+    renderTree(
+      <>
+        <EmptyCapture />
+        <FullCapture />
+      </>,
+    );
+
+    expect(emptyCtx!._lastEmpty).toBe(true);
+    expect(fullCtx!._lastEmpty).toBe(false);
+  });
+
+  it("ContentSlot triggers ensureIsEmpty and tracks reactively", () => {
+    const ContentSlot = createContentSlot();
+    const showContent = ref(false);
+
+    const tree = renderTree(
+      <>
+        {ContentSlot.isEmpty && "empty"}
+        <ContentSlot>
+          <Show when={showContent.value}>content</Show>
+        </ContentSlot>
+      </>,
+    );
+
+    expect(printTree(tree)).toBe("empty");
+
+    showContent.value = true;
+    expect(printTree(tree)).toBe("content");
+  });
+
+  it("propagates empty state up through parent contexts", () => {
+    const OuterSlot = createContentSlot();
+    const showContent = ref(false);
+
+    const tree = renderTree(
+      <>
+        {OuterSlot.isEmpty && "outer-empty"}
+        <OuterSlot>
+          <Show when={showContent.value}>content</Show>
+        </OuterSlot>
+      </>,
+    );
+
+    // Outer should be empty initially.
+    expect(printTree(tree)).toBe("outer-empty");
+
+    // Show content — outer should become non-empty.
+    showContent.value = true;
+    expect(printTree(tree)).toBe("content");
+  });
+});

package/test/reactive-union-set-disposers.test.tsx

@@ -0,0 +1,112 @@
+import { reactive } from "@vue/reactivity";
+import { describe, expect, it } from "vitest";
+import { ReactiveUnionSet } from "../src/reactive-union-set.js";
+import { effect } from "../src/reactivity.js";
+import { flushJobs } from "../src/scheduler.js";
+
+describe("ReactiveUnionSet: per-item disposers via addSubset", () => {
+  it("calls onDelete when item is removed from subset", () => {
+    const parentSet = new ReactiveUnionSet<string>();
+    const subset = reactive(new Set<string>());
+    const deleted: string[] = [];
+
+    parentSet.addSubset(subset, {
+      onDelete(value) {
+        deleted.push(value);
+      },
+    });
+
+    subset.add("a");
+    subset.add("b");
+    flushJobs();
+    expect(parentSet.has("a")).toBe(true);
+    expect(parentSet.has("b")).toBe(true);
+
+    subset.delete("a");
+    flushJobs();
+    expect(parentSet.has("a")).toBe(false);
+    expect(deleted).toContain("a");
+  });
+
+  it("calls onDelete for all items when subset is cleared", () => {
+    const parentSet = new ReactiveUnionSet<string>();
+    const subset = reactive(new Set<string>());
+    const deleted: string[] = [];
+
+    parentSet.addSubset(subset, {
+      onDelete(value) {
+        deleted.push(value);
+      },
+    });
+
+    subset.add("a");
+    subset.add("b");
+    subset.add("c");
+    flushJobs();
+    expect(parentSet.size).toBe(3);
+
+    subset.clear();
+    flushJobs();
+    expect(parentSet.size).toBe(0);
+    expect(deleted.sort()).toEqual(["a", "b", "c"]);
+  });
+
+  it("disposes root scopes created by onAdd when item is removed", () => {
+    const parentSet = new ReactiveUnionSet<string>();
+    const subset = reactive(new Set<string>());
+    let disposeCount = 0;
+
+    // Use the constructor-level onAdd so items are still added to the set,
+    // plus per-subset onAdd with root scope tracking.
+    parentSet.addSubset(subset, {
+      onAdd(value) {
+        // The onAdd in addSubset wraps in root() internally.
+        // Side-effects created here are cleaned up when the item is removed.
+        effect(() => {
+          void value; // track nothing real, just proving the effect exists
+        });
+        return value;
+      },
+      onDelete() {
+        disposeCount++;
+      },
+    });
+
+    subset.add("x");
+    flushJobs();
+
+    // Remove item — root scope (and its effects) should be disposed.
+    subset.delete("x");
+    flushJobs();
+    expect(disposeCount).toBe(1);
+  });
+
+  it("re-adding after delete triggers fresh onAdd", () => {
+    const parentSet = new ReactiveUnionSet<string>();
+    const subset = reactive(new Set<string>());
+    let addCount = 0;
+    const deleted: string[] = [];
+
+    parentSet.addSubset(subset, {
+      onAdd(value) {
+        addCount++;
+        return value;
+      },
+      onDelete(value) {
+        deleted.push(value);
+      },
+    });
+
+    subset.add("a");
+    flushJobs();
+    expect(addCount).toBe(1);
+
+    subset.delete("a");
+    flushJobs();
+    expect(deleted).toEqual(["a"]);
+
+    subset.add("a");
+    flushJobs();
+    expect(addCount).toBe(2);
+  });
+});

package/test/reactivity/shallow-reactive.test.tsx

@@ -0,0 +1,56 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import {
+  getReactiveCreationLocation,
+  shallowReactive,
+} from "../../src/reactivity.js";
+
+describe("shallowReactive creation location", () => {
+  let origDebug: string | undefined;
+
+  beforeEach(() => {
+    origDebug = process.env.ALLOY_DEBUG;
+    process.env.ALLOY_DEBUG = "1";
+  });
+
+  afterEach(() => {
+    if (origDebug === undefined) {
+      delete process.env.ALLOY_DEBUG;
+    } else {
+      process.env.ALLOY_DEBUG = origDebug;
+    }
+  });
+
+  it("stores creation location keyed by raw target when debug enabled", () => {
+    const raw = { x: 1 };
+    shallowReactive(raw);
+
+    const location = getReactiveCreationLocation(raw);
+    // When ALLOY_DEBUG is set, captureSourceLocation should return something.
+    expect(location).toBeDefined();
+  });
+
+  it("does not store location when debug is disabled", () => {
+    delete process.env.ALLOY_DEBUG;
+    const raw = { y: 2 };
+    shallowReactive(raw);
+
+    const location = getReactiveCreationLocation(raw);
+    expect(location).toBeUndefined();
+  });
+
+  it("location is keyed by raw target, not proxy", () => {
+    const raw = { z: 3 };
+    const proxy = shallowReactive(raw);
+
+    // Proxy and raw are different objects.
+    expect(proxy).not.toBe(raw);
+
+    // Location should be on the raw target.
+    const location = getReactiveCreationLocation(raw);
+    expect(location).toBeDefined();
+
+    // The proxy itself should NOT have a location stored (WeakMap keyed by raw).
+    // Note: Vue may unwrap the proxy to raw internally, but our code explicitly
+    // stores on `target` (the raw object passed to shallowReactive).
+  });
+});

package/test/scheduler-extended.test.tsx

@@ -0,0 +1,122 @@
+import { ref, stop, effect as vueEffect } from "@vue/reactivity";
+import { describe, expect, it } from "vitest";
+import {
+  flushJobs,
+  flushJobsAsync,
+  queueJob,
+  scheduler,
+} from "../src/scheduler.js";
+
+describe("scheduler: isJobActive additional coverage", () => {
+  it("does not run stopped effects in async flush", async () => {
+    const source = ref(0);
+    let runCount = 0;
+
+    const runner = vueEffect(
+      () => {
+        runCount++;
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+        source.value;
+      },
+      { scheduler: scheduler() },
+    );
+    expect(runCount).toBe(1);
+
+    source.value = 1;
+    stop(runner);
+    await flushJobsAsync();
+
+    expect(runCount).toBe(1);
+  });
+
+  it("does not run stopped immediate effects", () => {
+    const source = ref(0);
+    let runCount = 0;
+
+    const runner = vueEffect(
+      () => {
+        runCount++;
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+        source.value;
+      },
+      { scheduler: scheduler(true) },
+    );
+    expect(runCount).toBe(1);
+
+    source.value = 1;
+    stop(runner);
+    flushJobs();
+
+    expect(runCount).toBe(1);
+  });
+
+  it("runs effect in first flush but not after stop", () => {
+    const source = ref(0);
+    let runCount = 0;
+
+    const runner = vueEffect(
+      () => {
+        runCount++;
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+        source.value;
+      },
+      { scheduler: scheduler() },
+    );
+    expect(runCount).toBe(1);
+
+    // First flush: effect is active, should run.
+    source.value = 1;
+    flushJobs();
+    expect(runCount).toBe(2);
+
+    // Stop, then trigger again — should not run.
+    stop(runner);
+    source.value = 2;
+    flushJobs();
+    expect(runCount).toBe(2);
+  });
+
+  it("skips multiple stopped effects in the same flush", () => {
+    const source = ref(0);
+    let runCountA = 0;
+    let runCountB = 0;
+
+    const runnerA = vueEffect(
+      () => {
+        runCountA++;
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+        source.value;
+      },
+      { scheduler: scheduler() },
+    );
+
+    const runnerB = vueEffect(
+      () => {
+        runCountB++;
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+        source.value;
+      },
+      { scheduler: scheduler() },
+    );
+
+    expect(runCountA).toBe(1);
+    expect(runCountB).toBe(1);
+
+    source.value = 1;
+    stop(runnerA);
+    stop(runnerB);
+    flushJobs();
+
+    expect(runCountA).toBe(1);
+    expect(runCountB).toBe(1);
+  });
+
+  it("handles plain function jobs that lack flags", () => {
+    let ran = false;
+    queueJob(() => {
+      ran = true;
+    });
+    flushJobs();
+    expect(ran).toBe(true);
+  });
+});

package/test/scheduler.test.tsx

@@ -0,0 +1,50 @@
+import { ref, stop, effect as vueEffect } from "@vue/reactivity";
+import { describe, expect, it } from "vitest";
+import { effect } from "../src/reactivity.js";
+import { flushJobs, scheduler } from "../src/scheduler.js";
+
+describe("scheduler", () => {
+  it("does not run stopped effects from the queue", () => {
+    const source = ref(0);
+    let runCount = 0;
+
+    // Create an effect that tracks source via alloy's scheduler.
+    const runner = vueEffect(
+      () => {
+        runCount++;
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+        source.value;
+      },
+      { scheduler: scheduler() },
+    );
+    expect(runCount).toBe(1);
+
+    // Trigger the effect — it gets queued in the scheduler.
+    source.value = 1;
+    // Stop the effect before flushing.
+    stop(runner);
+    flushJobs();
+
+    // The stopped effect must not have run.
+    expect(runCount).toBe(1);
+  });
+
+  it("runs active effects normally", () => {
+    const source = ref(0);
+    let runCount = 0;
+
+    effect(() => {
+      runCount++;
+      // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+      source.value;
+    });
+
+    expect(runCount).toBe(1);
+    source.value = 1;
+    flushJobs();
+    expect(runCount).toBe(2);
+    source.value = 2;
+    flushJobs();
+    expect(runCount).toBe(3);
+  });
+});