ultimate-jekyll-manager 1.1.9 → 1.2.0

package/dist/gulp/tasks/minifyHtml.js

@@ -4,7 +4,7 @@ const logger = Manager.logger('minifyHtml');
 const { src, dest, series } = require('gulp');
 const { minify: minifyRust } = require('@minify-html/node');
 const { minify: minifyJs } = require('terser');
-const through2 = require('through2');
+const { Transform } = require('node:stream');
 
 // Load package
 const package = Manager.getPackage('main');
@@ -85,61 +85,65 @@ function minifyHtmlTask(complete) {
 
   // Process HTML files
   return src(input)
-    .pipe(through2.obj(function(file, _enc, callback) {
-      if (file.isBuffer()) {
-        fileQueue.push({ file });
-        callback();
-      } else {
-        callback(null, file);
-      }
-    }, async function(callback) {
-      // This function is called when all files have been queued
-      if (fileQueue.length === 0) {
-        logger.log('No HTML files to minify');
-        return callback();
-      }
+    .pipe(new Transform({
+      objectMode: true,
+      transform(file, _enc, callback) {
+        if (file.isBuffer()) {
+          fileQueue.push({ file });
+          callback();
+        } else {
+          callback(null, file);
+        }
+      },
+      async flush(callback) {
+        // This function is called when all files have been queued
+        if (fileQueue.length === 0) {
+          logger.log('No HTML files to minify');
+          return callback();
+        }
 
-      const totalFiles = fileQueue.length;
-      logger.log(`Minifying ${totalFiles} HTML files...`);
-
-      try {
-        // Process files in batches
-        for (let i = 0; i < fileQueue.length; i += CONCURRENCY_LIMIT) {
-          const batch = fileQueue.slice(i, i + CONCURRENCY_LIMIT);
-
-          // Process batch in parallel
-          const processedFiles = await Promise.all(
-            batch.map(async ({ file }) => {
-              try {
-                const htmlContent = file.contents.toString();
-                const finalHtml = await minifyFileContent(htmlContent, options, file.path);
-                file.contents = Buffer.from(finalHtml);
-                processed.count++;
-
-                // Log progress every 50 files or on last file
-                if (processed.count % 50 === 0 || processed.count === totalFiles) {
-                  const percentage = ((processed.count / totalFiles) * 100).toFixed(1);
-                  logger.log(`Progress: ${processed.count}/${totalFiles} files (${percentage}%)`);
-                  Manager.logMemory(logger, `After ${processed.count} files`);
+        const totalFiles = fileQueue.length;
+        logger.log(`Minifying ${totalFiles} HTML files...`);
+
+        try {
+          // Process files in batches
+          for (let i = 0; i < fileQueue.length; i += CONCURRENCY_LIMIT) {
+            const batch = fileQueue.slice(i, i + CONCURRENCY_LIMIT);
+
+            // Process batch in parallel
+            const processedFiles = await Promise.all(
+              batch.map(async ({ file }) => {
+                try {
+                  const htmlContent = file.contents.toString();
+                  const finalHtml = await minifyFileContent(htmlContent, options, file.path);
+                  file.contents = Buffer.from(finalHtml);
+                  processed.count++;
+
+                  // Log progress every 50 files or on last file
+                  if (processed.count % 50 === 0 || processed.count === totalFiles) {
+                    const percentage = ((processed.count / totalFiles) * 100).toFixed(1);
+                    logger.log(`Progress: ${processed.count}/${totalFiles} files (${percentage}%)`);
+                    Manager.logMemory(logger, `After ${processed.count} files`);
+                  }
+
+                  return file;
+                } catch (err) {
+                  logger.error(`Error minifying ${file.path}: ${err.message}`);
+                  return file;
                 }
+              })
+            );
 
-                return file;
-              } catch (err) {
-                logger.error(`Error minifying ${file.path}: ${err.message}`);
-                return file;
-              }
-            })
-          );
+            // Push processed files to the stream
+            processedFiles.forEach(file => this.push(file));
+          }
 
-          // Push processed files to the stream
-          processedFiles.forEach(file => this.push(file));
+          callback();
+        } catch (err) {
+          logger.error(`Batch processing error: ${err.message}`);
+          callback(err);
         }
-
-        callback();
-      } catch (err) {
-        logger.error(`Batch processing error: ${err.message}`);
-        callback(err);
-      }
+      },
     }))
     .pipe(dest(output))
     .on('finish', () => {

package/dist/gulp/tasks/sass.js

@@ -13,7 +13,7 @@ const { template } = require('node-powertools');
 const yaml = require('js-yaml');
 const postcss = require('gulp-postcss');
 const purgeCss = require('@fullhuman/postcss-purgecss');
-const through2 = require('through2');
+const { Transform } = require('node:stream');
 
 // Load package
 const package = Manager.getPackage('main');
@@ -324,19 +324,20 @@ function sass(complete) {
     let purgeCssLogged = false;
     stream = stream
       .pipe(postcss([purgeCssPlugin]))
-      .pipe(through2.obj(
-        function (file, enc, cb) {
+      .pipe(new Transform({
+        objectMode: true,
+        transform(file, enc, cb) {
           cb(null, file);
         },
-        function (cb) {
+        flush(cb) {
           if (!purgeCssLogged) {
             purgeCssLogged = true;
             const purgeCssTime = ((performance.now() - purgeCssStartTime) / 1000).toFixed(2);
             logger.log(`PurgeCSS completed in ${purgeCssTime}s`);
           }
           cb();
-        }
-      ));
+        },
+      }));
   }
 
   // Process

package/dist/gulp/tasks/utils/template-transform.js

@@ -1,49 +1,49 @@
 // Libraries
-const through2 = require('through2');
+const { Transform } = require('node:stream');
 const { template } = require('node-powertools');
 const path = require('path');
 
 /**
- * Creates a through2 transform stream that processes template variables in files
+ * Creates a transform stream that processes template variables in files
  **/
 function createTemplateTransform(data) {
   const extensions = ['html', 'md', 'liquid', 'json']
 
-  return through2.obj(function(file, encoding, callback) {
-    // Skip directories
-    if (file.isDirectory()) {
-      return callback(null, file);
-    }
-
-    // Check if file extension matches
-    const ext = path.extname(file.path).toLowerCase().slice(1);
-    if (!extensions.includes(ext)) {
-      return callback(null, file);
-    }
-
-    // Log
-    // console.log(`Processing file: ${file.path}`);
-
-    // Process the file contents
-    try {
-      const contents = file.contents.toString();
-
-      // Process templates
-      const templated = template(contents, data, {
-        brackets: ['[', ']'],
-      });
-
-      // Update file contents if changed
-      if (contents !== templated) {
-        file.contents = Buffer.from(templated);
-        const relativePath = file.relative || file.path;
+  return new Transform({
+    objectMode: true,
+    transform(file, encoding, callback) {
+      // Skip directories
+      if (file.isDirectory()) {
+        return callback(null, file);
       }
-    } catch (error) {
-      console.error(`Error processing templates in ${file.path}:`, error);
-    }
 
-    // Pass the file through
-    callback(null, file);
+      // Check if file extension matches
+      const ext = path.extname(file.path).toLowerCase().slice(1);
+      if (!extensions.includes(ext)) {
+        return callback(null, file);
+      }
+
+      // Process the file contents
+      try {
+        const contents = file.contents.toString();
+
+        // Process templates
+        const templated = template(contents, data, {
+          brackets: ['[', ']'],
+        });
+
+        // Update file contents if changed
+        if (contents !== templated) {
+          file.contents = Buffer.from(templated);
+          const relativePath = file.relative || file.path;
+        }
+      } catch (error) {
+        console.error(`Error processing templates in ${file.path}:`, error);
+      }
+
+      // Pass the file through
+      callback(null, file);
+    },
   });
 }
 

package/dist/index.js

@@ -1,5 +1,6 @@
 // Libraries
 import webManager from 'web-manager';
+import { attachTo as attachModeHelpers } from './utils/mode-helpers.js';
 
 // Manager Class
 class Manager {
@@ -133,5 +134,8 @@ class Manager {
   }
 }
 
+// Mix in cross-context mode helpers (isDevelopment/isProduction/isTesting/getVersion).
+attachModeHelpers(Manager);
+
 // Export
 export default Manager;

package/dist/test/assert.js

@@ -0,0 +1,120 @@
+// Tiny expect() — Jest/Vitest-compatible subset.
+// Each matcher throws on failure; the runner catches.
+
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a !== typeof b) return false;
+  if (a === null || b === null) return a === b;
+  if (typeof a !== 'object') return false;
+
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b) || a.length !== b.length) return false;
+    return a.every((x, i) => deepEqual(x, b[i]));
+  }
+
+  const ka = Object.keys(a);
+  const kb = Object.keys(b);
+  if (ka.length !== kb.length) return false;
+  return ka.every((k) => deepEqual(a[k], b[k]));
+}
+
+function fmt(v) {
+  if (typeof v === 'string') return JSON.stringify(v);
+  if (v === undefined) return 'undefined';
+  try {
+    return JSON.stringify(v);
+  } catch (e) {
+    return String(v);
+  }
+}
+
+function fail(message) {
+  const err = new Error(message);
+  err.name = 'AssertionError';
+  throw err;
+}
+
+function buildMatchers(actual, negated) {
+  const not = negated ? 'not ' : '';
+
+  function check(cond, message) {
+    if (negated) cond = !cond;
+    if (!cond) fail(message);
+  }
+
+  return {
+    toBe(expected) {
+      check(actual === expected, `expected ${fmt(actual)} ${not}to be ${fmt(expected)}`);
+    },
+    toEqual(expected) {
+      check(deepEqual(actual, expected), `expected ${fmt(actual)} ${not}to deeply equal ${fmt(expected)}`);
+    },
+    toBeTruthy() {
+      check(!!actual, `expected ${fmt(actual)} ${not}to be truthy`);
+    },
+    toBeFalsy() {
+      check(!actual, `expected ${fmt(actual)} ${not}to be falsy`);
+    },
+    toBeDefined() {
+      check(actual !== undefined, `expected ${fmt(actual)} ${not}to be defined`);
+    },
+    toBeUndefined() {
+      check(actual === undefined, `expected ${fmt(actual)} ${not}to be undefined`);
+    },
+    toBeNull() {
+      check(actual === null, `expected ${fmt(actual)} ${not}to be null`);
+    },
+    toContain(item) {
+      const has = Array.isArray(actual)
+        ? actual.includes(item)
+        : (typeof actual === 'string' && actual.includes(item));
+      check(has, `expected ${fmt(actual)} ${not}to contain ${fmt(item)}`);
+    },
+    toHaveProperty(key) {
+      const has = actual != null && Object.prototype.hasOwnProperty.call(actual, key);
+      check(has, `expected ${fmt(actual)} ${not}to have property "${key}"`);
+    },
+    toMatch(regex) {
+      check(regex.test(actual), `expected ${fmt(actual)} ${not}to match ${regex}`);
+    },
+    toBeInstanceOf(cls) {
+      check(actual instanceof cls, `expected value ${not}to be instance of ${cls.name}`);
+    },
+    toBeGreaterThan(n) {
+      check(actual > n, `expected ${fmt(actual)} ${not}to be > ${n}`);
+    },
+    toBeLessThan(n) {
+      check(actual < n, `expected ${fmt(actual)} ${not}to be < ${n}`);
+    },
+    async toThrow(matcher) {
+      let threw = false;
+      let thrown;
+      try {
+        if (typeof actual === 'function') {
+          await actual();
+        }
+      } catch (e) {
+        threw = true;
+        thrown = e;
+      }
+      if (!threw) {
+        return check(false, `expected function ${not}to throw`);
+      }
+      if (matcher instanceof RegExp) {
+        check(matcher.test(thrown.message), `expected thrown message ${not}to match ${matcher} (got: ${thrown.message})`);
+      } else if (typeof matcher === 'string') {
+        check(thrown.message.includes(matcher), `expected thrown message ${not}to contain "${matcher}" (got: ${thrown.message})`);
+      } else {
+        check(true, '');
+      }
+    },
+  };
+}
+
+function expect(actual) {
+  const m = buildMatchers(actual, false);
+  m.not = buildMatchers(actual, true);
+  return m;
+}
+
+module.exports = expect;

package/dist/test/fixtures/consumer-site/_site/about.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en" data-page-path="/about">
+<head>
+<meta charset="utf-8">
+<title>About — UJM Fixture Consumer</title>
+</head>
+<body>
+  <main id="main-content">
+    <h1>About</h1>
+    <p>Fixture about page.</p>
+  </main>
+</body>
+</html>

package/dist/test/fixtures/consumer-site/_site/assets/css/main.bundle.css

@@ -0,0 +1,2 @@
+/* Fixture stylesheet — loaded by index.html to verify CSS MIME routing. */
+body { font-family: system-ui, sans-serif; margin: 2rem; }

package/dist/test/fixtures/consumer-site/_site/assets/js/main.bundle.js

@@ -0,0 +1,6 @@
+// Minimal fixture bundle. Real UJM bundles initialize a Manager + webManager;
+// for boot tests we only need a script that loads without throwing so the
+// fixture site can assert "no console errors".
+(function () {
+  window.__ujmFixtureLoaded = true;
+})();

package/dist/test/fixtures/consumer-site/_site/build.json

@@ -0,0 +1,11 @@
+{
+  "timestamp": "2024-01-01T00:00:00.000Z",
+  "repo":      { "user": "itw-creative-works", "name": "ujm-fixture" },
+  "environment": "production",
+  "packages":  { "ultimate-jekyll-manager": "fixture", "web-manager": "fixture" },
+  "config": {
+    "brand": { "id": "ujm-fixture", "name": "UJM Fixture Consumer" },
+    "theme": { "id": "classy", "target": "frontend" },
+    "uj":    { "environment": "production", "cache_breaker": "fixture-1" }
+  }
+}

package/dist/test/fixtures/consumer-site/_site/index.html

@@ -0,0 +1,28 @@
+<!doctype html>
+<html lang="en" data-page-path="/">
+<head>
+<meta charset="utf-8">
+<title>UJM Fixture Consumer</title>
+<meta name="description" content="Fixture site for UJM boot tests.">
+<link rel="stylesheet" href="/assets/css/main.bundle.css">
+</head>
+<body>
+  <main id="main-content">
+    <h1>UJM Fixture Consumer</h1>
+    <p>This is a minimal _site/ snapshot used by UJM's framework boot tests.</p>
+  </main>
+  <script>
+    window.Configuration = {
+      brand: { id: 'ujm-fixture', name: 'UJM Fixture Consumer' },
+      theme: { id: 'classy', target: 'frontend' },
+      uj:    { environment: 'production', cache_breaker: 'fixture-1' },
+    };
+  </script>
+  <script src="/assets/js/main.bundle.js"></script>
+  <script>
+    if ('serviceWorker' in navigator) {
+      navigator.serviceWorker.register('/service-worker.js', { scope: '/' });
+    }
+  </script>
+</body>
+</html>

package/dist/test/fixtures/consumer-site/_site/service-worker.js

@@ -0,0 +1,29 @@
+// Minimal fixture service worker. UJM's real SW imports Firebase + does cache
+// management; for boot tests we only need to verify registration + activation
+// + cache naming, so this is a trimmed-down stand-in.
+
+const UJ_BUILD_JSON = {
+  config: {
+    brand: { id: 'ujm-fixture' },
+    uj:    { environment: 'production', cache_breaker: 'fixture-1' },
+  },
+};
+
+const brand        = UJ_BUILD_JSON.config.brand.id;
+const cacheBreaker = UJ_BUILD_JSON.config.uj.cache_breaker;
+const CACHE_NAME   = `${brand}-${cacheBreaker}`;
+
+self.addEventListener('install', (event) => {
+  self.skipWaiting();
+});
+
+self.addEventListener('activate', (event) => {
+  event.waitUntil(self.clients.claim());
+});
+
+self.addEventListener('message', (event) => {
+  const data = event.data || {};
+  if (data.command === 'get-cache-name') {
+    event.ports[0] && event.ports[0].postMessage({ name: CACHE_NAME });
+  }
+});

package/dist/test/fixtures/consumer-site/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "ujm-fixture-consumer",
+  "version": "0.0.0",
+  "private": true,
+  "description": "Fixture consumer site used by UJM's framework boot tests. Not published."
+}

package/dist/test/harness/page/index.html

@@ -0,0 +1,51 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>UJM Test Harness</title>
+<!--
+  Page-layer test harness. Loaded by Puppeteer from a tiny embedded HTTP server.
+  Stubs `window.Configuration` (what consumer sites get from Jekyll-rendered
+  HTML) and the data-attributes Manager.initialize() reads. Page-layer suites
+  run their `run(ctx)` body inside this page via `page.evaluate(payload)` —
+  the payload bakes assert.js + each test's body as inline async functions.
+
+  Test results are emitted as console messages prefixed `__UJM_TEST__` and
+  parsed by the parent runner via `page.on('console')`.
+-->
+</head>
+<body data-uj-test-harness>
+  <!--
+    Stub the same DOM signals the frontend Manager reads. The frontend
+    `src/index.js` reads `document.documentElement.dataset.pagePath` and
+    `dataset.assetPath` — set defaults here.
+  -->
+  <script>
+    document.documentElement.dataset.pagePath  = '/';
+    document.documentElement.dataset.assetPath = '';
+
+    // Minimal stub of what Jekyll renders as `window.Configuration` —
+    // enough that webManager.initialize() doesn't throw, and enough for
+    // tests to assert against. Tests that need richer config can mutate
+    // this in their own setup.
+    window.Configuration = {
+      brand:       { id: 'ujm-test', name: 'UJM Test' },
+      theme:       { id: 'classy', target: 'frontend' },
+      meta:        { title: 'UJM Test Harness' },
+      uj:          { environment: 'development', cache_breaker: '0' },
+      web_manager: { firebase: { app: { config: { apiKey: 'test', projectId: 'ujm-test' } } } },
+    };
+
+    // Prerendered icons template — the harness exposes a single icon so
+    // `getPrerenderedIcon('test')` works without any consumer page setup.
+    const tmpl = document.createElement('template');
+    tmpl.id = 'prerendered-icons';
+    tmpl.innerHTML = '<svg data-icon="test" viewBox="0 0 1 1"><rect width="1" height="1"/></svg>';
+    document.body.appendChild(tmpl);
+
+    // Signal the canonical test-mode flag so cross-context helpers can pick
+    // it up even though `process.env` is unreachable from a tab.
+    globalThis.UJ_TEST_MODE = true;
+  </script>
+</body>
+</html>

package/dist/test/index.js

@@ -0,0 +1,63 @@
+// Public test API — what consumers see.
+//
+// Test files export a test definition. Three forms:
+//
+// Standalone:
+//   module.exports = {
+//     layer: 'build',                  // 'build' | 'page' | 'boot'
+//     description: 'config has brand.id',
+//     timeout: 5000,
+//     run: async (ctx) => {
+//       const cfg = Manager.getConfig('project');
+//       ctx.expect(cfg.brand.id).toBeTruthy();
+//     },
+//     cleanup: async (ctx) => { ... },
+//   };
+//
+// Boot layer — spawns Chromium with the consumer's actually-built `_site/` and
+// serves it from an embedded local HTTP server, then runs `inspect` against the
+// live site. Replaces shell-level smoke tests with deterministic, signal-driven
+// pass/fail. Use this to verify the WHOLE integration: site builds, SW registers,
+// pages render, no console errors.
+//
+//   module.exports = {
+//     layer: 'boot',
+//     description: 'home renders + SW registers',
+//     timeout: 20000,
+//     inspect: async ({ site, page, expect, projectRoot }) => {
+//       await page.goto(site.baseUrl + '/');
+//       expect(await page.title()).toBeTruthy();
+//     },
+//   };
+//
+// Suite (sequential, shared state, stop on first failure):
+//   module.exports = {
+//     type: 'suite',
+//     layer: 'page',
+//     description: 'manager init',
+//     tests: [
+//       { name: 'step 1', run: async (ctx) => { ctx.state.mgr = new Manager(); } },
+//       { name: 'step 2', run: async (ctx) => { ctx.expect(ctx.state.mgr).toBeTruthy(); } },
+//     ],
+//   };
+//
+// Group (sequential, shared state, runs ALL tests even if some fail):
+//   module.exports = {
+//     type: 'group',
+//     layer: 'build',
+//     tests: [ ... ],
+//   };
+//
+// Array form (treated as group):
+//   module.exports = [ { name, run }, ... ];
+//
+// The ctx (context) provided to every run/cleanup includes:
+//   - ctx.expect       — Jest-compatible assertion library
+//   - ctx.state        — shared object across tests in a suite/group
+//   - ctx.skip(reason) — throw to skip the current test at runtime
+//   - ctx.layer        — current layer name
+//   - ctx.page         — Puppeteer Page (page layer only)
+
+module.exports = {
+  expect: require('./assert.js'),
+};