@alloy-js/core 0.16.0 → 0.18.0-dev.2

package/dist/test/reactive-union-set.test.js

@@ -0,0 +1,170 @@
+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("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());
+  const subset2 = reactive(new Set());
+  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());
+  const subset2 = reactive(new Set());
+  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());
+  const subset2 = reactive(new Set());
+  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);
+});
+describe("indexing", () => {
+  it("creates an index of properties", () => {
+    const set = new ReactiveUnionSet();
+    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();
+    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();
+    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/dist/test/reactivity/cleanup.test.js

@@ -1,6 +1,7 @@
-import { effect, memo, onCleanup, createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
 import { ref } from "@vue/reactivity";
 import { describe, expect, it } from "vitest";
+import { effect, memo, onCleanup } from "../../src/reactivity.js";
 import { renderTree } from "../../src/render.js";
 import { flushJobs } from "../../src/scheduler.js";
 describe("memo cleanup", () => {

package/dist/test/reactivity/memo.test.js

@@ -1,6 +1,6 @@
-import { memo } from "@alloy-js/core/jsx-runtime";
 import { ref } from "@vue/reactivity";
 import { expect, it } from "vitest";
+import { memo } from "../../src/reactivity.js";
 it("doesn't recalculate when dependencies don't change", () => {
   const signal = ref(0);
   let callCount = 0;

package/dist/test/reactivity/untrack.test.js

@@ -1,6 +1,6 @@
 import { ref } from "@vue/reactivity";
 import { expect, it } from "vitest";
-import { memo, untrack } from "../../src/jsx-runtime.js";
+import { memo, untrack } from "../../src/reactivity.js";
 import { flushJobs } from "../../src/scheduler.js";
 it("ignores signals for dependency tracking", () => {
   const signal = ref(0);

package/dist/test/rendering/memoization.test.js

@@ -1,6 +1,7 @@
-import { memo, createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
 import { ref } from "@vue/reactivity";
 import { expect, it } from "vitest";
+import { memo } from "../../src/reactivity.js";
 import { renderTree } from "../../src/render.js";
 import { flushJobs } from "../../src/scheduler.js";
 it("memoizes child components", () => {

package/dist/test/split-props.test.js

@@ -1,6 +1,6 @@
 import { effect, reactive } from "@vue/reactivity";
 import { expect, it, vi } from "vitest";
-import { splitProps } from "../src/jsx-runtime.js";
+import { splitProps } from "../src/props-combinators.js";
 it("splits regular object props", () => {
   const props = {
     a: 1,

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=output-scope.test.d.ts.map

package/dist/test/symbols/output-scope.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output-scope.test.d.ts","sourceRoot":"","sources":["../../../test/symbols/output-scope.test.ts"],"names":[],"mappings":""}

package/dist/test/symbols/output-scope.test.js

@@ -0,0 +1,343 @@
+import { reactive, watch } from "@vue/reactivity";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { createOutputBinder } from "../../src/binder.js";
+import { flushJobs } from "../../src/scheduler.js";
+import { OutputScopeFlags } from "../../src/symbols/flags.js";
+import { OutputScope } from "../../src/symbols/output-scope.js";
+import { OutputSymbol } from "../../src/symbols/output-symbol.js";
+import { SymbolTable } from "../../src/symbols/symbol-table.js";
+let 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";
+    const key2a = "key2a";
+    const key2b = "key2b";
+
+    // 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;
+  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");
+  });
+});

package/dist/test/symbols/output-symbol.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=output-symbol.test.d.ts.map

package/dist/test/symbols/output-symbol.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output-symbol.test.d.ts","sourceRoot":"","sources":["../../../test/symbols/output-symbol.test.ts"],"names":[],"mappings":""}