eleventy-test 0.1.2 → 1.1.0

package/README.md

@@ -24,13 +24,15 @@ Want to see how it is in action? For the dogfooding fans, you can see this libra
     import { buildScenarios } from "eleventy-test";
     import test from "ava";
 
-    // omit the second parameter to return as array
-    const resultsAsDict = await buildScenarios(cwd(), false);
+    const resultsAsDict = await buildScenarios({
+        projectRoot: cwd(),
+        returnArray: false
+    });
 
-    test("Check if index.html is consistent across builds", t => {
+    test("Check if index.html is consistent across builds", async t => {
         t.deepEqual(
-            results["3--example"].getFileContent("/index.html"), 
-            results["3.0.0--identical-example"].getFileContent("/index.html"));
+            await results["3--example"].getFileContent("/index.html"), 
+            await results["3.0.0--identical-example"].getFileContent("/index.html"));
     });
     ```
 

package/dist/ScenarioOutput.d.ts

@@ -8,5 +8,5 @@ export default class ScenarioOutput {
     get files(): {
         [key: string]: () => string;
     };
-    getFileContent(filename: any): string;
+    getFileContent(filename: any): Promise<string>;
 }

package/dist/eleventyUtils.d.ts

@@ -1,5 +1,8 @@
 import ScenarioOutput from "./ScenarioOutput";
-export declare function ensureEleventyExists(projectRoot: string, eleventyVersion: string): string;
+export declare function determineInstalledEleventyVersions(projectRoot?: string): Promise<{
+    [key: string]: string;
+}>;
+export declare function ensureEleventyExists(projectRoot: string, eleventyVersion: string): Promise<string>;
 export declare function buildEleventy({ eleventyVersion, scenarioDir, scenarioName, projectRoot, globalInputDir }: {
     eleventyVersion: any;
     scenarioDir: any;

package/dist/index.d.ts

@@ -1,6 +1,18 @@
 import ScenarioOutput from "./ScenarioOutput";
 export * from "./eleventyUtils";
-export declare function buildScenarios(projectRoot: string, returnArray?: true, scenariosDir?: string, globalInputDir?: string): Promise<ScenarioOutput[]>;
-export declare function buildScenarios(projectRoot: string, returnArray?: false, scenariosDir?: string, globalInputDir?: string): Promise<{
+interface IbuildScenariosArgs {
+    projectRoot: string;
+    returnArray?: boolean;
+    scenariosDir?: string;
+    globalInputDir?: string;
+}
+interface IbuildScenariosArrayArgs extends IbuildScenariosArgs {
+    returnArray?: true;
+}
+interface IbuildScenariosDictArgs extends IbuildScenariosArgs {
+    returnArray?: false;
+}
+export declare function buildScenarios(opts: IbuildScenariosArrayArgs): Promise<ScenarioOutput[]>;
+export declare function buildScenarios(opts: IbuildScenariosDictArgs): Promise<{
     [key: string]: ScenarioOutput;
 }>;

package/dist/index.js

@@ -21,16 +21,19 @@ var src_exports = {};
 __export(src_exports, {
   buildEleventy: () => buildEleventy,
   buildScenarios: () => buildScenarios,
+  determineInstalledEleventyVersions: () => determineInstalledEleventyVersions,
   ensureEleventyExists: () => ensureEleventyExists
 });
 module.exports = __toCommonJS(src_exports);
 var import_process2 = require("process");
 var import_path3 = require("path");
-var import_fs3 = require("fs");
+var import_promises2 = require("fs/promises");
+var import_https = require("https");
 
 // src/eleventyUtils.ts
 var import_child_process = require("child_process");
 var import_fs2 = require("fs");
+var import_promises = require("fs/promises");
 var import_path2 = require("path");
 var import_process = require("process");
 
@@ -73,37 +76,76 @@ var ScenarioOutput = class {
     return this._files;
   }
   getFileContent(filename) {
-    if (!Object.keys(this.cache).includes(filename)) {
-      this.cache[filename] = this._files[filename]();
-    }
-    return this.cache[filename];
+    return new Promise(async (resolve, reject) => {
+      if (!Object.keys(this.cache).includes(filename)) {
+        this.cache[filename] = this._files[filename]();
+      }
+      resolve(this.cache[filename]);
+    });
   }
 };
 
 // src/eleventyUtils.ts
-function installEleventy(eleventyVersion, cwd3, command) {
-  try {
-    (0, import_child_process.execSync)(`${command} @11ty/eleventy${eleventyVersion}@npm:@11ty/eleventy@${eleventyVersion}`, { cwd: cwd3 });
-  } catch (e) {
-    console.error(`Couldn't install eleventy ${eleventyVersion} using yarn`);
-    throw e;
+async function determineInstalledEleventyVersions(projectRoot = (0, import_process.cwd)()) {
+  let eleventyPkgs = await (0, import_promises.readdir)((0, import_path2.join)(projectRoot, "node_modules/@11ty/"));
+  const eleventyRegex = new RegExp(/eleventy(\d|$)/m);
+  eleventyPkgs = eleventyPkgs.filter((name) => eleventyRegex.test(name));
+  const versions2 = {};
+  for (let i = 0; i < eleventyPkgs.length; i++) {
+    const eleventyPkg = eleventyPkgs[i];
+    const eleventyPkgDir = (0, import_path2.join)(projectRoot, "node_modules/@11ty/", eleventyPkg);
+    const version = JSON.parse(
+      await (0, import_promises.readFile)(
+        (0, import_path2.join)(eleventyPkgDir, "package.json"),
+        { encoding: "utf-8" }
+      )
+    ).version;
+    versions2[version] = eleventyPkgDir;
   }
+  return versions2;
 }
-function ensureEleventyExists(projectRoot, eleventyVersion) {
-  const eleventyDir = (0, import_path2.join)(projectRoot, "node_modules/@11ty/eleventy" + eleventyVersion);
-  if ((0, import_fs2.existsSync)(eleventyDir)) {
-    return eleventyDir;
-  } else {
-    console.log(`Eleventy version ${eleventyVersion} could not be found. Installing...`);
-    if ((0, import_fs2.existsSync)((0, import_path2.join)(projectRoot, "package-lock.json"))) {
-      installEleventy(eleventyVersion, projectRoot, "npm install --save-dev");
-    } else if ((0, import_fs2.existsSync)((0, import_path2.join)(projectRoot, "yarn.lock"))) {
-      installEleventy(eleventyVersion, projectRoot, "yarn add -D");
+async function installEleventyIfPkgManagerFound(eleventyVersion, projectRoot, filename, command) {
+  return new Promise(async (resolve, reject) => {
+    if ((0, import_fs2.existsSync)((0, import_path2.join)(projectRoot, filename))) {
+      try {
+        (0, import_child_process.execSync)(`${command} @11ty/eleventy${eleventyVersion}@npm:@11ty/eleventy@${eleventyVersion}`, { cwd: projectRoot });
+        resolve(true);
+      } catch (e) {
+        throw e;
+      }
     } else {
-      throw new Error(`Error while installing eleventy${eleventyVersion}: Could not determine package manager`);
+      console.error(`Couldn't detect ${filename}, skipping ${command.split(" ")[0]}...`);
+      resolve(false);
     }
-    return eleventyDir;
-  }
+  });
+}
+async function ensureEleventyExists(projectRoot, eleventyVersion) {
+  return new Promise(async (resolve, reject) => {
+    const versions2 = await determineInstalledEleventyVersions(projectRoot);
+    if (Object.keys(versions2).includes(eleventyVersion)) {
+      resolve(versions2[eleventyVersion]);
+    } else {
+      console.log(`Eleventy version ${eleventyVersion} could not be found. Installing...`);
+      const eleventyDir = (0, import_path2.join)(projectRoot, "node_modules/@11ty/eleventy" + eleventyVersion);
+      if (await installEleventyIfPkgManagerFound(
+        eleventyVersion,
+        projectRoot,
+        "package-lock.json",
+        "npm install --save-dev"
+      )) {
+        resolve(eleventyDir);
+      } else if (await installEleventyIfPkgManagerFound(
+        eleventyVersion,
+        projectRoot,
+        "yarn.lock",
+        "yarn add -D"
+      )) {
+        resolve(eleventyDir);
+      } else {
+        throw new Error(`Error while installing eleventy${eleventyVersion}: Could not determine package manager`);
+      }
+    }
+  });
 }
 async function buildEleventy({
   eleventyVersion,
@@ -112,22 +154,32 @@ async function buildEleventy({
   projectRoot = (0, import_process.cwd)(),
   globalInputDir
 }) {
-  return new Promise((resolve, reject) => {
-    const eleventyDir = ensureEleventyExists(projectRoot, eleventyVersion);
+  return new Promise(async (resolve, reject) => {
+    const eleventyDir = await ensureEleventyExists(projectRoot, eleventyVersion);
     const bin = JSON.parse(
-      (0, import_fs2.readFileSync)(
+      await (0, import_promises.readFile)(
         (0, import_path2.join)(eleventyDir, "package.json"),
         { encoding: "utf-8" }
       )
     ).bin.eleventy;
     const pathToBin = (0, import_path2.join)(eleventyDir, bin);
     const scenarioInputDir = (0, import_path2.join)(scenarioDir, "input");
-    const inputDir = (0, import_fs2.existsSync)(scenarioInputDir) ? scenarioInputDir : globalInputDir;
+    let inputDir;
+    try {
+      await (0, import_promises.access)(scenarioInputDir);
+      inputDir = scenarioInputDir;
+    } catch {
+      try {
+        await (0, import_promises.access)(globalInputDir);
+        inputDir = globalInputDir;
+      } catch {
+      }
+    }
     if (inputDir == void 0) {
       throw Error("inputDir is undefined!");
     }
     const outputDir = (0, import_path2.join)(scenarioDir, "eleventy-test-out");
-    (0, import_fs2.rmSync)(outputDir, { force: true, recursive: true });
+    await (0, import_promises.rm)(outputDir, { force: true, recursive: true });
     try {
       const out = (0, import_child_process.fork)(
         pathToBin,
@@ -137,9 +189,8 @@ async function buildEleventy({
       out.on("message", (msg) => {
         console.log(msg);
       });
-      out.on("close", (code) => {
-        const output = new ScenarioOutput(outputDir, scenarioName);
-        resolve(output);
+      out.on("close", async (code) => {
+        resolve(new ScenarioOutput(outputDir, scenarioName));
       });
     } catch (e) {
       throw e;
@@ -148,52 +199,94 @@ async function buildEleventy({
 }
 
 // src/index.ts
-async function buildScenarios(projectRoot = (0, import_process2.cwd)(), returnArray = true, scenariosDir = "tests/scenarios/", globalInputDir = "tests/input") {
-  return new Promise(async (resolve, reject) => {
-    scenariosDir = (0, import_path3.join)(projectRoot, scenariosDir);
-    globalInputDir = (0, import_fs3.existsSync)((0, import_path3.join)(projectRoot, globalInputDir)) ? (0, import_path3.join)(projectRoot, globalInputDir) : "undefined";
-    const scenarioDirs = (0, import_fs3.readdirSync)(scenariosDir);
-    const scenarioOutputs = [];
-    for (let i = 0; i < scenarioDirs.length; i++) {
-      const scenarioDirname = scenarioDirs[i];
-      const scenarioDir = (0, import_path3.join)(scenariosDir, scenarioDirname);
-      let scenarioEleventyVersion = scenarioDirname.includes("--") ? scenarioDirname.split("--")[0] : scenarioDirname;
-      if (scenarioEleventyVersion.length < 5) {
-        const scenarioMajorVersion = scenarioDirname[0];
-        const versions = await (await fetch("https://api.github.com/repos/11ty/eleventy/tags")).json();
-        for (let i2 = 0; i2 < versions.length; i2++) {
-          const version = versions[i2];
-          if (!version.name.includes("-") && version.name[1] == scenarioMajorVersion) {
-            scenarioEleventyVersion = version.name.substring(1);
-            break;
+var versions;
+async function scenarioDirnameToEleventyVersion(scenarioDirname) {
+  let eleventyVersion = scenarioDirname.includes("--") ? scenarioDirname.split("--")[0] : scenarioDirname;
+  if (eleventyVersion.length < 5) {
+    const scenarioMajorVersion = scenarioDirname[0];
+    if (versions == void 0) {
+      console.log("Pulling Eleventy tags...");
+      versions = await new Promise((resolve, reject) => {
+        (0, import_https.get)({
+          hostname: "api.github.com",
+          path: "/repos/11ty/eleventy/tags",
+          headers: {
+            "User-Agent": "Mozilla/5.0"
           }
-        }
+        }, (res) => {
+          let data = [];
+          res.on("data", (chunk) => {
+            data.push(chunk);
+          }).on("end", () => {
+            console.log("Parsing API response...");
+            resolve(
+              JSON.parse(
+                Buffer.concat(data).toString("utf-8")
+              )
+            );
+          }).on("error", (err) => {
+            throw err;
+          });
+        });
+      });
+    }
+    for (let i = 0; i < versions.length; i++) {
+      const version = versions[i];
+      if (!version.name.includes("-") && version.name[1] == scenarioMajorVersion) {
+        eleventyVersion = version.name.substring(1);
+        break;
       }
-      scenarioOutputs.push(await buildEleventy({
-        eleventyVersion: scenarioEleventyVersion,
-        scenarioName: scenarioDirname,
-        globalInputDir,
-        projectRoot,
-        scenarioDir
-      }));
     }
-    if (returnArray) {
-      resolve(scenarioOutputs);
-    } else {
-      const returnDict = {};
-      scenarioOutputs.forEach((scenarioOutput) => {
-        returnDict[scenarioOutput.title] = scenarioOutput;
-      });
-      resolve(returnDict);
+  }
+  return eleventyVersion;
+}
+async function buildScenarios({ projectRoot = (0, import_process2.cwd)(), returnArray = true, scenariosDir = "tests/scenarios/", globalInputDir = "tests/input" }) {
+  return new Promise(async (resolve, reject) => {
+    scenariosDir = (0, import_path3.isAbsolute)(scenariosDir) ? scenariosDir : (0, import_path3.join)(projectRoot, scenariosDir);
+    globalInputDir = (0, import_path3.isAbsolute)(globalInputDir) ? globalInputDir : (0, import_path3.join)(projectRoot, globalInputDir);
+    try {
+      await (0, import_promises2.access)(globalInputDir);
+    } catch {
+      globalInputDir = "undefined";
+    }
+    try {
+      const scenarioDirs = await (0, import_promises2.readdir)(scenariosDir, { recursive: false, encoding: "utf-8" });
+      const scenarioOutputs = [];
+      for (let i = 0; i < scenarioDirs.length; i++) {
+        const scenarioDirname = scenarioDirs[i];
+        const scenarioDir = (0, import_path3.join)(scenariosDir, scenarioDirname);
+        let scenarioEleventyVersion = await scenarioDirnameToEleventyVersion(scenarioDirname);
+        scenarioOutputs.push(await buildEleventy({
+          eleventyVersion: scenarioEleventyVersion,
+          scenarioName: scenarioDirname,
+          globalInputDir,
+          projectRoot,
+          scenarioDir
+        }));
+      }
+      if (returnArray) {
+        resolve(scenarioOutputs);
+      } else {
+        const returnDict = {};
+        scenarioOutputs.forEach((scenarioOutput) => {
+          returnDict[scenarioOutput.title] = scenarioOutput;
+        });
+        resolve(returnDict);
+      }
+    } catch (e) {
+      throw e;
     }
   });
 }
 if (require.main === module) {
-  buildScenarios((0, import_process2.cwd)());
+  buildScenarios({
+    projectRoot: (0, import_process2.cwd)()
+  });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   buildEleventy,
   buildScenarios,
+  determineInstalledEleventyVersions,
   ensureEleventyExists
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eleventy-test",
-  "version": "0.1.2",
+  "version": "1.1.0",
   "description": "Multi-configuration testing for Eleventy plugins",
   "license": "MIT",
   "repository": "https://github.com/Denperidge/eleventy-test.git",
@@ -15,18 +15,19 @@
     "build": "npm-run-all --serial build:js build:types",
     "build:js": "esbuild src/index.ts --bundle --outfile=dist/index.js --platform=node",
     "build:types": "tsc --declaration src/index.ts --emitDeclarationOnly --outDir ./dist",
-    "test": "ava tests/test.mjs --timeout=30s"
+    "test": "ava tests/test.mjs --timeout=90s"
   },
   "devDependencies": {
+    "@11ty/eleventy": "^3.0.0",
     "@11ty/eleventy1.0.2": "npm:@11ty/eleventy@1.0.2",
     "@11ty/eleventy2.0.0-canary.8": "npm:@11ty/eleventy@2.0.0-canary.8",
     "@11ty/eleventy2.0.1": "npm:@11ty/eleventy@2.0.1",
-    "@11ty/eleventy3.0.0": "npm:@11ty/eleventy@3.0.0",
     "@types/node": "^22.10.1",
     "ava": "^6.2.0",
     "esbuild": "^0.24.0",
     "jsdom": "^25.0.1",
     "npm-run-all": "^4.1.5",
     "typescript": "^5.7.2"
-  }
+  },
+  "dependencies": {}
 }