@abreen/tada 1.11.3 → 1.13.2

package/watch/fs-commit.ts

@@ -1,5 +1,6 @@
 import fs from 'fs';
 import path from 'path';
+import { globals, type Globals } from '../build/globals';
 import type {
   ApplyMutationsCommitPlan,
   CommitPlan,
@@ -7,6 +8,17 @@ import type {
   ReplaceRootCommitPlan,
 } from './types';
 
+type CommitPlanGlobals = Pick<Globals, 'now' | 'pid' | 'sleepSync'>;
+
+const TRANSIENT_RENAME_ERROR_CODES = new Set([
+  'EACCES',
+  'EBUSY',
+  'ENOTEMPTY',
+  'EPERM',
+]);
+const RENAME_RETRY_DELAY_MS = 25;
+const RENAME_RETRY_COUNT = 8;
+
 function removeDirIfExists(dir: string): void {
   fs.rmSync(dir, { recursive: true, force: true });
 }
@@ -15,6 +27,39 @@ function ensureParentDir(filePath: string): void {
   fs.mkdirSync(path.dirname(filePath), { recursive: true });
 }
 
+function isTransientRenameError(
+  error: unknown,
+  sourcePath: string,
+): error is NodeJS.ErrnoException {
+  const code = (error as NodeJS.ErrnoException | undefined)?.code;
+  return (
+    typeof code === 'string' &&
+    TRANSIENT_RENAME_ERROR_CODES.has(code) &&
+    fs.existsSync(sourcePath)
+  );
+}
+
+function renameWithRetry(
+  sourcePath: string,
+  targetPath: string,
+  globals: CommitPlanGlobals,
+): void {
+  for (let attempt = 0; attempt <= RENAME_RETRY_COUNT; attempt++) {
+    try {
+      fs.renameSync(sourcePath, targetPath);
+      return;
+    } catch (error) {
+      if (
+        attempt === RENAME_RETRY_COUNT ||
+        !isTransientRenameError(error, sourcePath)
+      ) {
+        throw error;
+      }
+      globals.sleepSync(RENAME_RETRY_DELAY_MS);
+    }
+  }
+}
+
 function pruneEmptyDirs(rootDir: string, filePath: string): void {
   let currentDir = path.dirname(filePath);
   const root = path.resolve(rootDir);
@@ -36,6 +81,7 @@ function applyFileMutation(
   rootDir: string,
   mutation: FileMutation,
   stagedRoot: string,
+  globals: CommitPlanGlobals,
 ): void {
   const targetPath = path.join(rootDir, mutation.path);
   const stagedPath = path.join(stagedRoot, mutation.path);
@@ -44,7 +90,7 @@ function applyFileMutation(
     ensureParentDir(stagedPath);
     fs.writeFileSync(stagedPath, mutation.content);
     ensureParentDir(targetPath);
-    fs.renameSync(stagedPath, targetPath);
+    renameWithRetry(stagedPath, targetPath, globals);
     return;
   }
 
@@ -52,7 +98,10 @@ function applyFileMutation(
   pruneEmptyDirs(rootDir, targetPath);
 }
 
-function applyMutations(plan: ApplyMutationsCommitPlan): void {
+function applyMutations(
+  plan: ApplyMutationsCommitPlan,
+  globals: CommitPlanGlobals,
+): void {
   const stagedRoot = fs.mkdtempSync(path.join(plan.rootDir, '.watch-stage-'));
   try {
     for (const mutation of plan.mutations) {
@@ -64,39 +113,43 @@ function applyMutations(plan: ApplyMutationsCommitPlan): void {
     }
 
     for (const mutation of plan.mutations) {
-      applyFileMutation(plan.rootDir, mutation, stagedRoot);
+      applyFileMutation(plan.rootDir, mutation, stagedRoot, globals);
     }
   } finally {
     removeDirIfExists(stagedRoot);
   }
 }
 
-function replaceRoot(plan: ReplaceRootCommitPlan): void {
+function replaceRoot(
+  plan: ReplaceRootCommitPlan,
+  globals: CommitPlanGlobals,
+): void {
   const { targetPath, stagedPath } = plan;
-  const backupDir = `${targetPath}.bak-${process.pid}-${Date.now()}`;
+  const backupDir = `${targetPath}.bak-${globals.pid()}-${globals.now()}`;
   const targetExists = fs.existsSync(targetPath);
 
   try {
     if (targetExists) {
-      fs.renameSync(targetPath, backupDir);
+      renameWithRetry(targetPath, backupDir, globals);
     }
-    fs.renameSync(stagedPath, targetPath);
+    renameWithRetry(stagedPath, targetPath, globals);
     if (targetExists) {
       removeDirIfExists(backupDir);
     }
   } catch (err) {
     if (!fs.existsSync(targetPath) && fs.existsSync(backupDir)) {
-      fs.renameSync(backupDir, targetPath);
+      renameWithRetry(backupDir, targetPath, globals);
     }
     throw err;
   }
 }
 
 export function applyCommitPlan(plan: CommitPlan): void {
+  const runtimeGlobals: CommitPlanGlobals = globals;
   if (plan.kind === 'replace-root') {
-    replaceRoot(plan);
+    replaceRoot(plan, runtimeGlobals);
     return;
   }
 
-  applyMutations(plan);
+  applyMutations(plan, runtimeGlobals);
 }

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

@@ -1,186 +0,0 @@
-import path from 'path';
-import type MarkdownIt from 'markdown-it';
-import type Token from 'markdown-it/lib/token.mjs';
-import { JSDOM } from 'jsdom';
-import { createApplyBasePath } from './utils/paths';
-import { getExtensionToShikiLanguage } from './site-variables';
-import { isInternalLink } from './utils/link';
-import { makeLogger } from './log';
-import type { SiteVariables } from './types';
-
-const log = makeLogger(import.meta.url);
-
-function serializeStartTag(element: Element): string {
-  const attrs = Array.from(element.attributes).map(attr =>
-    attr.value === '' ? attr.name : `${attr.name}="${attr.value}"`,
-  );
-  return `<${element.tagName.toLowerCase()}${attrs.length > 0 ? ` ${attrs.join(' ')}` : ''}>`;
-}
-
-function isStandaloneOpeningAnchorTag(html: string): boolean {
-  if (!/^<a\b/i.test(html)) {
-    return false;
-  }
-
-  let i = 2;
-  let quote: '"' | "'" | null = null;
-
-  while (i < html.length) {
-    const char = html[i];
-    if (quote) {
-      if (char === quote) {
-        quote = null;
-      }
-      i += 1;
-      continue;
-    }
-
-    if (char === '"' || char === "'") {
-      quote = char;
-      i += 1;
-      continue;
-    }
-
-    if (char === '>') {
-      return html.slice(i + 1).trim() === '';
-    }
-
-    i += 1;
-  }
-
-  return false;
-}
-
-interface ApplyBasePathOptions {
-  literateJavaOutputPaths?: Set<string>;
-  sourceUrlPath?: string;
-  validTargets?: Set<string>;
-}
-
-export default function applyBasePathPlugin(
-  md: MarkdownIt,
-  siteVariables: SiteVariables,
-  pluginOptions: ApplyBasePathOptions = {},
-): void {
-  const applyBasePath = createApplyBasePath(siteVariables);
-  const literateJavaOutputPaths = pluginOptions.literateJavaOutputPaths;
-  const sourceUrlPath = pluginOptions.sourceUrlPath;
-  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] : '';
-    let modifiedPath = pathname;
-
-    for (const ext of Object.keys(getExtensionToShikiLanguage(siteVariables))) {
-      if (modifiedPath.endsWith(`.${ext}`)) {
-        if (literateJavaOutputPaths && sourceUrlPath) {
-          const resolved = resolveAgainstSource(modifiedPath);
-          if (literateJavaOutputPaths.has(resolved)) {
-            break;
-          }
-        }
-        // 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 = resolveAgainstSource(modifiedPath);
-          if (!validTargets.has(`${resolved}.html`)) {
-            break;
-          }
-        }
-        modifiedPath += '.html';
-        break;
-      }
-    }
-
-    return modifiedPath + suffix;
-  }
-
-  function checkAndApplyBasePath(token: Token): void {
-    if (token.type === 'link_open') {
-      const href = token.attrGet('href');
-      if (!href) {
-        return;
-      }
-
-      if (href.startsWith('/')) {
-        const modifiedHref = rewriteInternalHref(href);
-        const afterApply = applyBasePath(modifiedHref);
-        log.debug`Applying base path: ${href} -> ${afterApply}`;
-        token.attrSet('href', afterApply);
-      } else if (isInternalLink(href)) {
-        // Relative link: only rewrite code extensions, don't apply base path
-        const modifiedHref = rewriteInternalHref(href);
-        if (modifiedHref !== href) {
-          log.debug`Rewriting internal link: ${href} -> ${modifiedHref}`;
-          token.attrSet('href', modifiedHref);
-        }
-      }
-    } else if (token.type === 'image') {
-      const src = token.attrGet('src');
-      if (src && src.startsWith('/')) {
-        const afterApply = applyBasePath(src);
-        log.debug`Applying base path to image: ${src} -> ${afterApply}`;
-        token.attrSet('src', afterApply);
-      }
-    } else if (token.type === 'html_block' || token.type === 'html_inline') {
-      if (isStandaloneOpeningAnchorTag(token.content)) {
-        const dom = new JSDOM(`<body>${token.content}__tada__</a></body>`);
-        const anchor = dom.window.document.body.querySelector('a[href]');
-        const href = anchor?.getAttribute('href');
-        if (anchor && href && isInternalLink(href)) {
-          const rewrittenHref = rewriteInternalHref(href);
-          const finalHref = href.startsWith('/')
-            ? applyBasePath(rewrittenHref)
-            : rewrittenHref;
-          log.debug`Rewriting raw HTML anchor: ${href} -> ${finalHref}`;
-          anchor.setAttribute('href', finalHref);
-          token.content = serializeStartTag(anchor);
-        }
-      } else {
-        const dom = new JSDOM(`<body>${token.content}</body>`);
-        const { document } = dom.window;
-        let changed = false;
-
-        for (const anchor of document.body.querySelectorAll('a[href]')) {
-          const href = anchor.getAttribute('href');
-          if (href && isInternalLink(href)) {
-            const rewrittenHref = rewriteInternalHref(href);
-            const finalHref = href.startsWith('/')
-              ? applyBasePath(rewrittenHref)
-              : rewrittenHref;
-            log.debug`Rewriting raw HTML anchor: ${href} -> ${finalHref}`;
-            anchor.setAttribute('href', finalHref);
-            changed = true;
-          }
-        }
-
-        for (const image of document.body.querySelectorAll('img[src]')) {
-          const src = image.getAttribute('src');
-          if (src && src.startsWith('/')) {
-            const afterApply = applyBasePath(src);
-            log.debug`Applying base path to raw HTML image: ${src} -> ${afterApply}`;
-            image.setAttribute('src', afterApply);
-            changed = true;
-          }
-        }
-
-        if (changed) {
-          token.content = document.body.innerHTML;
-        }
-      }
-    }
-
-    token.children?.forEach(checkAndApplyBasePath);
-  }
-
-  md.core.ruler.push('apply_base_path', state => {
-    state.tokens.forEach(checkAndApplyBasePath);
-  });
-}

package/build/content-watch.ts

@@ -1,104 +0,0 @@
-import path from 'path';
-import type { SiteVariables } from './types';
-import { getExtensionToShikiLanguage } from './site-variables';
-import { getContentDir, getBuildContentFiles, isPartial } from './util';
-import { compileTemplates, getJsonDataDir, JSON_DATA_FILES } from './templates';
-import { B } from './colors';
-import { makeLogger } from './log';
-
-const log = makeLogger(import.meta.url);
-
-interface ChangeDetectionResult {
-  templateError: Error | null;
-  needsRestart: boolean;
-  changedContentFiles?: Set<string>;
-  jsonDataChanged?: boolean;
-  partialsChanged?: boolean;
-}
-
-export class ContentChangeDetector {
-  private siteVariables: SiteVariables;
-  private lastSig: string | null;
-
-  constructor(siteVariables: SiteVariables) {
-    this.siteVariables = siteVariables;
-    this.lastSig = null;
-  }
-
-  detectChanges(modifiedFiles: Iterable<string>): ChangeDetectionResult {
-    const resolvedFiles = new Set(
-      [...modifiedFiles].map(filePath => path.resolve(filePath)),
-    );
-
-    const jsonDataDir = getJsonDataDir();
-
-    // Try to recompile templates (also re-reads JSON data files)
-    let templateError: Error | null = null;
-    try {
-      compileTemplates(this.siteVariables);
-    } catch (err) {
-      templateError = err as Error;
-    }
-
-    if (templateError) {
-      return { templateError, needsRestart: false };
-    }
-
-    const contentDir = getContentDir();
-    const normalizedContentDir = path.resolve(contentDir) + path.sep;
-    const buildContentFiles = getBuildContentFiles(
-      contentDir,
-      Object.keys(getExtensionToShikiLanguage(this.siteVariables)),
-    );
-
-    // Detect structural changes (files added or deleted)
-    const sig = buildContentFiles.slice().sort().join('\0');
-    let needsRestart = false;
-    if (this.lastSig !== null && sig !== this.lastSig) {
-      needsRestart = true;
-    }
-    this.lastSig = sig;
-
-    const changedContentFiles = new Set(
-      [...resolvedFiles].filter(filePath =>
-        filePath.startsWith(normalizedContentDir),
-      ),
-    );
-
-    // Check if any JSON data file changed (nav.json, authors.json)
-    const jsonDataPaths = JSON_DATA_FILES.map(f =>
-      path.resolve(jsonDataDir, f),
-    );
-    const changedJsonDataPaths = [...resolvedFiles].filter(filePath =>
-      jsonDataPaths.includes(filePath),
-    );
-    const jsonDataChanged = changedJsonDataPaths.length > 0;
-    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) {
-      for (const filePath of changedPartials) {
-        log.event`Partial ${B`${path.basename(filePath)}`} changed, rebuilding`;
-      }
-    }
-
-    const changedTraceFiles = [...changedContentFiles].filter(
-      f => f.endsWith('.java') || f.endsWith('.py'),
-    );
-    for (const filePath of changedTraceFiles) {
-      log.event`${B`${path.basename(filePath)}`} changed, re-running traces`;
-    }
-
-    return {
-      templateError: null,
-      needsRestart,
-      changedContentFiles,
-      jsonDataChanged,
-      partialsChanged,
-    };
-  }
-}

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

@@ -1,207 +0,0 @@
-import type MarkdownIt from 'markdown-it';
-import type Token from 'markdown-it/lib/token.mjs';
-import { JSDOM } from 'jsdom';
-import path from 'path';
-import { isInternalLink } from './utils/link';
-import { makeLogger } from './log';
-
-const log = makeLogger(import.meta.url);
-
-interface ValidateInternalLinksOptions {
-  enabled?: boolean;
-  filePath?: string;
-  sourceUrlPath?: string;
-  validTargets?: Set<string>;
-  codeExtensions?: string[];
-  onValidLink?: (targetPath: string) => void;
-}
-
-function stripQueryAndHash(href: string): string {
-  return href.split('#')[0].split('?')[0];
-}
-
-function normalizePathname(pathname: string): string {
-  const normalized = path.posix.normalize(pathname);
-  if (normalized === '.') {
-    return '/';
-  }
-  return normalized.startsWith('/') ? normalized : `/${normalized}`;
-}
-
-function createCodeExtPattern(codeExtensions: string[]): RegExp | null {
-  const escaped = codeExtensions.map(ext =>
-    ext.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'),
-  );
-  if (escaped.length === 0) {
-    return null;
-  }
-  return new RegExp(`\\.(${escaped.join('|')})$`, 'i');
-}
-
-function rewriteCodeLink(
-  pathname: string,
-  codeExtPattern: RegExp | null,
-): string {
-  if (!codeExtPattern || !codeExtPattern.test(pathname)) {
-    return pathname;
-  }
-
-  return `${pathname}.html`;
-}
-
-function resolveLinkPath(
-  sourceUrlPath: string,
-  rawHref: string,
-  codeExtPattern: RegExp | null,
-): string | null {
-  const hrefPath = stripQueryAndHash(rawHref.trim());
-  if (!hrefPath) {
-    return null;
-  }
-
-  const sourceDir = path.posix.dirname(sourceUrlPath);
-  const resolved = hrefPath.startsWith('/')
-    ? normalizePathname(hrefPath)
-    : normalizePathname(path.posix.join(sourceDir, hrefPath));
-
-  // Decode percent-encoded characters so the resolved path can be matched
-  // against `validTargets`, which contains raw filesystem-derived paths.
-  // markdown-it's normalizeLink percent-encodes hrefs, so a link like
-  // `[x](/my notes.md)` arrives here as `/my%20notes.md`.
-  let decoded: string;
-  try {
-    decoded = normalizePathname(decodeURIComponent(resolved));
-  } catch {
-    decoded = resolved;
-  }
-
-  return rewriteCodeLink(decoded, codeExtPattern);
-}
-
-function getDirectoryIndexPath(pathname: string): string {
-  return normalizePathname(path.posix.join(pathname, 'index.html'));
-}
-
-export default function validateInternalLinks(
-  md: MarkdownIt,
-  options: ValidateInternalLinksOptions = {},
-): void {
-  const {
-    enabled = true,
-    filePath,
-    sourceUrlPath,
-    validTargets,
-    codeExtensions = [],
-    onValidLink,
-  } = options;
-
-  if (!enabled) {
-    return;
-  }
-
-  if (!filePath || !sourceUrlPath || !(validTargets instanceof Set)) {
-    throw new Error(
-      'validate-internal-links-plugin requires filePath, sourceUrlPath, and validTargets',
-    );
-  }
-
-  const codeExtPattern = createCodeExtPattern(codeExtensions);
-  const seenErrors = new Set<string>();
-
-  function reportBrokenLink(rawHref: string, resolvedPath: string): void {
-    const key = `${rawHref}|${resolvedPath}`;
-    if (seenErrors.has(key)) {
-      return;
-    }
-    seenErrors.add(key);
-
-    log.error`${filePath}: broken internal link: "${rawHref}" (resolved to "${resolvedPath}")`;
-  }
-
-  function reportDirectoryLink(
-    rawHref: string,
-    resolvedPath: string,
-    indexPath: string,
-  ): void {
-    const key = `${rawHref}|${resolvedPath}|directory`;
-    if (seenErrors.has(key)) {
-      return;
-    }
-    seenErrors.add(key);
-
-    log.error`${filePath}: directory link must reference index.html explicitly: "${rawHref}" (resolved to "${resolvedPath}", expected "${indexPath}")`;
-  }
-
-  function validateHref(rawHref: string): void {
-    if (!rawHref) {
-      return;
-    }
-
-    const href = rawHref.trim();
-    if (!href || !isInternalLink(href)) {
-      return;
-    }
-
-    const resolvedPath = resolveLinkPath(sourceUrlPath!, href, codeExtPattern);
-    if (!resolvedPath) {
-      return;
-    }
-
-    const directoryIndexPath = getDirectoryIndexPath(resolvedPath);
-    if (
-      directoryIndexPath !== resolvedPath &&
-      validTargets!.has(directoryIndexPath)
-    ) {
-      reportDirectoryLink(rawHref, resolvedPath, directoryIndexPath);
-      return;
-    }
-
-    if (!validTargets!.has(resolvedPath)) {
-      // If code extension rewriting changed the path, check the original
-      // path too. Public files with code extensions are copied as-is and
-      // do not produce .html versions.
-      if (codeExtPattern) {
-        const unrewritten = resolveLinkPath(sourceUrlPath!, href, null);
-        if (unrewritten && validTargets!.has(unrewritten)) {
-          onValidLink?.(unrewritten);
-          return;
-        }
-      }
-      reportBrokenLink(rawHref, resolvedPath);
-      return;
-    }
-
-    onValidLink?.(resolvedPath);
-  }
-
-  function validateToken(token: Token): void {
-    if (token.type === 'link_open') {
-      const href = token.attrGet('href');
-      if (href) {
-        validateHref(href);
-      }
-    } else if (token.type === 'html_block' || token.type === 'html_inline') {
-      const dom = new JSDOM(`<body>${token.content}</body>`);
-      for (const anchor of dom.window.document.body.querySelectorAll(
-        'a[href]',
-      )) {
-        const href = anchor.getAttribute('href');
-        if (href) {
-          validateHref(href);
-        }
-      }
-    }
-
-    token.children?.forEach(validateToken);
-  }
-
-  md.core.ruler.push('validate_internal_links', state => {
-    state.tokens.forEach(validateToken);
-
-    if (seenErrors.size > 0) {
-      throw new Error(
-        `${filePath}: found ${seenErrors.size} broken internal link(s)`,
-      );
-    }
-  });
-}