erudit 4.3.0-dev.1 → 4.3.1-dev.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/modules/erudit/setup/elements/appTemplate.ts

@@ -2,15 +2,17 @@ import type { Nuxt } from 'nuxt/schema';
 import { addTemplate } from 'nuxt/kit';
 
 import type { ElementData } from './shared';
+import { toJsSlug } from '../toJsSlug';
 
 export function createAppTemplate(nuxt: Nuxt, elementsData: ElementData[]) {
-  const defaultImportName = (elementName: string) => `app_${elementName}`;
+  const importName = (i: number, name: string) => `app_${i}_${toJsSlug(name)}`;
 
   const apps: Record<string, string> = {};
 
-  for (const elementData of elementsData) {
+  for (let i = 0; i < elementsData.length; i++) {
+    const elementData = elementsData[i]!;
     if (elementData.absAppPath) {
-      apps[defaultImportName(elementData.name)] = elementData.absAppPath;
+      apps[importName(i, elementData.name)] = elementData.absAppPath;
     }
   }
 

package/modules/erudit/setup/elements/globalTemplate.ts

@@ -3,20 +3,21 @@ import type { Nuxt } from 'nuxt/schema';
 import { addTemplate } from 'nuxt/kit';
 
 import type { ElementData } from './shared';
+import { toJsSlug } from '../toJsSlug';
 
 export function createGlobalTemplate(nuxt: Nuxt, elementsData: ElementData[]) {
-  const defaultImportName = (type: 'core' | 'global', elementName: string) =>
-    `${type}_${elementName}`;
+  const importName = (type: 'core' | 'global', i: number, name: string) =>
+    `${type}_${i}_${toJsSlug(name)}`;
 
   const cores: Record<string, string> = {};
   const globals: Record<string, string> = {};
 
-  for (const elementData of elementsData) {
-    cores[defaultImportName('core', elementData.name)] =
-      elementData.absCorePath;
+  for (let i = 0; i < elementsData.length; i++) {
+    const elementData = elementsData[i]!;
+    cores[importName('core', i, elementData.name)] = elementData.absCorePath;
 
     if (existsSync(elementData.absDirectory + '/_global.ts')) {
-      globals[defaultImportName('global', elementData.name)] =
+      globals[importName('global', i, elementData.name)] =
         elementData.absDirectory + '/_global.ts';
     }
   }

package/modules/erudit/setup/problemChecks/template.ts

@@ -2,23 +2,27 @@ import type { Nuxt } from 'nuxt/schema';
 import { addTemplate } from 'nuxt/kit';
 
 import type { ResolvedProblemCheck } from './shared';
+import { toJsSlug } from '../toJsSlug';
 
 export function createTemplate(
   nuxt: Nuxt,
   problemChecks: ResolvedProblemCheck[],
 ) {
+  const importName = (i: number, name: string) =>
+    `check_${i}_${toJsSlug(name)}`;
+
   const template = `
 import type { ProblemCheckers } from '@erudit-js/core/problemCheck';
 
 ${problemChecks
   .map(
-    (check) =>
-      `import ${check.name} from '${check.absPath.replace(/\.(ts|js)$/, '')}';`,
+    (check, i) =>
+      `import ${importName(i, check.name)} from '${check.absPath.replace(/\.(ts|js)$/, '')}';`,
   )
   .join('\n')}
 
 export const problemCheckers: ProblemCheckers = {
-  ${problemChecks.map((check) => `${check.name},`).join('\n  ')}
+  ${problemChecks.map((check, i) => `${JSON.stringify(check.name)}: ${importName(i, check.name)},`).join('\n  ')}
 }
   `.trim();
 

package/modules/erudit/setup/toJsSlug.ts

@@ -0,0 +1,19 @@
+/**
+ * Converts a name string into a valid JavaScript identifier segment.
+ * Replaces non-alphanumeric/underscore/$ characters with `_`.
+ * Prefixes with `_` if the result starts with a digit.
+ * Returns `_` if the result is empty.
+ */
+export function toJsSlug(name: string): string {
+  let slug = name.replace(/[^a-zA-Z0-9_$]/g, '_');
+
+  if (/^[0-9]/.test(slug)) {
+    slug = '_' + slug;
+  }
+
+  if (!slug) {
+    slug = '_';
+  }
+
+  return slug;
+}

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-dev.1",
+  "version": "4.3.1-dev.1",
   "type": "module",
   "description": "🤓 CMS for perfect educational sites.",
   "license": "MIT",
@@ -24,29 +24,31 @@
     }
   },
   "dependencies": {
-    "@erudit-js/cli": "4.3.0-dev.1",
-    "@erudit-js/core": "4.3.0-dev.1",
-    "@erudit-js/prose": "4.3.0-dev.1",
+    "@erudit-js/cli": "4.3.1-dev.1",
+    "@erudit-js/core": "4.3.1-dev.1",
+    "@erudit-js/prose": "4.3.1-dev.1",
     "unslash": "^2.0.0",
-    "@floating-ui/vue": "^1.1.10",
+    "@floating-ui/vue": "^1.1.11",
     "tsprose": "^1.0.1",
-    "@tailwindcss/vite": "^4.2.0",
-    "better-sqlite3": "^12.6.2",
+    "@tailwindcss/vite": "^4.2.1",
+    "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.0",
-    "vue": "^3.5.28",
-    "vue-router": "^5.0.3",
+    "tailwindcss": "^4.2.1",
+    "vue": "latest",
+    "vue-router": "latest",
     "ts-xor": "^1.3.0"
   },
   "devDependencies": {

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/api/problemScript/[...problemScriptPath].ts

@@ -312,10 +312,28 @@ function normalizeEruditGlobals(code: string): string {
   code = code.replace(/_jsx\d*\b/g, 'jsx');
   code = code.replace(/_Fragment\d*\b/g, 'Fragment');
 
+  // Collect names already declared via real imports that esbuild kept
+  // (i.e. non-global imports). These must NOT appear in the preamble to avoid
+  // duplicate-identifier errors when a file explicitly imports a global name.
+  const declaredByImports = new Set<string>();
+  const importPattern = /^import\s+\{([^}]+)\}\s+from\s+/gm;
+  let im;
+  while ((im = importPattern.exec(code)) !== null) {
+    for (const part of im[1]!.split(',')) {
+      const trimmed = part.trim();
+      if (!trimmed) continue;
+      // Handle "X as Y" — the local name Y is the declared identifier
+      const asMatch = trimmed.match(/\w+\s+as\s+(\w+)/);
+      const name = asMatch ? asMatch[1]! : trimmed.match(/^(\w+)$/)?.[1];
+      if (name) declaredByImports.add(name);
+    }
+  }
+
   // Detect which ERUDIT_GLOBAL names are actually used in the code
   const allNames = getGlobalNames();
   const usedNames = [...allNames]
     .filter((n) => /^[a-zA-Z_$]\w*$/.test(n) && !n.startsWith('_'))
+    .filter((n) => !declaredByImports.has(n))
     .filter((n) => new RegExp('\\b' + n + '\\b').test(code));
 
   if (usedNames.length > 0) {

package/server/erudit/importer.ts

@@ -16,27 +16,85 @@ export type EruditServerImporter = Jiti['import'];
 
 export let jiti: Jiti;
 
-/** Cached preamble that destructures all ERUDIT_GLOBAL keys into local vars. */
-let eruditGlobalPreamble: string | undefined;
+/** Cached list of valid identifier keys from ERUDIT_GLOBAL. */
+let cachedGlobalKeys: string[] | undefined;
 
-function getEruditGlobalPreamble(): string {
-  if (eruditGlobalPreamble !== undefined) return eruditGlobalPreamble;
+function getGlobalKeys(): string[] {
+  if (cachedGlobalKeys !== undefined) return cachedGlobalKeys;
 
   const eg = (globalThis as any).ERUDIT_GLOBAL;
   if (!eg || typeof eg !== 'object') {
-    eruditGlobalPreamble = '';
-    return eruditGlobalPreamble;
+    cachedGlobalKeys = [];
+    return cachedGlobalKeys;
   }
 
-  const names = Object.keys(eg).filter((n) => /^[a-zA-Z_$]\w*$/.test(n));
-  if (names.length === 0) {
-    eruditGlobalPreamble = '';
-    return eruditGlobalPreamble;
+  cachedGlobalKeys = Object.keys(eg).filter((n) => /^[a-zA-Z_$]\w*$/.test(n));
+  return cachedGlobalKeys;
+}
+
+/**
+ * Collect names already declared in the transpiled code via imports.
+ * Jiti transpiles ESM imports to CJS-style interop, so we match patterns like:
+ *   const/var/let { X, Y } = require(...)   — destructured CJS
+ *   const/var/let X = require(...)          — default CJS
+ *   const/var/let X = ...                   — interop helpers
+ *   import { X } from '...'                — preserved ESM (if any)
+ */
+function collectDeclaredNames(code: string): Set<string> {
+  const declared = new Set<string>();
+
+  // Destructured require/import: const/var/let { X, Y as Z } = require(...)
+  // or: import { X, Y as Z } from '...'
+  const destructuredPattern =
+    /\b(?:const|let|var)\s+\{([^}]+)\}\s*=\s*require\s*\(|\bimport\s+\{([^}]+)\}\s+from\s+/g;
+  let m;
+  while ((m = destructuredPattern.exec(code)) !== null) {
+    const bindings = m[1] ?? m[2];
+    if (!bindings) continue;
+    for (const part of bindings.split(',')) {
+      const trimmed = part.trim();
+      if (!trimmed) continue;
+      // Handle "X as Y" (import) or "X: Y" (destructured require)
+      const asMatch = trimmed.match(/\w+\s+as\s+(\w+)/);
+      if (asMatch) {
+        declared.add(asMatch[1]!);
+        continue;
+      }
+      const colonMatch = trimmed.match(/\w+\s*:\s*(\w+)/);
+      if (colonMatch) {
+        declared.add(colonMatch[1]!);
+        continue;
+      }
+      const nameOnly = trimmed.match(/^(\w+)$/);
+      if (nameOnly) declared.add(nameOnly[1]!);
+    }
+  }
+
+  // Simple declarations: const/var/let X = require(...) or interop helpers
+  const simplePattern = /\b(?:const|let|var)\s+(\w+)\s*=/g;
+  let sm;
+  while ((sm = simplePattern.exec(code)) !== null) {
+    declared.add(sm[1]!);
   }
 
-  eruditGlobalPreamble =
-    'var { ' + names.join(', ') + ' } = globalThis.ERUDIT_GLOBAL;\n';
-  return eruditGlobalPreamble;
+  return declared;
+}
+
+/**
+ * Build a per-file preamble that destructures ERUDIT_GLOBAL keys, skipping
+ * any names the file already declares via explicit imports.
+ */
+function buildFilteredPreamble(code: string): string {
+  const allKeys = getGlobalKeys();
+  if (allKeys.length === 0) return '';
+
+  const declared = collectDeclaredNames(code);
+  const filtered =
+    declared.size > 0 ? allKeys.filter((n) => !declared.has(n)) : allKeys;
+
+  if (filtered.length === 0) return '';
+
+  return 'var { ' + filtered.join(', ') + ' } = globalThis.ERUDIT_GLOBAL;\n';
 }
 
 export async function setupServerImporter() {
@@ -67,7 +125,7 @@ export async function setupServerImporter() {
       // into local variables so bare identifiers resolve correctly.
       //
       if (filename.startsWith(ERUDIT.paths.project() + '/')) {
-        const preamble = getEruditGlobalPreamble();
+        const preamble = buildFilteredPreamble(code);
         if (preamble) {
           code = preamble + code;
         }

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;
+}