@abreen/tada 1.13.4 → 1.13.9

package/build/watch-reachability-state.ts

@@ -1,305 +0,0 @@
-import { collectOutgoingHtmlAssetPaths } from './reachability';
-import type { HtmlOutputAnalysis } from './types';
-
-type ReadAnalysisForAsset = (assetPath: string) => HtmlOutputAnalysis;
-
-function cloneSet(values: Iterable<string> | undefined): Set<string> {
-  return new Set(values || []);
-}
-
-interface IncrementalOptions {
-  changedAssetPaths?: Iterable<string>;
-  removedAssetPaths?: Iterable<string>;
-  readAnalysisForAsset: ReadAnalysisForAsset;
-}
-
-class WatchReachabilityState {
-  private rootPath: string;
-  private knownAssets: Set<string>;
-  private outgoingBySource: Map<string, Set<string>>;
-  private incomingByTarget: Map<string, Set<string>>;
-  private reachable: Set<string>;
-  private initialized: boolean;
-
-  constructor({ rootPath = 'index.html' }: { rootPath?: string } = {}) {
-    this.rootPath = rootPath;
-    this.knownAssets = new Set();
-    this.outgoingBySource = new Map();
-    this.incomingByTarget = new Map();
-    this.reachable = new Set();
-    this.initialized = false;
-  }
-
-  reset(): void {
-    this.knownAssets = new Set();
-    this.outgoingBySource = new Map();
-    this.incomingByTarget = new Map();
-    this.reachable = new Set();
-    this.initialized = false;
-  }
-
-  setKnownAssets(assetPaths: Iterable<string>): void {
-    this.knownAssets = cloneSet(assetPaths);
-    this.reachable = new Set(
-      [...this.reachable].filter(assetPath => this.knownAssets.has(assetPath)),
-    );
-
-    const nextOutgoingBySource = new Map<string, Set<string>>();
-    for (const [sourcePath, targets] of this.outgoingBySource) {
-      if (!this.knownAssets.has(sourcePath)) {
-        continue;
-      }
-
-      nextOutgoingBySource.set(
-        sourcePath,
-        new Set(
-          [...targets].filter(targetPath => this.knownAssets.has(targetPath)),
-        ),
-      );
-    }
-
-    this.outgoingBySource = nextOutgoingBySource;
-    this.rebuildIncomingByTarget();
-  }
-
-  rebuild(readAnalysisForAsset: ReadAnalysisForAsset): void {
-    if (!this.knownAssets.has(this.rootPath)) {
-      throw new Error(`Pagefind reachability root not found: ${this.rootPath}`);
-    }
-
-    this.outgoingBySource = new Map();
-    this.incomingByTarget = new Map();
-    this.reachable = new Set();
-
-    const knownAssetPaths = [...this.knownAssets].sort();
-    for (const sourcePath of knownAssetPaths) {
-      const outgoingPaths = this.readOutgoingPaths(
-        sourcePath,
-        readAnalysisForAsset,
-      );
-      this.outgoingBySource.set(sourcePath, outgoingPaths);
-      this.addIncomingEdges(sourcePath, outgoingPaths);
-    }
-
-    this.reachable = this.collectClosure(new Set([this.rootPath]));
-    this.initialized = true;
-  }
-
-  applyIncremental({
-    changedAssetPaths,
-    removedAssetPaths,
-    readAnalysisForAsset,
-  }: IncrementalOptions): void {
-    if (!this.initialized) {
-      this.rebuild(readAnalysisForAsset);
-      return;
-    }
-
-    const normalizedChanged = new Set<string>();
-    for (const assetPath of changedAssetPaths || []) {
-      if (this.knownAssets.has(assetPath)) {
-        normalizedChanged.add(assetPath);
-      }
-    }
-
-    const normalizedRemoved = new Set<string>();
-    for (const assetPath of removedAssetPaths || []) {
-      if (
-        !this.knownAssets.has(assetPath) &&
-        !normalizedChanged.has(assetPath)
-      ) {
-        normalizedRemoved.add(assetPath);
-      }
-    }
-
-    const previouslyReachableRoots = new Set<string>();
-    for (const assetPath of normalizedChanged) {
-      if (this.reachable.has(assetPath)) {
-        previouslyReachableRoots.add(assetPath);
-      }
-    }
-    for (const assetPath of normalizedRemoved) {
-      if (this.reachable.has(assetPath)) {
-        previouslyReachableRoots.add(assetPath);
-      }
-    }
-
-    const oldAffectedClosure = this.collectClosure(previouslyReachableRoots);
-
-    for (const assetPath of normalizedRemoved) {
-      this.removeAsset(assetPath);
-    }
-
-    const changedAssetList = [...normalizedChanged].sort();
-    for (const assetPath of changedAssetList) {
-      const outgoingPaths = this.readOutgoingPaths(
-        assetPath,
-        readAnalysisForAsset,
-      );
-      this.replaceOutgoing(assetPath, outgoingPaths);
-    }
-
-    const stillKnownRoots = new Set(
-      [...previouslyReachableRoots].filter(assetPath =>
-        this.knownAssets.has(assetPath),
-      ),
-    );
-    const newAffectedClosure = this.collectClosure(stillKnownRoots);
-    const affected = new Set([...oldAffectedClosure, ...newAffectedClosure]);
-
-    if (affected.size === 0) {
-      this.initialized = true;
-      return;
-    }
-
-    for (const assetPath of affected) {
-      this.reachable.delete(assetPath);
-    }
-
-    const seedPaths = new Set<string>();
-    for (const assetPath of stillKnownRoots) {
-      if (affected.has(assetPath)) {
-        seedPaths.add(assetPath);
-      }
-    }
-
-    if (this.knownAssets.has(this.rootPath) && affected.has(this.rootPath)) {
-      seedPaths.add(this.rootPath);
-    }
-
-    for (const assetPath of affected) {
-      const incomingPaths = this.incomingByTarget.get(assetPath);
-      if (!incomingPaths) {
-        continue;
-      }
-
-      for (const sourcePath of incomingPaths) {
-        if (this.reachable.has(sourcePath) && !affected.has(sourcePath)) {
-          seedPaths.add(assetPath);
-          break;
-        }
-      }
-    }
-
-    const restoredReachable = this.collectClosure(seedPaths, affected);
-    for (const assetPath of restoredReachable) {
-      this.reachable.add(assetPath);
-    }
-
-    this.initialized = true;
-  }
-
-  getReachablePaths(): string[] {
-    return [...this.reachable].sort();
-  }
-
-  private readOutgoingPaths(
-    sourcePath: string,
-    readAnalysisForAsset: ReadAnalysisForAsset,
-  ): Set<string> {
-    if (!this.knownAssets.has(sourcePath)) {
-      return new Set();
-    }
-
-    const analysis = readAnalysisForAsset(sourcePath);
-    return new Set(collectOutgoingHtmlAssetPaths(analysis, this.knownAssets));
-  }
-
-  private addIncomingEdges(
-    sourcePath: string,
-    outgoingPaths: Set<string>,
-  ): void {
-    for (const targetPath of outgoingPaths) {
-      let incomingPaths = this.incomingByTarget.get(targetPath);
-      if (!incomingPaths) {
-        incomingPaths = new Set();
-        this.incomingByTarget.set(targetPath, incomingPaths);
-      }
-      incomingPaths.add(sourcePath);
-    }
-  }
-
-  private rebuildIncomingByTarget(): void {
-    this.incomingByTarget = new Map();
-    for (const [sourcePath, outgoingPaths] of this.outgoingBySource) {
-      this.addIncomingEdges(sourcePath, outgoingPaths);
-    }
-  }
-
-  private removeOutgoingEdges(sourcePath: string): void {
-    const outgoingPaths = this.outgoingBySource.get(sourcePath);
-    if (!outgoingPaths) {
-      return;
-    }
-
-    for (const targetPath of outgoingPaths) {
-      const incomingPaths = this.incomingByTarget.get(targetPath);
-      if (!incomingPaths) {
-        continue;
-      }
-
-      incomingPaths.delete(sourcePath);
-      if (incomingPaths.size === 0) {
-        this.incomingByTarget.delete(targetPath);
-      }
-    }
-  }
-
-  private replaceOutgoing(
-    sourcePath: string,
-    outgoingPaths: Set<string>,
-  ): void {
-    this.removeOutgoingEdges(sourcePath);
-    if (!this.knownAssets.has(sourcePath)) {
-      this.outgoingBySource.delete(sourcePath);
-      return;
-    }
-
-    this.outgoingBySource.set(sourcePath, outgoingPaths);
-    this.addIncomingEdges(sourcePath, outgoingPaths);
-  }
-
-  private removeAsset(assetPath: string): void {
-    this.removeOutgoingEdges(assetPath);
-    this.outgoingBySource.delete(assetPath);
-    this.incomingByTarget.delete(assetPath);
-    this.reachable.delete(assetPath);
-  }
-
-  private collectClosure(
-    rootPaths: Set<string>,
-    allowedPaths: Set<string> | null = null,
-  ): Set<string> {
-    const pending = [...rootPaths];
-    const visited = new Set<string>();
-
-    while (pending.length > 0) {
-      const currentPath = pending.pop()!;
-      if (visited.has(currentPath)) {
-        continue;
-      }
-      if (allowedPaths && !allowedPaths.has(currentPath)) {
-        continue;
-      }
-
-      visited.add(currentPath);
-      const outgoingPaths = this.outgoingBySource.get(currentPath);
-      if (!outgoingPaths) {
-        continue;
-      }
-
-      for (const targetPath of outgoingPaths) {
-        if (allowedPaths && !allowedPaths.has(targetPath)) {
-          continue;
-        }
-        if (!visited.has(targetPath)) {
-          pending.push(targetPath);
-        }
-      }
-    }
-
-    return visited;
-  }
-}
-
-export default WatchReachabilityState;

package/watch/engine.ts

@@ -1,296 +0,0 @@
-import chokidar from 'chokidar';
-import { applyCommitPlan } from './fs-commit';
-import { emitWatchEvent } from './events';
-import type {
-  ChangeBatch,
-  CompilerBuildResult,
-  CompilerPlanResult,
-  WatchEngineOptions,
-  WatchEventKind,
-} from './types';
-
-function normalizeBatch(changes: Map<string, WatchEventKind>): ChangeBatch {
-  return {
-    changes: [...changes.entries()]
-      .sort(([a], [b]) => a.localeCompare(b))
-      .map(([path, kind]) => ({ path, kind })),
-  };
-}
-
-function mergeChangeKind(
-  previous: WatchEventKind | undefined,
-  next: WatchEventKind,
-): WatchEventKind {
-  if (!previous) {
-    return next;
-  }
-  if (previous === 'add' && next === 'unlink') {
-    return 'change';
-  }
-  if (previous === 'unlink' && next === 'add') {
-    return 'change';
-  }
-  if (previous === 'add' || next === 'add') {
-    return 'add';
-  }
-  if (previous === 'unlink' || next === 'unlink') {
-    return 'unlink';
-  }
-  return 'change';
-}
-
-function toDiagnostics(error: unknown): { message: string }[] {
-  if (error instanceof Error) {
-    return [{ message: error.message }];
-  }
-  return [{ message: String(error) }];
-}
-
-function isNoopCommit(commit: {
-  kind: string;
-  mutations?: unknown[];
-}): boolean {
-  return (
-    commit.kind === 'apply-mutations' && (commit.mutations?.length ?? 0) === 0
-  );
-}
-
-type BuildAttemptOutcome<Snapshot, Meta> =
-  | { kind: 'skipped'; batch: ChangeBatch; initial: boolean }
-  | {
-      kind: 'succeeded';
-      batch?: ChangeBatch;
-      initial: boolean;
-      result: Extract<CompilerBuildResult<Snapshot, Meta>, { ok: true }>;
-    }
-  | {
-      kind: 'failed';
-      batch?: ChangeBatch;
-      initial: boolean;
-      diagnostics: { message: string }[];
-      meta?: Meta;
-    };
-
-export async function runWatchEngine<Snapshot, Plan, Meta>(
-  options: WatchEngineOptions<Snapshot, Plan, Meta>,
-): Promise<void> {
-  const debounceMs = options.debounceMs ?? 300;
-  let snapshot: Snapshot | undefined;
-  let pending = new Map<string, WatchEventKind>();
-  let blocked = new Map<string, WatchEventKind>();
-  let timer: ReturnType<typeof setTimeout> | null = null;
-  let running = false;
-
-  async function waitForQuietPeriod(): Promise<void> {
-    await new Promise(resolve => setTimeout(resolve, debounceMs));
-  }
-
-  async function runBuild(
-    batch?: ChangeBatch,
-    initial: boolean = false,
-  ): Promise<BuildAttemptOutcome<Snapshot, Meta>> {
-    await emitWatchEvent(options, { kind: 'build-started', batch, initial });
-    try {
-      let result: CompilerBuildResult<Snapshot, Meta> | null = null;
-      if (initial) {
-        result = await options.compiler.buildInitial();
-      } else if (batch) {
-        const nextPlan: CompilerPlanResult<Plan> = await options.compiler.plan(
-          snapshot,
-          batch,
-        );
-        if (nextPlan.kind === 'skip') {
-          return { kind: 'skipped', batch, initial };
-        }
-        result = await options.compiler.run(nextPlan.plan, snapshot);
-      }
-      if (!result) {
-        return { kind: 'skipped', batch: batch!, initial };
-      }
-
-      if (result.ok) {
-        return { kind: 'succeeded', batch, initial, result };
-      }
-
-      return {
-        kind: 'failed',
-        batch,
-        initial,
-        diagnostics: result.diagnostics,
-        meta: result.meta,
-      };
-    } catch (error) {
-      return {
-        kind: 'failed',
-        batch,
-        initial,
-        diagnostics: toDiagnostics(error),
-      };
-    }
-  }
-
-  async function flush(): Promise<void> {
-    if (running) {
-      return;
-    }
-    running = true;
-    try {
-      let finalSuccess:
-        | {
-            batch?: ChangeBatch;
-            initial: boolean;
-            result: Extract<CompilerBuildResult<Snapshot, Meta>, { ok: true }>;
-            changed: boolean;
-          }
-        | undefined;
-
-      while (pending.size > 0) {
-        const batch = normalizeBatch(pending);
-        pending = new Map();
-        const outcome = await runBuild(batch, false);
-
-        if (outcome.kind === 'skipped') {
-          if (pending.size === 0 && !finalSuccess) {
-            await emitWatchEvent(options, {
-              kind: 'build-skipped',
-              batch: outcome.batch,
-            });
-          }
-          continue;
-        }
-
-        if (outcome.kind === 'failed') {
-          await emitWatchEvent(options, {
-            kind: 'build-failed',
-            initial: outcome.initial,
-            batch: outcome.batch,
-            diagnostics: outcome.diagnostics,
-            meta: outcome.meta,
-          });
-          if (outcome.batch) {
-            for (const change of outcome.batch.changes) {
-              blocked.set(
-                change.path,
-                mergeChangeKind(blocked.get(change.path), change.kind),
-              );
-            }
-          }
-          return;
-        }
-
-        const changed = !isNoopCommit(outcome.result.commit);
-        if (changed) {
-          applyCommitPlan(outcome.result.commit);
-        }
-        snapshot = outcome.result.snapshot;
-        finalSuccess = {
-          batch: outcome.batch,
-          initial: outcome.initial,
-          result: outcome.result,
-          changed: (finalSuccess?.changed ?? false) || changed,
-        };
-
-        if (pending.size === 0) {
-          await waitForQuietPeriod();
-        }
-      }
-
-      if (finalSuccess) {
-        await emitWatchEvent(options, {
-          kind: 'build-succeeded',
-          initial: finalSuccess.initial,
-          batch: finalSuccess.batch,
-          changed: finalSuccess.changed,
-          snapshot: finalSuccess.result.snapshot,
-          meta: finalSuccess.result.meta,
-          diagnostics: finalSuccess.result.diagnostics || [],
-        });
-      }
-    } finally {
-      running = false;
-      if (pending.size > 0) {
-        schedule();
-      }
-    }
-  }
-
-  function schedule(): void {
-    if (timer) {
-      clearTimeout(timer);
-    }
-    timer = setTimeout(() => {
-      timer = null;
-      void flush();
-    }, debounceMs);
-  }
-
-  function onFileChange(filePath: string, kind: WatchEventKind): void {
-    if (blocked.size > 0) {
-      for (const [blockedPath, blockedKind] of blocked) {
-        pending.set(
-          blockedPath,
-          mergeChangeKind(pending.get(blockedPath), blockedKind),
-        );
-      }
-      blocked = new Map();
-    }
-    pending.set(filePath, mergeChangeKind(pending.get(filePath), kind));
-    schedule();
-  }
-
-  const initialOutcome = await runBuild(undefined, true);
-  if (initialOutcome.kind === 'failed') {
-    await emitWatchEvent(options, {
-      kind: 'build-failed',
-      initial: true,
-      diagnostics: initialOutcome.diagnostics,
-      meta: initialOutcome.meta,
-    });
-  } else if (initialOutcome.kind === 'succeeded') {
-    applyCommitPlan(initialOutcome.result.commit);
-    snapshot = initialOutcome.result.snapshot;
-    await emitWatchEvent(options, {
-      kind: 'build-succeeded',
-      initial: true,
-      changed: !isNoopCommit(initialOutcome.result.commit),
-      snapshot: initialOutcome.result.snapshot,
-      meta: initialOutcome.result.meta,
-      diagnostics: initialOutcome.result.diagnostics || [],
-    });
-  }
-
-  const watcherEntries = options.compiler
-    .getWatchTargets()
-    .map(target => ({
-      target,
-      watcher: chokidar.watch(target.path, {
-        ignoreInitial: true,
-        atomic: true,
-        awaitWriteFinish: { stabilityThreshold: 100 },
-        depth: target.chokidar?.depth,
-      }),
-    }));
-
-  let readyCount = 0;
-  const readyGoal = watcherEntries.length;
-  const onReady = async () => {
-    readyCount += 1;
-    if (readyCount === readyGoal) {
-      await emitWatchEvent(options, { kind: 'watching' });
-    }
-  };
-
-  for (const { watcher, target } of watcherEntries) {
-    const emitIfIncluded = (filePath: string, kind: WatchEventKind) => {
-      if (!target.filter || target.filter(filePath)) {
-        onFileChange(filePath, kind);
-      }
-    };
-    watcher.on('add', filePath => emitIfIncluded(filePath, 'add'));
-    watcher.on('change', filePath => emitIfIncluded(filePath, 'change'));
-    watcher.on('unlink', filePath => emitIfIncluded(filePath, 'unlink'));
-    watcher.on('ready', () => void onReady());
-  }
-
-  return new Promise(() => {});
-}

package/watch/events.ts

@@ -1,10 +0,0 @@
-import type { WatchEngineOptions, WatchLifecycleEvent } from './types';
-
-export async function emitWatchEvent<Snapshot, Plan, Meta>(
-  options: WatchEngineOptions<Snapshot, Plan, Meta>,
-  event: WatchLifecycleEvent<Snapshot, Meta>,
-): Promise<void> {
-  if (options.onEvent) {
-    await options.onEvent(event);
-  }
-}

package/watch/types.d.ts

@@ -1,103 +0,0 @@
-export type WatchEventKind = 'add' | 'change' | 'unlink';
-
-export interface FileChange {
-  path: string;
-  kind: WatchEventKind;
-}
-
-export interface ChangeBatch {
-  changes: FileChange[];
-}
-
-export interface WatchTarget {
-  path: string;
-  chokidar?: { depth?: number };
-  filter?: (filePath: string) => boolean;
-}
-
-export interface WatchDiagnostic {
-  message: string;
-}
-
-export interface WriteFileMutation {
-  kind: 'write';
-  path: string;
-  content: string | Buffer;
-}
-
-export interface DeleteFileMutation {
-  kind: 'delete';
-  path: string;
-}
-
-export type FileMutation = WriteFileMutation | DeleteFileMutation;
-
-export interface ReplaceRootCommitPlan {
-  kind: 'replace-root';
-  stagedPath: string;
-  targetPath: string;
-}
-
-export interface ApplyMutationsCommitPlan {
-  kind: 'apply-mutations';
-  rootDir: string;
-  mutations: FileMutation[];
-}
-
-export type CommitPlan = ReplaceRootCommitPlan | ApplyMutationsCommitPlan;
-
-export type CompilerPlanResult<Plan> =
-  | { kind: 'skip' }
-  | { kind: 'build'; plan: Plan };
-
-export type CompilerBuildResult<Snapshot, Meta> =
-  | {
-      ok: true;
-      snapshot: Snapshot;
-      commit: CommitPlan;
-      diagnostics?: WatchDiagnostic[];
-      meta?: Meta;
-    }
-  | { ok: false; diagnostics: WatchDiagnostic[]; meta?: Meta };
-
-export interface WatchCompiler<Snapshot, Plan, Meta> {
-  getWatchTargets(): WatchTarget[];
-  buildInitial(): Promise<CompilerBuildResult<Snapshot, Meta>>;
-  plan(
-    snapshot: Snapshot | undefined,
-    batch: ChangeBatch,
-  ): Promise<CompilerPlanResult<Plan>>;
-  run(
-    plan: Plan,
-    snapshot: Snapshot | undefined,
-  ): Promise<CompilerBuildResult<Snapshot, Meta>>;
-}
-
-export type WatchLifecycleEvent<Snapshot, Meta> =
-  | { kind: 'watching' }
-  | { kind: 'build-started'; batch?: ChangeBatch; initial: boolean }
-  | {
-      kind: 'build-succeeded';
-      initial: boolean;
-      batch?: ChangeBatch;
-      changed: boolean;
-      snapshot: Snapshot;
-      meta?: Meta;
-      diagnostics: WatchDiagnostic[];
-    }
-  | {
-      kind: 'build-failed';
-      initial: boolean;
-      batch?: ChangeBatch;
-      diagnostics: WatchDiagnostic[];
-      meta?: Meta;
-    }
-  | { kind: 'build-skipped'; batch: ChangeBatch };
-
-export interface WatchEngineOptions<Snapshot, Plan, Meta> {
-  compiler: WatchCompiler<Snapshot, Plan, Meta>;
-  debounceMs?: number;
-  onEvent?: (
-    event: WatchLifecycleEvent<Snapshot, Meta>,
-  ) => void | Promise<void>;
-}