@abreen/tada 1.0.2 → 1.2.0

package/bin/validators.test.ts

@@ -0,0 +1,205 @@
+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/bin/validators.ts

@@ -0,0 +1,85 @@
+import type { SiteConfigInput, SiteVariables } from '../build/types';
+
+export function validateSymbol(value: string): string | null {
+  if (!value) {
+    return 'Symbol is required';
+  }
+  if (value.length > 5) {
+    return 'Symbol must be 5 characters or fewer';
+  }
+  if (!/^[A-Z0-9\- ]{1,5}$/.test(value)) {
+    return 'Symbol must contain only uppercase letters, digits, hyphens, and spaces';
+  }
+  return null;
+}
+
+export function validateColor(value: string): string | null {
+  if (!value) {
+    return 'Color is required';
+  }
+  try {
+    if (!Bun.color(value)) {
+      throw new Error();
+    }
+  } catch {
+    return 'Must be a valid CSS color, e.g. "tomato", "#c04040", or "hsl(195 70% 40%)"';
+  }
+  return null;
+}
+
+export function validateHue(value: string): string | null {
+  if (!value) {
+    return 'Hue is required';
+  }
+  const n = Number(String(value).replace(/deg$/, ''));
+  if (!Number.isInteger(n) || n < 0 || n > 360) {
+    return 'Must be an integer from 0 to 360, with or without "deg"';
+  }
+  return null;
+}
+
+export function validateUrl(value: string): string | null {
+  if (!value) {
+    return 'URL is required';
+  }
+  if (!/^https?:\/\/[-.:a-zA-Z0-9]+$/.test(value)) {
+    return 'Must be a valid URL like https://example.edu (no trailing slash or path)';
+  }
+  return null;
+}
+
+export function validateBasePath(value: string): string | null {
+  if (!/^\/[-a-zA-Z0-9]*$/.test(value)) {
+    return 'Must start with / and contain only letters, digits, and hyphens';
+  }
+  return null;
+}
+
+export function createSiteConfig({
+  title,
+  symbol,
+  themeColor,
+  tintHue,
+  tintAmount,
+  defaultTimeZone,
+  base,
+  basePath,
+  internalDomains,
+  features,
+}: SiteConfigInput): SiteVariables {
+  return {
+    title,
+    titlePostfix: ` - ${title}`,
+    symbol,
+    features,
+    base,
+    basePath,
+    internalDomains,
+    defaultTimeZone,
+    codeLanguages: { java: 'java', py: 'python' },
+    themeColor,
+    tintHue: Number(tintHue),
+    tintAmount: Number(tintAmount),
+    vars: {},
+  };
+}

package/{webpack/apply-base-path-plugin.js → build/apply-base-path-plugin.ts}

@@ -1,13 +1,20 @@
-const { createApplyBasePath } = require('./utils/paths');
-const { makeLogger } = require('./log');
+import type MarkdownIt from 'markdown-it';
+import type Token from 'markdown-it/lib/token.mjs';
+import { createApplyBasePath } from './utils/paths';
+import { isFeatureEnabled } from './features';
+import { makeLogger } from './log';
+import type { SiteVariables } from './types';
 
 const log = makeLogger(__filename);
 
-module.exports = function externalLinks(md, siteVariables, options = {}) {
+export default function applyBasePathPlugin(
+  md: MarkdownIt,
+  siteVariables: SiteVariables,
+): void {
   const applyBasePath = createApplyBasePath(siteVariables);
-  const rewriteCodeLinks = siteVariables.features?.code !== false;
+  const rewriteCodeLinks = isFeatureEnabled(siteVariables, 'code');
 
-  function rewriteInternalHref(href) {
+  function rewriteInternalHref(href: string): string {
     const match = href.match(/^([^?#]*)(.*)$/);
     const pathname = match ? match[1] : href;
     const suffix = match ? match[2] : '';
@@ -15,7 +22,7 @@ module.exports = function externalLinks(md, siteVariables, options = {}) {
 
     if (rewriteCodeLinks) {
       // Rewrite code file links to .html links
-      for (const ext of Object.keys(siteVariables.codeLanguages)) {
+      for (const ext of Object.keys(siteVariables.codeLanguages ?? {})) {
         if (modifiedPath.endsWith(`.${ext}`)) {
           modifiedPath = modifiedPath.replace(
             new RegExp(`\\.${ext}$`),
@@ -29,9 +36,12 @@ module.exports = function externalLinks(md, siteVariables, options = {}) {
     return modifiedPath + suffix;
   }
 
-  function checkAndApplyBasePath(token) {
+  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);
@@ -58,15 +68,25 @@ module.exports = function externalLinks(md, siteVariables, options = {}) {
         token.attrSet('src', afterApply);
       }
     } else if (token.type === 'html_block' || token.type === 'html_inline') {
-      token.content = token.content.replace(
-        /(<img\b[^>]*\bsrc=")(\/)([^"]*")/g,
-        (match, prefix, slash, rest) => {
-          const src = slash + rest.slice(0, -1);
-          const afterApply = applyBasePath(src);
-          log.debug`Applying base path to img tag src: ${src} -> ${afterApply}`;
-          return prefix + afterApply + '"';
-        },
-      );
+      token.content = token.content
+        .replace(
+          /(<a\b[^>]*\bhref=")(\/)([^"]*")/g,
+          (match, prefix, slash, rest) => {
+            const href = slash + rest.slice(0, -1);
+            const afterApply = applyBasePath(href);
+            log.debug`Applying base path to a tag href: ${href} -> ${afterApply}`;
+            return prefix + afterApply + '"';
+          },
+        )
+        .replace(
+          /(<img\b[^>]*\bsrc=")(\/)([^"]*")/g,
+          (match, prefix, slash, rest) => {
+            const src = slash + rest.slice(0, -1);
+            const afterApply = applyBasePath(src);
+            log.debug`Applying base path to img tag src: ${src} -> ${afterApply}`;
+            return prefix + afterApply + '"';
+          },
+        );
     }
 
     token.children?.map(checkAndApplyBasePath);
@@ -75,4 +95,4 @@ module.exports = function externalLinks(md, siteVariables, options = {}) {
   md.core.ruler.push('apply_base_path', state => {
     state.tokens.map(checkAndApplyBasePath);
   });
-};
+}