@abreen/tada 1.0.2 → 1.1.0

package/build/utils/shiki-highlighter.ts

@@ -0,0 +1,29 @@
+import type { HighlighterGeneric, BundledLanguage, BundledTheme } from 'shiki';
+import { makeLogger } from '../log.js';
+
+const log = makeLogger(__filename);
+
+let highlighter: HighlighterGeneric<BundledLanguage, BundledTheme> | null =
+  null;
+
+export async function initHighlighter(langs: string[]): Promise<void> {
+  if (highlighter) {
+    return;
+  }
+  log.debug`Initializing syntax highlighter`;
+  const { createHighlighter } = await import('shiki');
+  highlighter = await createHighlighter({
+    themes: ['github-light', 'github-dark'],
+    langs,
+  });
+}
+
+export function getHighlighter(): HighlighterGeneric<
+  BundledLanguage,
+  BundledTheme
+> {
+  if (!highlighter) {
+    throw new Error('Shiki highlighter not initialized');
+  }
+  return highlighter;
+}

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

@@ -0,0 +1,106 @@
+import { describe, expect, test } from 'bun:test';
+import MarkdownIt from 'markdown-it';
+import validateInternalLinks from './validate-internal-links-plugin.js';
+
+function createMd(
+  validTargets: string[],
+  options: { sourceUrlPath?: string; codeExtensions?: string[] } = {},
+) {
+  const md = new MarkdownIt({ html: true });
+  md.use(validateInternalLinks, {
+    enabled: true,
+    filePath: 'test.md',
+    sourceUrlPath: options.sourceUrlPath ?? '/test.html',
+    validTargets: new Set(validTargets),
+    codeExtensions: options.codeExtensions ?? [],
+  });
+  return md;
+}
+
+describe('validateInternalLinks', () => {
+  test('does nothing when disabled', () => {
+    const md = new MarkdownIt();
+    md.use(validateInternalLinks, { enabled: false });
+    expect(() => md.render('[link](/missing.html)')).not.toThrow();
+  });
+
+  test('throws when required options are missing', () => {
+    const md = new MarkdownIt();
+    expect(() => {
+      md.use(validateInternalLinks, { enabled: true });
+      md.render('test');
+    }).toThrow('requires filePath');
+  });
+
+  test('allows valid internal links', () => {
+    const md = createMd(['/about.html']);
+    expect(() => md.render('[About](/about.html)')).not.toThrow();
+  });
+
+  test('allows external links', () => {
+    const md = createMd([]);
+    expect(() => md.render('[Google](https://google.com)')).not.toThrow();
+  });
+
+  test('allows anchor links', () => {
+    const md = createMd([]);
+    expect(() => md.render('[Section](#top)')).not.toThrow();
+  });
+
+  test('allows mailto links', () => {
+    const md = createMd([]);
+    expect(() => md.render('[Email](mailto:test@example.com)')).not.toThrow();
+  });
+
+  test('throws for broken internal link', () => {
+    const md = createMd(['/about.html']);
+    expect(() => md.render('[Missing](/missing.html)')).toThrow(
+      'broken internal link',
+    );
+  });
+
+  test('strips query and hash before validating', () => {
+    const md = createMd(['/page.html']);
+    expect(() => md.render('[Page](/page.html?v=1#section)')).not.toThrow();
+  });
+
+  test('resolves relative links from source path', () => {
+    const md = createMd(['/docs/guide.html'], {
+      sourceUrlPath: '/docs/index.html',
+    });
+    expect(() => md.render('[Guide](guide.html)')).not.toThrow();
+  });
+
+  test('throws for broken relative link', () => {
+    const md = createMd(['/docs/guide.html'], {
+      sourceUrlPath: '/docs/index.html',
+    });
+    expect(() => md.render('[Missing](missing.html)')).toThrow(
+      'broken internal link',
+    );
+  });
+
+  test('rewrites code extensions to .html', () => {
+    const md = createMd(['/src/App.html'], { codeExtensions: ['java'] });
+    expect(() => md.render('[App](/src/App.java)')).not.toThrow();
+  });
+
+  test('detects directory links that should reference index.html', () => {
+    const md = createMd(['/docs/index.html']);
+    // The plugin logs the "directory link" message and throws a generic
+    // "broken internal link(s)" error, so match the thrown message.
+    expect(() => md.render('[Docs](/docs)')).toThrow('broken internal link');
+  });
+
+  test('validates links in raw HTML blocks', () => {
+    const md = createMd(['/about.html']);
+    expect(() => md.render('<a href="/missing.html">link</a>')).toThrow(
+      'broken internal link',
+    );
+  });
+
+  test('allows protocol-relative URLs', () => {
+    const md = createMd([]);
+    expect(() => md.render('[CDN](//cdn.example.com/lib.js)')).not.toThrow();
+  });
+});

package/{webpack/validate-internal-links-plugin.js → build/validate-internal-links-plugin.ts}

@@ -1,13 +1,23 @@
-const path = require('path');
-const { makeLogger } = require('./log');
+import type MarkdownIt from 'markdown-it';
+import type Token from 'markdown-it/lib/token.mjs';
+import path from 'path';
+import { makeLogger } from './log.js';
 
 const log = makeLogger(__filename);
 
-function stripQueryAndHash(href) {
+interface ValidateInternalLinksOptions {
+  enabled?: boolean;
+  filePath?: string;
+  sourceUrlPath?: string;
+  validTargets?: Set<string>;
+  codeExtensions?: string[];
+}
+
+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;
   }
@@ -15,7 +25,7 @@ function isExternalOrAnchor(href) {
   return /^[a-zA-Z][a-zA-Z\d+.-]*:/.test(href);
 }
 
-function normalizePathname(pathname) {
+function normalizePathname(pathname: string): string {
   const normalized = path.posix.normalize(pathname);
   if (normalized === '.') {
     return '/';
@@ -23,7 +33,7 @@ function normalizePathname(pathname) {
   return normalized.startsWith('/') ? normalized : `/${normalized}`;
 }
 
-function createCodeExtPattern(codeExtensions) {
+function createCodeExtPattern(codeExtensions: string[]): RegExp | null {
   const escaped = codeExtensions.map(ext =>
     ext.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'),
   );
@@ -33,7 +43,10 @@ function createCodeExtPattern(codeExtensions) {
   return new RegExp(`\\.(${escaped.join('|')})$`, 'i');
 }
 
-function rewriteCodeLink(pathname, codeExtPattern) {
+function rewriteCodeLink(
+  pathname: string,
+  codeExtPattern: RegExp | null,
+): string {
   if (!codeExtPattern) {
     return pathname;
   }
@@ -41,7 +54,11 @@ function rewriteCodeLink(pathname, codeExtPattern) {
   return pathname.replace(codeExtPattern, '.html');
 }
 
-function resolveLinkPath(sourceUrlPath, rawHref, codeExtPattern) {
+function resolveLinkPath(
+  sourceUrlPath: string,
+  rawHref: string,
+  codeExtPattern: RegExp | null,
+): string | null {
   const hrefPath = stripQueryAndHash(rawHref.trim());
   if (!hrefPath) {
     return null;
@@ -55,11 +72,14 @@ function resolveLinkPath(sourceUrlPath, rawHref, codeExtPattern) {
   return rewriteCodeLink(resolved, codeExtPattern);
 }
 
-function getDirectoryIndexPath(pathname) {
+function getDirectoryIndexPath(pathname: string): string {
   return normalizePathname(path.posix.join(pathname, 'index.html'));
 }
 
-module.exports = function validateInternalLinks(md, options = {}) {
+export default function validateInternalLinks(
+  md: MarkdownIt,
+  options: ValidateInternalLinksOptions = {},
+): void {
   const {
     enabled = true,
     filePath,
@@ -79,9 +99,9 @@ module.exports = function validateInternalLinks(md, options = {}) {
   }
 
   const codeExtPattern = createCodeExtPattern(codeExtensions);
-  const seenErrors = new Set();
+  const seenErrors = new Set<string>();
 
-  function reportBrokenLink(rawHref, resolvedPath) {
+  function reportBrokenLink(rawHref: string, resolvedPath: string): void {
     const key = `${rawHref}|${resolvedPath}`;
     if (seenErrors.has(key)) {
       return;
@@ -91,7 +111,11 @@ module.exports = function validateInternalLinks(md, options = {}) {
     log.error`${filePath}: broken internal link: "${rawHref}" (resolved to "${resolvedPath}")`;
   }
 
-  function reportDirectoryLink(rawHref, resolvedPath, indexPath) {
+  function reportDirectoryLink(
+    rawHref: string,
+    resolvedPath: string,
+    indexPath: string,
+  ): void {
     const key = `${rawHref}|${resolvedPath}|directory`;
     if (seenErrors.has(key)) {
       return;
@@ -101,7 +125,7 @@ module.exports = function validateInternalLinks(md, options = {}) {
     log.error`${filePath}: directory link must reference index.html explicitly: "${rawHref}" (resolved to "${resolvedPath}", expected "${indexPath}")`;
   }
 
-  function validateHref(rawHref) {
+  function validateHref(rawHref: string): void {
     if (!rawHref) {
       return;
     }
@@ -111,7 +135,7 @@ module.exports = function validateInternalLinks(md, options = {}) {
       return;
     }
 
-    const resolvedPath = resolveLinkPath(sourceUrlPath, href, codeExtPattern);
+    const resolvedPath = resolveLinkPath(sourceUrlPath!, href, codeExtPattern);
     if (!resolvedPath) {
       return;
     }
@@ -119,20 +143,23 @@ module.exports = function validateInternalLinks(md, options = {}) {
     const directoryIndexPath = getDirectoryIndexPath(resolvedPath);
     if (
       directoryIndexPath !== resolvedPath &&
-      validTargets.has(directoryIndexPath)
+      validTargets!.has(directoryIndexPath)
     ) {
       reportDirectoryLink(rawHref, resolvedPath, directoryIndexPath);
       return;
     }
 
-    if (!validTargets.has(resolvedPath)) {
+    if (!validTargets!.has(resolvedPath)) {
       reportBrokenLink(rawHref, resolvedPath);
     }
   }
 
-  function validateToken(token) {
+  function validateToken(token: Token): void {
     if (token.type === 'link_open') {
-      validateHref(token.attrGet('href'));
+      const href = token.attrGet('href');
+      if (href) {
+        validateHref(href);
+      }
     } else if (token.type === 'html_block' || token.type === 'html_inline') {
       token.content.replace(/<a\b[^>]*\bhref\s*=\s*"([^"]+)"/gi, (_, href) => {
         validateHref(href);
@@ -152,4 +179,4 @@ module.exports = function validateInternalLinks(md, options = {}) {
       );
     }
   });
-};
+}

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

@@ -1,23 +1,23 @@
-const { describe, expect, test } = require('bun:test');
-const { collectReachableSiteAssets } = require('./reachability');
-const WatchReachabilityState = require('./watch-reachability-state');
+import { describe, expect, test } from 'bun:test';
+import { collectReachableSiteAssets } from './reachability.js';
+import WatchReachabilityState from './watch-reachability-state.js';
 
-function createReader(htmlByPath) {
-  const calls = [];
+function createReader(htmlByPath: Map<string, string>) {
+  const calls: string[] = [];
 
   return {
     calls,
-    read(assetPath) {
+    read(assetPath: string): string {
       calls.push(assetPath);
       if (!htmlByPath.has(assetPath)) {
         throw new Error(`Missing HTML asset: ${assetPath}`);
       }
-      return htmlByPath.get(assetPath);
+      return htmlByPath.get(assetPath)!;
     },
   };
 }
 
-function createState(htmlEntries) {
+function createState(htmlEntries: Record<string, string>) {
   const htmlByPath = new Map(Object.entries(htmlEntries));
   const reader = createReader(htmlByPath);
   const state = new WatchReachabilityState();

package/{webpack/watch-reachability-state.js → build/watch-reachability-state.ts}

@@ -1,17 +1,40 @@
-const { collectDirectSiteAssetLinks } = require('./reachability');
+import { collectDirectSiteAssetLinks } from './reachability.js';
 
-function cloneSet(values) {
+type ReadHtmlForAsset = (assetPath: string) => string;
+
+function cloneSet(values: Iterable<string> | undefined): Set<string> {
   return new Set(values || []);
 }
 
+interface IncrementalOptions {
+  changedAssetPaths?: Iterable<string>;
+  removedAssetPaths?: Iterable<string>;
+  readHtmlForAsset: ReadHtmlForAsset;
+}
+
 class WatchReachabilityState {
-  constructor({ rootPath = 'index.html', basePath = '/' } = {}) {
+  private rootPath: string;
+  private basePath: string;
+  private knownAssets: Set<string>;
+  private outgoingBySource: Map<string, Set<string>>;
+  private incomingByTarget: Map<string, Set<string>>;
+  private reachable: Set<string>;
+  private initialized: boolean;
+
+  constructor({
+    rootPath = 'index.html',
+    basePath = '/',
+  }: { rootPath?: string; basePath?: string } = {}) {
     this.rootPath = rootPath;
     this.basePath = basePath;
-    this.reset();
+    this.knownAssets = new Set();
+    this.outgoingBySource = new Map();
+    this.incomingByTarget = new Map();
+    this.reachable = new Set();
+    this.initialized = false;
   }
 
-  reset() {
+  reset(): void {
     this.knownAssets = new Set();
     this.outgoingBySource = new Map();
     this.incomingByTarget = new Map();
@@ -19,13 +42,13 @@ class WatchReachabilityState {
     this.initialized = false;
   }
 
-  setKnownAssets(assetPaths) {
+  setKnownAssets(assetPaths: Iterable<string>): void {
     this.knownAssets = cloneSet(assetPaths);
     this.reachable = new Set(
       [...this.reachable].filter(assetPath => this.knownAssets.has(assetPath)),
     );
 
-    const nextOutgoingBySource = new Map();
+    const nextOutgoingBySource = new Map<string, Set<string>>();
     for (const [sourcePath, targets] of this.outgoingBySource) {
       if (!this.knownAssets.has(sourcePath)) {
         continue;
@@ -43,7 +66,7 @@ class WatchReachabilityState {
     this.rebuildIncomingByTarget();
   }
 
-  rebuild(readHtmlForAsset) {
+  rebuild(readHtmlForAsset: ReadHtmlForAsset): void {
     if (!this.knownAssets.has(this.rootPath)) {
       throw new Error(`Pagefind reachability root not found: ${this.rootPath}`);
     }
@@ -66,20 +89,24 @@ class WatchReachabilityState {
     this.initialized = true;
   }
 
-  applyIncremental({ changedAssetPaths, removedAssetPaths, readHtmlForAsset }) {
+  applyIncremental({
+    changedAssetPaths,
+    removedAssetPaths,
+    readHtmlForAsset,
+  }: IncrementalOptions): void {
     if (!this.initialized) {
       this.rebuild(readHtmlForAsset);
       return;
     }
 
-    const normalizedChanged = new Set();
+    const normalizedChanged = new Set<string>();
     for (const assetPath of changedAssetPaths || []) {
       if (this.knownAssets.has(assetPath)) {
         normalizedChanged.add(assetPath);
       }
     }
 
-    const normalizedRemoved = new Set();
+    const normalizedRemoved = new Set<string>();
     for (const assetPath of removedAssetPaths || []) {
       if (
         !this.knownAssets.has(assetPath) &&
@@ -89,7 +116,7 @@ class WatchReachabilityState {
       }
     }
 
-    const previouslyReachableRoots = new Set();
+    const previouslyReachableRoots = new Set<string>();
     for (const assetPath of normalizedChanged) {
       if (this.reachable.has(assetPath)) {
         previouslyReachableRoots.add(assetPath);
@@ -130,7 +157,7 @@ class WatchReachabilityState {
       this.reachable.delete(assetPath);
     }
 
-    const seedPaths = new Set();
+    const seedPaths = new Set<string>();
     for (const assetPath of stillKnownRoots) {
       if (affected.has(assetPath)) {
         seedPaths.add(assetPath);
@@ -163,11 +190,14 @@ class WatchReachabilityState {
     this.initialized = true;
   }
 
-  getReachablePaths() {
+  getReachablePaths(): string[] {
     return [...this.reachable].sort();
   }
 
-  readOutgoingPaths(sourcePath, readHtmlForAsset) {
+  private readOutgoingPaths(
+    sourcePath: string,
+    readHtmlForAsset: ReadHtmlForAsset,
+  ): Set<string> {
     if (!this.knownAssets.has(sourcePath)) {
       return new Set();
     }
@@ -182,7 +212,10 @@ class WatchReachabilityState {
     return new Set(htmlAssetPaths);
   }
 
-  addIncomingEdges(sourcePath, outgoingPaths) {
+  private addIncomingEdges(
+    sourcePath: string,
+    outgoingPaths: Set<string>,
+  ): void {
     for (const targetPath of outgoingPaths) {
       let incomingPaths = this.incomingByTarget.get(targetPath);
       if (!incomingPaths) {
@@ -193,14 +226,14 @@ class WatchReachabilityState {
     }
   }
 
-  rebuildIncomingByTarget() {
+  private rebuildIncomingByTarget(): void {
     this.incomingByTarget = new Map();
     for (const [sourcePath, outgoingPaths] of this.outgoingBySource) {
       this.addIncomingEdges(sourcePath, outgoingPaths);
     }
   }
 
-  removeOutgoingEdges(sourcePath) {
+  private removeOutgoingEdges(sourcePath: string): void {
     const outgoingPaths = this.outgoingBySource.get(sourcePath);
     if (!outgoingPaths) {
       return;
@@ -219,7 +252,10 @@ class WatchReachabilityState {
     }
   }
 
-  replaceOutgoing(sourcePath, outgoingPaths) {
+  private replaceOutgoing(
+    sourcePath: string,
+    outgoingPaths: Set<string>,
+  ): void {
     this.removeOutgoingEdges(sourcePath);
     if (!this.knownAssets.has(sourcePath)) {
       this.outgoingBySource.delete(sourcePath);
@@ -230,19 +266,22 @@ class WatchReachabilityState {
     this.addIncomingEdges(sourcePath, outgoingPaths);
   }
 
-  removeAsset(assetPath) {
+  private removeAsset(assetPath: string): void {
     this.removeOutgoingEdges(assetPath);
     this.outgoingBySource.delete(assetPath);
     this.incomingByTarget.delete(assetPath);
     this.reachable.delete(assetPath);
   }
 
-  collectClosure(rootPaths, allowedPaths = null) {
+  private collectClosure(
+    rootPaths: Set<string>,
+    allowedPaths: Set<string> | null = null,
+  ): Set<string> {
     const pending = [...rootPaths];
-    const visited = new Set();
+    const visited = new Set<string>();
 
     while (pending.length > 0) {
-      const currentPath = pending.pop();
+      const currentPath = pending.pop()!;
       if (visited.has(currentPath)) {
         continue;
       }
@@ -270,4 +309,4 @@ class WatchReachabilityState {
   }
 }
 
-module.exports = WatchReachabilityState;
+export default WatchReachabilityState;

package/{webpack/watch-reload-client.js → build/watch-reload-client.ts}

@@ -1,3 +1,5 @@
+declare const __WEBSOCKET_PORT__: number;
+
 (function () {
   const style = document.createElement('style');
   style.textContent = [
@@ -24,7 +26,7 @@
   ].join('\n');
   document.head.appendChild(style);
 
-  const ws = new WebSocket('ws://localhost:35729');
+  const ws = new WebSocket(`ws://localhost:${__WEBSOCKET_PORT__}`);
 
   ws.onopen = () => {
     console.log('[watch-reload] connected to watcher');