erudit 4.3.1 → 4.3.3

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

@@ -24,15 +24,6 @@ export const phrases: LanguagePhrases = {
   no_content: 'No content.',
   to_index: 'To index',
   about_textbook: 'About textbook',
-  flag_title_dev: 'Development',
-  flag_hint_dev:
-    'This material is not complete, may contain error and will change in the future! Use with caution!',
-  flag_title_advanced: 'Advanced',
-  flag_hint_advanced:
-    'This material is for learners with a high level of knowledge. It contains information that is not suitable for beginners!',
-  flag_title_secondary: 'Additional',
-  flag_hint_secondary:
-    'This is an optional material is for learners who want to dive deeper and gain additional knowledge and context.',
   ads_replacer:
     'We help you. Help us back.<br><strong style="color: inherit;">Disable your ads blocker!</strong>',
   direct_link: 'Direct link',

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

@@ -24,15 +24,6 @@ export const phrases: LanguagePhrases = {
   no_content: 'Контента нет.',
   to_index: 'К оглавлению',
   about_textbook: 'Об учебнике',
-  flag_title_dev: 'Разработка',
-  flag_hint_dev:
-    'Этот материал не завершен, может содержать ошибки и измениться в будущем! Используйте с осторожностью!',
-  flag_title_advanced: 'Профиль',
-  flag_hint_advanced:
-    'Этот материал предназначен для учеников с хорошим уровнем понимания предмета. Информация здесь не предназначена для новичков!',
-  flag_title_secondary: 'Дополнение',
-  flag_hint_secondary:
-    'Это материал для тех, кто хочет глубже погрузиться предмет и получить дополнительные знания и контекст.',
   ads_replacer:
     'Помогите улучшить проект.<br><strong style="color: inherit;">Включите показ рекламы!</strong>',
   direct_link: 'Прямая ссылка',
@@ -55,7 +46,7 @@ export const phrases: LanguagePhrases = {
     'Этот материал предназначен для учеников с высоким уровнем понимания предмета. Информация здесь не предназначена для новичков!',
   flag_secondary: 'Дополнение',
   flag_secondary_description:
-    'Это дополнительный материал для тех, кто хочет глубже погрузиться предмет и получить дополнительные знания и контекст.',
+    'Это дополнительный материал для тех, кто хочет глубже погрузиться в предмет и получить дополнительные знания и контекст.',
   key_elements: 'Ключевые элементы',
   stats: 'Статистика',
   connections: 'Связи',
@@ -96,7 +87,7 @@ export const phrases: LanguagePhrases = {
   article_seo_description: (contentTitle: string) =>
     `Понятное и интересное объяснение темы «${contentTitle}». Показательные примеры, важные свойства, интересные факты, применение в жизни, понятные доказательства. Здесь вы точно разберетесь!`,
   summary_seo_description: (contentTitle: string) =>
-    `Конспект темы «${contentTitle}»: ключевые определения, теоремы, свойства и примеры их использвания. Все самое важное и в кратком виде!`,
+    `Конспект темы «${contentTitle}»: ключевые определения, теоремы, свойства и примеры их использования. Все самое важное и в кратком виде!`,
   practice_seo_description: (contentTitle: string) =>
     `Разнообразные задачи с подсказками и ответами по теме «${contentTitle}». Интересные условия, подсказки и подробные решения. Превратите знания в навык!`,
   externals_own: 'Собственные',

package/server/erudit/repository.ts

@@ -37,6 +37,7 @@ import {
 import { getContentSeo } from './content/repository/seo';
 import { getContentElementSnippets } from './content/repository/elementSnippets';
 import { isContentHidden } from './content/repository/hidden';
+import { getContentLastmod } from './content/repository/lastmod';
 import { serverRawToProse } from './prose/repository/rawToProse';
 
 export const repository = {
@@ -77,6 +78,7 @@ export const repository = {
     updateSchemaCounts: updateContentSchemaCounts,
     contentContributions: getContentContributions,
     seo: getContentSeo,
+    lastmod: getContentLastmod,
   },
   prose: {
     fromRaw: serverRawToProse,

package/server/routes/favicon/[...path].ts

@@ -0,0 +1,89 @@
+import { loadFaviconSource } from '#layers/erudit/server/erudit/favicon/loadSource';
+import { convertFaviconToPng } from '#layers/erudit/server/erudit/favicon/convertToPng';
+import {
+  FAVICON_SIZES,
+  FAVICON_KEYS,
+  getFaviconHref,
+  type FaviconSize,
+  type FaviconKey,
+} from '#layers/erudit/server/erudit/favicon/shared';
+
+export default defineEventHandler(async (event) => {
+  const rawPath = event.context.params?.path;
+  if (!rawPath) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: 'Invalid favicon path',
+    });
+  }
+
+  const slashIdx = rawPath.indexOf('/');
+  if (slashIdx === -1) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: 'Invalid favicon path',
+    });
+  }
+
+  const key = rawPath.slice(0, slashIdx);
+  const file = rawPath.slice(slashIdx + 1);
+
+  if (!FAVICON_KEYS.includes(key as FaviconKey)) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: `Unknown favicon key: ${key}`,
+    });
+  }
+
+  const href = getFaviconHref(key);
+  if (!href) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: `No favicon configured for: ${key}`,
+    });
+  }
+
+  const source = await loadFaviconSource(href);
+  if (!source) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: 'Failed to load favicon source',
+    });
+  }
+
+  // Source route: {key}/source.{ext}
+  if (file.startsWith('source.')) {
+    setHeader(event, 'Content-Type', source.mime);
+    setHeader(event, 'Cache-Control', 'public, max-age=86400, s-maxage=86400');
+    return source.buffer;
+  }
+
+  // PNG route: {key}/{size}.png
+  if (!file.endsWith('.png')) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: 'Invalid favicon path',
+    });
+  }
+
+  const size = Number(file.slice(0, -4)) as FaviconSize;
+
+  if (!FAVICON_SIZES.includes(size)) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: `Invalid favicon size: ${file}`,
+    });
+  }
+
+  if (source.width !== undefined && source.width < size) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: `Favicon source too small (${source.width}px) for size ${size}px`,
+    });
+  }
+
+  const png = await convertFaviconToPng(key, source, size);
+  setHeader(event, 'Content-Type', 'image/png');
+  setHeader(event, 'Cache-Control', 'public, max-age=86400, s-maxage=86400');
+  return png;
+});

package/server/routes/sitemap.xml.ts

@@ -2,7 +2,14 @@ import { sn } from 'unslash';
 
 export default defineEventHandler(async (event) => {
   const urls = new Set<string>();
-  urls.add(PAGES.index);
+  const urlLastmod = new Map<string, string>();
+
+  function addUrl(url: string, lastmod?: string) {
+    urls.add(url);
+    if (lastmod) urlLastmod.set(url, lastmod);
+  }
+
+  addUrl(PAGES.index);
 
   //
   // Contributors
@@ -34,7 +41,7 @@ export default defineEventHandler(async (event) => {
 
   {
     const dbContentItems = await ERUDIT.db.query.content.findMany({
-      columns: { fullId: true },
+      columns: { fullId: true, lastmod: true },
     });
 
     for (const dbContentItem of dbContentItems) {
@@ -45,14 +52,15 @@ export default defineEventHandler(async (event) => {
       }
 
       const contentNode = ERUDIT.contentNav.getNodeOrThrow(fullId);
+      const lastmod = dbContentItem.lastmod ?? undefined;
 
       if (contentNode.type === 'topic') {
         const parts = await ERUDIT.repository.content.topicParts(fullId);
         for (const part of parts) {
-          urls.add(PAGES.topic(part, contentNode.shortId));
+          addUrl(PAGES.topic(part, contentNode.shortId), lastmod);
         }
       } else {
-        urls.add(PAGES[contentNode.type](fullId));
+        addUrl(PAGES[contentNode.type](fullId), lastmod);
       }
 
       const elementSnippets =
@@ -60,7 +68,7 @@ export default defineEventHandler(async (event) => {
 
       for (const snippet of elementSnippets || []) {
         if (snippet.seo) {
-          urls.add(snippet.link);
+          addUrl(snippet.link, lastmod);
         }
       }
     }
@@ -75,11 +83,12 @@ export default defineEventHandler(async (event) => {
   const xml = `<?xml version="1.0" encoding="UTF-8"?>
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
 ${Array.from(urls)
-  .map(
-    (url) => `    <url>
-        <loc>${sn(runtimeConfig.public.siteUrl, url)}</loc>
-    </url>`,
-  )
+  .map((url) => {
+    const lastmod = urlLastmod.get(url);
+    return `    <url>
+        <loc>${sn(runtimeConfig.public.siteUrl, url)}</loc>${lastmod ? `\n        <lastmod>${lastmod}</lastmod>` : ''}
+    </url>`;
+  })
   .join('\n')}
 </urlset>`.trim();