eleventy-test 1.0.0 → 1.2.0

package/README.md

@@ -26,7 +26,8 @@ Want to see how it is in action? For the dogfooding fans, you can see this libra
 
     const resultsAsDict = await buildScenarios({
         projectRoot: cwd(),
-        returnArray: false
+        returnArray: false,
+        enableDebug: false
     });
 
     test("Check if index.html is consistent across builds", async t => {

package/dist/debug.d.ts

@@ -0,0 +1,2 @@
+export declare function setDebug(enabled: any): void;
+export default function debug(...message: any[]): void;

package/dist/eleventyUtils.d.ts

@@ -1,4 +1,7 @@
 import ScenarioOutput from "./ScenarioOutput";
+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;

package/dist/index.d.ts

@@ -5,6 +5,7 @@ interface IbuildScenariosArgs {
     returnArray?: boolean;
     scenariosDir?: string;
     globalInputDir?: string;
+    enableDebug?: boolean;
 }
 interface IbuildScenariosArrayArgs extends IbuildScenariosArgs {
     returnArray?: true;

package/dist/index.js

@@ -21,6 +21,7 @@ var src_exports = {};
 __export(src_exports, {
   buildEleventy: () => buildEleventy,
   buildScenarios: () => buildScenarios,
+  determineInstalledEleventyVersions: () => determineInstalledEleventyVersions,
   ensureEleventyExists: () => ensureEleventyExists
 });
 module.exports = __toCommonJS(src_exports);
@@ -36,6 +37,17 @@ var import_promises = require("fs/promises");
 var import_path2 = require("path");
 var import_process = require("process");
 
+// src/debug.ts
+var debugEnabled = false;
+function setDebug(enabled) {
+  debugEnabled = enabled;
+}
+function debug(...message) {
+  if (debugEnabled) {
+    message.forEach((msg) => console.log(msg));
+  }
+}
+
 // src/ScenarioOutput.ts
 var import_path = require("path");
 var import_fs = require("fs");
@@ -76,6 +88,9 @@ var ScenarioOutput = class {
   }
   getFileContent(filename) {
     return new Promise(async (resolve, reject) => {
+      if (!Object.keys(this._files).includes(filename)) {
+        throw new Error(`Can't find "${filename}" in files. Available files: ${Object.keys(this._files).join(", ")}`);
+      }
       if (!Object.keys(this.cache).includes(filename)) {
         this.cache[filename] = this._files[filename]();
       }
@@ -85,11 +100,39 @@ var ScenarioOutput = class {
 };
 
 // src/eleventyUtils.ts
+async function determineInstalledEleventyVersions(projectRoot = (0, import_process.cwd)()) {
+  const eleventyPkgsDir = (0, import_path2.join)(projectRoot, "node_modules/@11ty/");
+  const versions2 = {};
+  debug("Determining installed Eleventy versions in " + eleventyPkgsDir);
+  if ((0, import_fs2.existsSync)(eleventyPkgsDir)) {
+    let eleventyPkgs = await (0, import_promises.readdir)(eleventyPkgsDir);
+    debug(`Found the followintg installed packages from @11ty: ${eleventyPkgs}`);
+    const eleventyRegex = new RegExp(/eleventy(\d|$)/m);
+    eleventyPkgs = eleventyPkgs.filter((name) => eleventyRegex.test(name));
+    debug(`Filtered non-main-eleventy packages. Results: ${eleventyPkgs}`);
+    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;
+      debug(`Found ${version} at ${eleventyPkgDir}`);
+    }
+  }
+  return versions2;
+}
 async function installEleventyIfPkgManagerFound(eleventyVersion, projectRoot, filename, command) {
+  debug(`Attempting to find a package manager to install Eleventy ${eleventyVersion} with`);
   return new Promise(async (resolve, reject) => {
     if ((0, import_fs2.existsSync)((0, import_path2.join)(projectRoot, filename))) {
       try {
+        debug("Running Eleventy " + eleventyVersion);
         (0, import_child_process.execSync)(`${command} @11ty/eleventy${eleventyVersion}@npm:@11ty/eleventy@${eleventyVersion}`, { cwd: projectRoot });
+        debug("Done running Eleventy " + eleventyVersion);
         resolve(true);
       } catch (e) {
         throw e;
@@ -101,13 +144,14 @@ async function installEleventyIfPkgManagerFound(eleventyVersion, projectRoot, fi
   });
 }
 async function ensureEleventyExists(projectRoot, eleventyVersion) {
+  debug(`Ensuring Eleventy ${eleventyVersion} exists`);
   return new Promise(async (resolve, reject) => {
-    const eleventyDir = (0, import_path2.join)(projectRoot, "node_modules/@11ty/eleventy" + eleventyVersion);
-    try {
-      await (0, import_promises.access)(eleventyDir);
-      resolve(eleventyDir);
-    } catch {
+    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,
@@ -135,8 +179,11 @@ async function buildEleventy({
   projectRoot = (0, import_process.cwd)(),
   globalInputDir
 }) {
+  debug("Running buildEleventy", "scenarioDir: " + scenarioDir, "Eleventy version: " + eleventyVersion);
   return new Promise(async (resolve, reject) => {
+    debug("Finding package for Eleventy " + eleventyVersion);
     const eleventyDir = await ensureEleventyExists(projectRoot, eleventyVersion);
+    debug("Found pacakge for Eleventy " + eleventyVersion);
     const bin = JSON.parse(
       await (0, import_promises.readFile)(
         (0, import_path2.join)(eleventyDir, "package.json"),
@@ -144,24 +191,27 @@ async function buildEleventy({
       )
     ).bin.eleventy;
     const pathToBin = (0, import_path2.join)(eleventyDir, bin);
+    debug(`Found entrypoint for Eleventy ${eleventyVersion} at ${pathToBin}`);
     const scenarioInputDir = (0, import_path2.join)(scenarioDir, "input");
     let inputDir;
-    try {
-      await (0, import_promises.access)(scenarioInputDir);
+    debug(`Checking whether to use scenario (${scenarioInputDir}) or global input (${globalInputDir})...`);
+    if ((0, import_fs2.existsSync)(scenarioInputDir)) {
+      debug("Using scenario input");
       inputDir = scenarioInputDir;
-    } catch {
-      try {
-        await (0, import_promises.access)(globalInputDir);
-        inputDir = globalInputDir;
-      } catch {
-      }
+    } else if ((0, import_fs2.existsSync)(globalInputDir)) {
+      debug("Using global input dir");
+      inputDir = globalInputDir;
     }
+    debug("inputDir: " + inputDir);
     if (inputDir == void 0) {
-      throw Error("inputDir is undefined!");
+      throw new Error("inputDir is undefined! Either create a global input dir or one for the scenario specifically");
     }
     const outputDir = (0, import_path2.join)(scenarioDir, "eleventy-test-out");
+    debug("Cleaning old test output");
     await (0, import_promises.rm)(outputDir, { force: true, recursive: true });
+    debug("Cleaned");
     try {
+      debug("Creating Eleventy process...");
       const out = (0, import_child_process.fork)(
         pathToBin,
         ["--input", inputDir, "--output", outputDir],
@@ -171,6 +221,7 @@ async function buildEleventy({
         console.log(msg);
       });
       out.on("close", async (code) => {
+        debug(`Eleventy ${eleventyVersion}/${scenarioName} finished`);
         resolve(new ScenarioOutput(outputDir, scenarioName));
       });
     } catch (e) {
@@ -180,13 +231,16 @@ async function buildEleventy({
 }
 
 // src/index.ts
+var import_fs3 = require("fs");
 var versions;
 async function scenarioDirnameToEleventyVersion(scenarioDirname) {
   let eleventyVersion = scenarioDirname.includes("--") ? scenarioDirname.split("--")[0] : scenarioDirname;
+  debug(`eleventyVersion from dirname: ${eleventyVersion}`);
   if (eleventyVersion.length < 5) {
+    debug("eleventyVersion length is under 5, and as such not a full semantic version. Determining latest...");
     const scenarioMajorVersion = scenarioDirname[0];
     if (versions == void 0) {
-      console.log("Pulling Eleventy tags...");
+      debug("Pulling Eleventy tags...");
       versions = await new Promise((resolve, reject) => {
         (0, import_https.get)({
           hostname: "api.github.com",
@@ -199,7 +253,7 @@ async function scenarioDirnameToEleventyVersion(scenarioDirname) {
           res.on("data", (chunk) => {
             data.push(chunk);
           }).on("end", () => {
-            console.log("Parsing API response...");
+            debug("Parsing Eleventy tags API response...");
             resolve(
               JSON.parse(
                 Buffer.concat(data).toString("utf-8")
@@ -213,30 +267,36 @@ async function scenarioDirnameToEleventyVersion(scenarioDirname) {
     }
     for (let i = 0; i < versions.length; i++) {
       const version = versions[i];
+      debug("Checking " + version);
       if (!version.name.includes("-") && version.name[1] == scenarioMajorVersion) {
         eleventyVersion = version.name.substring(1);
+        debug("Determined latest of relevant major version for: " + eleventyVersion);
         break;
       }
     }
   }
   return eleventyVersion;
 }
-async function buildScenarios({ projectRoot = (0, import_process2.cwd)(), returnArray = true, scenariosDir = "tests/scenarios/", globalInputDir = "tests/input" }) {
+async function buildScenarios({ projectRoot = (0, import_process2.cwd)(), returnArray = true, scenariosDir = "tests/scenarios/", globalInputDir: passedGlobalInputDir = "tests/input", enableDebug = false }) {
+  setDebug(enableDebug);
+  debug("If you can see this, debugging has been enabled. Starting buildScenarios");
   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";
+    let globalInputDir = (0, import_path3.isAbsolute)(passedGlobalInputDir) ? passedGlobalInputDir : (0, import_path3.join)(projectRoot, passedGlobalInputDir);
+    if (globalInputDir) {
+      globalInputDir = (0, import_fs3.existsSync)(globalInputDir) ? globalInputDir : void 0;
     }
+    debug(`scenariosDir: ${scenariosDir}`, `globalInputDir: ${globalInputDir}`);
     try {
       const scenarioDirs = await (0, import_promises2.readdir)(scenariosDir, { recursive: false, encoding: "utf-8" });
       const scenarioOutputs = [];
+      debug(`Found scenario dirs: ${scenarioDirs}`);
       for (let i = 0; i < scenarioDirs.length; i++) {
         const scenarioDirname = scenarioDirs[i];
         const scenarioDir = (0, import_path3.join)(scenariosDir, scenarioDirname);
+        debug("Parsing Eleventy version of scenario " + scenarioDirname);
         let scenarioEleventyVersion = await scenarioDirnameToEleventyVersion(scenarioDirname);
+        debug("Determined Eleventy version: " + scenarioEleventyVersion);
         scenarioOutputs.push(await buildEleventy({
           eleventyVersion: scenarioEleventyVersion,
           scenarioName: scenarioDirname,
@@ -246,8 +306,10 @@ async function buildScenarios({ projectRoot = (0, import_process2.cwd)(), return
         }));
       }
       if (returnArray) {
+        debug("Returning as array...");
         resolve(scenarioOutputs);
       } else {
+        debug("Returning as object...");
         const returnDict = {};
         scenarioOutputs.forEach((scenarioOutput) => {
           returnDict[scenarioOutput.title] = scenarioOutput;
@@ -261,12 +323,14 @@ async function buildScenarios({ projectRoot = (0, import_process2.cwd)(), return
 }
 if (require.main === module) {
   buildScenarios({
-    projectRoot: (0, import_process2.cwd)()
+    projectRoot: (0, import_process2.cwd)(),
+    enableDebug: true
   });
 }
 // 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": "1.0.0",
+  "version": "1.2.0",
   "description": "Multi-configuration testing for Eleventy plugins",
   "license": "MIT",
   "repository": "https://github.com/Denperidge/eleventy-test.git",
@@ -18,15 +18,16 @@
     "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": {}
 }