npm - @openelement/ssg - Versions diffs - 0.41.0-alpha.1 - Mend

@openelement/ssg 0.41.0-alpha.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (35) hide show

package/LICENSE +21 -0
package/README.md +21 -0
package/package.json +30 -0
package/src/build-postprocess.d.ts +24 -0
package/src/build-postprocess.js +74 -0
package/src/cem-compat.js +226 -0
package/src/entry-generators.d.ts +3 -0
package/src/entry-generators.js +126 -0
package/src/entry-render-helpers.js +307 -0
package/src/entry-render-runtime.js +94 -0
package/src/entry-render-ssg.js +169 -0
package/src/entry-renderer.d.ts +87 -0
package/src/entry-renderer.js +555 -0
package/src/external-resolver.d.ts +62 -0
package/src/external-resolver.js +285 -0
package/src/index.d.ts +31 -0
package/src/index.js +28 -0
package/src/island-manifest.d.ts +27 -0
package/src/island-manifest.js +78 -0
package/src/postprocess.d.ts +73 -0
package/src/postprocess.js +376 -0
package/src/route-scanner-fs.js +29 -0
package/src/route-scanner.d.ts +132 -0
package/src/route-scanner.js +497 -0
package/src/route-type-generator.d.ts +29 -0
package/src/route-type-generator.js +99 -0
package/src/ssg-dynamic.js +66 -0
package/src/ssg-helpers.d.ts +8 -0
package/src/ssg-helpers.js +96 -0
package/src/ssg-i18n.js +78 -0
package/src/ssg-render.d.ts +3 -0
package/src/ssg-render.js +162 -0
package/src/ssg-report.js +172 -0
package/src/ssr-polyfills.d.ts +15 -0
package/src/ssr-polyfills.js +26 -0

package/src/postprocess.d.ts ADDED Viewed

@@ -0,0 +1,73 @@
+import type { SpeculationRulesOptions } from '@openelement/protocol/ssg';
+/** Insert content immediately after <head> opening tag (handles attributes) */ export declare function insertAfterHead(html: string, content: string): string;
+/**
+ * Scan client build output to build tagName -> chunk path mapping.
+ * Reads Rollup manifest JSON (v0.3.0+ deterministic approach).
+ */ export declare function buildIslandChunkMap(root: string, outDir: string, islands: string[], basePath?: string): Record<string, string>;
+/**
+ * Inject client script tag into all HTML files.
+ */ export declare function injectClientScript(dir: string, scriptSrc: string): void;
+/**
+ * Inject CSP <meta> tag into all HTML files (SSG-only).
+ *
+ * For static sites, CSP is enforced via <meta http-equiv="Content-Security-Policy">
+ * rather than HTTP headers. Nonce-based CSP is NOT supported for SSG
+ * (nonces must be per-request and unpredictable - impossible in static files).
+ */ export declare function injectCspMeta(dir: string, cspPolicy: string, reportOnly?: boolean, nonce?: boolean): void;
+/**
+ * Inject DSD polyfill into all HTML files.
+ * Handles browsers that don't natively support Declarative Shadow DOM.
+ */ export declare function injectDsdPolyfill(dir: string): void;
+/**
+ * Inject View Transitions meta tag into all HTML files.
+ *
+ * The View Transitions API (Chrome 111+, Safari 18+, Firefox 129+) enables
+ * smooth cross-page animations for MPA (Multi-Page App) navigation.
+ * For SSG sites, this is a single meta tag - zero JavaScript required.
+ *
+ * When a user clicks a link, the browser automatically creates a cross-fade
+ * transition between the old and new page. No SPA routing needed.
+ *
+ * Supported browsers: Chrome 111+, Edge 111+, Safari 18+, Firefox 129+.
+ * Unsupported browsers silently ignore the meta tag (graceful degradation).
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/View_Transitions_API
+ * @see https://chromestatus.com/feature/5190686707568640
+ */ export declare function injectViewTransitionMeta(dir: string): void;
+/**
+ * Build Speculation Rules JSON from configuration and known routes.
+ *
+ * If user-provided rules exist, they are used directly.
+ * Otherwise, heuristics are applied based on the route list:
+ * - Home page (/) -> prerender (moderate)
+ * - Top-level static pages (1 level deep) -> prerender (conservative)
+ * - Nested static pages -> prefetch
+ * - Dynamic routes (containing :) -> excluded (content depends on params)
+ * - API routes -> excluded
+ *
+ * This two-tier strategy balances instant navigation for high-probability
+ * targets (prerender) with bandwidth-conscious loading for deeper pages (prefetch).
+ *
+ * @param options - User-provided speculation rules configuration
+ * @param routes - Known route entries from route scanner (for heuristic rules)
+ * @returns Speculation Rules JSON string, or empty string if no rules apply
+ */ export declare function buildSpeculationRulesJson(options: SpeculationRulesOptions, routes?: Array<{
+  path: string;
+  type: string;
+}>): string;
+/**
+ * Inject Speculation Rules into all HTML files.
+ *
+ * The Speculation Rules API (Chrome 121+) enables the browser to
+ * prefetch or prerender pages before the user navigates to them.
+ * This makes navigation feel instant for SSG sites.
+ *
+ * Speculation Rules are declarative JSON in a <script type="speculationrules"> tag.
+ * They have zero JavaScript runtime cost - the browser handles everything natively.
+ *
+ * Only Chromium-based browsers (Chrome, Edge) support this as of 2026.
+ * Safari and Firefox silently ignore the script tag (graceful degradation).
+ *
+ * @param dir - Output directory containing HTML files
+ * @param rulesJson - Pre-built speculation rules JSON string
+ */ export declare function injectSpeculationRules(dir: string, rulesJson: string): void;

package/src/postprocess.js ADDED Viewed

@@ -0,0 +1,376 @@
+/**
+ * adapter-vite internal SSG post-processing.
+ *
+ * Pure Node.js fs operations for SSG output post-processing.
+ * No Vite dependency - these functions only read/write files.
+ *
+ * URLPattern is used for route matching per WHATWG section7.2.
+ *
+ * Post-processing pipeline (called after SSG rendering):
+ * 1. injectClientScript() - add island client entry
+ * 2. injectViewTransitionMeta() - enable cross-page View Transitions
+ * 3. injectSpeculationRules() - prefetch/prerender for navigation performance
+ * 4. injectCspMeta() - Content-Security-Policy meta tag
+ * 5. injectDsdPolyfill() - DSD polyfill for Firefox
+ */ import { join, resolve } from 'node:path';
+import { existsSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { createLogger } from '@openelement/core/logger';
+import { formatError } from '@openelement/core/errors';
+const log = createLogger('core');
+// Shared directory walker
+/**
+ * Walk a directory tree and apply a visitor to each HTML file.
+ * If the visitor returns a string, the file is overwritten with that content.
+ * If it returns null, the file is left unchanged.
+ */ function walkHtmlFiles(dir, visitor) {
+  const entries = readdirSync(dir, {
+    withFileTypes: true
+  });
+  for (const entry of entries){
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      walkHtmlFiles(fullPath, visitor);
+    } else if (entry.name.endsWith('.html')) {
+      const content = readFileSync(fullPath, 'utf-8');
+      const result = visitor(content, fullPath);
+      if (result !== null) {
+        writeFileSync(fullPath, result, 'utf-8');
+      }
+    }
+  }
+}
+// ─── HTML Insertion Helpers ────────────────────────────────────────────
+/** Insert content immediately after <head> opening tag (handles attributes) */ export function insertAfterHead(html, content) {
+  // M-11 fix: Use [^>]* instead of [\s\S]*? to prevent backtracking
+  const headMatch = html.match(/<head(\s[^>]*)?>/i);
+  if (!headMatch) {
+    return html.startsWith('<!') || html.startsWith('<html') ? html.replace(/(<(?:!DOCTYPE|html)[^>]*>)/i, `$1\n<head>\n  ${content}\n</head>`) : `<head>\n  ${content}\n</head>\n${html}`;
+  }
+  if (headMatch.index === undefined) {
+    throw new Error('insertAfterHead: matched <head> but index is undefined');
+  }
+  const headEnd = headMatch.index + headMatch[0].length;
+  return html.slice(0, headEnd) + `\n  ${content}` + html.slice(headEnd);
+}
+/** Insert content immediately before </body> closing tag */ function insertBeforeBodyClose(html, content) {
+  const bodyCloseMatch = html.match(/<\/body\s*>/i);
+  if (!bodyCloseMatch) {
+    return html + `\n${content}\n`;
+  }
+  if (bodyCloseMatch.index === undefined) {
+    throw new Error('insertBeforeBodyClose: matched </body> but index is undefined');
+  }
+  const idx = bodyCloseMatch.index;
+  return html.slice(0, idx) + `${content}\n` + html.slice(idx);
+}
+// ─── Public API ────────────────────────────────────────────────────────
+/**
+ * Scan client build output to build tagName -> chunk path mapping.
+ * Reads Rollup manifest JSON (v0.3.0+ deterministic approach).
+ */ export function buildIslandChunkMap(root, outDir, islands, basePath = '/') {
+  const distDir = resolve(root, outDir);
+  const clientDir = resolve(distDir, 'client');
+  const islandChunkMap = {};
+  if (!existsSync(clientDir)) return islandChunkMap;
+  const manifestPath = join(clientDir, '.vite', 'manifest.json');
+  if (!existsSync(manifestPath)) return islandChunkMap;
+  try {
+    const manifestRaw = readFileSync(manifestPath, 'utf-8');
+    const manifest = JSON.parse(manifestRaw);
+    for (const [_srcPath, entry] of Object.entries(manifest)){
+      if (!entry.file) continue;
+      const chunkMatch = entry.file.match(/^islands\/island-(.+?)-[A-Za-z0-9]+\.js$/);
+      if (chunkMatch && islands.includes(chunkMatch[1])) {
+        islandChunkMap[chunkMatch[1]] = `${basePath}client/${entry.file}`;
+      }
+      if (entry.file === 'islands/client.js') {
+        for (const tagName of islands){
+          if (!islandChunkMap[tagName]) {
+            islandChunkMap[tagName] = `${basePath}client/islands/client.js`;
+          }
+        }
+      }
+    }
+  } catch (e) {
+    // Malformed manifest - warn and return empty map
+    log.warn(`Could not parse client manifest: ${formatError(e)}`);
+  }
+  return islandChunkMap;
+}
+/**
+ * Inject client script tag into all HTML files.
+ */ export function injectClientScript(dir, scriptSrc) {
+  const scriptTag = `  <script type="module" src="${scriptSrc}"></script>`;
+  walkHtmlFiles(dir, (content)=>{
+    if (content.includes(scriptSrc)) return null;
+    return insertBeforeBodyClose(content, scriptTag);
+  });
+}
+/**
+ * Inject CSP <meta> tag into all HTML files (SSG-only).
+ *
+ * For static sites, CSP is enforced via <meta http-equiv="Content-Security-Policy">
+ * rather than HTTP headers. Nonce-based CSP is NOT supported for SSG
+ * (nonces must be per-request and unpredictable - impossible in static files).
+ */ export function injectCspMeta(dir, cspPolicy, reportOnly = false, nonce = false) {
+  if (nonce) {
+    log.warn('CSP nonce is not supported for SSG static output. ' + 'Falling back to policy-only Content-Security-Policy meta tag. ' + 'For per-request nonces, use a server-side middleware instead.');
+  }
+  const headerName = reportOnly ? 'Content-Security-Policy-Report-Only' : 'Content-Security-Policy';
+  const escapedPolicy = cspPolicy.replace(/"/g, '&quot;');
+  const metaTag = `  <meta http-equiv="${headerName}" content="${escapedPolicy}">`;
+  walkHtmlFiles(dir, (content)=>{
+    if (content.includes(`http-equiv="${headerName}"`)) return null;
+    return insertAfterHead(content, metaTag);
+  });
+}
+/**
+ * DSD polyfill for browsers that don't support Declarative Shadow DOM.
+ * Firefox does NOT support shadowrootmode as of 2025.
+ * This polyfill attaches Shadow Roots manually via attachShadow().
+ */ const DSD_POLYFILL = `
+<style>html{visibility:visible!important}</style>
+<script>
+// DSD Polyfill (Firefox, older browsers)
+(function() {
+  try {
+    const t = document.createElement('template');
+    t.setAttribute('shadowrootmode', 'open');
+    if ('shadowRootMode' in t) return; // Native support
+  } catch { /* native detection failed - fallback to polyfill */ }
+  const attachDSD = (root) => {
+    root.querySelectorAll('template[shadowrootmode]').forEach(tpl => {
+      const parent = tpl.parentNode;
+      if (!parent || parent.shadowRoot) return;
+      try {
+        const mode = tpl.getAttribute('shadowrootmode');
+        const opts = { mode: mode === 'open' ? 'open' : 'closed' };
+        if (tpl.hasAttribute('shadowrootdelegatesfocus')) opts.delegatesFocus = true;
+        const sr = parent.attachShadow(opts);
+        sr.innerHTML = tpl.innerHTML;
+        tpl.remove();
+        attachDSD(sr); // Handle nested DSD
+      } catch { /* non-fatal: skip malformed DSD templates */ }
+    });
+  };
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', () => attachDSD(document));
+  } else {
+    attachDSD(document);
+  }
+  // Fallback: if after polyfill some templates remain unattached, inline them
+  // into light DOM so content is still visible even if attachShadow failed.
+  const fallbackRender = () => {
+    document.querySelectorAll('template[shadowrootmode]').forEach((tpl) => {
+      const parent = tpl.parentNode;
+      if (!parent || parent.shadowRoot) return;
+      const frag = tpl.content.cloneNode(true);
+      parent.appendChild(frag);
+      tpl.remove();
+    });
+  };
+  if (document.readyState === 'complete') {
+    fallbackRender();
+  } else {
+    window.addEventListener('load', fallbackRender, { once: true });
+  }
+})();
+</script>
+`;
+/**
+ * Inject DSD polyfill into all HTML files.
+ * Handles browsers that don't natively support Declarative Shadow DOM.
+ */ export function injectDsdPolyfill(dir) {
+  walkHtmlFiles(dir, (content)=>{
+    if (content.includes('DSD Polyfill')) return null;
+    return insertAfterHead(content, DSD_POLYFILL);
+  });
+}
+// ─── View Transitions API ─────────────────────────────────────────────
+/**
+ * Inject View Transitions meta tag into all HTML files.
+ *
+ * The View Transitions API (Chrome 111+, Safari 18+, Firefox 129+) enables
+ * smooth cross-page animations for MPA (Multi-Page App) navigation.
+ * For SSG sites, this is a single meta tag - zero JavaScript required.
+ *
+ * When a user clicks a link, the browser automatically creates a cross-fade
+ * transition between the old and new page. No SPA routing needed.
+ *
+ * Supported browsers: Chrome 111+, Edge 111+, Safari 18+, Firefox 129+.
+ * Unsupported browsers silently ignore the meta tag (graceful degradation).
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/View_Transitions_API
+ * @see https://chromestatus.com/feature/5190686707568640
+ */ export function injectViewTransitionMeta(dir) {
+  const metaTag = '  <meta name="view-transition" content="same-origin">';
+  walkHtmlFiles(dir, (content)=>{
+    if (content.includes('<meta name="view-transition"')) return null;
+    return insertAfterHead(content, metaTag);
+  });
+}
+// ─── Speculation Rules API ────────────────────────────────────────────
+/**
+ * Build Speculation Rules JSON from configuration and known routes.
+ *
+ * If user-provided rules exist, they are used directly.
+ * Otherwise, heuristics are applied based on the route list:
+ * - Home page (/) -> prerender (moderate)
+ * - Top-level static pages (1 level deep) -> prerender (conservative)
+ * - Nested static pages -> prefetch
+ * - Dynamic routes (containing :) -> excluded (content depends on params)
+ * - API routes -> excluded
+ *
+ * This two-tier strategy balances instant navigation for high-probability
+ * targets (prerender) with bandwidth-conscious loading for deeper pages (prefetch).
+ *
+ * @param options - User-provided speculation rules configuration
+ * @param routes - Known route entries from route scanner (for heuristic rules)
+ * @returns Speculation Rules JSON string, or empty string if no rules apply
+ */ export function buildSpeculationRulesJson(options, routes) {
+  // If user provided explicit rules, use them
+  if (options.prerender?.length || options.prefetch?.length) {
+    const rules = {};
+    if (options.prerender && options.prerender.length > 0) {
+      rules.prerender = options.prerender.map((pattern)=>({
+          where: {
+            href_matches: pattern
+          },
+          ...options.eagerness && options.eagerness !== 'moderate' ? {
+            eagerness: options.eagerness
+          } : {}
+        }));
+    }
+    if (options.prefetch && options.prefetch.length > 0) {
+      rules.prefetch = options.prefetch.map((pattern)=>({
+          where: {
+            href_matches: pattern
+          }
+        }));
+    }
+    // Add exclusion if provided
+    if (options.exclude && options.exclude.length > 0) {
+      const excludeWhere = options.exclude.map((pattern)=>({
+          href_matches: pattern
+        }));
+      // Apply exclusions to both prerender and prefetch
+      for (const key of [
+        'prerender',
+        'prefetch'
+      ]){
+        if (rules[key]) {
+          for (const rule of rules[key]){
+            rule.where.not = {
+              or_matches: excludeWhere
+            };
+          }
+        }
+      }
+    }
+    return JSON.stringify(rules, null, 2);
+  }
+  // Heuristic mode: generate rules from route list
+  if (!routes || routes.length === 0) return '';
+  const staticPagePaths = routes.filter((r)=>r.type === 'page' && !r.path.includes(':')).map((r)=>r.path);
+  if (staticPagePaths.length === 0) return '';
+  // Two-tier strategy:
+  //   - Home page is the highest-probability target -> prerender (moderate)
+  //   - Top-level pages (e.g. /about, /blog) -> prerender (conservative)
+  //   - Nested pages (e.g. /blog/post-slug, /docs/guide) -> prefetch only
+  const prerenderPaths = [];
+  const prefetchPaths = [];
+  for (const path of staticPagePaths){
+    if (path === '/') {
+      // Highest probability: prerender with moderate eagerness
+      prerenderPaths.push(path);
+    } else if (path.split('/').filter(Boolean).length <= 1) {
+      // v0.14.3: Top-level pages get exact-match patterns, NOT wildcards.
+      // Adding /about/* would waste bandwidth prefetching all /about/* sub-paths
+      // that may not exist. Use exact match for single pages.
+      prerenderPaths.push(path);
+    } else {
+      // Deeper pages: prefetch only (lighter than prerender)
+      // Use wildcard for nested sections (e.g., /blog/* matches /blog/post-1, /blog/post-2)
+      prefetchPaths.push(`${path}/*`);
+    }
+  }
+  const rules = {};
+  if (prerenderPaths.length > 0) {
+    rules.prerender = prerenderPaths.map((pattern)=>{
+      // Home page (/): use list rule (source + urls) - no document matcher
+      if (pattern === '/') {
+        return {
+          source: 'list',
+          urls: [
+            '/'
+          ],
+          eagerness: 'moderate'
+        };
+      }
+      // Top-level pages (/about, /blog): use document rule (where: href_matches)
+      return {
+        where: {
+          href_matches: pattern
+        },
+        eagerness: 'conservative'
+      };
+    });
+  }
+  if (prefetchPaths.length > 0) {
+    rules.prefetch = prefetchPaths.map((pattern)=>({
+        where: {
+          href_matches: pattern
+        }
+      }));
+  }
+  // Exclude API routes if any exist
+  const apiPaths = routes.filter((r)=>r.type === 'api').map((r)=>`${r.path}/*`);
+  if (apiPaths.length > 0) {
+    const excludeWhere = apiPaths.map((p)=>({
+        href_matches: p
+      }));
+    for (const key of [
+      'prerender',
+      'prefetch'
+    ]){
+      if (rules[key]) {
+        for (const rule of rules[key]){
+          // Only add exclusion to document rules (where) - list rules (source+urls) don't have where
+          if (rule.where && typeof rule.where === 'object') {
+            rule.where.not = {
+              or_matches: excludeWhere
+            };
+          }
+        }
+      }
+    }
+  }
+  return JSON.stringify(rules, null, 2);
+}
+/**
+ * Inject Speculation Rules into all HTML files.
+ *
+ * The Speculation Rules API (Chrome 121+) enables the browser to
+ * prefetch or prerender pages before the user navigates to them.
+ * This makes navigation feel instant for SSG sites.
+ *
+ * Speculation Rules are declarative JSON in a <script type="speculationrules"> tag.
+ * They have zero JavaScript runtime cost - the browser handles everything natively.
+ *
+ * Only Chromium-based browsers (Chrome, Edge) support this as of 2026.
+ * Safari and Firefox silently ignore the script tag (graceful degradation).
+ *
+ * @param dir - Output directory containing HTML files
+ * @param rulesJson - Pre-built speculation rules JSON string
+ */ export function injectSpeculationRules(dir, rulesJson) {
+  if (!rulesJson.trim()) return;
+  const scriptTag = `  <script type="speculationrules">\n  ${rulesJson}\n  </script>`;
+  walkHtmlFiles(dir, (content)=>{
+    if (content.includes('<script type="speculationrules"')) return null;
+    return insertAfterHead(content, scriptTag);
+  });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/ssg/src/postprocess.ts"],"sourcesContent":["/**\n * adapter-vite internal SSG post-processing.\n *\n * Pure Node.js fs operations for SSG output post-processing.\n * No Vite dependency - these functions only read/write files.\n *\n * URLPattern is used for route matching per WHATWG section7.2.\n *\n * Post-processing pipeline (called after SSG rendering):\n * 1. injectClientScript() - add island client entry\n * 2. injectViewTransitionMeta() - enable cross-page View Transitions\n * 3. injectSpeculationRules() - prefetch/prerender for navigation performance\n * 4. injectCspMeta() - Content-Security-Policy meta tag\n * 5. injectDsdPolyfill() - DSD polyfill for Firefox\n */\n\nimport { join, resolve } from 'node:path';\nimport { existsSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';\nimport { createLogger } from '@openelement/core/logger';\nimport { formatError } from '@openelement/core/errors';\nimport type { SpeculationRulesOptions } from '@openelement/protocol/ssg';\n\nconst log = createLogger('core');\n\n// Shared directory walker\n\n/**\n * Walk a directory tree and apply a visitor to each HTML file.\n * If the visitor returns a string, the file is overwritten with that content.\n * If it returns null, the file is left unchanged.\n */\nfunction walkHtmlFiles(\n  dir: string,\n  visitor: (content: string, fullPath: string) => string | null,\n): void {\n  const entries = readdirSync(dir, { withFileTypes: true });\n  for (const entry of entries) {\n    const fullPath = join(dir, entry.name);\n    if (entry.isDirectory()) {\n      walkHtmlFiles(fullPath, visitor);\n    } else if (entry.name.endsWith('.html')) {\n      const content = readFileSync(fullPath, 'utf-8');\n      const result = visitor(content, fullPath);\n      if (result !== null) {\n        writeFileSync(fullPath, result, 'utf-8');\n      }\n    }\n  }\n}\n\n// ─── HTML Insertion Helpers ────────────────────────────────────────────\n\n/** Insert content immediately after <head> opening tag (handles attributes) */\nexport function insertAfterHead(html: string, content: string): string {\n  // M-11 fix: Use [^>]* instead of [\\s\\S]*? to prevent backtracking\n  const headMatch = html.match(/<head(\\s[^>]*)?>/i);\n  if (!headMatch) {\n    return html.startsWith('<!') || html.startsWith('<html')\n      ? html.replace(/(<(?:!DOCTYPE|html)[^>]*>)/i, `$1\\n<head>\\n  ${content}\\n</head>`)\n      : `<head>\\n  ${content}\\n</head>\\n${html}`;\n  }\n  if (headMatch.index === undefined) {\n    throw new Error('insertAfterHead: matched <head> but index is undefined');\n  }\n  const headEnd = headMatch.index + headMatch[0].length;\n  return html.slice(0, headEnd) + `\\n  ${content}` + html.slice(headEnd);\n}\n\n/** Insert content immediately before </body> closing tag */\nfunction insertBeforeBodyClose(html: string, content: string): string {\n  const bodyCloseMatch = html.match(/<\\/body\\s*>/i);\n  if (!bodyCloseMatch) {\n    return html + `\\n${content}\\n`;\n  }\n  if (bodyCloseMatch.index === undefined) {\n    throw new Error('insertBeforeBodyClose: matched </body> but index is undefined');\n  }\n  const idx = bodyCloseMatch.index;\n  return html.slice(0, idx) + `${content}\\n` + html.slice(idx);\n}\n\n// ─── Public API ────────────────────────────────────────────────────────\n\n/**\n * Scan client build output to build tagName -> chunk path mapping.\n * Reads Rollup manifest JSON (v0.3.0+ deterministic approach).\n */\nexport function buildIslandChunkMap(\n  root: string,\n  outDir: string,\n  islands: string[],\n  basePath: string = '/',\n): Record<string, string> {\n  const distDir = resolve(root, outDir);\n  const clientDir = resolve(distDir, 'client');\n  const islandChunkMap: Record<string, string> = {};\n\n  if (!existsSync(clientDir)) return islandChunkMap;\n\n  const manifestPath = join(clientDir, '.vite', 'manifest.json');\n  if (!existsSync(manifestPath)) return islandChunkMap;\n\n  try {\n    const manifestRaw = readFileSync(manifestPath, 'utf-8');\n    const manifest = JSON.parse(manifestRaw);\n\n    for (const [_srcPath, entry] of Object.entries(manifest) as [string, { file?: string }][]) {\n      if (!entry.file) continue;\n      const chunkMatch = entry.file.match(/^islands\\/island-(.+?)-[A-Za-z0-9]+\\.js$/);\n      if (chunkMatch && islands.includes(chunkMatch[1])) {\n        islandChunkMap[chunkMatch[1]] = `${basePath}client/${entry.file}`;\n      }\n      if (entry.file === 'islands/client.js') {\n        for (const tagName of islands) {\n          if (!islandChunkMap[tagName]) {\n            islandChunkMap[tagName] = `${basePath}client/islands/client.js`;\n          }\n        }\n      }\n    }\n  } catch (e) {\n    // Malformed manifest - warn and return empty map\n    log.warn(\n      `Could not parse client manifest: ${formatError(e)}`,\n    );\n  }\n\n  return islandChunkMap;\n}\n\n/**\n * Inject client script tag into all HTML files.\n */\nexport function injectClientScript(dir: string, scriptSrc: string): void {\n  const scriptTag = `  <script type=\"module\" src=\"${scriptSrc}\"></script>`;\n  walkHtmlFiles(dir, (content) => {\n    if (content.includes(scriptSrc)) return null;\n    return insertBeforeBodyClose(content, scriptTag);\n  });\n}\n\n/**\n * Inject CSP <meta> tag into all HTML files (SSG-only).\n *\n * For static sites, CSP is enforced via <meta http-equiv=\"Content-Security-Policy\">\n * rather than HTTP headers. Nonce-based CSP is NOT supported for SSG\n * (nonces must be per-request and unpredictable - impossible in static files).\n */\nexport function injectCspMeta(\n  dir: string,\n  cspPolicy: string,\n  reportOnly = false,\n  nonce = false,\n): void {\n  if (nonce) {\n    log.warn(\n      'CSP nonce is not supported for SSG static output. ' +\n        'Falling back to policy-only Content-Security-Policy meta tag. ' +\n        'For per-request nonces, use a server-side middleware instead.',\n    );\n  }\n\n  const headerName = reportOnly ? 'Content-Security-Policy-Report-Only' : 'Content-Security-Policy';\n  const escapedPolicy = cspPolicy.replace(/\"/g, '&quot;');\n  const metaTag = `  <meta http-equiv=\"${headerName}\" content=\"${escapedPolicy}\">`;\n\n  walkHtmlFiles(dir, (content) => {\n    if (content.includes(`http-equiv=\"${headerName}\"`)) return null;\n    return insertAfterHead(content, metaTag);\n  });\n}\n\n/**\n * DSD polyfill for browsers that don't support Declarative Shadow DOM.\n * Firefox does NOT support shadowrootmode as of 2025.\n * This polyfill attaches Shadow Roots manually via attachShadow().\n */\nconst DSD_POLYFILL = `\n<style>html{visibility:visible!important}</style>\n<script>\n// DSD Polyfill (Firefox, older browsers)\n(function() {\n  try {\n    const t = document.createElement('template');\n    t.setAttribute('shadowrootmode', 'open');\n    if ('shadowRootMode' in t) return; // Native support\n  } catch { /* native detection failed - fallback to polyfill */ }\n  \n  const attachDSD = (root) => {\n    root.querySelectorAll('template[shadowrootmode]').forEach(tpl => {\n      const parent = tpl.parentNode;\n      if (!parent || parent.shadowRoot) return;\n      try {\n        const mode = tpl.getAttribute('shadowrootmode');\n        const opts = { mode: mode === 'open' ? 'open' : 'closed' };\n        if (tpl.hasAttribute('shadowrootdelegatesfocus')) opts.delegatesFocus = true;\n        const sr = parent.attachShadow(opts);\n        sr.innerHTML = tpl.innerHTML;\n        tpl.remove();\n        attachDSD(sr); // Handle nested DSD\n      } catch { /* non-fatal: skip malformed DSD templates */ }\n    });\n  };\n  \n  if (document.readyState === 'loading') {\n    document.addEventListener('DOMContentLoaded', () => attachDSD(document));\n  } else {\n    attachDSD(document);\n  }\n\n  // Fallback: if after polyfill some templates remain unattached, inline them\n  // into light DOM so content is still visible even if attachShadow failed.\n  const fallbackRender = () => {\n    document.querySelectorAll('template[shadowrootmode]').forEach((tpl) => {\n      const parent = tpl.parentNode;\n      if (!parent || parent.shadowRoot) return;\n      const frag = tpl.content.cloneNode(true);\n      parent.appendChild(frag);\n      tpl.remove();\n    });\n  };\n  if (document.readyState === 'complete') {\n    fallbackRender();\n  } else {\n    window.addEventListener('load', fallbackRender, { once: true });\n  }\n})();\n</script>\n`;\n\n/**\n * Inject DSD polyfill into all HTML files.\n * Handles browsers that don't natively support Declarative Shadow DOM.\n */\nexport function injectDsdPolyfill(dir: string): void {\n  walkHtmlFiles(dir, (content) => {\n    if (content.includes('DSD Polyfill')) return null;\n    return insertAfterHead(content, DSD_POLYFILL);\n  });\n}\n\n// ─── View Transitions API ─────────────────────────────────────────────\n\n/**\n * Inject View Transitions meta tag into all HTML files.\n *\n * The View Transitions API (Chrome 111+, Safari 18+, Firefox 129+) enables\n * smooth cross-page animations for MPA (Multi-Page App) navigation.\n * For SSG sites, this is a single meta tag - zero JavaScript required.\n *\n * When a user clicks a link, the browser automatically creates a cross-fade\n * transition between the old and new page. No SPA routing needed.\n *\n * Supported browsers: Chrome 111+, Edge 111+, Safari 18+, Firefox 129+.\n * Unsupported browsers silently ignore the meta tag (graceful degradation).\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/API/View_Transitions_API\n * @see https://chromestatus.com/feature/5190686707568640\n */\nexport function injectViewTransitionMeta(dir: string): void {\n  const metaTag = '  <meta name=\"view-transition\" content=\"same-origin\">';\n\n  walkHtmlFiles(dir, (content) => {\n    if (content.includes('<meta name=\"view-transition\"')) return null;\n    return insertAfterHead(content, metaTag);\n  });\n}\n\n// ─── Speculation Rules API ────────────────────────────────────────────\n\n/**\n * Build Speculation Rules JSON from configuration and known routes.\n *\n * If user-provided rules exist, they are used directly.\n * Otherwise, heuristics are applied based on the route list:\n * - Home page (/) -> prerender (moderate)\n * - Top-level static pages (1 level deep) -> prerender (conservative)\n * - Nested static pages -> prefetch\n * - Dynamic routes (containing :) -> excluded (content depends on params)\n * - API routes -> excluded\n *\n * This two-tier strategy balances instant navigation for high-probability\n * targets (prerender) with bandwidth-conscious loading for deeper pages (prefetch).\n *\n * @param options - User-provided speculation rules configuration\n * @param routes - Known route entries from route scanner (for heuristic rules)\n * @returns Speculation Rules JSON string, or empty string if no rules apply\n */\nexport function buildSpeculationRulesJson(\n  options: SpeculationRulesOptions,\n  routes?: Array<{ path: string; type: string }>,\n): string {\n  // If user provided explicit rules, use them\n  if (options.prerender?.length || options.prefetch?.length) {\n    const rules: Record<string, unknown[]> = {};\n\n    if (options.prerender && options.prerender.length > 0) {\n      rules.prerender = options.prerender.map((pattern) => ({\n        where: { href_matches: pattern },\n        ...(options.eagerness && options.eagerness !== 'moderate'\n          ? { eagerness: options.eagerness }\n          : {}),\n      }));\n    }\n\n    if (options.prefetch && options.prefetch.length > 0) {\n      rules.prefetch = options.prefetch.map((pattern) => ({\n        where: { href_matches: pattern },\n      }));\n    }\n\n    // Add exclusion if provided\n    if (options.exclude && options.exclude.length > 0) {\n      const excludeWhere = options.exclude.map((pattern) => ({\n        href_matches: pattern,\n      }));\n      // Apply exclusions to both prerender and prefetch\n      for (const key of ['prerender', 'prefetch'] as const) {\n        if (rules[key]) {\n          for (const rule of rules[key] as Record<string, unknown>[]) {\n            (rule.where as Record<string, unknown>).not = { or_matches: excludeWhere };\n          }\n        }\n      }\n    }\n\n    return JSON.stringify(rules, null, 2);\n  }\n\n  // Heuristic mode: generate rules from route list\n  if (!routes || routes.length === 0) return '';\n\n  const staticPagePaths = routes\n    .filter((r) => r.type === 'page' && !r.path.includes(':'))\n    .map((r) => r.path);\n\n  if (staticPagePaths.length === 0) return '';\n\n  // Two-tier strategy:\n  //   - Home page is the highest-probability target -> prerender (moderate)\n  //   - Top-level pages (e.g. /about, /blog) -> prerender (conservative)\n  //   - Nested pages (e.g. /blog/post-slug, /docs/guide) -> prefetch only\n  const prerenderPaths: string[] = [];\n  const prefetchPaths: string[] = [];\n\n  for (const path of staticPagePaths) {\n    if (path === '/') {\n      // Highest probability: prerender with moderate eagerness\n      prerenderPaths.push(path);\n    } else if (path.split('/').filter(Boolean).length <= 1) {\n      // v0.14.3: Top-level pages get exact-match patterns, NOT wildcards.\n      // Adding /about/* would waste bandwidth prefetching all /about/* sub-paths\n      // that may not exist. Use exact match for single pages.\n      prerenderPaths.push(path);\n    } else {\n      // Deeper pages: prefetch only (lighter than prerender)\n      // Use wildcard for nested sections (e.g., /blog/* matches /blog/post-1, /blog/post-2)\n      prefetchPaths.push(`${path}/*`);\n    }\n  }\n\n  const rules: Record<string, unknown[]> = {};\n\n  if (prerenderPaths.length > 0) {\n    rules.prerender = prerenderPaths.map((pattern) => {\n      // Home page (/): use list rule (source + urls) - no document matcher\n      if (pattern === '/') {\n        return {\n          source: 'list',\n          urls: ['/'],\n          eagerness: 'moderate',\n        };\n      }\n      // Top-level pages (/about, /blog): use document rule (where: href_matches)\n      return {\n        where: { href_matches: pattern },\n        eagerness: 'conservative',\n      };\n    });\n  }\n\n  if (prefetchPaths.length > 0) {\n    rules.prefetch = prefetchPaths.map((pattern) => ({\n      where: { href_matches: pattern },\n    }));\n  }\n\n  // Exclude API routes if any exist\n  const apiPaths = routes\n    .filter((r) => r.type === 'api')\n    .map((r) => `${r.path}/*`);\n\n  if (apiPaths.length > 0) {\n    const excludeWhere = apiPaths.map((p) => ({ href_matches: p }));\n    for (const key of ['prerender', 'prefetch'] as const) {\n      if (rules[key]) {\n        for (const rule of rules[key] as Record<string, unknown>[]) {\n          // Only add exclusion to document rules (where) - list rules (source+urls) don't have where\n          if (rule.where && typeof rule.where === 'object') {\n            (rule.where as Record<string, unknown>).not = { or_matches: excludeWhere };\n          }\n        }\n      }\n    }\n  }\n\n  return JSON.stringify(rules, null, 2);\n}\n\n/**\n * Inject Speculation Rules into all HTML files.\n *\n * The Speculation Rules API (Chrome 121+) enables the browser to\n * prefetch or prerender pages before the user navigates to them.\n * This makes navigation feel instant for SSG sites.\n *\n * Speculation Rules are declarative JSON in a <script type=\"speculationrules\"> tag.\n * They have zero JavaScript runtime cost - the browser handles everything natively.\n *\n * Only Chromium-based browsers (Chrome, Edge) support this as of 2026.\n * Safari and Firefox silently ignore the script tag (graceful degradation).\n *\n * @param dir - Output directory containing HTML files\n * @param rulesJson - Pre-built speculation rules JSON string\n */\nexport function injectSpeculationRules(dir: string, rulesJson: string): void {\n  if (!rulesJson.trim()) return;\n\n  const scriptTag = `  <script type=\"speculationrules\">\\n  ${rulesJson}\\n  </script>`;\n\n  walkHtmlFiles(dir, (content) => {\n    if (content.includes('<script type=\"speculationrules\"')) return null;\n    return insertAfterHead(content, scriptTag);\n  });\n}\n"],"names":[],"mappings":"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"}

package/src/route-scanner-fs.js ADDED Viewed

@@ -0,0 +1,29 @@
+/**
+ * @openelement/ssg - Route scanner file-system helpers
+ *
+ * Thin wrappers around Node.js fs promises that swallow errors and return
+ * `undefined` (or `null`) instead of throwing. Used by the route scanner to
+ * keep file-system concerns separate from AST extraction and orchestration.
+ */ import { readdir, readFile, stat } from 'node:fs/promises';
+/** Read a directory, returning `undefined` if it cannot be read. */ export async function safeReadDir(dirPath) {
+  try {
+    return await readdir(dirPath);
+  } catch  {
+    return undefined;
+  }
+}
+/** Read a text file, returning `undefined` if it cannot be read. */ export async function safeReadFile(filePath) {
+  try {
+    return await readFile(filePath, 'utf-8');
+  } catch  {
+    return undefined;
+  }
+}
+/** Stat a path, returning `undefined` if it cannot be stated. */ export async function safeStat(filePath) {
+  try {
+    return await stat(filePath);
+  } catch  {
+    return undefined;
+  }
+}
+//# sourceMappingURL=data:application/json;base64,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