erudit 4.3.0 → 4.3.1

package/app/composables/formatText.ts

@@ -1,100 +1,9 @@
-import type { FormatTextState, FormatText } from '@erudit-js/core/formatText';
-
-type LanguageFormatText = (text: string) => string;
-
-const formatTextLoaders: Partial<
-  Record<LanguageCode, () => Promise<{ default: LanguageFormatText }>>
-> = {
-  ru: () => import('../formatters/ru'),
-};
-
-export let formatText: FormatText;
-
-export async function initFormatText() {
-  const languageCode = ERUDIT.config.language.current;
-
-  const formatTextLoader =
-    languageCode in formatTextLoaders
-      ? formatTextLoaders[languageCode]
-      : undefined;
-
-  let languageFormatText: LanguageFormatText = (text) => text;
-  if (formatTextLoader) {
-    languageFormatText = (await formatTextLoader()).default;
-  }
-
-  function _formatText(text: string, state?: FormatTextState): string;
-  function _formatText(text: undefined, state?: FormatTextState): undefined;
-  function _formatText(
-    text?: string,
-    state?: FormatTextState,
-  ): string | undefined;
-  function _formatText(
-    text?: string,
-    state?: FormatTextState,
-  ): string | undefined {
-    if (text === undefined) {
-      return text;
-    }
-
-    //
-    // Normalize spacing (new lines, spaces)
-    //
-
-    {
-      text = text
-        .trim()
-        .replace(/\r\n/gm, '\n')
-        .replace(/\n{3,}/gm, '\n\n')
-        .replace(/[ \t]+/gm, ' ');
-    }
-
-    //
-    // Normalize dashes
-    //
-
-    {
-      text = text.replace(/(^| )--($| )/gm, '$1—$2');
-    }
-
-    //
-    // Normalize quotes
-    //
-
-    {
-      const quoteSymbols: [string, string] = (() => {
-        switch (languageCode) {
-          case 'ru':
-            return ['«', '»'];
-          default:
-            return ['“', '”'];
-        }
-      })();
-
-      let quoteOpen = state?.quote === 'opened';
-      text = text.replaceAll(/"/gm, () => {
-        quoteOpen = !quoteOpen;
-        if (state) {
-          state.quote = quoteOpen ? 'opened' : 'closed';
-        }
-        return quoteOpen ? quoteSymbols[0] : quoteSymbols[1];
-      });
-    }
-
-    //
-    // Normalize ellipsis
-    //
-
-    {
-      text = text.replace(/\.{3}/gm, '…');
-    }
-
-    //
-    // Language-specific formatting
-    //
-
-    return languageFormatText(text);
-  }
-
-  formatText = _formatText;
-}
+import type { FormatText } from '@erudit-js/core/formatText';
+import { createFormatTextFn } from '../../shared/utils/formatText';
+
+export let formatText: FormatText;
+
+export async function initFormatText() {
+  const languageCode = ERUDIT.config.language.current;
+  formatText = createFormatTextFn(languageCode);
+}

package/app/composables/og.ts

@@ -15,22 +15,18 @@ export function initOgSiteName() {
 }
 
 export function initOgImage() {
-  const withSiteUrl = useSiteUrl();
-
-  const fallbackOgImage = {
-    src: eruditPublic('og.png'),
-    width: 500,
-    height: 500,
-  };
-
-  const ogImage = ERUDIT.config.seo?.image || fallbackOgImage;
-  useSeoMeta({
-    ogImage: {
-      url: withSiteUrl(ogImage.src),
-      width: ogImage.width,
-      height: ogImage.height,
-    },
-  });
+  const ogImageConfig = ERUDIT.config.seo?.ogImage;
+
+  if (ogImageConfig?.type === 'manual') {
+    const withSiteUrl = useSiteUrl();
+    useSeoMeta({
+      ogImage: {
+        url: withSiteUrl(ogImageConfig.src),
+        width: ogImageConfig.width,
+        height: ogImageConfig.height,
+      },
+    });
+  }
 }
 
 export function useIndexSeo(indexPage: IndexPage) {
@@ -39,12 +35,25 @@ export function useIndexSeo(indexPage: IndexPage) {
     description: indexPage.seo?.description || indexPage.description,
     urlPath: '/',
   });
+
+  const ogImageConfig = ERUDIT.config.seo?.ogImage;
+  if (ogImageConfig?.type === 'auto') {
+    const withSiteUrl = useSiteUrl();
+    useSeoMeta({
+      ogImage: {
+        url: withSiteUrl('/og/site/index.png'),
+        width: 1200,
+        height: 630,
+      },
+    });
+  }
 }
 
 export function useStandartSeo(args: {
   title: string;
   description?: string;
   urlPath: string;
+  ogImagePath?: string;
 }) {
   const seoSiteTitle =
     ERUDIT.config.seo?.siteTitle ||
@@ -58,6 +67,20 @@ export function useStandartSeo(args: {
     description: args.description,
     urlPath: args.urlPath,
   });
+
+  if (args.ogImagePath) {
+    const ogImageConfig = ERUDIT.config.seo?.ogImage;
+    if (ogImageConfig?.type === 'auto') {
+      const withSiteUrl = useSiteUrl();
+      useSeoMeta({
+        ogImage: {
+          url: withSiteUrl(args.ogImagePath),
+          width: 1200,
+          height: 630,
+        },
+      });
+    }
+  }
 }
 
 export async function useContentSeo(args: {
@@ -100,6 +123,25 @@ export async function useContentSeo(args: {
 
   setupSeo(baseSeo);
 
+  // Auto-generated OG image for content
+  // Manual OG image is handled globally by initOgImage() in app.vue
+  const ogImageConfig = ERUDIT.config.seo?.ogImage;
+  if (ogImageConfig?.type === 'auto') {
+    const withSiteUrl = useSiteUrl();
+    const ogTypePart =
+      args.contentTypePath.type === 'topic'
+        ? args.contentTypePath.topicPart
+        : args.contentTypePath.type;
+    const ogPath = `/og/content/${ogTypePart}/${args.contentTypePath.contentId}.png`;
+    useSeoMeta({
+      ogImage: {
+        url: withSiteUrl(ogPath),
+        width: 1200,
+        height: 630,
+      },
+    });
+  }
+
   //
   // SEO snippets
   //

package/app/pages/contributor/[contributorId].vue

@@ -45,6 +45,7 @@ useStandartSeo({
     pageContributor.displayName || pageContributor.id,
   ),
   urlPath: PAGES.contributor(contributorId.value),
+  ogImagePath: `/og/site/contributor/${contributorId.value}.png`,
 });
 </script>
 

package/app/pages/contributors.vue

@@ -33,6 +33,7 @@ useStandartSeo({
   title: phrase.contributors,
   description: phrase.contributors_description,
   urlPath: PAGES.contributors,
+  ogImagePath: '/og/site/contributors.png',
 });
 </script>
 

package/app/pages/sponsors.vue

@@ -24,6 +24,7 @@ useStandartSeo({
   title: phrase.sponsors,
   description: phrase.sponsors_description,
   urlPath: PAGES.sponsors,
+  ogImagePath: '/og/site/sponsors.png',
 });
 </script>
 

package/app/plugins/prerender.server.ts

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

package/nuxt.config.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "erudit",
-  "version": "4.3.0",
+  "version": "4.3.1",
   "type": "module",
   "description": "🤓 CMS for perfect educational sites.",
   "license": "MIT",
@@ -24,24 +24,26 @@
     }
   },
   "dependencies": {
-    "@erudit-js/cli": "4.3.0",
-    "@erudit-js/core": "4.3.0",
-    "@erudit-js/prose": "4.3.0",
+    "@erudit-js/cli": "4.3.1",
+    "@erudit-js/core": "4.3.1",
+    "@erudit-js/prose": "4.3.1",
     "unslash": "^2.0.0",
     "@floating-ui/vue": "^1.1.11",
     "tsprose": "^1.0.1",
     "@tailwindcss/vite": "^4.2.1",
-    "better-sqlite3": "^12.6.2",
+    "better-sqlite3": "^12.8.0",
     "chokidar": "^5.0.0",
     "consola": "^3.4.2",
     "drizzle-kit": "^0.31.9",
     "drizzle-orm": "^0.45.1",
-    "esbuild": "^0.27.3",
+    "esbuild": "^0.27.4",
     "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.3.1",
+    "nuxt": "4.4.2",
     "nuxt-my-icons": "1.2.2",
     "perfect-debounce": "^2.1.0",
     "tailwindcss": "^4.2.1",

package/server/api/prerender/ogImages.ts

@@ -0,0 +1,46 @@
+export default defineEventHandler(async () => {
+  const ogImageConfig = ERUDIT.config.public.seo?.ogImage;
+  if (ogImageConfig?.type !== 'auto') {
+    return [];
+  }
+
+  const routes: string[] = [];
+
+  // Index page
+  routes.push('/og/site/index.png');
+
+  // Contributors page
+  if (ERUDIT.config.public.contributors?.enabled) {
+    routes.push('/og/site/contributors.png');
+
+    const dbContributors = await ERUDIT.db.query.contributors.findMany({
+      columns: { contributorId: true },
+    });
+
+    for (const dbContributor of dbContributors) {
+      routes.push(`/og/site/contributor/${dbContributor.contributorId}.png`);
+    }
+  }
+
+  // Sponsors page
+  if (ERUDIT.config.public.sponsors?.enabled) {
+    routes.push('/og/site/sponsors.png');
+  }
+
+  // Content pages
+  for (const navNode of ERUDIT.contentNav.id2Node.values()) {
+    if (navNode.type === 'topic') {
+      const topicParts = await ERUDIT.repository.content.topicParts(
+        navNode.fullId,
+      );
+
+      for (const part of topicParts) {
+        routes.push(`/og/content/${part}/${navNode.shortId}.png`);
+      }
+    } else {
+      routes.push(`/og/content/${navNode.type}/${navNode.shortId}.png`);
+    }
+  }
+
+  return routes;
+});

package/server/erudit/ogImage/formatText.ts

@@ -0,0 +1,12 @@
+import type { FormatText } from '@erudit-js/core/formatText';
+import { createFormatTextFn } from '../../../shared/utils/formatText';
+
+let _ogFormatText: FormatText | undefined;
+
+export function ogFormatText(text: string): string {
+  if (!_ogFormatText) {
+    const languageCode = ERUDIT.config.public.language.current;
+    _ogFormatText = createFormatTextFn(languageCode);
+  }
+  return _ogFormatText(text);
+}

package/server/erudit/ogImage/icons.ts

@@ -0,0 +1,22 @@
+import { readFileSync } from 'node:fs';
+import { ICONS } from '../../../shared/utils/icons';
+
+const ICON_MAP: Record<string, string> = {
+  ...ICONS,
+  contributors: 'users',
+  contributor: 'user',
+  sponsors: 'diamond',
+};
+
+const iconCache = new Map<string, string>();
+
+export function getIconSvg(contentType: string): string {
+  const cached = iconCache.get(contentType);
+  if (cached) return cached;
+
+  const iconName = ICON_MAP[contentType] || 'lines';
+  const iconPath = ERUDIT.paths.erudit('app/assets/icons', iconName + '.svg');
+  const svg = readFileSync(iconPath, 'utf-8');
+  iconCache.set(contentType, svg);
+  return svg;
+}

package/server/erudit/ogImage/logotype.ts

@@ -0,0 +1,51 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { isAbsolute } from 'node:path';
+
+let cachedLogotypeDataUri: string | undefined | null;
+
+export async function loadLogotypeDataUri(
+  explicitPath?: string,
+): Promise<string | undefined> {
+  if (cachedLogotypeDataUri !== undefined) {
+    return cachedLogotypeDataUri ?? undefined;
+  }
+
+  const logotypeUrl =
+    explicitPath || ERUDIT.config.public.asideMajor?.siteInfo?.logotype;
+  if (!logotypeUrl || logotypeUrl === '') {
+    cachedLogotypeDataUri = null;
+    return undefined;
+  }
+
+  if (logotypeUrl.startsWith('http://') || logotypeUrl.startsWith('https://')) {
+    try {
+      const response = await fetch(logotypeUrl);
+      if (response.ok) {
+        const contentType =
+          response.headers.get('content-type') || 'image/svg+xml';
+        const buffer = Buffer.from(await response.arrayBuffer());
+        cachedLogotypeDataUri = `data:${contentType};base64,${buffer.toString('base64')}`;
+        return cachedLogotypeDataUri;
+      }
+    } catch {
+      // Ignore fetch errors
+    }
+    cachedLogotypeDataUri = null;
+    return undefined;
+  }
+
+  // Local path — resolve relative to project root, or use as-is if absolute
+  const localPath = isAbsolute(logotypeUrl)
+    ? logotypeUrl
+    : ERUDIT.paths.project(logotypeUrl.replace(/^\/+/, ''));
+  if (existsSync(localPath)) {
+    const buffer = readFileSync(localPath);
+    const ext = logotypeUrl.split('.').pop()?.toLowerCase();
+    const mime = ext === 'svg' ? 'image/svg+xml' : `image/${ext}`;
+    cachedLogotypeDataUri = `data:${mime};base64,${buffer.toString('base64')}`;
+    return cachedLogotypeDataUri;
+  }
+
+  cachedLogotypeDataUri = null;
+  return undefined;
+}

package/server/erudit/ogImage/render.ts

@@ -0,0 +1,90 @@
+import { readFileSync } from 'node:fs';
+import satori from 'satori';
+import { Resvg } from '@resvg/resvg-js';
+import { type SatoriNode, OG_WIDTH, OG_HEIGHT } from './shared';
+
+let regularFontData: ArrayBuffer | undefined;
+let boldFontData: ArrayBuffer | undefined;
+
+function loadFontFile(filename: string): ArrayBuffer {
+  const fontPath = ERUDIT.paths.erudit('server/erudit/ogImage/fonts', filename);
+  const buffer = readFileSync(fontPath);
+  return buffer.buffer.slice(
+    buffer.byteOffset,
+    buffer.byteOffset + buffer.byteLength,
+  );
+}
+
+function loadFonts(): { regular: ArrayBuffer; bold: ArrayBuffer } {
+  if (!regularFontData) {
+    regularFontData = loadFontFile('NotoSans-Regular.ttf');
+  }
+  if (!boldFontData) {
+    boldFontData = loadFontFile('NotoSans-Bold.ttf');
+  }
+  return { regular: regularFontData, bold: boldFontData };
+}
+
+const CACHE_CAPACITY = 50;
+const cacheSlotKeys: (string | undefined)[] = new Array(CACHE_CAPACITY);
+const cacheSlotValues: (Buffer | undefined)[] = new Array(CACHE_CAPACITY);
+const cacheKeyToSlot = new Map<string, number>();
+let cachePointer = 0;
+
+export async function renderOgImage(
+  cacheKey: string,
+  template: SatoriNode,
+): Promise<Buffer> {
+  const slot = cacheKeyToSlot.get(cacheKey);
+  if (slot !== undefined) return cacheSlotValues[slot]!;
+
+  const fonts = loadFonts();
+
+  const svg = await satori(template as any, {
+    width: OG_WIDTH,
+    height: OG_HEIGHT,
+    fonts: [
+      {
+        name: 'Noto Sans',
+        data: fonts.regular,
+        weight: 400,
+        style: 'normal',
+      },
+      {
+        name: 'Noto Sans',
+        data: fonts.bold,
+        weight: 600,
+        style: 'normal',
+      },
+      {
+        name: 'Noto Sans',
+        data: fonts.bold,
+        weight: 700,
+        style: 'normal',
+      },
+    ],
+  });
+
+  const resvg = new Resvg(svg, {
+    fitTo: {
+      mode: 'width',
+      value: OG_WIDTH,
+    },
+  });
+
+  const pngData = resvg.render();
+  const pngBuffer = Buffer.from(pngData.asPng());
+
+  // Evict oldest entry when the circular buffer is full
+  const evictedKey = cacheSlotKeys[cachePointer];
+  if (evictedKey !== undefined) {
+    cacheKeyToSlot.delete(evictedKey);
+  }
+
+  cacheSlotKeys[cachePointer] = cacheKey;
+  cacheSlotValues[cachePointer] = pngBuffer;
+  cacheKeyToSlot.set(cacheKey, cachePointer);
+  cachePointer = (cachePointer + 1) % CACHE_CAPACITY;
+
+  return pngBuffer;
+}