ultimate-jekyll-manager 1.1.9 → 1.2.0

package/dist/test/suites/build/validate-yaml.test.js

@@ -0,0 +1,60 @@
+// validateYAMLFrontMatter pure helper from src/gulp/tasks/utils/_validate-yaml.js.
+// Used by audit to verify _posts / _layouts have valid frontmatter before Jekyll
+// chokes on them with cryptic errors. We test the pure function via a temp file.
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+module.exports = {
+  layer: 'build',
+  description: 'validateYAMLFrontMatter (utils/_validate-yaml.js)',
+  type: 'group',
+  tests: [
+    {
+      name: 'returns { valid: true } for a file with valid frontmatter',
+      run: async (ctx) => {
+        const { validateYAMLFrontMatter } = require('../../../gulp/tasks/utils/_validate-yaml.js');
+        const tmp = path.join(os.tmpdir(), `ujm-test-valid-${Date.now()}.md`);
+        fs.writeFileSync(tmp, '---\ntitle: Hello\nlayout: post\n---\nBody text.', 'utf8');
+        try {
+          const result = validateYAMLFrontMatter(tmp);
+          ctx.expect(result.valid).toBe(true);
+        } finally {
+          fs.unlinkSync(tmp);
+        }
+      },
+    },
+    {
+      name: 'returns { valid: true } when no frontmatter present',
+      run: async (ctx) => {
+        const { validateYAMLFrontMatter } = require('../../../gulp/tasks/utils/_validate-yaml.js');
+        const tmp = path.join(os.tmpdir(), `ujm-test-noyaml-${Date.now()}.md`);
+        fs.writeFileSync(tmp, 'Just markdown, no frontmatter.\n', 'utf8');
+        try {
+          const result = validateYAMLFrontMatter(tmp);
+          ctx.expect(result.valid).toBe(true);
+        } finally {
+          fs.unlinkSync(tmp);
+        }
+      },
+    },
+    {
+      name: 'flags malformed YAML frontmatter as invalid with error message',
+      run: async (ctx) => {
+        const { validateYAMLFrontMatter } = require('../../../gulp/tasks/utils/_validate-yaml.js');
+        const tmp = path.join(os.tmpdir(), `ujm-test-invalid-${Date.now()}.md`);
+        // Mismatched quotes — js-yaml will refuse to parse this.
+        fs.writeFileSync(tmp, '---\ntitle: "Unclosed\ndescription: foo\n---\nBody.', 'utf8');
+        try {
+          const result = validateYAMLFrontMatter(tmp);
+          ctx.expect(result.valid).toBe(false);
+          ctx.expect(typeof result.error).toBe('string');
+          ctx.expect(result.file).toBe(tmp);
+        } finally {
+          fs.unlinkSync(tmp);
+        }
+      },
+    },
+  ],
+};

package/dist/test/suites/page/dom-baseline.test.js

@@ -0,0 +1,34 @@
+// Baseline page-layer sanity: the harness loads, DOM APIs work, fetch works
+// against the local server. If THIS suite fails the harness is broken — no
+// other page-layer test result is trustworthy.
+
+module.exports = {
+  layer: 'page',
+  description: 'page-layer baseline (DOM + fetch + storage)',
+  type: 'group',
+  tests: [
+    {
+      name: 'document is interactive or complete',
+      run: async (ctx) => {
+        ctx.expect(['interactive', 'complete']).toContain(document.readyState);
+      },
+    },
+    {
+      name: 'fetch() works against the local harness server',
+      run: async (ctx) => {
+        const res = await fetch('/');
+        ctx.expect(res.ok).toBe(true);
+        const text = await res.text();
+        ctx.expect(text).toContain('UJM Test Harness');
+      },
+    },
+    {
+      name: 'localStorage is available',
+      run: async (ctx) => {
+        localStorage.setItem('ujm-test-key', 'value');
+        ctx.expect(localStorage.getItem('ujm-test-key')).toBe('value');
+        localStorage.removeItem('ujm-test-key');
+      },
+    },
+  ],
+};

package/dist/test/suites/page/harness-globals.test.js

@@ -0,0 +1,38 @@
+// Verify the page-layer harness provides the globals UJM's frontend Manager
+// reads at runtime: window.Configuration with brand/theme/web_manager, plus
+// document.documentElement.dataset.{pagePath,assetPath}.
+//
+// These are what Jekyll-rendered consumer pages provide. The harness stubs
+// them so we can test frontend Manager logic without a full Jekyll build.
+
+module.exports = {
+  layer: 'page',
+  description: 'harness globals (window.Configuration + dataset)',
+  type: 'group',
+  tests: [
+    {
+      name: 'window.Configuration has brand + theme + web_manager',
+      run: async (ctx) => {
+        ctx.expect(typeof window.Configuration).toBe('object');
+        ctx.expect(window.Configuration.brand.id).toBeTruthy();
+        ctx.expect(window.Configuration.theme.id).toBeTruthy();
+        ctx.expect(window.Configuration.web_manager).toBeTruthy();
+      },
+    },
+    {
+      name: 'document.documentElement.dataset.pagePath is set',
+      run: async (ctx) => {
+        ctx.expect(typeof document.documentElement.dataset.pagePath).toBe('string');
+        // No leading slash (Manager.initialize strips before using).
+        // Harness sets it to '/' so the assertion just checks shape.
+        ctx.expect(document.documentElement.dataset.pagePath).toBe('/');
+      },
+    },
+    {
+      name: 'UJ_TEST_MODE is signalled on globalThis',
+      run: async (ctx) => {
+        ctx.expect(globalThis.UJ_TEST_MODE).toBe(true);
+      },
+    },
+  ],
+};

package/dist/test/suites/page/prerendered-icons.test.js

@@ -0,0 +1,32 @@
+// The harness ships a single icon in <template id="prerendered-icons">.
+// UJM's libs/prerendered-icons.js exposes getPrerenderedIcon(name, classes)
+// that pulls SVG from this template. We can't easily import that lib from
+// in-tab (it's webpack-bundled ESM), so we reimplement the lookup logic
+// inline and assert the template + its data-icon contract.
+
+module.exports = {
+  layer: 'page',
+  description: 'prerendered icons template lookup',
+  type: 'group',
+  tests: [
+    {
+      name: 'template#prerendered-icons exists and has the test icon',
+      run: async (ctx) => {
+        const tmpl = document.getElementById('prerendered-icons');
+        ctx.expect(tmpl).toBeTruthy();
+        ctx.expect(tmpl.tagName.toLowerCase()).toBe('template');
+        const svg = tmpl.content.querySelector('[data-icon="test"]');
+        ctx.expect(svg).toBeTruthy();
+        ctx.expect(svg.tagName.toLowerCase()).toBe('svg');
+      },
+    },
+    {
+      name: 'looking up a missing icon returns null',
+      run: async (ctx) => {
+        const tmpl = document.getElementById('prerendered-icons');
+        const missing = tmpl.content.querySelector('[data-icon="nope-not-real"]');
+        ctx.expect(missing).toBeNull();
+      },
+    },
+  ],
+};

package/dist/utils/mode-helpers.js

@@ -0,0 +1,84 @@
+// Runtime mode helpers (BEM/EM/BXM-pattern), shared across UJM's Managers
+// (build-time `src/build.js`, frontend ES module `src/index.js`, service worker
+// `src/service-worker.js`).
+//
+// Three orthogonal concepts:
+//   isDevelopment() — true when running in dev mode (jekyll dev server, not a
+//                     production build). Detected via NODE_ENV / UJ_BUILD_MODE /
+//                     site config.
+//   isProduction()  — inverse. Running a production-built `_site/`.
+//   isTesting()     — true when UJM's test framework is running this process. Set
+//                     by UJM's test runners (UJ_TEST_MODE=true) and consumer test
+//                     setups that want the same signal.
+//
+// Use these whenever behavior should differ by *what kind of process* you're in —
+// shorter timeouts in tests, prompts suppressed in tests, dev-only banners.
+// Don't use them for "should we hit dev or prod backends" — that's a config
+// concern; use `getEnvironment()` for that (in build.js).
+//
+// Context caveat: in build-time Node (gulp / CLI), `window` is undefined. We
+// detect via `typeof window` so the same code works in every context. In test
+// mode the browser-side check is short-circuited via UJ_TEST_MODE / global so
+// `isTesting()` returns a stable value regardless of which test layer is running.
+
+function isDevelopment() {
+  // Build-time Node fallback.
+  if (typeof process !== 'undefined' && process.env) {
+    if (process.env.UJ_BUILD_MODE === 'true') return false;
+    if (process.env.NODE_ENV === 'development') return true;
+    if (process.env.UJ_IS_SERVER === 'true') return false;
+  }
+  // Browser-side: look at window.Configuration if present.
+  if (typeof window !== 'undefined' && window.Configuration && window.Configuration.uj) {
+    if (window.Configuration.uj.environment === 'development') return true;
+    if (window.Configuration.uj.environment === 'production') return false;
+  }
+  return false;
+}
+
+function isProduction() {
+  return !this.isDevelopment();
+}
+
+function isTesting() {
+  // Canonical signal — set by UJM's test runners and consumer test setups alike.
+  // Works in Node (process.env) AND in browser contexts (the harness preload sets
+  // globalThis.UJ_TEST_MODE before any consumer code runs).
+  if (typeof process !== 'undefined' && process.env && process.env.UJ_TEST_MODE === 'true') return true;
+  if (typeof globalThis !== 'undefined' && globalThis.UJ_TEST_MODE === true) return true;
+  return false;
+}
+
+// `getVersion()` — returns UJM's own version string.
+//   1. `<cwd>/package.json#version` for build-time scripts.
+//   2. null when nothing resolves (e.g. shipped browser bundle with no package.json).
+function getVersion() {
+  try {
+    const path = require('path');
+    const pkg = require(path.join(process.cwd(), 'package.json'));
+    return pkg.version || null;
+  } catch (_) {
+    return null;
+  }
+}
+
+// Mix the helpers into a Manager constructor's prototype + the constructor itself
+// (so `Manager.isTesting()` works statically too, matching BEM/EM/BXM pattern).
+function attachTo(Manager) {
+  Manager.prototype.isDevelopment = isDevelopment;
+  Manager.prototype.isProduction  = isProduction;
+  Manager.prototype.isTesting     = isTesting;
+  Manager.prototype.getVersion    = getVersion;
+  Manager.isDevelopment = isDevelopment;
+  Manager.isProduction  = isProduction;
+  Manager.isTesting     = isTesting;
+  Manager.getVersion    = getVersion;
+}
+
+module.exports = {
+  attachTo,
+  isDevelopment,
+  isProduction,
+  isTesting,
+  getVersion,
+};