@alloy-js/core 0.19.0-dev.0 → 0.19.0-dev.12

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

@@ -0,0 +1,214 @@
+import { existsSync, unlinkSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "pathe";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { UpdateFile } from "../../src/components/UpdateFile.jsx";
+import { render } from "../../src/render.js";
+import "../../testing/extend-expect.js";
+import { d } from "../../testing/render.js";
+
+describe("UpdateFile", () => {
+  let testFilePath: string;
+
+  beforeEach(() => {
+    testFilePath = join(tmpdir(), "test-file.txt");
+  });
+
+  afterEach(() => {
+    if (existsSync(testFilePath)) {
+      unlinkSync(testFilePath);
+    }
+  });
+
+  describe("when file exists", () => {
+    it("should read existing file and transform content", async () => {
+      const existingContent = "Hello World";
+      writeFileSync(testFilePath, existingContent, "utf-8");
+
+      const result = (
+        <UpdateFile path={testFilePath}>
+          {(currentContents) => {
+            return `${currentContents?.toUpperCase()}`;
+          }}
+        </UpdateFile>
+      );
+
+      await expect(result).toRenderToAsync("HELLO WORLD");
+    });
+
+    it("should handle JSON file updates", async () => {
+      const existingConfig = { version: "1.0.0", name: "test" };
+      writeFileSync(testFilePath, JSON.stringify(existingConfig), "utf-8");
+
+      const result = (
+        <UpdateFile path={testFilePath}>
+          {(currentContents) => {
+            const config = JSON.parse(currentContents!);
+            config.version = "2.0.0";
+            config.newProperty = "added";
+            return JSON.stringify(config, null, 2);
+          }}
+        </UpdateFile>
+      );
+
+      await expect(result).toRenderToAsync(d`
+        {
+          "version": "2.0.0",
+          "name": "test",
+          "newProperty": "added"
+        }
+      `);
+    });
+
+    it("should handle multiline content transformation", async () => {
+      const existingContent = d`
+        line 1
+        line 2
+        line 3
+      `;
+      writeFileSync(testFilePath, existingContent, "utf-8");
+
+      const result = (
+        <UpdateFile path={testFilePath}>
+          {(currentContents) => {
+            const lines = currentContents!.split("\n");
+            const modifiedLines = lines.map((line) => `// ${line}`);
+            return modifiedLines.join("\n");
+          }}
+        </UpdateFile>
+      );
+
+      await expect(result).toRenderToAsync(d`
+        // line 1
+        // line 2
+        // line 3
+      `);
+    });
+
+    it("should handle empty existing file", async () => {
+      writeFileSync(testFilePath, "", "utf-8");
+
+      const result = (
+        <UpdateFile path={testFilePath}>
+          {(currentContents) => {
+            return `Content was: "${currentContents || "empty"}"`;
+          }}
+        </UpdateFile>
+      );
+
+      await expect(result).toRenderToAsync('Content was: "empty"');
+    });
+  });
+
+  describe("when file does not exist", () => {
+    it("should use defaultContent when file does not exist", async () => {
+      const result = (
+        <UpdateFile path="non-existent.txt" defaultContent="default content">
+          {(currentContents) => {
+            if (currentContents === null) {
+              return `File did not exist`;
+            }
+            return `File existed with: ${currentContents}`;
+          }}
+        </UpdateFile>
+      );
+
+      await expect(result).toRenderToAsync("File did not exist");
+    });
+
+    it("should use defaultContentPath when file does not exist", async () => {
+      const defaultFilePath = join(
+        tmpdir(),
+        `default-content-${Date.now()}.txt`,
+      );
+      const defaultContent = "This is default content from file";
+      writeFileSync(defaultFilePath, defaultContent, "utf-8");
+
+      try {
+        const result = (
+          <UpdateFile
+            path="non-existent.txt"
+            defaultContentPath={defaultFilePath}
+          >
+            {(currentContents) => {
+              return `Default: ${currentContents}`;
+            }}
+          </UpdateFile>
+        );
+
+        await expect(result).toRenderToAsync(
+          "Default: This is default content from file",
+        );
+      } finally {
+        if (existsSync(defaultFilePath)) {
+          unlinkSync(defaultFilePath);
+        }
+      }
+    });
+
+    it("should pass null to children when no default content provided", async () => {
+      const result = (
+        <UpdateFile path="non-existent.txt">
+          {(currentContents) => {
+            if (currentContents === null) {
+              return `Creating new file`;
+            }
+            return `Updating existing file: ${currentContents}`;
+          }}
+        </UpdateFile>
+      );
+
+      await expect(result).toRenderToAsync("Creating new file");
+    });
+
+    it("should create JSON file from scratch when it doesn't exist", async () => {
+      const result = (
+        <UpdateFile path="new-config.json">
+          {(currentContents) => {
+            const config = currentContents ? JSON.parse(currentContents) : {};
+            config.name = "new-project";
+            config.version = "1.0.0";
+            config.dependencies = {};
+            return JSON.stringify(config, null, 2);
+          }}
+        </UpdateFile>
+      );
+
+      await expect(result).toRenderToAsync(d`
+        {
+          "name": "new-project",
+          "version": "1.0.0",
+          "dependencies": {}
+        }
+      `);
+    });
+  });
+
+  describe("error handling", () => {
+    it("should throw error when defaultContentPath file does not exist", async () => {
+      expect(() =>
+        render(
+          <UpdateFile
+            path="non-existent.txt"
+            defaultContentPath="/path/that/does/not/exist.txt"
+          >
+            {(currentContents) => currentContents}
+          </UpdateFile>,
+        ),
+      ).toThrow();
+    });
+
+    it("should handle file system errors gracefully", async () => {
+      // Try to read a directory as a file (should cause an error)
+      const dirPath = join(tmpdir(), `test-dir-${Date.now()}`);
+
+      expect(() =>
+        render(
+          <UpdateFile path={dirPath}>
+            {(currentContents) => currentContents}
+          </UpdateFile>,
+        ),
+      ).toThrow();
+    });
+  });
+});

package/test/rendering/formatting.test.tsx

@@ -1,5 +1,11 @@
 import { describe, expect, it } from "vitest";
-import { For, Output, render, SourceFile } from "../../src/index.js";
+import {
+  ContentOutputFile,
+  For,
+  Output,
+  render,
+  SourceFile,
+} from "../../src/index.js";
 import "../../testing/extend-expect.js";
 import { d } from "../../testing/render.js";
 
@@ -454,7 +460,7 @@ it("formats based on the output component props", () => {
   );
 
   const tree = render(template);
-  expect(tree.contents[0].contents).toEqual(d`
+  expect((tree.contents[0] as ContentOutputFile).contents).toEqual(d`
     1
     2
     3
@@ -476,7 +482,7 @@ it("formats based on the source file component props", () => {
   );
 
   const tree = render(template);
-  expect(tree.contents[0].contents).toEqual(d`
+  expect((tree.contents[0] as ContentOutputFile).contents).toEqual(d`
     1
     2
     3

package/testing/extend-expect.test.tsx

@@ -0,0 +1,126 @@
+import { Indent, Output, SourceDirectory, SourceFile } from "@alloy-js/core";
+import { describe, expect, it } from "vitest";
+import "./extend-expect.js";
+
+describe("toRenderTo", () => {
+  it("can validate structure without source files", () => {
+    expect(
+      <>
+        base
+        <Indent>indented</Indent>
+      </>,
+    ).toRenderTo(`
+      base
+        indented
+      `);
+  });
+
+  it("can expect the content of the single source file used", () => {
+    expect(
+      <Output>
+        <SourceFile path="Test.cs" tabWidth={4} filetype="csharp">
+          base
+          <Indent>indented</Indent>
+        </SourceFile>
+      </Output>,
+    ).toRenderTo(`
+        base
+            indented
+        `);
+  });
+
+  it("expect with specific file name", () => {
+    expect(
+      <Output>
+        <SourceFile path="Test.cs" tabWidth={4} filetype="csharp">
+          base
+          <Indent>indented</Indent>
+        </SourceFile>
+      </Output>,
+    ).toRenderTo({
+      "Test.cs": `
+        base
+            indented
+        `,
+    });
+  });
+
+  it("expect with specific file name in SourceDirectory", () => {
+    expect(
+      <Output>
+        <SourceDirectory path="src">
+          <SourceFile path="test.txt" filetype="text">
+            content
+          </SourceFile>
+        </SourceDirectory>
+      </Output>,
+    ).toRenderTo({
+      "src/test.txt": `
+          content
+        `,
+    });
+  });
+
+  it("each source file respect their print options", () => {
+    expect(
+      <Output>
+        <SourceFile path="Test.cs" tabWidth={4} filetype="csharp">
+          base1
+          <Indent>indented</Indent>
+        </SourceFile>
+        <SourceFile path="Test.ts" tabWidth={2} filetype="csharp">
+          base2
+          <Indent>indented</Indent>
+        </SourceFile>
+      </Output>,
+    ).toRenderTo({
+      "Test.cs": `
+        base1
+            indented
+        `,
+      "Test.ts": `
+        base2
+          indented
+        `,
+    });
+  });
+
+  it("fails when content does not match", () => {
+    expect(() =>
+      expect(
+        <>
+          base
+          <Indent>indented</Indent>
+        </>,
+      ).toRenderTo(`
+      base
+        wrong
+    `),
+    ).toThrowError(/Render is incorrect/);
+  });
+
+  it("fails when files don't match", () => {
+    expect(() =>
+      expect(
+        <Output>
+          <SourceFile path="Test.cs" tabWidth={4} filetype="csharp">
+            base1
+            <Indent>indented</Indent>
+          </SourceFile>
+          <SourceFile path="Test.ts" tabWidth={2} filetype="typescript">
+            base2
+            <Indent>indented</Indent>
+          </SourceFile>
+        </Output>,
+      ).toRenderTo({
+        "Test.cs": `
+        bad
+        `,
+        "Test.ts": `
+        base2
+          indented
+        `,
+      }),
+    ).toThrowError(/Render is incorrect/);
+  });
+});

package/testing/extend-expect.ts

@@ -1,5 +1,13 @@
-import { Children, printTree, renderTree } from "@alloy-js/core";
+import {
+  Children,
+  getContextForRenderNode,
+  printTree,
+  RenderedTextTree,
+  renderTree,
+} from "@alloy-js/core";
+import "vitest";
 import { expect } from "vitest";
+import { flushJobs, flushJobsAsync } from "../src/scheduler.js";
 import { dedent } from "./render.js";
 
 interface ToRenderToOptions {
@@ -11,36 +19,128 @@ interface ToRenderToOptions {
 expect.extend({
   toRenderTo(
     received: Children,
-    expectedRaw: string,
+    expectedRaw: string | Record<string, string>,
+    renderOptions?: ToRenderToOptions,
+  ) {
+    const tree = renderTree(received);
+    flushJobs();
+    const actual = getFilesFromTree(tree, renderOptions);
+
+    return validateRender(actual, expectedRaw, this.isNot);
+  },
+  async toRenderToAsync(
+    received: Children,
+    expectedRaw: string | Record<string, string>,
     renderOptions?: ToRenderToOptions,
   ) {
-    const { isNot } = this;
     const tree = renderTree(received);
-    const actual = printTree(tree, renderOptions);
+    await flushJobsAsync();
+    const actual = getFilesFromTree(tree, renderOptions);
+    return validateRender(actual, expectedRaw, this.isNot);
+  },
+});
+
+function validateRender(
+  actual: string | Record<string, string>,
+  expectedRaw: string | Record<string, string>,
+  isNot: boolean,
+) {
+  const message = () => `Render is${isNot ? " not" : ""} incorrect`;
+
+  if (typeof expectedRaw === "string") {
     const expected = dedent(expectedRaw);
+    let actualStr;
+    if (typeof actual === "string") {
+      actualStr = actual;
+    } else if (Object.keys(actual).length === 1) {
+      // If we have a single file, we can use its content directly.
+      actualStr = Object.values(actual)[0];
+    } else {
+      return {
+        pass: false,
+        message,
+        actual,
+        expected,
+      };
+    }
     return {
-      pass: actual === expected,
-      message: () => {
-        return `Render is${isNot ? " not" : ""} incorrect`;
-      },
-      actual,
+      pass: actualStr === expected,
+      message,
+      actual: actualStr,
       expected,
     };
-  },
-});
+  } else if (typeof actual === "object" && typeof expectedRaw === "object") {
+    const expected = expectedRaw;
+    const dedentExpected: Record<string, string> = {};
+    for (const [key, value] of Object.entries(expected)) {
+      dedentExpected[key] = dedent(value);
+    }
+    const pass =
+      Object.keys(actual).length === Object.keys(expected).length &&
+      Object.entries(actual).every(([key, value]) => {
+        return dedentExpected[key] === value;
+      });
+    return {
+      pass,
+      message,
+      actual,
+      expected: dedentExpected,
+    };
+  } else {
+    return {
+      pass: false,
+      message,
+      actual,
+      expected: expectedRaw,
+    };
+  }
+}
 
-import "vitest";
+function getFilesFromTree(tree: RenderedTextTree, options?: ToRenderToOptions) {
+  const files: Record<string, string> = {};
+  // when passing Output, the first render tree child is the Output component.
+  const rootRenderOptions =
+    Array.isArray(tree) ?
+      (getContextForRenderNode(tree[0] as RenderedTextTree)?.meta
+        ?.printOptions ?? {})
+    : {};
 
-interface ToRenderToRenderOptions {
-  printWidth?: number;
-  tabWidth?: number;
-  useTabs?: boolean;
-}
-interface CustomMatchers<R = unknown> {
-  toRenderTo: (str: string, options?: ToRenderToRenderOptions) => R;
-}
+  collectSourceFiles(tree);
+  // If we found no source files, we return the tree as a string.
+  if (Object.keys(files).length === 0) {
+    return printTree(tree, options);
+  } else {
+    return files;
+  }
+
+  function collectSourceFiles(root: RenderedTextTree) {
+    if (!Array.isArray(root)) {
+      return;
+    }
+    const context = getContextForRenderNode(root);
+    if (context?.meta?.sourceFile) {
+      files[context.meta.sourceFile.path] = printTree(root, {
+        printWidth:
+          options?.printWidth ??
+          context.meta?.printOptions?.printWidth ??
+          rootRenderOptions.printWidth,
+        tabWidth:
+          options?.tabWidth ??
+          context.meta?.printOptions?.tabWidth ??
+          rootRenderOptions.tabWidth,
+        useTabs:
+          options?.useTabs ??
+          context.meta?.printOptions?.useTabs ??
+          rootRenderOptions.useTabs,
+      });
+    } else {
+      visitChildren();
+    }
 
-declare module "vitest" {
-  interface Assertion<T = any> extends CustomMatchers<T> {}
-  interface AsymmetricMatchersContaining extends CustomMatchers {}
+    function visitChildren() {
+      for (const child of root) {
+        collectSourceFiles(child as RenderedTextTree);
+      }
+    }
+  }
 }

package/testing/vitest.d.ts

@@ -5,8 +5,16 @@ interface ToRenderToRenderOptions {
   tabWidth?: number;
   useTabs?: boolean;
 }
+
 interface CustomMatchers<R = unknown> {
-  toRenderTo: (str: string, options?: ToRenderToRenderOptions) => R;
+  toRenderTo: (
+    str: string | Record<string, string>,
+    options?: ToRenderToRenderOptions,
+  ) => R;
+  toRenderToAsync: (
+    str: string | Record<string, string>,
+    options?: ToRenderToRenderOptions,
+  ) => Promise<R>;
 }
 
 declare module "vitest" {

package/tsconfig.json

@@ -11,7 +11,8 @@
     "test/**/*.ts",
     "test/**/*.tsx",
     "testing/**/*.ts",
-    "testing/**/*.d.ts"
+    "testing/**/*.d.ts",
+    "testing/extend-expect.test.tsx"
   ],
   "exclude": ["node_modules", "dist"]
 }

package/dist/src/write-output.browser.d.ts

@@ -1,2 +0,0 @@
-export declare function writeOutput(output: any, basePath?: string): void;
-//# sourceMappingURL=write-output.browser.d.ts.map

package/dist/src/write-output.browser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"write-output.browser.d.ts","sourceRoot":"","sources":["../../src/write-output.browser.ts"],"names":[],"mappings":"AAAA,wBAAgB,WAAW,CAAC,MAAM,EAAE,GAAG,EAAE,QAAQ,GAAE,MAAW,QAG7D"}

package/dist/src/write-output.browser.js

@@ -1,4 +0,0 @@
-export function writeOutput(output, basePath = "") {
-  // eslint-disable-next-line no-console
-  console.warn("writeOutput is not supported in a browser environment.");
-}

package/src/write-output.browser.ts

@@ -1,4 +0,0 @@
-export function writeOutput(output: any, basePath: string = "") {
-  // eslint-disable-next-line no-console
-  console.warn("writeOutput is not supported in a browser environment.");
-}