@abreen/tada 1.17.0 → 1.18.0

package/build/watch/planner.ts

@@ -1,182 +1,126 @@
 import path from 'path';
-import { loadProjectConfig } from '../config-loader';
-import { getProjectConfigDir } from '../templates';
-import type { ChangeBatch } from './types';
-import type { TadaProjectScan, TadaSnapshot } from './snapshot';
-import { classifyWatchConfigPath } from './config-paths';
+import type { SourceEntry, TadaProjectScan } from '../source-model';
+import type { TadaSnapshot } from '../site-build';
 
 export interface TadaIncrementalWatchPlan {
   kind: 'incremental';
   scan: TadaProjectScan;
-  contentToRender: Set<string>;
-  publicToRender: Set<string>;
-  contentToRemove: Set<string>;
-  publicToRemove: Set<string>;
+  renderSources: Set<string>;
+  removeSources: Set<string>;
 }
 
 type TadaWatchPlan = { kind: 'full' } | TadaIncrementalWatchPlan;
 
-export function diffAuthorKeys(previous: unknown, next: unknown): Set<string> {
-  const previousMap =
-    previous && typeof previous === 'object'
-      ? (previous as Record<string, unknown>)
-      : {};
-  const nextMap =
-    next && typeof next === 'object' ? (next as Record<string, unknown>) : {};
-  const keys = new Set([...Object.keys(previousMap), ...Object.keys(nextMap)]);
-  const changed = new Set<string>();
-
-  for (const key of keys) {
-    if (JSON.stringify(previousMap[key]) !== JSON.stringify(nextMap[key])) {
-      changed.add(key);
-    }
-  }
-
-  return changed;
+function sameItems(a: ReadonlySet<string>, b: ReadonlySet<string>): boolean {
+  return a.size === b.size && [...a].every(item => b.has(item));
 }
 
-function addDependents(
-  destination: Set<string>,
-  reverseMap: Map<string, Set<string>>,
-  key: string,
-): void {
-  const dependents = reverseMap.get(key);
-  if (!dependents) {
-    return;
-  }
-  for (const dependent of dependents) {
-    destination.add(dependent);
-  }
+function sameSourceEntry(a: SourceEntry, b: SourceEntry | undefined): boolean {
+  return (
+    b !== undefined &&
+    a.kind === b.kind &&
+    a.renderKind === b.renderKind &&
+    sameItems(a.outputs, b.outputs) &&
+    sameItems(a.targets, b.targets)
+  );
 }
 
-function sourceExists(filePath: string, scan: TadaProjectScan): boolean {
-  return scan.contentFiles.has(filePath) || scan.publicFiles.has(filePath);
+export function diffAuthorKeys(previous: unknown, next: unknown): Set<string> {
+  const asMap = (value: unknown): Record<string, unknown> =>
+    value && typeof value === 'object'
+      ? (value as Record<string, unknown>)
+      : {};
+  const before = asMap(previous);
+  const after = asMap(next);
+  return new Set(
+    [...Object.keys(before), ...Object.keys(after)].filter(
+      key => JSON.stringify(before[key]) !== JSON.stringify(after[key]),
+    ),
+  );
 }
 
 export function createTadaWatchPlan({
   snapshot,
-  batch,
+  paths,
   scan,
+  full = false,
+  changedAuthors = new Set<string>(),
 }: {
   snapshot: TadaSnapshot;
-  batch: ChangeBatch;
+  paths: ReadonlySet<string>;
   scan: TadaProjectScan;
+  full?: boolean;
+  changedAuthors?: ReadonlySet<string>;
 }): TadaWatchPlan {
-  const contentToRender = new Set<string>();
-  const publicToRender = new Set<string>();
-  const contentToRemove = new Set<string>();
-  const publicToRemove = new Set<string>();
-  const projectConfigDir = getProjectConfigDir();
-
-  for (const change of batch.changes) {
-    const configKind = classifyWatchConfigPath(change.path);
-    if (configKind === 'site' || configKind === 'nav') {
-      return { kind: 'full' };
-    }
+  if (full) {
+    return { kind: 'full' };
   }
-
-  for (const change of batch.changes) {
-    const resolvedPath = path.resolve(change.path);
-    if (classifyWatchConfigPath(resolvedPath) === 'authors') {
-      const nextAuthorsData = loadProjectConfig(
-        projectConfigDir,
-        'authors',
-        snapshot.siteVariables,
-      )?.value;
-      if (snapshot.authorsData === undefined || nextAuthorsData === undefined) {
-        return { kind: 'full' };
-      }
-      const changedAuthorKeys = diffAuthorKeys(
-        snapshot.authorsData,
-        nextAuthorsData,
-      );
-      for (const key of changedAuthorKeys) {
-        addDependents(contentToRender, snapshot.reverseAuthorDeps, key);
-      }
-      continue;
-    }
-
-    if (scan.contentFiles.has(resolvedPath)) {
-      contentToRender.add(resolvedPath);
-    } else if (snapshot.contentRecords.has(resolvedPath)) {
-      contentToRemove.add(resolvedPath);
+  const renderSources = new Set<string>();
+  const removeSources = new Set(
+    [...snapshot.records.keys()].filter(source => !scan.sources.has(source)),
+  );
+  const include = (
+    index: ReadonlyMap<string, ReadonlySet<string>>,
+    key: string,
+  ) => {
+    for (const source of index.get(key) ?? []) {
+      renderSources.add(source);
     }
-
-    if (scan.publicFiles.has(resolvedPath)) {
-      publicToRender.add(resolvedPath);
-    } else if (snapshot.publicRecords.has(resolvedPath)) {
-      publicToRemove.add(resolvedPath);
+  };
+  const changedSources = new Set([...paths, ...removeSources]);
+  for (const source of snapshot.scan.sources.keys()) {
+    if (!scan.sources.has(source)) {
+      changedSources.add(source);
     }
-
-    addDependents(contentToRender, snapshot.reversePartialDeps, resolvedPath);
-    addDependents(contentToRender, snapshot.reverseTraceDeps, resolvedPath);
   }
-
-  const changedTargets = new Set<string>();
-  for (const target of snapshot.scan.validTargets) {
-    if (!scan.validTargets.has(target)) {
-      changedTargets.add(target);
+  // A directory event may arrive without events for the files inside it.
+  const changedDirPrefixes = [...paths].map(changed => changed + path.sep);
+  for (const [source, entry] of scan.sources) {
+    const inChangedDirectory = changedDirPrefixes.some(prefix =>
+      source.startsWith(prefix),
+    );
+    if (
+      inChangedDirectory ||
+      !sameSourceEntry(entry, snapshot.scan.sources.get(source))
+    ) {
+      changedSources.add(source);
     }
   }
-  for (const target of scan.validTargets) {
-    if (!snapshot.scan.validTargets.has(target)) {
-      changedTargets.add(target);
+  for (const source of changedSources) {
+    if (scan.sources.has(source)) {
+      renderSources.add(source);
     }
+    include(snapshot.fileDependents, source);
   }
-  for (const target of changedTargets) {
-    addDependents(contentToRender, snapshot.reverseInternalTargetDeps, target);
+  for (const key of changedAuthors) {
+    include(snapshot.authorDependents, key);
   }
-
-  for (const [outputPath, owner] of snapshot.outputOwners) {
-    const nextContentOwner = scan.contentOwners.get(outputPath);
-    const nextPublicOwner = scan.publicOwners.get(outputPath);
-    const nextKind = nextPublicOwner
-      ? 'public'
-      : nextContentOwner
-        ? 'content'
-        : null;
-    const nextSourcePath = nextPublicOwner || nextContentOwner;
-
-    if (!nextKind || !nextSourcePath) {
-      continue;
-    }
-    if (owner.kind !== nextKind || owner.sourcePath !== nextSourcePath) {
-      if (nextKind === 'content') {
-        contentToRender.add(nextSourcePath);
-      } else {
-        publicToRender.add(nextSourcePath);
-      }
+  for (const target of new Set([
+    ...snapshot.scan.validTargets,
+    ...scan.validTargets,
+    ...snapshot.scan.generatedPageTargets,
+    ...scan.generatedPageTargets,
+  ])) {
+    if (
+      snapshot.scan.validTargets.has(target) !==
+        scan.validTargets.has(target) ||
+      snapshot.scan.generatedPageTargets.has(target) !==
+        scan.generatedPageTargets.has(target)
+    ) {
+      include(snapshot.targetDependents, target);
     }
   }
-
-  for (const [outputPath, nextSourcePath] of scan.contentOwners) {
-    if (!snapshot.outputOwners.has(outputPath)) {
-      contentToRender.add(nextSourcePath);
-    }
-  }
-  for (const [outputPath, nextSourcePath] of scan.publicOwners) {
-    if (!snapshot.outputOwners.has(outputPath)) {
-      publicToRender.add(nextSourcePath);
-    }
-  }
-
-  for (const sourcePath of [...contentToRender]) {
-    if (!sourceExists(sourcePath, scan)) {
-      contentToRender.delete(sourcePath);
+  for (const [output, producers] of scan.outputProducers) {
+    for (const source of producers) {
+      if (snapshot.outputs.get(output)?.sourcePath !== source) {
+        renderSources.add(source);
+      }
     }
   }
-  for (const sourcePath of [...publicToRender]) {
-    if (!sourceExists(sourcePath, scan)) {
-      publicToRender.delete(sourcePath);
+  for (const source of renderSources) {
+    if (!scan.sources.has(source)) {
+      renderSources.delete(source);
     }
   }
-
-  return {
-    kind: 'incremental',
-    scan,
-    contentToRender,
-    publicToRender,
-    contentToRemove,
-    publicToRemove,
-  };
+  return { kind: 'incremental', scan, renderSources, removeSources };
 }

package/build/watch/runtime.ts

@@ -3,7 +3,10 @@ import { B } from '../colors';
 import { makeLogger, printFlair } from '../log';
 import { startServer } from '../serve';
 import { WatchPagefindRunner } from '../pagefind';
+import { isFeatureEnabled } from '../features';
+import { printDiagnostics } from '../build-validation';
 import type { WatchLifecycleEvent } from './types';
+import type { TadaBuildMeta } from '../build-types';
 import {
   WATCH_RELOAD_MESSAGE_REBUILDING,
   WATCH_RELOAD_MESSAGE_RELOAD,
@@ -14,28 +17,16 @@ import {
 const log = makeLogger(import.meta.url);
 const wslog = makeLogger('WebSocket');
 
-function describeChange(kind: 'add' | 'change' | 'unlink'): string {
-  if (kind === 'add') {
-    return 'added, rebuilding';
-  }
-  if (kind === 'unlink') {
-    return 'removed, rebuilding';
-  }
-  return 'changed, rebuilding';
-}
-
 export class TadaWatchRuntime {
   private httpPort: number | undefined;
   private distDir: string;
   private server: Bun.Server<undefined> | null;
   private pagefindRunner: WatchPagefindRunner | undefined;
-  private pagefindSiteVariablesKey: string | undefined;
 
   constructor({ httpPort, distDir }: { httpPort?: number; distDir: string }) {
     this.httpPort = httpPort;
     this.distDir = distDir;
     this.server = null;
-    this.pagefindSiteVariablesKey = undefined;
   }
 
   private broadcast(message: string): void {
@@ -64,48 +55,44 @@ export class TadaWatchRuntime {
     wslog.debug`WebSocket server listening at ws://localhost:${this.server.port}${WATCH_RELOAD_PATH}`;
   }
 
-  async onEvent(event: WatchLifecycleEvent): Promise<void> {
+  close(): void {
+    this.server?.stop(true);
+    this.server = null;
+  }
+
+  async onEvent(event: WatchLifecycleEvent<TadaBuildMeta>): Promise<void> {
     switch (event.kind) {
       case 'build-started':
-        if (!event.batch) {
+        if (!event.paths) {
           return;
         }
-        for (const change of event.batch.changes) {
-          log.event`${B`${path.basename(change.path)}`} ${describeChange(change.kind)}`;
+        for (const filePath of event.paths) {
+          log.event`${B`${path.basename(filePath)}`} changed, rebuilding`;
         }
         this.broadcast(WATCH_RELOAD_MESSAGE_REBUILDING);
         return;
       case 'build-succeeded': {
         printFlair();
         this.ensureServerStarted();
-        if (event.batch) {
+        if (event.paths) {
           this.broadcast(WATCH_RELOAD_MESSAGE_RELOAD);
         }
-        if (event.meta.siteVariables.features.search !== false) {
-          const siteVariablesKey = JSON.stringify(event.meta.siteVariables);
-          if (
-            !this.pagefindRunner ||
-            this.pagefindSiteVariablesKey !== siteVariablesKey
-          ) {
-            this.pagefindRunner = new WatchPagefindRunner();
-            this.pagefindSiteVariablesKey = siteVariablesKey;
-          }
-          this.pagefindRunner.update(
+        if (isFeatureEnabled(event.meta.siteVariables, 'search')) {
+          // One indexer for the whole session runs one index at a time, so
+          // two runs never write pagefind/ concurrently.
+          const runner = (this.pagefindRunner ??= new WatchPagefindRunner());
+          runner.update(
             this.distDir,
             event.meta.htmlAssetsByPath,
             event.meta.htmlAnalysisByPath,
+            event.meta.pdfSourceByOutputPath,
           );
-          setImmediate(() => this.pagefindRunner!.run());
-        } else {
-          this.pagefindRunner = undefined;
-          this.pagefindSiteVariablesKey = undefined;
+          setImmediate(() => runner.run());
         }
         return;
       }
       case 'build-failed':
-        for (const diagnostic of event.diagnostics) {
-          log.error`${diagnostic.message}`;
-        }
+        printDiagnostics(event.diagnostics);
         return;
       case 'watching':
         log.info`Watching for changes...`;

package/build/watch/types.d.ts

@@ -1,17 +1,6 @@
 import type { ChokidarOptions } from 'chokidar';
-import type { TadaBuildMeta } from './compiler-types';
-import type { TadaSnapshot } from './snapshot';
-
-export type WatchEventKind = 'add' | 'change' | 'unlink';
-
-export interface FileChange {
-  path: string;
-  kind: WatchEventKind;
-}
-
-export interface ChangeBatch {
-  changes: FileChange[];
-}
+import type { BuildDiagnostic } from '../build-types';
+import type { TadaSnapshot } from '../site-build';
 
 export interface WatchTarget {
   path: string;
@@ -19,66 +8,45 @@ export interface WatchTarget {
   filter?: (filePath: string) => boolean;
 }
 
-export interface WatchDiagnostic {
-  message: string;
-}
+export type WatchBuildResult<Meta> =
+  | { ok: true; meta: Meta }
+  | { ok: false; diagnostics: BuildDiagnostic[] };
 
-export interface WriteFileMutation {
-  kind: 'write';
-  path: string;
-  content: string | Buffer;
-}
+export type WatchLifecycleEvent<Meta> =
+  | { kind: 'watching' }
+  | { kind: 'build-started'; paths?: ReadonlySet<string> }
+  | { kind: 'build-succeeded'; paths?: ReadonlySet<string>; meta: Meta }
+  | {
+      kind: 'build-failed';
+      paths?: ReadonlySet<string>;
+      diagnostics: BuildDiagnostic[];
+    };
 
-export interface DeleteFileMutation {
-  kind: 'delete';
-  path: string;
+export interface WatchClock {
+  setTimeout: typeof setTimeout;
+  clearTimeout: typeof clearTimeout;
 }
 
-export type FileMutation = WriteFileMutation | DeleteFileMutation;
-
-export interface ReplaceRootCommitPlan {
-  kind: 'replace-root';
-  stagedPath: string;
-  targetPath: string;
+export interface WatchEngineOptions<Meta> {
+  targets: WatchTarget[];
+  build: (paths?: ReadonlySet<string>) => Promise<WatchBuildResult<Meta>>;
+  debounceMs?: number;
+  onEvent?: (event: WatchLifecycleEvent<Meta>) => void | Promise<void>;
 }
 
-export interface ApplyMutationsCommitPlan {
-  kind: 'apply-mutations';
-  rootDir: string;
-  mutations: FileMutation[];
+export interface WatchHandle {
+  done: Promise<void>;
+  close(): Promise<void>;
 }
 
-export type CommitPlan = ReplaceRootCommitPlan | ApplyMutationsCommitPlan;
-
-export type CompilerBuildResult =
+/** The result of compiling one watch build, before it is written */
+export type CompileOutcome =
   | {
       ok: true;
       snapshot: TadaSnapshot;
-      commit: CommitPlan;
-      meta: TadaBuildMeta;
+      /** Full builds are written against the files on disk */
+      full: boolean;
+      /** Sources whose outputs are rewritten even if they look unchanged */
+      forceSourcePaths?: ReadonlySet<string>;
     }
-  | { ok: false; diagnostics: WatchDiagnostic[] };
-
-export interface WatchCompiler {
-  getWatchTargets(): WatchTarget[];
-  build(
-    snapshot: TadaSnapshot | undefined,
-    batch?: ChangeBatch,
-  ): Promise<CompilerBuildResult>;
-}
-
-export type WatchLifecycleEvent =
-  | { kind: 'watching' }
-  | { kind: 'build-started'; batch?: ChangeBatch }
-  | { kind: 'build-succeeded'; batch?: ChangeBatch; meta: TadaBuildMeta }
-  | {
-      kind: 'build-failed';
-      batch?: ChangeBatch;
-      diagnostics: WatchDiagnostic[];
-    };
-
-export interface WatchEngineOptions {
-  compiler: WatchCompiler;
-  debounceMs?: number;
-  onEvent?: (event: WatchLifecycleEvent) => void | Promise<void>;
-}
+  | { ok: false; diagnostics: BuildDiagnostic[] };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abreen/tada",
-  "version": "1.17.0",
+  "version": "1.18.0",
   "type": "module",
   "description": "A static site generator",
   "license": "MIT",
@@ -65,10 +65,10 @@
     "chokidar": "^4.0.3",
     "culori": "^4.0.2",
     "d3-flextree": "^2.1.2",
+    "entities": "^4.5.0",
     "fontkit": "^2.0.4",
     "front-matter": "^4.0.2",
     "java-parser": "^3.0.1",
-    "jsdom": "^26.1.0",
     "katex": "^0.16.45",
     "lodash": "^4.18.1",
     "markdown-it": "^14.1.1",
@@ -81,8 +81,7 @@
     "quote-quote": "^1.2.0",
     "sass": "^1.99.0",
     "sharp": "^0.35.3",
-    "shiki": "^4.0.2",
-    "string-strip-html": "^8.5.0"
+    "shiki": "^4.0.2"
   },
   "lint-staged": {
     "*.{ts,js}": "prettier --write",
@@ -100,7 +99,6 @@
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@playwright/test": "^1.59.1",
-    "@saintedlama/lcov-parse": "^1.0.1",
     "@types/bun": "^1.3.12",
     "@types/culori": "^4.0.1",
     "@types/d3-flextree": "^2.1.4",
@@ -118,6 +116,7 @@
     "istanbul-lib-instrument": "^6.0.3",
     "istanbul-lib-report": "^3.0.1",
     "istanbul-reports": "^3.2.0",
+    "jsdom": "^26.1.0",
     "knip": "^6.11.0",
     "lint-staged": "^16.4.0",
     "postcss-scss": "^4.0.9",

package/schema/site.schema.json

@@ -46,6 +46,8 @@
       "maximum": 100,
       "default": 100
     },
+    "logo": { "type": "string" },
+    "favicon": { "type": "string" },
     "faviconColor": { "type": "string" },
     "faviconSymbol": { "type": "string", "pattern": "^[A-Z0-9\\- ]{1,5}$" },
     "faviconFontWeight": {
@@ -83,7 +85,14 @@
   "$defs": {
     "serifFontOverride": {
       "type": "object",
-      "required": ["regular"],
+      "anyOf": [
+        { "required": ["regular"] },
+        {
+          "required": ["tuning"],
+          "properties": { "tuning": {} },
+          "additionalProperties": false
+        }
+      ],
       "properties": {
         "regular": { "$ref": "#/$defs/publicWoff2Path" },
         "italic": { "$ref": "#/$defs/publicWoff2Path" },
@@ -110,7 +119,14 @@
     },
     "serifMonoFontOverride": {
       "type": "object",
-      "required": ["regular"],
+      "anyOf": [
+        { "required": ["regular"] },
+        {
+          "required": ["tuning"],
+          "properties": { "tuning": {} },
+          "additionalProperties": false
+        }
+      ],
       "properties": {
         "regular": { "$ref": "#/$defs/publicWoff2Path" },
         "italic": { "$ref": "#/$defs/publicWoff2Path" },