@abreen/tada 1.17.0 → 1.18.0

package/build/watch/assets.ts

@@ -1,103 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { bundle, getBundleNaming } from '../bundle';
-import { copyFonts, DEFAULT_FONT_PRELOAD_FILES } from '../generate-fonts';
-import { copyKatexAssets } from '../generate-katex-assets';
-import { generateFavicons } from '../generate-favicon';
-import { generateWebAppManifest } from '../generate-web-app-manifest';
-import { getRuntimeBundledShikiLanguages } from '../site-variables';
-import { getPackageDir, toPosix } from '../util';
-import { initHighlighter } from '../utils/shiki-highlighter';
-import type { SiteVariables } from '../types';
-
-const RELOAD_CLIENT_PATH = path.resolve(
-  getPackageDir(),
-  'build/watch-reload-client.ts',
-);
-
-export function makeTempBuildDir(distDir: string): string {
-  const parentDir = path.dirname(distDir);
-  const prefix = `${path.basename(distDir)}-watch-`;
-  return fs.mkdtempSync(path.join(parentDir, prefix));
-}
-
-export function removeDirIfExists(dir: string): void {
-  fs.rmSync(dir, { recursive: true, force: true });
-}
-
-export async function ensureHighlighter(
-  siteVariables: SiteVariables,
-): Promise<void> {
-  await initHighlighter(getRuntimeBundledShikiLanguages(siteVariables));
-}
-
-export async function bundleWatchAssets(
-  outputDir: string,
-  siteVariables: SiteVariables,
-): Promise<string[]> {
-  const appAssets = await bundle(siteVariables, {
-    mode: 'development',
-    distDir: outputDir,
-  });
-  const reloadAssets = await Bun.build({
-    entrypoints: [RELOAD_CLIENT_PATH],
-    outdir: outputDir,
-    naming: getBundleNaming(),
-    sourcemap: 'inline',
-  });
-  return [
-    ...appAssets,
-    ...reloadAssets.outputs.map(output =>
-      toPosix(path.relative(outputDir, output.path)),
-    ),
-  ];
-}
-
-export async function populateStaticAssets(
-  outputDir: string,
-  siteVariables: SiteVariables,
-): Promise<void> {
-  copyFonts(outputDir);
-  copyKatexAssets(outputDir);
-  if (siteVariables.features.favicon !== false) {
-    await generateFavicons(siteVariables, outputDir);
-    generateWebAppManifest(siteVariables, outputDir);
-  }
-}
-
-export function copyExistingBuildAssets(
-  distDir: string,
-  outputDir: string,
-  assetFiles: string[],
-): void {
-  const relPaths = [
-    ...assetFiles,
-    ...DEFAULT_FONT_PRELOAD_FILES.sans,
-    ...DEFAULT_FONT_PRELOAD_FILES.serif,
-  ];
-
-  for (const relPath of relPaths) {
-    const sourcePath = path.join(distDir, relPath);
-    if (!fs.existsSync(sourcePath)) {
-      continue;
-    }
-    const destinationPath = path.join(outputDir, relPath);
-    fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
-    try {
-      fs.linkSync(sourcePath, destinationPath);
-    } catch {
-      fs.copyFileSync(sourcePath, destinationPath);
-    }
-  }
-}
-
-export function writeAssets(
-  outputDir: string,
-  assets: Map<string, string | Buffer>,
-): void {
-  for (const [assetPath, content] of assets) {
-    const outputPath = path.join(outputDir, assetPath);
-    fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-    fs.writeFileSync(outputPath, content);
-  }
-}

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,153 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { globals, type Globals } from '../globals';
-import type {
-  ApplyMutationsCommitPlan,
-  CommitPlan,
-  FileMutation,
-  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);
-  }
-}
-
-function applyFileMutation(
-  rootDir: string,
-  mutation: FileMutation,
-  stagedRoot: string,
-  globals: CommitPlanGlobals,
-): void {
-  const targetPath = path.join(rootDir, mutation.path);
-  const stagedPath = path.join(stagedRoot, mutation.path);
-
-  if (mutation.kind === 'write') {
-    ensureParentDir(targetPath);
-    renameWithRetry(stagedPath, targetPath, globals);
-    return;
-  }
-
-  fs.rmSync(targetPath, { force: true });
-  pruneEmptyDirs(rootDir, targetPath);
-}
-
-function applyMutations(
-  plan: ApplyMutationsCommitPlan,
-  globals: CommitPlanGlobals,
-): void {
-  const stagedRoot = fs.mkdtempSync(path.join(plan.rootDir, '.watch-stage-'));
-  try {
-    for (const mutation of plan.mutations) {
-      if (mutation.kind === 'write') {
-        const stagedPath = path.join(stagedRoot, mutation.path);
-        ensureParentDir(stagedPath);
-        fs.writeFileSync(stagedPath, mutation.content);
-      }
-    }
-
-    for (const mutation of plan.mutations) {
-      applyFileMutation(plan.rootDir, mutation, stagedRoot, globals);
-    }
-  } finally {
-    removeDirIfExists(stagedRoot);
-  }
-}
-
-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 };