@abreen/tada 1.11.3 → 1.13.2

package/build/watch/build-full.ts

@@ -1,14 +1,16 @@
-import { compileTemplates, json } from '../templates';
+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,
-  scanProject,
   type TadaSourceRecord,
   type TadaSnapshot,
 } from './snapshot';
+import { scanProject } from '../source-model';
 import type {
   TadaBuildMeta,
   TraceCache,
@@ -22,19 +24,16 @@ import {
   removeDirIfExists,
   writeAssets,
 } from './assets';
-import { createPublicRecord, renderContentRecord } from './records';
 import {
   diagnosticsFromMessages,
   validateConfig,
-  validateJsonLinks,
+  validateProjectConfigLinks,
 } from './validation';
 
 export async function buildFull({
-  wsPort,
   traceCache,
   traceOptions,
 }: {
-  wsPort: number;
   traceCache: TraceCache;
   traceOptions: WatchTraceOptions;
 }): Promise<CompilerBuildResult<TadaSnapshot, TadaBuildMeta>> {
@@ -52,16 +51,12 @@ export async function buildFull({
     compileTemplates(siteVariables);
     await ensureHighlighter(siteVariables);
 
-    const assetFiles = await bundleWatchAssets(
-      outputDir,
-      siteVariables,
-      wsPort,
-    );
+    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({
+      const record = createContentRecord({
         filePath,
         siteVariables,
         scan,
@@ -72,6 +67,7 @@ export async function buildFull({
         cachedTraceSourceDir: distDir,
       });
       if (record.outputs.size > 0) {
+        writeAssets(outputDir, record.outputs);
         contentRecords.set(filePath, record);
       }
     }
@@ -83,7 +79,7 @@ export async function buildFull({
       publicRecords.set(filePath, record);
     }
 
-    const linkDiagnostics = validateJsonLinks(scan.validTargets);
+    const linkDiagnostics = validateProjectConfigLinks(scan.validTargets);
     if (linkDiagnostics.length > 0) {
       removeDirIfExists(outputDir);
       return { ok: false, diagnostics: linkDiagnostics };
@@ -92,8 +88,8 @@ export async function buildFull({
     const nextSnapshot = createSnapshot({
       siteVariables,
       assetFiles,
-      navData: json('nav.json'),
-      authorsData: json('authors.json'),
+      navData: config('nav'),
+      authorsData: config('authors'),
       scan,
       contentRecords,
       publicRecords,
@@ -109,6 +105,9 @@ export async function buildFull({
       },
       meta: {
         htmlAssetsByPath: collectHtmlAssetsByPath(nextSnapshot.contentRecords),
+        htmlAnalysisByPath: collectHtmlAnalysisByPath(
+          nextSnapshot.contentRecords,
+        ),
         siteVariables,
       },
     };

package/build/watch/build-incremental.ts

@@ -1,5 +1,6 @@
-import { compileTemplates, json } from '../templates';
+import { compileTemplates, config } from '../templates';
 import { getDistDir } from '../util';
+import { createContentRecord, createPublicRecord } from '../source-records';
 import type { CompilerBuildResult } from '../../watch/types';
 import type {
   TadaBuildMeta,
@@ -8,6 +9,7 @@ import type {
 } from './compiler-types';
 import type { TadaWatchPlan } from './planner';
 import {
+  collectHtmlAnalysisByPath,
   collectHtmlAssetsByPath,
   createSnapshot,
   type TadaSnapshot,
@@ -17,13 +19,13 @@ import {
   ensureHighlighter,
   makeTempBuildDir,
   removeDirIfExists,
+  writeAssets,
 } from './assets';
 import { computeMutations } from './mutations';
-import { createPublicRecord, renderContentRecord } from './records';
 import {
   diagnosticsFromMessages,
   validateConfig,
-  validateJsonLinks,
+  validateProjectConfigLinks,
 } from './validation';
 
 export async function buildIncremental({
@@ -62,7 +64,7 @@ export async function buildIncremental({
 
     for (const sourcePath of plan.contentToRender) {
       nextContentRecords.delete(sourcePath);
-      const record = renderContentRecord({
+      const record = createContentRecord({
         filePath: sourcePath,
         siteVariables,
         scan: plan.scan,
@@ -71,9 +73,9 @@ export async function buildIncremental({
         traceCache,
         traceToolAvailability: traceOptions.toolAvailability,
         cachedTraceSourceDir: getDistDir(),
-        persistOutputs: false,
       });
       if (record.outputs.size > 0) {
+        writeAssets(outputDir, record.outputs);
         nextContentRecords.set(sourcePath, record);
       }
     }
@@ -87,14 +89,16 @@ export async function buildIncremental({
     const nextSnapshot = createSnapshot({
       siteVariables,
       assetFiles: snapshot.assetFiles,
-      navData: json('nav.json'),
-      authorsData: json('authors.json'),
+      navData: config('nav'),
+      authorsData: config('authors'),
       scan: plan.scan,
       contentRecords: nextContentRecords,
       publicRecords: nextPublicRecords,
     });
 
-    const linkDiagnostics = validateJsonLinks(nextSnapshot.validTargets);
+    const linkDiagnostics = validateProjectConfigLinks(
+      nextSnapshot.validTargets,
+    );
     if (linkDiagnostics.length > 0) {
       removeDirIfExists(outputDir);
       return { ok: false, diagnostics: linkDiagnostics };
@@ -124,6 +128,9 @@ export async function buildIncremental({
       commit: { kind: 'apply-mutations', rootDir: getDistDir(), mutations },
       meta: {
         htmlAssetsByPath: collectHtmlAssetsByPath(nextSnapshot.contentRecords),
+        htmlAnalysisByPath: collectHtmlAnalysisByPath(
+          nextSnapshot.contentRecords,
+        ),
         siteVariables,
       },
     };

package/build/watch/compiler-types.d.ts

@@ -1,4 +1,8 @@
-import type { SiteVariables, TraceToolAvailability } from '../types';
+import type {
+  HtmlOutputAnalysis,
+  SiteVariables,
+  TraceToolAvailability,
+} from '../types';
 
 export interface TraceCacheEntry {
   manifestUrl: string;
@@ -11,6 +15,7 @@ export type TraceCache = Map<string, TraceCacheEntry>;
 
 export interface TadaBuildMeta {
   htmlAssetsByPath: Map<string, string>;
+  htmlAnalysisByPath: Map<string, HtmlOutputAnalysis>;
   siteVariables: SiteVariables;
 }
 

package/build/watch/compiler.ts

@@ -1,6 +1,11 @@
 import path from 'path';
+import {
+  getProjectConfigBaseName,
+  getSiteConfigBaseName,
+  getSupportedConfigFilePaths,
+} from '../config-files';
 import { getDevSiteVariables } from '../site-variables';
-import { getJsonDataDir } from '../templates';
+import { getProjectConfigDir } from '../templates';
 import { getContentDir, getPublicDir } from '../util';
 import type {
   ChangeBatch,
@@ -18,7 +23,8 @@ import type {
 } from './compiler-types';
 import { checkTraceToolAvailability, isTraceSourceFile } from '../utils/trace';
 import { createTadaWatchPlan, type TadaWatchPlan } from './planner';
-import { scanProject, type TadaSnapshot, updateProjectScan } from './snapshot';
+import { scanProject, updateProjectScan } from '../source-model';
+import type { TadaSnapshot } from './snapshot';
 
 export function invalidateTraceCacheForBatch(
   traceCache: TraceCache,
@@ -32,15 +38,15 @@ export function invalidateTraceCacheForBatch(
   }
 }
 
-export class TadaWatchCompiler
-  implements WatchCompiler<TadaSnapshot, TadaWatchPlan, TadaBuildMeta>
-{
-  private wsPort: number;
+export class TadaWatchCompiler implements WatchCompiler<
+  TadaSnapshot,
+  TadaWatchPlan,
+  TadaBuildMeta
+> {
   private traceCache: TraceCache;
   private traceOptions: WatchTraceOptions;
 
-  constructor({ wsPort }: { wsPort: number }) {
-    this.wsPort = wsPort;
+  constructor() {
     this.traceCache = new Map();
     this.traceOptions = { toolAvailability: checkTraceToolAvailability() };
   }
@@ -48,18 +54,26 @@ export class TadaWatchCompiler
   getWatchTargets(): WatchTarget[] {
     const contentDir = getContentDir();
     const publicDir = getPublicDir();
-    const jsonDataDir = path.resolve(getJsonDataDir());
+    const projectConfigDir = path.resolve(getProjectConfigDir());
     const configFilePaths = new Set([
-      path.resolve('site.dev.json'),
-      path.resolve(jsonDataDir, 'nav.json'),
-      path.resolve(jsonDataDir, 'authors.json'),
+      ...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)),
     ]);
 
     return [
       { path: contentDir },
       { path: publicDir },
       {
-        path: jsonDataDir,
+        path: projectConfigDir,
         chokidar: { depth: 0 },
         filter: filePath => configFilePaths.has(path.resolve(filePath)),
       },
@@ -70,7 +84,6 @@ export class TadaWatchCompiler
     CompilerBuildResult<TadaSnapshot, TadaBuildMeta>
   > {
     return buildFull({
-      wsPort: this.wsPort,
       traceCache: this.traceCache,
       traceOptions: this.traceOptions,
     });
@@ -96,7 +109,6 @@ export class TadaWatchCompiler
   ): Promise<CompilerBuildResult<TadaSnapshot, TadaBuildMeta>> {
     if (plan.kind === 'full' || !snapshot) {
       return buildFull({
-        wsPort: this.wsPort,
         traceCache: this.traceCache,
         traceOptions: this.traceOptions,
       });

package/build/watch/index.ts

@@ -3,19 +3,14 @@ import { runWatchEngine } from '../../watch/engine';
 import { TadaWatchCompiler } from './compiler';
 import { TadaWatchRuntime } from './runtime';
 
-export async function runWatch(options: {
-  httpPort?: number;
-  wsPort?: number;
-}): Promise<void> {
-  const wsPort = options.wsPort ?? 35729;
+export async function runWatch(options: { httpPort?: number }): Promise<void> {
   const runtime = new TadaWatchRuntime({
-    wsPort,
     httpPort: options.httpPort,
     distDir: getDistDir(),
   });
 
   await runWatchEngine({
-    compiler: new TadaWatchCompiler({ wsPort }),
+    compiler: new TadaWatchCompiler(),
     onEvent: event => runtime.onEvent(event),
     debounceMs: 300,
   });

package/build/watch/planner.ts

@@ -1,6 +1,11 @@
-import fs from 'fs';
 import path from 'path';
-import { getJsonDataDir } from '../templates';
+import {
+  getProjectConfigBaseName,
+  getSiteConfigBaseName,
+  getSupportedConfigFilePaths,
+} from '../config-files';
+import { loadProjectConfig } from '../config-loader';
+import { getProjectConfigDir } from '../templates';
 import type { ChangeBatch } from '../../watch/types';
 import type { TadaProjectScan, TadaSnapshot } from './snapshot';
 
@@ -13,13 +18,6 @@ export interface TadaWatchPlan {
   publicToRemove: Set<string>;
 }
 
-function readJsonFile(filePath: string): unknown {
-  if (!fs.existsSync(filePath)) {
-    return undefined;
-  }
-  return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-}
-
 export function diffAuthorKeys(previous: unknown, next: unknown): Set<string> {
   const previousMap =
     previous && typeof previous === 'object'
@@ -70,10 +68,24 @@ export function createTadaWatchPlan({
   const publicToRender = new Set<string>();
   const contentToRemove = new Set<string>();
   const publicToRemove = new Set<string>();
-  const jsonDataDir = getJsonDataDir();
-  const siteConfigPath = path.resolve('site.dev.json');
-  const navPath = path.resolve(jsonDataDir, 'nav.json');
-  const authorsPath = path.resolve(jsonDataDir, 'authors.json');
+  const projectConfigDir = getProjectConfigDir();
+  const siteConfigPaths = new Set(
+    getSupportedConfigFilePaths('.', getSiteConfigBaseName('dev')).map(
+      filePath => path.resolve(filePath),
+    ),
+  );
+  const navPaths = new Set(
+    getSupportedConfigFilePaths(
+      projectConfigDir,
+      getProjectConfigBaseName('nav'),
+    ).map(filePath => path.resolve(filePath)),
+  );
+  const authorsPaths = new Set(
+    getSupportedConfigFilePaths(
+      projectConfigDir,
+      getProjectConfigBaseName('authors'),
+    ).map(filePath => path.resolve(filePath)),
+  );
 
   if (!snapshot) {
     return {
@@ -88,7 +100,7 @@ export function createTadaWatchPlan({
 
   for (const change of batch.changes) {
     const resolvedPath = path.resolve(change.path);
-    if (resolvedPath === siteConfigPath || resolvedPath === navPath) {
+    if (siteConfigPaths.has(resolvedPath) || navPaths.has(resolvedPath)) {
       return {
         kind: 'full',
         scan,
@@ -102,8 +114,12 @@ export function createTadaWatchPlan({
 
   for (const change of batch.changes) {
     const resolvedPath = path.resolve(change.path);
-    if (resolvedPath === authorsPath) {
-      const nextAuthorsData = readJsonFile(authorsPath);
+    if (authorsPaths.has(resolvedPath)) {
+      const nextAuthorsData = loadProjectConfig(
+        projectConfigDir,
+        'authors',
+        snapshot.siteVariables,
+      )?.value;
       if (snapshot.authorsData === undefined || nextAuthorsData === undefined) {
         return {
           kind: 'full',

package/build/watch/reload.ts

@@ -0,0 +1,4 @@
+export const WATCH_RELOAD_PATH = '/__tada_watch';
+export const WATCH_RELOAD_TOPIC = 'tada-watch';
+export const WATCH_RELOAD_MESSAGE_REBUILDING = 'rebuilding';
+export const WATCH_RELOAD_MESSAGE_RELOAD = 'reload';

package/build/watch/runtime.ts

@@ -1,5 +1,4 @@
 import path from 'path';
-import WebSocket, { WebSocketServer } from 'ws';
 import { B } from '../colors';
 import { makeLogger, printFlair } from '../log';
 import { startServer } from '../serve';
@@ -7,6 +6,12 @@ import { WatchPagefindRunner } from '../pagefind';
 import type { TadaBuildMeta } from './compiler-types';
 import type { TadaSnapshot } from './snapshot';
 import type { WatchLifecycleEvent } from '../../watch/types';
+import {
+  WATCH_RELOAD_MESSAGE_REBUILDING,
+  WATCH_RELOAD_MESSAGE_RELOAD,
+  WATCH_RELOAD_PATH,
+  WATCH_RELOAD_TOPIC,
+} from './reload';
 
 const log = makeLogger(import.meta.url);
 const wslog = makeLogger('WebSocket');
@@ -22,65 +27,45 @@ function describeChange(kind: 'add' | 'change' | 'unlink'): string {
 }
 
 export class TadaWatchRuntime {
-  private wsPort: number;
   private httpPort: number | undefined;
   private distDir: string;
-  private wss: WebSocketServer | null;
+  private server: Bun.Server<undefined> | null;
   private lastBuildFailed: boolean;
-  private serveStarted: boolean;
   private pagefindRunner: WatchPagefindRunner | undefined;
   private pagefindSiteVariablesKey: string | undefined;
 
-  constructor({
-    wsPort,
-    httpPort,
-    distDir,
-  }: {
-    wsPort: number;
-    httpPort?: number;
-    distDir: string;
-  }) {
-    this.wsPort = wsPort;
+  constructor({ httpPort, distDir }: { httpPort?: number; distDir: string }) {
     this.httpPort = httpPort;
     this.distDir = distDir;
+    this.server = null;
     this.lastBuildFailed = false;
-    this.serveStarted = false;
     this.pagefindSiteVariablesKey = undefined;
-    this.wss = new WebSocketServer({ port: wsPort });
-
-    this.wss.on('connection', conn => {
-      wslog.debug`WebSocket client connected`;
-      conn.on('close', () => {
-        wslog.debug`WebSocket client disconnected`;
-      });
-    });
-
-    this.wss.on('listening', () => {
-      wslog.debug`WebSocket server listening at ws://localhost:${this.wsPort}`;
-    });
-
-    this.wss.on('error', err => {
-      wslog.error`WebSocket server error: ${err.message}`;
-    });
   }
 
   private broadcast(message: string): void {
-    if (!this.wss) {
+    if (!this.server) {
       return;
     }
-    for (const client of this.wss.clients) {
-      if (client.readyState === WebSocket.OPEN) {
-        client.send(message);
-      }
-    }
+    this.server.publish(WATCH_RELOAD_TOPIC, message);
   }
 
   private ensureServerStarted(): void {
-    if (this.serveStarted) {
+    if (this.server) {
       return;
     }
-    this.serveStarted = true;
-    startServer({ port: this.httpPort, distDir: this.distDir });
+    this.server = startServer({
+      port: this.httpPort,
+      distDir: this.distDir,
+      watchReload: {
+        onClientOpen: () => {
+          wslog.debug`WebSocket client connected`;
+        },
+        onClientClose: () => {
+          wslog.debug`WebSocket client disconnected`;
+        },
+      },
+    });
+    wslog.debug`WebSocket server listening at ws://localhost:${this.server.port}${WATCH_RELOAD_PATH}`;
   }
 
   async onEvent(
@@ -92,7 +77,7 @@ export class TadaWatchRuntime {
           for (const change of event.batch?.changes || []) {
             log.event`${B`${path.basename(change.path)}`} ${describeChange(change.kind)}`;
           }
-          this.broadcast('rebuilding');
+          this.broadcast(WATCH_RELOAD_MESSAGE_REBUILDING);
         }
         return;
       case 'build-succeeded': {
@@ -101,7 +86,7 @@ export class TadaWatchRuntime {
         printFlair();
         this.ensureServerStarted();
         if (!event.initial && (event.changed || recoveredFromFailure)) {
-          this.broadcast('reload');
+          this.broadcast(WATCH_RELOAD_MESSAGE_RELOAD);
         }
         if (event.meta && event.changed) {
           if (event.meta.siteVariables.features.search !== false) {
@@ -110,14 +95,13 @@ export class TadaWatchRuntime {
               !this.pagefindRunner ||
               this.pagefindSiteVariablesKey !== siteVariablesKey
             ) {
-              this.pagefindRunner = new WatchPagefindRunner(
-                event.meta.siteVariables,
-              );
+              this.pagefindRunner = new WatchPagefindRunner();
               this.pagefindSiteVariablesKey = siteVariablesKey;
             }
             this.pagefindRunner.update(
               this.distDir,
               event.meta.htmlAssetsByPath,
+              event.meta.htmlAnalysisByPath,
             );
             setImmediate(() => this.pagefindRunner!.run());
           } else {