@alloy-js/core 0.24.0-dev.6 → 0.24.0-dev.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alloy-js/core",
-  "version": "0.24.0-dev.6",
+  "version": "0.24.0-dev.7",
   "description": "",
   "repository": {
     "type": "git",

package/src/components/AccessExpression.test.tsx

@@ -1,12 +1,10 @@
 import { describe, expect, it } from "vitest";
-import "../../testing/extend-expect.js";
 import {
   BasePartProps,
   createAccessExpression,
 } from "../components/AccessExpression.jsx";
 import { code } from "../index.js";
 import { Children } from "../runtime/component.js";
-import { printTree, renderTree } from "../test-render.js";
 
 interface TestPartProps extends BasePartProps {
   name?: string;
@@ -105,28 +103,22 @@ describe("createAccessExpression", () => {
 
 describe("createAccessExpression: call chain formatting", () => {
   it("uses linear format with only one call", () => {
-    const tree = renderTree(
+    expect(
       <Expression>
         <Part name="foo" />
         <Part name="bar" args="x" />
       </Expression>,
-    );
-    // Single call → linear, no grouping.
-    expect(printTree(tree)).toBe("foo.bar(x)");
+    ).toRenderTo("foo.bar(x)");
   });
 
   it("uses call chain format with multiple calls", () => {
-    const tree = renderTree(
+    // Multiple calls → call chain with group/indent wrapping.
+    expect(
       <Expression>
         <Part name="foo" />
         <Part name="bar" args="x" />
         <Part name="baz" args="y" />
       </Expression>,
-    );
-    // Multiple calls → call chain with group/indent wrapping.
-    const result = printTree(tree);
-    // Should contain both calls.
-    expect(result).toContain("bar(x)");
-    expect(result).toContain("baz(y)");
+    ).toRenderTo("foo.bar(x).baz(y)");
   });
 });

package/src/content-slot.test.tsx

@@ -1,9 +1,7 @@
 import { ref } from "@vue/reactivity";
 import { expect, it } from "vitest";
-import "../testing/extend-expect.js";
 import { Show } from "./components/Show.jsx";
 import { createContentSlot } from "./content-slot.jsx";
-import { printTree, renderTree } from "./test-render.js";
 
 it("knows when its empty", () => {
   const ContentSlot = createContentSlot();
@@ -31,35 +29,35 @@ it("is reactive", () => {
   const ContentSlot = createContentSlot();
   const showContent = ref(false);
 
-  const tree = renderTree(
+  const tree = (
     <>
       {ContentSlot.isEmpty && "It's empty!"}
       <ContentSlot>
         <Show when={showContent.value}>Content!</Show>
       </ContentSlot>
-    </>,
+    </>
   );
 
-  expect(printTree(tree)).toBe(`It's empty!`);
+  expect(tree).toRenderTo("It's empty!");
   showContent.value = true;
-  expect(printTree(tree)).toBe(`Content!`);
+  expect(tree).toRenderTo("Content!");
 });
 
 it("works with WhenEmpty and WhenHasContent", () => {
   const ContentSlot = createContentSlot();
   const showContent = ref(false);
 
-  const tree = renderTree(
+  const tree = (
     <>
       <ContentSlot.WhenEmpty>It's empty!</ContentSlot.WhenEmpty>
       <ContentSlot.WhenHasContent>Has content!</ContentSlot.WhenHasContent>
       <ContentSlot>
         <Show when={showContent.value}>Content!</Show>
       </ContentSlot>
-    </>,
+    </>
   );
 
-  expect(printTree(tree)).toBe(`It's empty!`);
+  expect(tree).toRenderTo("It's empty!");
   showContent.value = true;
-  expect(printTree(tree)).toBe(`Has content!Content!`);
+  expect(tree).toRenderTo("Has content!Content!");
 });

package/src/symbols/symbol-slot.test.tsx

@@ -9,13 +9,13 @@ import { createSymbolSlot } from "./symbol-slot.jsx";
 it("captures firstSymbol", async () => {
   const Slot = createSymbolSlot();
 
-  renderTree(
+  expect(
     <Slot>
       {() => {
         emitSymbol(new BasicSymbol("a", undefined));
       }}
     </Slot>,
-  );
+  ).toRenderTo("");
   await flushJobs();
   expect(Slot.firstSymbol.value).toBeDefined();
   expect(Slot.firstSymbol.value!.name).toBe("a");
@@ -52,13 +52,13 @@ it("captures firstSymbol when emitting a ref to a symbol", async () => {
   const Slot = createSymbolSlot();
   const symref = shallowRef<BasicSymbol | undefined>();
 
-  renderTree(
+  expect(
     <Slot>
       {() => {
         emitSymbol(symref);
       }}
     </Slot>,
-  );
+  ).toRenderTo("");
   await flushJobs();
   expect(Slot.firstSymbol.value).toBeUndefined();
   symref.value = new BasicSymbol("a", undefined);

package/test/children.test.tsx

@@ -1,4 +1,4 @@
-import { children, Children, printTree, renderTree } from "@alloy-js/core";
+import { children, Children } from "@alloy-js/core";
 import { expect, it } from "vitest";
 
 it("handles a single element", () => {
@@ -6,8 +6,7 @@ it("handles a single element", () => {
     return children(() => props.children);
   }
 
-  const res = renderTree(<Foo>a b c</Foo>);
-  expect(printTree(res)).toBe("a b c");
+  expect(<Foo>a b c</Foo>).toRenderTo("a b c");
 });
 
 it("handles a multiple elements", () => {
@@ -20,12 +19,10 @@ it("handles a multiple elements", () => {
     return "Bar";
   }
 
-  const res = renderTree(
+  expect(
     <Foo>
       <Bar />
       <Bar />
     </Foo>,
-  );
-
-  expect(printTree(res)).toBe(`BarBar`);
+  ).toRenderTo(`BarBar`);
 });

package/test/components/append-file.test.tsx

@@ -3,7 +3,6 @@ import { tmpdir } from "os";
 import { join } from "path";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
 import { AppendFile, AppendRegion } from "../../src/components/AppendFile.jsx";
-import "../../testing/extend-expect.js";
 import { d } from "../../testing/render.js";
 
 describe("AppendFile", () => {

package/test/components/block.test.tsx

@@ -1,8 +1,6 @@
 import { ref } from "@vue/reactivity";
 import { expect, it } from "vitest";
 import { Block } from "../../src/components/Block.jsx";
-import { printTree, renderTree } from "../../src/test-render.js";
-import "../../testing/extend-expect.js";
 it("renders properly with no children", () => {
   const template = (
     <Block>
@@ -51,16 +49,16 @@ it("renders properly with newline and children", () => {
 
 it("renders properly when content is added reactively", () => {
   const contents = ref("");
-  const tree = renderTree(
+  const tree = (
     <>
       class Foo <Block>{contents}</Block>
-    </>,
+    </>
   );
-  expect(printTree(tree)).toRenderTo(`
+  expect(tree).toRenderTo(`
     class Foo {}
   `);
   contents.value = "x = 12;";
-  expect(printTree(tree)).toRenderTo(`
+  expect(tree).toRenderTo(`
     class Foo {
       x = 12;
     }

package/test/components/copy-file.test.tsx

@@ -7,7 +7,6 @@ import { SourceDirectory } from "../../src/components/SourceDirectory.jsx";
 import type { CopyOutputFile } from "../../src/output-types.js";
 import { render } from "../../src/render-output.js";
 import { writeOutput } from "../../src/write-output.js";
-import "../../testing/extend-expect.js";
 
 describe("CopyFile", () => {
   let testDir: string;

package/test/components/declaration.test.tsx

@@ -1,6 +1,6 @@
 import { expect, it } from "vitest";
 import { Output } from "../../src/components/Output.jsx";
-import { Declaration, ref, renderTree, Scope } from "../../src/index.js";
+import { Declaration, ref, Scope } from "../../src/index.js";
 import { flushJobs } from "../../src/scheduler.js";
 import { BasicScope } from "../../src/symbols/basic-scope.js";
 
@@ -17,7 +17,7 @@ it("creates and cleans up a symbol", () => {
     </Output>
   );
 
-  renderTree(template);
+  expect(template).toRenderTo("");
 
   expect(scope.symbols.size).toBe(1);
   doDecl.value = false;

package/test/components/list.test.tsx

@@ -1,14 +1,5 @@
 import { expect, it } from "vitest";
-import {
-  createContentSlot,
-  List,
-  printTree,
-  ref,
-  renderTree,
-  Show,
-} from "../../src/index.js";
-import "../../testing/extend-expect.js";
-import { d } from "../../testing/render.js";
+import { createContentSlot, List, ref, Show } from "../../src/index.js";
 
 it("creates a list with default options", () => {
   const template = (
@@ -73,14 +64,14 @@ it("is useful for statements", () => {
     return "console.log(true)";
   }
   const includeStatement = ref(false);
-  const tree = renderTree(
+  const tree = (
     <List semicolon hardline ender>
       <Statement />
       {includeStatement.value && <Statement />}
       <Statement />
-    </List>,
+    </List>
   );
-  expect(printTree(tree)).toEqual(d`
+  expect(tree).toRenderTo(`
     console.log(true);
     console.log(true);
 
@@ -88,7 +79,7 @@ it("is useful for statements", () => {
 
   includeStatement.value = true;
 
-  expect(printTree(tree)).toEqual(d`
+  expect(tree).toRenderTo(`
     console.log(true);
     console.log(true);
     console.log(true);
@@ -113,37 +104,37 @@ it("It add joiners when items are become non-empty", () => {
   const item2 = ref("");
   const item3 = ref("");
 
-  const tree = renderTree(
+  const tree = (
     <group>
       <List comma line ender=";">
         <>{item1}</>
         <>{item2}</>
         <>{item3}</>
       </List>
-    </group>,
+    </group>
   );
 
-  expect(printTree(tree)).toBe(``);
+  expect(tree).toRenderTo("");
   item1.value = "hi";
-  expect(printTree(tree)).toBe(`hi;`);
+  expect(tree).toRenderTo("hi;");
   item2.value = "there";
-  expect(printTree(tree)).toBe(`hi, there;`);
+  expect(tree).toRenderTo("hi, there;");
   item3.value = "friend";
-  expect(printTree(tree)).toBe(`hi, there, friend;`);
+  expect(tree).toRenderTo("hi, there, friend;");
 
   item1.value = "";
-  expect(printTree(tree)).toBe(`there, friend;`);
+  expect(tree).toRenderTo("there, friend;");
   item3.value = "";
-  expect(printTree(tree)).toBe(`there;`);
+  expect(tree).toRenderTo("there;");
   item2.value = "";
-  expect(printTree(tree)).toBe(``);
+  expect(tree).toRenderTo("");
 });
 
 it("works with show", () => {
   const ContentSlot = createContentSlot();
   const showFirst = ref(false);
   const showSecond = ref(false);
-  const tree = renderTree(
+  const tree = (
     <>
       <ContentSlot.WhenEmpty>Empty list!</ContentSlot.WhenEmpty>
       <ContentSlot>
@@ -152,14 +143,14 @@ it("works with show", () => {
           <Show when={showSecond.value}>Two</Show>
         </List>
       </ContentSlot>
-    </>,
+    </>
   );
-  expect(printTree(tree)).toBe(`Empty list!`);
+  expect(tree).toRenderTo("Empty list!");
   showFirst.value = true;
-  expect(printTree(tree)).toBe(`One`);
+  expect(tree).toRenderTo("One");
   showSecond.value = true;
-  expect(printTree(tree)).toBe(`One, Two`);
+  expect(tree).toRenderTo("One, Two");
   showFirst.value = false;
   showSecond.value = false;
-  expect(printTree(tree)).toBe(`Empty list!`);
+  expect(tree).toRenderTo("Empty list!");
 });

package/test/components/prose.test.tsx

@@ -1,6 +1,5 @@
 import { describe, expect, it } from "vitest";
 import { Prose } from "../../src/components/Prose.jsx";
-import "../../testing/extend-expect.js";
 import { d } from "../../testing/render.js";
 
 describe("Prose", () => {

package/test/components/reference-or-content.test.tsx

@@ -13,7 +13,6 @@ import {
   SourceFile,
   useBinder,
 } from "../../src/index.js";
-import { d, renderToString } from "../../testing/render.js";
 
 function TestWrapper(props: { children: Children }) {
   const GetBinder = createTap(() => useBinder());
@@ -47,7 +46,7 @@ describe("render the reference name if a declaration exists", () => {
       </TestWrapper>
     );
 
-    expect(renderToString(template)).toEqual(d`
+    expect(template).toRenderTo(`
       Declare A
       A
     `);
@@ -64,10 +63,10 @@ describe("render the reference name if a declaration exists", () => {
       </TestWrapper>
     );
 
-    expect(renderToString(template)).toEqual(d`
-    A
-    Declare A
-  `);
+    expect(template).toRenderTo(`
+      A
+      Declare A
+    `);
   });
 });
 
@@ -79,7 +78,7 @@ it("render content if there is not declaration attached to symbol", () => {
     </TestWrapper>
   );
 
-  expect(renderToString(template)).toEqual(d`
+  expect(template).toRenderTo(`
     No Reference A
   `);
 });
@@ -97,7 +96,7 @@ it("mixed", () => {
     </TestWrapper>
   );
 
-  expect(renderToString(template)).toEqual(d`
+  expect(template).toRenderTo(`
     Declare A
     A
     No Reference B
@@ -130,7 +129,7 @@ it("resolve ref via source file reference", () => {
     </Output>
   );
 
-  expect(renderToString(template)).toEqual(d`
+  expect(template).toRenderTo(`
     Declare A
     ViaRef.A
   `);

package/test/components/source-file.test.tsx

@@ -8,13 +8,11 @@ import {
   Output,
   Prose,
   render,
-  renderTree,
   SourceFile,
   useContext,
 } from "@alloy-js/core";
 import { describe, expect, it } from "vitest";
 import { SourceDirectoryContext } from "../../src/context/source-directory.js";
-import "../../testing/extend-expect.js";
 import { d } from "../../testing/render.js";
 
 it("tracks its content", () => {
@@ -22,14 +20,16 @@ it("tracks its content", () => {
   function Test() {
     context = useContext(SourceDirectoryContext);
   }
-  const _ = renderTree(
+  expect(
     <Output>
       <Test />
       <SourceFile path="hi.txt" filetype="text">
         hello!
       </SourceFile>
     </Output>,
-  );
+  ).toRenderTo({
+    "hi.txt": "hello!",
+  });
   expect(context!.contents.length).toEqual(1);
 });
 

package/test/components/template-file.test.tsx

@@ -6,7 +6,6 @@ import {
   TemplateFile,
   TemplateVariable,
 } from "../../src/components/TemplateFile.jsx";
-import "../../testing/extend-expect.js";
 import { d } from "../../testing/render.js";
 
 describe("TemplateFile", () => {

package/test/components/update-file.test.tsx

@@ -4,7 +4,6 @@ import { join } from "pathe";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
 import { UpdateFile } from "../../src/components/UpdateFile.jsx";
 import { render } from "../../src/render-output.js";
-import "../../testing/extend-expect.js";
 import { d } from "../../testing/render.js";
 
 describe("UpdateFile", () => {

package/test/components/wrap.test.tsx

@@ -1,8 +1,6 @@
 import { ref } from "@vue/reactivity";
 import { expect, it } from "vitest";
 import { Wrap } from "../../src/components/Wrap.jsx";
-import { printTree, renderTree } from "../../src/test-render.js";
-import "../../testing/extend-expect.js";
 
 function Wrapper(props: any) {
   return <>[{props.children}]</>;
@@ -33,10 +31,10 @@ it("works reactively", () => {
     </>
   );
 
-  const tree = renderTree(template);
-  expect(printTree(tree)).toEqual(`testing`);
+  const tree = template;
+  expect(tree).toRenderTo("testing");
 
   doWrap.value = true;
 
-  expect(printTree(tree)).toEqual(`testing`);
+  expect(tree).toRenderTo("testing");
 });

package/test/control-flow/for.test.tsx

@@ -1,14 +1,7 @@
-import "@alloy-js/core/testing";
 import { d } from "@alloy-js/core/testing";
 import { describe, expect, it } from "vitest";
 import { For } from "../../src/components/For.jsx";
-import {
-  onCleanup,
-  printTree,
-  reactive,
-  ref,
-  renderTree,
-} from "../../src/index.js";
+import { onCleanup, reactive, ref } from "../../src/index.js";
 import { flushJobs } from "../../src/scheduler.js";
 
 it("works", () => {
@@ -103,14 +96,18 @@ it("doesn't rerender mappers", () => {
   const messages = reactive(["hi", "bye"]);
   let count = 0;
   const template = <For each={messages}>{() => <>item {count++}</>}</For>;
-  const tree = renderTree(template);
+  const tree = <>{template}</>;
+  expect(tree).toRenderTo(`
+    item 0
+    item 1
+  `);
   expect(count).toBe(2);
 
   messages.push("maybe");
   flushJobs();
 
   expect(count).toBe(3);
-  expect(printTree(tree)).toBe(d`
+  expect(tree).toRenderTo(`
     item 0
     item 1
     item 2
@@ -121,13 +118,17 @@ it("doesn't rerender mappers with sets", () => {
   const messages = reactive(new Set(["hi", "bye"]));
   let count = 0;
   const template = <For each={messages}>{() => <>item {count++}</>}</For>;
-  const tree = renderTree(template);
+  const tree = <>{template}</>;
+  expect(tree).toRenderTo(`
+    item 0
+    item 1
+  `);
   expect(count).toBe(2);
 
   messages.add("maybe");
   flushJobs();
   expect(count).toBe(3);
-  expect(printTree(tree)).toBe(d`
+  expect(tree).toRenderTo(`
     item 0
     item 1
     item 2
@@ -144,13 +145,17 @@ it("doesn't rerender mappers with maps", () => {
 
   let count = 0;
   const template = <For each={messages}>{() => <>item {count++}</>}</For>;
-  const tree = renderTree(template);
+  const tree = <>{template}</>;
+  expect(tree).toRenderTo(`
+    item 0
+    item 1
+  `);
   expect(count).toBe(2);
 
   messages.set("maybe", "three");
   flushJobs();
   expect(count).toBe(3);
-  expect(printTree(tree)).toBe(d`
+  expect(tree).toRenderTo(`
     item 0
     item 1
     item 2
@@ -167,7 +172,12 @@ it("doesn't rerender mappers (with splice)", () => {
       }}
     </For>
   );
-  const tree = renderTree(template);
+  const tree = <>{template}</>;
+  expect(tree).toRenderTo(`
+    item 0
+    item 1
+    item 2
+  `);
   expect(count).toBe(3);
   messages.splice(1, 1);
   flushJobs();
@@ -175,7 +185,7 @@ it("doesn't rerender mappers (with splice)", () => {
   // but for now we re-render everything after the splice point.
   expect(count).toBe(4);
 
-  expect(printTree(tree)).toBe(d`
+  expect(tree).toRenderTo(`
     item 0
     item 3
   `);
@@ -196,10 +206,10 @@ it("cleans up things which end up removed (with push)", () => {
 
   const template = <For each={items}>{(item) => <Letter letter={item} />}</For>;
 
-  const tree = renderTree(template);
+  const tree = <>{template}</>;
 
   expect(cleanups).toEqual([]);
-  expect(printTree(tree)).toBe(d`
+  expect(tree).toRenderTo(`
     Letter a
     Letter b
   `);
@@ -207,14 +217,14 @@ it("cleans up things which end up removed (with push)", () => {
   items.pop();
   flushJobs();
   expect(cleanups).toEqual(["b"]);
-  expect(printTree(tree)).toBe(d`
+  expect(tree).toRenderTo(`
     Letter a
   `);
 
   items.pop();
   flushJobs();
   expect(cleanups).toEqual(["b", "a"]);
-  expect(printTree(tree)).toBe("");
+  expect(tree).toRenderTo("");
 });
 
 it("cleans up things which end up removed (with splice)", () => {
@@ -232,10 +242,10 @@ it("cleans up things which end up removed (with splice)", () => {
 
   const template = <For each={items}>{(item) => <Letter letter={item} />}</For>;
 
-  const tree = renderTree(template);
+  const tree = <>{template}</>;
 
   expect(cleanups).toEqual([]);
-  expect(printTree(tree)).toBe(d`
+  expect(tree).toRenderTo(`
     Letter a
     Letter b
     Letter c
@@ -246,7 +256,7 @@ it("cleans up things which end up removed (with splice)", () => {
   // A sufficiently smart mapJoin would be able to handle this case...
   // but for now we re-render everything after the splice point.
   expect(cleanups).toEqual(["b", "c"]);
-  expect(printTree(tree)).toBe(d`
+  expect(tree).toRenderTo(`
     Letter a
     Letter c
   `);
@@ -254,10 +264,8 @@ it("cleans up things which end up removed (with splice)", () => {
 
 it("doesn't render empty content", () => {
   const items = [1, 2, 3];
-  const tree = renderTree(
-    <For each={items}>{(item) => (item > 2 ? item : null)}</For>,
-  );
-  expect(printTree(tree)).toBe(`3`);
+  const tree = <For each={items}>{(item) => (item > 2 ? item : null)}</For>;
+  expect(tree).toRenderTo("3");
 });
 
 it("updates joiners appropriately when items get/lose content", () => {
@@ -267,16 +275,16 @@ it("updates joiners appropriately when items get/lose content", () => {
     { content: ref("hello") },
   ];
 
-  const tree = renderTree(
+  const tree = (
     <For each={items} joiner=", ">
       {(item) => {
         return item.content;
       }}
-    </For>,
+    </For>
   );
 
-  expect(printTree(tree)).toBe(`hello`);
+  expect(tree).toRenderTo("hello");
   items[1].content.value = "hi";
   flushJobs();
-  expect(printTree(tree)).toBe(`hi, hello`);
+  expect(tree).toRenderTo("hi, hello");
 });