erudit 4.2.0 → 4.3.0

package/server/erudit/content/resolve/utils/insertContentResolved.ts

@@ -1,4 +1,4 @@
-import chalk from 'chalk';
+import { styleText } from 'node:util';
 import { sql } from 'drizzle-orm';
 import type { ContentProseType } from '@erudit-js/core/content/prose';
 import { builtValidPaths } from '../../global/build';
@@ -80,7 +80,24 @@ async function insertContentDeps(
     await ERUDIT.db
       .insert(ERUDIT.db.schema.contentDeps)
       .values(contentDeps)
-      .onConflictDoNothing();
+      .onConflictDoUpdate({
+        target: [
+          ERUDIT.db.schema.contentDeps.fromFullId,
+          ERUDIT.db.schema.contentDeps.toFullId,
+        ],
+        set: {
+          // Merge unique names from the auto dep into the existing row
+          // (which may already be a hard dep that has no uniqueNames yet).
+          // Only uniqueNames is updated — hard/reason are left untouched.
+          uniqueNames: sql`CASE
+            WHEN ${ERUDIT.db.schema.contentDeps.uniqueNames} IS NULL
+              THEN excluded.uniqueNames
+            WHEN excluded.uniqueNames IS NULL
+              THEN ${ERUDIT.db.schema.contentDeps.uniqueNames}
+            ELSE ${ERUDIT.db.schema.contentDeps.uniqueNames} || ',' || excluded.uniqueNames
+          END`,
+        },
+      });
   }
 }
 
@@ -93,7 +110,7 @@ function filterTargetMap(
   const brokenLinkMessage = (message: string, metas: ContentLinkUsage[]) => {
     let output = `${message} in ${ERUDIT.log.stress(contentFullId)}:\n`;
     for (const { type, label } of metas) {
-      output += `  ${chalk.gray('➔')}  <${type}>${label}</${type}>\n`;
+      output += `  ${styleText('gray', '➔')}  <${type}>${label}</${type}>\n`;
     }
     return output;
   };
@@ -104,7 +121,7 @@ function filterTargetMap(
     if (storageKey.startsWith('<link:unknown>/')) {
       ERUDIT.log.warn(
         brokenLinkMessage(
-          `Unknown link ${chalk.red(storageKey.replace('<link:unknown>/', ''))}`,
+          `Unknown link ${styleText('red', storageKey.replace('<link:unknown>/', ''))}`,
           metas,
         ),
       );
@@ -136,7 +153,7 @@ function filterTargetMap(
       } catch {
         ERUDIT.log.warn(
           brokenLinkMessage(
-            `Failed to resolve content link ${chalk.red(storageKey.replace('<link:global>/', ''))}`,
+            `Failed to resolve content link ${styleText('red', storageKey.replace('<link:global>/', ''))}`,
             metas,
           ),
         );

package/server/erudit/global.ts

@@ -11,6 +11,7 @@ import type { EruditServerPaths } from './path';
 import type { EruditServerRepository } from './repository';
 
 import { registerProseGlobals } from '#erudit/prose/global';
+import { registerAutoImportGlobals } from '#erudit/autoImports';
 
 export const ERUDIT: {
   buildError: EruditServerBuildError;
@@ -27,7 +28,9 @@ export const ERUDIT: {
   import: EruditServerImporter;
 } = {} as any;
 
-Object.assign(globalThis, {
+(globalThis as any).ERUDIT_GLOBAL = (globalThis as any).ERUDIT_GLOBAL || {};
+
+Object.assign((globalThis as any).ERUDIT_GLOBAL, {
   defineContributor,
   defineSponsor,
   defineCameo,
@@ -40,3 +43,4 @@ Object.assign(globalThis, {
 });
 
 registerProseGlobals();
+registerAutoImportGlobals();

package/server/erudit/importer.ts

@@ -16,6 +16,87 @@ export type EruditServerImporter = Jiti['import'];
 
 export let jiti: Jiti;
 
+/** Cached list of valid identifier keys from ERUDIT_GLOBAL. */
+let cachedGlobalKeys: string[] | undefined;
+
+function getGlobalKeys(): string[] {
+  if (cachedGlobalKeys !== undefined) return cachedGlobalKeys;
+
+  const eg = (globalThis as any).ERUDIT_GLOBAL;
+  if (!eg || typeof eg !== 'object') {
+    cachedGlobalKeys = [];
+    return cachedGlobalKeys;
+  }
+
+  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]!);
+  }
+
+  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() {
   const jitiId = ERUDIT.paths.project();
   const defaultJiti = createJiti(jitiId, createBaseJitiOptions());
@@ -38,6 +119,18 @@ export async function setupServerImporter() {
 
       let code = getDefaultCode(opts);
 
+      //
+      // Inject ERUDIT_GLOBAL preamble for project files
+      // Destructures all erudit globals (tags, defineX, jsx runtime, etc.)
+      // into local variables so bare identifiers resolve correctly.
+      //
+      if (filename.startsWith(ERUDIT.paths.project() + '/')) {
+        const preamble = buildFilteredPreamble(code);
+        if (preamble) {
+          code = preamble + code;
+        }
+      }
+
       //
       // Insert IDs in `defineDocument(...)` calls
       //
@@ -58,6 +151,40 @@ export async function setupServerImporter() {
 
       code = insertProblemScriptId(toRelPath(filename), code);
 
+      //
+      // Rebind problem script creator src to this file's path.
+      //
+      // When defineProblemScript is called inside a shared utility file (e.g.
+      // shared.tsx) and then re-exported through an entry file (e.g.
+      // my-script.tsx), jiti injects the *shared* file's path as the scriptSrc.
+      // That makes the client fetch `/api/problemScript/.../shared.js`, which has
+      // no default export and fails at runtime.
+      //
+      // After the module's own code runs we inspect its default export: if it is
+      // a ProblemScriptInstanceCreator (a function whose return value has a
+      // `.generate` method), we wrap it so every created instance gets its
+      // scriptSrc replaced with **this** file's relative path – the actual entry
+      // file the API route will serve.
+      //
+      if (!filename.startsWith(ERUDIT.paths.project() + '/')) {
+        return { code };
+      }
+
+      const relFilePath = toRelPath(filename).replace(/\.[jt]sx?$/, '');
+      code += `
+;(function() {
+  var _eruditFileSrc = ${JSON.stringify(relFilePath)};
+  var _def = exports.default;
+  if (typeof _def !== 'function') return;
+  exports.default = Object.assign(function() {
+    var instance = _def.apply(this, arguments);
+    if (instance && typeof instance === 'object' && typeof instance.generate === 'function') {
+      return Object.assign({}, instance, { scriptSrc: _eruditFileSrc });
+    }
+    return instance;
+  }, _def);
+})();`;
+
       return { code };
     },
   });

package/server/erudit/index.ts

@@ -1,4 +1,4 @@
-import chalk from 'chalk';
+import { styleText } from 'node:util';
 import type { EruditMode } from '@erudit-js/core/mode';
 
 import { setupServerLogger } from './logger';
@@ -72,7 +72,7 @@ async function setupServer() {
     await setupServerDatabase();
     await setupServerRepository();
     await setupServerContentNav();
-    ERUDIT.log.success(chalk.green('Setup Complete!'));
+    ERUDIT.log.success(styleText('green', 'Setup Complete!'));
 
     await tryServerWatchProject();
     await buildServerErudit();

package/server/erudit/logger.ts

@@ -1,4 +1,4 @@
-import chalk from 'chalk';
+import { styleText } from 'node:util';
 import { brandColorTitle } from '@erudit-js/core/brandTerminal';
 
 interface Logger {
@@ -15,8 +15,12 @@ export type EruditServerLogger = Logger & {
 };
 
 export async function setupServerLogger() {
-  const serverLogger = createLogger(brandColorTitle + ' Server');
-  const serverDebugLogger = createLogger(brandColorTitle + ' Server Debug');
+  const serverLogger = createLogger(
+    `${brandColorTitle}${styleText('gray', ' Server')}`,
+  );
+  const serverDebugLogger = createLogger(
+    `${brandColorTitle}${styleText('gray', ' Server Debug')}`,
+  );
   const debugLogEnabled = !!ERUDIT.config.public.debug.log;
 
   ERUDIT.log = new Proxy(serverLogger, {
@@ -42,32 +46,36 @@ export async function setupServerLogger() {
 }
 
 function createLogger(tag: string): Logger {
-  const formattedTag = chalk.gray(`[${tag}]`);
+  const formattedTag = `${styleText('gray', '[')}${tag}${styleText('gray', ']')}`;
 
   return {
     info(message: any) {
-      console.log(`${formattedTag} ${chalk.blueBright('ℹ')} ${message}`);
+      console.log(`${formattedTag} ${styleText('blueBright', 'ℹ')} ${message}`);
     },
     start(message: any) {
-      console.log(`${formattedTag} ${chalk.magentaBright('◐')} ${message}`);
+      console.log(
+        `${formattedTag} ${styleText('magentaBright', '◐')} ${message}`,
+      );
     },
     success(message: any) {
-      console.log(`${formattedTag} ${chalk.greenBright('✔')} ${message}`);
+      console.log(
+        `${formattedTag} ${styleText('greenBright', '✔')} ${message}`,
+      );
     },
     warn(message: any) {
       console.log(
-        `${formattedTag} ${chalk.bgYellowBright.black(' WARN ')} ${message}`,
+        `${formattedTag} ${styleText(['bgYellowBright', 'black'], ' WARN ')} ${message}`,
       );
     },
     error(message: any) {
       console.log();
       console.log(
-        `${formattedTag} ${chalk.bgRed.whiteBright(' ERROR ')} ${message}`,
+        `${formattedTag} ${styleText(['bgRed', 'whiteBright'], ' ERROR ')} ${message}`,
       );
       console.log();
     },
     stress(message: any) {
-      return chalk.cyanBright(message);
+      return styleText('cyanBright', String(message));
     },
   };
 }

package/server/erudit/reloadSignal.ts

@@ -0,0 +1,14 @@
+type ReloadCallback = () => void;
+
+const subscribers = new Set<ReloadCallback>();
+
+export function subscribeReload(callback: ReloadCallback): () => void {
+  subscribers.add(callback);
+  return () => subscribers.delete(callback);
+}
+
+export function triggerReload(): void {
+  for (const callback of subscribers) {
+    callback();
+  }
+}

package/server/routes/_reload.ts

@@ -0,0 +1,27 @@
+import { isDevLikeMode } from '@erudit-js/core/mode';
+import { subscribeReload } from '../erudit/reloadSignal';
+
+export default defineEventHandler((event) => {
+  if (!isDevLikeMode(ERUDIT.mode)) {
+    throw createError({ statusCode: 404 });
+  }
+
+  const { res, req } = event.node;
+
+  setResponseHeaders(event, {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache',
+    Connection: 'keep-alive',
+  });
+
+  res.write(': connected\n\n');
+
+  const unsub = subscribeReload(() => {
+    res.write('data: reload\n\n');
+  });
+
+  req.on('close', unsub);
+
+  // Keep connection open
+  return new Promise<void>(() => {});
+});

package/shared/types/contentConnections.ts

@@ -24,6 +24,7 @@ export interface ContentAutoDep extends BaseContentDep {
 export interface ContentHardDep extends BaseContentDep {
   type: 'hard';
   reason: string;
+  uniques?: ContentDepUnique[];
 }
 
 export type ContentDep = ContentAutoDep | ContentHardDep;

package/shared/types/frontContentNav.ts

@@ -1,4 +1,5 @@
 import type { ContentFlags } from '@erudit-js/core/content/flags';
+import type { TopicPart } from '@erudit-js/core/content/topic';
 
 export interface FrontContentNavItemBase {
   shortId: string;
@@ -9,6 +10,7 @@ export interface FrontContentNavItemBase {
 
 export interface FrontContentNavTopic extends FrontContentNavItemBase {
   type: 'topic';
+  parts: TopicPart[];
 }
 
 export interface FrontContentNavPage extends FrontContentNavItemBase {