@abreen/tada 1.1.0 → 1.3.1

package/build/utils/render.ts

@@ -2,31 +2,28 @@ import fs from 'fs';
 import path from 'path';
 import _ from 'lodash';
 import { stripHtml } from 'string-strip-html';
-import { makeLogger } from '../log.js';
-import { B } from '../colors.js';
-import createGlobals from '../globals.js';
-import { render, json } from '../templates.js';
+import { isFeatureEnabled } from '../features';
+import { makeLogger } from '../log';
+import { B } from '../colors';
+import createGlobals from '../globals';
+import { render, json } from '../templates';
 import {
   extractJavaMethodToc,
   renderCodeSegment,
   renderCodeWithComments,
-} from './code.js';
-import { extensionIsMarkdown } from './file-types.js';
-import {
-  createApplyBasePath,
-  normalizeOutputPath,
-  getDistDir,
-} from './paths.js';
-import { parseFrontMatterAndContent } from './front-matter.js';
-import { createMarkdown } from './markdown.js';
-import { generateTocHtml, generateCodeTocHtml } from '../toc-plugin.js';
+} from './code';
+import { extensionIsMarkdown } from './file-types';
+import { createApplyBasePath, normalizeOutputPath } from './paths';
+import { parseFrontMatterAndContent } from './front-matter';
+import { createMarkdown } from './markdown';
+import { generateTocHtml, generateCodeTocHtml } from '../toc-plugin';
 import {
   parseLiterateJava,
   hasMainMethod,
   deriveClassName,
   compileJavaSource,
   executeLiterateJava,
-} from './literate-java.js';
+} from './literate-java';
 import type {
   Asset,
   SiteVariables,
@@ -34,7 +31,7 @@ import type {
   RenderCodePageOptions,
   RenderLiterateJavaOptions,
   RenderCopiedContentOptions,
-} from '../types.js';
+} from '../types';
 
 const log = makeLogger(__filename);
 
@@ -112,6 +109,7 @@ export function injectAssetTags(
   html: string,
   assetFiles: string[],
   applyBasePath: (subPath: string) => string,
+  distDir: string,
 ): string {
   const jsAssets = assetFiles.filter(f => f.endsWith('.js'));
   const cssAssets = assetFiles.filter(f => f.endsWith('.css'));
@@ -121,8 +119,6 @@ export function injectAssetTags(
     .join('');
   const criticalAssets = cssAssets.filter(f => f.includes('critical.bundle.'));
   const asyncAssets = cssAssets.filter(f => !f.includes('critical.bundle.'));
-
-  const distDir = getDistDir();
   const criticalTags = criticalAssets
     .map(asset => {
       const css = fs.readFileSync(path.join(distDir, asset), 'utf-8');
@@ -131,9 +127,7 @@ export function injectAssetTags(
     .join('');
   const asyncLinkTags = asyncAssets
     .map(
-      asset =>
-        `<link href="${applyBasePath('/' + asset)}" rel="stylesheet" media="print" onload="this.media='all'">` +
-        `<noscript><link href="${applyBasePath('/' + asset)}" rel="stylesheet"></noscript>`,
+      asset => `<link href="${applyBasePath('/' + asset)}" rel="stylesheet">`,
     )
     .join('');
 
@@ -142,6 +136,15 @@ export function injectAssetTags(
     .replace('</head>', `${scriptTags}</head>`);
 }
 
+export function injectKatexStylesheet(
+  html: string,
+  applyBasePath: (subPath: string) => string,
+): string {
+  const href = applyBasePath('/katex/katex.min.css');
+  const tag = `<link href="${href}" rel="stylesheet">`;
+  return html.replace('<head>', `<head>${tag}`);
+}
+
 function toContentAssetPath(contentDir: string, filePath: string): string {
   return path
     .relative(contentDir, filePath)
@@ -152,6 +155,7 @@ function toContentAssetPath(contentDir: string, filePath: string): string {
 export function renderPlainTextPageAsset({
   filePath,
   contentDir,
+  distDir,
   siteVariables,
   validInternalTargets,
   assetFiles,
@@ -190,11 +194,14 @@ export function renderPlainTextPageAsset({
     subPath,
   });
 
-  const html = injectAssetTags(
-    render(`${pageVariables.template}.html`, templateParameters) as string,
-    assetFiles,
-    applyBasePath,
-  );
+  const templateHtml = render(
+    `${pageVariables.template}.html`,
+    templateParameters,
+  ) as string;
+  let html = injectAssetTags(templateHtml, assetFiles, applyBasePath, distDir);
+  if (templateHtml.includes('class="katex"')) {
+    html = injectKatexStylesheet(html, applyBasePath);
+  }
 
   return [
     {
@@ -207,6 +214,7 @@ export function renderPlainTextPageAsset({
 export function renderCodePageAsset({
   filePath,
   contentDir,
+  distDir,
   siteVariables,
   assetFiles,
 }: RenderCodePageOptions): Asset[] {
@@ -247,6 +255,7 @@ export function renderCodePageAsset({
     render('code.html', templateParameters) as string,
     assetFiles,
     applyBasePath,
+    distDir,
   );
 
   return [
@@ -288,10 +297,9 @@ function renderPlainTextContent(
       filePath,
       sourceUrlPath,
       validTargets: validInternalTargets,
-      codeExtensions:
-        siteVariables.features?.code === false
-          ? []
-          : Object.keys(siteVariables.codeLanguages!),
+      codeExtensions: isFeatureEnabled(siteVariables, 'code')
+        ? Object.keys(siteVariables.codeLanguages!)
+        : [],
     },
   });
 
@@ -381,6 +389,7 @@ export function stripHtmlComments(str: string): string {
 export function renderLiterateJavaPageAsset({
   filePath,
   contentDir,
+  distDir,
   siteVariables,
   assetFiles,
   skipExecution,
@@ -403,6 +412,9 @@ export function renderLiterateJavaPageAsset({
 
   validateFrontMatter(pageVariables, filePath);
 
+  const stdin =
+    typeof pageVariables.stdin === 'string' ? pageVariables.stdin : undefined;
+
   // Compile and execute the concatenated Java source
   let tempDir: string | undefined;
   let blockOutputMap: Map<number, string> | null = null;
@@ -416,6 +428,7 @@ export function renderLiterateJavaPageAsset({
           className,
           tempDir,
           codeBlocks,
+          stdin,
         );
         blockOutputMap = new Map(
           outputEntries.map(e => [e.blockIndex, e.output]),
@@ -434,9 +447,17 @@ export function renderLiterateJavaPageAsset({
     validatorOptions: { enabled: false },
   });
   let fenceIndex = 0;
+  const defaultFence = md.renderer.rules.fence!;
 
-  md.renderer.rules.fence = (tokens, idx) => {
+  md.renderer.rules.fence = (tokens, idx, options, env, self) => {
     const token = tokens[idx];
+    const lang = token.info.trim();
+
+    // Non-Java fences render with the default renderer (no line numbers)
+    if (lang !== '' && lang !== 'java') {
+      return defaultFence(tokens, idx, options, env, self);
+    }
+
     const code = token.content;
     const lines = code.endsWith('\n')
       ? code.slice(0, -1).split('\n')
@@ -509,11 +530,11 @@ export function renderLiterateJavaPageAsset({
     subPath,
   });
 
-  const html = injectAssetTags(
-    render('literate.html', templateParameters) as string,
-    assetFiles,
-    applyBasePath,
-  );
+  const templateHtml = render('literate.html', templateParameters) as string;
+  let html = injectAssetTags(templateHtml, assetFiles, applyBasePath, distDir);
+  if (templateHtml.includes('class="katex"')) {
+    html = injectKatexStylesheet(html, applyBasePath);
+  }
 
   return [
     {

package/build/utils/shiki-highlighter.ts

@@ -1,5 +1,5 @@
 import type { HighlighterGeneric, BundledLanguage, BundledTheme } from 'shiki';
-import { makeLogger } from '../log.js';
+import { makeLogger } from '../log';
 
 const log = makeLogger(__filename);
 

package/build/validate-internal-links-plugin.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from 'bun:test';
 import MarkdownIt from 'markdown-it';
-import validateInternalLinks from './validate-internal-links-plugin.js';
+import validateInternalLinks from './validate-internal-links-plugin';
 
 function createMd(
   validTargets: string[],

package/build/validate-internal-links-plugin.ts

@@ -1,7 +1,7 @@
 import type MarkdownIt from 'markdown-it';
 import type Token from 'markdown-it/lib/token.mjs';
 import path from 'path';
-import { makeLogger } from './log.js';
+import { makeLogger } from './log';
 
 const log = makeLogger(__filename);
 

package/build/watch-reachability-state.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from 'bun:test';
-import { collectReachableSiteAssets } from './reachability.js';
-import WatchReachabilityState from './watch-reachability-state.js';
+import { collectReachableSiteAssets } from './reachability';
+import WatchReachabilityState from './watch-reachability-state';
 
 function createReader(htmlByPath: Map<string, string>) {
   const calls: string[] = [];

package/build/watch-reachability-state.ts

@@ -1,4 +1,4 @@
-import { collectDirectSiteAssetLinks } from './reachability.js';
+import { collectDirectSiteAssetLinks } from './reachability';
 
 type ReadHtmlForAsset = (assetPath: string) => string;
 

package/build/watch.ts

@@ -4,37 +4,33 @@ import { fork } from 'child_process';
 import path from 'path';
 import chokidar from 'chokidar';
 import WebSocket, { WebSocketServer } from 'ws';
-import type { SiteVariables, WatchState } from './types.js';
-import { B } from './colors.js';
-import { makeLogger, printFlair } from './log.js';
-import { getDevSiteVariables } from './site-variables.js';
-import {
-  compileTemplates,
-  getHtmlTemplatesDir,
-  getJsonDataDir,
-  JSON_DATA_FILES,
-} from './templates.js';
+import type { SiteVariables, WatchState } from './types';
+import { B } from './colors';
+import { makeLogger, printFlair } from './log';
+import { getDevSiteVariables } from './site-variables';
+import { compileTemplates, getJsonDataDir, JSON_DATA_FILES } from './templates';
 import {
   getContentDir,
   getPublicDir,
   getDistDir,
   getPackageDir,
-} from './utils/paths.js';
-import { isFeatureEnabled } from './features.js';
-import { bundle } from './bundle.js';
-import { copyFonts } from './generate-fonts.js';
-import { generateFavicons } from './generate-favicon.js';
-import { generateManifest } from './generate-manifest.js';
+} from './utils/paths';
+import { isFeatureEnabled } from './features';
+import { bundle } from './bundle';
+import { copyFonts } from './generate-fonts';
+import { copyKatexAssets } from './generate-katex-assets';
+import { generateFavicons } from './generate-favicon';
+import { generateManifest } from './generate-manifest';
 import {
   copyPublicFiles,
   copyContentAssets,
   copyContentFile,
   copyPublicFile,
-} from './copy.js';
-import { getProcessedExtensions } from './utils/file-types.js';
-import { ContentRenderer } from './generate-content-assets.js';
-import { WatchPagefindRunner } from './pagefind.js';
-import { ContentChangeDetector } from './content-watch.js';
+} from './copy';
+import { getProcessedExtensions } from './utils/file-types';
+import { ContentRenderer } from './generate-content-assets';
+import { WatchPagefindRunner } from './pagefind';
+import { ContentChangeDetector } from './content-watch';
 
 function getArg(name: string): number | null {
   const idx = process.argv.indexOf(name);
@@ -74,14 +70,15 @@ async function bundleReloadClient(): Promise<string[]> {
   );
 }
 
-type ChangeCategory = 'content' | 'public' | 'src' | 'templates' | 'config';
+type ChangeCategory = 'content' | 'public' | 'config';
 
 const log = makeLogger(__filename);
 const wslog = makeLogger('WebSocket');
 
-// --- WebSocket server (unchanged) ---
+// --- WebSocket server ---
 
 let webSocketsReady = false;
+let watcherReady = false;
 let webServerReady = false;
 let webServerTimeout: ReturnType<typeof setTimeout> | undefined;
 let serveStarted = false;
@@ -92,6 +89,12 @@ try {
 
   wss.on('connection', (conn: WebSocket) => {
     wslog.debug`WebSocket client connected`;
+    if (watcherReady && conn.readyState === WebSocket.OPEN) {
+      if (initialBuildFailed) {
+        conn.send('error');
+      }
+      conn.send('ready');
+    }
     conn.on('close', () => {
       wslog.debug`WebSocket client disconnected`;
     });
@@ -196,12 +199,9 @@ function toPublicRelativePath(filePath: string): string | null {
 const contentDir: string = getContentDir();
 const publicDir: string = getPublicDir();
 const distDir: string = getDistDir();
-const packageDir: string = getPackageDir();
 
-let siteVariables: SiteVariables = getDevSiteVariables();
-let processedExtSet = new Set<string>(
-  getProcessedExtensions(Object.keys(siteVariables.codeLanguages || {})),
-);
+let siteVariables: SiteVariables;
+let processedExtSet = new Set<string>();
 let publicRelPaths: Set<string> = new Set();
 let contentAssetRelPaths: Set<string> = new Set();
 let contentRenderer: ContentRenderer;
@@ -213,6 +213,10 @@ const pendingChanges = new Set<string>();
 let rebuilding = false;
 
 async function initialBuild(): Promise<void> {
+  siteVariables = getDevSiteVariables();
+  processedExtSet = new Set(
+    getProcessedExtensions(Object.keys(siteVariables.codeLanguages || {})),
+  );
   fs.mkdirSync(distDir, { recursive: true });
 
   compileTemplates(siteVariables);
@@ -231,6 +235,7 @@ async function initialBuild(): Promise<void> {
   ];
 
   copyFonts(distDir);
+  copyKatexAssets(distDir);
 
   if (isFeatureEnabled(siteVariables, 'favicon')) {
     await generateFavicons(siteVariables, distDir);
@@ -270,8 +275,6 @@ function classifyChange(filePath: string): ChangeCategory | null {
   const resolved = path.resolve(filePath);
   const resolvedContentDir = path.resolve(contentDir) + path.sep;
   const resolvedPublicDir = path.resolve(publicDir) + path.sep;
-  const resolvedSrcDir = path.resolve(packageDir, 'src') + path.sep;
-  const htmlTemplatesDir = path.resolve(getHtmlTemplatesDir()) + path.sep;
   const jsonDataDir = getJsonDataDir();
   const siteConfigPath = path.resolve('site.dev.json');
 
@@ -281,16 +284,10 @@ function classifyChange(filePath: string): ChangeCategory | null {
   if (resolved.startsWith(resolvedPublicDir)) {
     return 'public';
   }
-  if (resolved.startsWith(resolvedSrcDir)) {
-    return 'src';
-  }
   if (
-    resolved.startsWith(htmlTemplatesDir) ||
+    resolved === siteConfigPath ||
     JSON_DATA_FILES.some(f => resolved === path.resolve(jsonDataDir, f))
   ) {
-    return 'templates';
-  }
-  if (resolved === siteConfigPath) {
     return 'config';
   }
   return null;
@@ -316,6 +313,8 @@ async function rebuild(): Promise<void> {
     }
   }
 
+  let succeeded = false;
+
   try {
     // Site config changed, full restart
     if (categories.has('config')) {
@@ -337,61 +336,36 @@ async function rebuild(): Promise<void> {
         ...(await bundleReloadClient()),
       ];
 
-      const result = contentRenderer.processContent({ distDir, assetFiles });
-      for (const err of result.errors) {
-        log.error`${err.message}`;
-      }
-      if (result.errors.length === 0) {
-        printFlair();
-        broadcast('reload');
-        if (pagefindRunner) {
-          pagefindRunner.update(distDir, result.htmlAssetsByPath);
-          setImmediate(() => pagefindRunner!.run());
-        }
+      copyFonts(distDir);
+      copyKatexAssets(distDir);
+
+      if (isFeatureEnabled(siteVariables, 'favicon')) {
+        await generateFavicons(siteVariables, distDir);
+        generateManifest(siteVariables, distDir);
       }
-      rebuilding = false;
-      return;
-    }
 
-    // Source changed, re-bundle, then re-render all content
-    if (categories.has('src')) {
-      assetFiles = [
-        ...(await bundle(siteVariables, { mode: 'development' })),
-        ...(await bundleReloadClient()),
-      ];
-      // Force full content re-render since asset filenames may have changed
       const result = contentRenderer.processContent({ distDir, assetFiles });
       for (const err of result.errors) {
         log.error`${err.message}`;
       }
       if (result.errors.length === 0) {
         printFlair();
+        if (!serveStarted) {
+          serveStarted = true;
+          serve();
+        }
         broadcast('reload');
         if (pagefindRunner) {
           pagefindRunner.update(distDir, result.htmlAssetsByPath);
           setImmediate(() => pagefindRunner!.run());
         }
+        succeeded = true;
       }
-      rebuilding = false;
       return;
     }
 
-    // Templates/data changed, recompile templates, re-render all content
-    if (categories.has('templates')) {
-      const detection = changeDetector.detectChanges(changes);
-      if (detection.templateError) {
-        log.error`Template error: ${detection.templateError.message}`;
-        rebuilding = false;
-        return;
-      }
-    }
-
     // Public file changed, copy just that file
-    if (
-      categories.has('public') &&
-      !categories.has('content') &&
-      !categories.has('templates')
-    ) {
+    if (categories.has('public') && !categories.has('content')) {
       for (const filePath of changes) {
         if (classifyChange(filePath) === 'public') {
           const absPath = path.resolve(filePath);
@@ -407,17 +381,12 @@ async function rebuild(): Promise<void> {
       }
       printFlair();
       broadcast('reload');
-      rebuilding = false;
+      succeeded = true;
       return;
     }
 
-    // Content and/or templates changed, incremental rebuild
+    // Content changed, incremental rebuild
     const detection = changeDetector.detectChanges(changes);
-    if (detection.templateError) {
-      log.error`Template error: ${detection.templateError.message}`;
-      rebuilding = false;
-      return;
-    }
 
     if (detection.needsRestart) {
       log.event`Content structure changed, full rebuild`;
@@ -493,16 +462,24 @@ async function rebuild(): Promise<void> {
 
     if (result.errors.length === 0) {
       printFlair();
+      if (!serveStarted) {
+        serveStarted = true;
+        serve();
+      }
       broadcast('reload');
 
       if (pagefindRunner) {
         pagefindRunner.update(distDir, result.htmlAssetsByPath);
         setImmediate(() => pagefindRunner!.run());
       }
+      succeeded = true;
     }
   } catch (err) {
     log.error`Build failed: ${(err as Error).message}`;
   } finally {
+    if (!succeeded) {
+      broadcast('error');
+    }
     rebuilding = false;
 
     // If more changes accumulated during rebuild, schedule another
@@ -526,35 +503,36 @@ function onFileChange(filePath: string): void {
 
 // --- Start ---
 
+let initialBuildFailed = false;
+
 initialBuild()
-  .then(() => {
-    // Watch content, public, src, templates, data files, site config
+  .catch(err => {
+    log.error`Initial build failed: ${(err as Error).message}`;
+    initialBuildFailed = true;
+  })
+  .finally(() => {
     const watchPaths: string[] = [contentDir, publicDir];
 
-    // Watch package src/ and templates/ for Tada development
-    const srcDir = path.resolve(packageDir, 'src');
-    const templatesDir = getHtmlTemplatesDir();
-    if (fs.existsSync(srcDir)) {
-      watchPaths.push(srcDir);
-    }
-    if (fs.existsSync(templatesDir)) {
-      watchPaths.push(templatesDir);
-    }
-
-    // Watch data files
+    // Watch config files (nav.json, authors.json, site config) via the
+    // project root directory (depth 0). Chokidar v4 doesn't emit unlink
+    // for individually watched files, so we must watch the directory.
     const jsonDataDir = getJsonDataDir();
-    for (const dataFile of JSON_DATA_FILES) {
-      const dataPath = path.join(jsonDataDir, dataFile);
-      if (fs.existsSync(dataPath)) {
-        watchPaths.push(dataPath);
+    const configFilePaths = new Set([
+      ...JSON_DATA_FILES.map(f => path.resolve(jsonDataDir, f)),
+      path.resolve('site.dev.json'),
+    ]);
+    const configWatcher = chokidar.watch(jsonDataDir, {
+      ignoreInitial: true,
+      depth: 0,
+    });
+    const onConfigFileChange = (filePath: string) => {
+      if (configFilePaths.has(path.resolve(filePath))) {
+        onFileChange(filePath);
       }
-    }
-
-    // Watch site config
-    const siteConfigPath = path.resolve('site.dev.json');
-    if (fs.existsSync(siteConfigPath)) {
-      watchPaths.push(siteConfigPath);
-    }
+    };
+    configWatcher.on('add', onConfigFileChange);
+    configWatcher.on('change', onConfigFileChange);
+    configWatcher.on('unlink', onConfigFileChange);
 
     const watcher = chokidar.watch(watchPaths, {
       ignoreInitial: true,
@@ -565,9 +543,12 @@ initialBuild()
     watcher.on('add', onFileChange);
     watcher.on('unlink', onFileChange);
 
-    log.info`Watching for changes...`;
-  })
-  .catch(err => {
-    log.error`Initial build failed: ${(err as Error).message}`;
-    process.exit(1);
+    watcher.on('ready', () => {
+      watcherReady = true;
+      if (initialBuildFailed) {
+        broadcast('error');
+      }
+      broadcast('ready');
+      log.info`Watching for changes...`;
+    });
   });