@alloy-js/core 0.16.0 → 0.17.0

package/test/components/slot.test.tsx

@@ -4,7 +4,6 @@ import { SourceFile } from "../../src/components/SourceFile.jsx";
 import {
   Declaration,
   Name,
-  OutputSymbol,
   Ref,
   refkey,
   Scope,
@@ -12,6 +11,7 @@ import {
 } from "../../src/index.js";
 import { render } from "../../src/render.js";
 import { defineSlot, rename, replace } from "../../src/slot.js";
+import { OutputSymbol } from "../../src/symbols/output-symbol.js";
 import "../../testing/extend-expect.js";
 
 it("works with string keys", () => {
@@ -70,7 +70,7 @@ it("works with symbols", () => {
   const FunctionSlot = defineSlot<FunctionSlotProps>(
     (query: { fqn: string }) => {
       const binder = useBinder();
-      return binder.resolveFQN(query.fqn);
+      return binder!.resolveFQN(query.fqn);
     },
   );
 
@@ -80,9 +80,8 @@ it("works with symbols", () => {
 
   function MyFunctionComponent(props: FunctionComponentProps) {
     const binder = useBinder();
-    const sym = binder.createSymbol({
-      name: props.name,
-      refkey: refkey(),
+    const sym = new OutputSymbol(props.name, {
+      refkeys: refkey(),
     });
 
     const FunctionSlotInstance = FunctionSlot.create(
@@ -129,7 +128,7 @@ it("can rename", () => {
 
   const FunctionSlot = defineSlot<FunctionSlotProps>(
     (query: { fqn: string }) => {
-      const binder = useBinder();
+      const binder = useBinder()!;
       return binder.resolveFQN(query.fqn);
     },
   );
@@ -139,10 +138,8 @@ it("can rename", () => {
   }
 
   function MyFunctionComponent(props: FunctionComponentProps) {
-    const binder = useBinder();
-    const sym = binder.createSymbol({
-      name: props.name,
-      refkey: refkey(),
+    const sym = new OutputSymbol(props.name, {
+      refkeys: refkey(),
     });
 
     const FunctionSlotInstance = FunctionSlot.create(
@@ -161,7 +158,7 @@ it("can rename", () => {
 
   rename(() => {
     const binder = useBinder();
-    return binder.resolveFQN("foo.bar") as Ref<OutputSymbol | undefined>;
+    return binder!.resolveFQN("foo.bar") as Ref<OutputSymbol | undefined>;
   }, "bazxxx");
 
   const tree = render(

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

@@ -0,0 +1,191 @@
+import { effect } from "@alloy-js/core/jsx-runtime";
+import { reactive } from "@vue/reactivity";
+import { describe, expect, it } from "vitest";
+import { ReactiveUnionSet } from "../src/reactive-union-set.js";
+import { flushJobs } from "../src/scheduler.js";
+
+describe("is reactive", () => {
+  it("on size", () => {
+    const set = new ReactiveUnionSet();
+    let callCount = 0;
+    effect(() => {
+      callCount++;
+      // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+      set.size;
+    });
+
+    set.add(1);
+    flushJobs();
+    expect(callCount).toBe(2);
+  });
+
+  it("on iteration", () => {
+    const set = new ReactiveUnionSet();
+    let callCount = 0;
+    effect(() => {
+      callCount++;
+      for (const _ of set) {
+        // do nothing
+      }
+    });
+
+    set.add(1);
+    flushJobs();
+    expect(callCount).toBe(2);
+  });
+
+  it("on deletion with iteration", () => {
+    const set = new ReactiveUnionSet();
+    let callCount = 0;
+    effect(() => {
+      callCount++;
+      for (const _ of set) {
+        // do nothing
+      }
+    });
+
+    set.add(1);
+    flushJobs();
+    expect(callCount).toBe(2);
+
+    set.delete(1);
+    flushJobs();
+    expect(callCount).toBe(3);
+  });
+});
+
+it("adds items to main set from subset", () => {
+  const set = new ReactiveUnionSet();
+
+  const subset1 = reactive(new Set<number>());
+  const subset2 = reactive(new Set<number>());
+
+  set.addSubset(subset1);
+  set.addSubset(subset2);
+
+  subset1.add(1);
+  subset2.add(2);
+  flushJobs();
+  expect(set.has(1)).toBe(true);
+  expect(set.has(2)).toBe(true);
+
+  subset1.delete(1);
+  flushJobs();
+  expect(set.has(1)).toBe(false);
+});
+
+it("doesn't remove items that are present in more than one subset", () => {
+  const set = new ReactiveUnionSet();
+
+  const subset1 = reactive(new Set<number>());
+  const subset2 = reactive(new Set<number>());
+
+  set.addSubset(subset1);
+  set.addSubset(subset2);
+
+  subset1.add(1);
+  subset2.add(1);
+  flushJobs();
+  expect(set.has(1)).toBe(true);
+
+  subset1.delete(1);
+  flushJobs();
+  expect(set.has(1)).toBe(true);
+
+  subset2.delete(1);
+  flushJobs();
+  expect(set.has(1)).toBe(false);
+});
+
+it("removes all items when you clear the subset", () => {
+  const set = new ReactiveUnionSet();
+
+  const subset1 = reactive(new Set<number>());
+  const subset2 = reactive(new Set<number>());
+
+  set.addSubset(subset1);
+  set.addSubset(subset2);
+  subset1.add(1);
+  subset1.add(2);
+  subset1.add(3);
+  subset2.add(1);
+  flushJobs();
+  expect(set.size).toBe(3);
+  subset1.clear();
+  flushJobs();
+  expect(set.size).toBe(1);
+});
+
+interface Item {
+  id: number;
+  name: string;
+}
+
+describe("indexing", () => {
+  it("creates an index of properties", () => {
+    const set = new ReactiveUnionSet<Item>();
+
+    const index = set.createIndex((item) => item.id);
+
+    let callCount = 0;
+    effect(() => {
+      callCount++;
+      index.values();
+    });
+
+    const brian = { id: 1, name: "brian" };
+    const timothee = { id: 2, name: "timothee" };
+    set.add(brian);
+    set.add(timothee);
+    flushJobs();
+    expect(callCount).toBe(2);
+    expect(index.get(1)).toEqual(brian);
+    expect(index.get(2)).toEqual(timothee);
+    set.delete(brian);
+    flushJobs();
+    expect(callCount).toBe(3);
+    expect(index.get(1)).toBeUndefined();
+  });
+
+  it("updates the index when the item changeS", () => {
+    const set = new ReactiveUnionSet<Item>();
+
+    const index = set.createIndex((item) => item.id);
+
+    let callCount = 0;
+    effect(() => {
+      callCount++;
+      index.values();
+    });
+
+    const brian = reactive({ id: 1, name: "brian" });
+    set.add(brian);
+    flushJobs();
+    expect(index.get(1)).toEqual(brian);
+    brian.id = 2;
+    flushJobs();
+    expect(callCount).toBe(3);
+    expect(index.get(2)).toEqual(brian);
+  });
+});
+
+describe("derived sets", () => {
+  it("creates a derived set", () => {
+    const set = new ReactiveUnionSet<Item>();
+    const derivedSet = set.createDerivedSet((item) => item.name);
+    const brian = { id: 1, name: "brian" };
+    const timothee = { id: 2, name: "timothee" };
+    set.add(brian);
+    set.add(timothee);
+    flushJobs();
+    expect(derivedSet.size).toBe(2);
+    expect(derivedSet.has("brian")).toBe(true);
+    expect(derivedSet.has("timothee")).toBe(true);
+
+    set.delete(brian);
+    flushJobs();
+    expect(derivedSet.size).toBe(1);
+    expect(derivedSet.has("brian")).toBe(false);
+    expect(derivedSet.has("timothee")).toBe(true);
+  });
+});

package/test/symbols/output-scope.test.ts

@@ -0,0 +1,302 @@
+import { reactive, watch } from "@vue/reactivity";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { Binder, createOutputBinder } from "../../src/binder.js";
+import { Refkey } from "../../src/refkey.js";
+import { flushJobs } from "../../src/scheduler.js";
+import {
+  OutputScope,
+  OutputScopeFlags,
+} from "../../src/symbols/output-scope.js";
+import { OutputSymbol } from "../../src/symbols/output-symbol.js";
+import { SymbolTable } from "../../src/symbols/symbol-table.js";
+
+let binder: Binder;
+beforeEach(() => {
+  binder = createOutputBinder();
+});
+
+describe("OutputScope constructor", () => {
+  it("initializes properties correctly with default options", () => {
+    const scope = new OutputScope("testScope", { binder });
+    expect(scope.name).toBe("testScope");
+    expect(scope.binder).toBe(binder);
+    expect(scope.id).toEqual(expect.any(Number));
+    expect(scope.kind).toBe("scope");
+    expect(scope.flags).toBe(OutputScopeFlags.None);
+    expect(scope.metadata).toEqual({});
+    expect(scope.parent).toBe(binder.globalScope);
+    expect(scope.owner).toBeUndefined();
+    expect(scope.symbols).toBeInstanceOf(SymbolTable);
+    expect(scope.symbolNames.size).toBe(0);
+    expect(scope.children.size).toBe(0);
+  });
+
+  it("initializes properties correctly with custom options", () => {
+    const parentScope = new OutputScope("parentScope", { binder });
+    const metadata = { foo: "bar" };
+
+    const scope = new OutputScope("testScope", {
+      binder,
+      kind: "namespace",
+      metadata,
+      parent: parentScope,
+    });
+
+    expect(scope.name).toBe("testScope");
+    expect(scope.kind).toBe("namespace");
+    expect(scope.flags).toBe(OutputScopeFlags.None);
+    expect(scope.metadata.foo).toBe("bar");
+    expect(scope.parent).toBe(parentScope);
+    expect(parentScope.children.has(scope)).toBe(true);
+  });
+});
+
+describe("OutputScope reactivity", () => {
+  it("is reactive on name", () => {
+    const scope = new OutputScope("initialName", { binder });
+    const nameSpy = vi.fn();
+    watch(() => scope.name, nameSpy);
+
+    scope.name = "newName";
+    flushJobs();
+    expect(nameSpy).toHaveBeenCalled();
+    expect(scope.name).toBe("newName");
+  });
+
+  it("is reactive on flags", () => {
+    const scope = new OutputScope("scope", { binder });
+    const flagsSpy = vi.fn();
+    watch(() => scope.flags, flagsSpy);
+
+    scope.flags = OutputScopeFlags.InstanceMemberScope;
+    flushJobs();
+    expect(flagsSpy).toHaveBeenCalled();
+    expect(scope.flags).toBe(OutputScopeFlags.InstanceMemberScope);
+  });
+
+  it("updates symbolNames when symbols are added", () => {
+    const scope = new OutputScope("scope", { binder });
+    const symbolNamesSpy = vi.fn();
+    watch(() => scope.symbolNames.size, symbolNamesSpy);
+
+    new OutputSymbol("symbol1", { binder, scope });
+    flushJobs();
+    expect(symbolNamesSpy).toHaveBeenCalled();
+    expect(scope.symbolNames.has("symbol1")).toBe(true);
+  });
+
+  it("updates symbolNames when a symbol's name changes", () => {
+    const scope = new OutputScope("scope", { binder });
+    const symbol = new OutputSymbol("oldName", { binder, scope });
+    flushJobs();
+
+    // Verify initial state
+    expect(scope.symbolNames.has("oldName")).toBe(true);
+    expect(scope.symbolNames.has("newName")).toBe(false);
+
+    // Set up tracking for symbol names
+    const symbolNamesTracker = vi.fn();
+    watch(
+      () => ({
+        hasOld: scope.symbolNames.has("oldName"),
+        hasNew: scope.symbolNames.has("newName"),
+      }),
+      symbolNamesTracker,
+      { deep: true },
+    );
+
+    // Change the name
+    symbol.name = "newName";
+    flushJobs();
+
+    // Verify the changes
+    expect(symbolNamesTracker).toHaveBeenCalled();
+    expect(scope.symbolNames.has("oldName")).toBe(false);
+    expect(scope.symbolNames.has("newName")).toBe(true);
+  });
+
+  it("doesn't get wrapped in a reactive proxy", () => {
+    const scope = new OutputScope("scope", { binder });
+
+    const rScope = reactive(scope);
+    expect(rScope).toBe(scope);
+  });
+});
+
+describe("OutputScope#symbols", () => {
+  it("adds symbols to its collection", () => {
+    const scope = new OutputScope("scope", { binder });
+    const sym1 = new OutputSymbol("sym1", { binder, scope });
+    const sym2 = new OutputSymbol("sym2", { binder, scope });
+    flushJobs();
+
+    expect(scope.symbols.size).toBe(2);
+    expect(scope.symbols.has(sym1)).toBe(true);
+    expect(scope.symbols.has(sym2)).toBe(true);
+  });
+
+  it("resolves symbol name conflicts", () => {
+    const scope = new OutputScope("scope", { binder });
+    const s1 = new OutputSymbol("sym", { binder, scope });
+    const s2 = new OutputSymbol("sym", { binder, scope });
+    const s3 = new OutputSymbol("sym", { binder, scope });
+    flushJobs();
+
+    expect(s1.name).toBe("sym");
+    expect(s2.name).toBe("sym_2");
+    expect(s3.name).toBe("sym_3");
+    expect(scope.symbolNames.has("sym")).toBe(true);
+    expect(scope.symbolNames.has("sym_2")).toBe(true);
+    expect(scope.symbolNames.has("sym_3")).toBe(true);
+  });
+
+  it("updates when a symbol is deleted", () => {
+    const scope = new OutputScope("scope", { binder });
+    const sym = new OutputSymbol("sym", { binder, scope });
+    flushJobs();
+
+    expect(scope.symbols.size).toBe(1);
+    expect(scope.symbols.has(sym)).toBe(true);
+    expect(scope.symbolNames.has("sym")).toBe(true);
+
+    sym.delete();
+    flushJobs();
+
+    expect(scope.symbols.size).toBe(0);
+    expect(scope.symbols.has(sym)).toBe(false);
+    expect(scope.symbolNames.has("sym")).toBe(false);
+  });
+
+  it("updates when a symbol changes scope", () => {
+    const scope1 = new OutputScope("scope1", { binder });
+    const scope2 = new OutputScope("scope2", { binder });
+    const sym = new OutputSymbol("sym", { binder, scope: scope1 });
+    flushJobs();
+
+    expect(scope1.symbols.size).toBe(1);
+    expect(scope2.symbols.size).toBe(0);
+
+    sym.scope = scope2;
+    flushJobs();
+
+    expect(scope1.symbols.size).toBe(0);
+    expect(scope2.symbols.size).toBe(1);
+    expect(scope1.symbols.has(sym)).toBe(false);
+    expect(scope2.symbols.has(sym)).toBe(true);
+    expect(scope1.symbolNames.has("sym")).toBe(false);
+    expect(scope2.symbolNames.has("sym")).toBe(true);
+  });
+});
+
+describe("OutputScope#symbolsByRefkey", () => {
+  it("maps refkeys to symbols", () => {
+    const scope = new OutputScope("scope", { binder });
+
+    // Use the refkey function to create refkeys
+    // This is based on how refkey is being imported in binder.ts
+    const key1 = "key1" as unknown as Refkey;
+    const key2a = "key2a" as unknown as Refkey;
+    const key2b = "key2b" as unknown as Refkey;
+
+    // Create a symbol with a refkey
+    const sym1 = new OutputSymbol("sym1", {
+      binder,
+      scope,
+      refkeys: [key1],
+    });
+
+    // Create a symbol with multiple refkeys
+    const sym2 = new OutputSymbol("sym2", {
+      binder,
+      scope,
+      refkeys: [key2a, key2b],
+    });
+
+    flushJobs();
+
+    expect(scope.symbolsByRefkey.get(key1)).toBe(sym1);
+    expect(scope.symbolsByRefkey.get(key2a)).toBe(sym2);
+    expect(scope.symbolsByRefkey.get(key2b)).toBe(sym2);
+  });
+});
+
+describe("OutputScope#children", () => {
+  it("tracks child scopes", () => {
+    const parentScope = new OutputScope("parent", { binder });
+    const child1 = new OutputScope("child1", { binder, parent: parentScope });
+    const child2 = new OutputScope("child2", { binder, parent: parentScope });
+    flushJobs();
+
+    expect(parentScope.children.size).toBe(2);
+    expect(parentScope.children.has(child1)).toBe(true);
+    expect(parentScope.children.has(child2)).toBe(true);
+
+    // Check that each child's parent is set correctly
+    expect(child1.parent).toBe(parentScope);
+    expect(child2.parent).toBe(parentScope);
+  });
+});
+
+describe("OutputScope#clone", () => {
+  let originalScope: OutputScope;
+  const originalMetadata = { data: "original", nested: { value: 1 } };
+
+  beforeEach(() => {
+    const parentScope = new OutputScope("parent", { binder });
+
+    originalScope = new OutputScope("original", {
+      binder: binder,
+      kind: "class",
+      metadata: { ...originalMetadata },
+      parent: parentScope,
+    });
+
+    // Add a symbol and child scope to the original
+    new OutputSymbol("symbolInOriginal", { binder, scope: originalScope });
+    new OutputScope("childOfOriginal", { binder, parent: originalScope });
+    flushJobs();
+  });
+
+  it("clones basic properties", () => {
+    const newScope = new OutputScope("newScope", { binder });
+    const clonedScope = originalScope.clone({ parent: newScope });
+
+    expect(clonedScope.name).toBe(originalScope.name);
+    expect(clonedScope.kind).toBe(originalScope.kind);
+    expect(clonedScope.flags).toBe(originalScope.flags);
+    expect(clonedScope.id).not.toBe(originalScope.id);
+
+    expect(clonedScope.metadata).toEqual(originalScope.metadata);
+
+    expect(clonedScope.symbols.size).toBe(1);
+    expect(clonedScope.children.size).toBe(1);
+  });
+
+  it("can override parent in clone options", () => {
+    const newParent = new OutputScope("newParent", { binder });
+    const clonedScope = originalScope.clone({ parent: newParent });
+    flushJobs();
+
+    expect(clonedScope.parent).toBe(newParent);
+    expect(newParent.children.has(clonedScope)).toBe(true);
+  });
+
+  it("can override owner in clone options", () => {
+    const newOwnerParent = new OutputScope("newOwnerParent", { binder });
+    const newOwner = new OutputSymbol("newOwner", {
+      binder,
+      scope: newOwnerParent,
+    });
+    const clonedScope = originalScope.clone({ owner: newOwner });
+    flushJobs();
+
+    expect(clonedScope.owner).toBe(newOwner);
+  });
+
+  it("allows independent changes to clone properties", () => {
+    const clonedScope = originalScope.clone();
+    clonedScope.name = "clonedName";
+
+    expect(originalScope.name).toBe("original");
+  });
+});