erudit 4.3.2 → 4.3.3-dev.1

package/app/pages/page/[...pageId].vue

@@ -17,7 +17,7 @@ async function proseMounted() {
   );
 }
 
-const lastChangedDate = useLastChanged(() => mainContent.contentRelativePath);
+const lastChangedDate = useLastChanged(() => mainContent.lastmod);
 
 await useContentSeo({
   title: mainContent.title,
@@ -29,6 +29,8 @@ await useContentSeo({
   },
   seo: mainContent.seo,
   snippets: mainContent.snippets,
+  breadcrumbs: mainContent.breadcrumbs,
+  lastmod: mainContent.lastmod,
 });
 </script>
 

package/app/plugins/prerender.server.ts

@@ -26,6 +26,7 @@ export default defineNuxtPlugin({
       '/api/prerender/quotes',
       '/api/prerender/news',
       '/api/prerender/ogImages',
+      '/api/prerender/favicons',
     ];
 
     for (const provider of routeProviders) {

package/modules/erudit/setup/runtimeConfig.ts

@@ -1,6 +1,7 @@
 import { existsSync } from 'node:fs';
 import type { Nuxt } from '@nuxt/schema';
 import { sn } from 'unslash';
+import { findPath } from 'nuxt/kit';
 import type { EruditConfig } from '@erudit-js/core/eruditConfig/config';
 import { isDevLikeMode } from '@erudit-js/core/mode';
 
@@ -31,6 +32,7 @@ export async function setupEruditRuntimeConfig(nuxt: Nuxt) {
     elements: eruditConfig.elements || [],
     countElements: eruditConfig.countElements || [],
     indexPage: eruditConfig.indexPage,
+    lastmod: await resolveLastmodConfig(eruditConfig),
   }) satisfies EruditRuntimeConfig;
 
   //
@@ -46,9 +48,6 @@ export async function setupEruditRuntimeConfig(nuxt: Nuxt) {
         repository:
           eruditConfig.debug?.fakeApi?.repository ??
           (nuxt.options.dev || isDevLikeMode(ERUDIT_MODE)),
-        lastChanged:
-          eruditConfig.debug?.fakeApi?.lastChanged ??
-          (nuxt.options.dev || isDevLikeMode(ERUDIT_MODE)),
       },
       analytics: eruditConfig.debug?.analytics,
     },
@@ -106,3 +105,40 @@ export async function setupEruditRuntimeConfig(nuxt: Nuxt) {
     nuxtAugmentations: eruditConfig.nuxtAugmentations,
   };
 }
+
+async function resolveLastmodConfig(
+  eruditConfig: EruditConfig,
+): Promise<EruditRuntimeConfig['lastmod']> {
+  const lastmod = eruditConfig.lastmod;
+
+  if (!lastmod || lastmod.enabled === false) {
+    return undefined;
+  }
+
+  if (lastmod.type === 'git') {
+    return { type: 'git' };
+  }
+
+  if (lastmod.type === 'custom') {
+    if (!lastmod.scriptPath) {
+      throw new Error(
+        'Lastmod config with type "custom" requires a "scriptPath"!',
+      );
+    }
+
+    const absPath = await findPath(lastmod.scriptPath, {
+      cwd: PROJECT_PATH,
+      extensions: ['.ts', '.js'],
+    });
+
+    if (!absPath) {
+      throw new Error(
+        `Failed to resolve lastmod provider path "${lastmod.scriptPath}"!`,
+      );
+    }
+
+    return { type: 'custom', scriptPath: absPath };
+  }
+
+  return undefined;
+}

package/nuxt.config.ts

@@ -53,7 +53,7 @@ export default defineNuxtConfig({
     rollupConfig: {
       // Prevent inlining some packages
       external(source) {
-        const ignore = ['jiti', 'tsprose', '@resvg/resvg-js'];
+        const ignore = ['jiti', 'tsprose', '@resvg/resvg-js', 'sharp'];
 
         for (const ignoreItem of ignore) {
           if (source.includes(ignoreItem)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "erudit",
-  "version": "4.3.2",
+  "version": "4.3.3-dev.1",
   "type": "module",
   "description": "🤓 CMS for perfect educational sites.",
   "license": "MIT",
@@ -24,12 +24,11 @@
     }
   },
   "dependencies": {
-    "@erudit-js/cli": "4.3.2",
-    "@erudit-js/core": "4.3.2",
-    "@erudit-js/prose": "4.3.2",
-    "unslash": "^2.0.0",
+    "@erudit-js/cli": "4.3.3-dev.1",
+    "@erudit-js/core": "4.3.3-dev.1",
+    "@erudit-js/prose": "4.3.3-dev.1",
     "@floating-ui/vue": "^1.1.11",
-    "tsprose": "^1.0.1",
+    "@resvg/resvg-js": "^2.6.2",
     "@tailwindcss/vite": "^4.2.1",
     "better-sqlite3": "^12.8.0",
     "chokidar": "^5.0.0",
@@ -40,16 +39,18 @@
     "flexsearch": "^0.8.212",
     "glob": "^13.0.6",
     "image-size": "^2.0.2",
-    "@resvg/resvg-js": "^2.6.2",
-    "satori": "^0.25.0",
     "jiti": "^2.6.1",
     "nuxt": "4.4.2",
     "nuxt-my-icons": "1.2.2",
     "perfect-debounce": "^2.1.0",
+    "satori": "^0.26.0",
+    "sharp": "^0.34.5",
     "tailwindcss": "^4.2.1",
+    "ts-xor": "^1.3.0",
+    "tsprose": "^1.0.1",
+    "unslash": "^2.0.0",
     "vue": "latest",
-    "vue-router": "latest",
-    "ts-xor": "^1.3.0"
+    "vue-router": "latest"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13"

package/server/api/main/content/[...contentTypePath].ts

@@ -20,6 +20,7 @@ export default defineEventHandler<Promise<MainContent>>(async (event) => {
     ['topic', 'page'].includes(contentTypePath.type),
   );
   const seo = await ERUDIT.repository.content.seo(fullId);
+  const lastmod = await ERUDIT.repository.content.lastmod(fullId);
 
   const bookNode = ERUDIT.contentNav.getBookFor(fullId);
   const bookTitle = bookNode
@@ -37,6 +38,7 @@ export default defineEventHandler<Promise<MainContent>>(async (event) => {
     bookTitle,
     breadcrumbs: await ERUDIT.repository.content.breadcrumbs(fullId),
     seo,
+    lastmod,
   };
 
   if (description) {

package/server/api/prerender/favicons.ts

@@ -0,0 +1,31 @@
+import { loadFaviconSource } from '#layers/erudit/server/erudit/favicon/loadSource';
+import {
+  FAVICON_KEYS,
+  FAVICON_SIZES,
+  getFaviconHref,
+  extFromHref,
+} from '#layers/erudit/server/erudit/favicon/shared';
+
+export default defineEventHandler(async () => {
+  const routes: string[] = [];
+
+  for (const key of FAVICON_KEYS) {
+    const href = getFaviconHref(key);
+    if (!href) continue;
+
+    const source = await loadFaviconSource(href);
+    if (!source) continue;
+
+    const ext = extFromHref(href);
+    if (ext) {
+      routes.push(`/favicon/${key}/source${ext}`);
+    }
+
+    for (const size of FAVICON_SIZES) {
+      if (source.width !== undefined && source.width < size) continue;
+      routes.push(`/favicon/${key}/${size}.png`);
+    }
+  }
+
+  return routes;
+});

package/server/erudit/build.ts

@@ -9,6 +9,7 @@ import { buildSponsors } from './sponsors/build';
 import { buildCameos } from './cameos/build';
 import { buildContentNav } from './content/nav/build';
 import { requestFullContentResolve, resolveContent } from './content/resolve';
+import { buildContentLastmod } from './content/lastmod';
 import { buildGlobalContent } from './content/global/build';
 import { buildNews } from './news/build';
 import { triggerReload } from './reloadSignal';
@@ -29,6 +30,7 @@ export async function buildServerErudit() {
       await buildContentNav();
       await buildGlobalContent();
       await resolveContent();
+      await buildContentLastmod();
       ERUDIT.log.success(styleText('green', 'Build Complete!'));
     } catch (buildError) {
       requestFullContentResolve();

package/server/erudit/content/lastmod.ts

@@ -0,0 +1,206 @@
+import { spawnSync } from 'node:child_process';
+import { eq } from 'drizzle-orm';
+import type { LastmodProvider } from '@erudit-js/core/eruditConfig/lastmod';
+
+export async function buildContentLastmod() {
+  const lastmodConfig = ERUDIT.config.lastmod;
+
+  if (!lastmodConfig) {
+    return;
+  }
+
+  ERUDIT.log.debug.start('Collecting lastmod dates...');
+
+  let collected = false;
+
+  if (lastmodConfig.type === 'git') {
+    collected = await collectGitLastmod();
+  } else if (lastmodConfig.type === 'custom' && lastmodConfig.scriptPath) {
+    collected = await collectCustomLastmod(lastmodConfig.scriptPath);
+  }
+
+  if (collected) {
+    ERUDIT.log.success('Lastmod dates collected!');
+  }
+}
+
+function getGitContentPrefix(): string | undefined {
+  const projectRoot = ERUDIT.paths.project();
+
+  const result = spawnSync('git', ['rev-parse', '--show-prefix'], {
+    cwd: projectRoot,
+    encoding: 'utf-8',
+  });
+
+  if (result.status !== 0) return undefined;
+
+  // gitPrefix is e.g. "playground/" or "" (if project is at repo root)
+  return result.stdout.trim() + 'content/';
+}
+
+async function collectGitLastmod(): Promise<boolean> {
+  const projectRoot = ERUDIT.paths.project();
+  const contentPrefix = getGitContentPrefix();
+
+  if (!contentPrefix) {
+    ERUDIT.log.warn(
+      'Failed to detect git prefix — lastmod dates will be unavailable. ' +
+        'Is this a git repository?',
+    );
+    return false;
+  }
+
+  const result = spawnSync(
+    'git',
+    ['log', '--format=format:%cI', '--name-only', '--', contentPrefix],
+    {
+      cwd: projectRoot,
+      encoding: 'utf-8',
+      maxBuffer: 50 * 1024 * 1024,
+    },
+  );
+
+  if (result.status !== 0) {
+    ERUDIT.log.warn(
+      'Failed to run git log — lastmod dates will be unavailable. ' +
+        'Is this a git repository?',
+    );
+    return false;
+  }
+
+  const stdout = result.stdout;
+
+  if (!stdout.trim()) {
+    return false;
+  }
+
+  // Parse git log output: blocks separated by double newlines
+  // Each block: first line = ISO date, remaining lines = file paths
+  const dateMap = new Map<string, string>();
+  const blocks = stdout.split('\n\n');
+
+  for (const block of blocks) {
+    const lines = block.split('\n').filter(Boolean);
+    if (lines.length < 2) continue;
+
+    const date = lines[0]!;
+    for (let i = 1; i < lines.length; i++) {
+      const filePath = lines[i]!;
+      if (!filePath.startsWith(contentPrefix)) continue;
+
+      // Strip the prefix to get the content-relative path
+      // e.g. "playground/content/1-test/page.tsx" → "1-test"
+      const relPath = filePath.slice(contentPrefix.length);
+      const lastSlash = relPath.lastIndexOf('/');
+      const contentRelPath =
+        lastSlash > 0 ? relPath.slice(0, lastSlash) : relPath;
+
+      // Keep only the first (most recent) date per path
+      if (!dateMap.has(contentRelPath)) {
+        dateMap.set(contentRelPath, date);
+      }
+    }
+  }
+
+  // Detect shallow clone: if all dates are identical, warn
+  if (dateMap.size > 1) {
+    const dates = new Set(dateMap.values());
+    if (dates.size === 1) {
+      ERUDIT.log.warn(
+        'All git lastmod dates are identical — this likely means a shallow clone. ' +
+          'Use "fetch-depth: 0" in GitHub Actions checkout for accurate dates.',
+      );
+    }
+  }
+
+  // Build a map keyed by fullId from the contentRelPath-keyed dateMap
+  const ownDates = new Map<string, string>();
+  for (const [, navNode] of ERUDIT.contentNav.id2Node) {
+    const date = dateMap.get(navNode.contentRelPath);
+    if (date) {
+      ownDates.set(navNode.fullId, date);
+    }
+  }
+
+  await propagateAndSave(ownDates);
+  return true;
+}
+
+async function collectCustomLastmod(absPath: string): Promise<boolean> {
+  let provider: LastmodProvider;
+
+  try {
+    const module = await ERUDIT.import(absPath);
+    provider = (module as any).default;
+  } catch (error) {
+    ERUDIT.log.warn(
+      `Failed to import lastmod provider from "${absPath}":\n${error}`,
+    );
+    return false;
+  }
+
+  if (typeof provider !== 'function') {
+    ERUDIT.log.warn(
+      `Lastmod provider at "${absPath}" does not have a default-exported function!`,
+    );
+    return false;
+  }
+
+  // Collect dates from custom provider
+  const customDates = new Map<string, string>();
+
+  for (const [, navNode] of ERUDIT.contentNav.id2Node) {
+    try {
+      const date = await provider({
+        fullId: navNode.fullId,
+        mode: ERUDIT.mode,
+        projectPath: ERUDIT.paths.project(),
+      });
+      if (date instanceof Date && !isNaN(date.getTime())) {
+        customDates.set(navNode.fullId, date.toISOString());
+      }
+    } catch (error) {
+      ERUDIT.log.warn(
+        `Lastmod provider error for "${navNode.fullId}": ${error}`,
+      );
+    }
+  }
+
+  await propagateAndSave(customDates);
+  return true;
+}
+
+/**
+ * Propagate dates upward through the nav tree (parents inherit the most
+ * recent date from their children) and write resolved dates to the DB.
+ */
+async function propagateAndSave(ownDates: Map<string, string>) {
+  // Process deepest nodes first so child dates are finalized before parents
+  const sortedNodes = Array.from(ERUDIT.contentNav.id2Node.values()).sort(
+    (a, b) => b.fullId.split('/').length - a.fullId.split('/').length,
+  );
+
+  const resolvedDates = new Map<string, string>();
+
+  for (const navNode of sortedNodes) {
+    let bestDate = ownDates.get(navNode.fullId);
+
+    for (const child of navNode.children ?? []) {
+      const childDate = resolvedDates.get(child.fullId);
+      if (childDate && (!bestDate || childDate > bestDate)) {
+        bestDate = childDate;
+      }
+    }
+
+    if (bestDate) {
+      resolvedDates.set(navNode.fullId, bestDate);
+    }
+  }
+
+  for (const [fullId, date] of resolvedDates) {
+    await ERUDIT.db
+      .update(ERUDIT.db.schema.content)
+      .set({ lastmod: date })
+      .where(eq(ERUDIT.db.schema.content.fullId, fullId));
+  }
+}

package/server/erudit/content/repository/lastmod.ts

@@ -0,0 +1,12 @@
+import { eq } from 'drizzle-orm';
+
+export async function getContentLastmod(
+  fullId: string,
+): Promise<string | undefined> {
+  const result = await ERUDIT.db.query.content.findFirst({
+    columns: { lastmod: true },
+    where: eq(ERUDIT.db.schema.content.fullId, fullId),
+  });
+
+  return result?.lastmod ?? undefined;
+}

package/server/erudit/db/schema/content.ts

@@ -15,4 +15,5 @@ export const content = sqliteTable('content', {
   decorationExtension: text(),
   externals: text({ mode: 'json' }).$type<ContentExternalItem[]>(),
   seo: text({ mode: 'json' }).$type<ContentSeo>(),
+  lastmod: text(),
 });

package/server/erudit/favicon/convertToPng.ts

@@ -0,0 +1,48 @@
+import sharp from 'sharp';
+import { Resvg } from '@resvg/resvg-js';
+import type { FaviconSource } from './loadSource';
+
+const cache = new Map<string, Buffer>();
+
+export async function convertFaviconToPng(
+  faviconKey: string,
+  source: FaviconSource,
+  size: number,
+): Promise<Buffer> {
+  const cacheKey = `${faviconKey}:${size}`;
+  const cached = cache.get(cacheKey);
+  if (cached) return cached;
+
+  const png =
+    source.mime === 'image/svg+xml'
+      ? await svgToPng(source.buffer, size)
+      : await rasterToPng(source.buffer, size);
+
+  cache.set(cacheKey, png);
+  return png;
+}
+
+async function svgToPng(svgBuffer: Buffer, size: number): Promise<Buffer> {
+  const resvg = new Resvg(svgBuffer.toString('utf-8'), {
+    fitTo: { mode: 'width', value: size },
+  });
+  const rendered = Buffer.from(resvg.render().asPng());
+
+  return sharp(rendered)
+    .resize(size, size, {
+      fit: 'contain',
+      background: { r: 0, g: 0, b: 0, alpha: 0 },
+    })
+    .png()
+    .toBuffer();
+}
+
+async function rasterToPng(buffer: Buffer, size: number): Promise<Buffer> {
+  return sharp(buffer)
+    .resize(size, size, {
+      fit: 'contain',
+      background: { r: 0, g: 0, b: 0, alpha: 0 },
+    })
+    .png()
+    .toBuffer();
+}

package/server/erudit/favicon/loadSource.ts

@@ -0,0 +1,139 @@
+import { readFile } from 'node:fs/promises';
+import { isAbsolute } from 'node:path';
+import { imageSize } from 'image-size';
+import { mimeFromExt } from './shared';
+
+export interface FaviconSource {
+  buffer: Buffer;
+  mime: string;
+  /** Undefined for SVG (treated as infinitely scalable) */
+  width?: number;
+  height?: number;
+}
+
+function mimeFromBuffer(buffer: Buffer): string | undefined {
+  if (buffer.length < 12) return undefined;
+
+  if (buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff)
+    return 'image/jpeg';
+
+  if (
+    buffer[0] === 0x89 &&
+    buffer[1] === 0x50 &&
+    buffer[2] === 0x4e &&
+    buffer[3] === 0x47
+  )
+    return 'image/png';
+
+  if (buffer[0] === 0x47 && buffer[1] === 0x49 && buffer[2] === 0x46)
+    return 'image/gif';
+
+  if (
+    buffer[0] === 0x52 &&
+    buffer[1] === 0x49 &&
+    buffer[2] === 0x46 &&
+    buffer[3] === 0x46 &&
+    buffer[8] === 0x57 &&
+    buffer[9] === 0x45 &&
+    buffer[10] === 0x42 &&
+    buffer[11] === 0x50
+  )
+    return 'image/webp';
+
+  if (buffer[0] === 0x42 && buffer[1] === 0x4d) return 'image/bmp';
+
+  if (
+    buffer[0] === 0x00 &&
+    buffer[1] === 0x00 &&
+    buffer[2] === 0x01 &&
+    buffer[3] === 0x00
+  )
+    return 'image/x-icon';
+
+  const head = buffer.subarray(0, 512).toString('utf-8').trim();
+  if (head.startsWith('<svg') || head.startsWith('<?xml'))
+    return 'image/svg+xml';
+
+  return undefined;
+}
+
+function resolveMime(
+  buffer: Buffer,
+  href: string,
+  serverMime?: string,
+): string {
+  return (
+    mimeFromBuffer(buffer) ||
+    mimeFromExt(href) ||
+    (serverMime?.startsWith('image/') ? serverMime : undefined) ||
+    'application/octet-stream'
+  );
+}
+
+function detectDimensions(
+  buffer: Buffer,
+  mime: string,
+): { width?: number; height?: number } {
+  if (mime === 'image/svg+xml') return {};
+
+  try {
+    const size = imageSize(buffer);
+    return { width: size.width, height: size.height };
+  } catch {
+    return {};
+  }
+}
+
+function buildSource(buffer: Buffer, mime: string): FaviconSource {
+  return { buffer, mime, ...detectDimensions(buffer, mime) };
+}
+
+const cache = new Map<string, FaviconSource | null>();
+
+export async function loadFaviconSource(
+  href: string,
+): Promise<FaviconSource | undefined> {
+  if (cache.has(href)) return cache.get(href) ?? undefined;
+
+  const source = await doLoad(href);
+  cache.set(href, source ?? null);
+  return source;
+}
+
+async function doLoad(href: string): Promise<FaviconSource | undefined> {
+  if (href.startsWith('http://') || href.startsWith('https://'))
+    return loadFromUrl(href);
+
+  return loadFromFilesystem(href);
+}
+
+async function loadFromUrl(url: string): Promise<FaviconSource | undefined> {
+  try {
+    const response = await fetch(url);
+    if (!response.ok) return undefined;
+
+    const buffer = Buffer.from(await response.arrayBuffer());
+    const serverMime = (response.headers.get('content-type') || '')
+      .split(';')[0]
+      ?.trim();
+    return buildSource(buffer, resolveMime(buffer, url, serverMime));
+  } catch {
+    return undefined;
+  }
+}
+
+async function loadFromFilesystem(
+  href: string,
+): Promise<FaviconSource | undefined> {
+  const cleanPath = href.replace(/^\.\//, '');
+  const localPath = isAbsolute(cleanPath)
+    ? cleanPath
+    : ERUDIT.paths.project(cleanPath);
+
+  try {
+    const buffer = await readFile(localPath);
+    return buildSource(buffer, resolveMime(buffer, href));
+  } catch {
+    return undefined;
+  }
+}

package/server/erudit/favicon/shared.ts

@@ -0,0 +1,48 @@
+export const FAVICON_SIZES = [32, 48, 180] as const;
+export type FaviconSize = (typeof FAVICON_SIZES)[number];
+
+// Mirrors contentTypes (minus 'topic') + topicParts from @erudit-js/core
+export const FAVICON_KEYS = [
+  'default',
+  'book',
+  'group',
+  'page',
+  'article',
+  'summary',
+  'practice',
+] as const;
+export type FaviconKey = (typeof FAVICON_KEYS)[number];
+
+function fallbackFaviconPath(): string {
+  return ERUDIT.paths.erudit('public', 'favicons', 'default.svg');
+}
+
+export function getFaviconHref(key: string): string | undefined {
+  const href = (
+    ERUDIT.config.public.favicon as Record<string, string> | undefined
+  )?.[key];
+  if (href) return href;
+  if (key === 'default') return fallbackFaviconPath();
+  return undefined;
+}
+
+const mimeByExt: Record<string, string> = {
+  '.svg': 'image/svg+xml',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+  '.bmp': 'image/bmp',
+  '.ico': 'image/x-icon',
+};
+
+export function extFromHref(href: string): string {
+  const path = href.split(/[?#]/)[0] ?? '';
+  const dot = path.lastIndexOf('.');
+  return dot === -1 ? '' : path.slice(dot).toLowerCase();
+}
+
+export function mimeFromExt(href: string): string | undefined {
+  return mimeByExt[extFromHref(href)];
+}

package/server/erudit/language/list/en.ts

@@ -46,6 +46,7 @@ export const phrases: LanguagePhrases = {
   flag_secondary: 'Additional',
   flag_secondary_description:
     'This is an optional material is for learners who want to dive deeper and gain additional knowledge and context.',
+  breadcrumb: 'Breadcrumb',
   key_elements: 'Key elements',
   stats: 'Statistics',
   connections: 'Connections',