eleventy-auto-cache-buster 0.5.0 → 0.6.0

package/11tyAutoCacheBuster.js

@@ -4,6 +4,8 @@ const glob = require("glob");
 
 let enableLogging = false;
 let algorithm = "md5";
+let hashTruncate = 12;
+let hashFunction;
 
 function hash(content) {
     const currentHash = crypto.createHash(algorithm);
@@ -40,83 +42,122 @@ function logRed(string) {
 const defaultOptions = {
     globstring: "**/*.{css,js,png,jpg,jpeg,gif,mp4,ico}",
     hashTruncate: 12,
+    runAsync: true,
     enableLogging: enableLogging,
     hashAlgorithm: algorithm,
     hashFunction: hash,
 }
 
-module.exports = function(eleventyConfig, options=defaultOptions) {
-    eleventyConfig.on("eleventy.after", async ({ dir, results, runMode, outputMode }) => {
+function collectLocalAssets(globResults=[], outputDir) {
+    const assetPaths = [];
+    globResults.forEach((assetPath) => {
+        assetPath = assetPath.replace(/\\/g, "/")
+        logGreen(`[ACB] ${assetPath} is an asset! Calculating hash...`);
+        const assetHash = hashFunction(fs.readFileSync(assetPath));
+        logGreen(`[ACB] ${assetPath} hash = ${assetHash}`);
+
+        assetPaths.push({
+            assetPath: assetPath.replace(outputDir + "/", ""),
+            assetHash: assetHash
+        });
+    });
+
+    logYellow(`[ACB] Collected all asset hashes!`);
+    return assetPaths;
+}
+
+function writeSync(outputPath, outputData) {
+    try {
+        fs.writeFileSync(outputPath, outputData);
+        logGreen(`[ACB] Added hashes to ${outputPath}`);
+    } catch (err) {
+        logRed(err);
+    }
+}
+
+function writeAsync(outputPath, outputData) {
+    fs.writeFile(outputPath, outputData, () => {
+        logGreen(`[ACB] Added hashes to ${outputPath}`);
+    });
+}
 
-        // Override default options with set options
-        options = Object.assign(defaultOptions, options);
+function replaceAssetsInFile(fileData, filePath, assetPathsAndHashes, writeFunc) {
+    let outputString = fileData;
+    let outputChanged = false;  // Check if any hashes have been added
 
-        const globstring = options.globstring;
-        const hashTruncate = options.hashTruncate;
-        const hashFunction = options.hashFunction;
-        // Set options to globals
-        enableLogging = options.enableLogging;
-        algorithm = options.hashAlgorithm;
+    // Check for every asset
+    assetPathsAndHashes.forEach(({assetPath, assetHash}) => {
+        if (fileData.includes(assetPath)) {
+            logGreen(`[ACB] ${filePath} contains asset ${assetPath}`)
 
-        if (hashTruncate > 0) {
-            logRegular(`[ACB] Truncating hash to ${hashTruncate}`);
+            // Optionally truncate
+            if (hashTruncate > 0) {
+                assetHash = assetHash.substring(0, hashTruncate);
+            }
+
+            // Replace asset path with asset path with hash
+            outputString = outputString.replaceAll(assetPath, `${assetPath}?v=${assetHash}`);
+            // Write changes to file
+            outputChanged = true;
         } else {
-            logRegular(`[ACB] hashTruncate smaller than or equal to 0, disabling truncation`);
+            logRegular(`[ACB] ${filePath} does NOT contain asset ${assetPath}. Skipping`)                        
         }
+    });
 
-        const assetPaths = [];
-        logYellow(`[ACB] Collecting assets & calculating hashes using ${globstring}...`);
-        (await glob.glob(dir.output + "/" + globstring)).forEach((assetPath) => {
-            assetPath = assetPath.replace(/\\/g, "/")
-            logGreen(`[ACB] ${assetPath} is an asset! Calculating hash...`);
-            const assetHash = hashFunction(fs.readFileSync(assetPath));
-            logGreen(`[ACB] ${assetPath} hash = ${assetHash}`);
-
-            assetPaths.push({
-                assetPath: assetPath.replace(dir.output + "/", ""),
-                assetHash: assetHash
-            });
-        });
+    if (outputChanged) {
+        writeFunc(filePath, outputString);
+    }
 
-        logYellow(`[ACB] Collected all asset hashes!`);
-        logRegular(`[ACB] Replacing in output...`);
+}
 
-        // For every page Eleventy outputs
-        results.forEach(({inputPath, outputPath, url, content}) => {
-            let outputData = "";  // Assigned later
-            let outputChanged = false;  // Check if any hashes have been added
+module.exports = function(eleventyConfig, options=defaultOptions) {
+    // Override default options with set options
+    options = Object.assign(defaultOptions, options);
+    const globstring = options.globstring;
+    const runAsync = options.runAsync;
+    // Set options to globals
+    enableLogging = options.enableLogging;
+    hashTruncate = options.hashTruncate;
+    hashFunction = options.hashFunction;
+    algorithm = options.hashAlgorithm;
+    
+
+    // Setup
+    if (hashTruncate > 0) {
+        logRegular(`[ACB] Truncating hash to ${hashTruncate}`);
+    } else {
+        logRegular(`[ACB] hashTruncate smaller than or equal to 0, disabling truncation`);
+    }
 
-            // Read the output content
-            fs.readFile(outputPath, encoding="UTF-8", (err, pageData) => { 
-                if (err) {
-                    logRed(err);
-                    throw err;
-                }
-                // Save the output data
-                outputData = pageData;
-                
-                assetPaths.forEach(({assetPath, assetHash}) => {
-                    if (pageData.includes(assetPath)) {
-                        logGreen(`[ACB] ${outputPath} contains asset ${assetPath}`)
-
-                        if (hashTruncate > 0) {
-                            assetHash = assetHash.substring(0, hashTruncate);
-                        }
-
-                        outputData = outputData.replaceAll(assetPath, `${assetPath}?v=${assetHash}`);
-                        outputChanged = true;
-                        
-                    } else {
-                        logRegular(`[ACB] ${outputPath} does NOT contain asset ${assetPath}. Skipping`)                        
+    if (runAsync) {
+        eleventyConfig.on("eleventy.after", async ({ dir, results, runMode, outputMode }) => {
+            logYellow(`[ACB] Collecting assets & calculating hashes using ${globstring}...`);
+            const assetPathsAndHashes = collectLocalAssets(await glob.glob(dir.output + "/" + globstring), dir.output);
+
+            logRegular(`[ACB] Replacing in output...`);
+            results.forEach(({inputPath, outputPath, url, content}) => {
+                fs.readFile(outputPath, encoding="UTF-8", (err, pageData) => { 
+                    if (err) {
+                        logRed(err);
+                        throw err;
                     }
+                    // Save the output data
+                    replaceAssetsInFile(pageData, outputPath, assetPathsAndHashes, writeAsync);
                 });
-
-                if (outputChanged) {
-                    fs.writeFile(outputPath, outputData, () => {
-                        logGreen(`[ACB] Added hashes to ${outputPath}`);
-                    });
-                }
             });
         });
-    });
+    } else {
+        eleventyConfig.on("eleventy.after", ({ dir, results, runMode, outputMode }) => {
+            logYellow(`[ACB] Collecting assets & calculating hashes using ${globstring}...`);
+            const assetPathsAndHashes = collectLocalAssets(glob.globSync(dir.output + "/" + globstring), dir.output);
+
+            logRegular(`[ACB] Replacing in output...`);
+            results.forEach(({inputPath, outputPath, url, content}) => {
+                const pageData = fs.readFileSync(outputPath, encoding="UTF-8"); 
+                // Save the output data
+                replaceAssetsInFile(pageData, outputPath, assetPathsAndHashes, writeSync);
+            });
+        });
+    }
+
 }

package/README.md

@@ -43,6 +43,7 @@ module.exports = function (eleventyConfig) {
     eleventyConfig.addPlugin(eleventyAutoCacheBuster, {
         enableLogging: true,  // Whether to enable eleventy-auto-cache-buster logging.
         hashTruncate: 0,  // Desired substring length of the hash. Set to 0 or lower to disable truncating
+        runAsync: false,  // Whether to run asynchronously. Default is true
         globstring: "**/*.ico",  // What glob string is used to locate assets.
         hashAlgorithm: "sha1",  // What hash method to pass to the hash function. See Node.js' crypto.createHash documentation.
         hashFunction: function (content) { return "example" }  // What function to run to calculate hashes. Overrides hashAlgorithm.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eleventy-auto-cache-buster",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Busts cache using ?v= with minimal configuration!",
   "main": "11tyAutoCacheBuster.js",
   "repository": "https://github.com/Denperidge/eleventy-auto-cache-buster.git",