@abreen/tada 1.13.4 → 1.13.9

package/build/utils/trace.ts

@@ -42,6 +42,7 @@ export interface TraceContext {
 
 export interface TraceResult {
   manifestUrl: string;
+  artifactId: string;
   highlightedSource: string;
   totalSteps: number;
   mtime: number;
@@ -141,6 +142,7 @@ export function createTraceHelpers(context: TraceContext): {
         const outputPaths = getTraceOutputPaths(
           relDir,
           traceName,
+          cached.artifactId,
           cached.totalSteps,
         );
         if (
@@ -155,7 +157,12 @@ export function createTraceHelpers(context: TraceContext): {
           }
           return {
             ...cached,
-            manifestUrl: buildManifestUrl({ relDir, traceName, applyBasePath }),
+            manifestUrl: buildManifestUrl({
+              relDir,
+              traceName,
+              artifactId: cached.artifactId,
+              applyBasePath,
+            }),
           };
         }
       }
@@ -176,32 +183,42 @@ export function createTraceHelpers(context: TraceContext): {
     );
     const traceOutputDir = path.join(distDir, relDir, '_traces', traceName);
 
-    const manifest = chunkTraceOutput(
+    const traceOutput = chunkTraceOutput(
       output,
       traceOutputDir,
+      relDir,
+      traceName,
       sourceFileNameForTrace(sourceFile),
       source,
       { chunkSize: DEFAULT_CHUNK_SIZE, ignoreFields },
     );
-    for (const outputPath of getTraceOutputPaths(
-      relDir,
-      traceName,
-      manifest.totalSteps,
-    )) {
+    for (const outputPath of traceOutput.outputPaths) {
       dependencyCollector?.generatedOutputPaths?.add(outputPath);
     }
 
-    const manifestUrl = buildManifestUrl({ relDir, traceName, applyBasePath });
+    const manifestUrl = buildManifestUrl({
+      relDir,
+      traceName,
+      artifactId: traceOutput.artifactId,
+      applyBasePath,
+    });
 
-    const totalSteps = manifest.totalSteps;
+    const totalSteps = traceOutput.manifest.totalSteps;
     const mtime = fs.statSync(sourceFilePath).mtimeMs;
     cache.set(sourceFilePath, {
       manifestUrl,
+      artifactId: traceOutput.artifactId,
       highlightedSource,
       totalSteps,
       mtime,
     });
-    return { manifestUrl, highlightedSource, totalSteps, mtime };
+    return {
+      manifestUrl,
+      artifactId: traceOutput.artifactId,
+      highlightedSource,
+      totalSteps,
+      mtime,
+    };
   }
 
   return {

package/build/watch/assets.ts

@@ -1,6 +1,6 @@
 import fs from 'fs';
 import path from 'path';
-import { bundle } from '../bundle';
+import { bundle, getBundleNaming } from '../bundle';
 import { copyFonts } from '../generate-fonts';
 import { copyKatexAssets } from '../generate-katex-assets';
 import { generateFavicons } from '../generate-favicon';
@@ -42,7 +42,7 @@ export async function bundleWatchAssets(
   const reloadAssets = await Bun.build({
     entrypoints: [RELOAD_CLIENT_PATH],
     outdir: outputDir,
-    naming: '[name].bundle.[ext]',
+    naming: getBundleNaming(),
     sourcemap: 'inline',
   });
   return [

package/build/watch/build-full.ts

@@ -1,34 +1,24 @@
 import { compileTemplates, config } from '../templates';
 import { getDevSiteVariables } from '../site-variables';
-import { createContentRecord, createPublicRecord } from '../source-records';
 import { getDistDir } from '../util';
-import type { CompilerBuildResult } from '../../watch/types';
-import {
-  collectHtmlAnalysisByPath,
-  collectHtmlAssetsByPath,
-  createSnapshot,
-  type TadaSourceRecord,
-  type TadaSnapshot,
-} from './snapshot';
+import type { CompilerBuildResult } from './types';
+import { createSnapshot, type TadaSourceRecord } from './snapshot';
 import { scanProject } from '../source-model';
-import type {
-  TadaBuildMeta,
-  TraceCache,
-  WatchTraceOptions,
-} from './compiler-types';
+import type { TraceCache, WatchTraceOptions } from './compiler-types';
 import {
   bundleWatchAssets,
   ensureHighlighter,
   makeTempBuildDir,
   populateStaticAssets,
   removeDirIfExists,
-  writeAssets,
 } from './assets';
+import { validateConfig, validateProjectConfigLinks } from './validation';
+import { buildFailedFromError, buildSucceeded } from './build-result';
 import {
-  diagnosticsFromMessages,
-  validateConfig,
-  validateProjectConfigLinks,
-} from './validation';
+  buildFailedWithDiagnostics,
+  renderContentRecord,
+  renderPublicRecord,
+} from './build-helpers';
 
 export async function buildFull({
   traceCache,
@@ -36,7 +26,7 @@ export async function buildFull({
 }: {
   traceCache: TraceCache;
   traceOptions: WatchTraceOptions;
-}): Promise<CompilerBuildResult<TadaSnapshot, TadaBuildMeta>> {
+}): Promise<CompilerBuildResult> {
   const distDir = getDistDir();
   const outputDir = makeTempBuildDir(distDir);
   try {
@@ -44,8 +34,7 @@ export async function buildFull({
     const scan = scanProject(siteVariables);
     const configDiagnostics = validateConfig(scan);
     if (configDiagnostics.length > 0) {
-      removeDirIfExists(outputDir);
-      return { ok: false, diagnostics: configDiagnostics };
+      return buildFailedWithDiagnostics(outputDir, configDiagnostics);
     }
 
     compileTemplates(siteVariables);
@@ -56,33 +45,34 @@ export async function buildFull({
 
     const contentRecords = new Map<string, TadaSourceRecord>();
     for (const filePath of scan.contentFiles) {
-      const record = createContentRecord({
+      const record = renderContentRecord({
         filePath,
         siteVariables,
         scan,
         assetFiles,
         outputDir,
         traceCache,
-        traceToolAvailability: traceOptions.toolAvailability,
+        traceOptions,
         cachedTraceSourceDir: distDir,
       });
-      if (record.outputs.size > 0) {
-        writeAssets(outputDir, record.outputs);
+      if (record) {
         contentRecords.set(filePath, record);
       }
     }
 
     const publicRecords = new Map<string, TadaSourceRecord>();
     for (const filePath of scan.publicFiles) {
-      const record = createPublicRecord(filePath, scan.publicDir);
-      writeAssets(outputDir, record.outputs);
+      const record = renderPublicRecord({
+        filePath,
+        publicDir: scan.publicDir,
+        outputDir,
+      });
       publicRecords.set(filePath, record);
     }
 
     const linkDiagnostics = validateProjectConfigLinks(scan.validTargets);
     if (linkDiagnostics.length > 0) {
-      removeDirIfExists(outputDir);
-      return { ok: false, diagnostics: linkDiagnostics };
+      return buildFailedWithDiagnostics(outputDir, linkDiagnostics);
     }
 
     const nextSnapshot = createSnapshot({
@@ -95,29 +85,13 @@ export async function buildFull({
       publicRecords,
     });
 
-    return {
-      ok: true,
-      snapshot: nextSnapshot,
-      commit: {
-        kind: 'replace-root',
-        stagedPath: outputDir,
-        targetPath: distDir,
-      },
-      meta: {
-        htmlAssetsByPath: collectHtmlAssetsByPath(nextSnapshot.contentRecords),
-        htmlAnalysisByPath: collectHtmlAnalysisByPath(
-          nextSnapshot.contentRecords,
-        ),
-        siteVariables,
-      },
-    };
+    return buildSucceeded(nextSnapshot, {
+      kind: 'replace-root',
+      stagedPath: outputDir,
+      targetPath: distDir,
+    });
   } catch (error) {
     removeDirIfExists(outputDir);
-    return {
-      ok: false,
-      diagnostics: diagnosticsFromMessages([
-        error instanceof Error ? error.message : String(error),
-      ]),
-    };
+    return buildFailedFromError(error);
   }
 }

package/build/watch/build-helpers.ts

@@ -0,0 +1,66 @@
+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-incremental.ts

@@ -1,32 +1,23 @@
 import { compileTemplates, config } from '../templates';
 import { getDistDir } from '../util';
-import { createContentRecord, createPublicRecord } from '../source-records';
-import type { CompilerBuildResult } from '../../watch/types';
-import type {
-  TadaBuildMeta,
-  TraceCache,
-  WatchTraceOptions,
-} from './compiler-types';
-import type { TadaWatchPlan } from './planner';
-import {
-  collectHtmlAnalysisByPath,
-  collectHtmlAssetsByPath,
-  createSnapshot,
-  type TadaSnapshot,
-} from './snapshot';
+import type { CompilerBuildResult } from './types';
+import type { TraceCache, WatchTraceOptions } from './compiler-types';
+import type { TadaIncrementalWatchPlan } from './planner';
+import { createSnapshot, type TadaSnapshot } from './snapshot';
 import {
   copyExistingBuildAssets,
   ensureHighlighter,
   makeTempBuildDir,
   removeDirIfExists,
-  writeAssets,
 } from './assets';
 import { computeMutations } from './mutations';
+import { validateConfig, validateProjectConfigLinks } from './validation';
+import { buildFailedFromError, buildSucceeded } from './build-result';
 import {
-  diagnosticsFromMessages,
-  validateConfig,
-  validateProjectConfigLinks,
-} from './validation';
+  buildFailedWithDiagnostics,
+  renderContentRecord,
+  renderPublicRecord,
+} from './build-helpers';
 
 export async function buildIncremental({
   plan,
@@ -34,23 +25,23 @@ export async function buildIncremental({
   traceCache,
   traceOptions,
 }: {
-  plan: TadaWatchPlan;
+  plan: TadaIncrementalWatchPlan;
   snapshot: TadaSnapshot;
   traceCache: TraceCache;
   traceOptions: WatchTraceOptions;
-}): Promise<CompilerBuildResult<TadaSnapshot, TadaBuildMeta>> {
-  const outputDir = makeTempBuildDir(plan.scan.distDir);
+}): Promise<CompilerBuildResult> {
+  const distDir = getDistDir();
+  const outputDir = makeTempBuildDir(distDir);
   try {
     const siteVariables = snapshot.siteVariables;
     const configDiagnostics = validateConfig(plan.scan);
     if (configDiagnostics.length > 0) {
-      removeDirIfExists(outputDir);
-      return { ok: false, diagnostics: configDiagnostics };
+      return buildFailedWithDiagnostics(outputDir, configDiagnostics);
     }
 
     compileTemplates(siteVariables);
     await ensureHighlighter(siteVariables);
-    copyExistingBuildAssets(getDistDir(), outputDir, snapshot.assetFiles);
+    copyExistingBuildAssets(distDir, outputDir, snapshot.assetFiles);
 
     const nextContentRecords = new Map(snapshot.contentRecords);
     const nextPublicRecords = new Map(snapshot.publicRecords);
@@ -64,25 +55,27 @@ export async function buildIncremental({
 
     for (const sourcePath of plan.contentToRender) {
       nextContentRecords.delete(sourcePath);
-      const record = createContentRecord({
+      const record = renderContentRecord({
         filePath: sourcePath,
         siteVariables,
         scan: plan.scan,
         assetFiles: snapshot.assetFiles,
         outputDir,
         traceCache,
-        traceToolAvailability: traceOptions.toolAvailability,
-        cachedTraceSourceDir: getDistDir(),
+        traceOptions,
+        cachedTraceSourceDir: distDir,
       });
-      if (record.outputs.size > 0) {
-        writeAssets(outputDir, record.outputs);
+      if (record) {
         nextContentRecords.set(sourcePath, record);
       }
     }
 
     for (const sourcePath of plan.publicToRender) {
       nextPublicRecords.delete(sourcePath);
-      const record = createPublicRecord(sourcePath, plan.scan.publicDir);
+      const record = renderPublicRecord({
+        filePath: sourcePath,
+        publicDir: plan.scan.publicDir,
+      });
       nextPublicRecords.set(sourcePath, record);
     }
 
@@ -97,11 +90,10 @@ export async function buildIncremental({
     });
 
     const linkDiagnostics = validateProjectConfigLinks(
-      nextSnapshot.validTargets,
+      nextSnapshot.scan.validTargets,
     );
     if (linkDiagnostics.length > 0) {
-      removeDirIfExists(outputDir);
-      return { ok: false, diagnostics: linkDiagnostics };
+      return buildFailedWithDiagnostics(outputDir, linkDiagnostics);
     }
 
     const forceSourcePaths = new Set([
@@ -112,35 +104,15 @@ export async function buildIncremental({
       snapshot,
       nextSnapshot,
       forceSourcePaths,
-    ).map(mutation =>
-      mutation.kind === 'write'
-        ? {
-            kind: 'write' as const,
-            path: mutation.path,
-            content: mutation.content!,
-          }
-        : { kind: 'delete' as const, path: mutation.path },
     );
     removeDirIfExists(outputDir);
-    return {
-      ok: true,
-      snapshot: nextSnapshot,
-      commit: { kind: 'apply-mutations', rootDir: getDistDir(), mutations },
-      meta: {
-        htmlAssetsByPath: collectHtmlAssetsByPath(nextSnapshot.contentRecords),
-        htmlAnalysisByPath: collectHtmlAnalysisByPath(
-          nextSnapshot.contentRecords,
-        ),
-        siteVariables,
-      },
-    };
+    return buildSucceeded(nextSnapshot, {
+      kind: 'apply-mutations',
+      rootDir: distDir,
+      mutations,
+    });
   } catch (error) {
     removeDirIfExists(outputDir);
-    return {
-      ok: false,
-      diagnostics: diagnosticsFromMessages([
-        error instanceof Error ? error.message : String(error),
-      ]),
-    };
+    return buildFailedFromError(error);
   }
 }

package/build/watch/build-result.ts

@@ -0,0 +1,19 @@
+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/compiler-types.d.ts

@@ -6,6 +6,7 @@ import type {
 
 export interface TraceCacheEntry {
   manifestUrl: string;
+  artifactId: string;
   highlightedSource: string;
   totalSteps: number;
   mtime: number;

package/build/watch/compiler.ts

@@ -1,30 +1,20 @@
 import path from 'path';
-import {
-  getProjectConfigBaseName,
-  getSiteConfigBaseName,
-  getSupportedConfigFilePaths,
-} from '../config-files';
-import { getDevSiteVariables } from '../site-variables';
 import { getProjectConfigDir } from '../templates';
 import { getContentDir, getPublicDir } from '../util';
 import type {
   ChangeBatch,
   CompilerBuildResult,
-  CompilerPlanResult,
   WatchCompiler,
   WatchTarget,
-} from '../../watch/types';
+} from './types';
 import { buildFull } from './build-full';
 import { buildIncremental } from './build-incremental';
-import type {
-  TadaBuildMeta,
-  TraceCache,
-  WatchTraceOptions,
-} from './compiler-types';
+import type { TraceCache, WatchTraceOptions } from './compiler-types';
 import { checkTraceToolAvailability, isTraceSourceFile } from '../utils/trace';
-import { createTadaWatchPlan, type TadaWatchPlan } from './planner';
-import { scanProject, updateProjectScan } from '../source-model';
+import { createTadaWatchPlan } from './planner';
+import { updateProjectScan } from '../source-model';
 import type { TadaSnapshot } from './snapshot';
+import { getWatchConfigFilePaths } from './config-paths';
 
 export function invalidateTraceCacheForBatch(
   traceCache: TraceCache,
@@ -38,11 +28,7 @@ export function invalidateTraceCacheForBatch(
   }
 }
 
-export class TadaWatchCompiler implements WatchCompiler<
-  TadaSnapshot,
-  TadaWatchPlan,
-  TadaBuildMeta
-> {
+export class TadaWatchCompiler implements WatchCompiler {
   private traceCache: TraceCache;
   private traceOptions: WatchTraceOptions;
 
@@ -55,23 +41,11 @@ export class TadaWatchCompiler implements WatchCompiler<
     const contentDir = getContentDir();
     const publicDir = getPublicDir();
     const projectConfigDir = path.resolve(getProjectConfigDir());
-    const configFilePaths = new Set([
-      ...getSupportedConfigFilePaths('.', getSiteConfigBaseName('dev')).map(
-        filePath => path.resolve(filePath),
-      ),
-      ...getSupportedConfigFilePaths(
-        projectConfigDir,
-        getProjectConfigBaseName('nav'),
-      ).map(filePath => path.resolve(filePath)),
-      ...getSupportedConfigFilePaths(
-        projectConfigDir,
-        getProjectConfigBaseName('authors'),
-      ).map(filePath => path.resolve(filePath)),
-    ]);
+    const configFilePaths = getWatchConfigFilePaths();
 
     return [
-      { path: contentDir },
-      { path: publicDir },
+      { path: contentDir, chokidar: { usePolling: true } },
+      { path: publicDir, chokidar: { usePolling: true } },
       {
         path: projectConfigDir,
         chokidar: { depth: 0 },
@@ -80,34 +54,24 @@ export class TadaWatchCompiler implements WatchCompiler<
     ];
   }
 
-  async buildInitial(): Promise<
-    CompilerBuildResult<TadaSnapshot, TadaBuildMeta>
-  > {
-    return buildFull({
-      traceCache: this.traceCache,
-      traceOptions: this.traceOptions,
-    });
-  }
-
-  async plan(
+  async build(
     snapshot: TadaSnapshot | undefined,
-    batch: ChangeBatch,
-  ): Promise<CompilerPlanResult<TadaWatchPlan>> {
-    invalidateTraceCacheForBatch(this.traceCache, batch);
-    const scan = snapshot
-      ? updateProjectScan(snapshot, batch)
-      : scanProject(getDevSiteVariables());
-    return {
-      kind: 'build',
-      plan: createTadaWatchPlan({ snapshot, batch, scan }),
-    };
-  }
+    batch?: ChangeBatch,
+  ): Promise<CompilerBuildResult> {
+    if (batch) {
+      invalidateTraceCacheForBatch(this.traceCache, batch);
+    }
 
-  async run(
-    plan: TadaWatchPlan,
-    snapshot: TadaSnapshot | undefined,
-  ): Promise<CompilerBuildResult<TadaSnapshot, TadaBuildMeta>> {
-    if (plan.kind === 'full' || !snapshot) {
+    if (!snapshot || !batch) {
+      return buildFull({
+        traceCache: this.traceCache,
+        traceOptions: this.traceOptions,
+      });
+    }
+
+    const scan = updateProjectScan(snapshot.scan, batch);
+    const plan = createTadaWatchPlan({ snapshot, batch, scan });
+    if (plan.kind === 'full') {
       return buildFull({
         traceCache: this.traceCache,
         traceOptions: this.traceOptions,

package/build/watch/config-paths.ts

@@ -0,0 +1,56 @@
+import path from 'path';
+import {
+  getProjectConfigBaseName,
+  getSiteConfigBaseName,
+  getSupportedConfigFilePaths,
+} from '../config-files';
+import { getProjectConfigDir } from '../templates';
+
+export type WatchConfigPathKind = 'site' | 'nav' | 'authors';
+
+function getConfigPathEntries(): Array<{
+  kind: WatchConfigPathKind;
+  paths: string[];
+}> {
+  const projectConfigDir = getProjectConfigDir();
+  return [
+    {
+      kind: 'site',
+      paths: getSupportedConfigFilePaths('.', getSiteConfigBaseName('dev')),
+    },
+    {
+      kind: 'nav',
+      paths: getSupportedConfigFilePaths(
+        projectConfigDir,
+        getProjectConfigBaseName('nav'),
+      ),
+    },
+    {
+      kind: 'authors',
+      paths: getSupportedConfigFilePaths(
+        projectConfigDir,
+        getProjectConfigBaseName('authors'),
+      ),
+    },
+  ];
+}
+
+function getWatchConfigPathKinds(): Map<string, WatchConfigPathKind> {
+  return new Map(
+    getConfigPathEntries().flatMap(entry =>
+      entry.paths.map(
+        filePath => [path.resolve(filePath), entry.kind] as const,
+      ),
+    ),
+  );
+}
+
+export function getWatchConfigFilePaths(): Set<string> {
+  return new Set(getWatchConfigPathKinds().keys());
+}
+
+export function classifyWatchConfigPath(
+  filePath: string,
+): WatchConfigPathKind | undefined {
+  return getWatchConfigPathKinds().get(path.resolve(filePath));
+}