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

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.d.ts

@@ -1,17 +1,2 @@
 import "vitest";
-interface ToRenderToRenderOptions {
-    printWidth?: number;
-    tabWidth?: number;
-    useTabs?: boolean;
-}
-interface CustomMatchers<R = unknown> {
-    toRenderTo: (str: string, options?: ToRenderToRenderOptions) => R;
-}
-declare module "vitest" {
-    interface Assertion<T = any> extends CustomMatchers<T> {
-    }
-    interface AsymmetricMatchersContaining extends CustomMatchers {
-    }
-}
-export {};
 //# sourceMappingURL=extend-expect.d.ts.map

package/dist/testing/extend-expect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extend-expect.d.ts","sourceRoot":"","sources":["../../testing/extend-expect.ts"],"names":[],"mappings":"AA+BA,OAAO,QAAQ,CAAC;AAEhB,UAAU,uBAAuB;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AACD,UAAU,cAAc,CAAC,CAAC,GAAG,OAAO;IAClC,UAAU,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,uBAAuB,KAAK,CAAC,CAAC;CACnE;AAED,OAAO,QAAQ,QAAQ,CAAC;IACtB,UAAU,SAAS,CAAC,CAAC,GAAG,GAAG,CAAE,SAAQ,cAAc,CAAC,CAAC,CAAC;KAAG;IACzD,UAAU,4BAA6B,SAAQ,cAAc;KAAG;CACjE"}
+{"version":3,"file":"extend-expect.d.ts","sourceRoot":"","sources":["../../testing/extend-expect.ts"],"names":[],"mappings":"AAOA,OAAO,QAAQ,CAAC"}

package/dist/testing/extend-expect.js

@@ -1,22 +1,99 @@
-import { printTree, renderTree } from "@alloy-js/core";
+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 {
-      isNot
-    } = this;
     const tree = renderTree(received);
-    const actual = printTree(tree, renderOptions);
+    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
+      };
+    }
     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 = {};
+    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, options) {
+  const files = {};
+  // 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;
+    }
+    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();
+    }
+    function visitChildren() {
+      for (const child of root) {
+        collectSourceFiles(child);
+      }
+    }
+  }
+}

package/dist/testing/extend-expect.test.d.ts

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

package/dist/testing/extend-expect.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extend-expect.test.d.ts","sourceRoot":"","sources":["../../testing/extend-expect.test.tsx"],"names":[],"mappings":"AAEA,OAAO,oBAAoB,CAAC"}