erudit 4.2.0 → 4.3.0-dev.1

package/server/erudit/importer.ts

@@ -16,6 +16,29 @@ export type EruditServerImporter = Jiti['import'];
 
 export let jiti: Jiti;
 
+/** Cached preamble that destructures all ERUDIT_GLOBAL keys into local vars. */
+let eruditGlobalPreamble: string | undefined;
+
+function getEruditGlobalPreamble(): string {
+  if (eruditGlobalPreamble !== undefined) return eruditGlobalPreamble;
+
+  const eg = (globalThis as any).ERUDIT_GLOBAL;
+  if (!eg || typeof eg !== 'object') {
+    eruditGlobalPreamble = '';
+    return eruditGlobalPreamble;
+  }
+
+  const names = Object.keys(eg).filter((n) => /^[a-zA-Z_$]\w*$/.test(n));
+  if (names.length === 0) {
+    eruditGlobalPreamble = '';
+    return eruditGlobalPreamble;
+  }
+
+  eruditGlobalPreamble =
+    'var { ' + names.join(', ') + ' } = globalThis.ERUDIT_GLOBAL;\n';
+  return eruditGlobalPreamble;
+}
+
 export async function setupServerImporter() {
   const jitiId = ERUDIT.paths.project();
   const defaultJiti = createJiti(jitiId, createBaseJitiOptions());
@@ -38,6 +61,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 = getEruditGlobalPreamble();
+        if (preamble) {
+          code = preamble + code;
+        }
+      }
+
       //
       // Insert IDs in `defineDocument(...)` calls
       //
@@ -58,6 +93,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 {