radiant-docs 0.1.7 → 0.1.8

package/template/scripts/rewrite-static-asset-host.mjs

@@ -0,0 +1,408 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const CWD = process.cwd();
+const DIST_DIR = path.join(CWD, "dist");
+const LOCAL_ORIGIN = "https://radiant.invalid";
+
+const STATIC_EXTENSIONS = new Set([
+  ".avif",
+  ".css",
+  ".eot",
+  ".gif",
+  ".ico",
+  ".jpeg",
+  ".jpg",
+  ".js",
+  ".json",
+  ".mjs",
+  ".mp4",
+  ".otf",
+  ".pdf",
+  ".png",
+  ".svg",
+  ".ttf",
+  ".txt",
+  ".wasm",
+  ".webmanifest",
+  ".webp",
+  ".woff",
+  ".woff2",
+  ".xml",
+]);
+
+const STATIC_PATH_PREFIXES = ["/_astro/", "/_og/", "/pagefind/"];
+
+function normalizeHostUrl(input) {
+  const withScheme = /^https?:\/\//i.test(input) ? input : `https://${input}`;
+  return new URL(withScheme);
+}
+
+function normalizePrefix(input) {
+  return input.replace(/^\/+/, "").replace(/\/+$/, "");
+}
+
+function findFilesByExtension(dir, extension, files = []) {
+  if (!fs.existsSync(dir)) return files;
+
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+
+    if (entry.isDirectory()) {
+      findFilesByExtension(fullPath, extension, files);
+      continue;
+    }
+
+    if (entry.isFile() && entry.name.endsWith(extension)) {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+function htmlBasePathname(filePath) {
+  const relative = path.relative(DIST_DIR, filePath).replace(/\\/g, "/");
+  if (relative === "index.html") return "/";
+
+  if (relative.endsWith("/index.html")) {
+    return `/${relative.slice(0, -"index.html".length)}`;
+  }
+
+  const slashIndex = relative.lastIndexOf("/");
+  if (slashIndex === -1) return "/";
+  return `/${relative.slice(0, slashIndex + 1)}`;
+}
+
+function decodeValue(value) {
+  return value.trim().replace(/&/g, "&");
+}
+
+function isSkippableUrl(value) {
+  return (
+    !value ||
+    value.startsWith("data:") ||
+    value.startsWith("blob:") ||
+    value.startsWith("mailto:") ||
+    value.startsWith("tel:") ||
+    value.startsWith("javascript:") ||
+    value.startsWith("//")
+  );
+}
+
+function isStaticAssetPath(pathname) {
+  const normalizedPath = pathname.toLowerCase();
+  if (STATIC_PATH_PREFIXES.some((prefix) => normalizedPath.startsWith(prefix))) {
+    return true;
+  }
+
+  const extension = path.extname(normalizedPath);
+  return STATIC_EXTENSIONS.has(extension);
+}
+
+function withPrefix(pathname, prefix) {
+  const normalizedPathname = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  if (
+    normalizedPathname === `/${prefix}` ||
+    normalizedPathname.startsWith(`/${prefix}/`)
+  ) {
+    return normalizedPathname;
+  }
+
+  return `/${prefix}${normalizedPathname}`.replace(/\/+/g, "/");
+}
+
+function rewriteSingleUrl(value, filePath, hostUrl, prefix) {
+  const decoded = decodeValue(value);
+  if (isSkippableUrl(decoded)) {
+    return { value, changed: false };
+  }
+
+  let parsed;
+  try {
+    parsed = new URL(decoded, `${LOCAL_ORIGIN}${htmlBasePathname(filePath)}`);
+  } catch {
+    return { value, changed: false };
+  }
+
+  if (parsed.origin === hostUrl.origin) {
+    const prefixedPathname = withPrefix(parsed.pathname, prefix);
+    if (prefixedPathname === parsed.pathname) {
+      return { value, changed: false };
+    }
+
+    const updated = `${hostUrl.origin}${prefixedPathname}${parsed.search}${parsed.hash}`;
+    return {
+      value: updated.replace(/&/g, "&"),
+      changed: true,
+    };
+  }
+
+  if (parsed.origin !== LOCAL_ORIGIN) {
+    return { value, changed: false };
+  }
+
+  if (!isStaticAssetPath(parsed.pathname)) {
+    return { value, changed: false };
+  }
+
+  const prefixedPathname = withPrefix(parsed.pathname, prefix);
+  const updated = `${hostUrl.origin}${prefixedPathname}${parsed.search}${parsed.hash}`;
+
+  return {
+    value: updated.replace(/&/g, "&"),
+    changed: updated !== decoded,
+  };
+}
+
+function rewriteSrcset(value, filePath, hostUrl, prefix) {
+  const candidates = value.split(",");
+  let changed = false;
+
+  const rewritten = candidates.map((candidate) => {
+    const trimmed = candidate.trim();
+    if (!trimmed) return candidate;
+
+    const whitespaceIndex = trimmed.search(/\s/);
+    const urlPart =
+      whitespaceIndex === -1 ? trimmed : trimmed.slice(0, whitespaceIndex);
+    const descriptor = whitespaceIndex === -1 ? "" : trimmed.slice(whitespaceIndex);
+
+    const rewrittenCandidate = rewriteSingleUrl(urlPart, filePath, hostUrl, prefix);
+    if (rewrittenCandidate.changed) changed = true;
+
+    return `${rewrittenCandidate.value}${descriptor}`;
+  });
+
+  return {
+    value: changed ? rewritten.join(", ") : value,
+    changed,
+  };
+}
+
+function rewriteAttribute(html, filePath, tagName, attribute, hostUrl, prefix) {
+  const pattern = new RegExp(
+    `(<${tagName}\\b[^>]*\\b${attribute}\\s*=\\s*["'])([^"']*)(["'][^>]*>)`,
+    "gi",
+  );
+
+  let changed = false;
+
+  const rewritten = html.replace(pattern, (full, before, value, after) => {
+    const result =
+      attribute === "srcset"
+        ? rewriteSrcset(value, filePath, hostUrl, prefix)
+        : rewriteSingleUrl(value, filePath, hostUrl, prefix);
+
+    if (!result.changed) return full;
+    changed = true;
+    return `${before}${result.value}${after}`;
+  });
+
+  return { html: rewritten, changed };
+}
+
+function rewriteMetaImageContent(html, propertyName, hostUrl, prefix) {
+  const patterns = [
+    new RegExp(
+      `(<meta\\s+[^>]*property\\s*=\\s*["']${propertyName}["'][^>]*\\bcontent\\s*=\\s*["'])([^"']*)(["'][^>]*>)`,
+      "gi",
+    ),
+    new RegExp(
+      `(<meta\\s+[^>]*\\bcontent\\s*=\\s*["'])([^"']*)(["'][^>]*property\\s*=\\s*["']${propertyName}["'][^>]*>)`,
+      "gi",
+    ),
+  ];
+
+  let changed = false;
+  let nextHtml = html;
+
+  for (const pattern of patterns) {
+    nextHtml = nextHtml.replace(pattern, (full, before, value, after) => {
+      const result = rewriteSingleUrl(value, DIST_DIR, hostUrl, prefix);
+      if (!result.changed) return full;
+      changed = true;
+      return `${before}${result.value}${after}`;
+    });
+  }
+
+  return { html: nextHtml, changed };
+}
+
+function rewriteMetaNameContent(html, name, hostUrl, prefix) {
+  const patterns = [
+    new RegExp(
+      `(<meta\\s+[^>]*name\\s*=\\s*["']${name}["'][^>]*\\bcontent\\s*=\\s*["'])([^"']*)(["'][^>]*>)`,
+      "gi",
+    ),
+    new RegExp(
+      `(<meta\\s+[^>]*\\bcontent\\s*=\\s*["'])([^"']*)(["'][^>]*name\\s*=\\s*["']${name}["'][^>]*>)`,
+      "gi",
+    ),
+  ];
+
+  let changed = false;
+  let nextHtml = html;
+
+  for (const pattern of patterns) {
+    nextHtml = nextHtml.replace(pattern, (full, before, value, after) => {
+      const result = rewriteSingleUrl(value, DIST_DIR, hostUrl, prefix);
+      if (!result.changed) return full;
+      changed = true;
+      return `${before}${result.value}${after}`;
+    });
+  }
+
+  return { html: nextHtml, changed };
+}
+
+function rewriteInlinePagefindRuntimeImports(html, filePath, hostUrl, prefix) {
+  const pattern =
+    /(["'])(https?:\/\/[^"'`)]*\/pagefind\/pagefind\.js(?:\?[^"'`)]*)?|\/pagefind\/pagefind\.js(?:\?[^"'`)]*)?)\1/g;
+  let changed = false;
+
+  const rewritten = html.replace(pattern, (full, quote, urlValue) => {
+    const result = rewriteSingleUrl(urlValue, filePath, hostUrl, prefix);
+    if (!result.changed) return full;
+
+    changed = true;
+    return `${quote}${result.value}${quote}`;
+  });
+
+  return { html: rewritten, changed };
+}
+
+function rewriteCssUrls(css, filePath, hostUrl, prefix) {
+  const pattern = /url\(\s*(['"]?)([^"')]+)\1\s*\)/gi;
+  let changed = false;
+
+  const rewritten = css.replace(pattern, (full, quote, value) => {
+    const result = rewriteSingleUrl(value, filePath, hostUrl, prefix);
+    if (!result.changed) return full;
+
+    changed = true;
+    return `url(${quote}${result.value}${quote})`;
+  });
+
+  return { css: rewritten, changed };
+}
+
+function main() {
+  const staticAssetHostInput = process.env.STATIC_ASSET_HOST?.trim();
+  const staticAssetPrefixInput =
+    process.env.R2_BUCKET_PREFIX?.trim() ??
+    process.env.STATIC_ASSET_PREFIX?.trim();
+
+  if (!staticAssetHostInput) {
+    console.log(
+      "Skipping static asset host rewrite: STATIC_ASSET_HOST is not configured.",
+    );
+    return;
+  }
+
+  if (!staticAssetPrefixInput) {
+    console.log(
+      "Skipping static asset host rewrite: R2_BUCKET_PREFIX or STATIC_ASSET_PREFIX is not configured.",
+    );
+    return;
+  }
+
+  if (!fs.existsSync(DIST_DIR)) {
+    console.warn("Skipping static asset host rewrite: dist directory not found.");
+    return;
+  }
+
+  const hostUrl = normalizeHostUrl(staticAssetHostInput);
+  const prefix = normalizePrefix(staticAssetPrefixInput);
+  const htmlFiles = findFilesByExtension(DIST_DIR, ".html").sort();
+
+  if (htmlFiles.length === 0) {
+    console.warn("Skipping static asset host rewrite: no HTML files found in dist.");
+    return;
+  }
+
+  let updatedHtmlCount = 0;
+  let updatedCssCount = 0;
+
+  for (const htmlFile of htmlFiles) {
+    const sourceHtml = fs.readFileSync(htmlFile, "utf8");
+    let nextHtml = sourceHtml;
+    let fileChanged = false;
+
+    const rewrites = [
+      ["link", "href"],
+      ["script", "src"],
+      ["img", "src"],
+      ["img", "srcset"],
+      ["source", "src"],
+      ["source", "srcset"],
+      ["video", "src"],
+      ["video", "poster"],
+      ["audio", "src"],
+    ];
+
+    for (const [tagName, attribute] of rewrites) {
+      const result = rewriteAttribute(
+        nextHtml,
+        htmlFile,
+        tagName,
+        attribute,
+        hostUrl,
+        prefix,
+      );
+      nextHtml = result.html;
+      fileChanged = fileChanged || result.changed;
+    }
+
+    const ogResult = rewriteMetaImageContent(
+      nextHtml,
+      "og:image",
+      hostUrl,
+      prefix,
+    );
+    nextHtml = ogResult.html;
+    fileChanged = fileChanged || ogResult.changed;
+
+    const twitterResult = rewriteMetaNameContent(
+      nextHtml,
+      "twitter:image",
+      hostUrl,
+      prefix,
+    );
+    nextHtml = twitterResult.html;
+    fileChanged = fileChanged || twitterResult.changed;
+
+    const pagefindImportResult = rewriteInlinePagefindRuntimeImports(
+      nextHtml,
+      htmlFile,
+      hostUrl,
+      prefix,
+    );
+    nextHtml = pagefindImportResult.html;
+    fileChanged = fileChanged || pagefindImportResult.changed;
+
+    if (fileChanged) {
+      fs.writeFileSync(htmlFile, nextHtml, "utf8");
+      updatedHtmlCount += 1;
+    }
+  }
+
+  const cssFiles = findFilesByExtension(DIST_DIR, ".css").sort();
+
+  for (const cssFile of cssFiles) {
+    const sourceCss = fs.readFileSync(cssFile, "utf8");
+    const result = rewriteCssUrls(sourceCss, cssFile, hostUrl, prefix);
+
+    if (!result.changed) continue;
+
+    fs.writeFileSync(cssFile, result.css, "utf8");
+    updatedCssCount += 1;
+  }
+
+  console.log(
+    `✅ Static asset host rewrite complete. Updated HTML ${updatedHtmlCount}/${htmlFiles.length}, CSS ${updatedCssCount}/${cssFiles.length}.`,
+  );
+}
+
+main();

package/template/scripts/stamp-image-versions.mjs

@@ -0,0 +1,277 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+
+const CWD = process.cwd();
+const DIST_DIR = path.join(CWD, "dist");
+const VERSION_LENGTH = 12;
+const DIST_ROOT = path.resolve(DIST_DIR);
+const VERSIONED_EXTENSIONS = new Set([
+  ".avif",
+  ".gif",
+  ".ico",
+  ".jpg",
+  ".jpeg",
+  ".m4a",
+  ".mp3",
+  ".mp4",
+  ".oga",
+  ".ogg",
+  ".ogv",
+  ".opus",
+  ".png",
+  ".svg",
+  ".wav",
+  ".webm",
+  ".webp",
+]);
+
+const hashCache = new Map();
+
+function findHtmlFiles(dir, files = []) {
+  if (!fs.existsSync(dir)) return files;
+
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+
+    if (entry.isDirectory()) {
+      findHtmlFiles(fullPath, files);
+      continue;
+    }
+
+    if (entry.isFile() && entry.name.endsWith(".html")) {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+function htmlBasePathname(filePath) {
+  const relative = path.relative(DIST_DIR, filePath).replace(/\\/g, "/");
+  if (relative === "index.html") return "/";
+
+  if (relative.endsWith("/index.html")) {
+    return `/${relative.slice(0, -"index.html".length)}`;
+  }
+
+  const slashIndex = relative.lastIndexOf("/");
+  if (slashIndex === -1) return "/";
+  return `/${relative.slice(0, slashIndex + 1)}`;
+}
+
+function getHash(filePath) {
+  const cached = hashCache.get(filePath);
+  if (cached) return cached;
+
+  const buffer = fs.readFileSync(filePath);
+  const hash = crypto
+    .createHash("sha256")
+    .update(buffer)
+    .digest("hex")
+    .slice(0, VERSION_LENGTH);
+
+  hashCache.set(filePath, hash);
+  return hash;
+}
+
+function resolveLocalImagePath(urlValue, filePath) {
+  const trimmed = urlValue.trim();
+  if (!trimmed) return null;
+
+  const decoded = trimmed.replace(/&/g, "&");
+  if (
+    decoded.startsWith("data:") ||
+    decoded.startsWith("blob:") ||
+    decoded.startsWith("mailto:") ||
+    decoded.startsWith("tel:") ||
+    decoded.startsWith("//")
+  ) {
+    return null;
+  }
+
+  // Ignore fully-qualified URLs.
+  if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(decoded)) {
+    return null;
+  }
+
+  let parsed;
+  try {
+    parsed = new URL(decoded, `https://radiant.invalid${htmlBasePathname(filePath)}`);
+  } catch {
+    return null;
+  }
+
+  const extension = path.extname(parsed.pathname).toLowerCase();
+  if (!VERSIONED_EXTENSIONS.has(extension)) {
+    return null;
+  }
+
+  const normalizedPathname = path.posix
+    .normalize(parsed.pathname)
+    .replace(/^\/+/, "");
+  const absolutePath = path.resolve(DIST_DIR, normalizedPathname);
+
+  if (
+    absolutePath !== DIST_ROOT &&
+    !absolutePath.startsWith(`${DIST_ROOT}${path.sep}`)
+  ) {
+    return null;
+  }
+
+  if (!fs.existsSync(absolutePath) || !fs.statSync(absolutePath).isFile()) {
+    return null;
+  }
+
+  return { parsed, absolutePath };
+}
+
+function formatUpdatedUrl(parsed) {
+  const pathnameWithParams = `${parsed.pathname}${parsed.search}${parsed.hash}`;
+  return pathnameWithParams.replace(/&/g, "&");
+}
+
+function stampSingleUrl(urlValue, filePath) {
+  const resolved = resolveLocalImagePath(urlValue, filePath);
+  if (!resolved) {
+    return { value: urlValue, changed: false };
+  }
+
+  const version = getHash(resolved.absolutePath);
+  resolved.parsed.searchParams.set("v", version);
+
+  const updated = formatUpdatedUrl(resolved.parsed);
+  return { value: updated, changed: updated !== urlValue };
+}
+
+function stampSrcset(srcsetValue, filePath) {
+  const candidates = srcsetValue.split(",");
+  let changed = false;
+
+  const updated = candidates.map((candidate) => {
+    const trimmed = candidate.trim();
+    if (!trimmed) return candidate;
+
+    const whitespaceIndex = trimmed.search(/\s/);
+    const urlPart =
+      whitespaceIndex === -1 ? trimmed : trimmed.slice(0, whitespaceIndex);
+    const descriptor = whitespaceIndex === -1 ? "" : trimmed.slice(whitespaceIndex);
+
+    const stamped = stampSingleUrl(urlPart, filePath);
+    if (stamped.changed) changed = true;
+
+    return `${stamped.value}${descriptor}`;
+  });
+
+  return {
+    value: changed ? updated.join(", ") : srcsetValue,
+    changed,
+  };
+}
+
+function replaceAttribute(html, filePath, attribute) {
+  let tagAlternation = "img|source";
+  if (attribute === "src") {
+    tagAlternation = "img|source|video|audio|track";
+  } else if (attribute === "poster") {
+    tagAlternation = "video";
+  }
+
+  const pattern = new RegExp(
+    `(<(?:${tagAlternation})\\b[^>]*\\b${attribute}\\s*=\\s*["'])([^"']*)(["'][^>]*>)`,
+    "gi",
+  );
+
+  let changed = false;
+
+  const nextHtml = html.replace(
+    pattern,
+    (fullMatch, prefix, value, suffix) => {
+      const stamped =
+        attribute === "srcset"
+          ? stampSrcset(value, filePath)
+          : stampSingleUrl(value, filePath);
+
+      if (!stamped.changed) return fullMatch;
+
+      changed = true;
+      return `${prefix}${stamped.value}${suffix}`;
+    },
+  );
+
+  return { html: nextHtml, changed };
+}
+
+function hasIconRel(tagSource) {
+  const relMatch = tagSource.match(/\brel\s*=\s*["']([^"']+)["']/i);
+  if (!relMatch) return false;
+
+  const relTokens = relMatch[1]
+    .toLowerCase()
+    .split(/\s+/)
+    .filter(Boolean);
+
+  return relTokens.includes("icon") || relTokens.includes("apple-touch-icon");
+}
+
+function replaceIconLinkHref(html, filePath) {
+  const pattern =
+    /(<link\b[^>]*\bhref\s*=\s*["'])([^"']*)(["'][^>]*>)/gi;
+  let changed = false;
+
+  const nextHtml = html.replace(pattern, (fullMatch, prefix, value, suffix) => {
+    if (!hasIconRel(fullMatch)) {
+      return fullMatch;
+    }
+
+    const stamped = stampSingleUrl(value, filePath);
+    if (!stamped.changed) {
+      return fullMatch;
+    }
+
+    changed = true;
+    return `${prefix}${stamped.value}${suffix}`;
+  });
+
+  return { html: nextHtml, changed };
+}
+
+function main() {
+  if (!fs.existsSync(DIST_DIR)) {
+    console.warn("Skipping image version stamping: dist directory not found.");
+    return;
+  }
+
+  const htmlFiles = findHtmlFiles(DIST_DIR).sort();
+  if (htmlFiles.length === 0) {
+    console.warn("Skipping image version stamping: no HTML files found in dist.");
+    return;
+  }
+
+  let updatedCount = 0;
+
+  for (const htmlFile of htmlFiles) {
+    const sourceHtml = fs.readFileSync(htmlFile, "utf8");
+    const srcResult = replaceAttribute(sourceHtml, htmlFile, "src");
+    const srcSetResult = replaceAttribute(srcResult.html, htmlFile, "srcset");
+    const posterResult = replaceAttribute(srcSetResult.html, htmlFile, "poster");
+    const iconHrefResult = replaceIconLinkHref(posterResult.html, htmlFile);
+    const fileChanged =
+      srcResult.changed ||
+      srcSetResult.changed ||
+      posterResult.changed ||
+      iconHrefResult.changed;
+
+    if (fileChanged) {
+      fs.writeFileSync(htmlFile, iconHrefResult.html, "utf8");
+      updatedCount += 1;
+    }
+  }
+
+  console.log(
+    `✅ Image version stamping complete. Updated ${updatedCount}/${htmlFiles.length} HTML files.`,
+  );
+}
+
+main();