@abreen/tada 1.5.1 → 1.5.4

package/build/validate-config-links.test.ts

@@ -1,239 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import {
-  validateNavLinks,
-  validateAuthorLinks,
-  validateConfigLinks,
-  validateParentLink,
-} from './validate-config-links';
-
-describe('validateNavLinks', () => {
-  test('passes for valid internal links', () => {
-    const validTargets = new Set(['/lectures/index.html', '/labs/index.html']);
-    const navData = [
-      {
-        title: 'Topics',
-        links: [
-          { text: 'Lectures', internal: '/lectures/index.html' },
-          { text: 'Labs', internal: '/labs/index.html' },
-        ],
-      },
-    ];
-    expect(validateNavLinks(navData, validTargets)).toEqual([]);
-  });
-
-  test('reports broken internal links', () => {
-    const validTargets = new Set(['/about.html']);
-    const navData = [
-      {
-        title: 'Menu',
-        links: [{ text: 'Missing', internal: '/missing.html' }],
-      },
-    ];
-    const errors = validateNavLinks(navData, validTargets);
-    expect(errors).toHaveLength(1);
-    expect(errors[0]).toContain('/missing.html');
-    expect(errors[0]).toContain('nav.json');
-  });
-
-  test('reports multiple broken links', () => {
-    const validTargets = new Set<string>();
-    const navData = [
-      {
-        title: 'Menu',
-        links: [
-          { text: 'A', internal: '/a.html' },
-          { text: 'B', internal: '/b.html' },
-        ],
-      },
-    ];
-    const errors = validateNavLinks(navData, validTargets);
-    expect(errors).toHaveLength(2);
-  });
-
-  test('skips disabled links', () => {
-    const validTargets = new Set<string>();
-    const navData = [
-      {
-        title: 'Menu',
-        links: [
-          { text: 'Coming Soon', internal: '/coming.html', disabled: true },
-        ],
-      },
-    ];
-    expect(validateNavLinks(navData, validTargets)).toEqual([]);
-  });
-
-  test('skips external links', () => {
-    const validTargets = new Set<string>();
-    const navData = [
-      {
-        title: 'External',
-        links: [{ text: 'Google', external: 'https://google.com' }],
-      },
-    ];
-    expect(validateNavLinks(navData, validTargets)).toEqual([]);
-  });
-
-  test('normalizes paths before checking', () => {
-    const validTargets = new Set(['/docs/guide.html']);
-    const navData = [
-      {
-        title: 'Menu',
-        links: [{ text: 'Guide', internal: '/docs/../docs/guide.html' }],
-      },
-    ];
-    expect(validateNavLinks(navData, validTargets)).toEqual([]);
-  });
-
-  test('returns empty array for empty nav data', () => {
-    expect(validateNavLinks([], new Set())).toEqual([]);
-  });
-
-  test('returns empty array for null/undefined nav data', () => {
-    expect(validateNavLinks(null, new Set())).toEqual([]);
-    expect(validateNavLinks(undefined, new Set())).toEqual([]);
-  });
-});
-
-describe('validateAuthorLinks', () => {
-  test('passes for valid author url and avatar', () => {
-    const validTargets = new Set(['/about/alex.html', '/avatars/alex.jpg']);
-    const authorsData = {
-      alex: {
-        name: 'Alex',
-        avatar: '/avatars/alex.jpg',
-        url: '/about/alex.html',
-      },
-    };
-    expect(validateAuthorLinks(authorsData, validTargets)).toEqual([]);
-  });
-
-  test('reports broken author url', () => {
-    const validTargets = new Set(['/avatars/alex.jpg']);
-    const authorsData = {
-      alex: { name: 'Alex', avatar: '/avatars/alex.jpg', url: '/missing.html' },
-    };
-    const errors = validateAuthorLinks(authorsData, validTargets);
-    expect(errors).toHaveLength(1);
-    expect(errors[0]).toContain('/missing.html');
-    expect(errors[0]).toContain('authors.json');
-    expect(errors[0]).toContain('alex');
-  });
-
-  test('reports broken avatar path', () => {
-    const validTargets = new Set<string>();
-    const authorsData = {
-      alex: { name: 'Alex', avatar: '/avatars/missing.jpg' },
-    };
-    const errors = validateAuthorLinks(authorsData, validTargets);
-    expect(errors).toHaveLength(1);
-    expect(errors[0]).toContain('/avatars/missing.jpg');
-    expect(errors[0]).toContain('avatar');
-  });
-
-  test('reports both broken url and avatar', () => {
-    const validTargets = new Set<string>();
-    const authorsData = {
-      alex: {
-        name: 'Alex',
-        avatar: '/avatars/missing.jpg',
-        url: '/missing.html',
-      },
-    };
-    const errors = validateAuthorLinks(authorsData, validTargets);
-    expect(errors).toHaveLength(2);
-  });
-
-  test('skips author without url field', () => {
-    const validTargets = new Set(['/avatars/alex.jpg']);
-    const authorsData = { alex: { name: 'Alex', avatar: '/avatars/alex.jpg' } };
-    expect(validateAuthorLinks(authorsData, validTargets)).toEqual([]);
-  });
-
-  test('returns empty array for null/undefined authors data', () => {
-    expect(validateAuthorLinks(null, new Set())).toEqual([]);
-    expect(validateAuthorLinks(undefined, new Set())).toEqual([]);
-  });
-
-  test('validates multiple authors independently', () => {
-    const validTargets = new Set(['/avatars/alex.jpg']);
-    const authorsData = {
-      alex: { name: 'Alex', avatar: '/avatars/alex.jpg' },
-      bob: { name: 'Bob', avatar: '/avatars/bob.jpg' },
-    };
-    const errors = validateAuthorLinks(authorsData, validTargets);
-    expect(errors).toHaveLength(1);
-    expect(errors[0]).toContain('bob');
-  });
-});
-
-describe('validateConfigLinks', () => {
-  test('combines nav and author errors', () => {
-    const validTargets = new Set(['/avatars/alex.jpg']);
-    const navData = [
-      {
-        title: 'Menu',
-        links: [{ text: 'Missing', internal: '/missing.html' }],
-      },
-    ];
-    const authorsData = {
-      alex: {
-        name: 'Alex',
-        avatar: '/avatars/alex.jpg',
-        url: '/also-missing.html',
-      },
-    };
-    const errors = validateConfigLinks(validTargets, navData, authorsData);
-    expect(errors).toHaveLength(2);
-  });
-
-  test('returns empty array when everything is valid', () => {
-    const validTargets = new Set(['/about.html', '/avatars/a.jpg']);
-    const navData = [
-      { title: 'Menu', links: [{ text: 'About', internal: '/about.html' }] },
-    ];
-    const authorsData = { a: { name: 'A', avatar: '/avatars/a.jpg' } };
-    expect(validateConfigLinks(validTargets, navData, authorsData)).toEqual([]);
-  });
-
-  test('handles missing authors.json gracefully', () => {
-    const validTargets = new Set(['/about.html']);
-    const navData = [
-      { title: 'Menu', links: [{ text: 'About', internal: '/about.html' }] },
-    ];
-    expect(validateConfigLinks(validTargets, navData, undefined)).toEqual([]);
-  });
-});
-
-describe('validateParentLink', () => {
-  test('returns null for valid parent link', () => {
-    const validTargets = new Set(['/lectures/index.html']);
-    expect(
-      validateParentLink('/lectures/index.html', 'test.md', validTargets),
-    ).toBeNull();
-  });
-
-  test('returns error for broken parent link', () => {
-    const validTargets = new Set<string>();
-    const error = validateParentLink(
-      '/missing/index.html',
-      'content/page.md',
-      validTargets,
-    );
-    expect(error).not.toBeNull();
-    expect(error).toContain('/missing/index.html');
-    expect(error).toContain('content/page.md');
-    expect(error).toContain('parent');
-  });
-
-  test('returns null when parent is undefined', () => {
-    expect(validateParentLink(undefined, 'test.md', new Set())).toBeNull();
-  });
-
-  test('normalizes parent path before checking', () => {
-    const validTargets = new Set(['/docs/index.html']);
-    expect(
-      validateParentLink('/docs/../docs/index.html', 'test.md', validTargets),
-    ).toBeNull();
-  });
-});

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

@@ -1,134 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import MarkdownIt from 'markdown-it';
-import validateInternalLinks from './validate-internal-links-plugin';
-
-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('resolves code file links to .ext.html pages', () => {
-    const md = createMd(['/src/App.java.html'], { codeExtensions: ['java'] });
-    expect(() => md.render('[App](/src/App.java)')).not.toThrow();
-  });
-
-  test('throws for link missing the code extension', () => {
-    const md = createMd(['/src/App.java.html'], { codeExtensions: ['java'] });
-    expect(() => md.render('[App](/src/App.html)')).toThrow(
-      'broken internal link',
-    );
-  });
-
-  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();
-  });
-
-  test('throws for .java.html link when code feature is disabled', () => {
-    // When features.code is false, codeExtensions is [] and no code pages
-    // are generated. Only the raw .java file exists as a valid target.
-    const md = createMd(['/src/Rectangle.java'], { codeExtensions: [] });
-    expect(() => md.render('[Rect](/src/Rectangle.java.html)')).toThrow(
-      'broken internal link',
-    );
-  });
-
-  test('throws for .py.html link when code feature is disabled', () => {
-    const md = createMd(['/src/demo.py'], { codeExtensions: [] });
-    expect(() => md.render('[Demo](/src/demo.py.html)')).toThrow(
-      'broken internal link',
-    );
-  });
-
-  test('allows .java link to raw file when code feature is disabled', () => {
-    const md = createMd(['/src/Rectangle.java'], { codeExtensions: [] });
-    expect(() => md.render('[Rect](/src/Rectangle.java)')).not.toThrow();
-  });
-});

package/build/watch-reachability-state.test.ts

@@ -1,198 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { collectReachableSiteAssets } from './reachability';
-import WatchReachabilityState from './watch-reachability-state';
-
-function createReader(htmlByPath: Map<string, string>) {
-  const calls: string[] = [];
-
-  return {
-    calls,
-    read(assetPath: string): string {
-      calls.push(assetPath);
-      if (!htmlByPath.has(assetPath)) {
-        throw new Error(`Missing HTML asset: ${assetPath}`);
-      }
-      return htmlByPath.get(assetPath)!;
-    },
-  };
-}
-
-function createState(htmlEntries: Record<string, string>) {
-  const htmlByPath = new Map(Object.entries(htmlEntries));
-  const reader = createReader(htmlByPath);
-  const state = new WatchReachabilityState();
-
-  state.setKnownAssets(new Set(htmlByPath.keys()));
-  state.rebuild(assetPath => reader.read(assetPath));
-
-  return { htmlByPath, reader, state };
-}
-
-describe('WatchReachabilityState', () => {
-  test('rebuild matches full traversal reachability', () => {
-    const htmlByPath = new Map([
-      ['index.html', '<a href="/about/">About</a>'],
-      ['about/index.html', '<a href="/deep/">Deep</a>'],
-      ['deep/index.html', '<p>Deep</p>'],
-      ['orphan/index.html', '<p>Orphan</p>'],
-    ]);
-    const reader = createReader(htmlByPath);
-    const state = new WatchReachabilityState();
-
-    state.setKnownAssets(new Set(htmlByPath.keys()));
-    state.rebuild(assetPath => reader.read(assetPath));
-
-    expect(state.getReachablePaths()).toEqual(
-      collectReachableSiteAssets({ htmlAssetsByPath: htmlByPath })
-        .reachableHtmlPaths,
-    );
-  });
-
-  test('incremental update adds a newly linked subtree', () => {
-    const { htmlByPath, reader, state } = createState({
-      'index.html': '<a href="/about/">About</a>',
-      'about/index.html': '<p>About</p>',
-      'hidden/index.html': '<a href="/bonus/">Bonus</a>',
-      'bonus/index.html': '<p>Bonus</p>',
-    });
-
-    reader.calls.length = 0;
-    htmlByPath.set(
-      'about/index.html',
-      '<a href="/hidden/">Reveal hidden subtree</a>',
-    );
-    state.setKnownAssets(new Set(htmlByPath.keys()));
-    state.applyIncremental({
-      changedAssetPaths: new Set(['about/index.html']),
-      removedAssetPaths: new Set(),
-      readHtmlForAsset: assetPath => reader.read(assetPath),
-    });
-
-    expect(reader.calls).toEqual(['about/index.html']);
-    expect(state.getReachablePaths()).toEqual([
-      'about/index.html',
-      'bonus/index.html',
-      'hidden/index.html',
-      'index.html',
-    ]);
-  });
-
-  test('incremental update removes a subtree when its only parent stops linking to it', () => {
-    const { htmlByPath, reader, state } = createState({
-      'index.html': '<a href="/about/">About</a>',
-      'about/index.html': '<a href="/hidden/">Hidden</a>',
-      'hidden/index.html': '<a href="/bonus/">Bonus</a>',
-      'bonus/index.html': '<p>Bonus</p>',
-    });
-
-    reader.calls.length = 0;
-    htmlByPath.set('about/index.html', '<p>About</p>');
-    state.setKnownAssets(new Set(htmlByPath.keys()));
-    state.applyIncremental({
-      changedAssetPaths: new Set(['about/index.html']),
-      removedAssetPaths: new Set(),
-      readHtmlForAsset: assetPath => reader.read(assetPath),
-    });
-
-    expect(reader.calls).toEqual(['about/index.html']);
-    expect(state.getReachablePaths()).toEqual([
-      'about/index.html',
-      'index.html',
-    ]);
-  });
-
-  test('removing one of two parents keeps the child reachable', () => {
-    const { htmlByPath, reader, state } = createState({
-      'index.html': '<a href="/about/">About</a><a href="/keep/">Keep</a>',
-      'about/index.html': '<a href="/child/">Child</a>',
-      'keep/index.html': '<a href="/child/">Child</a>',
-      'child/index.html': '<p>Child</p>',
-    });
-
-    htmlByPath.delete('about/index.html');
-    state.setKnownAssets(new Set(htmlByPath.keys()));
-    state.applyIncremental({
-      changedAssetPaths: new Set(),
-      removedAssetPaths: new Set(['about/index.html']),
-      readHtmlForAsset: assetPath => reader.read(assetPath),
-    });
-
-    expect(state.getReachablePaths()).toEqual([
-      'child/index.html',
-      'index.html',
-      'keep/index.html',
-    ]);
-  });
-
-  test('a supported cycle remains reachable and drops once external support is removed', () => {
-    const { htmlByPath, reader, state } = createState({
-      'index.html': '<a href="/support/">Support</a>',
-      'support/index.html': '<a href="/a/">A</a>',
-      'a/index.html': '<a href="/b/">B</a>',
-      'b/index.html': '<a href="/a/">A</a>',
-    });
-
-    expect(state.getReachablePaths()).toEqual([
-      'a/index.html',
-      'b/index.html',
-      'index.html',
-      'support/index.html',
-    ]);
-
-    reader.calls.length = 0;
-    htmlByPath.set('support/index.html', '<p>No links</p>');
-    state.setKnownAssets(new Set(htmlByPath.keys()));
-    state.applyIncremental({
-      changedAssetPaths: new Set(['support/index.html']),
-      removedAssetPaths: new Set(),
-      readHtmlForAsset: assetPath => reader.read(assetPath),
-    });
-
-    expect(reader.calls).toEqual(['support/index.html']);
-    expect(state.getReachablePaths()).toEqual([
-      'index.html',
-      'support/index.html',
-    ]);
-  });
-
-  test('changing an unreachable page updates its graph without reparsing the whole site', () => {
-    const { htmlByPath, reader, state } = createState({
-      'index.html': '<a href="/about/">About</a>',
-      'about/index.html': '<p>About</p>',
-      'hidden/index.html': '<p>Hidden</p>',
-      'bonus/index.html': '<p>Bonus</p>',
-    });
-
-    reader.calls.length = 0;
-    htmlByPath.set('hidden/index.html', '<a href="/bonus/">Bonus</a>');
-    state.setKnownAssets(new Set(htmlByPath.keys()));
-    state.applyIncremental({
-      changedAssetPaths: new Set(['hidden/index.html']),
-      removedAssetPaths: new Set(),
-      readHtmlForAsset: assetPath => reader.read(assetPath),
-    });
-
-    expect(reader.calls).toEqual(['hidden/index.html']);
-    expect(state.getReachablePaths()).toEqual([
-      'about/index.html',
-      'index.html',
-    ]);
-
-    reader.calls.length = 0;
-    htmlByPath.set('about/index.html', '<a href="/hidden/">Hidden</a>');
-    state.setKnownAssets(new Set(htmlByPath.keys()));
-    state.applyIncremental({
-      changedAssetPaths: new Set(['about/index.html']),
-      removedAssetPaths: new Set(),
-      readHtmlForAsset: assetPath => reader.read(assetPath),
-    });
-
-    expect(reader.calls).toEqual(['about/index.html']);
-    expect(state.getReachablePaths()).toEqual([
-      'about/index.html',
-      'bonus/index.html',
-      'hidden/index.html',
-      'index.html',
-    ]);
-  });
-});

package/src/anchor/index.test.ts

@@ -1,64 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { JSDOM } from 'jsdom';
-import mount from './index';
-
-function create(html: string) {
-  const dom = new JSDOM(`<body>${html}</body>`);
-  return dom.window;
-}
-
-describe('anchor', () => {
-  test('wraps heading content in an anchor link', () => {
-    const win = create('<h2 id="intro">Introduction</h2>');
-    mount(win);
-
-    const h2 = win.document.querySelector('h2')!;
-    const link = h2.querySelector('a.heading-anchor')!;
-    expect(link).not.toBeNull();
-    expect(link.getAttribute('href')).toBe('#intro');
-    expect(link.textContent).toBe('Introduction');
-  });
-
-  test('sets title on anchor link', () => {
-    const win = create('<h3 id="setup">Setup</h3>');
-    mount(win);
-
-    const link = win.document.querySelector('a.heading-anchor')!;
-    expect(link.getAttribute('title')).toBe('Link to this heading');
-  });
-
-  test('skips headings without an id', () => {
-    const win = create('<h2>No ID</h2>');
-    mount(win);
-
-    const link = win.document.querySelector('a.heading-anchor');
-    expect(link).toBeNull();
-  });
-
-  test('handles multiple headings', () => {
-    const win = create('<h1 id="a">A</h1><h2 id="b">B</h2><h3>C</h3>');
-    mount(win);
-
-    const links = win.document.querySelectorAll('a.heading-anchor');
-    expect(links.length).toBe(2);
-    expect(links[0].getAttribute('href')).toBe('#a');
-    expect(links[1].getAttribute('href')).toBe('#b');
-  });
-
-  test('preserves child elements inside heading', () => {
-    const win = create('<h2 id="x"><em>Bold</em> text</h2>');
-    mount(win);
-
-    const link = win.document.querySelector('a.heading-anchor')!;
-    expect(link.querySelector('em')).not.toBeNull();
-    expect(link.textContent).toBe('Bold text');
-  });
-
-  test('does nothing when no headings exist', () => {
-    const win = create('<p>No headings here</p>');
-    mount(win);
-
-    const links = win.document.querySelectorAll('a.heading-anchor');
-    expect(links.length).toBe(0);
-  });
-});