@abreen/tada 1.11.3 → 1.13.2

package/build/globals.ts

@@ -1,91 +1,50 @@
-import timezones from '../src/timezone/timezones.json' with { type: 'json' };
-import type { SiteVariables } from './types';
-
-const MONTHS = [
-  '',
-  'January',
-  'February',
-  'March',
-  'April',
-  'May',
-  'June',
-  'July',
-  'August',
-  'September',
-  'October',
-  'November',
-  'December',
-];
-
-interface Globals {
-  isHomePage: boolean;
-  isoDate: (str: string | null | undefined) => string | null;
-  readableDate: (date: string | Date | null | undefined) => string;
-  classNames: (obj: Record<string, unknown>) => string;
-  cx: (obj: Record<string, unknown>) => string;
-  renderTimeZoneChooser: () => string;
-}
-
-export default function createGlobals(
-  pageVariables: Record<string, unknown>,
-  siteVariables: SiteVariables,
-  subPath: string,
-): Globals {
-  const defaultTz = timezones.find(
-    t => t.value === siteVariables.defaultTimeZone,
-  )!;
-  const options = timezones
-    .map(tz => {
-      const label =
-        tz.value === 'UTC' ? tz.label : `${tz.label} (${tz.abbreviation})`;
-      const selected = tz.value === defaultTz.value ? ' selected' : '';
-      return `<option value="${tz.value}"${selected}>${label}</option>`;
-    })
-    .join('');
-  const renderTimeZoneChooser = () =>
-    `<span class="time-zone-label" hidden>Times shown in </span><select class="time-zone" hidden disabled aria-label="Time zone">${options}</select><noscript>Times shown in ${defaultTz.abbreviation}.</noscript>`;
-
-  return {
-    isHomePage: subPath === 'index',
-    isoDate,
-    readableDate,
-    classNames,
-    cx: classNames,
-    renderTimeZoneChooser,
-  };
-}
-
-function isoDate(str: string | null | undefined): string | null {
-  if (str == null || str == '') {
-    return null;
-  }
-  const date = new Date(str);
-  return date.toISOString().slice(0, 10);
+type Sha256Hasher = {
+  update: (buffer: ArrayBuffer) => void;
+  digest: (encoding: 'hex') => string;
+};
+
+export interface Globals {
+  createSha256Hasher: () => Sha256Hasher;
+  cwd: () => string;
+  getEnv: (name: string) => string | undefined;
+  now: () => number;
+  pid: () => number;
+  readFileArrayBuffer: (filePath: string) => Promise<ArrayBuffer>;
+  sleepSync: (delayMs: number) => void;
+  stderrWrite: (chunk: string) => void;
+  stdoutWrite: (chunk: string) => void;
+  toISOString: (timestampMs: number) => string;
 }
 
-function readableDate(date: string | Date | null | undefined): string {
-  if (date == null || date == '') {
-    return '';
-  }
-
-  if (!(date instanceof Date)) {
-    date = new Date(date);
-  }
-
-  const str = date.toISOString();
-  const year = str.slice(0, 4);
-  const month = Number(str.slice(5, 7));
-  const day = Number(str.slice(8, 10));
-
-  return `${MONTHS[month]} ${day}, ${year}`;
-}
-
-export function classNames(obj: Record<string, unknown>): string {
-  const names: string[] = [];
-  for (const key in obj) {
-    if (obj[key]) {
-      names.push(key);
-    }
-  }
-  return names.join(' ');
-}
+export const globals: Globals = {
+  createSha256Hasher() {
+    return new Bun.CryptoHasher('sha256');
+  },
+  cwd() {
+    return process.cwd();
+  },
+  getEnv(name) {
+    return process.env[name];
+  },
+  now() {
+    return Date.now();
+  },
+  pid() {
+    return process.pid;
+  },
+  readFileArrayBuffer(filePath) {
+    return Bun.file(filePath).arrayBuffer();
+  },
+  sleepSync(delayMs) {
+    Bun.sleepSync(delayMs);
+  },
+  stderrWrite(chunk) {
+    process.stderr.write(chunk);
+  },
+  stdoutWrite(chunk) {
+    process.stdout.write(chunk);
+  },
+  toISOString(timestampMs) {
+    return new Date(timestampMs).toISOString();
+  },
+};

package/build/log.ts

@@ -1,20 +1,14 @@
 import { inspect } from 'node:util';
 import path from 'path';
 import { Gi, L, Ri, P, Yi, Li } from './colors';
+import { globals, type Globals } from './globals';
 import type { Logger } from './types';
 import FLAIR_STRINGS from './flair.json' with { type: 'json' };
 
 const LEVELS = ['debug', 'info', 'warn', 'error'] as const;
 
 type LogLevel = (typeof LEVELS)[number];
-
-const ENV_LOG_LEVEL = process.env.TADA_LOG_LEVEL;
-
-if (ENV_LOG_LEVEL && !LEVELS.includes(ENV_LOG_LEVEL as LogLevel)) {
-  throw new Error(
-    `Invalid TADA_LOG_LEVEL "${ENV_LOG_LEVEL}", must be one of: ${LEVELS.join(', ')}`,
-  );
-}
+type LogGlobals = Pick<Globals, 'getEnv' | 'stderrWrite' | 'stdoutWrite'>;
 
 function shouldLog(loggerLevel: string, level: string): boolean {
   return (
@@ -32,20 +26,35 @@ function validateLevel(level: string): void {
 
 function print(
   strings: string[],
+  globals: LogGlobals,
   stream: 'stdout' | 'stderr' = 'stdout',
   end: string = '\n',
 ): void {
   for (const s of strings) {
-    process[stream].write(s);
+    if (stream === 'stderr') {
+      globals.stderrWrite(s);
+    } else {
+      globals.stdoutWrite(s);
+    }
+  }
+  if (stream === 'stderr') {
+    globals.stderrWrite(end);
+  } else {
+    globals.stdoutWrite(end);
   }
-  process[stream].write(end);
 }
 
 export function makeLogger(name: string, logLevel: string = 'info'): Logger {
+  const envLogLevel = globals.getEnv('TADA_LOG_LEVEL');
+  if (envLogLevel && !LEVELS.includes(envLogLevel as LogLevel)) {
+    throw new Error(
+      `Invalid TADA_LOG_LEVEL "${envLogLevel}", must be one of: ${LEVELS.join(', ')}`,
+    );
+  }
   validateLevel(logLevel);
 
-  if (ENV_LOG_LEVEL) {
-    logLevel = ENV_LOG_LEVEL;
+  if (envLogLevel) {
+    logLevel = envLogLevel;
   }
 
   if (name) {
@@ -74,29 +83,29 @@ export function makeLogger(name: string, logLevel: string = 'info'): Logger {
     },
     debug(strings: TemplateStringsArray, ...args: unknown[]) {
       if (shouldLog(this.minLogLevel, 'debug')) {
-        print(getArgs('debug', strings, args, L), 'stderr');
+        print(getArgs('debug', strings, args, L), globals, 'stderr');
       }
     },
     info(strings: TemplateStringsArray, ...args: unknown[]) {
       if (shouldLog(this.minLogLevel, 'info')) {
-        print(getArgs('info', strings, args, Li));
+        print(getArgs('info', strings, args, Li), globals);
       }
     },
     warn(strings: TemplateStringsArray, ...args: unknown[]) {
       if (shouldLog(this.minLogLevel, 'warn')) {
-        print(getArgs('warn', strings, args, Yi));
+        print(getArgs('warn', strings, args, Yi), globals);
       }
     },
     error(strings: TemplateStringsArray, ...args: unknown[]) {
       if (shouldLog(this.minLogLevel, 'error')) {
-        print(getArgs('error', strings, args, Ri));
+        print(getArgs('error', strings, args, Ri), globals);
       }
     },
     event(strings: TemplateStringsArray, ...args: unknown[]) {
-      print(getArgs('event', strings, args, Gi));
+      print(getArgs('event', strings, args, Gi), globals);
     },
     followup(strings: string[]) {
-      print(strings);
+      print(strings, globals);
     },
   };
 

package/build/pagefind.ts

@@ -7,7 +7,7 @@ import {
   normalizeOutputPath,
 } from './util';
 import { assertMutoolAvailable, extractPdfPages } from './pdf-text';
-import type { SiteVariables } from './types';
+import type { HtmlOutputAnalysis } from './types';
 
 const log = makeLogger(import.meta.url);
 const PAGEFIND_VERBOSE = process.env.TADA_LOG_LEVEL === 'debug';
@@ -89,20 +89,26 @@ interface IndexTargets {
 }
 
 function collectIndexTargets(
-  htmlAssetsByPath: Map<string, string>,
-  siteVariables: SiteVariables,
+  htmlAnalysisByPath: Map<string, HtmlOutputAnalysis>,
   pdfSourceByOutputPath: Map<string, string>,
 ): IndexTargets {
-  if (htmlAssetsByPath.size === 0) {
+  if (htmlAnalysisByPath.size === 0) {
     return { reachableHtmlPaths: [], reachablePdfPaths: [] };
   }
 
-  return collectReachableSiteAssets({
-    htmlAssetsByPath,
-    knownPdfPaths: new Set(pdfSourceByOutputPath.keys()),
-    rootPath: 'index.html',
-    basePath: siteVariables.basePath || '/',
-  });
+  const { reachableHtmlPaths, reachableAssetTargets } =
+    collectReachableSiteAssets({
+      htmlAnalysisByPath,
+      knownAssetTargets: new Set(pdfSourceByOutputPath.keys()),
+      rootPath: 'index.html',
+    });
+
+  return {
+    reachableHtmlPaths,
+    reachablePdfPaths: reachableAssetTargets.filter(target =>
+      pdfSourceByOutputPath.has(target),
+    ),
+  };
 }
 
 interface BuildIndexOptions {
@@ -207,28 +213,25 @@ async function buildIndex({
 }
 
 interface RunPagefindOptions {
-  siteVariables: SiteVariables;
   distPath: string;
   htmlAssetsByPath: Map<string, string>;
+  htmlAnalysisByPath: Map<string, HtmlOutputAnalysis>;
 }
 
 export async function runPagefind({
-  siteVariables,
   distPath,
   htmlAssetsByPath,
+  htmlAnalysisByPath,
 }: RunPagefindOptions): Promise<void> {
   const pdfSourceByOutputPath = getPdfSourceByOutputPath();
   const start = Date.now();
 
   log.debug`Finding reachable pages for search index`;
   const { reachableHtmlPaths, reachablePdfPaths } = collectIndexTargets(
-    htmlAssetsByPath,
-    siteVariables,
+    htmlAnalysisByPath,
     pdfSourceByOutputPath,
   );
 
-  const snapshotReadyAt = Date.now();
-
   let noun = reachableHtmlPaths.length === 1 ? 'page' : 'pages';
   let message = `Building search index for ${reachableHtmlPaths.length} ${noun}`;
   if (reachablePdfPaths.length > 0) {
@@ -246,27 +249,32 @@ export async function runPagefind({
   });
 
   const finishedAt = Date.now();
-  log.debug`Search index built in ${finishedAt - snapshotReadyAt}ms (${finishedAt - start}ms total)`;
+  log.debug`Search index built in ${finishedAt - start}ms`;
 }
 
 export class WatchPagefindRunner {
-  private siteVariables: SiteVariables;
   private watchRunInProgress: boolean;
   private watchRunQueued: boolean;
   private distPath: string | null;
   private htmlCacheByAssetPath: Map<string, string>;
+  private htmlAnalysisByPath: Map<string, HtmlOutputAnalysis>;
 
-  constructor(siteVariables: SiteVariables) {
-    this.siteVariables = siteVariables;
+  constructor() {
     this.watchRunInProgress = false;
     this.watchRunQueued = false;
     this.distPath = null;
     this.htmlCacheByAssetPath = new Map();
+    this.htmlAnalysisByPath = new Map();
   }
 
-  update(distPath: string, htmlAssetsByPath: Map<string, string>): void {
+  update(
+    distPath: string,
+    htmlAssetsByPath: Map<string, string>,
+    htmlAnalysisByPath: Map<string, HtmlOutputAnalysis>,
+  ): void {
     this.distPath = distPath;
     this.htmlCacheByAssetPath = htmlAssetsByPath;
+    this.htmlAnalysisByPath = htmlAnalysisByPath;
   }
 
   run(): void {
@@ -280,6 +288,7 @@ export class WatchPagefindRunner {
     this.watchRunQueued = false;
     const distPath = this.distPath!;
     const htmlAssetsByPath = new Map(this.htmlCacheByAssetPath);
+    const htmlAnalysisByPath = new Map(this.htmlAnalysisByPath);
     const pdfSourceByOutputPath = getPdfSourceByOutputPath();
     const start = Date.now();
 
@@ -289,8 +298,7 @@ export class WatchPagefindRunner {
     let reachablePdfPaths: string[];
     try {
       ({ reachableHtmlPaths, reachablePdfPaths } = collectIndexTargets(
-        htmlAssetsByPath,
-        this.siteVariables,
+        htmlAnalysisByPath,
         pdfSourceByOutputPath,
       ));
     } catch (err) {
@@ -302,7 +310,6 @@ export class WatchPagefindRunner {
       return;
     }
 
-    const snapshotReadyAt = Date.now();
     log.debug`Building search index in background`;
     buildIndex({
       distPath,
@@ -313,11 +320,11 @@ export class WatchPagefindRunner {
     })
       .then(() => {
         const finishedAt = Date.now();
-        log.debug`Search index ready after ${finishedAt - snapshotReadyAt}ms (${finishedAt - start}ms total)`;
+        log.info`Search index ready after ${finishedAt - start}ms`;
       })
       .catch(err => {
         const failedAt = Date.now();
-        log.warn`Search index failed after ${failedAt - snapshotReadyAt}ms of indexing (${failedAt - start}ms total): ${err.message}`;
+        log.warn`Search index failed after ${failedAt - start}ms: ${err.message}`;
       })
       .finally(() => {
         this.watchRunInProgress = false;

package/build/pipeline.ts

@@ -1,13 +1,7 @@
 import fs from 'fs';
 import { getDevSiteVariables, getProdSiteVariables } from './site-variables';
-import { getExtensionToShikiLanguage } from './site-variables';
 import { compileTemplates } from './templates';
-import {
-  getDistDir,
-  getProdDistDir,
-  getContentDir,
-  getPublicDir,
-} from './utils/paths';
+import { getDistDir, getProdDistDir } from './utils/paths';
 import { isFeatureEnabled } from './features';
 import { bundle } from './bundle';
 import { copyFonts } from './generate-fonts';
@@ -15,90 +9,115 @@ import { copyKatexAssets } from './generate-katex-assets';
 import { generateFavicons } from './generate-favicon';
 import { generateWebAppManifest } from './generate-web-app-manifest';
 import { copyPublicFiles, copyContentAssets } from './copy';
-import { getProcessedExtensions } from './utils/file-types';
 import { ContentRenderer } from './generate-content-assets';
 import { runPagefind } from './pagefind';
 import { makeLogger, printFlair } from './log';
 import { generateBuildManifest, getNextVersion } from './build-manifest';
+import { scanProject } from './source-model';
+import { validateConfig } from './watch/validation';
+import { applyCommitPlan } from '../watch/fs-commit';
 import path from 'path';
 
 const log = makeLogger(import.meta.url);
 
+function makeTempOutputDir(targetDir: string): string {
+  const parentDir = path.dirname(targetDir);
+  fs.mkdirSync(parentDir, { recursive: true });
+  return fs.mkdtempSync(
+    path.join(parentDir, `${path.basename(targetDir)}-build-`),
+  );
+}
+
+function removeDirIfExists(dir: string): void {
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
 export async function runPipeline(
   mode: 'development' | 'production',
 ): Promise<void> {
   const isDev = mode === 'development';
   const siteVariables = isDev ? getDevSiteVariables() : getProdSiteVariables();
-  let distDir: string;
-  let prodVersion: number;
-
-  if (isDev) {
-    distDir = getDistDir();
-  } else {
-    const prodBase = getProdDistDir();
-    prodVersion = getNextVersion(prodBase);
-    distDir = path.join(prodBase, `v${prodVersion}`);
+  const scan = scanProject(siteVariables);
+  const publishDir = isDev
+    ? getDistDir()
+    : path.join(getProdDistDir(), 'v-next');
+  const distDir = makeTempOutputDir(publishDir);
+  let published = false;
+
+  try {
+    const configDiagnostics = validateConfig(scan);
+    if (configDiagnostics.length > 0) {
+      throw new Error(configDiagnostics[0].message);
+    }
+
+    compileTemplates(siteVariables);
+    const contentRenderer = new ContentRenderer(siteVariables);
+    await contentRenderer.initHighlighter();
+
+    const parallelTasks: (Promise<unknown> | void)[] = [
+      bundle(siteVariables, { mode, distDir }),
+      copyFonts(distDir),
+      copyKatexAssets(distDir),
+    ];
+
+    if (isFeatureEnabled(siteVariables, 'favicon')) {
+      parallelTasks.push(generateFavicons(siteVariables, distDir));
+    }
+
+    const results = await Promise.all(parallelTasks);
+    const assetFiles = results[0] as string[]; // bundle output filenames
+
+    if (isFeatureEnabled(siteVariables, 'favicon')) {
+      generateWebAppManifest(siteVariables, distDir);
+    }
+
+    const publicRelPaths = copyPublicFiles(scan.publicDir, distDir);
+    copyContentAssets(
+      scan.contentDir,
+      distDir,
+      [...scan.processedExts],
+      publicRelPaths,
+    );
+
+    const { errors, htmlAssetsByPath, htmlAnalysisByPath } =
+      contentRenderer.processContent({ distDir, assetFiles, scan });
+
+    for (const err of errors) {
+      log.error`${err.message}`;
+    }
+    if (errors.length > 0) {
+      throw new Error(errors[0].message);
+    }
+
+    if (isFeatureEnabled(siteVariables, 'search')) {
+      await runPagefind({
+        distPath: distDir,
+        htmlAssetsByPath,
+        htmlAnalysisByPath,
+      });
+    }
+
+    let finalOutputDir = getDistDir();
+
+    if (!isDev) {
+      const prodBase = getProdDistDir();
+      const prodVersion = getNextVersion(prodBase);
+      finalOutputDir = path.join(prodBase, `v${prodVersion}`);
+      const manifestPath = path.join(distDir, 'tada.manifest.json');
+      await generateBuildManifest(distDir, manifestPath, prodVersion);
+      log.info`Built dist-prod/v${prodVersion}/`;
+    }
+
+    applyCommitPlan({
+      kind: 'replace-root',
+      stagedPath: distDir,
+      targetPath: finalOutputDir,
+    });
+    published = true;
+    printFlair();
+  } finally {
+    if (!published) {
+      removeDirIfExists(distDir);
+    }
   }
-
-  const contentDir = getContentDir();
-  const publicDir = getPublicDir();
-
-  // Ensure dist/ exists
-  fs.mkdirSync(distDir, { recursive: true });
-
-  // Phase 1: Setup
-  compileTemplates(siteVariables);
-  const contentRenderer = new ContentRenderer(siteVariables);
-  await contentRenderer.initHighlighter();
-
-  // Phase 2: Bundle + assets (parallel)
-  const parallelTasks: (Promise<unknown> | void)[] = [
-    bundle(siteVariables, { mode, distDir }),
-    copyFonts(distDir),
-    copyKatexAssets(distDir),
-  ];
-
-  if (isFeatureEnabled(siteVariables, 'favicon')) {
-    parallelTasks.push(generateFavicons(siteVariables, distDir));
-  }
-
-  const results = await Promise.all(parallelTasks);
-  const assetFiles = results[0] as string[]; // bundle output filenames
-
-  if (isFeatureEnabled(siteVariables, 'favicon')) {
-    generateWebAppManifest(siteVariables, distDir);
-  }
-
-  const publicRelPaths = copyPublicFiles(publicDir, distDir);
-  const processedExtensions = getProcessedExtensions(
-    Object.keys(getExtensionToShikiLanguage(siteVariables)),
-  );
-  copyContentAssets(contentDir, distDir, processedExtensions, publicRelPaths);
-
-  // Phase 3: Content rendering
-  const { errors, htmlAssetsByPath } = contentRenderer.processContent({
-    distDir,
-    assetFiles,
-  });
-
-  for (const err of errors) {
-    log.error`${err.message}`;
-  }
-  if (errors.length > 0) {
-    process.exit(1);
-  }
-
-  // Phase 4: Post-processing
-  if (isFeatureEnabled(siteVariables, 'search')) {
-    await runPagefind({ siteVariables, distPath: distDir, htmlAssetsByPath });
-  }
-
-  // Phase 5: Build manifest (production only)
-  if (!isDev) {
-    const manifestPath = path.join(distDir, 'tada.manifest.json');
-    await generateBuildManifest(distDir, manifestPath, prodVersion!);
-    log.info`Built dist-prod/v${prodVersion!}/`;
-  }
-
-  printFlair();
 }