erudit 3.0.0-dev.3 → 3.0.0-dev.30

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

@@ -0,0 +1,167 @@
+import chalk from 'chalk';
+import type { Nuxt } from 'nuxt/schema';
+import { findPath } from 'nuxt/kit';
+import type { EruditProseCoreElement } from '@erudit-js/prose';
+
+import type { EruditRuntimeConfig } from '../../../../shared/types/runtimeConfig';
+import { moduleLogger } from '../../logger';
+import type { ElementData } from './shared';
+import { createTagsTable } from './tagsTable';
+import { createGlobalTypes } from './globalTypes';
+import { createGlobalTemplate } from './globalTemplate';
+import { createAppTemplate } from './appTemplate';
+
+const BUILTIN_ELEMENT_PATHS = [
+    '@erudit-js/prose/elements/callout',
+    '@erudit-js/prose/elements/caption',
+    '@erudit-js/prose/elements/details',
+    '@erudit-js/prose/elements/emphasis',
+    '@erudit-js/prose/elements/flex',
+    '@erudit-js/prose/elements/gallery',
+    '@erudit-js/prose/elements/heading',
+    '@erudit-js/prose/elements/horizontalLine',
+    '@erudit-js/prose/elements/image',
+    '@erudit-js/prose/elements/lineBreak',
+    '@erudit-js/prose/elements/link/dependency',
+    '@erudit-js/prose/elements/link/reference',
+    '@erudit-js/prose/elements/list',
+    '@erudit-js/prose/elements/paragraph',
+    '@erudit-js/prose/elements/problem',
+    '@erudit-js/prose/elements/table',
+    '@erudit-js/prose/elements/video',
+];
+
+export async function setupProseElements(
+    nuxt: Nuxt,
+    runtimeConfig: EruditRuntimeConfig,
+) {
+    const elementsData: ElementData[] = [];
+
+    const seenElements = new Set<string>();
+    const seenSchemas = new Set<string>();
+    const seenTags = new Set<string>();
+
+    const elementPaths: string[] = [
+        ...BUILTIN_ELEMENT_PATHS,
+        ...runtimeConfig.project.elements,
+    ];
+
+    for (const elementPath of elementPaths) {
+        const pathParts = elementPath.split('/');
+        let elementName = pathParts[pathParts.length - 1]!;
+        let uniqueElementName = elementName;
+        let counter = 1;
+        while (seenElements.has(uniqueElementName)) {
+            uniqueElementName = `${elementName}_${counter}`;
+            counter++;
+        }
+        seenElements.add(uniqueElementName);
+
+        const elementData: ElementData = {
+            name: uniqueElementName,
+            registryItems: [],
+            absDirectory: '',
+            absCorePath: '',
+            absAppPath: undefined,
+        };
+
+        const corePath = elementPath + '/core';
+        const coreAbsPath = await findPath(corePath, {
+            cwd: runtimeConfig.paths.project,
+            extensions: ['.ts', '.js'],
+        });
+
+        if (!coreAbsPath) {
+            throw new Error(
+                `Failed to detect "core" part of prose element "${elementPath}"!`,
+            );
+        }
+
+        elementData.absCorePath = coreAbsPath;
+        elementData.absDirectory = coreAbsPath.replace(
+            /\/core\.(?:ts|js)$/,
+            '',
+        );
+
+        const appPath = elementPath + '/app';
+        const appAbsPath = await findPath(appPath, {
+            cwd: runtimeConfig.paths.project,
+            extensions: ['.ts', '.js'],
+        });
+
+        if (appAbsPath) {
+            elementData.absAppPath = appAbsPath;
+        }
+
+        const coreDefault: EruditProseCoreElement | EruditProseCoreElement[] = (
+            await import(coreAbsPath)
+        ).default;
+
+        const coreElements = Array.isArray(coreDefault)
+            ? coreDefault
+            : [coreDefault];
+
+        for (const coreElement of coreElements) {
+            const schemaName = coreElement.registryItem.schema.name;
+
+            if (seenSchemas.has(schemaName)) {
+                throw new Error(
+                    `Prose element schema name "${schemaName}" is already registered by another element!`,
+                );
+            }
+
+            seenSchemas.add(schemaName);
+            elementData.registryItems.push({
+                schemaName,
+                tagNames: [],
+            });
+
+            if (coreElement.registryItem.tags) {
+                for (const tagName of Object.keys(
+                    coreElement.registryItem.tags,
+                )) {
+                    if (seenTags.has(tagName)) {
+                        throw new Error(
+                            `Prose element tag name "<${tagName}>" is already registered by another element!`,
+                        );
+                    }
+
+                    seenTags.add(tagName);
+                    elementData.registryItems[
+                        elementData.registryItems.length - 1
+                    ]!.tagNames.push(tagName);
+                }
+            }
+
+            const transpile = (nuxt.options.build.transpile ||= []);
+            const optimizeDeps = nuxt.options.vite.optimizeDeps || {};
+            const optimizeDepsInclude = (optimizeDeps.include ||= []);
+
+            for (const [name, options] of Object.entries(
+                coreElement.dependencies ?? {},
+            )) {
+                if (options?.transpile) transpile.push(name);
+                if (options?.optimize) optimizeDepsInclude.push(name);
+            }
+        }
+
+        elementsData.push(elementData);
+    }
+
+    createGlobalTypes(runtimeConfig, elementsData);
+    createGlobalTemplate(nuxt, elementsData);
+    createAppTemplate(nuxt, elementsData);
+
+    const elementsNumber = elementsData.length;
+    const schemasNumber = seenSchemas.size;
+    const tagsNumber = seenTags.size;
+
+    moduleLogger.success(
+        `
+Registered ${elementsNumber} prose elements: ${schemasNumber} schema(s) and ${tagsNumber} tag(s)!
+        `.trim(),
+    );
+
+    const tagsTable = createTagsTable(elementsData);
+    console.log(chalk.gray(tagsTable));
+}

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

@@ -0,0 +1,10 @@
+export interface ElementData {
+    name: string;
+    registryItems: {
+        schemaName: string;
+        tagNames: string[];
+    }[];
+    absDirectory: string;
+    absCorePath: string;
+    absAppPath: string | undefined;
+}

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

@@ -0,0 +1,28 @@
+import type { ElementData } from './shared';
+
+export function createTagsTable(elementsData: ElementData[], columns = 4) {
+    const tagNames = elementsData.flatMap((data) =>
+        data.registryItems.flatMap((item) => item.tagNames),
+    );
+
+    if (tagNames.length === 0) return '';
+
+    const cols = Math.max(1, columns);
+    const formatted = tagNames.map((t) => `<${t}>`);
+    const maxLen = Math.max(...formatted.map((s) => s.length));
+    const colWidth = maxLen + 2; // padding between columns
+
+    const rows = Math.ceil(formatted.length / cols);
+    const lines: string[] = [];
+
+    for (let r = 0; r < rows; r++) {
+        const start = r * cols;
+        const rowItems = formatted.slice(start, start + cols);
+        const padded = rowItems.map((s) => s.padEnd(colWidth, ' '));
+        lines.push(padded.join('').replace(/\s+$/u, '')); // trim trailing spaces on the row
+    }
+
+    const tagTable = lines.join('\n');
+
+    return tagTable;
+}

package/modules/erudit/setup/fullRestart.ts

@@ -0,0 +1,71 @@
+import type { Nuxt } from '@nuxt/schema';
+import { debounce } from 'perfect-debounce';
+import { globSync } from 'glob';
+import chalk from 'chalk';
+import slash from 'slash';
+
+import { ERUDIT_PACKAGE_WATCHER, ERUDIT_PROJECT_WATCHER } from '../watcher';
+import { moduleLogger } from '../logger';
+import type { EruditRuntimeConfig } from '../../../shared/types/runtimeConfig';
+
+export async function setupEruditFullRestart(
+    nuxt: Nuxt,
+    runtimeConfig: EruditRuntimeConfig,
+) {
+    const paths = runtimeConfig.paths;
+    const changedPaths = new Set<string>();
+
+    const tryRestartNuxt = debounce(async () => {
+        const files = Array.from(changedPaths);
+        changedPaths.clear();
+
+        moduleLogger.warn(
+            `${chalk.yellow('Full restart due to critical file change(s):')}\n\n` +
+                files
+                    .map((p, i) => chalk.gray(`${i + 1} -`) + ` "${p}"`)
+                    .join('\n'),
+        );
+
+        await nuxt.callHook('close', nuxt);
+        process.exit(1337);
+    }, 300);
+
+    const isTargetFile = (path: string): boolean => {
+        // Check if it's in the module directory
+        if (path.startsWith(paths.module)) {
+            return true;
+        }
+
+        // Check if it's in package/shared
+        if (path.startsWith(paths.package + '/shared')) {
+            return true;
+        }
+
+        // Check if it's nuxt.config.ts in package
+        if (path === paths.package + '/nuxt.config.ts') {
+            return true;
+        }
+
+        // Check if it's erudit.config.{js,ts} in project
+        const configFiles = globSync(
+            paths.project + '/erudit.config.{js,ts}',
+        ).map((p) => slash(p));
+        if (configFiles.includes(path)) {
+            return true;
+        }
+
+        return false;
+    };
+
+    const handleFileChange = (_event: string, path: string) => {
+        path = slash(path);
+
+        if (path.trim() && isTargetFile(path)) {
+            changedPaths.add(String(path));
+            tryRestartNuxt();
+        }
+    };
+
+    ERUDIT_PACKAGE_WATCHER?.on('all', handleFileChange);
+    ERUDIT_PROJECT_WATCHER?.on('all', handleFileChange);
+}

package/modules/erudit/setup/globals.ts

@@ -0,0 +1,196 @@
+import { writeFileSync } from 'node:fs';
+import { addImports, addServerImports } from 'nuxt/kit';
+
+import { defineEruditConfig } from '../globals/eruditConfig';
+import { eruditPublic, projectPublic } from '../globals/public';
+import type { EruditRuntimeConfig } from '../../../shared/types/runtimeConfig';
+
+//
+// Module
+//
+
+export async function registerModuleGlobals() {
+    const moduleGlobals = {
+        defineEruditConfig,
+        projectPublic,
+        eruditPublic,
+    };
+
+    Object.assign(globalThis, moduleGlobals);
+}
+
+//
+// App
+//
+
+export async function registerAppGlobals(runtimeConfig: EruditRuntimeConfig) {
+    addImports([
+        {
+            name: 'ERUDIT',
+            from: `${runtimeConfig.paths.app}/plugins/appSetup/global`,
+        },
+        {
+            name: 'eruditPublic',
+            from: `${runtimeConfig.paths.module}/globals/public`,
+        },
+        {
+            name: 'defineProblemScript',
+            from: `${runtimeConfig.paths.module}/globals/problem`,
+        },
+    ]);
+}
+
+//
+// Server
+//
+
+export async function registerServerGlobals(
+    runtimeConfig: EruditRuntimeConfig,
+) {
+    addServerImports([
+        {
+            name: 'ERUDIT',
+            from: `${runtimeConfig.paths.server}/global`,
+        },
+        {
+            name: '$CONTRIBUTOR',
+            from: `${runtimeConfig.paths.server}/contributors/global`,
+        },
+        {
+            name: '$CONTENT',
+            from: `${runtimeConfig.paths.server}/content/global`,
+        },
+        {
+            name: 'defineContributor',
+            from: `${runtimeConfig.paths.module}/globals/contributor`,
+        },
+        {
+            name: 'defineSponsor',
+            from: `@erudit-js/core/sponsor`,
+        },
+        {
+            name: 'defineCameo',
+            from: `@erudit-js/core/cameo`,
+        },
+        {
+            name: 'defineBook',
+            from: `${runtimeConfig.paths.module}/globals/content`,
+        },
+        {
+            name: 'defineTopic',
+            from: `${runtimeConfig.paths.module}/globals/content`,
+        },
+        {
+            name: 'definePage',
+            from: `${runtimeConfig.paths.module}/globals/content`,
+        },
+
+        {
+            name: 'defineGroup',
+            from: `${runtimeConfig.paths.module}/globals/content`,
+        },
+        {
+            name: 'defineProse',
+            from: `${runtimeConfig.paths.module}/globals/prose`,
+        },
+        {
+            name: 'Include',
+            from: `@erudit-js/prose`,
+        },
+    ]);
+}
+
+//
+// Content Types
+//
+
+export async function registerGlobalContentTypes(
+    runtimeConfig: EruditRuntimeConfig,
+) {
+    interface ContentType {
+        name: string;
+        from: string;
+    }
+
+    const contentTypes: ContentType[] = [];
+
+    const addContentTypes = (types: ContentType[]) => {
+        contentTypes.push(...types);
+    };
+
+    //
+    //
+    //
+
+    addContentTypes([
+        {
+            name: 'defineEruditConfig',
+            from: `${runtimeConfig.paths.module}/globals/eruditConfig`,
+        },
+        {
+            name: 'projectPublic',
+            from: `${runtimeConfig.paths.module}/globals/public`,
+        },
+        {
+            name: 'eruditPublic',
+            from: `${runtimeConfig.paths.module}/globals/public`,
+        },
+        {
+            name: 'defineContributor',
+            from: `${runtimeConfig.paths.module}/globals/contributor`,
+        },
+        {
+            name: 'defineSponsor',
+            from: `@erudit-js/core/sponsor`,
+        },
+        {
+            name: 'defineCameo',
+            from: `@erudit-js/core/cameo`,
+        },
+        {
+            name: 'defineProblemScript',
+            from: `${runtimeConfig.paths.module}/globals/problem`,
+        },
+        {
+            name: 'defineBook',
+            from: `${runtimeConfig.paths.module}/globals/content`,
+        },
+        {
+            name: 'defineTopic',
+            from: `${runtimeConfig.paths.module}/globals/content`,
+        },
+        {
+            name: 'definePage',
+            from: `${runtimeConfig.paths.module}/globals/content`,
+        },
+        {
+            name: 'defineGroup',
+            from: `${runtimeConfig.paths.module}/globals/content`,
+        },
+        {
+            name: 'defineProse',
+            from: `${runtimeConfig.paths.module}/globals/prose`,
+        },
+        {
+            name: 'Include',
+            from: `@erudit-js/prose`,
+        },
+    ]);
+
+    //
+    //
+    //
+
+    let erudit_d_ts = 'export {}\n\ndeclare global {\n';
+
+    for (const contentType of contentTypes) {
+        erudit_d_ts += `    const ${contentType.name}: typeof import('${contentType.from}')['${contentType.name}']\n`;
+    }
+
+    erudit_d_ts += `}\n`;
+
+    writeFileSync(
+        `${runtimeConfig.paths.build}/types/erudit.d.ts`,
+        erudit_d_ts,
+    );
+}

package/modules/erudit/setup/nuxtConfig.ts

@@ -0,0 +1,48 @@
+import type { Nuxt } from '@nuxt/schema';
+
+import type {
+    EruditRuntimeConfig,
+    EruditPublicRuntimeConfig,
+} from '../../../shared/types/runtimeConfig';
+
+export async function setupEruditNuxtConfig(
+    nuxt: Nuxt,
+    runtimeConfig: EruditRuntimeConfig,
+    publicRuntimeConfig: EruditPublicRuntimeConfig,
+) {
+    //
+    // Include Erudit package and Erudit project files in TSConfig
+    //
+
+    nuxt.options.typescript.tsConfig.include = [
+        ...(nuxt.options.typescript.tsConfig.include || []),
+        runtimeConfig.paths.package + '/**/*',
+        runtimeConfig.paths.project + '/**/*',
+    ];
+
+    //
+    // Locate `.output` directory in project root
+    //
+
+    {
+        const outputOptions = (nuxt.options.nitro.output ||= {});
+        outputOptions.dir = runtimeConfig.paths.project + '/.output';
+        outputOptions.publicDir =
+            runtimeConfig.paths.project +
+            '/.output/public' +
+            publicRuntimeConfig.project.baseUrl;
+    }
+
+    //
+    // Add Erudit Layer `server` dir to Nuxt server TSConfig
+    //
+
+    {
+        const nitroTypescript = (nuxt.options.nitro.typescript ||= {});
+        nitroTypescript.tsConfig = nitroTypescript.tsConfig || {};
+        nitroTypescript.tsConfig.include = [
+            ...(nitroTypescript.tsConfig.include || []),
+            runtimeConfig.paths.package + '/server/**/*',
+        ];
+    }
+}

package/modules/erudit/setup/projectConfig.ts

@@ -0,0 +1,114 @@
+import type { Nuxt } from '@nuxt/schema';
+import type { EruditConfig } from '@erudit-js/core/eruditConfig/config';
+
+import type {
+    EruditRuntimeConfig,
+    EruditPublicRuntimeConfig,
+} from '../../../shared/types/runtimeConfig';
+import { moduleLogger } from '../logger';
+
+export async function addEruditProjectConfigToRuntime(
+    nuxt: Nuxt,
+    runtimeConfig: EruditRuntimeConfig,
+    publicRuntimeConfig: EruditPublicRuntimeConfig,
+) {
+    let projectConfig: Partial<EruditConfig> = {};
+
+    try {
+        projectConfig = (
+            await import(runtimeConfig.paths.project + '/erudit.config')
+        ).default as Partial<EruditConfig>;
+
+        if (typeof projectConfig !== 'object') {
+            throw new Error(
+                'Project config must export an object, got: ' +
+                    typeof projectConfig,
+            );
+        }
+    } catch (error) {
+        moduleLogger.warn(`Failed to load Erudit project config!\n\n${error}`);
+    }
+
+    await transferConfigData(
+        nuxt,
+        projectConfig,
+        runtimeConfig,
+        publicRuntimeConfig,
+    );
+
+    if (projectConfig.nuxtAugmentations) {
+        return projectConfig.nuxtAugmentations;
+    }
+}
+
+async function transferConfigData(
+    nuxt: Nuxt,
+    projectConfig: Partial<EruditConfig>,
+    runtimeConfig: EruditRuntimeConfig,
+    publicRuntimeConfig: EruditPublicRuntimeConfig,
+) {
+    runtimeConfig.project = {
+        elements: projectConfig.elements || [],
+        countElements: projectConfig.countElements || [],
+        indexPage: projectConfig.indexPage,
+    };
+
+    publicRuntimeConfig.project = {
+        language: projectConfig.language || { current: 'en' },
+        originUrl: nuxt.options.dev
+            ? 'http://localhost:3000'
+            : projectConfig.site?.originUrl || 'http://localhost:3000',
+        baseUrl: projectConfig.site?.baseUrl || '/',
+        siteInfo: {
+            title: projectConfig.site?.title,
+            short: projectConfig.site?.short,
+            logotype: projectConfig.site?.logotype,
+            favicon: projectConfig.site?.favicon
+                ? typeof projectConfig.site?.favicon === 'string'
+                    ? { default: projectConfig.site?.favicon }
+                    : projectConfig.site?.favicon
+                : undefined,
+        },
+        seo: projectConfig.seo,
+        debug: {
+            ads: projectConfig.debug?.ads ?? false,
+            log: projectConfig.debug?.log ?? false,
+            slowTransition: projectConfig.debug?.slowTransition ?? false,
+            fakeApi: {
+                repository:
+                    projectConfig.debug?.fakeApi?.repository ??
+                    nuxt.options.dev,
+            },
+            analytics: projectConfig.debug?.analytics,
+        },
+        style: {
+            brandColor: projectConfig.site?.style?.brandColor,
+        },
+        repository: (() => {
+            const repository = projectConfig.repository;
+
+            if (!repository) {
+                return undefined;
+            }
+
+            const link = (() => {
+                switch (repository.type) {
+                    case 'custom':
+                        return repository.link;
+                    case 'github':
+                        return `https://github.com/${repository.name}/tree/${repository.branch}`;
+                }
+            })();
+
+            return {
+                ...repository,
+                _link: link,
+            };
+        })(),
+        customLinks: projectConfig.customLinks,
+        contributors: projectConfig.contributors,
+        sponsors: projectConfig.sponsors,
+        ads: projectConfig.ads,
+        analytics: projectConfig.analytics,
+    };
+}

package/modules/erudit/setup/publicAssets.ts

@@ -0,0 +1,52 @@
+import type { Nuxt } from '@nuxt/schema';
+
+import type { EruditRuntimeConfig } from '../../../shared/types/runtimeConfig';
+import {
+    PUBLIC_ERUDIT_BASE_URL,
+    PUBLIC_PROJECT_BASE_URL,
+} from '../globals/public';
+
+export async function setupEruditPublicAssets(
+    nuxt: Nuxt,
+    runtimeConfig: EruditRuntimeConfig,
+) {
+    const nitro = nuxt.options.nitro;
+    const nitroPublicAssets = (nitro.publicAssets ||= []);
+    const nitroModules = (nitro.modules ||= []);
+
+    // Clear default Nuxt/Nitro public assets
+    nitroModules.push((nitro) => {
+        nitro.options.publicAssets = nitro.options.publicAssets?.filter(
+            (item) => {
+                const wantsToCopyToRoot = item.baseURL === '/';
+                const fromPackagePublic =
+                    item.dir === runtimeConfig.paths.package + '/public';
+                const fromProjectPublic =
+                    item.dir === runtimeConfig.paths.project + '/public';
+
+                if (
+                    wantsToCopyToRoot &&
+                    (fromPackagePublic || fromProjectPublic)
+                ) {
+                    return false;
+                }
+
+                return true;
+            },
+        );
+    });
+
+    // Adding Erudit package and project public assets
+    nitroPublicAssets.push(
+        {
+            baseURL: PUBLIC_ERUDIT_BASE_URL,
+            dir: runtimeConfig.paths.package + '/public',
+            maxAge: 60 * 60 * 24 * 365,
+        },
+        {
+            baseURL: PUBLIC_PROJECT_BASE_URL,
+            dir: runtimeConfig.paths.project + '/public',
+            maxAge: 60 * 60 * 24 * 365,
+        },
+    );
+}