erudit 4.3.0-dev.1 → 4.3.0

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "erudit",
-  "version": "4.3.0-dev.1",
+  "version": "4.3.0",
   "type": "module",
   "description": "🤓 CMS for perfect educational sites.",
   "license": "MIT",
@@ -24,13 +24,13 @@
     }
   },
   "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.0",
+    "@erudit-js/core": "4.3.0",
+    "@erudit-js/prose": "4.3.0",
     "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",
+    "@tailwindcss/vite": "^4.2.1",
     "better-sqlite3": "^12.6.2",
     "chokidar": "^5.0.0",
     "consola": "^3.4.2",
@@ -44,9 +44,9 @@
     "nuxt": "4.3.1",
     "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/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;
         }