@abreen/tada 1.8.1 → 1.10.1

package/build/watch/planner.ts

@@ -0,0 +1,230 @@
+import fs from 'fs';
+import path from 'path';
+import { getJsonDataDir } from '../templates';
+import type { ChangeBatch } from '../../watch/types';
+import type { TadaProjectScan, TadaSnapshot } from './snapshot';
+
+export interface TadaWatchPlan {
+  kind: 'full' | 'incremental';
+  scan: TadaProjectScan;
+  contentToRender: Set<string>;
+  publicToRender: Set<string>;
+  contentToRemove: Set<string>;
+  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'
+      ? (previous as Record<string, unknown>)
+      : {};
+  const nextMap =
+    next && typeof next === 'object' ? (next as Record<string, unknown>) : {};
+  const keys = new Set([...Object.keys(previousMap), ...Object.keys(nextMap)]);
+  const changed = new Set<string>();
+
+  for (const key of keys) {
+    if (JSON.stringify(previousMap[key]) !== JSON.stringify(nextMap[key])) {
+      changed.add(key);
+    }
+  }
+
+  return changed;
+}
+
+function addDependents(
+  destination: Set<string>,
+  reverseMap: Map<string, Set<string>>,
+  key: string,
+): void {
+  const dependents = reverseMap.get(key);
+  if (!dependents) {
+    return;
+  }
+  for (const dependent of dependents) {
+    destination.add(dependent);
+  }
+}
+
+function sourceExists(filePath: string, scan: TadaProjectScan): boolean {
+  return scan.contentFiles.has(filePath) || scan.publicFiles.has(filePath);
+}
+
+export function createTadaWatchPlan({
+  snapshot,
+  batch,
+  scan,
+}: {
+  snapshot: TadaSnapshot | undefined;
+  batch: ChangeBatch;
+  scan: TadaProjectScan;
+}): TadaWatchPlan {
+  const contentToRender = new Set<string>();
+  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');
+
+  if (!snapshot) {
+    return {
+      kind: 'full',
+      scan,
+      contentToRender,
+      publicToRender,
+      contentToRemove,
+      publicToRemove,
+    };
+  }
+
+  for (const change of batch.changes) {
+    const resolvedPath = path.resolve(change.path);
+    if (resolvedPath === siteConfigPath || resolvedPath === navPath) {
+      return {
+        kind: 'full',
+        scan,
+        contentToRender,
+        publicToRender,
+        contentToRemove,
+        publicToRemove,
+      };
+    }
+  }
+
+  for (const change of batch.changes) {
+    const resolvedPath = path.resolve(change.path);
+    if (resolvedPath === authorsPath) {
+      const nextAuthorsData = readJsonFile(authorsPath);
+      if (snapshot.authorsData === undefined || nextAuthorsData === undefined) {
+        return {
+          kind: 'full',
+          scan,
+          contentToRender,
+          publicToRender,
+          contentToRemove,
+          publicToRemove,
+        };
+      }
+      const changedAuthorKeys = diffAuthorKeys(
+        snapshot.authorsData,
+        nextAuthorsData,
+      );
+      for (const key of changedAuthorKeys) {
+        addDependents(contentToRender, snapshot.reverseAuthorDeps, key);
+      }
+      continue;
+    }
+
+    if (scan.contentFiles.has(resolvedPath)) {
+      contentToRender.add(resolvedPath);
+    } else if (snapshot.contentRecords.has(resolvedPath)) {
+      contentToRemove.add(resolvedPath);
+      const previousRecord = snapshot.contentRecords.get(resolvedPath)!;
+      for (const partialPath of previousRecord.partialDeps) {
+        addDependents(
+          contentToRender,
+          snapshot.reversePartialDeps,
+          partialPath,
+        );
+      }
+      for (const tracePath of previousRecord.traceDeps) {
+        addDependents(contentToRender, snapshot.reverseTraceDeps, tracePath);
+      }
+    }
+
+    if (scan.publicFiles.has(resolvedPath)) {
+      publicToRender.add(resolvedPath);
+    } else if (snapshot.publicRecords.has(resolvedPath)) {
+      publicToRemove.add(resolvedPath);
+    }
+
+    addDependents(contentToRender, snapshot.reversePartialDeps, resolvedPath);
+    addDependents(contentToRender, snapshot.reverseTraceDeps, resolvedPath);
+  }
+
+  const changedTargets = new Set<string>();
+  const removedTargets = new Set<string>();
+  for (const target of snapshot.validTargets) {
+    if (!scan.validTargets.has(target)) {
+      changedTargets.add(target);
+      removedTargets.add(target);
+    }
+  }
+  for (const target of scan.validTargets) {
+    if (!snapshot.validTargets.has(target)) {
+      changedTargets.add(target);
+    }
+  }
+  for (const target of changedTargets) {
+    addDependents(contentToRender, snapshot.reverseInternalTargetDeps, target);
+  }
+
+  if (removedTargets.size > 0 && contentToRender.size === 0) {
+    const rootOwner = snapshot.outputOwners.get('index.html');
+    if (rootOwner?.kind === 'content') {
+      contentToRender.add(rootOwner.sourcePath);
+    }
+  }
+
+  for (const [outputPath, owner] of snapshot.outputOwners) {
+    const nextContentOwner = scan.contentOwners.get(outputPath);
+    const nextPublicOwner = scan.publicOwners.get(outputPath);
+    const nextKind = nextPublicOwner
+      ? 'public'
+      : nextContentOwner
+        ? 'content'
+        : null;
+    const nextSourcePath = nextPublicOwner || nextContentOwner;
+
+    if (!nextKind || !nextSourcePath) {
+      continue;
+    }
+    if (owner.kind !== nextKind || owner.sourcePath !== nextSourcePath) {
+      if (nextKind === 'content') {
+        contentToRender.add(nextSourcePath);
+      } else {
+        publicToRender.add(nextSourcePath);
+      }
+    }
+  }
+
+  for (const [outputPath, nextSourcePath] of scan.contentOwners) {
+    if (!snapshot.outputOwners.has(outputPath)) {
+      contentToRender.add(nextSourcePath);
+    }
+  }
+  for (const [outputPath, nextSourcePath] of scan.publicOwners) {
+    if (!snapshot.outputOwners.has(outputPath)) {
+      publicToRender.add(nextSourcePath);
+    }
+  }
+
+  for (const sourcePath of [...contentToRender]) {
+    if (!sourceExists(sourcePath, scan)) {
+      contentToRender.delete(sourcePath);
+    }
+  }
+  for (const sourcePath of [...publicToRender]) {
+    if (!sourceExists(sourcePath, scan)) {
+      publicToRender.delete(sourcePath);
+    }
+  }
+
+  return {
+    kind: 'incremental',
+    scan,
+    contentToRender,
+    publicToRender,
+    contentToRemove,
+    publicToRemove,
+  };
+}

package/build/watch/records.ts

@@ -0,0 +1,190 @@
+import fs from 'fs';
+import path from 'path';
+import {
+  renderCodePageAsset,
+  renderCopiedContentAsset,
+  renderLiterateJavaPageAsset,
+  renderPlainTextPageAsset,
+  toPosix,
+} from '../util';
+import { extensionIsMarkdown, isLiterateJava } from '../utils/file-types';
+import type {
+  Asset,
+  RenderDependencyCollector,
+  SiteVariables,
+  TraceToolAvailability,
+} from '../types';
+import {
+  collectSourceOutputs,
+  type TadaProjectScan,
+  type TadaSourceRecord,
+} from './snapshot';
+import type { TraceCache } from './compiler-types';
+import { writeAssets } from './assets';
+
+function createDependencyCollector(): {
+  collector: RenderDependencyCollector;
+  partials: Set<string>;
+  traceFiles: Set<string>;
+  internalTargets: Set<string>;
+  generatedOutputPaths: Set<string>;
+  authorKey: string | undefined;
+} {
+  const partials = new Set<string>();
+  const traceFiles = new Set<string>();
+  const internalTargets = new Set<string>();
+  const generatedOutputPaths = new Set<string>();
+  let authorKey: string | undefined;
+
+  return {
+    collector: {
+      partials,
+      traceFiles,
+      internalTargets,
+      generatedOutputPaths,
+      setAuthorKey(value: string) {
+        authorKey = value;
+      },
+    },
+    partials,
+    traceFiles,
+    internalTargets,
+    generatedOutputPaths,
+    get authorKey() {
+      return authorKey;
+    },
+  };
+}
+
+function createRawContentAsset(filePath: string, contentDir: string): Asset[] {
+  return [
+    {
+      assetPath: toPosix(path.relative(contentDir, filePath)),
+      content: fs.readFileSync(filePath),
+    },
+  ];
+}
+
+export function renderContentRecord({
+  filePath,
+  siteVariables,
+  scan,
+  assetFiles,
+  outputDir,
+  traceCache,
+  traceToolAvailability,
+  cachedTraceSourceDir,
+  persistOutputs = true,
+}: {
+  filePath: string;
+  siteVariables: SiteVariables;
+  scan: TadaProjectScan;
+  assetFiles: string[];
+  outputDir: string;
+  traceCache: TraceCache;
+  traceToolAvailability: TraceToolAvailability;
+  cachedTraceSourceDir?: string;
+  persistOutputs?: boolean;
+}): TadaSourceRecord {
+  const deps = createDependencyCollector();
+  const codeExtensions = Object.keys(siteVariables.codeLanguages || {}).map(
+    ext => ext.toLowerCase(),
+  );
+  const ext = path.extname(filePath).slice(1).toLowerCase();
+  const assets: Asset[] = [];
+  const codeEnabled = siteVariables.features.code !== false;
+
+  if (isLiterateJava(filePath)) {
+    assets.push(
+      ...renderLiterateJavaPageAsset({
+        filePath,
+        contentDir: scan.contentDir,
+        distDir: outputDir,
+        siteVariables,
+        assetFiles,
+        validInternalTargets: scan.validTargets,
+        literateJavaOutputPaths: scan.literateJavaOutputPaths,
+        dependencyCollector: deps.collector,
+      }),
+    );
+  } else if (scan.buildContentFiles.has(filePath)) {
+    if (
+      extensionIsMarkdown(path.extname(filePath).toLowerCase()) ||
+      path.extname(filePath).toLowerCase() === '.html'
+    ) {
+      assets.push(
+        ...renderPlainTextPageAsset({
+          filePath,
+          contentDir: scan.contentDir,
+          distDir: outputDir,
+          siteVariables,
+          validInternalTargets: scan.validTargets,
+          assetFiles,
+          literateJavaOutputPaths: scan.literateJavaOutputPaths,
+          dependencyCollector: deps.collector,
+          cachedTraceSourceDir,
+          traceCache,
+          traceToolAvailability,
+        }),
+      );
+    } else if (codeExtensions.includes(ext)) {
+      if (codeEnabled) {
+        assets.push(
+          ...renderCodePageAsset({
+            filePath,
+            contentDir: scan.contentDir,
+            distDir: outputDir,
+            siteVariables,
+            assetFiles,
+            dependencyCollector: deps.collector,
+          }),
+        );
+      }
+      assets.push(
+        ...renderCopiedContentAsset({
+          filePath,
+          contentDir: scan.contentDir,
+          siteVariables,
+        }),
+      );
+    }
+  } else if (!scan.processedExts.has(ext)) {
+    assets.push(...createRawContentAsset(filePath, scan.contentDir));
+  }
+
+  const outputs = collectSourceOutputs(
+    assets,
+    deps.generatedOutputPaths,
+    outputDir,
+  );
+  if (persistOutputs) {
+    writeAssets(outputDir, outputs);
+  }
+
+  return {
+    sourcePath: filePath,
+    kind: 'content',
+    outputs,
+    partialDeps: deps.partials,
+    traceDeps: deps.traceFiles,
+    internalTargets: deps.internalTargets,
+    generatedOutputPaths: deps.generatedOutputPaths,
+    authorKey: deps.authorKey,
+  };
+}
+
+export function createPublicRecord(
+  filePath: string,
+  publicDir: string,
+): TadaSourceRecord {
+  const relPath = toPosix(path.relative(publicDir, filePath));
+  return {
+    sourcePath: filePath,
+    kind: 'public',
+    outputs: new Map([[relPath, fs.readFileSync(filePath)]]),
+    partialDeps: new Set(),
+    traceDeps: new Set(),
+    internalTargets: new Set(),
+    generatedOutputPaths: new Set(),
+  };
+}

package/build/watch/runtime.ts

@@ -0,0 +1,143 @@
+import path from 'path';
+import WebSocket, { WebSocketServer } from 'ws';
+import { B } from '../colors';
+import { makeLogger, printFlair } from '../log';
+import { startServer } from '../serve';
+import { WatchPagefindRunner } from '../pagefind';
+import type { TadaBuildMeta } from './compiler-types';
+import type { TadaSnapshot } from './snapshot';
+import type { WatchLifecycleEvent } from '../../watch/types';
+
+const log = makeLogger(import.meta.url);
+const wslog = makeLogger('WebSocket');
+
+function describeChange(kind: 'add' | 'change' | 'unlink'): string {
+  if (kind === 'add') {
+    return 'added, rebuilding';
+  }
+  if (kind === 'unlink') {
+    return 'removed, rebuilding';
+  }
+  return 'changed, rebuilding';
+}
+
+export class TadaWatchRuntime {
+  private wsPort: number;
+  private httpPort: number | undefined;
+  private distDir: string;
+  private wss: WebSocketServer | 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;
+    this.httpPort = httpPort;
+    this.distDir = distDir;
+    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) {
+      return;
+    }
+    for (const client of this.wss.clients) {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(message);
+      }
+    }
+  }
+
+  private ensureServerStarted(): void {
+    if (this.serveStarted) {
+      return;
+    }
+    this.serveStarted = true;
+    startServer({ port: this.httpPort, distDir: this.distDir });
+  }
+
+  async onEvent(
+    event: WatchLifecycleEvent<TadaSnapshot, TadaBuildMeta>,
+  ): Promise<void> {
+    switch (event.kind) {
+      case 'build-started':
+        if (!event.initial) {
+          for (const change of event.batch?.changes || []) {
+            log.event`${B`${path.basename(change.path)}`} ${describeChange(change.kind)}`;
+          }
+          this.broadcast('rebuilding');
+        }
+        return;
+      case 'build-succeeded': {
+        const recoveredFromFailure = this.lastBuildFailed;
+        this.lastBuildFailed = false;
+        printFlair();
+        this.ensureServerStarted();
+        if (!event.initial && (event.changed || recoveredFromFailure)) {
+          this.broadcast('reload');
+        }
+        if (event.meta && event.changed) {
+          if (event.meta.siteVariables.features.search !== false) {
+            const siteVariablesKey = JSON.stringify(event.meta.siteVariables);
+            if (
+              !this.pagefindRunner ||
+              this.pagefindSiteVariablesKey !== siteVariablesKey
+            ) {
+              this.pagefindRunner = new WatchPagefindRunner(
+                event.meta.siteVariables,
+              );
+              this.pagefindSiteVariablesKey = siteVariablesKey;
+            }
+            this.pagefindRunner.update(
+              this.distDir,
+              event.meta.htmlAssetsByPath,
+            );
+            setImmediate(() => this.pagefindRunner!.run());
+          } else {
+            this.pagefindRunner = undefined;
+            this.pagefindSiteVariablesKey = undefined;
+          }
+        }
+        return;
+      }
+      case 'build-failed':
+        this.lastBuildFailed = true;
+        for (const diagnostic of event.diagnostics) {
+          log.error`${diagnostic.message}`;
+        }
+        return;
+      case 'watching':
+        log.info`Watching for changes...`;
+        return;
+      case 'build-skipped':
+        return;
+    }
+  }
+}