@abreen/tada 1.6.4 → 1.7.1

package/build/log.ts

@@ -48,64 +48,58 @@ export function makeLogger(name: string, logLevel: string = 'info'): Logger {
     logLevel = ENV_LOG_LEVEL;
   }
 
-  if (!name) {
-    name = '';
-  } else {
-    // Allow for passing import.meta.url (file:// URL) or a plain path
+  if (name) {
     if (name.startsWith('file://')) {
       name = new URL(name).pathname;
     }
     name = path.basename(name, path.extname(name));
   }
 
+  function getArgs(
+    level: string,
+    strings: TemplateStringsArray | string | string[],
+    args: unknown[],
+    labelFn: (strings: TemplateStringsArray, ...args: unknown[]) => string,
+  ): string[] {
+    return [
+      labelFn` ${level} ` + ' ' + (level === 'debug' ? name + ' ' : ''),
+      format(strings, ...args),
+    ];
+  }
+
   const logger: Logger = {
     minLogLevel: logLevel,
-    /** Don't log if the level is < minLogLevel */
     setMinLogLevel(minLogLevel: string) {
       this.minLogLevel = minLogLevel;
     },
-    getArgs(
-      level: string,
-      strings: TemplateStringsArray | string | string[],
-      args: unknown[],
-      labelFn: (strings: TemplateStringsArray, ...args: unknown[]) => string,
-    ): string[] {
-      const params: string[] = [];
-      params.push(
-        labelFn` ${level} ` + ' ' + (level === 'debug' ? name + ' ' : ''),
-      );
-      params.push(format(strings, ...args));
-      return params;
-    },
     debug(strings: TemplateStringsArray, ...args: unknown[]) {
       if (shouldLog(this.minLogLevel, 'debug')) {
-        print(this.getArgs('debug', strings, args, L), 'stderr');
+        print(getArgs('debug', strings, args, L), 'stderr');
       }
     },
     info(strings: TemplateStringsArray, ...args: unknown[]) {
       if (shouldLog(this.minLogLevel, 'info')) {
-        print(this.getArgs('info', strings, args, Li));
+        print(getArgs('info', strings, args, Li));
       }
     },
     warn(strings: TemplateStringsArray, ...args: unknown[]) {
       if (shouldLog(this.minLogLevel, 'warn')) {
-        print(this.getArgs('warn', strings, args, Yi));
+        print(getArgs('warn', strings, args, Yi));
       }
     },
     error(strings: TemplateStringsArray, ...args: unknown[]) {
       if (shouldLog(this.minLogLevel, 'error')) {
-        print(this.getArgs('error', strings, args, Ri));
+        print(getArgs('error', strings, args, Ri));
       }
     },
     event(strings: TemplateStringsArray, ...args: unknown[]) {
-      print(this.getArgs('event', strings, args, Gi));
+      print(getArgs('event', strings, args, Gi));
     },
     followup(strings: string[]) {
       print(strings);
     },
   };
 
-  logger.setMinLogLevel(logLevel);
   return logger;
 }
 
@@ -118,7 +112,7 @@ function format(
     try {
       return String.raw(strings as TemplateStringsArray, ...args.map(toString));
     } catch {
-      // fallback to safe join
+      return '';
     }
   } else {
     if (Array.isArray(strings)) {
@@ -129,35 +123,25 @@ function format(
 
     return args.map(toString).join(' ');
   }
-
-  return '';
 }
 
 function toString(item: unknown): string {
-  if (item === undefined) {
-    return 'undefined';
-  }
-  if (item === null) {
-    return 'null';
+  if (item == null) {
+    return String(item);
   }
   if (typeof item === 'string') {
     return item;
   }
-
-  try {
-    if (typeof item === 'object') {
-      return inspect(item, {
-        compact: true,
-        depth: 2,
-        breakLength: 80,
-        maxStringLength: 250,
-        colors: true,
-      });
-    }
-    throw new Error('not an object');
-  } catch {
-    return String(item);
+  if (typeof item === 'object') {
+    return inspect(item, {
+      compact: true,
+      depth: 2,
+      breakLength: 80,
+      maxStringLength: 250,
+      colors: true,
+    });
   }
+  return String(item);
 }
 
 export function getFlair(): string {

package/build/pagefind.ts

@@ -101,7 +101,7 @@ function collectIndexTargets(
     htmlAssetsByPath,
     knownPdfPaths: new Set(pdfSourceByOutputPath.keys()),
     rootPath: 'index.html',
-    basePath: siteVariables?.basePath || '/',
+    basePath: siteVariables.basePath || '/',
   });
 }
 
@@ -264,7 +264,7 @@ export class WatchPagefindRunner {
   private htmlCacheByAssetPath: Map<string, string>;
 
   constructor(siteVariables: SiteVariables) {
-    this.siteVariables = siteVariables || {};
+    this.siteVariables = siteVariables;
     this.watchRunInProgress = false;
     this.watchRunQueued = false;
     this.distPath = null;

package/build/reachability.ts

@@ -24,7 +24,7 @@ function normalizeUrlPath(pathname: string): string {
 
 function stripBasePath(pathname: string, basePath: string): string {
   const normalizedPath = normalizeUrlPath(pathname);
-  const normalizedBasePath = normalizeUrlPath(basePath || '/');
+  const normalizedBasePath = normalizeUrlPath(basePath);
 
   if (normalizedBasePath === '/') {
     return normalizedPath;

package/build/serve.ts

@@ -29,10 +29,6 @@ export function resolvePathname(
     return null;
   }
 
-  if (stat.isDirectory()) {
-    return null;
-  }
-
   if (!stat.isFile()) {
     return null;
   }
@@ -81,7 +77,7 @@ export function startServer(options: StartServerOptions): void {
 
     log.info`Dev server: ${B`http://localhost:${server.port}/index.html`}`;
     if (onReady) {
-      onReady(server.port as number);
+      onReady(server.port!);
     }
   } catch (err) {
     log.error`Failed to start server on port ${port}: ${err}`;

package/build/site-variables.ts

@@ -39,12 +39,12 @@ function getSiteVariables(env: string): SiteVariables {
   }
 
   // Derive faviconColor from themeColor if not explicitly set
-  if (variables.themeColor && !variables.faviconColor) {
+  if (!variables.faviconColor) {
     variables.faviconColor = variables.themeColor;
   }
 
   // Derive titlePostfix from title if not explicitly set
-  if (variables.title && !variables.titlePostfix) {
+  if (!variables.titlePostfix) {
     variables.titlePostfix = ` - ${variables.title}`;
   }
 

package/build/templates.ts

@@ -3,7 +3,7 @@ import path from 'path';
 import _ from 'lodash';
 import { compile as compileJsonSchema, doValidation } from './json-schema';
 import { makeLogger } from './log';
-import { getPackageDir, getConfigDir } from './utils/paths';
+import { getPackageDir, getProjectDir } from './utils/paths';
 import type { ValidateFunction } from 'ajv';
 import type { Logger, SiteVariables } from './types';
 
@@ -35,7 +35,7 @@ function getHtmlTemplatesDir(): string {
 }
 
 function getJsonDataDir(): string {
-  return getConfigDir();
+  return getProjectDir();
 }
 
 export function json(fileName: string): unknown {

package/build/text-to-id.ts

@@ -6,3 +6,9 @@ export default function textToId(value: unknown): string {
     .replace(/\s+/g, '-')
     .replace(/[^\w-]/g, '');
 }
+
+export function deduplicateId(used: Map<string, number>, id: string): string {
+  const count = (used.get(id) ?? 0) + 1;
+  used.set(id, count);
+  return count === 1 ? id : `${id}-${count}`;
+}

package/build/types.d.ts

@@ -11,7 +11,7 @@ export interface SiteVariables {
   faviconFontWeight?: number;
   internalDomains?: string[];
   defaultTimeZone: string;
-  features?: FeatureConfig;
+  features: FeatureConfig;
   codeLanguages?: Record<string, string>;
   tintHue?: number;
   tintAmount?: number;
@@ -57,12 +57,6 @@ export interface ContentRenderResult {
 export interface Logger {
   minLogLevel: string;
   setMinLogLevel(level: string): void;
-  getArgs(
-    level: string,
-    strings: TemplateStringsArray | string | string[],
-    args: unknown[],
-    colorFn: (strings: TemplateStringsArray, ...args: unknown[]) => string,
-  ): string[];
   debug(strings: TemplateStringsArray, ...args: unknown[]): void;
   info(strings: TemplateStringsArray, ...args: unknown[]): void;
   warn(strings: TemplateStringsArray, ...args: unknown[]): void;

package/build/utils/code.ts

@@ -7,6 +7,7 @@ import { getHighlighter } from './shiki-highlighter';
 import externalLinksPlugin from '../external-links-plugin';
 import applyBasePathPlugin from '../apply-base-path-plugin';
 import { createApplyBasePath } from './paths';
+import { splitLines } from './literate-java';
 import type { JavaTocEntry, SiteVariables } from '../types';
 
 interface CstNode {
@@ -73,9 +74,7 @@ export function rewriteProseLinks(
 
   function rewriteHref(href: string): string {
     // Separate pathname from query/fragment
-    const match = href.match(/^([^?#]*)(.*)$/);
-    const pathname = match ? match[1] : href;
-    const suffix = match ? match[2] : '';
+    const [, pathname, suffix] = href.match(/^([^?#]*)(.*)$/)!;
 
     // Leave external, protocol-relative, and anchor-only links unchanged
     if (
@@ -509,10 +508,7 @@ export function renderCodeWithComments(
   pageDirPath?: string,
 ): string {
   const md = createCodeMarkdown(siteVariables);
-  const lines = sourceCode.split('\n');
-  if (lines[lines.length - 1] === '') {
-    lines.pop();
-  }
+  const lines = splitLines(sourceCode);
 
   // Group lines into segments
   const segments: CodeSegment[] = [];

package/build/utils/front-matter.ts

@@ -57,11 +57,39 @@ function parseFrontMatterPlainText(rawContent: string): RawParsedFrontMatter {
   };
 }
 
+function parseFrontMatterStandard(rawContent: string): RawParsedFrontMatter {
+  const lines = rawContent.split(/\r?\n/);
+
+  // Caller has already verified lines[0] === '---'
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i].trimEnd() === '---') {
+      return {
+        frontMatter: lines.slice(1, i).join('\n'),
+        content: lines.slice(i + 1).join('\n'),
+      };
+    }
+  }
+
+  throw new Error(
+    'Front matter starts with --- but no closing --- delimiter was found',
+  );
+}
+
 export function parseFrontMatter(
   rawContent: string,
   ext: string,
 ): RawParsedFrontMatter {
   if (extensionIsMarkdown(ext) || ext === '.html') {
+    // Detect standard YAML front matter (first line is exactly ---,
+    // ignoring trailing whitespace and \r)
+    const firstNewline = rawContent.indexOf('\n');
+    const firstLine =
+      firstNewline === -1 ? rawContent : rawContent.slice(0, firstNewline);
+
+    if (firstLine.trimEnd() === '---') {
+      return parseFrontMatterStandard(rawContent);
+    }
+
     return parseFrontMatterPlainText(rawContent);
   } else {
     // unknown type, return raw

package/build/utils/link.ts

@@ -0,0 +1,8 @@
+const SCHEME_RE = /^[a-zA-Z][a-zA-Z\d+.-]*:/;
+
+export function isInternalLink(href: string | undefined): boolean {
+  if (!href || href.startsWith('#') || href.startsWith('//')) {
+    return false;
+  }
+  return !SCHEME_RE.test(href);
+}

package/build/utils/literate-java.ts

@@ -14,6 +14,37 @@ import type {
 
 const log = makeLogger(import.meta.url);
 
+export function runJavac(
+  args: string[],
+  opts: { cwd?: string; tempDir: string; label: string },
+): void {
+  try {
+    execFileSync('javac', args, {
+      cwd: opts.cwd,
+      timeout: 30000,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+  } catch (err: unknown) {
+    const execErr = err as { stderr?: Buffer; message: string };
+    const stderr = execErr.stderr ? execErr.stderr.toString() : execErr.message;
+    fs.rmSync(opts.tempDir, { recursive: true, force: true });
+    throw new Error(`${opts.label}:\n${stderr}`, { cause: err });
+  }
+}
+
+export function getExecError(err: unknown): string {
+  const execErr = err as { stderr?: Buffer; message: string };
+  return execErr.stderr ? execErr.stderr.toString() : execErr.message;
+}
+
+export function splitLines(source: string): string[] {
+  const lines = source.split('\n');
+  if (lines.length > 0 && lines[lines.length - 1] === '') {
+    lines.pop();
+  }
+  return lines;
+}
+
 let runnerClassDir: string | null = null;
 
 const MAIN_PATTERN = /\bvoid\s+main\s*\(/m;
@@ -95,20 +126,11 @@ export function compileJavaSource(
 
   log.debug`Compiling ${className}.java (${javaSource.split('\n').length} lines) in ${tempDir}`;
 
-  try {
-    execFileSync('javac', [`${className}.java`], {
-      cwd: tempDir,
-      timeout: 30000,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-  } catch (err: unknown) {
-    const execErr = err as { stderr?: Buffer; message: string };
-    const stderr = execErr.stderr ? execErr.stderr.toString() : execErr.message;
-    fs.rmSync(tempDir, { recursive: true, force: true });
-    throw new Error(`Compilation failed for ${className}.java:\n${stderr}`, {
-      cause: err,
-    });
-  }
+  runJavac([`${className}.java`], {
+    cwd: tempDir,
+    tempDir,
+    label: `Compilation failed for ${className}.java`,
+  });
 
   return tempDir;
 }
@@ -127,19 +149,10 @@ function ensureRunnerCompiled(): string {
 
   log.debug`Compiling LiterateRunner.java into ${tempDir}`;
 
-  try {
-    execFileSync('javac', ['-d', tempDir, sourceFile], {
-      timeout: 30000,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-  } catch (err: unknown) {
-    const execErr = err as { stderr?: Buffer; message: string };
-    const stderr = execErr.stderr ? execErr.stderr.toString() : execErr.message;
-    fs.rmSync(tempDir, { recursive: true, force: true });
-    throw new Error(`Failed to compile LiterateRunner.java:\n${stderr}`, {
-      cause: err,
-    });
-  }
+  runJavac(['-d', tempDir, sourceFile], {
+    tempDir,
+    label: 'Failed to compile LiterateRunner.java',
+  });
 
   runnerClassDir = tempDir;
   return tempDir;
@@ -174,12 +187,8 @@ export function executeLiterateJava(
     log.debug`LiterateRunner returned ${entries.length} output entries`;
     return entries;
   } catch (err: unknown) {
-    const execErr = err as {
-      stderr?: Buffer | string;
-      stdout?: Buffer | string;
-      message: string;
-    };
-    const stderr = execErr.stderr ? execErr.stderr.toString() : '';
+    const execErr = err as { stdout?: Buffer | string; message: string };
+    const stderr = getExecError(err);
     const stdout = execErr.stdout ? execErr.stdout.toString() : '';
     throw new Error(
       `Execution failed for ${className}:\n${stderr || stdout || execErr.message}`,

package/build/utils/markdown.ts

@@ -7,7 +7,7 @@ import markdownItAnchor from 'markdown-it-anchor';
 import markdownItFootnote from 'markdown-it-footnote';
 import markdownItDeflist from 'markdown-it-deflist';
 import markdownItContainer from 'markdown-it-container';
-import textToId from '../text-to-id';
+import textToId, { deduplicateId } from '../text-to-id';
 import { getHighlighter } from './shiki-highlighter';
 import headingSubtitlePlugin from '../heading-subtitle-plugin';
 import deflistIdPlugin from '../deflist-id-plugin';
@@ -21,6 +21,10 @@ import katex from 'katex';
 import renderA11yString from 'katex/contrib/render-a11y-string';
 import type { SiteVariables } from '../types';
 
+const DETAILS_PATTERN = /^details\s+(.*)$/;
+const ALERT_PATTERN = /^(note|warning)(?:\s+"(.+)"|\s+(.+))?$/;
+const QUESTION_PATTERN = /^question\s+(.+)$/;
+
 interface CreateMarkdownOptions {
   validatorOptions?: Record<string, unknown>;
   literateJavaOutputPaths?: Set<string>;
@@ -29,11 +33,7 @@ interface CreateMarkdownOptions {
 }
 
 function capitalize(str: string): string {
-  if (str.length < 2) {
-    return str;
-  }
-
-  return str[0].toUpperCase() + str.slice(1);
+  return str.charAt(0).toUpperCase() + str.slice(1);
 }
 
 const MAX_FOOTNOTES = 35;
@@ -81,11 +81,11 @@ export function createMarkdown(
     .use(markdownItContainer, 'details', {
       marker: '<',
       validate: function (params: string) {
-        return !!params.trim().match(/^details\s+(.*)$/);
+        return DETAILS_PATTERN.test(params.trim());
       },
 
       render: function (tokens: Token[], idx: number) {
-        const m = tokens[idx].info.trim().match(/^details\s+(.*)$/);
+        const m = tokens[idx].info.trim().match(DETAILS_PATTERN);
 
         if (tokens[idx].nesting === 1) {
           return (
@@ -144,7 +144,7 @@ export function createMarkdown(
   markdown.use(markdownItContainer, 'alert', {
     marker: '!',
     validate: function (params: string) {
-      return !!params.trim().match(/^(note|warning)(?:\s+"(.+)"|\s+(.+))?$/);
+      return ALERT_PATTERN.test(params.trim());
     },
     render: function (
       tokens: Token[],
@@ -152,9 +152,7 @@ export function createMarkdown(
       _options: unknown,
       env: Record<string, unknown>,
     ) {
-      const matches = tokens[idx].info
-        .trim()
-        .match(/^(note|warning)(?:\s+"(.+)"|\s+(.+))?$/);
+      const matches = tokens[idx].info.trim().match(ALERT_PATTERN);
 
       if (tokens[idx].nesting === 1) {
         const classNames = ['alert'];
@@ -168,9 +166,7 @@ export function createMarkdown(
           ? markdown.utils.escapeHtml(curlyQuote(title))
           : capitalize(type || '');
         const baseId = textToId(title || type || '');
-        const count = (usedIds.get(baseId) ?? 0) + 1;
-        usedIds.set(baseId, count);
-        const titleId = count === 1 ? baseId : `${baseId}-${count}`;
+        const titleId = deduplicateId(usedIds, baseId);
 
         if (!env.alertIds) {
           env.alertIds = [];
@@ -190,10 +186,10 @@ export function createMarkdown(
   markdown.use(markdownItContainer, 'question', {
     marker: '?',
     validate: function (params: string) {
-      return !!params.trim().match(/^question\s+(.+)$/);
+      return QUESTION_PATTERN.test(params.trim());
     },
     render: function (tokens: Token[], idx: number) {
-      const m = tokens[idx].info.trim().match(/^question\s+(.+)$/);
+      const m = tokens[idx].info.trim().match(QUESTION_PATTERN);
       if (tokens[idx].nesting === 1) {
         const question = markdown.renderInline(m![1]);
         return (

package/build/utils/paths.ts

@@ -25,23 +25,15 @@ export function getPublicDir(): string {
   return path.resolve(getProjectDir(), 'public');
 }
 
-export function getConfigDir(): string {
-  return getProjectDir();
-}
-
 export function createApplyBasePath(
   siteVariables: SiteVariables,
 ): (subPath: string) => string {
+  const base = (siteVariables.basePath || '/').replace(/\/$/, '');
   return function applyBasePath(subPath: string): string {
     if (!subPath.startsWith('/')) {
       throw new Error('invalid internal path, must start with "/": ' + subPath);
     }
-
-    let path = siteVariables.basePath || '/';
-    if (path.endsWith('/')) {
-      path = path.slice(0, -1);
-    }
-    return path + subPath;
+    return base + subPath;
   };
 }
 
@@ -62,7 +54,7 @@ export function toUrlPath(p: string): string {
 
 export function normalizeOutputPath(outputPath: string): string {
   const normalized = path.posix.normalize(toPosix(outputPath));
-  if (normalized === '.' || normalized === '') {
+  if (normalized === '.') {
     return '/';
   }
   return normalized.startsWith('/') ? normalized : `/${normalized}`;

package/build/utils/render.ts

@@ -1,6 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 import _ from 'lodash';
+import type MarkdownIt from 'markdown-it';
 import { stripHtml } from 'string-strip-html';
 import { isFeatureEnabled } from '../features';
 import { makeLogger } from '../log';
@@ -50,6 +51,20 @@ function isWatchMode(assetFiles: string[]): boolean {
   return assetFiles.some(f => f.includes('watch-reload-client'));
 }
 
+function renderInlineField(
+  md: MarkdownIt,
+  vars: Record<string, unknown>,
+  field: string,
+): void {
+  const raw = vars[field];
+  if (!raw || typeof raw !== 'string') {
+    return;
+  }
+  const html = md.renderInline(raw);
+  vars[`${field}Html`] = html;
+  vars[field] = stripHtml(html).result;
+}
+
 interface TemplateParametersInput {
   pageVariables: Record<string, unknown>;
   siteVariables: SiteVariables;
@@ -410,35 +425,16 @@ function renderPlainTextContent(
     subPath,
     isWatchMode,
   });
-  const pageVariablesProcessed: Record<string, unknown> = Object.entries(
-    pageVariables,
-  )
-    .map(([k, v]) => {
-      const newValue =
-        typeof v === 'string' ? _.template(v)(siteOnlyParams) : v;
-      return [k, newValue] as [string, unknown];
-    })
-    .reduce(
-      (acc, [k, v]) => {
-        acc[k] = v;
-        return acc;
-      },
-      {} as Record<string, unknown>,
-    );
+  const pageVariablesProcessed: Record<string, unknown> = Object.fromEntries(
+    Object.entries(pageVariables).map(([k, v]) => [
+      k,
+      typeof v === 'string' ? _.template(v)(siteOnlyParams) : v,
+    ]),
+  );
 
   // Render title and description as inline Markdown
-  if (pageVariablesProcessed.title) {
-    const titleHtml = md.renderInline(pageVariablesProcessed.title as string);
-    pageVariablesProcessed.titleHtml = titleHtml;
-    pageVariablesProcessed.title = stripHtml(titleHtml).result;
-  }
-  if (pageVariablesProcessed.description) {
-    const descriptionHtml = md.renderInline(
-      pageVariablesProcessed.description as string,
-    );
-    pageVariablesProcessed.descriptionHtml = descriptionHtml;
-    pageVariablesProcessed.description = stripHtml(descriptionHtml).result;
-  }
+  renderInlineField(md, pageVariablesProcessed, 'title');
+  renderInlineField(md, pageVariablesProcessed, 'description');
 
   resolveAuthor(pageVariablesProcessed, filePath);
 
@@ -620,10 +616,7 @@ export function renderLiterateJavaPageAsset({
         : null;
 
     if (output) {
-      const escapedOutput = output
-        .replace(/&/g, '&amp;')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;');
+      const escapedOutput = md.utils.escapeHtml(output);
       return `<div class="literate-code-output">${codeHtml}<pre>${escapedOutput}</pre></div>`;
     }
 
@@ -641,9 +634,7 @@ export function renderLiterateJavaPageAsset({
     ),
   );
 
-  const titleHtml = md.renderInline(pageVariables.title as string);
-  pageVariables.titleHtml = titleHtml;
-  pageVariables.title = stripHtml(titleHtml).result;
+  renderInlineField(md, pageVariables, 'title');
   pageVariables.template = 'literate';
   pageVariables.codeFilePath = codeFilePath;
   pageVariables.downloadName = javaFileName;