@abreen/tada 1.7.0 → 1.7.1

package/bin/tada.ts

@@ -607,21 +607,14 @@ try {
       await initCommand(process.argv.slice(3));
       break;
 
-    case 'dev': {
-      requireSiteConfig('dev');
-      const { runPipeline } = await import(
-        path.join(packageDir, 'build/pipeline.ts')
-      );
-      await runPipeline('development');
-      break;
-    }
-
+    case 'dev':
     case 'prod': {
-      requireSiteConfig('prod');
+      const mode = command === 'dev' ? 'development' : 'production';
+      requireSiteConfig(command);
       const { runPipeline } = await import(
         path.join(packageDir, 'build/pipeline.ts')
       );
-      await runPipeline('production');
+      await runPipeline(mode);
       break;
     }
 

package/build/apply-base-path-plugin.ts

@@ -3,6 +3,7 @@ import type MarkdownIt from 'markdown-it';
 import type Token from 'markdown-it/lib/token.mjs';
 import { createApplyBasePath } from './utils/paths';
 import { isFeatureEnabled } from './features';
+import { isInternalLink } from './utils/link';
 import { makeLogger } from './log';
 import type { SiteVariables } from './types';
 
@@ -26,6 +27,11 @@ export default function applyBasePathPlugin(
   const validTargets = pluginOptions.validTargets;
 
   function rewriteInternalHref(href: string): string {
+    const resolveAgainstSource = (p: string): string =>
+      p.startsWith('/')
+        ? p
+        : path.posix.join(path.posix.dirname(sourceUrlPath!), p);
+
     const match = href.match(/^([^?#]*)(.*)$/);
     const pathname = match ? match[1] : href;
     const suffix = match ? match[2] : '';
@@ -35,12 +41,7 @@ export default function applyBasePathPlugin(
       for (const ext of Object.keys(siteVariables.codeLanguages ?? {})) {
         if (modifiedPath.endsWith(`.${ext}`)) {
           if (literateJavaOutputPaths && sourceUrlPath) {
-            const resolved = modifiedPath.startsWith('/')
-              ? modifiedPath
-              : path.posix.join(
-                  path.posix.dirname(sourceUrlPath),
-                  modifiedPath,
-                );
+            const resolved = resolveAgainstSource(modifiedPath);
             if (literateJavaOutputPaths.has(resolved)) {
               break;
             }
@@ -48,12 +49,7 @@ export default function applyBasePathPlugin(
           // Only rewrite if the .html version exists. Public files with
           // code extensions are copied as-is and have no .html page.
           if (validTargets && sourceUrlPath) {
-            const resolved = modifiedPath.startsWith('/')
-              ? modifiedPath
-              : path.posix.join(
-                  path.posix.dirname(sourceUrlPath),
-                  modifiedPath,
-                );
+            const resolved = resolveAgainstSource(modifiedPath);
             if (!validTargets.has(`${resolved}.html`)) {
               break;
             }
@@ -79,11 +75,7 @@ export default function applyBasePathPlugin(
         const afterApply = applyBasePath(modifiedHref);
         log.debug`Applying base path: ${href} -> ${afterApply}`;
         token.attrSet('href', afterApply);
-      } else if (
-        !href.startsWith('#') &&
-        !href.startsWith('//') &&
-        !/^[a-zA-Z][a-zA-Z\d+.-]*:/.test(href)
-      ) {
+      } else if (isInternalLink(href)) {
         // Relative link: only rewrite code extensions, don't apply base path
         const modifiedHref = rewriteInternalHref(href);
         if (modifiedHref !== href) {
@@ -120,10 +112,10 @@ export default function applyBasePathPlugin(
         );
     }
 
-    token.children?.map(checkAndApplyBasePath);
+    token.children?.forEach(checkAndApplyBasePath);
   }
 
   md.core.ruler.push('apply_base_path', state => {
-    state.tokens.map(checkAndApplyBasePath);
+    state.tokens.forEach(checkAndApplyBasePath);
   });
 }

package/build/colors.ts

@@ -1,25 +1,22 @@
 import util from 'util';
 
-export const R = (str: TemplateStringsArray, ...args: unknown[]): string =>
-  util.styleText(['red'], String.raw(str, ...args));
-export const G = (str: TemplateStringsArray, ...args: unknown[]): string =>
-  util.styleText(['green'], String.raw(str, ...args));
-export const B = (str: TemplateStringsArray, ...args: unknown[]): string =>
-  util.styleText(['blue'], String.raw(str, ...args));
-export const Y = (str: TemplateStringsArray, ...args: unknown[]): string =>
-  util.styleText(['yellow'], String.raw(str, ...args));
-export const L = (str: TemplateStringsArray, ...args: unknown[]): string =>
-  util.styleText(['blackBright'], String.raw(str, ...args));
-export const P = (str: TemplateStringsArray, ...args: unknown[]): string =>
-  util.styleText(['magenta'], String.raw(str, ...args));
-export const I = (str: TemplateStringsArray, ...args: unknown[]): string =>
-  util.styleText(['italic', 'bold'], String.raw(str, ...args));
+type StyleFormat = Parameters<typeof util.styleText>[0];
+type TagFn = (str: TemplateStringsArray, ...args: unknown[]) => string;
 
-export const Ri = (str: TemplateStringsArray, ...args: unknown[]): string =>
-  util.styleText(['inverse', 'red'], String.raw(str, ...args));
-export const Gi = (str: TemplateStringsArray, ...args: unknown[]): string =>
-  util.styleText(['inverse', 'green'], String.raw(str, ...args));
-export const Yi = (str: TemplateStringsArray, ...args: unknown[]): string =>
-  util.styleText(['inverse', 'yellow'], String.raw(str, ...args));
-export const Li = (str: TemplateStringsArray, ...args: unknown[]): string =>
-  util.styleText(['inverse', 'blackBright'], String.raw(str, ...args));
+const style =
+  (styles: StyleFormat): TagFn =>
+  (str, ...args) =>
+    util.styleText(styles, String.raw(str, ...args));
+
+export const R = style(['red']);
+export const G = style(['green']);
+export const B = style(['blue']);
+export const Y = style(['yellow']);
+export const L = style(['blackBright']);
+export const P = style(['magenta']);
+export const I = style(['italic', 'bold']);
+
+export const Ri = style(['inverse', 'red']);
+export const Gi = style(['inverse', 'green']);
+export const Yi = style(['inverse', 'yellow']);
+export const Li = style(['inverse', 'blackBright']);

package/build/content-watch.ts

@@ -2,7 +2,6 @@ import path from 'path';
 import type { SiteVariables } from './types';
 import { getContentDir, getBuildContentFiles, isPartial } from './util';
 import { compileTemplates, getJsonDataDir, JSON_DATA_FILES } from './templates';
-import { getProjectDir } from './utils/paths';
 import { B } from './colors';
 import { makeLogger } from './log';
 
@@ -18,18 +17,16 @@ interface ChangeDetectionResult {
 
 export class ContentChangeDetector {
   private siteVariables: SiteVariables;
-  private siteConfigPath: string;
   private lastSig: string | null;
 
   constructor(siteVariables: SiteVariables) {
     this.siteVariables = siteVariables;
-    this.siteConfigPath = path.resolve(getProjectDir(), 'site.dev.json');
     this.lastSig = null;
   }
 
   detectChanges(modifiedFiles: Iterable<string>): ChangeDetectionResult {
     const resolvedFiles = new Set(
-      [...(modifiedFiles || [])].map(filePath => path.resolve(filePath)),
+      [...modifiedFiles].map(filePath => path.resolve(filePath)),
     );
 
     const jsonDataDir = getJsonDataDir();
@@ -75,16 +72,14 @@ export class ContentChangeDetector {
       jsonDataPaths.includes(filePath),
     );
     const jsonDataChanged = changedJsonDataPaths.length > 0;
-    const partialsChanged = [...changedContentFiles].some(f => isPartial(f));
+    const changedPartials = [...changedContentFiles].filter(f => isPartial(f));
+    const partialsChanged = changedPartials.length > 0;
 
     for (const filePath of changedJsonDataPaths) {
       log.event`${B`${path.basename(filePath)}`} changed, rebuilding`;
     }
 
     if (partialsChanged) {
-      const changedPartials = [...changedContentFiles].filter(f =>
-        isPartial(f),
-      );
       for (const filePath of changedPartials) {
         log.event`Partial ${B`${path.basename(filePath)}`} changed, rebuilding`;
       }
@@ -97,14 +92,6 @@ export class ContentChangeDetector {
       log.event`${B`${path.basename(filePath)}`} changed, re-running traces`;
     }
 
-    // Check if site config changed
-    const siteConfigChanged = resolvedFiles.has(
-      path.resolve(this.siteConfigPath),
-    );
-    if (siteConfigChanged) {
-      needsRestart = true;
-    }
-
     return {
       templateError: null,
       needsRestart,

package/build/copy.ts

@@ -15,8 +15,11 @@ function collectFiles(dir: string): CollectedFile[] {
   let entries: fs.Dirent[];
   try {
     entries = fs.readdirSync(dir, { withFileTypes: true, recursive: true });
-  } catch {
-    return [];
+  } catch (err: unknown) {
+    if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+      return [];
+    }
+    throw err;
   }
   return entries
     .filter(entry => entry.isFile())
@@ -59,7 +62,7 @@ export function copyContentAssets(
       continue;
     }
     contentAssetRelPaths.add(rel);
-    if (publicRelPaths && publicRelPaths.has(rel)) {
+    if (publicRelPaths.has(rel)) {
       conflicts.push(rel);
     }
     const dest = path.join(distDir, rel);
@@ -78,21 +81,41 @@ export function copyContentAssets(
   return contentAssetRelPaths;
 }
 
-export function copyPublicFile(
-  publicDir: string,
+function copySingleFile(
+  sourceDir: string,
   distDir: string,
   filePath: string,
-  contentAssetRelPaths?: Set<string>,
+  sourceLabel: string,
+  conflictLabel: string,
+  conflictSet?: Set<string>,
 ): void {
-  const rel = toPosix(path.relative(publicDir, filePath));
-  if (contentAssetRelPaths && contentAssetRelPaths.has(rel)) {
-    log.error`public/${B`${rel}`} conflicts with content/${B`${rel}`}`;
-    throw new Error(`public/${rel} and content/${rel} have the same path`);
+  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 public file ${B`${rel}`}`;
+  log.info`Copying ${sourceLabel} file ${B`${rel}`}`;
+}
+
+export function copyPublicFile(
+  publicDir: string,
+  distDir: string,
+  filePath: string,
+  contentAssetRelPaths?: Set<string>,
+): void {
+  copySingleFile(
+    publicDir,
+    distDir,
+    filePath,
+    'public',
+    'content',
+    contentAssetRelPaths,
+  );
 }
 
 export function copyContentFile(
@@ -101,13 +124,12 @@ export function copyContentFile(
   filePath: string,
   publicRelPaths?: Set<string>,
 ): void {
-  const rel = toPosix(path.relative(contentDir, filePath));
-  if (publicRelPaths && publicRelPaths.has(rel)) {
-    log.error`content/${B`${rel}`} conflicts with public/${B`${rel}`}`;
-    throw new Error(`content/${rel} and public/${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 content file ${B`${rel}`}`;
+  copySingleFile(
+    contentDir,
+    distDir,
+    filePath,
+    'content',
+    'public',
+    publicRelPaths,
+  );
 }

package/build/deflist-id-plugin.ts

@@ -1,5 +1,5 @@
 import type MarkdownIt from 'markdown-it';
-import textToId from './text-to-id';
+import textToId, { deduplicateId } from './text-to-id';
 
 export default function deflistIdPlugin(md: MarkdownIt): void {
   md.core.ruler.push('deflist_id_injector', function (state) {
@@ -7,21 +7,8 @@ export default function deflistIdPlugin(md: MarkdownIt): void {
     const used = new Map<string, number>();
 
     function slugify(str: string): string {
-      let slug = textToId(str);
-
-      if (!slug) {
-        slug = 'term';
-      }
-
-      if (used.has(slug)) {
-        const n = (used.get(slug) as number) + 1;
-        used.set(slug, n);
-        slug = `${slug}-${n}`;
-      } else {
-        used.set(slug, 1);
-      }
-
-      return slug;
+      const base = textToId(str) || 'term';
+      return deduplicateId(used, base);
     }
 
     for (let i = 0; i < tokens.length; i++) {

package/build/features.ts

@@ -1,11 +1,8 @@
-import type { SiteVariables } from './types';
+import type { FeatureConfig, SiteVariables } from './types';
 
 export function isFeatureEnabled(
   siteVariables: SiteVariables,
-  featureName: string,
+  featureName: keyof FeatureConfig,
 ): boolean {
-  return (
-    siteVariables.features?.[featureName as keyof SiteVariables['features']] !==
-    false
-  );
+  return siteVariables.features[featureName] !== false;
 }

package/build/generate-content-assets.ts

@@ -44,12 +44,16 @@ export class ContentRenderer {
   > = new Map();
 
   constructor(siteVariables: SiteVariables) {
-    this.siteVariables = siteVariables || {};
+    this.siteVariables = siteVariables;
     this.loggedCodeDisabled = false;
     this.sourceFileCache = new Map();
     this.lastBuildFiles = new Set();
   }
 
+  private getCachedAssets(filePath: string): Asset[] {
+    return this.sourceFileCache.get(filePath) ?? [];
+  }
+
   async initHighlighter(): Promise<void> {
     const langs = [
       ...new Set([
@@ -210,7 +214,7 @@ export class ContentRenderer {
     changedHtmlAssetPaths: Set<string>,
     removedHtmlAssetPaths: Set<string>,
   ): void {
-    const previousAssets = this.sourceFileCache.get(filePath) || [];
+    const previousAssets = this.getCachedAssets(filePath);
     const nextAssetPaths = new Set(assets.map(asset => asset.assetPath));
 
     for (const asset of previousAssets) {
@@ -233,7 +237,7 @@ export class ContentRenderer {
 
   writeCachedAssets(distDir: string, buildContentFiles: string[]): void {
     for (const filePath of buildContentFiles) {
-      const assets = this.sourceFileCache.get(filePath) || [];
+      const assets = this.getCachedAssets(filePath);
       for (const asset of assets) {
         const outPath = path.join(distDir, asset.assetPath);
         fs.mkdirSync(path.dirname(outPath), { recursive: true });
@@ -251,7 +255,7 @@ export class ContentRenderer {
         continue;
       }
 
-      const previousAssets = this.sourceFileCache.get(filePath) || [];
+      const previousAssets = this.getCachedAssets(filePath);
       for (const asset of previousAssets) {
         if (asset.assetPath.endsWith('.html')) {
           removedHtmlAssetPaths.add(asset.assetPath);
@@ -352,7 +356,7 @@ export class ContentRenderer {
     // Collect HTML asset content for Pagefind
     const htmlAssetsByPath = new Map<string, string>();
     for (const filePath of buildContentFiles) {
-      const assets = this.sourceFileCache.get(filePath) || [];
+      const assets = this.getCachedAssets(filePath);
       for (const asset of assets) {
         if (asset.assetPath.endsWith('.html')) {
           htmlAssetsByPath.set(asset.assetPath, asset.content as string);

package/build/generate-favicon.ts

@@ -10,6 +10,8 @@ import type { SiteVariables } from './types';
 
 const log = makeLogger(import.meta.url);
 
+export const FAVICON_SIZES = [16, 32, 48, 64, 128, 192, 256, 512, 1024];
+
 const FONT_PATH = path.join(
   getPackageDir(),
   'fonts',
@@ -110,24 +112,12 @@ export async function generateFavicons(
   siteVariables: SiteVariables,
   distDir: string,
 ): Promise<void> {
-  const color = siteVariables.faviconColor;
-  const symbol = siteVariables.faviconSymbol;
+  const color = siteVariables.faviconColor!;
+  const symbol = siteVariables.faviconSymbol!;
   const fontWeight = siteVariables.faviconFontWeight || 700;
-  const sizes = [16, 32, 48, 64, 128, 192, 256, 512, 1024];
   const svgSize = 512;
   const filenameBase = 'favicon';
 
-  if (!symbol) {
-    throw new Error(
-      'Favicon generation requires "symbol" in site config (or "faviconSymbol")',
-    );
-  }
-  if (!color) {
-    throw new Error(
-      'Favicon generation requires "themeColor" in site config (or "faviconColor")',
-    );
-  }
-
   const { themeColorLight, textOnThemeLight } = deriveTheme(color);
 
   log.info`Generating favicons`;
@@ -145,7 +135,7 @@ export async function generateFavicons(
   fs.writeFileSync(path.join(distDir, `${filenameBase}.svg`), svgMarkup);
 
   const pngBuffers = await Promise.all(
-    sizes.map(async size => {
+    FAVICON_SIZES.map(async size => {
       const svgForSize = createFaviconSvg(
         size,
         themeColorLight,

package/build/generate-web-app-manifest.ts

@@ -1,6 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 import { createApplyBasePath } from './util';
+import { FAVICON_SIZES } from './generate-favicon';
 import type { SiteVariables } from './types';
 
 interface ManifestIcon {
@@ -19,6 +20,20 @@ interface WebAppManifest {
 
 function createManifest(siteVariables: SiteVariables): WebAppManifest {
   const applyBasePath = createApplyBasePath(siteVariables);
+  const filenameBase = 'favicon';
+
+  const pngIcons: ManifestIcon[] = [...FAVICON_SIZES]
+    .sort((a, b) => b - a)
+    .map(size => ({
+      src: `${filenameBase}-${size}.png`,
+      sizes: `${size}x${size}`,
+      type: 'image/png',
+      purpose: size >= 128 ? 'any maskable' : 'any',
+    }));
+
+  const icoSizes = FAVICON_SIZES.filter(s => s <= 256)
+    .map(s => `${s}x${s}`)
+    .join(' ');
 
   return {
     name: siteVariables.title,
@@ -26,68 +41,15 @@ function createManifest(siteVariables: SiteVariables): WebAppManifest {
     display: 'minimal-ui',
     icons: [
       {
-        src: 'favicon.svg',
+        src: `${filenameBase}.svg`,
         sizes: 'any',
         type: 'image/svg+xml',
         purpose: 'any maskable',
       },
+      ...pngIcons,
       {
-        src: 'favicon-1024.png',
-        sizes: '1024x1024',
-        type: 'image/png',
-        purpose: 'any maskable',
-      },
-      {
-        src: 'favicon-512.png',
-        sizes: '512x512',
-        type: 'image/png',
-        purpose: 'any maskable',
-      },
-      {
-        src: 'favicon-256.png',
-        sizes: '256x256',
-        type: 'image/png',
-        purpose: 'any maskable',
-      },
-      {
-        src: 'favicon-192.png',
-        sizes: '192x192',
-        type: 'image/png',
-        purpose: 'any maskable',
-      },
-      {
-        src: 'favicon-128.png',
-        sizes: '128x128',
-        type: 'image/png',
-        purpose: 'any maskable',
-      },
-      {
-        src: 'favicon-64.png',
-        sizes: '64x64',
-        type: 'image/png',
-        purpose: 'any',
-      },
-      {
-        src: 'favicon-48.png',
-        sizes: '48x48',
-        type: 'image/png',
-        purpose: 'any',
-      },
-      {
-        src: 'favicon-32.png',
-        sizes: '32x32',
-        type: 'image/png',
-        purpose: 'any',
-      },
-      {
-        src: 'favicon-16.png',
-        sizes: '16x16',
-        type: 'image/png',
-        purpose: 'any',
-      },
-      {
-        src: 'favicon.ico',
-        sizes: '16x16 32x32 48x48 64x64 128x128 192x192 256x256',
+        src: `${filenameBase}.ico`,
+        sizes: icoSizes,
         type: 'image/x-icon',
         purpose: 'any maskable',
       },

package/build/globals.ts

@@ -1,6 +1,22 @@
 import timezones from '../src/timezone/timezones.json' with { type: 'json' };
 import type { SiteVariables } from './types';
 
+const MONTHS = [
+  '',
+  'January',
+  'February',
+  'March',
+  'April',
+  'May',
+  'June',
+  'July',
+  'August',
+  'September',
+  'October',
+  'November',
+  'December',
+];
+
 interface Globals {
   isHomePage: boolean;
   isoDate: (str: string | null | undefined) => string | null;
@@ -58,31 +74,10 @@ function readableDate(date: string | Date | null | undefined): string {
 
   const str = date.toISOString();
   const year = str.slice(0, 4);
-  let month: string = str.slice(5, 7);
-  if (month[0] === '0') {
-    month = month[1];
-  }
-  let day: string = str.slice(8, 10);
-  if (day[0] === '0') {
-    day = day[1];
-  }
-
-  const months: Record<string, string> = {
-    1: 'January',
-    2: 'February',
-    3: 'March',
-    4: 'April',
-    5: 'May',
-    6: 'June',
-    7: 'July',
-    8: 'August',
-    9: 'September',
-    10: 'October',
-    11: 'November',
-    12: 'December',
-  };
+  const month = Number(str.slice(5, 7));
+  const day = Number(str.slice(8, 10));
 
-  return `${months[month]} ${day}, ${year}`;
+  return `${MONTHS[month]} ${day}, ${year}`;
 }
 
 export function classNames(obj: Record<string, unknown>): string {