@alloy-js/core 0.19.0-dev.1 → 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.ts

@@ -7,8 +7,8 @@ import {
 } from "@alloy-js/core";
 import "vitest";
 import { expect } from "vitest";
+import { flushJobs, flushJobsAsync } from "../src/scheduler.js";
 import { dedent } from "./render.js";
-import "./vitest.d.ts";
 
 interface ToRenderToOptions {
   printWidth?: number;
@@ -22,67 +22,82 @@ expect.extend({
     expectedRaw: string | Record<string, string>,
     renderOptions?: ToRenderToOptions,
   ) {
-    const message = () => `Render is${isNot ? " not" : ""} incorrect`;
+    const tree = renderTree(received);
+    flushJobs();
+    const actual = getFilesFromTree(tree, renderOptions);
 
-    const { isNot } = this;
-    const actual = renderAsFiles(received, renderOptions);
-    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: 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,
-      };
+    return validateRender(actual, expectedRaw, this.isNot);
+  },
+  async toRenderToAsync(
+    received: Children,
+    expectedRaw: string | Record<string, string>,
+    renderOptions?: ToRenderToOptions,
+  ) {
+    const tree = renderTree(received);
+    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: expectedRaw,
+        expected,
       };
     }
-  },
-});
+    return {
+      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,
+    };
+  }
+}
 
-function renderAsFiles(
-  received: Children,
-  options?: ToRenderToOptions,
-): Record<string, string> | string {
+function getFilesFromTree(tree: RenderedTextTree, options?: ToRenderToOptions) {
   const files: Record<string, string> = {};
-  const tree = renderTree(received);
-
   // when passing Output, the first render tree child is the Output component.
   const rootRenderOptions =
     Array.isArray(tree) ?
@@ -91,6 +106,13 @@ function renderAsFiles(
     : {};
 
   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;
@@ -121,11 +143,4 @@ function renderAsFiles(
       }
     }
   }
-
-  // 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;
-  }
 }

package/testing/vitest.d.ts

@@ -11,6 +11,10 @@ interface CustomMatchers<R = unknown> {
     str: string | Record<string, string>,
     options?: ToRenderToRenderOptions,
   ) => R;
+  toRenderToAsync: (
+    str: string | Record<string, string>,
+    options?: ToRenderToRenderOptions,
+  ) => Promise<R>;
 }
 
 declare module "vitest" {

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.");
-}