snappy-prerender 2.7.0 → 2.8.0

package/src/core/audit/metadata.js

@@ -49,7 +49,7 @@ export function auditMetadata({ pages, config, add }) {
       ]);
     }
     if (config.metadata?.siteUrl && meta.canonical) {
-      const expected = expectedPageUrl(page.route, config);
+      const expected = expectedPageUrl(page.route, config, page.locale);
       if (expected && meta.canonical !== expected) {
         add(
           'warning',
@@ -60,6 +60,7 @@ export function auditMetadata({ pages, config, add }) {
       }
     }
   }
+  auditHreflang({ pages, config, add });
   for (const [title, routes] of titles) {
     if (routes.length < 2) continue;
     add('error', 'duplicate-title', `routes share the title "${title}": ${routes.join(', ')}`, {
@@ -77,12 +78,120 @@ export function auditMetadata({ pages, config, add }) {
   }
 }
 
+/**
+ * Checks generated and app-owned hreflang links for validity, self-reference, x-default
+ * and reciprocal links inside the run.
+ * @param {{ pages: Array<object>, config: object, add: Function }} input
+ */
+function auditHreflang({ pages, config, add }) {
+  if (!config.locales) return;
+  const byUrl = new Map();
+  for (const page of pages) {
+    if (page.noindex || page.notFound) continue;
+    const url = expectedPageUrl(page.route, config, page.locale) ?? page.meta?.canonical;
+    if (url) byUrl.set(url, page);
+  }
+  for (const page of pages) {
+    if (page.noindex || page.notFound) continue;
+    const meta = page.meta ?? {};
+    const code = page.locale ?? config.locales.active ?? config.locales.default;
+    const locale = config.locales.list.find((entry) => entry.code === code) ?? null;
+    const expectedLang = locale?.htmlLang ?? code;
+    if (!meta.lang) {
+      add('warning', 'html-lang-missing', `${page.route} has no <html lang>`, {
+        route: page.route,
+      });
+    } else if (meta.lang !== expectedLang && meta.lang !== code) {
+      add(
+        'warning',
+        'html-lang-mismatch',
+        `${page.route} has <html lang="${meta.lang}">, expected "${expectedLang}"`,
+        { route: page.route },
+      );
+    }
+    if (locale?.ogLocale && !meta.ogLocale) {
+      add('warning', 'og-locale-missing', `${page.route} has no og:locale for ${code}`, {
+        route: page.route,
+      });
+    }
+    if (config.locales.hreflang === false) continue;
+    const alternates = meta.alternates ?? [];
+    const seen = new Set();
+    for (const alternate of alternates) {
+      const value = String(alternate.hreflang);
+      if (value !== 'x-default' && !validHreflang(value)) {
+        add('error', 'hreflang-invalid', `${page.route} has invalid hreflang "${value}"`, {
+          route: page.route,
+        });
+      }
+      const key = value.toLowerCase();
+      if (seen.has(key)) {
+        add('error', 'hreflang-duplicate', `${page.route} repeats hreflang "${value}"`, {
+          route: page.route,
+        });
+      }
+      seen.add(key);
+    }
+    const selfUrl = meta.canonical ?? expectedPageUrl(page.route, config, page.locale);
+    const self = alternates.find((alternate) => alternate.hreflang === code);
+    if (!self) {
+      add('warning', 'hreflang-missing-self', `${page.route} has no self hreflang "${code}"`, {
+        route: page.route,
+      });
+    } else if (selfUrl && self.href !== selfUrl) {
+      add(
+        'warning',
+        'hreflang-canonical-mismatch',
+        `${page.route} hreflang "${code}" points at ${self.href}, expected ${selfUrl}`,
+        { route: page.route },
+      );
+    }
+    if (!seen.has('x-default') && config.locales.xDefault !== false) {
+      add('warning', 'hreflang-missing-x-default', `${page.route} has no x-default hreflang`, {
+        route: page.route,
+      });
+    }
+    for (const alternate of alternates) {
+      const target = byUrl.get(alternate.href);
+      if (!target) continue;
+      const targetSelf = target.meta?.alternates?.some(
+        (entry) => entry.hreflang === code && entry.href === selfUrl,
+      );
+      if (!targetSelf) {
+        add(
+          'error',
+          'hreflang-missing-return',
+          `${page.route} links to ${target.route} for ${alternate.hreflang}, but ${target.route} does not link back`,
+          { route: page.route, to: target.route },
+        );
+      }
+    }
+  }
+}
+
+/**
+ * Reports whether a value is a valid hreflang language tag.
+ * @param {string} code
+ * @returns {boolean}
+ */
+function validHreflang(code) {
+  try {
+    return Intl.getCanonicalLocales(code).length === 1;
+  } catch {
+    return false;
+  }
+}
+
 // Resolves the public URL a page should canonicalise and be listed at.
-export function expectedPageUrl(route, config) {
-  if (!config.metadata?.siteUrl) return null;
+export function expectedPageUrl(route, config, localeCode = null) {
+  const locale = localeCode
+    ? config.locales?.list?.find((entry) => entry.code === localeCode)
+    : null;
+  const baseUrl = locale?.url ?? config.metadata?.siteUrl;
+  if (!baseUrl) return null;
   const path = pagePath(route, {
     flatOutput: config.flatOutput,
     trailingSlash: config.metadata.trailingSlash,
   });
-  return `${config.metadata.siteUrl.replace(/\/$/, '')}${toPublicPath(path, config.base)}`;
+  return `${baseUrl.replace(/\/$/, '')}${toPublicPath(path, config.base)}`;
 }

package/src/core/audit/sitemap.js

@@ -9,7 +9,7 @@ export function auditSitemap({ pages, config, report, add }) {
   const indexable = new Map();
   const noindex = new Map();
   for (const page of pages) {
-    const loc = expectedPageUrl(page.route, config);
+    const loc = expectedPageUrl(page.route, config, page.locale);
     if (!loc) continue;
     if (page.noindex || page.notFound) {
       noindex.set(loc, page.route);

package/src/core/clock.js

@@ -0,0 +1,60 @@
+/**
+ * Resolves the fixed build time used by both the render and verification passes. Explicit
+ * values win, then SOURCE_DATE_EPOCH, then the supplied fallback (the run start time).
+ * @param {object} config
+ * @param {number} fallbackTime
+ * @returns {number | null}
+ */
+export function resolveFixedTime(config, fallbackTime = Date.now()) {
+  if (config.freezeTime === false) return null;
+  if (typeof config.freezeTime === 'number') return config.freezeTime;
+  if (typeof config.freezeTime === 'string') {
+    const parsed = Date.parse(config.freezeTime);
+    return Number.isNaN(parsed) ? null : parsed;
+  }
+  const rawSourceDate = process.env.SOURCE_DATE_EPOCH;
+  if (rawSourceDate && /^\d+$/.test(rawSourceDate)) {
+    return Number.parseInt(rawSourceDate, 10) * 1000;
+  }
+  return fallbackTime;
+}
+
+/**
+ * Fixes Date in one page while leaving real timers running, so settling and scheduled
+ * work keep the same timing they have in a normal browser.
+ * @param {import('playwright-core').Page} page
+ * @param {number | null} fixedTime
+ */
+export async function installClock(page, fixedTime) {
+  if (fixedTime === null) return;
+  await page.clock.setFixedTime(fixedTime);
+}
+
+/**
+ * Adds the build-time globals and an optional deterministic Math.random. The PRNG is for
+ * reproducible demo content, never for security-sensitive values.
+ * @param {import('playwright-core').Page} page
+ * @param {{ fixedTime: number | null, randomSeed: number | null }} options
+ */
+export async function installClockScripts(page, { fixedTime, randomSeed }) {
+  if (fixedTime === null && randomSeed === null) return;
+  await page.addInitScript(
+    ({ time, seed }) => {
+      if (time !== null) {
+        window.__SNAPPY_NOW__ = time;
+        window.__SNAPPY_NOW_ISO__ = new Date(time).toISOString();
+      }
+      if (seed !== null) {
+        let state = seed >>> 0;
+        Math.random = () => {
+          state = (state + 0x6d2b79f5) >>> 0;
+          let value = state;
+          value = Math.imul(value ^ (value >>> 15), value | 1);
+          value ^= value + Math.imul(value ^ (value >>> 7), value | 61);
+          return ((value ^ (value >>> 14)) >>> 0) / 4294967296;
+        };
+      }
+    },
+    { time: fixedTime, seed: randomSeed },
+  );
+}