erudit 3.0.0-dev.8 → 4.0.0-dev.1

package/modules/erudit/globals/eruditConfig.ts

@@ -0,0 +1,10 @@
+import { defu } from 'defu';
+import type { EruditConfig } from '@erudit-js/core/eruditConfig/config';
+
+export function defineEruditConfig(
+    eruditConfig: Partial<EruditConfig> | Partial<EruditConfig>[],
+) {
+    const configs = Array.isArray(eruditConfig) ? eruditConfig : [eruditConfig];
+    // @ts-ignore
+    return defu(...configs.reverse());
+}

package/modules/erudit/globals/problem.ts

@@ -0,0 +1 @@
+export { defineProblemScript } from '@erudit-js/prose/elements/problem/problemScript';

package/modules/erudit/globals/prose.ts

@@ -0,0 +1 @@
+export { defineDocument as defineProse } from '@jsprose/core';

package/modules/erudit/globals/public.ts

@@ -0,0 +1,18 @@
+import { slasher } from '../../../shared/utils/slasher';
+
+export const PUBLIC_PROJECT_BASE_URL = '/public/project/';
+export const PUBLIC_ERUDIT_BASE_URL = '/public/erudit/';
+
+/**
+ * Target static files located in `<project_dir>/public` folder.
+ */
+export function projectPublic(path: string) {
+    return slasher(`${PUBLIC_PROJECT_BASE_URL}${path}`);
+}
+
+/**
+ * Target static files located in `<erudit_package>/public` folder.
+ */
+export function eruditPublic(path: string) {
+    return slasher(`${PUBLIC_ERUDIT_BASE_URL}${path}`);
+}

package/modules/erudit/index.ts

@@ -0,0 +1,60 @@
+import { defineNuxtModule } from 'nuxt/kit';
+
+import { version } from '../../package.json';
+import { moduleLogger } from './logger';
+import { setupWatchers } from './watcher';
+
+// Setup procedures
+import { setupEruditRuntimeConfig } from './setup/runtimeConfig';
+import { setupEruditFullRestart } from './setup/fullRestart';
+import { setupEruditAliases } from './setup/aliases';
+import { addEruditProjectConfigToRuntime } from './setup/projectConfig';
+import { setupEruditPublicAssets } from './setup/publicAssets';
+import { setupEruditCustomBaseUrl } from './setup/baseUrl';
+import { setupEruditNuxtConfig } from './setup/nuxtConfig';
+import {
+    registerAppGlobals,
+    registerGlobalContentTypes,
+    registerModuleGlobals,
+    registerServerGlobals,
+} from './setup/globals';
+import { setupProseElements } from './setup/elements/setup';
+
+export default defineNuxtModule({
+    meta: { name: 'Erudit', configKey: 'erudit', version },
+    async setup(_, nuxt) {
+        moduleLogger.start('Setting up Erudit module...');
+
+        const { eruditRuntimeConfig, eruditPublicRuntimeConfig } =
+            await setupEruditRuntimeConfig(nuxt);
+
+        await setupWatchers(nuxt, eruditRuntimeConfig);
+        await setupEruditFullRestart(nuxt, eruditRuntimeConfig);
+        await setupEruditAliases(nuxt, eruditRuntimeConfig);
+        await registerModuleGlobals();
+        await registerAppGlobals(eruditRuntimeConfig);
+        await registerServerGlobals(eruditRuntimeConfig);
+        await registerGlobalContentTypes(eruditRuntimeConfig);
+        const nuxtAugmentations = await addEruditProjectConfigToRuntime(
+            nuxt,
+            eruditRuntimeConfig,
+            eruditPublicRuntimeConfig,
+        );
+        await setupEruditPublicAssets(nuxt, eruditRuntimeConfig);
+        await setupEruditCustomBaseUrl(nuxt, eruditPublicRuntimeConfig);
+        await setupProseElements(nuxt, eruditRuntimeConfig);
+        await setupEruditNuxtConfig(
+            nuxt,
+            eruditRuntimeConfig,
+            eruditPublicRuntimeConfig,
+        );
+
+        if (nuxtAugmentations) {
+            for (const augment of nuxtAugmentations) {
+                await augment(nuxt);
+            }
+        }
+
+        moduleLogger.success('Erudit module setup complete!');
+    },
+});

package/{module → modules/erudit}/logger.ts

@@ -1,9 +1,9 @@
 import { createConsola } from 'consola';
-import { brandColorTitle } from '@erudit-js/cog/utils/brandNode';
+import { brandColorTitle } from '@erudit-js/core/brandTerminal';
 
 const tag = brandColorTitle + ' Module';
 
-export const logger = createConsola({
+export const moduleLogger = createConsola({
     defaults: {
         tag,
     },

package/modules/erudit/setup/aliases.ts

@@ -0,0 +1,17 @@
+import type { Nuxt } from '@nuxt/schema';
+
+import type { EruditRuntimeConfig } from '../../../shared/types/runtimeConfig';
+
+export async function setupEruditAliases(
+    nuxt: Nuxt,
+    runtimeConfig: EruditRuntimeConfig,
+) {
+    nuxt.options.alias = {
+        ...nuxt.options.alias,
+        '@erudit': runtimeConfig.paths.package,
+        '@erudit/module': runtimeConfig.paths.module,
+        '@erudit/app': runtimeConfig.paths.app,
+        '@erudit/server': runtimeConfig.paths.server,
+        $: runtimeConfig.paths.app + '/styles',
+    };
+}

package/modules/erudit/setup/baseUrl.ts

@@ -0,0 +1,19 @@
+import type { Nuxt } from '@nuxt/schema';
+import { updateTemplates } from 'nuxt/kit';
+
+import type { EruditPublicRuntimeConfig } from '../../../shared/types/runtimeConfig';
+
+export async function setupEruditCustomBaseUrl(
+    nuxt: Nuxt,
+    publicRuntimeConfig: EruditPublicRuntimeConfig,
+) {
+    const newBaseUrl = publicRuntimeConfig.project.baseUrl;
+
+    if (newBaseUrl === '/') {
+        return;
+    }
+
+    nuxt.options.app.baseURL = newBaseUrl;
+    nuxt.options.nitro.runtimeConfig!.app!.baseURL = newBaseUrl;
+    await updateTemplates();
+}

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

@@ -0,0 +1,45 @@
+import type { Nuxt } from 'nuxt/schema';
+import { addTemplate } from 'nuxt/kit';
+
+import type { ElementData } from './shared';
+
+export function createAppTemplate(nuxt: Nuxt, elementsData: ElementData[]) {
+    const defaultImportName = (elementName: string) => `app_${elementName}`;
+
+    const apps: Record<string, string> = {};
+
+    for (const elementData of elementsData) {
+        if (elementData.absAppPath) {
+            apps[defaultImportName(elementData.name)] = elementData.absAppPath;
+        }
+    }
+
+    const template = `
+import type { AppElement } from '@erudit-js/prose/app';
+
+${Object.entries(apps)
+    .map(
+        ([importName, importPath]) =>
+            `import ${importName} from '${importPath.replace(/\.(ts|js)$/, '')}';`,
+    )
+    .join('\n')}
+
+export const appElementsArray: AppElement[] = [
+    ${Object.keys(apps).join(',\n    ')}
+].flatMap(element => (Array.isArray(element) ? element : [element]) as any);
+
+export const appElements = Object.fromEntries(
+    appElementsArray.map(element => [element.schema.name, element])
+);
+    `.trim();
+
+    addTemplate({
+        write: true,
+        filename: '#erudit/prose/app.ts',
+        getContents: () => template,
+    });
+
+    const alias = (nuxt.options.alias ||= {});
+    alias['#erudit/prose/app'] =
+        nuxt.options.buildDir + '/#erudit/prose/app.ts';
+}

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

@@ -0,0 +1,82 @@
+import { existsSync } from 'node:fs';
+import type { Nuxt } from 'nuxt/schema';
+import { addTemplate } from 'nuxt/kit';
+
+import type { ElementData } from './shared';
+
+export function createGlobalTemplate(nuxt: Nuxt, elementsData: ElementData[]) {
+    const defaultImportName = (type: 'core' | 'global', elementName: string) =>
+        `${type}_${elementName}`;
+
+    const cores: Record<string, string> = {};
+    const globals: Record<string, string> = {};
+
+    for (const elementData of elementsData) {
+        cores[defaultImportName('core', elementData.name)] =
+            elementData.absCorePath;
+
+        if (existsSync(elementData.absDirectory + '/_global.ts')) {
+            globals[defaultImportName('global', elementData.name)] =
+                elementData.absDirectory + '/_global.ts';
+        }
+    }
+
+    const template = `
+import { PROSE_REGISTRY } from '@jsprose/core';
+import { jsx, jsxs, Fragment } from '@jsprose/core/jsx-runtime';
+import type { EruditProseCoreElement } from '@erudit-js/prose';
+import { defineProblemScript } from '@erudit-js/prose/elements/problem/problemScript';
+
+${Object.entries(cores)
+    .map(
+        ([importName, importPath]) =>
+            `import ${importName} from '${importPath.replace(/\.(ts|js)$/, '')}';`,
+    )
+    .join('\n')}
+
+${Object.entries(globals)
+    .map(
+        ([importName, importPath]) =>
+            `import ${importName} from '${importPath.replace(/\.(ts|js)$/, '')}';`,
+    )
+    .join('\n')}
+
+const coreElements: EruditProseCoreElement[] = [
+    ${Object.keys(cores).join(',\n    ')}
+].flatMap(element => (Array.isArray(element) ? element : [element]) as any);
+
+const elementsGlobals = {
+    ${Object.keys(globals)
+        .map((key) => `...${key}`)
+        .join(',\n    ')}
+}
+
+export function registerProseGlobals() {
+    for (const element of coreElements) {
+        PROSE_REGISTRY.addItem(element.registryItem);
+        Object.assign(globalThis, element.registryItem.tags || {});
+    }
+
+    Object.assign(globalThis, {
+        // Make jsx runtime globally available (for prose generation in isolated modules like problem scripts)
+        jsx,
+        jsxs,
+        Fragment,
+        // Problem globals
+        defineProblemScript,
+        // Elements globals
+        ...elementsGlobals
+    });
+}
+    `.trim();
+
+    addTemplate({
+        write: true,
+        filename: '#erudit/prose/global.ts',
+        getContents: () => template,
+    });
+
+    const alias = (nuxt.options.alias ||= {});
+    alias['#erudit/prose/global'] =
+        nuxt.options.buildDir + `/#erudit/prose/global.ts`;
+}

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

@@ -0,0 +1,273 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+import type { EruditRuntimeConfig } from '../../../../shared/types/runtimeConfig';
+import type { ElementData } from './shared';
+
+export function createGlobalTypes(
+    runtimeConfig: EruditRuntimeConfig,
+    elementsData: ElementData[],
+) {
+    for (const elementData of elementsData) {
+        // Collect all tag names from registry
+        const allRegistryTagNames = new Set<string>();
+        for (const registryItem of elementData.registryItems) {
+            for (const tagName of registryItem.tagNames) {
+                allRegistryTagNames.add(tagName);
+            }
+        }
+
+        // Parse existing _global.d.ts if it exists
+        let imports: string[] = [];
+        let tags: Record<string, string> = {};
+        let other: Record<
+            string,
+            { jsdoc: string; definition: string; kind: 'type' | 'const' }
+        > = {};
+
+        const globalDtsPath = elementData.absDirectory + '/_global.d.ts';
+        if (existsSync(globalDtsPath)) {
+            const globalDts = readFileSync(globalDtsPath, 'utf-8');
+            const parsed = parseGlobalDts(globalDts);
+            imports = parsed.imports;
+            tags = parsed.tags;
+            other = parsed.other;
+        }
+
+        // Add missing tags from registry
+        for (const tagName of allRegistryTagNames) {
+            if (!(tagName in tags)) {
+                tags[tagName] = '';
+            }
+        }
+
+        // Skip if there's nothing to generate
+        if (Object.keys(tags).length === 0 && Object.keys(other).length === 0) {
+            continue;
+        }
+
+        // Transform import paths from relative to absolute
+        const resolvedImports = imports.map((importLine) => {
+            return importLine.replace(
+                /from\s+['"](\.[^'"]+)['"]/,
+                (_match: string, relativePath: string) => {
+                    const absolutePath = resolve(
+                        elementData.absDirectory,
+                        relativePath,
+                    ).replace(/\\/g, '/');
+                    return `from '${absolutePath}'`;
+                },
+            );
+        });
+
+        // Create typeof imports for tags that exist in element's registry items
+        const tagDefinitions = Object.entries(tags).map(([tagName, jsdoc]) => {
+            // Find which registry item contains this tag
+            let tagDefinition = "'_tag_'";
+            for (let i = 0; i < elementData.registryItems.length; i++) {
+                const registryItem = elementData.registryItems[i]!;
+                if (registryItem.tagNames.includes(tagName)) {
+                    // If there are multiple schemas, include the index
+                    if (elementData.registryItems.length > 1) {
+                        tagDefinition = `typeof import('${elementData.absCorePath}')['default'][${i}]['registryItem']['tags']['${tagName}']`;
+                    } else {
+                        tagDefinition = `typeof import('${elementData.absCorePath}')['default']['registryItem']['tags']['${tagName}']`;
+                    }
+                    break;
+                }
+            }
+
+            const indentedJsdoc = indentJsDoc(jsdoc);
+
+            return indentedJsdoc
+                ? `${indentedJsdoc}\n    const ${tagName}: ${tagDefinition};`
+                : `    const ${tagName}: ${tagDefinition};`;
+        });
+
+        const finalDts = `
+${resolvedImports.join('\n')}
+
+declare global {
+${tagDefinitions.join('\n')}
+
+${Object.entries(other)
+    .map(([typeName, { jsdoc, definition, kind }]) => {
+        const indentedJsdoc = indentJsDoc(jsdoc);
+        const declaration =
+            kind === 'type'
+                ? `type ${typeName} = ${definition};`
+                : `const ${typeName}: ${definition};`;
+        return indentedJsdoc
+            ? `${indentedJsdoc}\n    ${declaration}`
+            : `    ${declaration}`;
+    })
+    .join('\n')}
+}
+
+export {};
+        `.trim();
+
+        mkdirSync(
+            runtimeConfig.paths.build + '/types/elements/' + elementData.name,
+            { recursive: true },
+        );
+
+        writeFileSync(
+            runtimeConfig.paths.build +
+                '/types/elements/' +
+                elementData.name +
+                '/global.d.ts',
+            finalDts,
+            'utf-8',
+        );
+    }
+
+    //
+}
+
+function parseGlobalDts(dts: string): {
+    imports: string[];
+    tags: Record<string, string>;
+    other: Record<
+        string,
+        { jsdoc: string; definition: string; kind: 'type' | 'const' }
+    >;
+} {
+    const imports: string[] = [];
+    const tags: Record<string, string> = {};
+    const other: Record<
+        string,
+        { jsdoc: string; definition: string; kind: 'type' | 'const' }
+    > = {};
+
+    const lines = dts.split('\n');
+    let currentJsDoc = '';
+    let inJsDoc = false;
+
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i]!.trim();
+
+        // Collect imports as-is (will be transformed later)
+        if (line.startsWith('import ')) {
+            imports.push(line);
+            continue;
+        }
+
+        // Track JSDoc comments
+        if (line.startsWith('/**')) {
+            inJsDoc = true;
+            currentJsDoc = line + '\n';
+            continue;
+        }
+
+        if (inJsDoc) {
+            currentJsDoc += lines[i] + '\n';
+            if (line.includes('*/')) {
+                inJsDoc = false;
+            }
+            continue;
+        }
+
+        // Parse export type definitions
+        if (line.startsWith('export type ')) {
+            const typeMatch = line.match(
+                /^export\s+type\s+(\w+)\s*=\s*(.+);?$/,
+            );
+            if (typeMatch) {
+                const [, typeName, typeDefinition] = typeMatch;
+                const normalizedDefinition = typeDefinition!
+                    .replace(/;$/, '')
+                    .trim();
+
+                // Check if it's a tag
+                if (
+                    normalizedDefinition === "'_tag_'" ||
+                    normalizedDefinition === '"_tag_"'
+                ) {
+                    tags[typeName!] = currentJsDoc.trim();
+                    // Don't reset JSDoc for tags - let it apply to next consecutive tags
+                } else {
+                    other[typeName!] = {
+                        jsdoc: currentJsDoc.trim(),
+                        definition: normalizedDefinition,
+                        kind: 'type',
+                    };
+                    currentJsDoc = '';
+                }
+            }
+            continue;
+        }
+
+        // Parse export const definitions
+        if (line.startsWith('export const ')) {
+            const constMatch = line.match(
+                /^export\s+const\s+(\w+)\s*[=:]\s*(.+);?$/,
+            );
+            if (constMatch) {
+                const [, constName, constType] = constMatch;
+                const normalizedType = constType!.replace(/;$/, '').trim();
+
+                // Check if it's a tag
+                if (
+                    normalizedType === "'_tag_'" ||
+                    normalizedType === '"_tag_"'
+                ) {
+                    tags[constName!] = currentJsDoc.trim();
+                    // Don't reset JSDoc for tags - let it apply to next consecutive tags
+                } else {
+                    other[constName!] = {
+                        jsdoc: currentJsDoc.trim(),
+                        definition: normalizedType,
+                        kind: 'const',
+                    };
+                    currentJsDoc = '';
+                }
+            }
+            continue;
+        }
+
+        // Parse legacy type definitions (for backwards compatibility)
+        if (line.startsWith('type ')) {
+            const typeMatch = line.match(/^type\s+(\w+)\s*=\s*(.+);?$/);
+            if (typeMatch) {
+                const [, typeName, typeDefinition] = typeMatch;
+                const normalizedDefinition = typeDefinition!
+                    .replace(/;$/, '')
+                    .trim();
+
+                // Check if it's a tag
+                if (
+                    normalizedDefinition === "'_tag_'" ||
+                    normalizedDefinition === '"_tag_"'
+                ) {
+                    tags[typeName!] = currentJsDoc.trim();
+                    // Don't reset JSDoc for tags - let it apply to next consecutive tags
+                } else {
+                    other[typeName!] = {
+                        jsdoc: currentJsDoc.trim(),
+                        definition: normalizedDefinition,
+                        kind: 'type',
+                    };
+                    currentJsDoc = '';
+                }
+            }
+            continue;
+        }
+
+        // Reset JSDoc on blank lines or comments
+        if (line.startsWith('//') || line === '') {
+            currentJsDoc = '';
+            continue;
+        }
+    }
+
+    return { imports, tags, other };
+}
+
+function indentJsDoc(jsdoc: string, indent: string = '    '): string {
+    if (!jsdoc) return '';
+    return jsdoc
+        .split('\n')
+        .map((line) => indent + line)
+        .join('\n');
+}