@abreen/tada 1.11.2 → 1.13.2

package/build/reachability.ts

@@ -1,288 +1,114 @@
 import path from 'path';
-import { JSDOM } from 'jsdom';
+import { normalizeOutputPath } from './util';
+import type { HtmlOutputAnalysis } from './types';
 
-function stripQueryAndHash(href: string): string {
-  return href.split('#')[0].split('?')[0];
+function normalizeInternalTarget(target: string): string {
+  return normalizeOutputPath(target);
 }
 
-function isExternalOrAnchor(href: string): boolean {
-  if (!href || href.startsWith('#') || href.startsWith('//')) {
-    return true;
-  }
-
-  return /^[a-zA-Z][a-zA-Z\d+.-]*:/.test(href);
-}
-
-function normalizeUrlPath(pathname: string): string {
-  const normalized = path.posix.normalize(pathname);
-  if (normalized === '.' || normalized === '') {
-    return '/';
-  }
-
-  return normalized.startsWith('/') ? normalized : `/${normalized}`;
-}
-
-function stripBasePath(pathname: string, basePath: string): string {
-  const normalizedPath = normalizeUrlPath(pathname);
-  const normalizedBasePath = normalizeUrlPath(basePath);
-
-  if (normalizedBasePath === '/') {
-    return normalizedPath;
-  }
+function toCandidateHtmlAssetPaths(target: string): string[] {
+  const normalizedTarget = normalizeInternalTarget(target);
 
-  if (normalizedPath === normalizedBasePath) {
-    return '/';
-  }
-
-  const prefix = `${normalizedBasePath}/`;
-  if (normalizedPath.startsWith(prefix)) {
-    return normalizeUrlPath(normalizedPath.slice(normalizedBasePath.length));
-  }
-
-  return normalizedPath;
-}
-
-function toCandidateAssetPaths(urlPath: string): string[] {
-  const normalizedPath = normalizeUrlPath(urlPath);
-
-  if (normalizedPath === '/') {
+  if (normalizedTarget === '/') {
     return ['index.html'];
   }
 
-  if (normalizedPath.endsWith('.html')) {
-    return [normalizedPath.slice(1)];
+  if (normalizedTarget.endsWith('.html')) {
+    return [normalizedTarget.slice(1)];
   }
 
-  if (path.posix.extname(normalizedPath)) {
+  if (path.posix.extname(normalizedTarget)) {
     return [];
   }
 
-  const withoutLeadingSlash = normalizedPath.slice(1);
-  if (normalizedPath.endsWith('/')) {
+  const withoutLeadingSlash = normalizedTarget.slice(1);
+  if (normalizedTarget.endsWith('/')) {
     return [`${withoutLeadingSlash}index.html`];
   }
 
   return [`${withoutLeadingSlash}/index.html`, `${withoutLeadingSlash}.html`];
 }
 
-interface ResolveInternalPathOptions {
-  href: string | null;
-  fromAssetPath: string;
-  basePath?: string;
-}
-
-function resolveInternalPath({
-  href,
-  fromAssetPath,
-  basePath = '/',
-}: ResolveInternalPathOptions): string | null {
-  if (!href) {
+function resolveTargetToAssetTarget(target: string): string | null {
+  const normalizedTarget = normalizeInternalTarget(target);
+  if (normalizedTarget === '/' || normalizedTarget.endsWith('.html')) {
     return null;
   }
-
-  const trimmedHref = href.trim();
-  if (!trimmedHref || isExternalOrAnchor(trimmedHref)) {
-    return null;
-  }
-
-  const pathname = stripQueryAndHash(trimmedHref);
-  if (!pathname) {
-    return null;
-  }
-
-  const resolvedPath = pathname.startsWith('/')
-    ? stripBasePath(pathname, basePath)
-    : normalizeUrlPath(
-        path.posix.join(path.posix.dirname(`/${fromAssetPath}`), pathname),
-      );
-
-  try {
-    return normalizeUrlPath(decodeURIComponent(resolvedPath));
-  } catch {
-    return normalizeUrlPath(resolvedPath);
-  }
+  return path.posix.extname(normalizedTarget) ? normalizedTarget : null;
 }
 
-interface ResolveHrefToHtmlOptions {
-  href: string | null;
-  fromAssetPath: string;
-  basePath?: string;
-  knownAssets: Set<string>;
-}
-
-export function resolveHrefToHtmlAssetPath({
-  href,
-  fromAssetPath,
-  basePath = '/',
-  knownAssets,
-}: ResolveHrefToHtmlOptions): string | null {
-  const decodedPath = resolveInternalPath({ href, fromAssetPath, basePath });
-  if (!decodedPath) {
-    return null;
-  }
-
-  for (const candidate of toCandidateAssetPaths(decodedPath)) {
-    if (knownAssets.has(candidate)) {
-      return candidate;
-    }
-  }
-
-  return null;
-}
-
-interface ResolveHrefToPdfOptions {
-  href: string | null;
-  fromAssetPath: string;
-  basePath?: string;
-  knownPdfPaths: Set<string>;
-}
-
-export function resolveHrefToPdfPath({
-  href,
-  fromAssetPath,
-  basePath = '/',
-  knownPdfPaths,
-}: ResolveHrefToPdfOptions): string | null {
-  const decodedPath = resolveInternalPath({ href, fromAssetPath, basePath });
-  if (!decodedPath || !decodedPath.toLowerCase().endsWith('.pdf')) {
-    return null;
-  }
-
-  return knownPdfPaths.has(decodedPath) ? decodedPath : null;
-}
-
-interface CollectDirectLinksOptions {
-  html: string;
-  fromAssetPath: string;
-  knownAssets: Set<string>;
-  knownPdfPaths?: Set<string>;
-  basePath?: string;
-}
-
-interface DirectSiteAssetLinks {
-  htmlAssetPaths: string[];
-  pdfPaths: string[];
-}
-
-export function collectDirectSiteAssetLinks({
-  html,
-  fromAssetPath,
-  knownAssets,
-  knownPdfPaths = new Set(),
-  basePath = '/',
-}: CollectDirectLinksOptions): DirectSiteAssetLinks {
+export function collectOutgoingHtmlAssetPaths(
+  analysis: HtmlOutputAnalysis,
+  knownHtmlAssetPaths: Set<string>,
+): string[] {
   const htmlAssetPaths = new Set<string>();
-  const pdfPaths = new Set<string>();
-  const dom = new JSDOM(html);
-
-  try {
-    const links = dom.window.document.querySelectorAll('a');
-    for (const link of links) {
-      if (link.classList.contains('disabled')) {
-        continue;
-      }
-
-      const href = link.getAttribute('href');
-      const pdfPath = resolveHrefToPdfPath({
-        href,
-        fromAssetPath,
-        basePath,
-        knownPdfPaths,
-      });
-      if (pdfPath) {
-        pdfPaths.add(pdfPath);
-      }
-
-      const targetPath = resolveHrefToHtmlAssetPath({
-        href,
-        fromAssetPath,
-        basePath,
-        knownAssets,
-      });
-      if (targetPath) {
-        htmlAssetPaths.add(targetPath);
-      }
-    }
 
-    const refreshTarget = getMetaRefreshTarget(dom.window.document);
-    if (refreshTarget) {
-      const targetPath = resolveHrefToHtmlAssetPath({
-        href: refreshTarget,
-        fromAssetPath,
-        basePath,
-        knownAssets,
-      });
-      if (targetPath) {
-        htmlAssetPaths.add(targetPath);
+  for (const target of analysis.outgoingTargets) {
+    for (const candidate of toCandidateHtmlAssetPaths(target)) {
+      if (knownHtmlAssetPaths.has(candidate)) {
+        htmlAssetPaths.add(candidate);
+        break;
       }
     }
-  } finally {
-    dom.window.close();
   }
 
-  return {
-    htmlAssetPaths: [...htmlAssetPaths].sort(),
-    pdfPaths: [...pdfPaths].sort(),
-  };
+  return [...htmlAssetPaths].sort();
 }
 
 interface CollectReachableOptions {
-  htmlAssetsByPath: Map<string, string>;
-  knownPdfPaths?: Set<string>;
+  htmlAnalysisByPath: Map<string, HtmlOutputAnalysis>;
+  knownAssetTargets?: Set<string>;
   rootPath?: string;
-  basePath?: string;
 }
 
 interface ReachableSiteAssets {
   reachableHtmlPaths: string[];
-  reachablePdfPaths: string[];
+  reachableAssetTargets: string[];
 }
 
 export function collectReachableSiteAssets({
-  htmlAssetsByPath,
-  knownPdfPaths = new Set(),
+  htmlAnalysisByPath,
+  knownAssetTargets = new Set(),
   rootPath = 'index.html',
-  basePath = '/',
 }: CollectReachableOptions): ReachableSiteAssets {
-  if (!htmlAssetsByPath.has(rootPath)) {
+  if (!htmlAnalysisByPath.has(rootPath)) {
     throw new Error(`Pagefind reachability root not found: ${rootPath}`);
   }
 
-  const knownAssets = new Set(htmlAssetsByPath.keys());
-  const reachable = new Set<string>();
-  const reachablePdfPaths = new Set<string>();
+  const knownHtmlAssetPaths = new Set(htmlAnalysisByPath.keys());
+  const reachableHtmlPaths = new Set<string>();
+  const reachableAssetTargets = new Set<string>();
   const pending: string[] = [rootPath];
 
   while (pending.length > 0) {
     const currentPath = pending.pop()!;
-    if (reachable.has(currentPath)) {
+    if (reachableHtmlPaths.has(currentPath)) {
       continue;
     }
-    reachable.add(currentPath);
+    reachableHtmlPaths.add(currentPath);
 
-    const html = htmlAssetsByPath.get(currentPath)!;
-    const { htmlAssetPaths, pdfPaths } = collectDirectSiteAssetLinks({
-      html,
-      fromAssetPath: currentPath,
-      knownAssets,
-      knownPdfPaths,
-      basePath,
-    });
+    const analysis = htmlAnalysisByPath.get(currentPath)!;
 
-    for (const pdfPath of pdfPaths) {
-      reachablePdfPaths.add(pdfPath);
+    for (const targetPath of collectOutgoingHtmlAssetPaths(
+      analysis,
+      knownHtmlAssetPaths,
+    )) {
+      if (!reachableHtmlPaths.has(targetPath)) {
+        pending.push(targetPath);
+      }
     }
 
-    for (const targetPath of htmlAssetPaths) {
-      if (!reachable.has(targetPath)) {
-        pending.push(targetPath);
+    for (const target of analysis.outgoingTargets) {
+      const assetTarget = resolveTargetToAssetTarget(target);
+      if (assetTarget && knownAssetTargets.has(assetTarget)) {
+        reachableAssetTargets.add(assetTarget);
       }
     }
   }
 
   return {
-    reachableHtmlPaths: [...reachable].sort(),
-    reachablePdfPaths: [...reachablePdfPaths].sort(),
+    reachableHtmlPaths: [...reachableHtmlPaths].sort(),
+    reachableAssetTargets: [...reachableAssetTargets].sort(),
   };
 }
 
@@ -291,26 +117,3 @@ export function collectReachableHtmlAssets(
 ): string[] {
   return collectReachableSiteAssets(options).reachableHtmlPaths;
 }
-
-function getMetaRefreshTarget(document: Document): string | null {
-  const refreshTags = document.querySelectorAll('meta[http-equiv]');
-  for (const tag of refreshTags) {
-    const httpEquiv = tag.getAttribute('http-equiv');
-    if (!httpEquiv || httpEquiv.toLowerCase() !== 'refresh') {
-      continue;
-    }
-
-    const content = tag.getAttribute('content') || '';
-    const match = content.match(/(?:^|;)\s*url\s*=\s*(.+)\s*$/i);
-    if (!match) {
-      continue;
-    }
-
-    const target = match[1].trim().replace(/^['"]|['"]$/g, '');
-    if (target) {
-      return target;
-    }
-  }
-
-  return null;
-}

package/build/serve.ts

@@ -2,9 +2,14 @@ import fs from 'fs';
 import path from 'path';
 import { makeLogger } from './log';
 import { B } from './colors';
+import { WATCH_RELOAD_PATH, WATCH_RELOAD_TOPIC } from './watch/reload';
 
 const log = makeLogger(import.meta.url);
 
+interface ServerUpgradeTarget {
+  upgrade(req: Request): boolean;
+}
+
 export function resolvePathname(
   distDir: string,
   pathname: string,
@@ -40,13 +45,21 @@ export interface StartServerOptions {
   port?: number;
   distDir: string;
   onReady?: (port: number) => void;
+  watchReload?: { onClientOpen?: () => void; onClientClose?: () => void };
 }
 
-export function startServer(options: StartServerOptions): void {
-  const { port = 8080, distDir, onReady } = options;
-
-  function createResponse(req: Request): Response {
+export function createDevServerFetchHandler(
+  distDir: string,
+  watchReloadEnabled = false,
+) {
+  return (req: Request, server: ServerUpgradeTarget): Response | undefined => {
     const url = new URL(req.url);
+    if (watchReloadEnabled && url.pathname === WATCH_RELOAD_PATH) {
+      return server.upgrade(req)
+        ? undefined
+        : new Response('WebSocket upgrade error', { status: 400 });
+    }
+
     const result = resolvePathname(distDir, url.pathname);
     if (!result) {
       return new Response('Not Found', { status: 404 });
@@ -67,22 +80,38 @@ export function startServer(options: StartServerOptions): void {
     }
 
     return new Response(Bun.file(result.filePath), { headers });
-  }
+  };
+}
+
+export function startServer(options: StartServerOptions) {
+  const { port = 8080, distDir, onReady, watchReload } = options;
 
   try {
+    const fetch = createDevServerFetchHandler(distDir, Boolean(watchReload));
     const server = Bun.serve({
       port,
-      fetch: createResponse,
+      fetch,
       error(error: Error) {
         log.error`Request failed: ${error}`;
         return new Response('Internal Server Error', { status: 500 });
       },
+      websocket: {
+        message() {},
+        open(ws) {
+          ws.subscribe(WATCH_RELOAD_TOPIC);
+          watchReload?.onClientOpen?.();
+        },
+        close() {
+          watchReload?.onClientClose?.();
+        },
+      },
     });
 
     log.info`Dev server: ${B`http://localhost:${server.port}/index.html`}`;
     if (onReady) {
       onReady(server.port!);
     }
+    return server;
   } catch (err) {
     log.error`Failed to start server on port ${port}: ${err}`;
     process.exit(1);

package/build/site-variables.ts

@@ -1,7 +1,7 @@
-import fs from 'fs';
-import path from 'path';
 import { bundledLanguages } from 'shiki';
 import type { BundledLanguage } from 'shiki';
+import { getSiteConfigBaseName, type SiteEnv } from './config-files';
+import { loadSiteConfig } from './config-loader';
 import { compile as compileJsonSchema, doValidation } from './json-schema';
 import { getProjectDir } from './utils/paths';
 import type { PlainTextLanguage, SiteVariables } from './types';
@@ -17,12 +17,6 @@ const DEFAULT: Partial<SiteVariables> = {
 
 const isValid = compileJsonSchema(siteSchema);
 
-function getJson(filePath: string): Record<string, unknown> {
-  return JSON.parse(
-    fs.readFileSync(path.resolve(configDir, filePath), 'utf-8'),
-  );
-}
-
 const PLAIN_TEXT_LANGUAGES = ['plain', 'text', 'txt'] as const;
 
 export function isPlainTextLanguage(lang: string): lang is PlainTextLanguage {
@@ -112,9 +106,10 @@ export function getRuntimeBundledShikiLanguages(
   return [...new Set(configured)];
 }
 
-function getSiteVariables(env: string): SiteVariables {
-  const fileName = `site.${env}.json`;
-  const fromFile = getJson(fileName);
+function getSiteVariables(env: SiteEnv): SiteVariables {
+  const loaded = loadSiteConfig(configDir, env);
+  const fileName = loaded.fileName;
+  const fromFile = getValidatedSiteConfigRoot(loaded.value, fileName);
   const extensionToShikiLanguage = validateExtensionToShikiLanguage(
     fromFile.extensionToShikiLanguage,
     fileName,
@@ -167,3 +162,17 @@ export function getDevSiteVariables(): SiteVariables {
 export function getProdSiteVariables(): SiteVariables {
   return getSiteVariables('prod');
 }
+
+export { getSiteConfigBaseName };
+
+function getValidatedSiteConfigRoot(
+  value: unknown,
+  fileName: string,
+): Record<string, unknown> {
+  if (value && typeof value === 'object' && !Array.isArray(value)) {
+    return value as Record<string, unknown>;
+  }
+
+  doValidation(isValid, value, fileName);
+  throw new Error(`${fileName} failed validation`);
+}