@abreen/tada 1.5.1 → 1.5.2

package/build/reachability.test.ts

@@ -1,80 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import {
-  collectDirectSiteAssetLinks,
-  collectReachableSiteAssets,
-} from './reachability';
-
-describe('reachability', () => {
-  test('collectDirectSiteAssetLinks resolves relative links and ignores excluded links', () => {
-    const result = collectDirectSiteAssetLinks({
-      html: `
-        <a href="../guide.html?x=1#top">Guide</a>
-        <a class="disabled" href="/ignore/">Ignore</a>
-        <a href="https://example.com/">External</a>
-        <a href="#section">Anchor</a>
-        <a href="mailto:test@example.com">Mail</a>
-        <a href="/docs/guide.pdf#page=2">PDF</a>
-      `,
-      fromAssetPath: 'section/index.html',
-      knownAssets: new Set(['guide.html', 'ignore/index.html']),
-      knownPdfPaths: new Set(['/docs/guide.pdf']),
-      basePath: '/',
-    });
-
-    expect(result).toEqual({
-      htmlAssetPaths: ['guide.html'],
-      pdfPaths: ['/docs/guide.pdf'],
-    });
-  });
-
-  test('collectDirectSiteAssetLinks honors basePath and meta refresh', () => {
-    const result = collectDirectSiteAssetLinks({
-      html: `
-        <a href="/course/faq/">FAQ</a>
-        <meta http-equiv="refresh" content="0; url='/course/refresh/'" />
-      `,
-      fromAssetPath: 'index.html',
-      knownAssets: new Set(['faq/index.html', 'refresh/index.html']),
-      basePath: '/course',
-    });
-
-    expect(result).toEqual({
-      htmlAssetPaths: ['faq/index.html', 'refresh/index.html'],
-      pdfPaths: [],
-    });
-  });
-
-  test('collectReachableSiteAssets reuses direct link parsing for html and pdf reachability', () => {
-    const htmlAssetsByPath = new Map([
-      [
-        'index.html',
-        `
-          <a href="/about/">About</a>
-          <a href="/docs/guide.pdf">Guide PDF</a>
-        `,
-      ],
-      [
-        'about/index.html',
-        `<meta http-equiv="refresh" content="0; url='/redirect/'" />`,
-      ],
-      ['redirect/index.html', '<p>Done</p>'],
-      ['orphan/index.html', '<p>Orphan</p>'],
-    ]);
-
-    const result = collectReachableSiteAssets({
-      htmlAssetsByPath,
-      knownPdfPaths: new Set(['/docs/guide.pdf']),
-      rootPath: 'index.html',
-      basePath: '/',
-    });
-
-    expect(result).toEqual({
-      reachableHtmlPaths: [
-        'about/index.html',
-        'index.html',
-        'redirect/index.html',
-      ],
-      reachablePdfPaths: ['/docs/guide.pdf'],
-    });
-  });
-});

package/build/serve.test.ts

@@ -1,59 +0,0 @@
-import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
-import fs from 'fs';
-import path from 'path';
-import { resolvePathname } from './serve';
-
-let tmpDir: string;
-
-beforeAll(() => {
-  tmpDir = fs.mkdtempSync('/tmp/serve-test-');
-  fs.writeFileSync(path.join(tmpDir, 'index.html'), '<h1>hello</h1>');
-  fs.mkdirSync(path.join(tmpDir, 'sub'));
-  fs.writeFileSync(path.join(tmpDir, 'sub', 'page.html'), '<p>page</p>');
-});
-
-afterAll(() => {
-  fs.rmSync(tmpDir, { recursive: true });
-});
-
-describe('resolvePathname', () => {
-  test('resolves a file at the root', () => {
-    const result = resolvePathname(tmpDir, '/index.html');
-    expect(result).not.toBeNull();
-    expect(result!.filePath).toBe(path.join(tmpDir, 'index.html'));
-    expect(result!.mtime).toBeInstanceOf(Date);
-  });
-
-  test('resolves a file in a subdirectory', () => {
-    const result = resolvePathname(tmpDir, '/sub/page.html');
-    expect(result).not.toBeNull();
-    expect(result!.filePath).toBe(path.join(tmpDir, 'sub', 'page.html'));
-  });
-
-  test('returns null for nonexistent file', () => {
-    expect(resolvePathname(tmpDir, '/missing.html')).toBeNull();
-  });
-
-  test('returns null for directory', () => {
-    expect(resolvePathname(tmpDir, '/sub')).toBeNull();
-  });
-
-  test('returns null for path traversal', () => {
-    expect(resolvePathname(tmpDir, '/../etc/passwd')).toBeNull();
-  });
-
-  test('returns null for encoded path traversal', () => {
-    expect(resolvePathname(tmpDir, '/%2e%2e/etc/passwd')).toBeNull();
-  });
-
-  test('returns null for invalid URL encoding', () => {
-    expect(resolvePathname(tmpDir, '/%ZZ')).toBeNull();
-  });
-
-  test('decodes percent-encoded path', () => {
-    fs.writeFileSync(path.join(tmpDir, 'spaced file.html'), 'ok');
-    const result = resolvePathname(tmpDir, '/spaced%20file.html');
-    expect(result).not.toBeNull();
-    expect(result!.filePath).toBe(path.join(tmpDir, 'spaced file.html'));
-  });
-});

package/build/toc-plugin.test.ts

@@ -1,120 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { generateTocHtml, generateCodeTocHtml } from './toc-plugin';
-import type { JavaTocEntry } from './types';
-
-describe('generateTocHtml', () => {
-  test('returns empty string for empty array', () => {
-    expect(generateTocHtml([], [])).toBe('');
-  });
-
-  test('generates heading items with correct level and link', () => {
-    const html = generateTocHtml(
-      [{ kind: 'heading', level: '2', id: 'intro', innerHtml: 'Introduction' }],
-      [],
-    );
-    expect(html).toContain('<ol>');
-    expect(html).toContain('class="heading-item level2"');
-    expect(html).toContain('href="#intro"');
-    expect(html).toContain('Introduction');
-    expect(html).toContain('</ol>');
-  });
-
-  test('generates dinkus items', () => {
-    const html = generateTocHtml([{ kind: 'dinkus' }], []);
-    expect(html).toContain('class="dinkus-item"');
-  });
-
-  test('generates alert items at one level deeper than last heading', () => {
-    const html = generateTocHtml(
-      [
-        { kind: 'heading', level: '2', id: 'sec', innerHtml: 'Section' },
-        { kind: 'alert', type: 'warning', title: 'Caution' },
-      ],
-      ['caution'],
-    );
-    expect(html).toContain('class="alert-item level3 warning"');
-    expect(html).toContain('href="#caution"');
-    expect(html).toContain('Caution');
-  });
-
-  test('alert before any heading uses level 2 (lastHeadingLevel defaults to 1)', () => {
-    const html = generateTocHtml(
-      [{ kind: 'alert', type: 'note', title: 'Note' }],
-      ['note'],
-    );
-    expect(html).toContain('class="alert-item level2 note"');
-    expect(html).toContain('href="#note"');
-  });
-
-  test('alert links use deduplicated IDs', () => {
-    const html = generateTocHtml(
-      [
-        { kind: 'alert', type: 'note', title: 'Note' },
-        { kind: 'alert', type: 'note', title: 'Note' },
-      ],
-      ['note', 'note-2'],
-    );
-    expect(html).toContain('href="#note"');
-    expect(html).toContain('href="#note-2"');
-  });
-
-  test('handles mixed items in order', () => {
-    const html = generateTocHtml(
-      [
-        { kind: 'heading', level: '2', id: 'a', innerHtml: 'A' },
-        { kind: 'dinkus' },
-        { kind: 'heading', level: '3', id: 'b', innerHtml: 'B' },
-        { kind: 'alert', type: 'note', title: 'FYI' },
-      ],
-      ['fyi'],
-    );
-    expect(html).toContain('level2');
-    expect(html).toContain('dinkus-item');
-    expect(html).toContain('level3');
-    expect(html).toContain('level4');
-  });
-});
-
-describe('generateCodeTocHtml', () => {
-  test('returns empty string for empty array', () => {
-    expect(generateCodeTocHtml([])).toBe('');
-  });
-
-  test('returns empty string for null/undefined', () => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    expect(generateCodeTocHtml(null as any)).toBe('');
-  });
-
-  test('generates grouped entries with labels', () => {
-    const items: JavaTocEntry[] = [
-      { kind: 'field', label: 'x', name: 'x', line: 5 },
-      { kind: 'method', label: 'getX()', name: 'getX()', line: 10 },
-    ];
-    const html = generateCodeTocHtml(items);
-    expect(html).toContain('Fields');
-    expect(html).toContain('Methods');
-    expect(html).toContain('href="#L5"');
-    expect(html).toContain('href="#L10"');
-  });
-
-  test('groups items by kind in order of appearance', () => {
-    const items: JavaTocEntry[] = [
-      { kind: 'method', label: 'foo()', name: 'foo()', line: 1 },
-      { kind: 'constructor', label: 'Bar()', name: 'Bar()', line: 5 },
-      { kind: 'method', label: 'baz()', name: 'baz()', line: 10 },
-    ];
-    const html = generateCodeTocHtml(items);
-    const methodsPos = html.indexOf('Methods');
-    const constructorsPos = html.indexOf('Constructors');
-    expect(methodsPos).toBeLessThan(constructorsPos);
-  });
-
-  test('escapes HTML in names', () => {
-    const items: JavaTocEntry[] = [
-      { kind: 'method', label: 'compare<T>()', name: 'compare<T>()', line: 1 },
-    ];
-    const html = generateCodeTocHtml(items);
-    expect(html).toContain('compare&lt;T&gt;()');
-    expect(html).not.toContain('compare<T>()');
-  });
-});

package/build/utils/content-files.test.ts

@@ -1,56 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { getValidInternalTargets } from './content-files';
-
-describe('getValidInternalTargets', () => {
-  let tempDir: string;
-  let originalCwd: string;
-
-  beforeEach(() => {
-    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tada-targets-test-'));
-    fs.mkdirSync(path.join(tempDir, 'content'));
-    fs.mkdirSync(path.join(tempDir, 'public'), { recursive: true });
-    originalCwd = process.cwd();
-    process.chdir(tempDir);
-  });
-
-  afterEach(() => {
-    process.chdir(originalCwd);
-    fs.rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  test('includes public files as valid targets', () => {
-    fs.writeFileSync(path.join(tempDir, 'public', 'test.txt'), '');
-
-    const contentDir = path.join(tempDir, 'content');
-    const targets = getValidInternalTargets(contentDir, [], [], false);
-
-    expect(targets.has('/test.txt')).toBe(true);
-  });
-
-  test('includes public index.html by exact path only', () => {
-    const coverageDir = path.join(tempDir, 'public', 'coverage');
-    fs.mkdirSync(coverageDir, { recursive: true });
-    fs.writeFileSync(path.join(coverageDir, 'index.html'), '');
-
-    const contentDir = path.join(tempDir, 'content');
-    const targets = getValidInternalTargets(contentDir, [], [], false);
-
-    expect(targets.has('/coverage/index.html')).toBe(true);
-    expect(targets.has('/coverage/')).toBe(false);
-    expect(targets.has('/coverage')).toBe(false);
-  });
-
-  test('includes nested public files', () => {
-    const subDir = path.join(tempDir, 'public', 'assets');
-    fs.mkdirSync(subDir, { recursive: true });
-    fs.writeFileSync(path.join(subDir, 'style.css'), '');
-
-    const contentDir = path.join(tempDir, 'content');
-    const targets = getValidInternalTargets(contentDir, [], [], false);
-
-    expect(targets.has('/assets/style.css')).toBe(true);
-  });
-});

package/build/utils/derive-theme.test.ts

@@ -1,111 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { parse, oklch } from 'culori';
-import { deriveTheme, getTextOnColor } from './derive-theme';
-
-function getL(hex: string): number {
-  return oklch(parse(hex))!.l;
-}
-
-describe('deriveTheme', () => {
-  test('returns valid hex strings for all outputs', () => {
-    const result = deriveTheme('steelblue');
-    for (const value of Object.values(result)) {
-      expect(value).toMatch(/^#[0-9a-f]{3,6}$/);
-    }
-  });
-
-  test('light theme color lightness is in range', () => {
-    for (const color of [
-      'cornsilk',
-      'navy',
-      'steelblue',
-      'tomato',
-      '#000',
-      '#fff',
-    ]) {
-      const { themeColorLight } = deriveTheme(color);
-      const l = getL(themeColorLight);
-      expect(l).toBeGreaterThanOrEqual(0.34);
-      expect(l).toBeLessThanOrEqual(0.63);
-    }
-  });
-
-  test('dark theme color lightness is in range', () => {
-    for (const color of [
-      'cornsilk',
-      'navy',
-      'steelblue',
-      'tomato',
-      '#000',
-      '#fff',
-    ]) {
-      const { themeColorDark } = deriveTheme(color);
-      const l = getL(themeColorDark);
-      expect(l).toBeGreaterThanOrEqual(0.54);
-      expect(l).toBeLessThanOrEqual(0.81);
-    }
-  });
-
-  test('light text color lightness is in range', () => {
-    for (const color of ['cornsilk', 'navy', 'steelblue', 'tomato', 'lime']) {
-      const { themeColorTextLight } = deriveTheme(color);
-      const l = getL(themeColorTextLight);
-      expect(l).toBeGreaterThanOrEqual(0.34);
-      expect(l).toBeLessThanOrEqual(0.51);
-    }
-  });
-
-  test('dark text color lightness is in range', () => {
-    for (const color of ['cornsilk', 'navy', 'steelblue', 'tomato', 'lime']) {
-      const { themeColorTextDark } = deriveTheme(color);
-      const l = getL(themeColorTextDark);
-      expect(l).toBeGreaterThanOrEqual(0.69);
-      expect(l).toBeLessThanOrEqual(0.83);
-    }
-  });
-
-  test('white text on dark colors', () => {
-    expect(deriveTheme('navy').textOnThemeLight).toBe('#fff');
-    expect(deriveTheme('#000').textOnThemeLight).toBe('#fff');
-    expect(deriveTheme('hsl(351 70% 40%)').textOnThemeLight).toBe('#fff');
-  });
-
-  test('black text on bright colors', () => {
-    expect(deriveTheme('lime').textOnThemeLight).toBe('#000');
-  });
-
-  test('white text on saturated and mid-tone colors', () => {
-    expect(deriveTheme('steelblue').textOnThemeLight).toBe('#fff');
-    expect(deriveTheme('teal').textOnThemeLight).toBe('#fff');
-    expect(deriveTheme('tomato').textOnThemeLight).toBe('#fff');
-    expect(deriveTheme('cornsilk').textOnThemeLight).toBe('#fff');
-    expect(deriveTheme('hsl(195 70% 40%)').textOnThemeLight).toBe('#fff');
-  });
-
-  test('steelblue produces values close to original', () => {
-    const result = deriveTheme('steelblue');
-    // steelblue OKLCH L is ~0.588 which is within light theme range,
-    // so it should be unchanged (or very close)
-    expect(result.themeColorLight).toBe('#4682b4');
-  });
-
-  test('throws on invalid color', () => {
-    expect(() => deriveTheme('notacolor')).toThrow('Invalid color');
-  });
-});
-
-describe('getTextOnColor', () => {
-  test('returns white for dark colors', () => {
-    expect(getTextOnColor('navy')).toBe('#fff');
-    expect(getTextOnColor('#000')).toBe('#fff');
-  });
-
-  test('returns black for bright colors', () => {
-    expect(getTextOnColor('cornsilk')).toBe('#000');
-    expect(getTextOnColor('#fff')).toBe('#000');
-  });
-
-  test('throws on invalid color', () => {
-    expect(() => getTextOnColor('notacolor')).toThrow('Invalid color');
-  });
-});

package/build/utils/file-types.test.ts

@@ -1,79 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import {
-  getProcessedExtensions,
-  extensionIsMarkdown,
-  isLiterateJava,
-  isPartial,
-} from './file-types';
-
-describe('getProcessedExtensions', () => {
-  test('includes md, markdown, html, and custom extensions', () => {
-    expect(getProcessedExtensions(['java'])).toEqual([
-      'md',
-      'markdown',
-      'html',
-      'java',
-    ]);
-  });
-
-  test('works with empty code extensions', () => {
-    expect(getProcessedExtensions([])).toEqual(['md', 'markdown', 'html']);
-  });
-});
-
-describe('extensionIsMarkdown', () => {
-  test('returns true for .md', () => {
-    expect(extensionIsMarkdown('.md')).toBe(true);
-  });
-
-  test('returns true for .markdown', () => {
-    expect(extensionIsMarkdown('.markdown')).toBe(true);
-  });
-
-  test('returns false for .html', () => {
-    expect(extensionIsMarkdown('.html')).toBe(false);
-  });
-
-  test('returns false for .txt', () => {
-    expect(extensionIsMarkdown('.txt')).toBe(false);
-  });
-});
-
-describe('isPartial', () => {
-  test('returns true for files starting with _', () => {
-    expect(isPartial('_foo.md')).toBe(true);
-    expect(isPartial('/content/subdir/_bar.html')).toBe(true);
-  });
-
-  test('returns false for regular files', () => {
-    expect(isPartial('index.md')).toBe(false);
-    expect(isPartial('/content/page.html')).toBe(false);
-  });
-
-  test('handles paths with directories', () => {
-    expect(isPartial('/content/lectures/02/_pr1.md')).toBe(true);
-    expect(isPartial('/content/lectures/02/subdir/_foobar.html')).toBe(true);
-  });
-});
-
-describe('isLiterateJava', () => {
-  test('returns true for .java.md files', () => {
-    expect(isLiterateJava('Example.java.md')).toBe(true);
-  });
-
-  test('case insensitive', () => {
-    expect(isLiterateJava('Example.JAVA.MD')).toBe(true);
-  });
-
-  test('returns false for plain .md files', () => {
-    expect(isLiterateJava('readme.md')).toBe(false);
-  });
-
-  test('returns false for .java files', () => {
-    expect(isLiterateJava('Example.java')).toBe(false);
-  });
-
-  test('handles paths with directories', () => {
-    expect(isLiterateJava('/content/code/Example.java.md')).toBe(true);
-  });
-});

package/build/utils/front-matter.test.ts

@@ -1,77 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { parseFrontMatterAndContent, parseFrontMatter } from './front-matter';
-
-describe('parseFrontMatter', () => {
-  test('parses markdown front matter separated by blank line', () => {
-    const raw = 'title: Hello\nauthor: Alice\n\nBody content here.';
-    const result = parseFrontMatter(raw, '.md');
-    expect(result.frontMatter).toBe('title: Hello\nauthor: Alice');
-    expect(result.content).toBe('\nBody content here.');
-  });
-
-  test('handles .markdown extension', () => {
-    const raw = 'title: Test\n\nContent.';
-    const result = parseFrontMatter(raw, '.markdown');
-    expect(result.frontMatter).toBe('title: Test');
-  });
-
-  test('handles .html extension', () => {
-    const raw = 'title: Page\nlayout: full\n\n<h1>Hi</h1>';
-    const result = parseFrontMatter(raw, '.html');
-    expect(result.frontMatter).toBe('title: Page\nlayout: full');
-    expect(result.content).toBe('\n<h1>Hi</h1>');
-  });
-
-  test('returns null frontMatter for unknown extensions', () => {
-    const raw = 'title: Nope\n\nContent';
-    const result = parseFrontMatter(raw, '.txt');
-    expect(result.frontMatter).toBe(null);
-    expect(result.content).toBe(raw);
-  });
-
-  test('returns null frontMatter when content starts with blank line', () => {
-    const raw = '\nNo front matter here.';
-    const result = parseFrontMatter(raw, '.md');
-    expect(result.frontMatter).toBe(null);
-    expect(result.content).toBe(raw);
-  });
-
-  test('handles YAML multiline pipe syntax', () => {
-    const raw =
-      'title: Hello\ndescription: |\n  This is a\n  multiline value\n\nBody.';
-    const result = parseFrontMatter(raw, '.md');
-    expect(result.frontMatter).toContain('description: |');
-    expect(result.frontMatter).toContain('  This is a');
-    expect(result.frontMatter).toContain('  multiline value');
-  });
-});
-
-describe('parseFrontMatterAndContent', () => {
-  test('returns parsed pageVariables and content', () => {
-    const raw = 'title: Hello World\nauthor: Bob\n\n# Main Content';
-    const result = parseFrontMatterAndContent(raw, '.md');
-    expect(result.pageVariables.title).toBe('Hello World');
-    expect(result.pageVariables.author).toBe('Bob');
-    expect(result.content).toContain('# Main Content');
-  });
-
-  test('handles content with no front matter fields', () => {
-    const raw = '\nJust content, no front matter.';
-    const result = parseFrontMatterAndContent(raw, '.md');
-    expect(result.pageVariables).toEqual({});
-    expect(result.content).toBe(raw);
-  });
-
-  test('handles boolean and numeric front matter values', () => {
-    const raw = 'toc: true\norder: 5\n\nContent.';
-    const result = parseFrontMatterAndContent(raw, '.md');
-    expect(result.pageVariables.toc).toBe(true);
-    expect(result.pageVariables.order).toBe(5);
-  });
-
-  test('handles Windows-style line endings', () => {
-    const raw = 'title: Hello\r\n\r\nBody content.';
-    const result = parseFrontMatterAndContent(raw, '.md');
-    expect(result.pageVariables.title).toBe('Hello');
-  });
-});