@abreen/tada 1.11.3 → 1.13.2

package/build/config-loader.ts

@@ -0,0 +1,159 @@
+import fs from 'fs';
+import _ from 'lodash';
+import {
+  resolveProjectConfigFile,
+  resolveSiteConfigFile,
+  type ConfigName,
+  type ProjectConfigName,
+  type ResolvedProjectConfigFile,
+  type SiteConfigName,
+  type SiteEnv,
+} from './config-files';
+import type { SiteVariables } from './types';
+
+export interface LoadedProjectConfigFile<
+  T = unknown,
+  Name extends ConfigName = ConfigName,
+> extends ResolvedProjectConfigFile<Name> {
+  value: T;
+}
+
+interface ConfigTemplateContext {
+  vars: Record<string, unknown>;
+  site: SiteVariables;
+}
+
+const EXACT_INTERPOLATION_RE = /^\s*<%=\s*([\s\S]+?)\s*%>\s*$/;
+
+export function parseConfigText(text: string, fileName: string): unknown {
+  try {
+    return Bun.YAML.parse(text);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`${fileName}: ${message}`, { cause: error });
+  }
+}
+
+function getTemplateErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function renderConfigTemplateString(
+  value: string,
+  context: ConfigTemplateContext,
+  fileName: string,
+): string {
+  try {
+    return _.template(value)(context);
+  } catch (error) {
+    throw new Error(
+      `${fileName}: Lodash template error in config: ${getTemplateErrorMessage(error)}`,
+      { cause: error },
+    );
+  }
+}
+
+function evaluateConfigTemplateExpression(
+  expression: string,
+  context: ConfigTemplateContext,
+  fileName: string,
+): unknown {
+  let captured: unknown;
+
+  try {
+    _.template(`<% __capture(( ${expression} )); %>`)({
+      ...context,
+      __capture(value: unknown) {
+        captured = value;
+      },
+    });
+  } catch (error) {
+    throw new Error(
+      `${fileName}: Lodash template error in config: ${getTemplateErrorMessage(error)}`,
+      { cause: error },
+    );
+  }
+
+  return captured;
+}
+
+function interpolateConfigValue(
+  value: unknown,
+  context: ConfigTemplateContext,
+  fileName: string,
+): unknown {
+  if (typeof value === 'string') {
+    if (!value.includes('<%')) {
+      return value;
+    }
+
+    const exactInterpolation = value.match(EXACT_INTERPOLATION_RE);
+    if (exactInterpolation) {
+      return evaluateConfigTemplateExpression(
+        exactInterpolation[1],
+        context,
+        fileName,
+      );
+    }
+
+    return renderConfigTemplateString(value, context, fileName);
+  }
+
+  if (Array.isArray(value)) {
+    return value.map(item => interpolateConfigValue(item, context, fileName));
+  }
+
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, item]) => [
+        key,
+        interpolateConfigValue(item, context, fileName),
+      ]),
+    );
+  }
+
+  return value;
+}
+
+export function loadResolvedConfigFile<
+  T = unknown,
+  Name extends ConfigName = ConfigName,
+>(
+  resolved: ResolvedProjectConfigFile<Name>,
+  {
+    interpolate = false,
+    siteVariables,
+  }: { interpolate?: boolean; siteVariables?: SiteVariables } = {},
+): LoadedProjectConfigFile<T, Name> {
+  const rawText = fs.readFileSync(resolved.filePath, 'utf-8');
+  const parsed = parseConfigText(rawText, resolved.fileName);
+  const value = interpolate
+    ? interpolateConfigValue(
+        parsed,
+        { vars: siteVariables?.vars || {}, site: siteVariables! },
+        resolved.fileName,
+      )
+    : parsed;
+
+  return { ...resolved, value: value as T };
+}
+
+export function loadSiteConfig(
+  projectDir: string,
+  env: SiteEnv,
+): LoadedProjectConfigFile<unknown, SiteConfigName> {
+  const resolved = resolveSiteConfigFile(projectDir, env);
+  return loadResolvedConfigFile(resolved);
+}
+
+export function loadProjectConfig(
+  projectDir: string,
+  name: ProjectConfigName,
+  siteVariables: SiteVariables,
+): LoadedProjectConfigFile<unknown, ProjectConfigName> | undefined {
+  const resolved = resolveProjectConfigFile(projectDir, name);
+  if (!resolved) {
+    return undefined;
+  }
+  return loadResolvedConfigFile(resolved, { interpolate: true, siteVariables });
+}

package/build/copy.ts

@@ -80,86 +80,3 @@ export function copyContentAssets(
   }
   return contentAssetRelPaths;
 }
-
-function copySingleFile(
-  sourceDir: string,
-  distDir: string,
-  filePath: string,
-  sourceLabel: string,
-  conflictLabel: string,
-  conflictSet?: Set<string>,
-): void {
-  const rel = toPosix(path.relative(sourceDir, filePath));
-  if (conflictSet?.has(rel)) {
-    log.error`${sourceLabel}/${B`${rel}`} conflicts with ${conflictLabel}/${B`${rel}`}`;
-    throw new Error(
-      `${sourceLabel}/${rel} and ${conflictLabel}/${rel} have the same path`,
-    );
-  }
-  const dest = path.join(distDir, rel);
-  fs.mkdirSync(path.dirname(dest), { recursive: true });
-  fs.copyFileSync(filePath, dest);
-  log.info`Copying ${sourceLabel} file ${B`${rel}`}`;
-}
-
-export function deleteOutputPath(distDir: string, relPath: string): void {
-  const root = path.resolve(distDir);
-  const target = path.resolve(distDir, relPath);
-  const relative = path.relative(root, target);
-  if (
-    relative.startsWith('..') ||
-    path.isAbsolute(relative) ||
-    relative.length === 0
-  ) {
-    throw new Error(`refusing to delete path outside dist/: ${relPath}`);
-  }
-
-  fs.rmSync(target, { force: true });
-  log.info`Removing output ${B`${toPosix(relPath)}`}`;
-
-  let currentDir = path.dirname(target);
-  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);
-  }
-}
-
-export function copyPublicFile(
-  publicDir: string,
-  distDir: string,
-  filePath: string,
-  contentAssetRelPaths?: Set<string>,
-): void {
-  copySingleFile(
-    publicDir,
-    distDir,
-    filePath,
-    'public',
-    'content',
-    contentAssetRelPaths,
-  );
-}
-
-export function copyContentFile(
-  contentDir: string,
-  distDir: string,
-  filePath: string,
-  publicRelPaths?: Set<string>,
-): void {
-  copySingleFile(
-    contentDir,
-    distDir,
-    filePath,
-    'content',
-    'public',
-    publicRelPaths,
-  );
-}

package/build/generate-content-assets.ts

@@ -1,39 +1,33 @@
 import fs from 'fs';
 import path from 'path';
 import { makeLogger } from './log';
-import {
-  getExtensionToShikiLanguage,
-  getRuntimeBundledShikiLanguages,
-} from './site-variables';
+import { getRuntimeBundledShikiLanguages } from './site-variables';
+import { createContentRecord } from './source-records';
 import { validateConfigLinks } from './validate-config-links';
-import { json } from './templates';
+import { config, getConfigFileName } from './templates';
 import { initHighlighter } from './utils/shiki-highlighter';
-import {
-  getBuildContentFiles,
-  getContentDir,
-  getValidInternalTargets,
-  renderCodePageAsset,
-  renderCopiedContentAsset,
-  renderLiterateJavaPageAsset,
-  renderPlainTextPageAsset,
-} from './util';
-import { isLiterateJava } from './utils/file-types';
 import { checkTraceToolAvailability, isTraceSourceFile } from './utils/trace';
-import { toPosix } from './utils/paths';
 import type {
   SiteVariables,
-  Asset,
   ContentRenderOptions,
   ContentRenderResult,
+  HtmlOutputAnalysis,
   TraceToolAvailability,
   WatchState,
 } from './types';
+import type { TadaSourceRecord } from './watch/snapshot';
 
 const log = makeLogger(import.meta.url);
 
+function cloneHtmlOutputAnalysis(
+  analysis: HtmlOutputAnalysis,
+): HtmlOutputAnalysis {
+  return { outgoingTargets: new Set(analysis.outgoingTargets) };
+}
+
 export class ContentRenderer {
   private siteVariables: SiteVariables;
-  private sourceFileCache: Map<string, Asset[]>;
+  private sourceFileCache: Map<string, TadaSourceRecord>;
   private lastBuildFiles: Set<string>;
   private javacAvailable: boolean | undefined;
   private traceToolAvailability: TraceToolAvailability | undefined;
@@ -53,8 +47,8 @@ export class ContentRenderer {
     this.lastBuildFiles = new Set();
   }
 
-  private getCachedAssets(filePath: string): Asset[] {
-    return this.sourceFileCache.get(filePath) ?? [];
+  private getCachedRecord(filePath: string): TadaSourceRecord | undefined {
+    return this.sourceFileCache.get(filePath);
   }
 
   async initHighlighter(): Promise<void> {
@@ -91,124 +85,47 @@ export class ContentRenderer {
     return dirtySourceFiles;
   }
 
-  isCopiedAssetSource(filePath: string): boolean {
-    const ext = path.extname(filePath).toLowerCase();
-    const codeExtensions = getExtensionToShikiLanguage(this.siteVariables);
-    return Object.prototype.hasOwnProperty.call(codeExtensions, ext.slice(1));
-  }
-
-  renderSourceAssets(
-    filePath: string,
-    contentDir: string,
-    distDir: string,
-    validInternalTargets: Set<string>,
-    assetFiles: string[],
-    literateJavaOutputPaths: Set<string>,
-  ): Asset[] {
-    const ext = path.extname(filePath).toLowerCase();
-    const assets: Asset[] = [];
-
-    if (isLiterateJava(filePath)) {
-      assets.push(
-        ...renderLiterateJavaPageAsset({
-          filePath,
-          contentDir,
-          distDir,
-          siteVariables: this.siteVariables,
-          assetFiles,
-          skipExecution: !this.javacAvailable,
-          validInternalTargets,
-          literateJavaOutputPaths,
-        }),
-      );
-      return assets;
-    }
-
-    if (ext === '.html' || ext === '.md' || ext === '.markdown') {
-      assets.push(
-        ...renderPlainTextPageAsset({
-          filePath,
-          contentDir,
-          distDir,
-          siteVariables: this.siteVariables,
-          validInternalTargets,
-          assetFiles,
-          literateJavaOutputPaths,
-          traceCache: this.traceCache,
-          traceToolAvailability: this.traceToolAvailability,
-        }),
-      );
-      return assets;
-    }
-
-    const codeExtensions = getExtensionToShikiLanguage(this.siteVariables);
-    if (ext.slice(1) in codeExtensions) {
-      assets.push(
-        ...renderCodePageAsset({
-          filePath,
-          contentDir,
-          distDir,
-          siteVariables: this.siteVariables,
-          validInternalTargets,
-          assetFiles,
-          literateJavaOutputPaths,
-        }),
-      );
-    }
-
-    return assets;
-  }
-
-  renderCopiedSourceAssets(filePath: string, contentDir: string): Asset[] {
-    if (!this.isCopiedAssetSource(filePath)) {
-      return [];
-    }
-
-    return renderCopiedContentAsset({
-      filePath,
-      contentDir,
-      siteVariables: this.siteVariables,
-    });
-  }
-
   updateSourceCache(
     filePath: string,
-    assets: Asset[],
+    record: TadaSourceRecord,
     changedOutputRelPaths: Set<string>,
     removedOutputRelPaths: Set<string>,
     changedHtmlAssetPaths: Set<string>,
     removedHtmlAssetPaths: Set<string>,
   ): void {
-    const previousAssets = this.getCachedAssets(filePath);
-    const nextAssetPaths = new Set(assets.map(asset => asset.assetPath));
+    const previousRecord = this.getCachedRecord(filePath);
+    const nextOutputPaths = new Set(record.outputs.keys());
 
-    for (const asset of previousAssets) {
-      if (nextAssetPaths.has(asset.assetPath)) {
+    for (const outputPath of previousRecord?.outputs.keys() ?? []) {
+      if (nextOutputPaths.has(outputPath)) {
         continue;
       }
-      removedOutputRelPaths.add(asset.assetPath);
-      if (asset.assetPath.endsWith('.html')) {
-        removedHtmlAssetPaths.add(asset.assetPath);
+      removedOutputRelPaths.add(outputPath);
+      if (outputPath.endsWith('.html')) {
+        removedHtmlAssetPaths.add(outputPath);
       }
     }
 
-    for (const asset of assets) {
-      changedOutputRelPaths.add(asset.assetPath);
-      if (asset.assetPath.endsWith('.html')) {
-        changedHtmlAssetPaths.add(asset.assetPath);
+    for (const outputPath of record.outputs.keys()) {
+      changedOutputRelPaths.add(outputPath);
+      if (outputPath.endsWith('.html')) {
+        changedHtmlAssetPaths.add(outputPath);
       }
     }
 
-    this.sourceFileCache.set(filePath, assets);
+    this.sourceFileCache.set(filePath, record);
   }
 
   writeCachedAssets(distDir: string, buildContentFiles: string[]): void {
     for (const filePath of buildContentFiles) {
-      const assets = this.getCachedAssets(filePath);
-      for (const asset of assets) {
-        const outPath = path.join(distDir, asset.assetPath);
+      const record = this.getCachedRecord(filePath);
+      if (!record) {
+        continue;
+      }
+      for (const [outputPath, content] of record.outputs) {
+        const outPath = path.join(distDir, outputPath);
         fs.mkdirSync(path.dirname(outPath), { recursive: true });
-        fs.writeFileSync(outPath, asset.content);
+        fs.writeFileSync(outPath, content);
       }
     }
   }
@@ -223,11 +140,11 @@ export class ContentRenderer {
         continue;
       }
 
-      const previousAssets = this.getCachedAssets(filePath);
-      for (const asset of previousAssets) {
-        removedOutputRelPaths.add(asset.assetPath);
-        if (asset.assetPath.endsWith('.html')) {
-          removedHtmlAssetPaths.add(asset.assetPath);
+      const previousRecord = this.getCachedRecord(filePath);
+      for (const outputPath of previousRecord?.outputs.keys() ?? []) {
+        removedOutputRelPaths.add(outputPath);
+        if (outputPath.endsWith('.html')) {
+          removedHtmlAssetPaths.add(outputPath);
         }
       }
       this.sourceFileCache.delete(filePath);
@@ -237,13 +154,10 @@ export class ContentRenderer {
   processContent({
     distDir,
     assetFiles,
+    scan,
     watchState,
   }: ContentRenderOptions): ContentRenderResult {
-    const contentDir: string = getContentDir();
-    const buildContentFiles: string[] = getBuildContentFiles(
-      contentDir,
-      Object.keys(getExtensionToShikiLanguage(this.siteVariables)),
-    );
+    const buildContentFiles = [...scan.buildContentFiles];
     const buildFileSet = new Set<string>(buildContentFiles);
     const dirtySourceFiles = this.getDirtySourceFiles(
       buildContentFiles,
@@ -253,26 +167,18 @@ export class ContentRenderer {
     const removedOutputRelPaths = new Set<string>();
     const changedHtmlAssetPaths = new Set<string>();
     const removedHtmlAssetPaths = new Set<string>();
-    const validInternalTargets = getValidInternalTargets(
-      contentDir,
-      buildContentFiles,
-      Object.keys(getExtensionToShikiLanguage(this.siteVariables)),
-    );
-    const literateJavaOutputPaths = new Set<string>();
-    for (const filePath of buildContentFiles) {
-      if (isLiterateJava(filePath)) {
-        const parsed = path.parse(path.relative(contentDir, filePath));
-        const javaPath = toPosix(path.join(parsed.dir, parsed.name));
-        literateJavaOutputPaths.add(`/${javaPath}`);
-      }
-    }
+    const validInternalTargets = scan.validTargets;
 
     const errors: Error[] = [];
 
     const configLinkErrors = validateConfigLinks(
       validInternalTargets,
-      json('nav.json'),
-      json('authors.json'),
+      config('nav'),
+      config('authors'),
+      {
+        navFileName: getConfigFileName('nav'),
+        authorsFileName: getConfigFileName('authors'),
+      },
     );
     for (const msg of configLinkErrors) {
       errors.push(new Error(msg));
@@ -298,26 +204,25 @@ export class ContentRenderer {
     }
 
     for (const filePath of dirtySourceFiles) {
-      let assets: Asset[];
+      let record: TadaSourceRecord;
       try {
-        assets = [
-          ...this.renderSourceAssets(
-            filePath,
-            contentDir,
-            distDir,
-            validInternalTargets,
-            assetFiles,
-            literateJavaOutputPaths,
-          ),
-          ...this.renderCopiedSourceAssets(filePath, contentDir),
-        ];
+        record = createContentRecord({
+          filePath,
+          siteVariables: this.siteVariables,
+          scan,
+          assetFiles,
+          outputDir: distDir,
+          traceCache: this.traceCache,
+          traceToolAvailability: this.traceToolAvailability,
+          skipLiterateJavaExecution: !this.javacAvailable,
+        });
       } catch (err) {
         errors.push(err as Error);
         continue;
       }
       this.updateSourceCache(
         filePath,
-        assets,
+        record,
         changedOutputRelPaths,
         removedOutputRelPaths,
         changedHtmlAssetPaths,
@@ -328,13 +233,22 @@ export class ContentRenderer {
     this.writeCachedAssets(distDir, buildContentFiles);
     this.lastBuildFiles = buildFileSet;
 
-    // Collect HTML asset content for Pagefind
+    // Collect HTML asset content and analysis for Pagefind
     const htmlAssetsByPath = new Map<string, string>();
+    const htmlAnalysisByPath = new Map<string, HtmlOutputAnalysis>();
     for (const filePath of buildContentFiles) {
-      const assets = this.getCachedAssets(filePath);
-      for (const asset of assets) {
-        if (asset.assetPath.endsWith('.html')) {
-          htmlAssetsByPath.set(asset.assetPath, asset.content as string);
+      const record = this.getCachedRecord(filePath);
+      if (!record) {
+        continue;
+      }
+      for (const [outputPath, content] of record.outputs) {
+        if (!outputPath.endsWith('.html') || typeof content !== 'string') {
+          continue;
+        }
+        htmlAssetsByPath.set(outputPath, content);
+        const analysis = record.htmlAnalysisByOutputPath?.get(outputPath);
+        if (analysis) {
+          htmlAnalysisByPath.set(outputPath, cloneHtmlOutputAnalysis(analysis));
         }
       }
     }
@@ -345,6 +259,7 @@ export class ContentRenderer {
       removedHtmlAssetPaths,
       removedOutputRelPaths,
       htmlAssetsByPath,
+      htmlAnalysisByPath,
       buildContentFiles,
     };
   }