@abreen/tada 1.5.1 → 1.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abreen/tada",
-  "version": "1.5.1",
+  "version": "1.5.2",
   "type": "module",
   "description": "A static site generator",
   "license": "MIT",
@@ -21,7 +21,8 @@
     "init/",
     "schema/",
     "types/",
-    "tsconfig.json"
+    "tsconfig.json",
+    "!**/*.test.ts"
   ],
   "scripts": {
     "prepare": "bunx husky && bun run scripts/check-deps.ts",

package/bin/validators.test.ts

@@ -1,205 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import type { SiteConfigInput } from '../build/types';
-import {
-  validateSymbol,
-  validateColor,
-  validateHue,
-  validateUrl,
-  validateBasePath,
-  createSiteConfig,
-} from './validators';
-
-describe('validateSymbol', () => {
-  test('accepts a single uppercase letter', () => {
-    expect(validateSymbol('A')).toBeNull();
-  });
-
-  test('accepts digits and uppercase letters up to 5 chars', () => {
-    expect(validateSymbol('CS 0')).toBeNull();
-    expect(validateSymbol('CS101')).toBeNull();
-    expect(validateSymbol('AB-CD')).toBeNull();
-  });
-
-  test('rejects empty string', () => {
-    expect(validateSymbol('')).not.toBeNull();
-  });
-
-  test('rejects value longer than 5 chars', () => {
-    expect(validateSymbol('TOOLONG')).not.toBeNull();
-  });
-
-  test('rejects lowercase letters', () => {
-    expect(validateSymbol('abc')).not.toBeNull();
-  });
-
-  test('rejects special characters', () => {
-    expect(validateSymbol('A@B')).not.toBeNull();
-    expect(validateSymbol('A.B')).not.toBeNull();
-  });
-});
-
-describe('validateColor', () => {
-  test('accepts CSS color names', () => {
-    expect(validateColor('red')).toBeNull();
-    expect(validateColor('tomato')).toBeNull();
-    expect(validateColor('blue')).toBeNull();
-  });
-
-  test('accepts hex colors', () => {
-    expect(validateColor('#f00')).toBeNull();
-    expect(validateColor('#ff0000')).toBeNull();
-    expect(validateColor('#c04040')).toBeNull();
-  });
-
-  test('accepts HSL colors', () => {
-    expect(validateColor('hsl(195 70% 40%)')).toBeNull();
-    expect(validateColor('hsl(195, 70%, 40%)')).toBeNull();
-    expect(validateColor('hsl(195deg 70% 40%)')).toBeNull();
-  });
-
-  test('accepts RGB colors', () => {
-    expect(validateColor('rgb(0 0 0)')).toBeNull();
-    expect(validateColor('rgb(255, 99, 71)')).toBeNull();
-  });
-
-  test('rejects empty string', () => {
-    expect(validateColor('')).not.toBeNull();
-  });
-
-  test('rejects invalid color strings', () => {
-    expect(validateColor('notacolor')).not.toBeNull();
-    expect(validateColor('hsl 195 70% 40%')).not.toBeNull();
-  });
-});
-
-describe('validateHue', () => {
-  test('accepts integer', () => {
-    expect(validateHue('0')).toBeNull();
-    expect(validateHue('180')).toBeNull();
-    expect(validateHue('360')).toBeNull();
-  });
-
-  test('accepts integer with deg suffix', () => {
-    expect(validateHue('90deg')).toBeNull();
-    expect(validateHue('360deg')).toBeNull();
-  });
-
-  test('rejects empty string', () => {
-    expect(validateHue('')).not.toBeNull();
-  });
-
-  test('rejects out of range', () => {
-    expect(validateHue('-1')).not.toBeNull();
-    expect(validateHue('361')).not.toBeNull();
-  });
-
-  test('rejects non-integer', () => {
-    expect(validateHue('1.5')).not.toBeNull();
-    expect(validateHue('abc')).not.toBeNull();
-  });
-});
-
-describe('validateUrl', () => {
-  test('accepts https URL', () => {
-    expect(validateUrl('https://example.edu')).toBeNull();
-  });
-
-  test('accepts http URL', () => {
-    expect(validateUrl('http://localhost')).toBeNull();
-  });
-
-  test('accepts URL with port', () => {
-    expect(validateUrl('http://localhost:8080')).toBeNull();
-  });
-
-  test('rejects empty string', () => {
-    expect(validateUrl('')).not.toBeNull();
-  });
-
-  test('rejects trailing slash', () => {
-    expect(validateUrl('https://example.edu/')).not.toBeNull();
-  });
-
-  test('rejects URL with path', () => {
-    expect(validateUrl('https://example.edu/foo')).not.toBeNull();
-  });
-
-  test('rejects non-http scheme', () => {
-    expect(validateUrl('ftp://example.edu')).not.toBeNull();
-  });
-
-  test('rejects bare domain', () => {
-    expect(validateUrl('example.edu')).not.toBeNull();
-  });
-});
-
-describe('validateBasePath', () => {
-  test('accepts root path', () => {
-    expect(validateBasePath('/')).toBeNull();
-  });
-
-  test('accepts simple path segment', () => {
-    expect(validateBasePath('/foo')).toBeNull();
-    expect(validateBasePath('/foo-bar')).toBeNull();
-    expect(validateBasePath('/cs101')).toBeNull();
-  });
-
-  test('rejects path without leading slash', () => {
-    expect(validateBasePath('foo')).not.toBeNull();
-  });
-
-  test('rejects trailing slash', () => {
-    expect(validateBasePath('/foo/')).not.toBeNull();
-  });
-
-  test('rejects spaces', () => {
-    expect(validateBasePath('/foo bar')).not.toBeNull();
-  });
-
-  test('rejects nested paths', () => {
-    expect(validateBasePath('/foo/bar')).not.toBeNull();
-  });
-});
-
-describe('createSiteConfig', () => {
-  const base: SiteConfigInput = {
-    title: 'Test Site',
-    symbol: 'TS',
-    themeColor: 'hsl(200 50% 40%)',
-    tintHue: '20',
-    tintAmount: '100',
-    defaultTimeZone: 'America/New_York',
-    base: 'https://example.edu',
-    basePath: '/',
-    internalDomains: ['example.edu'],
-    features: { search: true, code: true, favicon: false },
-  };
-
-  test('returns an object with all expected keys', () => {
-    const config = createSiteConfig(base);
-    expect(config).toMatchObject({
-      title: 'Test Site',
-      symbol: 'TS',
-      themeColor: 'hsl(200 50% 40%)',
-      base: 'https://example.edu',
-      basePath: '/',
-      internalDomains: ['example.edu'],
-      defaultTimeZone: 'America/New_York',
-      features: { search: true, code: true, favicon: false },
-      codeLanguages: { java: 'java', py: 'python' },
-      vars: {},
-    });
-  });
-
-  test('coerces tintHue and tintAmount to numbers', () => {
-    const config = createSiteConfig(base);
-    expect(config.tintHue).toBe(20);
-    expect(config.tintAmount).toBe(100);
-  });
-
-  test('coerces numeric string tintHue correctly', () => {
-    const config = createSiteConfig({ ...base, tintHue: '0', tintAmount: '0' });
-    expect(config.tintHue).toBe(0);
-    expect(config.tintAmount).toBe(0);
-  });
-});

package/build/build-manifest.test.ts

@@ -1,369 +0,0 @@
-import { describe, expect, test, beforeEach, afterEach } from 'bun:test';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import {
-  diffManifests,
-  hashFile,
-  walkAndHash,
-  getVersions,
-  getNextVersion,
-  generateBuildManifest,
-  loadManifest,
-  pruneOldVersions,
-  copyChangedFiles,
-} from './build-manifest';
-import type { BuildManifest, ManifestDiff } from './build-manifest';
-
-function makeManifest(
-  files: Record<string, string>,
-  build: number = 1,
-): BuildManifest {
-  return { schema: 1, build, buildTime: '2025-01-01T00:00:00.000Z', files };
-}
-
-let tmpDir: string;
-
-beforeEach(() => {
-  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tada-test-'));
-});
-
-afterEach(() => {
-  fs.rmSync(tmpDir, { recursive: true });
-});
-
-describe('diffManifests', () => {
-  test('detects added files', () => {
-    const prev = makeManifest({ 'a.html': 'hash1' });
-    const current = makeManifest({ 'a.html': 'hash1', 'b.html': 'hash2' });
-    const diff = diffManifests(prev, current);
-    expect(diff.added).toEqual(['b.html']);
-    expect(diff.changed).toEqual([]);
-    expect(diff.removed).toEqual([]);
-  });
-
-  test('detects changed files', () => {
-    const prev = makeManifest({ 'a.html': 'hash1' });
-    const current = makeManifest({ 'a.html': 'hash2' });
-    const diff = diffManifests(prev, current);
-    expect(diff.added).toEqual([]);
-    expect(diff.changed).toEqual(['a.html']);
-    expect(diff.removed).toEqual([]);
-  });
-
-  test('detects removed files', () => {
-    const prev = makeManifest({ 'a.html': 'hash1', 'b.html': 'hash2' });
-    const current = makeManifest({ 'a.html': 'hash1' });
-    const diff = diffManifests(prev, current);
-    expect(diff.added).toEqual([]);
-    expect(diff.changed).toEqual([]);
-    expect(diff.removed).toEqual(['b.html']);
-  });
-
-  test('detects added, changed, and removed all at once', () => {
-    const prev = makeManifest({
-      'unchanged.html': 'same',
-      'changed.html': 'old',
-      'removed.html': 'gone',
-    });
-    const current = makeManifest({
-      'unchanged.html': 'same',
-      'changed.html': 'new',
-      'added.html': 'fresh',
-    });
-    const diff = diffManifests(prev, current);
-    expect(diff.added).toEqual(['added.html']);
-    expect(diff.changed).toEqual(['changed.html']);
-    expect(diff.removed).toEqual(['removed.html']);
-  });
-
-  test('returns empty arrays for identical manifests', () => {
-    const manifest = makeManifest({ 'a.html': 'hash1', 'b.css': 'hash2' });
-    const diff = diffManifests(manifest, manifest);
-    expect(diff.added).toEqual([]);
-    expect(diff.changed).toEqual([]);
-    expect(diff.removed).toEqual([]);
-  });
-
-  test('returns results in alphabetical order', () => {
-    const prev = makeManifest({
-      'z.html': 'old',
-      'removed-b.html': 'r',
-      'removed-a.html': 'r',
-    });
-    const current = makeManifest({
-      'z.html': 'new',
-      'c-added.html': 'c',
-      'a-added.html': 'a',
-    });
-    const diff = diffManifests(prev, current);
-    expect(diff.added).toEqual(['a-added.html', 'c-added.html']);
-    expect(diff.changed).toEqual(['z.html']);
-    expect(diff.removed).toEqual(['removed-a.html', 'removed-b.html']);
-  });
-});
-
-describe('hashFile', () => {
-  test('produces consistent hashes for the same content', async () => {
-    const file = path.join(tmpDir, 'test.txt');
-    fs.writeFileSync(file, 'hello world');
-    const hash1 = await hashFile(file);
-    const hash2 = await hashFile(file);
-    expect(hash1).toBe(hash2);
-  });
-
-  test('returns a 64-character hex string', async () => {
-    const file = path.join(tmpDir, 'test.txt');
-    fs.writeFileSync(file, 'content');
-    const hash = await hashFile(file);
-    expect(hash).toHaveLength(64);
-    expect(hash).toMatch(/^[0-9a-f]+$/);
-  });
-
-  test('different content produces different hashes', async () => {
-    const file1 = path.join(tmpDir, 'a.txt');
-    const file2 = path.join(tmpDir, 'b.txt');
-    fs.writeFileSync(file1, 'content one');
-    fs.writeFileSync(file2, 'content two');
-    const hash1 = await hashFile(file1);
-    const hash2 = await hashFile(file2);
-    expect(hash1).not.toBe(hash2);
-  });
-});
-
-describe('walkAndHash', () => {
-  test('returns a file map with relative paths and hashes', async () => {
-    fs.writeFileSync(path.join(tmpDir, 'index.html'), '<html></html>');
-    fs.writeFileSync(path.join(tmpDir, 'style.css'), 'body {}');
-    const result = await walkAndHash(tmpDir);
-    expect(Object.keys(result).sort()).toEqual(['index.html', 'style.css']);
-    for (const hash of Object.values(result)) {
-      expect(hash).toHaveLength(64);
-    }
-  });
-
-  test('excludes pagefind/ top-level directory', async () => {
-    fs.writeFileSync(path.join(tmpDir, 'index.html'), '<html></html>');
-    const pagefindDir = path.join(tmpDir, 'pagefind');
-    fs.mkdirSync(pagefindDir);
-    fs.writeFileSync(path.join(pagefindDir, 'pagefind.js'), 'code');
-    const result = await walkAndHash(tmpDir);
-    expect(Object.keys(result)).toEqual(['index.html']);
-    expect('pagefind/pagefind.js' in result).toBe(false);
-  });
-
-  test('excludes tada.manifest.json', async () => {
-    fs.writeFileSync(path.join(tmpDir, 'index.html'), '<html></html>');
-    fs.writeFileSync(path.join(tmpDir, 'tada.manifest.json'), '{"schema":1}');
-    const result = await walkAndHash(tmpDir);
-    expect(Object.keys(result)).toEqual(['index.html']);
-    expect('tada.manifest.json' in result).toBe(false);
-  });
-
-  test('returns empty object for empty directory', async () => {
-    const result = await walkAndHash(tmpDir);
-    expect(result).toEqual({});
-  });
-
-  test('uses forward slashes in keys', async () => {
-    const subDir = path.join(tmpDir, 'sub', 'nested');
-    fs.mkdirSync(subDir, { recursive: true });
-    fs.writeFileSync(path.join(subDir, 'file.html'), 'content');
-    const result = await walkAndHash(tmpDir);
-    const keys = Object.keys(result);
-    expect(keys).toEqual(['sub/nested/file.html']);
-    for (const key of keys) {
-      expect(key).not.toContain('\\');
-    }
-  });
-});
-
-describe('getVersions', () => {
-  test('returns sorted version numbers', () => {
-    fs.mkdirSync(path.join(tmpDir, 'v3'));
-    fs.mkdirSync(path.join(tmpDir, 'v1'));
-    fs.mkdirSync(path.join(tmpDir, 'v2'));
-    expect(getVersions(tmpDir)).toEqual([1, 2, 3]);
-  });
-
-  test('ignores non-version entries', () => {
-    fs.mkdirSync(path.join(tmpDir, 'v1'));
-    fs.mkdirSync(path.join(tmpDir, 'other'));
-    fs.mkdirSync(path.join(tmpDir, 'v2x'));
-    fs.writeFileSync(path.join(tmpDir, 'some-file.json'), '{}');
-    expect(getVersions(tmpDir)).toEqual([1]);
-  });
-
-  test('returns empty array for nonexistent directory', () => {
-    expect(getVersions(path.join(tmpDir, 'nonexistent'))).toEqual([]);
-  });
-
-  test('returns empty array for empty directory', () => {
-    expect(getVersions(tmpDir)).toEqual([]);
-  });
-});
-
-describe('getNextVersion', () => {
-  test('returns 1 for nonexistent directory', () => {
-    expect(getNextVersion(path.join(tmpDir, 'nonexistent'))).toBe(1);
-  });
-
-  test('returns 1 for empty directory', () => {
-    expect(getNextVersion(tmpDir)).toBe(1);
-  });
-
-  test('returns highest version + 1', () => {
-    fs.mkdirSync(path.join(tmpDir, 'v1'));
-    fs.mkdirSync(path.join(tmpDir, 'v3'));
-    expect(getNextVersion(tmpDir)).toBe(4);
-  });
-});
-
-describe('generateBuildManifest', () => {
-  test('writes valid JSON with schema, build, buildTime, and files', async () => {
-    const distDir = path.join(tmpDir, 'dist');
-    fs.mkdirSync(distDir);
-    fs.writeFileSync(path.join(distDir, 'index.html'), '<html></html>');
-
-    const manifestPath = path.join(distDir, 'tada.manifest.json');
-    await generateBuildManifest(distDir, manifestPath, 3);
-
-    const raw = fs.readFileSync(manifestPath, 'utf8');
-    const manifest = JSON.parse(raw) as BuildManifest;
-
-    expect(manifest.schema).toBe(1);
-    expect(manifest.build).toBe(3);
-    expect(typeof manifest.buildTime).toBe('string');
-    expect(manifest.buildTime).toMatch(/^\d{4}-\d{2}-\d{2}T/);
-    expect(typeof manifest.files).toBe('object');
-    expect('index.html' in manifest.files).toBe(true);
-    expect('tada.manifest.json' in manifest.files).toBe(false);
-  });
-});
-
-describe('loadManifest', () => {
-  test('loads and parses a manifest from a file', () => {
-    const manifest = makeManifest({ 'index.html': 'abc123' });
-    const filePath = path.join(tmpDir, 'tada.manifest.json');
-    fs.writeFileSync(filePath, JSON.stringify(manifest, null, 2) + '\n');
-
-    const loaded = loadManifest(filePath);
-    expect(loaded).toEqual(manifest);
-  });
-
-  test('returns null for a nonexistent file', () => {
-    const result = loadManifest(path.join(tmpDir, 'missing.json'));
-    expect(result).toBeNull();
-  });
-});
-
-describe('pruneOldVersions', () => {
-  function setupVersions(versions: number[]) {
-    for (const v of versions) {
-      const vDir = path.join(tmpDir, `v${v}`);
-      fs.mkdirSync(vDir);
-      fs.writeFileSync(
-        path.join(vDir, 'tada.manifest.json'),
-        JSON.stringify(makeManifest({}, v)),
-      );
-    }
-  }
-
-  test('removes all but the latest 2 version directories', () => {
-    setupVersions([1, 2, 3]);
-    pruneOldVersions(tmpDir);
-    expect(fs.existsSync(path.join(tmpDir, 'v1'))).toBe(false);
-    expect(fs.existsSync(path.join(tmpDir, 'v2'))).toBe(true);
-    expect(fs.existsSync(path.join(tmpDir, 'v3'))).toBe(true);
-  });
-
-  test('removes manifests inside pruned version directories', () => {
-    setupVersions([1, 2, 3]);
-    pruneOldVersions(tmpDir);
-    expect(fs.existsSync(path.join(tmpDir, 'v1', 'tada.manifest.json'))).toBe(
-      false,
-    );
-    expect(fs.existsSync(path.join(tmpDir, 'v2', 'tada.manifest.json'))).toBe(
-      true,
-    );
-    expect(fs.existsSync(path.join(tmpDir, 'v3', 'tada.manifest.json'))).toBe(
-      true,
-    );
-  });
-
-  test('keeps all versions when there are 2 or fewer', () => {
-    setupVersions([1, 2]);
-    pruneOldVersions(tmpDir);
-    expect(fs.existsSync(path.join(tmpDir, 'v1'))).toBe(true);
-    expect(fs.existsSync(path.join(tmpDir, 'v2'))).toBe(true);
-  });
-
-  test('is a no-op for a nonexistent directory', () => {
-    expect(() =>
-      pruneOldVersions(path.join(tmpDir, 'nonexistent')),
-    ).not.toThrow();
-  });
-});
-
-describe('copyChangedFiles', () => {
-  test('copies added and changed files', () => {
-    const distDir = path.join(tmpDir, 'dist');
-    const outDir = path.join(tmpDir, 'out');
-    fs.mkdirSync(distDir);
-    fs.mkdirSync(outDir);
-
-    fs.writeFileSync(path.join(distDir, 'added.html'), 'new file');
-    fs.writeFileSync(path.join(distDir, 'changed.css'), 'updated styles');
-
-    const diff: ManifestDiff = {
-      added: ['added.html'],
-      changed: ['changed.css'],
-      removed: ['old.html'],
-    };
-
-    copyChangedFiles(diff, distDir, outDir);
-
-    expect(fs.existsSync(path.join(outDir, 'added.html'))).toBe(true);
-    expect(fs.existsSync(path.join(outDir, 'changed.css'))).toBe(true);
-  });
-
-  test('does not copy removed files', () => {
-    const distDir = path.join(tmpDir, 'dist');
-    const outDir = path.join(tmpDir, 'out');
-    fs.mkdirSync(distDir);
-    fs.mkdirSync(outDir);
-
-    const diff: ManifestDiff = {
-      added: [],
-      changed: [],
-      removed: ['removed.html'],
-    };
-
-    copyChangedFiles(diff, distDir, outDir);
-
-    expect(fs.existsSync(path.join(outDir, 'removed.html'))).toBe(false);
-  });
-
-  test('creates nested directories as needed', () => {
-    const distDir = path.join(tmpDir, 'dist');
-    const outDir = path.join(tmpDir, 'out');
-    fs.mkdirSync(distDir);
-    fs.mkdirSync(outDir);
-
-    const nested = path.join(distDir, 'deep', 'nested');
-    fs.mkdirSync(nested, { recursive: true });
-    fs.writeFileSync(path.join(nested, 'page.html'), 'content');
-
-    const diff: ManifestDiff = {
-      added: ['deep/nested/page.html'],
-      changed: [],
-      removed: [],
-    };
-
-    copyChangedFiles(diff, distDir, outDir);
-
-    expect(
-      fs.existsSync(path.join(outDir, 'deep', 'nested', 'page.html')),
-    ).toBe(true);
-  });
-});