@abreen/tada 1.17.1 → 1.18.1

package/build/watch/build-full.ts

@@ -1,97 +0,0 @@
-import { compileTemplates, config } from '../templates';
-import { getDevSiteVariables } from '../site-variables';
-import { getDistDir } from '../util';
-import type { CompilerBuildResult } from './types';
-import { createSnapshot, type TadaSourceRecord } from './snapshot';
-import { scanProject } from '../source-model';
-import type { TraceCache, WatchTraceOptions } from './compiler-types';
-import {
-  bundleWatchAssets,
-  ensureHighlighter,
-  makeTempBuildDir,
-  populateStaticAssets,
-  removeDirIfExists,
-} from './assets';
-import { validateConfig, validateProjectConfigLinks } from './validation';
-import { buildFailedFromError, buildSucceeded } from './build-result';
-import {
-  buildFailedWithDiagnostics,
-  renderContentRecord,
-  renderPublicRecord,
-} from './build-helpers';
-
-export async function buildFull({
-  traceCache,
-  traceOptions,
-}: {
-  traceCache: TraceCache;
-  traceOptions: WatchTraceOptions;
-}): Promise<CompilerBuildResult> {
-  const distDir = getDistDir();
-  const outputDir = makeTempBuildDir(distDir);
-  try {
-    const siteVariables = getDevSiteVariables();
-    const scan = scanProject(siteVariables);
-    const configDiagnostics = validateConfig(scan, siteVariables);
-    if (configDiagnostics.length > 0) {
-      return buildFailedWithDiagnostics(outputDir, configDiagnostics);
-    }
-
-    compileTemplates(siteVariables);
-    await ensureHighlighter(siteVariables);
-
-    const assetFiles = await bundleWatchAssets(outputDir, siteVariables);
-    await populateStaticAssets(outputDir, siteVariables);
-
-    const contentRecords = new Map<string, TadaSourceRecord>();
-    for (const filePath of scan.contentFiles) {
-      const record = renderContentRecord({
-        filePath,
-        siteVariables,
-        scan,
-        assetFiles,
-        outputDir,
-        traceCache,
-        traceOptions,
-        cachedTraceSourceDir: distDir,
-      });
-      if (record) {
-        contentRecords.set(filePath, record);
-      }
-    }
-
-    const publicRecords = new Map<string, TadaSourceRecord>();
-    for (const filePath of scan.publicFiles) {
-      const record = renderPublicRecord({
-        filePath,
-        publicDir: scan.publicDir,
-        outputDir,
-      });
-      publicRecords.set(filePath, record);
-    }
-
-    const linkDiagnostics = validateProjectConfigLinks(scan.validTargets);
-    if (linkDiagnostics.length > 0) {
-      return buildFailedWithDiagnostics(outputDir, linkDiagnostics);
-    }
-
-    const nextSnapshot = createSnapshot({
-      siteVariables,
-      assetFiles,
-      navData: config('nav'),
-      authorsData: config('authors'),
-      scan,
-      contentRecords,
-      publicRecords,
-    });
-
-    return buildSucceeded(nextSnapshot, {
-      kind: 'replace-root',
-      stagedPath: outputDir,
-      targetPath: distDir,
-    });
-  } catch (error) {
-    removeDirIfExists(outputDir);
-    return buildFailedFromError(error);
-  }
-}

package/build/watch/build-helpers.ts

@@ -1,66 +0,0 @@
-import { createContentRecord, createPublicRecord } from '../source-records';
-import type { SiteVariables } from '../types';
-import type { TadaProjectScan, TadaSourceRecord } from './snapshot';
-import type { CompilerBuildResult, WatchDiagnostic } from './types';
-import type { TraceCache, WatchTraceOptions } from './compiler-types';
-import { removeDirIfExists, writeAssets } from './assets';
-
-export function buildFailedWithDiagnostics(
-  outputDir: string,
-  diagnostics: WatchDiagnostic[],
-): CompilerBuildResult {
-  removeDirIfExists(outputDir);
-  return { ok: false, diagnostics };
-}
-
-export function renderContentRecord({
-  filePath,
-  siteVariables,
-  scan,
-  assetFiles,
-  outputDir,
-  traceCache,
-  traceOptions,
-  cachedTraceSourceDir,
-}: {
-  filePath: string;
-  siteVariables: SiteVariables;
-  scan: TadaProjectScan;
-  assetFiles: string[];
-  outputDir: string;
-  traceCache: TraceCache;
-  traceOptions: WatchTraceOptions;
-  cachedTraceSourceDir: string;
-}): TadaSourceRecord | undefined {
-  const record = createContentRecord({
-    filePath,
-    siteVariables,
-    scan,
-    assetFiles,
-    outputDir,
-    traceCache,
-    traceToolAvailability: traceOptions.toolAvailability,
-    cachedTraceSourceDir,
-  });
-  if (record.outputs.size === 0) {
-    return undefined;
-  }
-  writeAssets(outputDir, record.outputs);
-  return record;
-}
-
-export function renderPublicRecord({
-  filePath,
-  publicDir,
-  outputDir,
-}: {
-  filePath: string;
-  publicDir: string;
-  outputDir?: string;
-}): TadaSourceRecord {
-  const record = createPublicRecord(filePath, publicDir);
-  if (outputDir) {
-    writeAssets(outputDir, record.outputs);
-  }
-  return record;
-}

package/build/watch/build-result.ts

@@ -1,19 +0,0 @@
-import type { CommitPlan, CompilerBuildResult } from './types';
-import { createBuildMeta, type TadaSnapshot } from './snapshot';
-import { diagnosticsFromMessages } from './validation';
-
-export function buildSucceeded(
-  snapshot: TadaSnapshot,
-  commit: CommitPlan,
-): CompilerBuildResult {
-  return { ok: true, snapshot, commit, meta: createBuildMeta(snapshot) };
-}
-
-export function buildFailedFromError(error: unknown): CompilerBuildResult {
-  return {
-    ok: false,
-    diagnostics: diagnosticsFromMessages([
-      error instanceof Error ? error.message : String(error),
-    ]),
-  };
-}

package/build/watch/fs-commit.ts

@@ -1,218 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { globals, type Globals } from '../globals';
-import type {
-  ApplyMutationsCommitPlan,
-  CommitPlan,
-  ReplaceRootCommitPlan,
-} from './types';
-
-type CommitPlanGlobals = Pick<Globals, 'now' | 'pid' | 'sleepSync'>;
-
-const TRANSIENT_RENAME_ERROR_CODES = new Set([
-  'EACCES',
-  'EBUSY',
-  'ENOTEMPTY',
-  'EPERM',
-]);
-const RENAME_RETRY_DELAY_MS = 25;
-const RENAME_RETRY_COUNT = 8;
-
-function removeDirIfExists(dir: string): void {
-  fs.rmSync(dir, { recursive: true, force: true });
-}
-
-function ensureParentDir(filePath: string): void {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-}
-
-function isTransientRenameError(
-  error: unknown,
-  sourcePath: string,
-): error is NodeJS.ErrnoException {
-  const code = (error as NodeJS.ErrnoException | undefined)?.code;
-  return (
-    typeof code === 'string' &&
-    TRANSIENT_RENAME_ERROR_CODES.has(code) &&
-    fs.existsSync(sourcePath)
-  );
-}
-
-function renameWithRetry(
-  sourcePath: string,
-  targetPath: string,
-  globals: CommitPlanGlobals,
-): void {
-  for (let attempt = 0; attempt <= RENAME_RETRY_COUNT; attempt++) {
-    try {
-      fs.renameSync(sourcePath, targetPath);
-      return;
-    } catch (error) {
-      if (
-        attempt === RENAME_RETRY_COUNT ||
-        !isTransientRenameError(error, sourcePath)
-      ) {
-        throw error;
-      }
-      globals.sleepSync(RENAME_RETRY_DELAY_MS);
-    }
-  }
-}
-
-function pruneEmptyDirs(rootDir: string, filePath: string): void {
-  let currentDir = path.dirname(filePath);
-  const root = path.resolve(rootDir);
-  while (currentDir !== root) {
-    try {
-      fs.rmdirSync(currentDir);
-    } catch (err) {
-      const code = (err as NodeJS.ErrnoException).code;
-      if (code === 'ENOTEMPTY' || code === 'ENOENT') {
-        break;
-      }
-      throw err;
-    }
-    currentDir = path.dirname(currentDir);
-  }
-}
-
-interface MutationJournalEntry {
-  targetPath: string;
-  backupPath?: string;
-}
-
-function applyMutations(
-  plan: ApplyMutationsCommitPlan,
-  globals: CommitPlanGlobals,
-): void {
-  const transactionRoot = fs.mkdtempSync(
-    path.join(plan.rootDir, '.watch-stage-'),
-  );
-  const journal: MutationJournalEntry[] = [];
-  const createdDirs: string[] = [];
-  try {
-    // Index staging paths so file/directory transitions cannot collide in staging.
-    for (const [index, mutation] of plan.mutations.entries()) {
-      if (mutation.kind === 'write') {
-        fs.writeFileSync(
-          path.join(transactionRoot, `write-${index}`),
-          mutation.content,
-        );
-      }
-    }
-
-    for (const [index, mutation] of plan.mutations.entries()) {
-      const targetPath = path.resolve(plan.rootDir, mutation.path);
-      const existing = fs.lstatSync(targetPath, { throwIfNoEntry: false });
-      if (existing?.isDirectory()) {
-        throw new Error(
-          `Cannot publish file mutation over directory: ${targetPath}`,
-        );
-      }
-      const backupPath = existing
-        ? path.join(transactionRoot, `backup-${index}`)
-        : undefined;
-      if (backupPath) {
-        renameWithRetry(targetPath, backupPath, globals);
-      }
-      journal.push({ targetPath, backupPath });
-      if (mutation.kind === 'write') {
-        // Track missing parents without relying on mkdir's returned path spelling.
-        let dir = path.dirname(targetPath);
-        while (!fs.existsSync(dir)) {
-          createdDirs.push(dir);
-          const parent = path.dirname(dir);
-          if (parent === dir) {
-            break;
-          }
-          dir = parent;
-        }
-        fs.mkdirSync(path.dirname(targetPath), { recursive: true });
-        renameWithRetry(
-          path.join(transactionRoot, `write-${index}`),
-          targetPath,
-          globals,
-        );
-      }
-    }
-    for (const mutation of plan.mutations) {
-      if (mutation.kind === 'delete') {
-        pruneEmptyDirs(plan.rootDir, path.resolve(plan.rootDir, mutation.path));
-      }
-    }
-  } catch (publicationError) {
-    const rollbackErrors: unknown[] = [];
-    const removeCreatedDirs = () => {
-      for (const dir of [...new Set(createdDirs)].sort(
-        (a, b) => b.length - a.length,
-      )) {
-        try {
-          fs.rmdirSync(dir);
-        } catch (error) {
-          const code = (error as NodeJS.ErrnoException).code;
-          if (code !== 'ENOENT' && code !== 'ENOTEMPTY' && code !== 'ENOTDIR') {
-            rollbackErrors.push(error);
-          }
-        }
-      }
-    };
-    for (const entry of journal.toReversed()) {
-      try {
-        removeCreatedDirs();
-        fs.rmSync(entry.targetPath, { force: true });
-        if (entry.backupPath) {
-          ensureParentDir(entry.targetPath);
-          renameWithRetry(entry.backupPath, entry.targetPath, globals);
-        }
-      } catch (error) {
-        rollbackErrors.push(error);
-      }
-    }
-    removeCreatedDirs();
-    if (rollbackErrors.length > 0) {
-      // Keep any unrestored originals available for manual recovery.
-      throw new AggregateError(
-        [publicationError, ...rollbackErrors],
-        `Failed to publish and restore output; recovery files remain in ${transactionRoot}`,
-        { cause: publicationError },
-      );
-    }
-    removeDirIfExists(transactionRoot);
-    throw publicationError;
-  }
-  removeDirIfExists(transactionRoot);
-}
-
-function replaceRoot(
-  plan: ReplaceRootCommitPlan,
-  globals: CommitPlanGlobals,
-): void {
-  const { targetPath, stagedPath } = plan;
-  const backupDir = `${targetPath}.bak-${globals.pid()}-${globals.now()}`;
-  const targetExists = fs.existsSync(targetPath);
-
-  try {
-    if (targetExists) {
-      renameWithRetry(targetPath, backupDir, globals);
-    }
-    renameWithRetry(stagedPath, targetPath, globals);
-    if (targetExists) {
-      removeDirIfExists(backupDir);
-    }
-  } catch (err) {
-    if (!fs.existsSync(targetPath) && fs.existsSync(backupDir)) {
-      renameWithRetry(backupDir, targetPath, globals);
-    }
-    throw err;
-  }
-}
-
-export function applyCommitPlan(plan: CommitPlan): void {
-  const runtimeGlobals: CommitPlanGlobals = globals;
-  if (plan.kind === 'replace-root') {
-    replaceRoot(plan, runtimeGlobals);
-    return;
-  }
-
-  applyMutations(plan, runtimeGlobals);
-}

package/build/watch/mutations.ts

@@ -1,73 +0,0 @@
-import type { FileMutation } from './types';
-import type { TadaOutputOwner, TadaSnapshot } from './snapshot';
-
-function outputsEqual(
-  left: string | Buffer | undefined,
-  right: string | Buffer | undefined,
-): boolean {
-  if (left === undefined || right === undefined) {
-    return left === right;
-  }
-  if (typeof left === 'string' && typeof right === 'string') {
-    return left === right;
-  }
-  const leftBuffer = typeof left === 'string' ? Buffer.from(left) : left;
-  const rightBuffer = typeof right === 'string' ? Buffer.from(right) : right;
-  return Buffer.compare(leftBuffer, rightBuffer) === 0;
-}
-
-function getOutputContent(
-  snapshot: TadaSnapshot,
-  owner: TadaOutputOwner | undefined,
-  outputPath: string,
-): string | Buffer | undefined {
-  if (!owner) {
-    return undefined;
-  }
-  const records =
-    owner.kind === 'content' ? snapshot.contentRecords : snapshot.publicRecords;
-  return records.get(owner.sourcePath)?.outputs.get(outputPath);
-}
-
-export function computeMutations(
-  previous: TadaSnapshot,
-  next: TadaSnapshot,
-  forceSourcePaths: Set<string> = new Set(),
-): FileMutation[] {
-  const mutations: FileMutation[] = [];
-  const allPaths = new Set([
-    ...previous.outputOwners.keys(),
-    ...next.outputOwners.keys(),
-  ]);
-
-  for (const outputPath of [...allPaths].sort()) {
-    const previousOwner = previous.outputOwners.get(outputPath);
-    const nextOwner = next.outputOwners.get(outputPath);
-
-    const previousContent = getOutputContent(
-      previous,
-      previousOwner,
-      outputPath,
-    );
-    const nextContent = getOutputContent(next, nextOwner, outputPath);
-
-    if (!nextOwner) {
-      mutations.push({ path: outputPath, kind: 'delete' });
-      continue;
-    }
-
-    if (
-      !previousOwner ||
-      !outputsEqual(previousContent, nextContent) ||
-      forceSourcePaths.has(nextOwner.sourcePath)
-    ) {
-      mutations.push({
-        path: outputPath,
-        kind: 'write',
-        content: nextContent!,
-      });
-    }
-  }
-
-  return mutations;
-}

package/build/watch/snapshot.ts

@@ -1,201 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import {
-  type TadaProjectScan,
-  assertNoOutputPathConflicts,
-} from '../source-model';
-import type { Asset, HtmlOutputAnalysis, SiteVariables } from '../types';
-import type { TadaBuildMeta } from './compiler-types';
-
-export interface TadaSourceRecord {
-  sourcePath: string;
-  kind: 'content' | 'public';
-  outputs: Map<string, string | Buffer>;
-  htmlAnalysisByOutputPath?: Map<string, HtmlOutputAnalysis>;
-  partialDeps: Set<string>;
-  traceDeps: Set<string>;
-  internalTargets: Set<string>;
-  generatedOutputPaths: Set<string>;
-  authorKey?: string;
-}
-
-export interface TadaOutputOwner {
-  kind: 'content' | 'public';
-  sourcePath: string;
-}
-
-export interface TadaSnapshot {
-  siteVariables: SiteVariables;
-  assetFiles: string[];
-  navData: unknown;
-  authorsData: unknown;
-  contentRecords: Map<string, TadaSourceRecord>;
-  publicRecords: Map<string, TadaSourceRecord>;
-  outputOwners: Map<string, TadaOutputOwner>;
-  reversePartialDeps: Map<string, Set<string>>;
-  reverseTraceDeps: Map<string, Set<string>>;
-  reverseInternalTargetDeps: Map<string, Set<string>>;
-  reverseAuthorDeps: Map<string, Set<string>>;
-  scan: TadaProjectScan;
-}
-
-function buildReverseMap(
-  records: Iterable<TadaSourceRecord>,
-  selector: (record: TadaSourceRecord) => Iterable<string>,
-): Map<string, Set<string>> {
-  const reverse = new Map<string, Set<string>>();
-
-  for (const record of records) {
-    for (const key of selector(record)) {
-      if (!reverse.has(key)) {
-        reverse.set(key, new Set());
-      }
-      reverse.get(key)!.add(record.sourcePath);
-    }
-  }
-
-  return reverse;
-}
-
-function collectOutputOwners(snapshot: {
-  contentRecords: Map<string, TadaSourceRecord>;
-  publicRecords: Map<string, TadaSourceRecord>;
-}): Map<string, TadaOutputOwner> {
-  const owners = new Map<string, TadaOutputOwner>();
-
-  for (const record of snapshot.contentRecords.values()) {
-    for (const outputPath of record.outputs.keys()) {
-      owners.set(outputPath, {
-        kind: 'content',
-        sourcePath: record.sourcePath,
-      });
-    }
-  }
-
-  for (const record of snapshot.publicRecords.values()) {
-    for (const outputPath of record.outputs.keys()) {
-      owners.set(outputPath, { kind: 'public', sourcePath: record.sourcePath });
-    }
-  }
-
-  return owners;
-}
-
-export function createSnapshot({
-  siteVariables,
-  assetFiles,
-  navData,
-  authorsData,
-  scan,
-  contentRecords,
-  publicRecords,
-}: {
-  siteVariables: SiteVariables;
-  assetFiles: string[];
-  navData: unknown;
-  authorsData: unknown;
-  scan: TadaProjectScan;
-  contentRecords: Map<string, TadaSourceRecord>;
-  publicRecords: Map<string, TadaSourceRecord>;
-}): TadaSnapshot {
-  const allRecords = [...contentRecords.values()];
-
-  return {
-    siteVariables,
-    assetFiles,
-    navData,
-    authorsData,
-    contentRecords,
-    publicRecords,
-    outputOwners: collectOutputOwners({ contentRecords, publicRecords }),
-    reversePartialDeps: buildReverseMap(
-      allRecords,
-      record => record.partialDeps,
-    ),
-    reverseTraceDeps: buildReverseMap(allRecords, record => record.traceDeps),
-    reverseInternalTargetDeps: buildReverseMap(
-      allRecords,
-      record => record.internalTargets,
-    ),
-    reverseAuthorDeps: buildReverseMap(allRecords, record =>
-      record.authorKey ? [record.authorKey] : [],
-    ),
-    scan,
-  };
-}
-
-export function collectSourceOutputs(
-  assets: Asset[],
-  generatedOutputPaths: Set<string>,
-  stageDir: string,
-): Map<string, string | Buffer> {
-  const outputs = new Map<string, string | Buffer>();
-  for (const asset of assets) {
-    outputs.set(asset.assetPath, asset.content);
-  }
-  for (const outputPath of generatedOutputPaths) {
-    outputs.set(outputPath, fs.readFileSync(path.join(stageDir, outputPath)));
-  }
-  return outputs;
-}
-
-function cloneHtmlOutputAnalysis(
-  analysis: HtmlOutputAnalysis,
-): HtmlOutputAnalysis {
-  return { outgoingTargets: new Set(analysis.outgoingTargets) };
-}
-
-export function collectSourceHtmlAnalysis(
-  assets: Asset[],
-): Map<string, HtmlOutputAnalysis> {
-  const htmlAnalysisByOutputPath = new Map<string, HtmlOutputAnalysis>();
-  for (const asset of assets) {
-    if (!asset.assetPath.endsWith('.html') || !asset.htmlAnalysis) {
-      continue;
-    }
-    htmlAnalysisByOutputPath.set(
-      asset.assetPath,
-      cloneHtmlOutputAnalysis(asset.htmlAnalysis),
-    );
-  }
-  return htmlAnalysisByOutputPath;
-}
-
-function collectHtmlAssetsByPath(
-  contentRecords: Map<string, TadaSourceRecord>,
-): Map<string, string> {
-  const htmlAssetsByPath = new Map<string, string>();
-  for (const record of contentRecords.values()) {
-    for (const [outputPath, content] of record.outputs) {
-      if (outputPath.endsWith('.html') && typeof content === 'string') {
-        htmlAssetsByPath.set(outputPath, content);
-      }
-    }
-  }
-  return htmlAssetsByPath;
-}
-
-function collectHtmlAnalysisByPath(
-  contentRecords: Map<string, TadaSourceRecord>,
-): Map<string, HtmlOutputAnalysis> {
-  const htmlAnalysisByPath = new Map<string, HtmlOutputAnalysis>();
-  for (const record of contentRecords.values()) {
-    if (!record.htmlAnalysisByOutputPath) {
-      continue;
-    }
-    for (const [outputPath, analysis] of record.htmlAnalysisByOutputPath) {
-      htmlAnalysisByPath.set(outputPath, cloneHtmlOutputAnalysis(analysis));
-    }
-  }
-  return htmlAnalysisByPath;
-}
-
-export function createBuildMeta(snapshot: TadaSnapshot): TadaBuildMeta {
-  return {
-    htmlAssetsByPath: collectHtmlAssetsByPath(snapshot.contentRecords),
-    htmlAnalysisByPath: collectHtmlAnalysisByPath(snapshot.contentRecords),
-    siteVariables: snapshot.siteVariables,
-  };
-}
-
-export { assertNoOutputPathConflicts, type TadaProjectScan };