@abreen/tada 1.10.2 → 1.11.0

package/README.md

@@ -67,6 +67,12 @@ Install Tada globally:
 bun install --global @abreen/tada
 ```
 
+To update Tada to the latest version:
+
+```
+bun update --global @abreen/tada
+```
+
 ## Quick start
 
 Create a new site:
@@ -204,12 +210,13 @@ Example site configuration JSON file:
   "symbol": "CS 0",
   "themeColor": "hsl(351 70% 40%)",
   "tintAmount": 0,
-  "features": { "search": true, "code": true, "favicon": true },
+  "features": { "search": true, "favicon": true },
   "base": "https://example.edu",
   "basePath": "/cs0",
   "internalDomains": ["example.edu"],
   "defaultTimeZone": "America/New_York",
-  "codeLanguages": { "java": "java", "py": "python" },
+  "extensionToShikiLanguage": { "java": "java", "py": "python" },
+  "shikiLanguages": ["java", "python"],
   "vars": {
     "staffEmail": "staff@example.edu"
   }
@@ -226,13 +233,13 @@ Example site configuration JSON file:
 | `tintAmount` | *Optional*, percentage (0-100) of tint to apply (default `100`) |
 | `faviconSymbol` | *Optional*, the text to use instead of `symbol` in the favicon |
 | `features.search` | Enable search UI and Pagefind index generation |
-| `features.code` | Enable generated source-code HTML pages for configured code extensions |
 | `features.favicon` | Enable automatically generated favicons |
 | `features.footer` | Show the Tada footer at the bottom of every page |
 | `base` | Full base URL of the deployed site, used for metadata and URL generation |
 | `basePath` | URL prefix for deployment under a subpath (e.g., `"/cs101"`), use `"/"` at root |
 | `internalDomains` | Domain names treated as internal by link processing (not marked external) |
-| `codeLanguages` | Map file extension to Shiki language (e.g., `"java": "java"`) |
+| `extensionToShikiLanguage` | *Optional*, map from source-file extension to the Shiki language used for generated code pages and copied-source processing |
+| `shikiLanguages` | *Optional*, list of Shiki languages permitted in code blocks |
 | `faviconColor` | *Optional*, background color for favicon (defaults to `themeColor`) |
 | `faviconFontWeight` | *Optional*, font weight used for favicon text (default `700`) |
 | `vars` | Arbitrary key/value variables exposed to templates/content as `vars.*` (e.g., `<%= vars.staffEmail %>`) |

package/bin/tada.ts

@@ -332,7 +332,9 @@ async function initCommand(args: string[]): Promise<void> {
     base: 'http://localhost:8080',
     basePath: '/',
     internalDomains: ['localhost'],
-    features: { search: true, code: true, favicon: false, footer: true },
+    features: { search: true, favicon: false, footer: true },
+    extensionToShikiLanguage: bare ? {} : { java: 'java', py: 'python' },
+    shikiLanguages: bare ? [] : ['java', 'python', 'html'],
   });
 
   const prodConfig = createSiteConfig({
@@ -345,7 +347,9 @@ async function initCommand(args: string[]): Promise<void> {
     base: prodBase,
     basePath: prodBasePath,
     internalDomains: [prodDomain],
-    features: { search: true, code: true, favicon: true, footer: true },
+    features: { search: true, favicon: true, footer: true },
+    extensionToShikiLanguage: bare ? {} : { java: 'java', py: 'python' },
+    shikiLanguages: bare ? [] : ['java', 'python', 'html'],
   });
 
   fs.writeFileSync(

package/bin/validators.ts

@@ -66,6 +66,8 @@ export function createSiteConfig({
   basePath,
   internalDomains,
   features,
+  extensionToShikiLanguage,
+  shikiLanguages,
 }: SiteConfigInput): SiteVariables {
   return {
     title,
@@ -76,7 +78,8 @@ export function createSiteConfig({
     basePath,
     internalDomains,
     defaultTimeZone,
-    codeLanguages: { java: 'java', py: 'python' },
+    extensionToShikiLanguage,
+    shikiLanguages,
     themeColor,
     tintHue: Number(tintHue),
     tintAmount: Number(tintAmount),

package/build/apply-base-path-plugin.ts

@@ -3,7 +3,7 @@ import type MarkdownIt from 'markdown-it';
 import type Token from 'markdown-it/lib/token.mjs';
 import { JSDOM } from 'jsdom';
 import { createApplyBasePath } from './utils/paths';
-import { isFeatureEnabled } from './features';
+import { getExtensionToShikiLanguage } from './site-variables';
 import { isInternalLink } from './utils/link';
 import { makeLogger } from './log';
 import type { SiteVariables } from './types';
@@ -63,7 +63,6 @@ export default function applyBasePathPlugin(
   pluginOptions: ApplyBasePathOptions = {},
 ): void {
   const applyBasePath = createApplyBasePath(siteVariables);
-  const rewriteCodeLinks = isFeatureEnabled(siteVariables, 'code');
   const literateJavaOutputPaths = pluginOptions.literateJavaOutputPaths;
   const sourceUrlPath = pluginOptions.sourceUrlPath;
   const validTargets = pluginOptions.validTargets;
@@ -79,26 +78,24 @@ export default function applyBasePathPlugin(
     const suffix = match ? match[2] : '';
     let modifiedPath = pathname;
 
-    if (rewriteCodeLinks) {
-      for (const ext of Object.keys(siteVariables.codeLanguages ?? {})) {
-        if (modifiedPath.endsWith(`.${ext}`)) {
-          if (literateJavaOutputPaths && sourceUrlPath) {
-            const resolved = resolveAgainstSource(modifiedPath);
-            if (literateJavaOutputPaths.has(resolved)) {
-              break;
-            }
+    for (const ext of Object.keys(getExtensionToShikiLanguage(siteVariables))) {
+      if (modifiedPath.endsWith(`.${ext}`)) {
+        if (literateJavaOutputPaths && sourceUrlPath) {
+          const resolved = resolveAgainstSource(modifiedPath);
+          if (literateJavaOutputPaths.has(resolved)) {
+            break;
           }
-          // Only rewrite if the .html version exists. Public files with
-          // code extensions are copied as-is and have no .html page.
-          if (validTargets && sourceUrlPath) {
-            const resolved = resolveAgainstSource(modifiedPath);
-            if (!validTargets.has(`${resolved}.html`)) {
-              break;
-            }
+        }
+        // Only rewrite if the .html version exists. Public files with
+        // code extensions are copied as-is and have no .html page.
+        if (validTargets && sourceUrlPath) {
+          const resolved = resolveAgainstSource(modifiedPath);
+          if (!validTargets.has(`${resolved}.html`)) {
+            break;
           }
-          modifiedPath += '.html';
-          break;
         }
+        modifiedPath += '.html';
+        break;
       }
     }
 
@@ -137,10 +134,13 @@ export default function applyBasePathPlugin(
         const dom = new JSDOM(`<body>${token.content}__tada__</a></body>`);
         const anchor = dom.window.document.body.querySelector('a[href]');
         const href = anchor?.getAttribute('href');
-        if (anchor && href && href.startsWith('/')) {
-          const afterApply = applyBasePath(href);
-          log.debug`Applying base path to raw HTML anchor: ${href} -> ${afterApply}`;
-          anchor.setAttribute('href', afterApply);
+        if (anchor && href && isInternalLink(href)) {
+          const rewrittenHref = rewriteInternalHref(href);
+          const finalHref = href.startsWith('/')
+            ? applyBasePath(rewrittenHref)
+            : rewrittenHref;
+          log.debug`Rewriting raw HTML anchor: ${href} -> ${finalHref}`;
+          anchor.setAttribute('href', finalHref);
           token.content = serializeStartTag(anchor);
         }
       } else {
@@ -150,10 +150,13 @@ export default function applyBasePathPlugin(
 
         for (const anchor of document.body.querySelectorAll('a[href]')) {
           const href = anchor.getAttribute('href');
-          if (href && href.startsWith('/')) {
-            const afterApply = applyBasePath(href);
-            log.debug`Applying base path to raw HTML anchor: ${href} -> ${afterApply}`;
-            anchor.setAttribute('href', afterApply);
+          if (href && isInternalLink(href)) {
+            const rewrittenHref = rewriteInternalHref(href);
+            const finalHref = href.startsWith('/')
+              ? applyBasePath(rewrittenHref)
+              : rewrittenHref;
+            log.debug`Rewriting raw HTML anchor: ${href} -> ${finalHref}`;
+            anchor.setAttribute('href', finalHref);
             changed = true;
           }
         }

package/build/content-watch.ts

@@ -1,5 +1,6 @@
 import path from 'path';
 import type { SiteVariables } from './types';
+import { getExtensionToShikiLanguage } from './site-variables';
 import { getContentDir, getBuildContentFiles, isPartial } from './util';
 import { compileTemplates, getJsonDataDir, JSON_DATA_FILES } from './templates';
 import { B } from './colors';
@@ -47,7 +48,7 @@ export class ContentChangeDetector {
     const normalizedContentDir = path.resolve(contentDir) + path.sep;
     const buildContentFiles = getBuildContentFiles(
       contentDir,
-      Object.keys(this.siteVariables.codeLanguages || {}),
+      Object.keys(getExtensionToShikiLanguage(this.siteVariables)),
     );
 
     // Detect structural changes (files added or deleted)

package/build/generate-content-assets.ts

@@ -1,7 +1,10 @@
 import fs from 'fs';
 import path from 'path';
 import { makeLogger } from './log';
-import { isFeatureEnabled } from './features';
+import {
+  getExtensionToShikiLanguage,
+  getRuntimeBundledShikiLanguages,
+} from './site-variables';
 import { validateConfigLinks } from './validate-config-links';
 import { json } from './templates';
 import { initHighlighter } from './utils/shiki-highlighter';
@@ -30,7 +33,6 @@ const log = makeLogger(import.meta.url);
 
 export class ContentRenderer {
   private siteVariables: SiteVariables;
-  private loggedCodeDisabled: boolean;
   private sourceFileCache: Map<string, Asset[]>;
   private lastBuildFiles: Set<string>;
   private javacAvailable: boolean | undefined;
@@ -47,7 +49,6 @@ export class ContentRenderer {
 
   constructor(siteVariables: SiteVariables) {
     this.siteVariables = siteVariables;
-    this.loggedCodeDisabled = false;
     this.sourceFileCache = new Map();
     this.lastBuildFiles = new Set();
   }
@@ -57,14 +58,7 @@ export class ContentRenderer {
   }
 
   async initHighlighter(): Promise<void> {
-    const langs = [
-      ...new Set([
-        'plaintext',
-        'text',
-        ...Object.values(this.siteVariables.codeLanguages || {}),
-      ]),
-    ];
-    await initHighlighter(langs);
+    await initHighlighter(getRuntimeBundledShikiLanguages(this.siteVariables));
   }
 
   getDirtySourceFiles(
@@ -99,7 +93,7 @@ export class ContentRenderer {
 
   isCopiedAssetSource(filePath: string): boolean {
     const ext = path.extname(filePath).toLowerCase();
-    const codeExtensions = this.siteVariables.codeLanguages || {};
+    const codeExtensions = getExtensionToShikiLanguage(this.siteVariables);
     return Object.prototype.hasOwnProperty.call(codeExtensions, ext.slice(1));
   }
 
@@ -147,22 +141,19 @@ export class ContentRenderer {
       return assets;
     }
 
-    const codeExtensions = this.siteVariables.codeLanguages || {};
+    const codeExtensions = getExtensionToShikiLanguage(this.siteVariables);
     if (ext.slice(1) in codeExtensions) {
-      if (isFeatureEnabled(this.siteVariables, 'code')) {
-        assets.push(
-          ...renderCodePageAsset({
-            filePath,
-            contentDir,
-            distDir,
-            siteVariables: this.siteVariables,
-            assetFiles,
-          }),
-        );
-      } else if (!this.loggedCodeDisabled) {
-        log.info`Not generating source code pages due to site.features.code = false`;
-        this.loggedCodeDisabled = true;
-      }
+      assets.push(
+        ...renderCodePageAsset({
+          filePath,
+          contentDir,
+          distDir,
+          siteVariables: this.siteVariables,
+          validInternalTargets,
+          assetFiles,
+          literateJavaOutputPaths,
+        }),
+      );
     }
 
     return assets;
@@ -251,7 +242,7 @@ export class ContentRenderer {
     const contentDir: string = getContentDir();
     const buildContentFiles: string[] = getBuildContentFiles(
       contentDir,
-      Object.keys(this.siteVariables.codeLanguages || {}),
+      Object.keys(getExtensionToShikiLanguage(this.siteVariables)),
     );
     const buildFileSet = new Set<string>(buildContentFiles);
     const dirtySourceFiles = this.getDirtySourceFiles(
@@ -265,8 +256,7 @@ export class ContentRenderer {
     const validInternalTargets = getValidInternalTargets(
       contentDir,
       buildContentFiles,
-      Object.keys(this.siteVariables.codeLanguages || {}),
-      isFeatureEnabled(this.siteVariables, 'code'),
+      Object.keys(getExtensionToShikiLanguage(this.siteVariables)),
     );
     const literateJavaOutputPaths = new Set<string>();
     for (const filePath of buildContentFiles) {

package/build/pipeline.ts

@@ -1,5 +1,6 @@
 import fs from 'fs';
 import { getDevSiteVariables, getProdSiteVariables } from './site-variables';
+import { getExtensionToShikiLanguage } from './site-variables';
 import { compileTemplates } from './templates';
 import {
   getDistDir,
@@ -70,7 +71,7 @@ export async function runPipeline(
 
   const publicRelPaths = copyPublicFiles(publicDir, distDir);
   const processedExtensions = getProcessedExtensions(
-    Object.keys(siteVariables.codeLanguages || {}),
+    Object.keys(getExtensionToShikiLanguage(siteVariables)),
   );
   copyContentAssets(contentDir, distDir, processedExtensions, publicRelPaths);
 

package/build/site-variables.ts

@@ -1,8 +1,10 @@
 import fs from 'fs';
 import path from 'path';
+import { bundledLanguages } from 'shiki';
+import type { BundledLanguage } from 'shiki';
 import { compile as compileJsonSchema, doValidation } from './json-schema';
 import { getProjectDir } from './utils/paths';
-import type { SiteVariables } from './types';
+import type { PlainTextLanguage, SiteVariables } from './types';
 import siteSchema from '../schema/site.schema.json' with { type: 'json' };
 import timezones from '../src/timezone/timezones.json' with { type: 'json' };
 
@@ -10,7 +12,7 @@ const configDir = getProjectDir();
 
 const DEFAULT: Partial<SiteVariables> = {
   basePath: '/',
-  features: { search: true, code: true, favicon: true, footer: true },
+  features: { search: true, favicon: true, footer: true },
 };
 
 const isValid = compileJsonSchema(siteSchema);
@@ -21,12 +23,111 @@ function getJson(filePath: string): Record<string, unknown> {
   );
 }
 
+const PLAIN_TEXT_LANGUAGES = ['plain', 'text', 'txt'] as const;
+
+export function isPlainTextLanguage(lang: string): lang is PlainTextLanguage {
+  return PLAIN_TEXT_LANGUAGES.some(value => value === lang);
+}
+
+export function isBundledLanguage(lang: string): lang is BundledLanguage {
+  return Object.hasOwn(bundledLanguages, lang);
+}
+
+function isSupportedShikiLanguage(
+  lang: string,
+): lang is BundledLanguage | PlainTextLanguage {
+  return isBundledLanguage(lang) || isPlainTextLanguage(lang);
+}
+
+export function validateExtensionToShikiLanguage(
+  value: unknown,
+  fileName: string,
+): Record<string, BundledLanguage | PlainTextLanguage> | undefined {
+  if (value === undefined) {
+    return undefined;
+  }
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return undefined;
+  }
+
+  const validated: Record<string, BundledLanguage | PlainTextLanguage> = {};
+  for (const [ext, lang] of Object.entries(value)) {
+    if (typeof lang !== 'string') {
+      continue;
+    }
+    if (!isSupportedShikiLanguage(lang)) {
+      throw new Error(
+        `${fileName}: extensionToShikiLanguage.${ext} "${lang}" is not a supported Shiki language`,
+      );
+    }
+    validated[ext] = lang;
+  }
+  return validated;
+}
+
+export function validateShikiLanguages(
+  value: unknown,
+  fileName: string,
+): BundledLanguage[] | undefined {
+  if (value === undefined) {
+    return undefined;
+  }
+  if (!Array.isArray(value)) {
+    return undefined;
+  }
+
+  const validated: BundledLanguage[] = [];
+  for (let i = 0; i < value.length; i++) {
+    const lang = value[i];
+    if (typeof lang !== 'string') {
+      throw new Error(`${fileName}: shikiLanguages[${i}] must be a string`);
+    }
+    if (isPlainTextLanguage(lang)) {
+      throw new Error(
+        `${fileName}: shikiLanguages[${i}] "${lang}" must be a bundled Shiki language`,
+      );
+    }
+    if (!isBundledLanguage(lang)) {
+      throw new Error(
+        `${fileName}: shikiLanguages[${i}] "${lang}" is not a supported Shiki language`,
+      );
+    }
+    validated.push(lang);
+  }
+  return validated;
+}
+
+export function getExtensionToShikiLanguage(
+  siteVariables: SiteVariables,
+): Record<string, BundledLanguage | PlainTextLanguage> {
+  return siteVariables.extensionToShikiLanguage ?? {};
+}
+
+export function getRuntimeBundledShikiLanguages(
+  siteVariables: SiteVariables,
+): BundledLanguage[] {
+  const configured = Object.values(getExtensionToShikiLanguage(siteVariables))
+    .filter(isBundledLanguage)
+    .concat(siteVariables.shikiLanguages ?? []);
+  return [...new Set(configured)];
+}
+
 function getSiteVariables(env: string): SiteVariables {
   const fileName = `site.${env}.json`;
   const fromFile = getJson(fileName);
+  const extensionToShikiLanguage = validateExtensionToShikiLanguage(
+    fromFile.extensionToShikiLanguage,
+    fileName,
+  );
+  const shikiLanguages = validateShikiLanguages(
+    fromFile.shikiLanguages,
+    fileName,
+  );
   const variables = {
     ...DEFAULT,
     ...fromFile,
+    ...(extensionToShikiLanguage ? { extensionToShikiLanguage } : {}),
+    ...(shikiLanguages ? { shikiLanguages } : {}),
     features: {
       ...DEFAULT.features,
       ...((fromFile.features as Record<string, unknown>) || {}),

package/build/types.d.ts

@@ -1,3 +1,7 @@
+import type { BundledLanguage } from 'shiki';
+
+export type PlainTextLanguage = 'text' | 'txt' | 'plain';
+
 /** Site configuration loaded from site.dev.json or site.prod.json */
 export interface SiteVariables {
   base: string;
@@ -12,7 +16,11 @@ export interface SiteVariables {
   internalDomains?: string[];
   defaultTimeZone: string;
   features: FeatureConfig;
-  codeLanguages?: Record<string, string>;
+  extensionToShikiLanguage?: Record<
+    string,
+    BundledLanguage | PlainTextLanguage
+  >;
+  shikiLanguages?: BundledLanguage[];
   tintHue?: number;
   tintAmount?: number;
   vars?: Record<string, unknown>;
@@ -20,7 +28,6 @@ export interface SiteVariables {
 
 export type FeatureConfig = {
   search: boolean;
-  code: boolean;
   favicon: boolean;
   footer: boolean;
 };
@@ -102,6 +109,8 @@ export interface RenderCodePageOptions {
   distDir: string;
   siteVariables: SiteVariables;
   assetFiles: string[];
+  validInternalTargets: Set<string>;
+  literateJavaOutputPaths?: Set<string>;
   dependencyCollector?: RenderDependencyCollector;
 }
 
@@ -278,4 +287,6 @@ export interface SiteConfigInput {
   basePath: string;
   internalDomains: string[];
   features: FeatureConfig;
+  extensionToShikiLanguage: Record<string, BundledLanguage | PlainTextLanguage>;
+  shikiLanguages: BundledLanguage[];
 }

package/build/utils/code.ts

@@ -3,7 +3,8 @@ import path from 'path';
 import { parse as parseJava } from 'java-parser';
 import { JSDOM } from 'jsdom';
 import { makeLogger } from '../log';
-import { getHighlighter } from './shiki-highlighter';
+import { getExtensionToShikiLanguage } from '../site-variables';
+import { highlightCode } from './shiki-highlighter';
 import externalLinksPlugin from '../external-links-plugin';
 import applyBasePathPlugin from '../apply-base-path-plugin';
 import { createApplyBasePath } from './paths';
@@ -61,7 +62,9 @@ export function rewriteProseLinks(
   pageDirPath: string,
 ): string[] {
   const applyBasePath = createApplyBasePath(siteVariables);
-  const codeExtensions = Object.keys(siteVariables.codeLanguages ?? {});
+  const codeExtensions = Object.keys(
+    getExtensionToShikiLanguage(siteVariables),
+  );
 
   function rewriteCodeExt(p: string): string {
     for (const ext of codeExtensions) {
@@ -473,12 +476,7 @@ export function renderCodeSegment(
   let lineHtml: string[] | undefined;
 
   try {
-    const highlighter = getHighlighter();
-    const html = highlighter.codeToHtml(source, {
-      lang,
-      themes: { light: 'github-light', dark: 'github-dark' },
-      defaultColor: false,
-    });
+    const html = highlightCode(source, lang);
     const fragment = JSDOM.fragment(html);
     const inner = (fragment.querySelector('code') as HTMLElement).innerHTML;
     lineHtml = splitHighlightedHtmlIntoLines(inner, lines.length);
@@ -506,8 +504,15 @@ export function renderCodeWithComments(
   lang: string,
   siteVariables: SiteVariables,
   pageDirPath?: string,
+  sourceUrlPath?: string,
+  validTargets?: Set<string>,
+  literateJavaOutputPaths?: Set<string>,
 ): string {
-  const md = createCodeMarkdown(siteVariables);
+  const md = createCodeMarkdown(siteVariables, {
+    sourceUrlPath,
+    validTargets,
+    literateJavaOutputPaths,
+  });
   const lines = splitLines(sourceCode);
 
   // Group lines into segments

package/build/utils/content-files.ts

@@ -55,7 +55,6 @@ export function getContentSourceOutputRelPaths(
   contentDir: string,
   filePath: string,
   codeExtensions: string[],
-  codeEnabled: boolean,
 ): Set<string> {
   const processedExtSet = new Set(getProcessedExtensions(codeExtensions));
   const relPath = toPosix(path.relative(contentDir, filePath));
@@ -94,9 +93,7 @@ export function getContentSourceOutputRelPaths(
   );
   if (codeExtensionSet.has(ext)) {
     outputs.add(relPath);
-    if (codeEnabled) {
-      outputs.add(`${relPath}.html`);
-    }
+    outputs.add(`${relPath}.html`);
   }
 
   return outputs;
@@ -105,7 +102,6 @@ export function getContentSourceOutputRelPaths(
 export function getContentOutputRelPaths(
   contentDir: string,
   codeExtensions: string[],
-  codeEnabled: boolean,
 ): Set<string> {
   const buildContentFiles = getBuildContentFiles(contentDir, codeExtensions);
   const codeExtensionSet = new Set(
@@ -131,9 +127,7 @@ export function getContentOutputRelPaths(
 
     if (codeExtensionSet.has(ext.slice(1))) {
       outputs.add(relPath);
-      if (codeEnabled) {
-        outputs.add(`${relPath}.html`);
-      }
+      outputs.add(`${relPath}.html`);
     }
   }
 
@@ -195,7 +189,6 @@ export function getValidInternalTargets(
   contentDir: string,
   contentFiles: string[],
   codeExtensions: string[],
-  codeEnabled: boolean,
 ): Set<string> {
   const targets = new Set<string>();
   const codeExtensionSet = new Set(
@@ -220,9 +213,7 @@ export function getValidInternalTargets(
     } else if (extensionIsMarkdown(ext) || ext === '.html') {
       addGeneratedRouteAliases(targets, `/${subPath}.html`);
     } else if (codeExtensionSet.has(ext.slice(1))) {
-      if (codeEnabled) {
-        addGeneratedRouteAliases(targets, `/${relPath}.html`);
-      }
+      addGeneratedRouteAliases(targets, `/${relPath}.html`);
       targets.add(normalizeOutputPath(`/${relPath}`));
     }
   }

package/build/utils/markdown.ts

@@ -8,7 +8,8 @@ import markdownItFootnote from 'markdown-it-footnote';
 import markdownItDeflist from 'markdown-it-deflist';
 import markdownItContainer from 'markdown-it-container';
 import textToId, { deduplicateId } from '../text-to-id';
-import { getHighlighter } from './shiki-highlighter';
+import { highlightCode } from './shiki-highlighter';
+import { isBundledLanguage, isPlainTextLanguage } from '../site-variables';
 import headingSubtitlePlugin from '../heading-subtitle-plugin';
 import deflistIdPlugin from '../deflist-id-plugin';
 import externalLinksPlugin from '../external-links-plugin';
@@ -27,6 +28,7 @@ const QUESTION_PATTERN = /^question\s+(.+)$/;
 
 interface CreateMarkdownOptions {
   validatorOptions?: Record<string, unknown>;
+  filePath?: string;
   literateJavaOutputPaths?: Set<string>;
   sourceUrlPath?: string;
   validTargets?: Set<string>;
@@ -58,6 +60,7 @@ export function createMarkdown(
 ): MarkdownIt {
   const {
     validatorOptions = {},
+    filePath,
     literateJavaOutputPaths,
     sourceUrlPath,
     validTargets,
@@ -352,15 +355,24 @@ export function createMarkdown(
     const token = tokens[idx];
     const lang = token.info.trim().split(/\s+/)[0] || 'text';
     const code = token.content;
-    const highlighter = getHighlighter();
-    const useLang = highlighter.getLoadedLanguages().includes(lang)
-      ? lang
-      : 'text';
-    return highlighter.codeToHtml(code, {
-      lang: useLang,
-      themes: { light: 'github-light', dark: 'github-dark' },
-      defaultColor: false,
-    });
+    let useLang: string;
+
+    if (isPlainTextLanguage(lang)) {
+      useLang = 'text';
+    } else if (isBundledLanguage(lang)) {
+      if (!(siteVariables.shikiLanguages ?? []).includes(lang)) {
+        throw new Error(
+          `${filePath ?? 'Markdown'}: Markdown fence language "${lang}" is not listed in site.shikiLanguages`,
+        );
+      }
+      useLang = lang;
+    } else {
+      throw new Error(
+        `${filePath ?? 'Markdown'}: Markdown fence language "${lang}" is not a supported Shiki language`,
+      );
+    }
+
+    return highlightCode(code, useLang);
   };
 
   return markdown;

package/build/utils/render.ts

@@ -3,10 +3,10 @@ import path from 'path';
 import _ from 'lodash';
 import type MarkdownIt from 'markdown-it';
 import { stripHtml } from 'string-strip-html';
-import { isFeatureEnabled } from '../features';
 import { makeLogger } from '../log';
 import { B } from '../colors';
 import createGlobals from '../globals';
+import { getExtensionToShikiLanguage } from '../site-variables';
 import { render, json } from '../templates';
 import { validateParentLink } from '../validate-config-links';
 import {
@@ -284,14 +284,20 @@ export function renderCodePageAsset({
   distDir,
   siteVariables,
   assetFiles,
+  validInternalTargets,
+  literateJavaOutputPaths,
 }: RenderCodePageOptions): Asset[] {
   const { dir, name, ext } = path.parse(filePath);
   const subPath = toPosix(path.relative(contentDir, path.join(dir, name)));
   const applyBasePath = createApplyBasePath(siteVariables);
-  const lang = siteVariables.codeLanguages![ext.slice(1).toLowerCase()];
+  const lang =
+    getExtensionToShikiLanguage(siteVariables)[ext.slice(1).toLowerCase()];
   const rawSource = fs.readFileSync(filePath, 'utf-8');
   const sourceCode = applySourceTemplate(rawSource, siteVariables, filePath);
   const pageDirPath = toPosix(path.relative(contentDir, dir));
+  const sourceUrlPath = normalizeOutputPath(
+    `/${toUrlPath(path.relative(contentDir, filePath))}.html`,
+  );
 
   log.info`Rendering code page ${B`${subPath + ext}`}`;
   const content = renderCodeWithComments(
@@ -299,6 +305,9 @@ export function renderCodePageAsset({
     lang,
     siteVariables,
     pageDirPath,
+    sourceUrlPath,
+    validInternalTargets,
+    literateJavaOutputPaths,
   );
   const codeFilePath = applyBasePath(
     normalizeOutputPath(`/${toUrlPath(path.relative(contentDir, filePath))}`),
@@ -354,10 +363,6 @@ export function renderCopiedContentAsset({
 
   log.info`${label} ${B`${relPath}`}`;
 
-  if (!isFeatureEnabled(siteVariables, 'code')) {
-    return [{ assetPath: relPath, content: fs.readFileSync(filePath) }];
-  }
-
   const rawSource = fs.readFileSync(filePath, 'utf-8');
   const templated = applySourceTemplate(rawSource, siteVariables, filePath);
 
@@ -419,14 +424,13 @@ function renderPlainTextContent(
 } {
   const sourceUrlPath = `/${subPath}.html`;
   const md = createMarkdown(siteVariables, {
+    filePath,
     validatorOptions: {
       enabled: validateInternalLinks,
       filePath,
       sourceUrlPath,
       validTargets: validInternalTargets,
-      codeExtensions: isFeatureEnabled(siteVariables, 'code')
-        ? Object.keys(siteVariables.codeLanguages!)
-        : [],
+      codeExtensions: Object.keys(getExtensionToShikiLanguage(siteVariables)),
       onValidLink: (targetPath: string) => {
         dependencyCollector?.internalTargets?.add(targetPath);
       },
@@ -597,13 +601,12 @@ export function renderLiterateJavaPageAsset({
   // with Shiki-highlighted code blocks and optional JDI output columns
   const sourceUrlPath = `/${subPath}.java.html`;
   const md = createMarkdown(siteVariables, {
+    filePath,
     validatorOptions: {
       filePath,
       sourceUrlPath,
       validTargets: validInternalTargets,
-      codeExtensions: isFeatureEnabled(siteVariables, 'code')
-        ? Object.keys(siteVariables.codeLanguages!)
-        : [],
+      codeExtensions: Object.keys(getExtensionToShikiLanguage(siteVariables)),
       onValidLink: (targetPath: string) => {
         dependencyCollector?.internalTargets?.add(targetPath);
       },

package/build/utils/shiki-highlighter.ts

@@ -1,21 +1,67 @@
-import type { HighlighterGeneric, BundledLanguage, BundledTheme } from 'shiki';
+import type {
+  HighlighterGeneric,
+  BundledLanguage,
+  BundledTheme,
+  ThemeRegistrationAny,
+} from 'shiki';
 import { makeLogger } from '../log';
+import type { PlainTextLanguage } from '../types';
 
 const log = makeLogger(import.meta.url);
+const COMMENT_COLOR = 'var(--fg2-color)';
+const SHIKI_THEMES = {
+  light: 'tada-github-light',
+  dark: 'tada-github-dark',
+} as const;
+const COMMENT_SCOPES = [
+  'comment',
+  'punctuation.definition.comment',
+  'string.comment',
+];
 
 let highlighter: HighlighterGeneric<BundledLanguage, BundledTheme> | null =
   null;
 
-export async function initHighlighter(langs: string[]): Promise<void> {
-  if (highlighter) {
+async function createThemeWithCommentOverride(
+  themeName: 'github-light' | 'github-dark',
+  customName: 'tada-github-light' | 'tada-github-dark',
+): Promise<ThemeRegistrationAny> {
+  const { bundledThemes } = await import('shiki');
+  const theme = (await bundledThemes[themeName]()).default;
+  return {
+    ...theme,
+    name: customName,
+    tokenColors: [
+      ...(theme.tokenColors ?? []),
+      { scope: COMMENT_SCOPES, settings: { foreground: COMMENT_COLOR } },
+    ],
+  };
+}
+
+export async function initHighlighter(
+  langs: Array<BundledLanguage | PlainTextLanguage>,
+): Promise<void> {
+  const langsWithFallback = [
+    ...new Set<BundledLanguage | PlainTextLanguage>(['text', ...langs]),
+  ];
+  if (!highlighter) {
+    log.debug`Initializing syntax highlighter`;
+    const { createHighlighter } = await import('shiki');
+    const themes = await Promise.all([
+      createThemeWithCommentOverride('github-light', 'tada-github-light'),
+      createThemeWithCommentOverride('github-dark', 'tada-github-dark'),
+    ]);
+    highlighter = await createHighlighter({ themes, langs: langsWithFallback });
     return;
   }
-  log.debug`Initializing syntax highlighter`;
-  const { createHighlighter } = await import('shiki');
-  highlighter = await createHighlighter({
-    themes: ['github-light', 'github-dark'],
-    langs,
-  });
+
+  const missingLangs = langsWithFallback.filter(
+    lang => !highlighter!.getLoadedLanguages().includes(lang),
+  );
+  if (missingLangs.length > 0) {
+    log.debug`Loading additional syntax languages: ${missingLangs.join(', ')}`;
+    await highlighter.loadLanguage(...missingLangs);
+  }
 }
 
 export function getHighlighter(): HighlighterGeneric<
@@ -27,3 +73,11 @@ export function getHighlighter(): HighlighterGeneric<
   }
   return highlighter;
 }
+
+export function highlightCode(code: string, lang: string): string {
+  return getHighlighter().codeToHtml(code, {
+    lang,
+    themes: SHIKI_THEMES,
+    defaultColor: false,
+  });
+}

package/build/utils/source-template.ts

@@ -6,8 +6,8 @@ import type { SiteVariables } from '../types';
  * authors can interpolate site variables (like `<%= vars.fullCourseName %>`)
  * in their source code. The template context mirrors the one used for JSON
  * data files in `build/templates.ts`: `vars` and `site`. Invoked from
- * `renderCodePageAsset` and `renderCopiedContentAsset` only when
- * `features.code` is enabled.
+ * `renderCodePageAsset` and `renderCopiedContentAsset` for source files whose
+ * extension is mapped in `site.extensionToShikiLanguage`.
  */
 export function applySourceTemplate(
   source: string,

package/build/watch/assets.ts

@@ -5,6 +5,7 @@ import { copyFonts } from '../generate-fonts';
 import { copyKatexAssets } from '../generate-katex-assets';
 import { generateFavicons } from '../generate-favicon';
 import { generateWebAppManifest } from '../generate-web-app-manifest';
+import { getRuntimeBundledShikiLanguages } from '../site-variables';
 import { getPackageDir, toPosix } from '../util';
 import { initHighlighter } from '../utils/shiki-highlighter';
 import type { SiteVariables } from '../types';
@@ -27,14 +28,7 @@ export function removeDirIfExists(dir: string): void {
 export async function ensureHighlighter(
   siteVariables: SiteVariables,
 ): Promise<void> {
-  const langs = [
-    ...new Set([
-      'plaintext',
-      'text',
-      ...Object.values(siteVariables.codeLanguages || {}),
-    ]),
-  ];
-  await initHighlighter(langs);
+  await initHighlighter(getRuntimeBundledShikiLanguages(siteVariables));
 }
 
 export async function bundleWatchAssets(

package/build/watch/records.ts

@@ -1,5 +1,6 @@
 import fs from 'fs';
 import path from 'path';
+import { getExtensionToShikiLanguage } from '../site-variables';
 import {
   renderCodePageAsset,
   renderCopiedContentAsset,
@@ -87,12 +88,11 @@ export function renderContentRecord({
   persistOutputs?: boolean;
 }): TadaSourceRecord {
   const deps = createDependencyCollector();
-  const codeExtensions = Object.keys(siteVariables.codeLanguages || {}).map(
-    ext => ext.toLowerCase(),
-  );
+  const codeExtensions = Object.keys(
+    getExtensionToShikiLanguage(siteVariables),
+  ).map(ext => ext.toLowerCase());
   const ext = path.extname(filePath).slice(1).toLowerCase();
   const assets: Asset[] = [];
-  const codeEnabled = siteVariables.features.code !== false;
 
   if (isLiterateJava(filePath)) {
     assets.push(
@@ -128,18 +128,18 @@ export function renderContentRecord({
         }),
       );
     } else if (codeExtensions.includes(ext)) {
-      if (codeEnabled) {
-        assets.push(
-          ...renderCodePageAsset({
-            filePath,
-            contentDir: scan.contentDir,
-            distDir: outputDir,
-            siteVariables,
-            assetFiles,
-            dependencyCollector: deps.collector,
-          }),
-        );
-      }
+      assets.push(
+        ...renderCodePageAsset({
+          filePath,
+          contentDir: scan.contentDir,
+          distDir: outputDir,
+          siteVariables,
+          validInternalTargets: scan.validTargets,
+          assetFiles,
+          literateJavaOutputPaths: scan.literateJavaOutputPaths,
+          dependencyCollector: deps.collector,
+        }),
+      );
       assets.push(
         ...renderCopiedContentAsset({
           filePath,

package/build/watch/snapshot.ts

@@ -8,7 +8,7 @@ import {
   shouldSkipContentFile,
   toPosix,
 } from '../util';
-import { isFeatureEnabled } from '../features';
+import { getExtensionToShikiLanguage } from '../site-variables';
 import {
   extensionIsMarkdown,
   getProcessedExtensions,
@@ -106,9 +106,9 @@ function buildReverseMap(
 
 function getProcessedExts(siteVariables: SiteVariables): Set<string> {
   return new Set(
-    getProcessedExtensions(Object.keys(siteVariables.codeLanguages || {})).map(
-      ext => ext.toLowerCase(),
-    ),
+    getProcessedExtensions(
+      Object.keys(getExtensionToShikiLanguage(siteVariables)),
+    ).map(ext => ext.toLowerCase()),
   );
 }
 
@@ -144,13 +144,11 @@ function getContentOutputPathsForSource({
   filePath,
   processedExts,
   buildContent,
-  codeEnabled,
 }: {
   contentDir: string;
   filePath: string;
   processedExts: Set<string>;
   buildContent: boolean;
-  codeEnabled: boolean;
 }): Set<string> {
   const relPath = toPosix(path.relative(contentDir, filePath));
   const parsed = path.parse(relPath);
@@ -181,9 +179,7 @@ function getContentOutputPathsForSource({
   }
 
   outputs.add(relPath);
-  if (codeEnabled) {
-    outputs.add(`${relPath}.html`);
-  }
+  outputs.add(`${relPath}.html`);
   return outputs;
 }
 
@@ -193,14 +189,12 @@ function getTargetPathsForSource({
   filePath,
   processedExts,
   buildContent,
-  codeEnabled,
 }: {
   kind: 'content' | 'public';
   rootDir: string;
   filePath: string;
   processedExts: Set<string>;
   buildContent: boolean;
-  codeEnabled: boolean;
 }): Set<string> {
   const targets = new Set<string>();
   const relPath = toPosix(path.relative(rootDir, filePath));
@@ -238,9 +232,7 @@ function getTargetPathsForSource({
     return targets;
   }
 
-  if (codeEnabled) {
-    addGeneratedRouteAliases(targets, `/${relPath}.html`);
-  }
+  addGeneratedRouteAliases(targets, `/${relPath}.html`);
   targets.add(normalizeOutputPath(`/${relPath}`));
   return targets;
 }
@@ -258,7 +250,6 @@ export function scanProject(siteVariables: SiteVariables): TadaProjectScan {
   const publicDir = getPublicDir();
   const distDir = getDistDir();
   const processedExts = getProcessedExts(siteVariables);
-  const codeEnabled = isFeatureEnabled(siteVariables, 'code');
   const contentFiles = new Set(walkFiles(contentDir).sort());
   const publicFiles = new Set(walkFiles(publicDir).sort());
   const buildContentFiles = new Set<string>();
@@ -286,7 +277,6 @@ export function scanProject(siteVariables: SiteVariables): TadaProjectScan {
       filePath,
       processedExts,
       buildContent,
-      codeEnabled,
     });
     sourceOutputPaths.set(filePath, outputs);
     for (const outputPath of outputs) {
@@ -299,7 +289,6 @@ export function scanProject(siteVariables: SiteVariables): TadaProjectScan {
       filePath,
       processedExts,
       buildContent,
-      codeEnabled,
     });
     sourceTargetPaths.set(filePath, targets);
     for (const target of targets) {
@@ -317,7 +306,6 @@ export function scanProject(siteVariables: SiteVariables): TadaProjectScan {
       filePath,
       processedExts,
       buildContent: false,
-      codeEnabled,
     });
     sourceTargetPaths.set(filePath, targets);
     for (const target of targets) {
@@ -349,7 +337,6 @@ export function updateProjectScan(
   const contentDir = getContentDir();
   const publicDir = getPublicDir();
   const distDir = getDistDir();
-  const codeEnabled = isFeatureEnabled(snapshot.siteVariables, 'code');
   const contentFiles = new Set(snapshot.contentFiles);
   const buildContentFiles = new Set(snapshot.buildContentFiles);
   const publicFiles = new Set(snapshot.publicFiles);
@@ -412,7 +399,6 @@ export function updateProjectScan(
         filePath: sourcePath,
         processedExts: snapshot.processedExts,
         buildContent,
-        codeEnabled,
       });
       sourceOutputPaths.set(sourcePath, outputs);
       for (const outputPath of outputs) {
@@ -427,7 +413,6 @@ export function updateProjectScan(
           filePath: sourcePath,
           processedExts: snapshot.processedExts,
           buildContent,
-          codeEnabled,
         }),
       );
       continue;
@@ -445,7 +430,6 @@ export function updateProjectScan(
         filePath: sourcePath,
         processedExts: snapshot.processedExts,
         buildContent: false,
-        codeEnabled,
       }),
     );
   }

package/init/content/lectures/01/index.md

@@ -13,7 +13,8 @@ The value of `vars.foobar` is <%= vars.foobar %>.
 You can add any variables you want to the `site.dev.json` and `site.prod.json`
 files under the `"vars"` property and access them using Lodash template syntax
 from Markdown files, HTML files, and source code. (Lodash template subtitution
-only works in source code files when `features.code` is `true`.)
+only works in source code files whose extension is listed in
+`extensionToShikiLanguage`.)
 
 ## Slides
 
@@ -35,8 +36,9 @@ you should see a result for page 2 of `lecture1.pdf`.
   - [A direct link](./Pair.java) to the source code
 
 !!! note
-Syntax highlighting is controlled by the `codeLanguages` configuration object
-and is generated at build time by [Shiki](https://shiki.style).
+Code pages and code blocks are highlighted by [Shiki](https://shiki.style).
+A source code file's extension must be present in the config file under
+`extensionToShikiLanguage` to be converted into a code page.
 !!!
 
 ## Review questions

package/init/content/markdown.md

@@ -92,7 +92,7 @@ By default, MarkdownIt supports [the table syntax from GitHub "flavored" Markdow
 
 Here's a basic table:
 
-```markdown
+```
 | Syntax | Description  |
 | ------ | ------------ |
 | Cell   | Another cell |
@@ -102,7 +102,7 @@ Here's a basic table:
 You can omit the starting and ending vertical pipes, and the pipes don't have
 to perfectly match on every line:
 
-```markdown
+```
 Syntax | Description
 --- | ---
 Cell | Another cell
@@ -197,7 +197,7 @@ Binary tree
 Each term (bolded) of the definition list gets its own `id` attribute, like
 headings, so you may [link directly to a definition](#binary-tree):
 
-```text
+```
 /example.html#binary-tree
 ```
 
@@ -256,7 +256,7 @@ Testing <dfn>definition</dfn> style
 
 You can specify a custom title:
 
-```markdown
+```
 !!! warning Double-check your answers
 No partial credit is offered for these questions, double-check your answers!
 !!!
@@ -275,7 +275,7 @@ table of contents alongside headings.
 
 Use
 
-```markdown
+```
 ??? question What is a base case? Give an example.
 
 The <dfn>base case</dfn> is the simplest version of the problem that can be
@@ -302,7 +302,7 @@ different background.
 
 Use
 
-```markdown
+```
 ::: section
 
 ### Submitting your work
@@ -337,7 +337,7 @@ Email the files you changed to the course staff.
 
 Use
 
-```markdown
+```
 +++
 Content in the first column (on the left)...
 +++
@@ -356,6 +356,7 @@ including lists:
 +++
 Here's a paragraph in the second column. We'll use a code block on this side:
 ```java
+// Return true if the number is odd
 static boolean isOdd(int n) {
   return n % 2 == 1;
 }

package/init/public/Test.java

@@ -1,7 +1,7 @@
 /// A source code file which is simply copied into the built site.
 /// Tada will not process this file: it won't create an HTML file for it
-/// (even if `features.code` is `true`) and it won't appear in search results
-/// (even if `features.search` is `true`).
+/// (even if its extension is listed in `extensionToShikiLanguage`) and
+// it won't appear in search results (even if `features.search` is `true`).
 public class Test {
   public static void main(String[] args) {
     System.out.println("hello");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abreen/tada",
-  "version": "1.10.2",
+  "version": "1.11.0",
   "type": "module",
   "description": "A static site generator",
   "license": "MIT",

package/schema/site.schema.json

@@ -4,15 +4,9 @@
   "properties": {
     "features": {
       "type": "object",
-      "default": {
-        "search": true,
-        "code": true,
-        "favicon": true,
-        "footer": true
-      },
+      "default": { "search": true, "favicon": true, "footer": true },
       "properties": {
         "search": { "type": "boolean", "default": true },
-        "code": { "type": "boolean", "default": true },
         "favicon": { "type": "boolean", "default": true },
         "footer": { "type": "boolean", "default": true }
       },
@@ -55,10 +49,11 @@
     },
     "defaultTimeZone": { "type": "string" },
     "vars": { "type": "object" },
-    "codeLanguages": {
+    "extensionToShikiLanguage": {
       "type": "object",
       "additionalProperties": { "type": "string" }
-    }
+    },
+    "shikiLanguages": { "type": "array", "items": { "type": "string" } }
   },
   "additionalProperties": false
 }

package/src/page-update/index.ts

@@ -8,7 +8,7 @@ import {
 } from '../validators';
 import { NAVIGATION_EVENT, refreshCurrentPage } from '../navigate/runtime';
 
-const POLL_INTERVAL_MS = 60_000;
+const POLL_INTERVAL_MS = 600_000;
 
 export interface PageUpdateOptions {
   pollIntervalMs?: number;