@abreen/tada 1.11.3 → 1.13.2

package/build/watch/snapshot.ts

@@ -1,27 +1,19 @@
 import fs from 'fs';
 import path from 'path';
+import { normalizeOutputPath } from '../util';
 import {
-  getContentDir,
-  getDistDir,
-  getPublicDir,
-  normalizeOutputPath,
-  shouldSkipContentFile,
-  toPosix,
-} from '../util';
-import { getExtensionToShikiLanguage } from '../site-variables';
-import {
-  extensionIsMarkdown,
-  getProcessedExtensions,
-  isLiterateJava,
-  isPartial,
-} from '../utils/file-types';
-import type { ChangeBatch } from '../../watch/types';
-import type { Asset, SiteVariables } from '../types';
+  type TadaProjectScan,
+  assertNoOutputPathConflicts,
+  scanProject,
+  updateProjectScan,
+} from '../source-model';
+import type { Asset, HtmlOutputAnalysis, SiteVariables } from '../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>;
@@ -53,39 +45,6 @@ export interface TadaSnapshot {
   validTargets: Set<string>;
 }
 
-export interface TadaProjectScan {
-  contentDir: string;
-  publicDir: string;
-  distDir: string;
-  contentFiles: Set<string>;
-  buildContentFiles: Set<string>;
-  publicFiles: Set<string>;
-  validTargets: Set<string>;
-  literateJavaOutputPaths: Set<string>;
-  processedExts: Set<string>;
-  contentOwners: Map<string, string>;
-  publicOwners: Map<string, string>;
-  sourceOutputPaths: Map<string, Set<string>>;
-  sourceTargetPaths: Map<string, Set<string>>;
-}
-
-function walkFiles(dir: string): string[] {
-  if (!fs.existsSync(dir)) {
-    return [];
-  }
-
-  return fs.readdirSync(dir, { withFileTypes: true }).flatMap(entry => {
-    const fullPath = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      return walkFiles(fullPath);
-    }
-    if (entry.isFile()) {
-      return [fullPath];
-    }
-    return [];
-  });
-}
-
 function buildReverseMap(
   records: Iterable<TadaSourceRecord>,
   selector: (record: TadaSourceRecord) => Iterable<string>,
@@ -104,139 +63,6 @@ function buildReverseMap(
   return reverse;
 }
 
-function getProcessedExts(siteVariables: SiteVariables): Set<string> {
-  return new Set(
-    getProcessedExtensions(
-      Object.keys(getExtensionToShikiLanguage(siteVariables)),
-    ).map(ext => ext.toLowerCase()),
-  );
-}
-
-function isBuildContentSource(
-  filePath: string,
-  processedExts: Set<string>,
-): boolean {
-  const ext = path.extname(filePath).slice(1).toLowerCase();
-  if (!processedExts.has(ext) || isPartial(filePath)) {
-    return false;
-  }
-  return !shouldSkipContentFile(filePath);
-}
-
-function addGeneratedRouteAliases(
-  targets: Set<string>,
-  outputPath: string,
-): void {
-  const normalizedPath = normalizeOutputPath(outputPath);
-  targets.add(normalizedPath);
-  if (!normalizedPath.endsWith('/index.html')) {
-    return;
-  }
-  const base = normalizedPath.slice(0, -'index.html'.length);
-  targets.add(base);
-  if (base.endsWith('/') && base.length > 1) {
-    targets.add(base.slice(0, -1));
-  }
-}
-
-function getContentOutputPathsForSource({
-  contentDir,
-  filePath,
-  processedExts,
-  buildContent,
-}: {
-  contentDir: string;
-  filePath: string;
-  processedExts: Set<string>;
-  buildContent: boolean;
-}): Set<string> {
-  const relPath = toPosix(path.relative(contentDir, filePath));
-  const parsed = path.parse(relPath);
-  const ext = path.extname(filePath).slice(1).toLowerCase();
-  const outputs = new Set<string>();
-
-  if (!processedExts.has(ext)) {
-    outputs.add(relPath);
-    return outputs;
-  }
-
-  if (!buildContent) {
-    return outputs;
-  }
-
-  if (isLiterateJava(filePath)) {
-    outputs.add(toPosix(path.join(parsed.dir, `${parsed.name}.html`)));
-    outputs.add(toPosix(path.join(parsed.dir, parsed.name)));
-    return outputs;
-  }
-
-  if (
-    extensionIsMarkdown(parsed.ext.toLowerCase()) ||
-    parsed.ext.toLowerCase() === '.html'
-  ) {
-    outputs.add(toPosix(path.join(parsed.dir, `${parsed.name}.html`)));
-    return outputs;
-  }
-
-  outputs.add(relPath);
-  outputs.add(`${relPath}.html`);
-  return outputs;
-}
-
-function getTargetPathsForSource({
-  kind,
-  rootDir,
-  filePath,
-  processedExts,
-  buildContent,
-}: {
-  kind: 'content' | 'public';
-  rootDir: string;
-  filePath: string;
-  processedExts: Set<string>;
-  buildContent: boolean;
-}): Set<string> {
-  const targets = new Set<string>();
-  const relPath = toPosix(path.relative(rootDir, filePath));
-
-  if (kind === 'public') {
-    targets.add(normalizeOutputPath(`/${relPath}`));
-    return targets;
-  }
-
-  const ext = path.extname(filePath).slice(1).toLowerCase();
-  if (!processedExts.has(ext)) {
-    targets.add(normalizeOutputPath(`/${relPath}`));
-    return targets;
-  }
-
-  if (!buildContent || isPartial(filePath)) {
-    return targets;
-  }
-
-  const parsed = path.parse(relPath);
-  const subPath = toPosix(path.join(parsed.dir, parsed.name));
-
-  if (isLiterateJava(filePath)) {
-    const javaSubPath = toPosix(path.join(parsed.dir, parsed.name));
-    addGeneratedRouteAliases(targets, `/${javaSubPath}.html`);
-    targets.add(normalizeOutputPath(`/${javaSubPath}`));
-    return targets;
-  }
-
-  if (
-    extensionIsMarkdown(parsed.ext.toLowerCase()) ||
-    parsed.ext.toLowerCase() === '.html'
-  ) {
-    addGeneratedRouteAliases(targets, `/${subPath}.html`);
-    return targets;
-  }
-
-  addGeneratedRouteAliases(targets, `/${relPath}.html`);
-  targets.add(normalizeOutputPath(`/${relPath}`));
-  return targets;
-}
-
 function cloneSetMap(
   source: Map<string, Set<string>>,
 ): Map<string, Set<string>> {
@@ -245,219 +71,6 @@ function cloneSetMap(
   );
 }
 
-export function scanProject(siteVariables: SiteVariables): TadaProjectScan {
-  const contentDir = getContentDir();
-  const publicDir = getPublicDir();
-  const distDir = getDistDir();
-  const processedExts = getProcessedExts(siteVariables);
-  const contentFiles = new Set(walkFiles(contentDir).sort());
-  const publicFiles = new Set(walkFiles(publicDir).sort());
-  const buildContentFiles = new Set<string>();
-  const literateJavaOutputPaths = new Set<string>();
-  const contentOwners = new Map<string, string>();
-  const publicOwners = new Map<string, string>();
-  const sourceOutputPaths = new Map<string, Set<string>>();
-  const sourceTargetPaths = new Map<string, Set<string>>();
-  const validTargets = new Set<string>();
-
-  for (const filePath of contentFiles) {
-    const buildContent = isBuildContentSource(filePath, processedExts);
-    if (buildContent) {
-      buildContentFiles.add(filePath);
-    }
-    if (buildContent && isLiterateJava(filePath)) {
-      const parsed = path.parse(path.relative(contentDir, filePath));
-      literateJavaOutputPaths.add(
-        `/${toPosix(path.join(parsed.dir, parsed.name))}`,
-      );
-    }
-
-    const outputs = getContentOutputPathsForSource({
-      contentDir,
-      filePath,
-      processedExts,
-      buildContent,
-    });
-    sourceOutputPaths.set(filePath, outputs);
-    for (const outputPath of outputs) {
-      contentOwners.set(outputPath, filePath);
-    }
-
-    const targets = getTargetPathsForSource({
-      kind: 'content',
-      rootDir: contentDir,
-      filePath,
-      processedExts,
-      buildContent,
-    });
-    sourceTargetPaths.set(filePath, targets);
-    for (const target of targets) {
-      validTargets.add(target);
-    }
-  }
-
-  for (const filePath of publicFiles) {
-    const relPath = toPosix(path.relative(publicDir, filePath));
-    publicOwners.set(relPath, filePath);
-    sourceOutputPaths.set(filePath, new Set([relPath]));
-    const targets = getTargetPathsForSource({
-      kind: 'public',
-      rootDir: publicDir,
-      filePath,
-      processedExts,
-      buildContent: false,
-    });
-    sourceTargetPaths.set(filePath, targets);
-    for (const target of targets) {
-      validTargets.add(target);
-    }
-  }
-
-  return {
-    contentDir,
-    publicDir,
-    distDir,
-    contentFiles,
-    buildContentFiles,
-    publicFiles,
-    validTargets,
-    literateJavaOutputPaths,
-    processedExts,
-    contentOwners,
-    publicOwners,
-    sourceOutputPaths,
-    sourceTargetPaths,
-  };
-}
-
-export function updateProjectScan(
-  snapshot: TadaSnapshot,
-  batch: ChangeBatch,
-): TadaProjectScan {
-  const contentDir = getContentDir();
-  const publicDir = getPublicDir();
-  const distDir = getDistDir();
-  const contentFiles = new Set(snapshot.contentFiles);
-  const buildContentFiles = new Set(snapshot.buildContentFiles);
-  const publicFiles = new Set(snapshot.publicFiles);
-  const literateJavaOutputPaths = new Set(snapshot.literateJavaOutputPaths);
-  const contentOwners = new Map(snapshot.contentOwners);
-  const publicOwners = new Map(snapshot.publicOwners);
-  const sourceOutputPaths = cloneSetMap(snapshot.sourceOutputPaths);
-  const sourceTargetPaths = cloneSetMap(snapshot.sourceTargetPaths);
-
-  for (const change of batch.changes) {
-    const sourcePath = path.resolve(change.path);
-    const inContent = sourcePath.startsWith(`${contentDir}${path.sep}`);
-    const inPublic = sourcePath.startsWith(`${publicDir}${path.sep}`);
-    if (!inContent && !inPublic) {
-      continue;
-    }
-
-    for (const outputPath of sourceOutputPaths.get(sourcePath) || []) {
-      if (inContent) {
-        contentOwners.delete(outputPath);
-      } else {
-        publicOwners.delete(outputPath);
-      }
-    }
-    sourceOutputPaths.delete(sourcePath);
-    sourceTargetPaths.delete(sourcePath);
-    contentFiles.delete(sourcePath);
-    buildContentFiles.delete(sourcePath);
-    publicFiles.delete(sourcePath);
-
-    if (inContent && isLiterateJava(sourcePath)) {
-      const parsed = path.parse(path.relative(contentDir, sourcePath));
-      literateJavaOutputPaths.delete(
-        `/${toPosix(path.join(parsed.dir, parsed.name))}`,
-      );
-    }
-
-    if (!fs.existsSync(sourcePath) || !fs.statSync(sourcePath).isFile()) {
-      continue;
-    }
-
-    if (inContent) {
-      const buildContent = isBuildContentSource(
-        sourcePath,
-        snapshot.processedExts,
-      );
-      contentFiles.add(sourcePath);
-      if (buildContent) {
-        buildContentFiles.add(sourcePath);
-      }
-      if (buildContent && isLiterateJava(sourcePath)) {
-        const parsed = path.parse(path.relative(contentDir, sourcePath));
-        literateJavaOutputPaths.add(
-          `/${toPosix(path.join(parsed.dir, parsed.name))}`,
-        );
-      }
-
-      const outputs = getContentOutputPathsForSource({
-        contentDir,
-        filePath: sourcePath,
-        processedExts: snapshot.processedExts,
-        buildContent,
-      });
-      sourceOutputPaths.set(sourcePath, outputs);
-      for (const outputPath of outputs) {
-        contentOwners.set(outputPath, sourcePath);
-      }
-
-      sourceTargetPaths.set(
-        sourcePath,
-        getTargetPathsForSource({
-          kind: 'content',
-          rootDir: contentDir,
-          filePath: sourcePath,
-          processedExts: snapshot.processedExts,
-          buildContent,
-        }),
-      );
-      continue;
-    }
-
-    const relPath = toPosix(path.relative(publicDir, sourcePath));
-    publicFiles.add(sourcePath);
-    publicOwners.set(relPath, sourcePath);
-    sourceOutputPaths.set(sourcePath, new Set([relPath]));
-    sourceTargetPaths.set(
-      sourcePath,
-      getTargetPathsForSource({
-        kind: 'public',
-        rootDir: publicDir,
-        filePath: sourcePath,
-        processedExts: snapshot.processedExts,
-        buildContent: false,
-      }),
-    );
-  }
-
-  const validTargets = new Set<string>();
-  for (const targets of sourceTargetPaths.values()) {
-    for (const target of targets) {
-      validTargets.add(target);
-    }
-  }
-
-  return {
-    contentDir,
-    publicDir,
-    distDir,
-    contentFiles,
-    buildContentFiles,
-    publicFiles,
-    validTargets,
-    literateJavaOutputPaths,
-    processedExts: snapshot.processedExts,
-    contentOwners,
-    publicOwners,
-    sourceOutputPaths,
-    sourceTargetPaths,
-  };
-}
-
 export function collectOutputOwners(snapshot: {
   contentRecords: Map<string, TadaSourceRecord>;
   publicRecords: Map<string, TadaSourceRecord>;
@@ -545,13 +158,6 @@ export function createSnapshot({
   };
 }
 
-export function assertNoOutputPathConflicts(scan: TadaProjectScan): string[] {
-  const conflicts = [...scan.contentOwners.keys()].filter(relPath =>
-    scan.publicOwners.has(relPath),
-  );
-  return conflicts.sort();
-}
-
 export function collectSourceOutputs(
   assets: Asset[],
   generatedOutputPaths: Set<string>,
@@ -567,6 +173,28 @@ export function collectSourceOutputs(
   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;
+}
+
 export function collectHtmlAssetsByPath(
   contentRecords: Map<string, TadaSourceRecord>,
 ): Map<string, string> {
@@ -581,6 +209,26 @@ export function collectHtmlAssetsByPath(
   return htmlAssetsByPath;
 }
 
+export function collectHtmlAnalysisByPath(
+  contentRecords: Map<string, TadaSourceRecord>,
+): Map<string, HtmlOutputAnalysis> {
+  const htmlAnalysisByPath = new Map<string, HtmlOutputAnalysis>();
+  for (const record of contentRecords.values()) {
+    for (const [outputPath, analysis] of record.htmlAnalysisByOutputPath ||
+      new Map<string, HtmlOutputAnalysis>()) {
+      htmlAnalysisByPath.set(outputPath, cloneHtmlOutputAnalysis(analysis));
+    }
+  }
+  return htmlAnalysisByPath;
+}
+
 export function normalizeInternalTarget(target: string): string {
   return normalizeOutputPath(target);
 }
+
+export {
+  assertNoOutputPathConflicts,
+  scanProject,
+  updateProjectScan,
+  type TadaProjectScan,
+};

package/build/watch/validation.ts

@@ -1,6 +1,6 @@
 import { B } from '../colors';
 import { makeLogger } from '../log';
-import { json } from '../templates';
+import { config, getConfigFileName } from '../templates';
 import { validateConfigLinks } from '../validate-config-links';
 import type { WatchDiagnostic } from '../../watch/types';
 import { assertNoOutputPathConflicts, type TadaProjectScan } from './snapshot';
@@ -27,10 +27,13 @@ export function validateConfig(scan: TadaProjectScan): WatchDiagnostic[] {
   ];
 }
 
-export function validateJsonLinks(
+export function validateProjectConfigLinks(
   validTargets: Set<string>,
 ): WatchDiagnostic[] {
   return diagnosticsFromMessages(
-    validateConfigLinks(validTargets, json('nav.json'), json('authors.json')),
+    validateConfigLinks(validTargets, config('nav'), config('authors'), {
+      navFileName: getConfigFileName('nav'),
+      authorsFileName: getConfigFileName('authors'),
+    }),
   );
 }

package/build/watch-reachability-state.ts

@@ -1,6 +1,7 @@
-import { collectDirectSiteAssetLinks } from './reachability';
+import { collectOutgoingHtmlAssetPaths } from './reachability';
+import type { HtmlOutputAnalysis } from './types';
 
-type ReadHtmlForAsset = (assetPath: string) => string;
+type ReadAnalysisForAsset = (assetPath: string) => HtmlOutputAnalysis;
 
 function cloneSet(values: Iterable<string> | undefined): Set<string> {
   return new Set(values || []);
@@ -9,24 +10,19 @@ function cloneSet(values: Iterable<string> | undefined): Set<string> {
 interface IncrementalOptions {
   changedAssetPaths?: Iterable<string>;
   removedAssetPaths?: Iterable<string>;
-  readHtmlForAsset: ReadHtmlForAsset;
+  readAnalysisForAsset: ReadAnalysisForAsset;
 }
 
 class WatchReachabilityState {
   private rootPath: string;
-  private basePath: string;
   private knownAssets: Set<string>;
   private outgoingBySource: Map<string, Set<string>>;
   private incomingByTarget: Map<string, Set<string>>;
   private reachable: Set<string>;
   private initialized: boolean;
 
-  constructor({
-    rootPath = 'index.html',
-    basePath = '/',
-  }: { rootPath?: string; basePath?: string } = {}) {
+  constructor({ rootPath = 'index.html' }: { rootPath?: string } = {}) {
     this.rootPath = rootPath;
-    this.basePath = basePath;
     this.knownAssets = new Set();
     this.outgoingBySource = new Map();
     this.incomingByTarget = new Map();
@@ -66,7 +62,7 @@ class WatchReachabilityState {
     this.rebuildIncomingByTarget();
   }
 
-  rebuild(readHtmlForAsset: ReadHtmlForAsset): void {
+  rebuild(readAnalysisForAsset: ReadAnalysisForAsset): void {
     if (!this.knownAssets.has(this.rootPath)) {
       throw new Error(`Pagefind reachability root not found: ${this.rootPath}`);
     }
@@ -79,7 +75,7 @@ class WatchReachabilityState {
     for (const sourcePath of knownAssetPaths) {
       const outgoingPaths = this.readOutgoingPaths(
         sourcePath,
-        readHtmlForAsset,
+        readAnalysisForAsset,
       );
       this.outgoingBySource.set(sourcePath, outgoingPaths);
       this.addIncomingEdges(sourcePath, outgoingPaths);
@@ -92,10 +88,10 @@ class WatchReachabilityState {
   applyIncremental({
     changedAssetPaths,
     removedAssetPaths,
-    readHtmlForAsset,
+    readAnalysisForAsset,
   }: IncrementalOptions): void {
     if (!this.initialized) {
-      this.rebuild(readHtmlForAsset);
+      this.rebuild(readAnalysisForAsset);
       return;
     }
 
@@ -136,7 +132,10 @@ class WatchReachabilityState {
 
     const changedAssetList = [...normalizedChanged].sort();
     for (const assetPath of changedAssetList) {
-      const outgoingPaths = this.readOutgoingPaths(assetPath, readHtmlForAsset);
+      const outgoingPaths = this.readOutgoingPaths(
+        assetPath,
+        readAnalysisForAsset,
+      );
       this.replaceOutgoing(assetPath, outgoingPaths);
     }
 
@@ -196,20 +195,14 @@ class WatchReachabilityState {
 
   private readOutgoingPaths(
     sourcePath: string,
-    readHtmlForAsset: ReadHtmlForAsset,
+    readAnalysisForAsset: ReadAnalysisForAsset,
   ): Set<string> {
     if (!this.knownAssets.has(sourcePath)) {
       return new Set();
     }
 
-    const html = readHtmlForAsset(sourcePath);
-    const { htmlAssetPaths } = collectDirectSiteAssetLinks({
-      html,
-      fromAssetPath: sourcePath,
-      knownAssets: this.knownAssets,
-      basePath: this.basePath,
-    });
-    return new Set(htmlAssetPaths);
+    const analysis = readAnalysisForAsset(sourcePath);
+    return new Set(collectOutgoingHtmlAssetPaths(analysis, this.knownAssets));
   }
 
   private addIncomingEdges(

package/build/watch-reload-client.ts

@@ -1,4 +1,8 @@
-declare const __WEBSOCKET_PORT__: number;
+import {
+  WATCH_RELOAD_MESSAGE_REBUILDING,
+  WATCH_RELOAD_MESSAGE_RELOAD,
+  WATCH_RELOAD_PATH,
+} from './watch/reload';
 
 (function () {
   function setLoading(loading: boolean): void {
@@ -16,17 +20,20 @@ body.loading-cursor * {
 }`;
   document.head.appendChild(style);
 
-  const ws = new WebSocket(`ws://localhost:${__WEBSOCKET_PORT__}`);
+  const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+  const ws = new WebSocket(
+    `${protocol}//${window.location.host}${WATCH_RELOAD_PATH}`,
+  );
 
   ws.onopen = () => {
     console.log('[watch-reload] connected to watcher');
   };
 
   ws.onmessage = event => {
-    if (event.data === 'rebuilding') {
+    if (event.data === WATCH_RELOAD_MESSAGE_REBUILDING) {
       console.log('[watch-reload] Rebuilding...');
       setLoading(true);
-    } else if (event.data === 'reload') {
+    } else if (event.data === WATCH_RELOAD_MESSAGE_RELOAD) {
       console.log('[watch-reload] Reloading page...');
       setLoading(false);
       window.history.scrollRestoration = 'auto';

package/init/content/index.md

@@ -14,7 +14,7 @@ This is an example site built with <%= page.toolName %>.
 ## Getting started
 
 Edit the files in `content/` to add your own pages. To configure the nav,
-update `nav.json`. Update `authors.json` with your information, or delete it
+update `nav.yaml`. Update `authors.yaml` with your information, or delete it
 if you won't use the `author` front matter field.
 
 See the [Markdown examples page](/markdown.html) for syntax examples.