@alloy-js/core 0.19.0-dev.3 → 0.19.0

package/dist/test/components/copy-file.test.d.ts

@@ -0,0 +1,2 @@
+import "../../testing/extend-expect.js";
+//# sourceMappingURL=copy-file.test.d.ts.map

package/dist/test/components/copy-file.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"copy-file.test.d.ts","sourceRoot":"","sources":["../../../test/components/copy-file.test.tsx"],"names":[],"mappings":"AAQA,OAAO,gCAAgC,CAAC"}

package/dist/test/components/copy-file.test.js

@@ -0,0 +1,94 @@
+import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { CopyFile } from "../../src/components/CopyFile.js";
+import { SourceDirectory } from "../../src/components/SourceDirectory.js";
+import { render } from "../../src/render.js";
+import { writeOutput } from "../../src/write-output.js";
+import "../../testing/extend-expect.js";
+describe("CopyFile", () => {
+  let testDir;
+  let sourceFile;
+  let targetFile;
+  beforeEach(() => {
+    // Create unique temporary paths for each test
+    testDir = tmpdir();
+    sourceFile = join(testDir, "source.txt");
+    targetFile = join(testDir, "target.txt");
+  });
+  afterEach(() => {
+    // Clean up test files after each test
+    if (existsSync(sourceFile)) {
+      unlinkSync(sourceFile);
+    }
+    if (existsSync(targetFile)) {
+      unlinkSync(targetFile);
+    }
+  });
+  it("should create copy file context with correct paths", async () => {
+    writeFileSync(sourceFile, "Hello, World!", "utf-8");
+    const result = _$createComponent(SourceDirectory, {
+      path: testDir,
+      get children() {
+        return _$createComponent(CopyFile, {
+          src: sourceFile,
+          path: "target.txt"
+        });
+      }
+    });
+    const output = render(result);
+    await writeOutput(output);
+    expect(output.contents).toHaveLength(1);
+    const copyFileOutput = output.contents[0];
+    expect(copyFileOutput.kind).toBe("file");
+    expect(copyFileOutput.sourcePath).toBe(sourceFile);
+    expect(copyFileOutput.path).toBe(join(testDir, "target.txt"));
+    expect(existsSync(targetFile)).toBe(true);
+    const targetContent = readFileSync(targetFile, "utf-8");
+    expect(targetContent).toBe("Hello, World!");
+  });
+  it("should handle relative paths correctly", async () => {
+    // Create source file
+    writeFileSync(sourceFile, "Relative path test", "utf-8");
+    const result = _$createComponent(SourceDirectory, {
+      path: testDir,
+      get children() {
+        return _$createComponent(SourceDirectory, {
+          path: "subdir",
+          get children() {
+            return _$createComponent(CopyFile, {
+              src: sourceFile,
+              path: "nested-target.txt"
+            });
+          }
+        });
+      }
+    });
+    const output = render(result);
+
+    // Find the copy file in the nested directory
+    const subdir = output.contents.find(item => item.kind === "directory" && item.path === join(testDir, "subdir"));
+    expect(subdir).toBeDefined();
+    if (subdir && subdir.kind === "directory") {
+      expect(subdir.contents).toHaveLength(1);
+      const copyFile = subdir.contents[0];
+      expect(copyFile.kind).toBe("file");
+      if (copyFile.kind === "file" && "sourcePath" in copyFile) {
+        expect(copyFile.sourcePath).toBe(sourceFile);
+        expect(copyFile.path).toBe(join(testDir, "subdir", "nested-target.txt"));
+      }
+    }
+  });
+  it("should throw error when used without SourceDirectory context", () => {
+    // Create source file
+    writeFileSync(sourceFile, "Error test", "utf-8");
+    expect(() => {
+      render(_$createComponent(CopyFile, {
+        src: sourceFile,
+        path: "target.txt"
+      }));
+    }).toThrow("Copy file doesn't have parent directory");
+  });
+});

package/dist/test/components/source-file.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"source-file.test.d.ts","sourceRoot":"","sources":["../../../test/components/source-file.test.tsx"],"names":[],"mappings":"AAUA,OAAO,gCAAgC,CAAC"}
+{"version":3,"file":"source-file.test.d.ts","sourceRoot":"","sources":["../../../test/components/source-file.test.tsx"],"names":[],"mappings":"AAWA,OAAO,gCAAgC,CAAC"}

package/dist/test/components/template-file.test.d.ts

@@ -0,0 +1,2 @@
+import "../../testing/extend-expect.js";
+//# sourceMappingURL=template-file.test.d.ts.map

package/dist/test/components/template-file.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-file.test.d.ts","sourceRoot":"","sources":["../../../test/components/template-file.test.tsx"],"names":[],"mappings":"AASA,OAAO,gCAAgC,CAAC"}

package/dist/test/components/template-file.test.js

@@ -0,0 +1,133 @@
+import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import { writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { describe, expect, it } from "vitest";
+import { TemplateFile, TemplateVariable } from "../../src/components/TemplateFile.js";
+import { renderAsync } from "../../src/render.js";
+import "../../testing/extend-expect.js";
+import { d } from "../../testing/render.js";
+describe("TemplateFile", () => {
+  it("should replace template variables with values", async () => {
+    // Create a temporary template file
+    const templatePath = join(tmpdir(), "test-template.txt");
+    const templateContent = "Hello {{ name }}! You are {{ age }} years old.";
+    writeFileSync(templatePath, templateContent);
+    const result = _$createComponent(TemplateFile, {
+      src: templatePath,
+      path: "output.txt",
+      get children() {
+        return [_$createComponent(TemplateVariable, {
+          name: "name",
+          value: "John"
+        }), _$createComponent(TemplateVariable, {
+          name: "age",
+          value: "25"
+        })];
+      }
+    });
+    await expect(result).toRenderToAsync("Hello John! You are 25 years old.");
+  });
+  it("should handle template variables with children", async () => {
+    const templatePath = join(tmpdir(), "test-template-children.txt");
+    const templateContent = "Welcome {{ greeting }}!";
+    writeFileSync(templatePath, templateContent);
+    const result = _$createComponent(TemplateFile, {
+      src: templatePath,
+      path: "output.txt",
+      get children() {
+        return _$createComponent(TemplateVariable, {
+          name: "greeting",
+          children: "Hello World"
+        });
+      }
+    });
+    await expect(result).toRenderToAsync("Welcome Hello World!");
+  });
+  it("should handle complex templates with multiple variables", async () => {
+    const templatePath = join(tmpdir(), "test-complex-template.txt");
+    const templateContent = d`
+      Name: {{ name }}
+      Age: {{ age }}
+      Location: {{ location }}
+      Status: {{ status }}
+    `;
+    writeFileSync(templatePath, templateContent);
+    const result = _$createComponent(TemplateFile, {
+      src: templatePath,
+      path: "output.txt",
+      get children() {
+        return [_$createComponent(TemplateVariable, {
+          name: "name",
+          value: "Alice"
+        }), _$createComponent(TemplateVariable, {
+          name: "age",
+          children: "30"
+        }), _$createComponent(TemplateVariable, {
+          name: "location",
+          value: "New York"
+        }), _$createComponent(TemplateVariable, {
+          name: "status",
+          value: "Active"
+        })];
+      }
+    });
+    await expect(result).toRenderToAsync(d`
+      Name: Alice
+      Age: 30
+      Location: New York
+      Status: Active
+    `);
+  });
+  it("should handle templates with whitespace around variable names", async () => {
+    const templatePath = join(tmpdir(), "test-whitespace-template.txt");
+    const templateContent = "Hello {{  name  }}!";
+    writeFileSync(templatePath, templateContent);
+    const result = _$createComponent(TemplateFile, {
+      src: templatePath,
+      path: "output.txt",
+      get children() {
+        return _$createComponent(TemplateVariable, {
+          name: "name",
+          value: "Bob"
+        });
+      }
+    });
+    await expect(result).toRenderToAsync("Hello Bob!");
+  });
+  it("should throw error for missing template variables", async () => {
+    const templatePath = join(tmpdir(), "test-missing-var-template.txt");
+    const templateContent = "Hello {{ name }}! Your age is {{ age }}.";
+    writeFileSync(templatePath, templateContent);
+    await expect(async () => await renderAsync(_$createComponent(TemplateFile, {
+      src: templatePath,
+      path: "output.txt",
+      get children() {
+        return _$createComponent(TemplateVariable, {
+          name: "name",
+          value: "Charlie"
+        });
+      }
+    }))).rejects.toThrow('Template variable "age" not found in TemplateVariable children');
+  });
+  it("should handle template with no variables", async () => {
+    const templatePath = join(tmpdir(), "test-no-vars-template.txt");
+    const templateContent = "This is just plain text with no variables.";
+    writeFileSync(templatePath, templateContent);
+    const result = _$createComponent(TemplateFile, {
+      src: templatePath,
+      path: "output.txt"
+    });
+    await expect(result).toRenderToAsync("This is just plain text with no variables.");
+  });
+  it("should handle empty template", async () => {
+    const templatePath = join(tmpdir(), "test-empty-template.txt");
+    const templateContent = "";
+    writeFileSync(templatePath, templateContent);
+    const result = _$createComponent(TemplateFile, {
+      src: templatePath,
+      path: "output.txt"
+    });
+    await expect(result).toRenderToAsync("");
+  });
+});

package/dist/test/components/update-file.test.d.ts

@@ -0,0 +1,2 @@
+import "../../testing/extend-expect.js";
+//# sourceMappingURL=update-file.test.d.ts.map

package/dist/test/components/update-file.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-file.test.d.ts","sourceRoot":"","sources":["../../../test/components/update-file.test.tsx"],"names":[],"mappings":"AAMA,OAAO,gCAAgC,CAAC"}

package/dist/test/components/update-file.test.js

@@ -0,0 +1,169 @@
+import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+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.js";
+import { render } from "../../src/render.js";
+import "../../testing/extend-expect.js";
+import { d } from "../../testing/render.js";
+describe("UpdateFile", () => {
+  let testFilePath;
+  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 = _$createComponent(UpdateFile, {
+        path: testFilePath,
+        children: currentContents => {
+          return `${currentContents?.toUpperCase()}`;
+        }
+      });
+      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 = _$createComponent(UpdateFile, {
+        path: testFilePath,
+        children: currentContents => {
+          const config = JSON.parse(currentContents);
+          config.version = "2.0.0";
+          config.newProperty = "added";
+          return JSON.stringify(config, null, 2);
+        }
+      });
+      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 = _$createComponent(UpdateFile, {
+        path: testFilePath,
+        children: currentContents => {
+          const lines = currentContents.split("\n");
+          const modifiedLines = lines.map(line => `// ${line}`);
+          return modifiedLines.join("\n");
+        }
+      });
+      await expect(result).toRenderToAsync(d`
+        // line 1
+        // line 2
+        // line 3
+      `);
+    });
+    it("should handle empty existing file", async () => {
+      writeFileSync(testFilePath, "", "utf-8");
+      const result = _$createComponent(UpdateFile, {
+        path: testFilePath,
+        children: currentContents => {
+          return `Content was: "${currentContents || "empty"}"`;
+        }
+      });
+      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 = _$createComponent(UpdateFile, {
+        path: "non-existent.txt",
+        defaultContent: "default content",
+        children: currentContents => {
+          if (currentContents === null) {
+            return `File did not exist`;
+          }
+          return `File existed with: ${currentContents}`;
+        }
+      });
+      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 = _$createComponent(UpdateFile, {
+          path: "non-existent.txt",
+          defaultContentPath: defaultFilePath,
+          children: currentContents => {
+            return `Default: ${currentContents}`;
+          }
+        });
+        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 = _$createComponent(UpdateFile, {
+        path: "non-existent.txt",
+        children: currentContents => {
+          if (currentContents === null) {
+            return `Creating new file`;
+          }
+          return `Updating existing file: ${currentContents}`;
+        }
+      });
+      await expect(result).toRenderToAsync("Creating new file");
+    });
+    it("should create JSON file from scratch when it doesn't exist", async () => {
+      const result = _$createComponent(UpdateFile, {
+        path: "new-config.json",
+        children: currentContents => {
+          const config = currentContents ? JSON.parse(currentContents) : {};
+          config.name = "new-project";
+          config.version = "1.0.0";
+          config.dependencies = {};
+          return JSON.stringify(config, null, 2);
+        }
+      });
+      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(_$createComponent(UpdateFile, {
+        path: "non-existent.txt",
+        defaultContentPath: "/path/that/does/not/exist.txt",
+        children: currentContents => currentContents
+      }))).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(_$createComponent(UpdateFile, {
+        path: dirPath,
+        children: currentContents => currentContents
+      }))).toThrow();
+    });
+  });
+});

package/dist/test/rendering/formatting.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"formatting.test.d.ts","sourceRoot":"","sources":["../../../test/rendering/formatting.test.tsx"],"names":[],"mappings":"AAEA,OAAO,gCAAgC,CAAC"}
+{"version":3,"file":"formatting.test.d.ts","sourceRoot":"","sources":["../../../test/rendering/formatting.test.tsx"],"names":[],"mappings":"AAQA,OAAO,gCAAgC,CAAC"}

package/dist/testing/extend-expect.js

@@ -1,68 +1,81 @@
 import { getContextForRenderNode, printTree, renderTree } from "@alloy-js/core";
 import "vitest";
 import { expect } from "vitest";
+import { flushJobs, flushJobsAsync } from "../src/scheduler.js";
 import { dedent } from "./render.js";
 expect.extend({
   toRenderTo(received, expectedRaw, renderOptions) {
-    const message = () => `Render is${isNot ? " not" : ""} incorrect`;
-    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 = {};
-      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
-      };
+    const tree = renderTree(received);
+    flushJobs();
+    const actual = getFilesFromTree(tree, renderOptions);
+    return validateRender(actual, expectedRaw, this.isNot);
+  },
+  async toRenderToAsync(received, expectedRaw, renderOptions) {
+    const tree = renderTree(received);
+    await flushJobsAsync();
+    const actual = getFilesFromTree(tree, renderOptions);
+    return validateRender(actual, expectedRaw, this.isNot);
+  }
+});
+function validateRender(actual, expectedRaw, isNot) {
+  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 = {};
+    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, options) {
+}
+function getFilesFromTree(tree, options) {
   const files = {};
-  const tree = renderTree(received);
-
   // when passing Output, the first render tree child is the Output component.
   const rootRenderOptions = Array.isArray(tree) ? getContextForRenderNode(tree[0])?.meta?.printOptions ?? {} : {};
   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) {
     if (!Array.isArray(root)) {
       return;
@@ -83,11 +96,4 @@ function renderAsFiles(received, options) {
       }
     }
   }
-
-  // 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;
-  }
 }