@abreen/tada 1.0.2 → 1.1.0

package/build/pipeline.ts

@@ -0,0 +1,93 @@
+#!/usr/bin/env bun
+import fs from 'fs';
+import { getDevSiteVariables, getProdSiteVariables } from './site-variables.js';
+import { compileTemplates } from './templates.js';
+import { getDistDir, getContentDir, getPublicDir } 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';
+import { copyPublicFiles, copyContentAssets } from './copy.js';
+import { getProcessedExtensions } from './utils/file-types.js';
+import { ContentRenderer } from './generate-content-assets.js';
+import { runPagefind } from './pagefind.js';
+import { makeLogger, printFlair } from './log.js';
+
+const log = makeLogger(__filename);
+
+async function runPipeline(mode: 'development' | 'production'): Promise<void> {
+  const isDev = mode === 'development';
+  const siteVariables = isDev ? getDevSiteVariables() : getProdSiteVariables();
+  const distDir = getDistDir();
+  const contentDir = getContentDir();
+  const publicDir = getPublicDir();
+
+  // Ensure dist/ exists
+  fs.mkdirSync(distDir, { recursive: true });
+
+  // Phase 1: Setup
+  compileTemplates(siteVariables);
+  const contentRenderer = new ContentRenderer(siteVariables);
+  await contentRenderer.initHighlighter();
+
+  // Phase 2: Bundle + assets (parallel)
+  const parallelTasks: (Promise<unknown> | void)[] = [
+    bundle(siteVariables, { mode }),
+    copyFonts(distDir),
+  ];
+
+  if (isFeatureEnabled(siteVariables, 'favicon')) {
+    parallelTasks.push(generateFavicons(siteVariables, distDir));
+  }
+
+  const results = await Promise.all(parallelTasks);
+  const assetFiles = results[0] as string[]; // bundle output filenames
+
+  if (isFeatureEnabled(siteVariables, 'favicon')) {
+    generateManifest(siteVariables, distDir);
+  }
+
+  const publicRelPaths = copyPublicFiles(publicDir, distDir);
+  const processedExtensions = getProcessedExtensions(
+    Object.keys(siteVariables.codeLanguages || {}),
+  );
+  copyContentAssets(contentDir, distDir, processedExtensions, publicRelPaths);
+
+  // Phase 3: Content rendering
+  const { errors, htmlAssetsByPath } = contentRenderer.processContent({
+    distDir,
+    assetFiles,
+  });
+
+  for (const err of errors) {
+    log.error`${err.message}`;
+  }
+  if (errors.length > 0) {
+    process.exit(1);
+  }
+
+  // Phase 4: Post-processing
+  if (isFeatureEnabled(siteVariables, 'search')) {
+    await runPagefind({ siteVariables, distPath: distDir, htmlAssetsByPath });
+  }
+
+  printFlair();
+}
+
+// CLI entry point
+const arg = process.argv[2];
+if (arg === 'dev') {
+  runPipeline('development').catch(err => {
+    log.error`Build failed: ${err.message}`;
+    process.exit(1);
+  });
+} else if (arg === 'prod') {
+  runPipeline('production').catch(err => {
+    log.error`Build failed: ${err.message}`;
+    process.exit(1);
+  });
+} else {
+  console.error('Usage: pipeline.js <dev|prod>');
+  process.exit(1);
+}

package/{webpack/reachability.test.js → build/reachability.test.ts}

@@ -1,8 +1,8 @@
-const { describe, expect, test } = require('bun:test');
-const {
+import { describe, expect, test } from 'bun:test';
+import {
   collectDirectSiteAssetLinks,
   collectReachableSiteAssets,
-} = require('./reachability');
+} from './reachability.js';
 
 describe('reachability', () => {
   test('collectDirectSiteAssetLinks resolves relative links and ignores excluded links', () => {

package/{webpack/reachability.js → build/reachability.ts}

@@ -1,11 +1,11 @@
-const path = require('path');
-const { JSDOM } = require('jsdom');
+import path from 'path';
+import { JSDOM } from 'jsdom';
 
-function stripQueryAndHash(href) {
+function stripQueryAndHash(href: string): string {
   return href.split('#')[0].split('?')[0];
 }
 
-function isExternalOrAnchor(href) {
+function isExternalOrAnchor(href: string): boolean {
   if (!href || href.startsWith('#') || href.startsWith('//')) {
     return true;
   }
@@ -13,7 +13,7 @@ function isExternalOrAnchor(href) {
   return /^[a-zA-Z][a-zA-Z\d+.-]*:/.test(href);
 }
 
-function normalizeUrlPath(pathname) {
+function normalizeUrlPath(pathname: string): string {
   const normalized = path.posix.normalize(pathname);
   if (normalized === '.' || normalized === '') {
     return '/';
@@ -22,7 +22,7 @@ function normalizeUrlPath(pathname) {
   return normalized.startsWith('/') ? normalized : `/${normalized}`;
 }
 
-function stripBasePath(pathname, basePath) {
+function stripBasePath(pathname: string, basePath: string): string {
   const normalizedPath = normalizeUrlPath(pathname);
   const normalizedBasePath = normalizeUrlPath(basePath || '/');
 
@@ -42,7 +42,7 @@ function stripBasePath(pathname, basePath) {
   return normalizedPath;
 }
 
-function toCandidateAssetPaths(urlPath) {
+function toCandidateAssetPaths(urlPath: string): string[] {
   const normalizedPath = normalizeUrlPath(urlPath);
 
   if (normalizedPath === '/') {
@@ -65,7 +65,17 @@ function toCandidateAssetPaths(urlPath) {
   return [`${withoutLeadingSlash}/index.html`, `${withoutLeadingSlash}.html`];
 }
 
-function resolveInternalPath({ href, fromAssetPath, basePath = '/' }) {
+interface ResolveInternalPathOptions {
+  href: string | null;
+  fromAssetPath: string;
+  basePath?: string;
+}
+
+function resolveInternalPath({
+  href,
+  fromAssetPath,
+  basePath = '/',
+}: ResolveInternalPathOptions): string | null {
   if (!href) {
     return null;
   }
@@ -80,7 +90,7 @@ function resolveInternalPath({ href, fromAssetPath, basePath = '/' }) {
     return null;
   }
 
-  let resolvedPath = pathname.startsWith('/')
+  const resolvedPath = pathname.startsWith('/')
     ? stripBasePath(pathname, basePath)
     : normalizeUrlPath(
         path.posix.join(path.posix.dirname(`/${fromAssetPath}`), pathname),
@@ -93,12 +103,19 @@ function resolveInternalPath({ href, fromAssetPath, basePath = '/' }) {
   }
 }
 
-function resolveHrefToHtmlAssetPath({
+interface ResolveHrefToHtmlOptions {
+  href: string | null;
+  fromAssetPath: string;
+  basePath?: string;
+  knownAssets: Set<string>;
+}
+
+export function resolveHrefToHtmlAssetPath({
   href,
   fromAssetPath,
   basePath = '/',
   knownAssets,
-}) {
+}: ResolveHrefToHtmlOptions): string | null {
   const decodedPath = resolveInternalPath({ href, fromAssetPath, basePath });
   if (!decodedPath) {
     return null;
@@ -113,12 +130,19 @@ function resolveHrefToHtmlAssetPath({
   return null;
 }
 
-function resolveHrefToPdfPath({
+interface ResolveHrefToPdfOptions {
+  href: string | null;
+  fromAssetPath: string;
+  basePath?: string;
+  knownPdfPaths: Set<string>;
+}
+
+export function resolveHrefToPdfPath({
   href,
   fromAssetPath,
   basePath = '/',
   knownPdfPaths,
-}) {
+}: ResolveHrefToPdfOptions): string | null {
   const decodedPath = resolveInternalPath({ href, fromAssetPath, basePath });
   if (!decodedPath || !decodedPath.toLowerCase().endsWith('.pdf')) {
     return null;
@@ -127,15 +151,28 @@ function resolveHrefToPdfPath({
   return knownPdfPaths.has(decodedPath) ? decodedPath : null;
 }
 
-function collectDirectSiteAssetLinks({
+interface CollectDirectLinksOptions {
+  html: string;
+  fromAssetPath: string;
+  knownAssets: Set<string>;
+  knownPdfPaths?: Set<string>;
+  basePath?: string;
+}
+
+interface DirectSiteAssetLinks {
+  htmlAssetPaths: string[];
+  pdfPaths: string[];
+}
+
+export function collectDirectSiteAssetLinks({
   html,
   fromAssetPath,
   knownAssets,
   knownPdfPaths = new Set(),
   basePath = '/',
-}) {
-  const htmlAssetPaths = new Set();
-  const pdfPaths = new Set();
+}: CollectDirectLinksOptions): DirectSiteAssetLinks {
+  const htmlAssetPaths = new Set<string>();
+  const pdfPaths = new Set<string>();
   const dom = new JSDOM(html);
 
   try {
@@ -189,29 +226,41 @@ function collectDirectSiteAssetLinks({
   };
 }
 
-function collectReachableSiteAssets({
+interface CollectReachableOptions {
+  htmlAssetsByPath: Map<string, string>;
+  knownPdfPaths?: Set<string>;
+  rootPath?: string;
+  basePath?: string;
+}
+
+interface ReachableSiteAssets {
+  reachableHtmlPaths: string[];
+  reachablePdfPaths: string[];
+}
+
+export function collectReachableSiteAssets({
   htmlAssetsByPath,
   knownPdfPaths = new Set(),
   rootPath = 'index.html',
   basePath = '/',
-}) {
+}: CollectReachableOptions): ReachableSiteAssets {
   if (!htmlAssetsByPath.has(rootPath)) {
     throw new Error(`Pagefind reachability root not found: ${rootPath}`);
   }
 
   const knownAssets = new Set(htmlAssetsByPath.keys());
-  const reachable = new Set();
-  const reachablePdfPaths = new Set();
-  const pending = [rootPath];
+  const reachable = new Set<string>();
+  const reachablePdfPaths = new Set<string>();
+  const pending: string[] = [rootPath];
 
   while (pending.length > 0) {
-    const currentPath = pending.pop();
+    const currentPath = pending.pop()!;
     if (reachable.has(currentPath)) {
       continue;
     }
     reachable.add(currentPath);
 
-    const html = htmlAssetsByPath.get(currentPath);
+    const html = htmlAssetsByPath.get(currentPath)!;
     const { htmlAssetPaths, pdfPaths } = collectDirectSiteAssetLinks({
       html,
       fromAssetPath: currentPath,
@@ -237,11 +286,13 @@ function collectReachableSiteAssets({
   };
 }
 
-function collectReachableHtmlAssets(options) {
+export function collectReachableHtmlAssets(
+  options: CollectReachableOptions,
+): string[] {
   return collectReachableSiteAssets(options).reachableHtmlPaths;
 }
 
-function getMetaRefreshTarget(document) {
+function getMetaRefreshTarget(document: Document): string | null {
   const refreshTags = document.querySelectorAll('meta[http-equiv]');
   for (const tag of refreshTags) {
     const httpEquiv = tag.getAttribute('http-equiv');
@@ -263,11 +314,3 @@ function getMetaRefreshTarget(document) {
 
   return null;
 }
-
-module.exports = {
-  collectDirectSiteAssetLinks,
-  collectReachableHtmlAssets,
-  collectReachableSiteAssets,
-  resolveHrefToHtmlAssetPath,
-  resolveHrefToPdfPath,
-};

package/build/serve.ts

@@ -0,0 +1,112 @@
+import fs from 'fs';
+import path from 'path';
+import { getDistDir } from './util.js';
+import { makeLogger } from './log.js';
+import { B } from './colors.js';
+
+const log = makeLogger(__filename);
+
+function messageReady(port: number): void {
+  if (process.send) {
+    process.send({ ready: true, port });
+  }
+}
+
+let distDir: string;
+try {
+  distDir = getDistDir();
+} catch (err) {
+  log.error`Failed to start server: ${err}`;
+  process.exit(1);
+}
+
+function resolvePathname(pathname: string): string | null {
+  let decodedPath: string;
+  try {
+    decodedPath = decodeURIComponent(pathname);
+  } catch {
+    return null;
+  }
+
+  const resolvedPath = path.resolve(distDir, '.' + decodedPath);
+  const relativePath = path.relative(distDir, resolvedPath);
+  if (relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
+    return null;
+  }
+
+  let stat: fs.Stats;
+  try {
+    stat = fs.statSync(resolvedPath);
+  } catch {
+    return null;
+  }
+
+  if (stat.isDirectory()) {
+    return null;
+  }
+
+  if (!stat.isFile()) {
+    return null;
+  }
+
+  return resolvedPath;
+}
+
+function createResponse(req: Request): Response {
+  const url = new URL(req.url);
+  const filePath = resolvePathname(url.pathname);
+  if (!filePath) {
+    return new Response('Not Found', { status: 404 });
+  }
+
+  return new Response(Bun.file(filePath));
+}
+
+function getPortArg(): number {
+  const idx = process.argv.indexOf('--port');
+  if (idx === -1) {
+    return 8080;
+  }
+  const raw = process.argv[idx + 1];
+  if (!raw) {
+    log.error`--port requires a value`;
+    process.exit(1);
+  }
+  const port = parseInt(raw, 10);
+  if (isNaN(port) || port <= 0 || port >= 65536) {
+    log.error`Invalid port value: ${raw}`;
+    process.exit(1);
+  }
+  return port;
+}
+
+function listen(port: number): void {
+  try {
+    const server = Bun.serve({
+      port,
+      fetch: createResponse,
+      error(error: Error) {
+        log.error`Request failed: ${error}`;
+        return new Response('Internal Server Error', { status: 500 });
+      },
+    });
+
+    log.info`Dev server: ${B`http://localhost:${server.port}/index.html`}`;
+    messageReady(server.port as number);
+  } catch (err) {
+    log.error`Failed to start server on port ${port}: ${err}`;
+    process.exit(1);
+  }
+}
+
+listen(getPortArg());
+
+process.on('uncaughtException', err => {
+  log.error`Uncaught exception: ${err}`;
+  process.exit(1);
+});
+
+process.on('unhandledRejection', reason => {
+  log.error`Unhandled rejection: ${reason}`;
+  process.exit(1);
+});

package/{webpack/site-variables.js → build/site-variables.ts}

@@ -1,27 +1,36 @@
-const fs = require('fs');
-const path = require('path');
-const { compile: compileJsonSchema, doValidation } = require('./json-schema');
-const { getProjectDir } = require('./utils/paths');
-const configDir = path.resolve(getProjectDir(), 'config');
+import fs from 'fs';
+import path from 'path';
+import { compile as compileJsonSchema, doValidation } from './json-schema.js';
+import { getProjectDir } from './utils/paths.js';
+import type { SiteVariables } from './types.js';
+import siteSchema from './site.schema.json' with { type: 'json' };
 
-const DEFAULT = { basePath: '/', features: { search: true, code: true } };
+const configDir = getProjectDir();
 
-const isValid = compileJsonSchema(require('./site.schema.json'));
+const DEFAULT: Partial<SiteVariables> = {
+  basePath: '/',
+  features: { search: true, code: true },
+};
 
-function getJson(filePath) {
+const isValid = compileJsonSchema(siteSchema);
+
+function getJson(filePath: string): Record<string, unknown> {
   return JSON.parse(
     fs.readFileSync(path.resolve(configDir, filePath), 'utf-8'),
   );
 }
 
-function getSiteVariables(env) {
+function getSiteVariables(env: string): SiteVariables {
   const fileName = `site.${env}.json`;
   const fromFile = getJson(fileName);
   const variables = {
     ...DEFAULT,
     ...fromFile,
-    features: { ...DEFAULT.features, ...(fromFile.features || {}) },
-  };
+    features: {
+      ...DEFAULT.features,
+      ...((fromFile.features as Record<string, unknown>) || {}),
+    },
+  } as SiteVariables;
 
   // Derive faviconSymbol from symbol if not explicitly set
   if (variables.symbol && !variables.faviconSymbol) {
@@ -42,12 +51,10 @@ function getSiteVariables(env) {
   return variables;
 }
 
-function getDevSiteVariables() {
+export function getDevSiteVariables(): SiteVariables {
   return getSiteVariables('dev');
 }
 
-function getProdSiteVariables() {
+export function getProdSiteVariables(): SiteVariables {
   return getSiteVariables('prod');
 }
-
-module.exports = { getDevSiteVariables, getProdSiteVariables };

package/{webpack → build}/site.schema.json

@@ -8,8 +8,7 @@
       "properties": {
         "search": { "type": "boolean", "default": true },
         "code": { "type": "boolean", "default": true },
-        "favicon": { "type": "boolean", "default": false },
-        "literateJava": { "type": "boolean", "default": false }
+        "favicon": { "type": "boolean", "default": false }
       },
       "required": ["search", "code", "favicon"],
       "additionalProperties": false
@@ -29,10 +28,7 @@
     "symbol": { "type": "string", "pattern": "^[A-Z0-9\\- ]{1,5}$" },
     "titlePostfix": { "type": "string" },
     "courseId": { "type": "string" },
-    "themeColor": {
-      "type": "string",
-      "pattern": "^hsl\\(\\d+(deg)? \\d+% \\d+%\\)$"
-    },
+    "themeColor": { "type": "string" },
     "tintHue": {
       "type": "integer",
       "minimum": 0,
@@ -45,10 +41,7 @@
       "maximum": 100,
       "default": 100
     },
-    "faviconColor": {
-      "type": "string",
-      "pattern": "^hsl\\(\\d+(deg)? \\d+% \\d+%\\)$"
-    },
+    "faviconColor": { "type": "string" },
     "faviconSymbol": { "type": "string", "pattern": "^[A-Z0-9\\- ]{1,5}$" },
     "faviconFontWeight": {
       "type": "integer",

package/{webpack/templates.js → build/templates.ts}

@@ -1,45 +1,49 @@
-const fs = require('fs');
-const path = require('path');
-const _ = require('lodash');
-const { compile: compileJsonSchema, doValidation } = require('./json-schema');
-const { makeLogger } = require('./log');
+import fs from 'fs';
+import path from 'path';
+import _ from 'lodash';
+import { compile as compileJsonSchema, doValidation } from './json-schema.js';
+import { makeLogger } from './log.js';
+import { getPackageDir, getConfigDir } from './utils/paths.js';
+import type { ValidateFunction } from 'ajv';
+import type { Logger, SiteVariables } from './types.js';
 
-const log = makeLogger(__filename);
+const log: Logger = makeLogger(__filename);
 
 // Store all templates in memory (don't read template files during build)
-const templates = {};
+const templates: Record<string, string> = {};
 
 // All parsed data (from .json files)
-const jsonData = {};
+const jsonData: Record<string, unknown> = {};
 
 // Compiled JSON Schema for the .json files
-const validators = {};
+const validators: Record<string, ValidateFunction> = {};
 
 // Keeps track of template call tree
-const renderStack = [];
-let errorStack = null;
+const renderStack: string[] = [];
+let errorStack: string[] | null = null;
 
 // JSON data files that live in the user's config directory
-const JSON_DATA_FILES = ['nav.json', 'authors.json'];
+const JSON_DATA_FILES: string[] = ['nav.json', 'authors.json'];
 
-function getHtmlTemplatesDir() {
-  const { getPackageDir } = require('./utils/paths');
+function getHtmlTemplatesDir(): string {
   return path.resolve(getPackageDir(), 'templates');
 }
 
-function getJsonDataDir() {
-  const { getConfigDir } = require('./utils/paths');
+function getJsonDataDir(): string {
   return getConfigDir();
 }
 
-function json(fileName) {
+export function json(fileName: string): unknown {
   return jsonData[fileName];
 }
 
-function render(fileName, params) {
+export function render(
+  fileName: string,
+  params?: Record<string, unknown> | null,
+): string | undefined {
   if (params != null) {
     // Allow the template to call render(), it will use our params
-    params.render = otherFileName => render(otherFileName, params);
+    params.render = (otherFileName: string) => render(otherFileName, params);
 
     // Allow the template to read the JSON files we previously read into memory
     params.json = json;
@@ -47,7 +51,7 @@ function render(fileName, params) {
 
   renderStack.push(fileName);
   try {
-    return _.template(templates[fileName])(params);
+    return _.template(templates[fileName])(params ?? undefined);
   } catch (err) {
     if (errorStack == null) {
       errorStack = renderStack.slice();
@@ -57,15 +61,20 @@ function render(fileName, params) {
       }
     } else if (renderStack.length === 1) {
       const topItem = errorStack[errorStack.length - 1];
-      throw new Error(`Render error in ${topItem}: ${err}`);
+      throw new Error(`Render error in ${topItem}: ${err}`, { cause: err });
     }
   } finally {
     renderStack.pop();
   }
 }
 
-function compileTemplates(siteVariables) {
-  log.info`Compiling templates`;
+export function compileTemplates(
+  siteVariables: SiteVariables,
+  quiet: boolean = false,
+): void {
+  if (!quiet) {
+    log.debug`Compiling templates`;
+  }
 
   Object.keys(templates).forEach(k => delete templates[k]);
   Object.keys(jsonData).forEach(k => delete jsonData[k]);
@@ -88,7 +97,7 @@ function compileTemplates(siteVariables) {
   for (const fileName of JSON_DATA_FILES) {
     const filePath = path.join(jsonDir, fileName);
     if (!fs.existsSync(filePath)) {
-      throw new Error(`Missing required data file: ${filePath}`);
+      continue;
     }
 
     // Schema validation (schemas live in the package templates dir)
@@ -113,16 +122,9 @@ function compileTemplates(siteVariables) {
   }
 }
 
-function compileAndSetValidator(schemaPath, fileName) {
+function compileAndSetValidator(schemaPath: string, fileName: string): void {
   const schema = JSON.parse(fs.readFileSync(schemaPath, 'utf-8'));
   validators[fileName] = compileJsonSchema(schema);
 }
 
-module.exports = {
-  compileTemplates,
-  render,
-  getHtmlTemplatesDir,
-  getJsonDataDir,
-  json,
-  JSON_DATA_FILES,
-};
+export { getHtmlTemplatesDir, getJsonDataDir, JSON_DATA_FILES };

package/{webpack/text-to-id.js → build/text-to-id.ts}

@@ -1,8 +1,8 @@
-module.exports = function textToId(value) {
+export default function textToId(value: unknown): string {
   const text = value == null ? '' : String(value);
   return text
     .trim()
     .toLowerCase()
     .replace(/\s+/g, '-')
     .replace(/[^\w-]/g, '');
-};
+}