erudit 2.0.0-dev.7

package/module/bitran.ts

@@ -0,0 +1,34 @@
+import { addTemplate } from 'nuxt/kit';
+import type { Nuxt } from 'nuxt/schema';
+
+import { eruditEndNuxtPath, projectPath } from '@erudit/globalPath';
+import type { EruditBitranConfig } from '@erudit/globals/bitran';
+import { logger } from '@erudit/module/logger';
+
+export async function setupBitranConfig(_nuxt: Nuxt) {
+    let config: Partial<EruditBitranConfig>;
+
+    try {
+        const projectConfig = (await import(projectPath('bitran'))).default;
+        if (!projectConfig) throw new Error('Falsy Bitran config!');
+        config = projectConfig;
+    } catch (error) {
+        logger.warn(`Failed to load Bitran config!\n\n${error}`);
+    }
+
+    const templateFilename = '#erudit/client/bitran.ts';
+
+    addTemplate({
+        filename: templateFilename,
+        write: true,
+        getContents: () => `
+            ${config ? `import bitranConfig from '${projectPath('bitran')}';` : ''}
+            export default ${config ? 'bitranConfig' : 'undefined'};
+        `,
+    });
+
+    const alias = (_nuxt.options.alias ||= {});
+    alias['#erudit/client/bitran'] = eruditEndNuxtPath(
+        `.nuxt/${templateFilename}`,
+    );
+}

package/module/config.ts

@@ -0,0 +1,34 @@
+import { addTemplate } from 'nuxt/kit';
+import type { Nuxt } from 'nuxt/schema';
+import type { EruditConfig } from 'erudit-cog/schema';
+
+import { eruditEndNuxtPath, projectPath } from '@erudit/globalPath';
+import { logger } from '@erudit/module/logger';
+
+export async function setupEruditConfig(_nuxt: Nuxt) {
+    let config: Partial<EruditConfig> = {};
+
+    try {
+        const projectConfig = (await import(projectPath('erudit'))).default;
+        if (!projectConfig) throw new Error('Falsy Erudit config!');
+        config = projectConfig;
+    } catch (error) {
+        logger.warn(`Failed to load Erudit config!\n\n${error}`);
+    }
+
+    const templateFilename = '#erudit/config.ts';
+
+    addTemplate({
+        filename: templateFilename,
+        write: true,
+        getContents: () => `
+            import type { EruditConfig } from 'erudit-cog/schema';
+            export default ${JSON.stringify(config, null, '    ')} as Partial<EruditConfig>;
+        `,
+    });
+
+    const alias = (_nuxt.options.alias ||= {});
+    alias['#erudit/config'] = eruditEndNuxtPath(`.nuxt/${templateFilename}`);
+
+    return config;
+}

package/module/imports.ts

@@ -0,0 +1,46 @@
+import { addImports, addServerImports } from 'nuxt/kit';
+
+import { eruditPath } from '@erudit/globalPath';
+
+export function setupGlobalImports() {
+    addImports([
+        {
+            name: 'defineEruditConfig',
+            from: eruditPath('globals/erudit'),
+        },
+        {
+            name: 'defineContributor',
+            from: eruditPath('globals/contributor'),
+        },
+        {
+            name: 'defineBitranConfig',
+            from: eruditPath('globals/bitran'),
+        },
+        // Content
+        ...(() => {
+            const imports = [
+                'defineBook',
+                'defineGroup',
+                'defineTopic',
+                'defineContentReferences',
+            ];
+            return imports.map((name) => ({
+                name,
+                from: eruditPath(`globals/content`),
+            }));
+        })(),
+        // Helper Asset Path Functions
+        ...(() => {
+            const imports = [
+                'eruditAsset',
+                'contributorAsset',
+                'contentAsset',
+                'publicAsset',
+            ];
+            return imports.map((name) => ({
+                name,
+                from: eruditPath(`shared/asset`),
+            }));
+        })(),
+    ]);
+}

package/module/index.ts

@@ -0,0 +1,35 @@
+import { defineNuxtModule, updateTemplates } from 'nuxt/kit';
+
+import { registerGlobals } from '@erudit/globals/register';
+import { setupRestartWatcher } from '@erudit/module/restart';
+import { setupEruditConfig } from '@erudit/module/config';
+import { logger } from '@erudit/module/logger';
+import { setupGlobalImports } from '@erudit/module/imports';
+import { setupBitranConfig } from './bitran';
+import { setupGlobalPaths } from './paths';
+
+export default defineNuxtModule({
+    meta: { name: 'Erudit', configKey: 'erudit' },
+    async setup(_options, _nuxt) {
+        if (_nuxt.options.dev) setupRestartWatcher(_nuxt);
+
+        setupGlobalImports();
+        registerGlobals();
+
+        const eruditConfig = await setupEruditConfig(_nuxt);
+        await setupBitranConfig(_nuxt);
+        setupGlobalPaths(_nuxt);
+
+        if (eruditConfig.site?.baseUrl) {
+            const newBaseUrl = eruditConfig.site.baseUrl;
+            _nuxt.options.app.baseURL = newBaseUrl;
+            _nuxt.options.nitro.runtimeConfig!.app!.baseURL = newBaseUrl;
+            await updateTemplates();
+        }
+
+        // TODO: Watch for contributors folder and create/update template with their IDs
+        // TODO: Create such helpers for other features!
+
+        logger.success('Erudit module setup complete!');
+    },
+});

package/module/logger.ts

@@ -0,0 +1,10 @@
+import { createConsola } from 'consola';
+import { brandColorTitle } from 'erudit-cog/utils/brand';
+
+const tag = brandColorTitle + ' Module';
+
+export const logger = createConsola({
+    defaults: {
+        tag,
+    },
+});

package/module/paths.ts

@@ -0,0 +1,22 @@
+import { addTemplate } from 'nuxt/kit';
+import type { Nuxt } from 'nuxt/schema';
+
+import { ERUDIT_DIR, eruditEndNuxtPath, PROJECT_DIR } from '@erudit/globalPath';
+
+export function setupGlobalPaths(_nuxt: Nuxt) {
+    const templateFilename = '#erudit/globalPaths.ts';
+
+    addTemplate({
+        filename: templateFilename,
+        write: true,
+        getContents: () => `
+            export const ERUDIT_DIR = '${ERUDIT_DIR}';
+            export const PROJECT_DIR = '${PROJECT_DIR}';
+        `,
+    });
+
+    const alias = (_nuxt.options.alias ||= {});
+    alias['#erudit/globalPaths'] = eruditEndNuxtPath(
+        `.nuxt/${templateFilename}`,
+    );
+}

package/module/restart.ts

@@ -0,0 +1,61 @@
+import { exit } from 'node:process';
+import { globSync } from 'glob';
+import chokidar, { type FSWatcher } from 'chokidar';
+import type { Nuxt } from 'nuxt/schema';
+
+import { eruditPath, projectPath } from '@erudit/globalPath';
+import { logger } from '@erudit/module/logger';
+import { stress } from '@erudit/utils/stress';
+
+const watchTargets: string[] = [
+    // Erudit Nuxt config file
+    eruditPath('nuxt.config.ts'),
+    // Erudit Globals
+    eruditPath('globals'),
+    // Erudit Nuxt module non-runtime files
+    ...globSync(eruditPath('module/**/*')),
+    // Erudit config in project root
+    ...globSync(projectPath('erudit.{js,ts}')),
+    // Erudit Bitran config in project root
+    ...globSync(projectPath('bitran.{js,ts}')),
+];
+
+const ignoreTargets: string[] = [
+    // Erudit Nuxt module runtime files
+    ...globSync(eruditPath('module/runtime/**/*')),
+];
+
+const restartDelay = 300;
+
+//
+//
+//
+
+let watcher: FSWatcher;
+let restartTimeout: any;
+let nuxt: Nuxt;
+
+export function setupRestartWatcher(_nuxt: Nuxt) {
+    nuxt = _nuxt;
+
+    if (watcher) return;
+
+    watcher = chokidar.watch(watchTargets, {
+        ignored: ignoreTargets,
+        ignoreInitial: true,
+    });
+
+    watcher.on('all', (event, path) => {
+        clearTimeout(restartTimeout);
+        restartTimeout = setTimeout(() => {
+            console.log('\n');
+            logger.info(
+                `Restarting due to critical file change: ${stress(path)}\n\n`,
+            );
+            // Nuxt Restart Hook won't work when unhandled Node exception is thrown!
+            // nuxt.callHook('restart', { hard: true, });
+            // So we kill the process and restart it in Erudit CLI instead.
+            exit(1337);
+        }, restartDelay);
+    });
+}

package/nuxt.config.ts

@@ -0,0 +1,96 @@
+import { eruditPath, projectPath } from './globalPath';
+
+export default defineNuxtConfig({
+    compatibilityDate: '2025-01-01',
+    devtools: { enabled: true },
+    future: { compatibilityVersion: 4 },
+    ssr: true,
+    alias: {
+        '@erudit': eruditPath(),
+        '@module': eruditPath('module'),
+        '@server': eruditPath('server/plugin'),
+        '@shared': eruditPath('shared'),
+        '@app': eruditPath('app'),
+        $: eruditPath('app/styles'),
+    },
+    modules: [eruditPath('module'), 'nuxt-my-icons'],
+    myicons: {
+        iconsDir: eruditPath('app/assets/icons'),
+    },
+    typescript: {
+        tsConfig: {
+            include: [eruditPath('**/*'), projectPath('**/*')],
+        },
+    },
+    ignore: [
+        // Content assets
+        ...[
+            '**/{book,group,topic}.{js,ts}',
+            '**/{article,summary,practice,content}.bi',
+        ].map((pattern) => projectPath(`content/${pattern}`)),
+        // Contributors assets
+        ...['*/contributor.{js,ts}', '*/description.bi'].map((pattern) =>
+            projectPath(`contributors/${pattern}`),
+        ),
+    ],
+    nitro: {
+        plugins: [eruditPath('server/plugin')],
+        prerender: {
+            failOnError: false,
+        },
+        output: {
+            publicDir: projectPath('dist'),
+        },
+        publicAssets: [
+            {
+                baseURL: '/_erudit-asset/',
+                dir: eruditPath('app/public'),
+                maxAge: 60 * 60 * 24 * 30,
+            },
+            {
+                baseURL: '/_user-asset/public/',
+                dir: projectPath('public'),
+                maxAge: 60 * 60 * 24 * 30,
+            },
+            {
+                baseURL: '/_user-asset/content/',
+                dir: projectPath('content'),
+                maxAge: 60 * 60 * 24 * 30,
+            },
+            {
+                baseURL: '/_user-asset/contributor/',
+                dir: projectPath('contributors'),
+                maxAge: 60 * 60 * 24 * 30,
+            },
+        ],
+        esbuild: {
+            options: {
+                tsconfigRaw: {
+                    compilerOptions: {
+                        experimentalDecorators: true, // Make TypeORM work with Nuxt
+                    },
+                },
+            },
+        },
+    },
+    vite: {
+        optimizeDeps: {
+            include: [
+                '@floating-ui/vue',
+                'bitran',
+                'bitran/core',
+                'bitran/render',
+                'yaml',
+                'slugify',
+            ],
+        },
+        css: {
+            preprocessorOptions: {
+                scss: {
+                    api: 'modern-compiler',
+                    additionalData: `@use '$/utils' as *;`,
+                },
+            },
+        },
+    },
+});

package/package.json

@@ -0,0 +1,32 @@
+{
+    "name": "erudit",
+    "version": "2.0.0-dev.7",
+    "type": "module",
+    "description": "🤓 CMS for perfect educational sites.",
+    "license": "MIT",
+    "main": "./nuxt.config.ts",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/erudit-js/erudit.git",
+        "directory": "packages/erudit"
+    },
+    "dependencies": {
+        "@floating-ui/vue": "^1.1.6",
+        "bitran": "^3.0.0-dev.3",
+        "chalk": "^5.4.1",
+        "chokidar": "^4.0.3",
+        "consola": "^3.4.0",
+        "erudit-cli": "1.0.0-dev.6",
+        "erudit-cog": "1.0.0-dev.3",
+        "glob": "^11.0.1",
+        "image-size": "^1.2.0",
+        "nuxt": "3.15.4",
+        "nuxt-my-icons": "1.0.2",
+        "sass": "^1.84.0",
+        "slugify": "^1.6.6",
+        "sqlite3": "^5.1.7",
+        "typeorm": "^0.3.20",
+        "vue": "latest",
+        "vue-router": "latest"
+    }
+}

package/server/api/aside/major/nav/bookIds.ts

@@ -0,0 +1,5 @@
+import { ERUDIT_SERVER } from '@server/global';
+
+export default defineEventHandler(() => {
+    return Object.keys(ERUDIT_SERVER.NAV_BOOKS || {});
+});

package/server/api/aside/major/nav/bookNav/[...bookId].ts

@@ -0,0 +1,20 @@
+import { ERUDIT_SERVER } from '@server/global';
+import { createBookFrontNav } from '@server/repository/frontNav';
+
+export default defineEventHandler(async (event) => {
+    const bookId = getRouterParam(event, 'bookId');
+
+    if (
+        !bookId ||
+        !ERUDIT_SERVER.NAV_BOOKS ||
+        !(bookId in ERUDIT_SERVER.NAV_BOOKS)
+    )
+        throw createError({
+            statusCode: 400,
+            statusText: `Unknown book id "${bookId}"!`,
+        });
+
+    const bookNode = ERUDIT_SERVER.NAV_BOOKS[bookId]!;
+
+    return await createBookFrontNav(bookNode);
+});

package/server/api/aside/major/nav/global.ts

@@ -0,0 +1,7 @@
+import type { FrontNav } from '@erudit/shared/frontNav';
+import { ERUDIT_SERVER } from '@server/global';
+import { createGlobalFrontNav } from '@server/repository/frontNav';
+
+export default defineEventHandler(async () => {
+    return (await createGlobalFrontNav(ERUDIT_SERVER.NAV, false)) as FrontNav;
+});

package/server/api/aside/minor/news.ts

@@ -0,0 +1,7 @@
+import type { AsideMinorNews } from '@shared/aside/minor';
+
+export default defineEventHandler(async () => {
+    return <AsideMinorNews>{
+        type: 'news',
+    };
+});

package/server/api/aside/minor/path.ts

@@ -0,0 +1,78 @@
+import { isTopicPart } from 'erudit-cog/schema';
+
+import type { AsideMinorContent, AsideMinorTopic } from '@shared/aside/minor';
+import { getBitranToc } from '@erudit/server/plugin/bitran/toc';
+import {
+    getContentContributors,
+    getFullContentId,
+    getPreviousNext,
+} from '@erudit/server/plugin/repository/content';
+import { getTopicPartsLinks } from '@erudit/server/plugin/repository/topic';
+import { locationFromPath } from '@erudit/shared/bitran/location';
+
+export default defineEventHandler(async (event) => {
+    const query = getQuery<{ path: string }>(event);
+
+    if (!query.path)
+        throw createError({
+            statusCode: 400,
+            statusText: 'Missing "path" query parameter!',
+        });
+
+    const path = query.path.substring(1);
+    const pathStart = path.split('/')[0];
+
+    if (isTopicPart(pathStart)) return await createTopicData(path);
+
+    if (['book', 'group'].includes(pathStart))
+        return await createContentData(pathStart, path);
+
+    return 'news';
+});
+
+async function createTopicData(path: string): Promise<AsideMinorTopic> {
+    const location = locationFromPath(path);
+
+    if (!location)
+        throw createError({
+            statusCode: 400,
+            statusText: `Provided path "${path}" is not a valid topic location!`,
+        });
+
+    const contentId = location.path;
+    const fullContentId = (await getFullContentId(contentId))!;
+
+    const toc = await getBitranToc(location);
+    const previousNext = await getPreviousNext(contentId);
+    const topicPartsLinks = await getTopicPartsLinks(contentId);
+    const contributors = await getContentContributors(contentId);
+
+    return {
+        type: 'topic',
+        fullContentId,
+        location,
+        toc,
+        nav: {
+            ...previousNext,
+            ...topicPartsLinks,
+        },
+        contributors,
+    };
+}
+
+async function createContentData(
+    type: string,
+    path: string,
+): Promise<AsideMinorContent> {
+    const contentId = path.split('/').slice(1).join('/');
+    const fullContentId = (await getFullContentId(contentId))!;
+    const previousNext = await getPreviousNext(contentId);
+    const contributors = await getContentContributors(contentId);
+
+    return {
+        type: type as any,
+        fullContentId,
+        nav: previousNext,
+        contributors,
+    };
+}

package/server/api/bitran/content/[location].ts

@@ -0,0 +1,7 @@
+import { parseUrlLocation } from '@server/bitran/location';
+import { getBitranContent } from '@server/bitran/content';
+
+export default defineEventHandler(async (event) => {
+    const location = parseUrlLocation(getRouterParam(event, 'location') || '');
+    return await getBitranContent(location);
+});

package/server/api/bitran/toc/[location].ts

@@ -0,0 +1,7 @@
+import { parseUrlLocation } from '@server/bitran/location';
+import { getBitranToc } from '@server/bitran/toc';
+
+export default defineEventHandler(async (event) => {
+    const location = parseUrlLocation(getRouterParam(event, 'location') || '');
+    return await getBitranToc(location);
+});

package/server/api/content/data.ts

@@ -0,0 +1,72 @@
+import { getTopicPartsLinks } from '@server/repository/topic';
+import { getContentBookFor } from '@server/repository/book';
+import { getContentGenericData } from '@server/repository/content';
+
+import type { ContentGenericData } from '@shared/content/data/base';
+import type { ContentTopicData } from '@shared/content/data/type/topic';
+import type { ContentGroupData } from '@shared/content/data/type/group';
+import type { ContentBookData } from '@shared/content/data/type/book';
+
+export default defineEventHandler(async (event) => {
+    const contentId = getQuery(event)?.contentId as string;
+
+    if (!contentId)
+        throw createError({
+            statusCode: 400,
+            statusText: 'Missing content ID!',
+        });
+
+    const generic = await getContentGenericData(contentId);
+
+    switch (generic.type) {
+        case 'topic':
+            return await getTopicData(generic);
+        case 'group':
+            return await getGroupData(generic);
+        case 'book':
+            return await getBookData(generic);
+    }
+
+    throw createError({
+        statusCode: 400,
+        statusText: `Unknown content data type "${generic.type}"!`,
+    });
+});
+
+//
+//
+//
+
+async function getTopicData(
+    generic: ContentGenericData,
+): Promise<ContentTopicData> {
+    const contentBook = await getContentBookFor(generic.contentId);
+
+    return {
+        type: 'topic',
+        generic,
+        bookTitle: contentBook?.title,
+        topicPartLinks: await getTopicPartsLinks(generic.contentId),
+    };
+}
+
+async function getGroupData(
+    generic: ContentGenericData,
+): Promise<ContentGroupData> {
+    const contentBook = await getContentBookFor(generic.contentId);
+
+    return {
+        type: 'group',
+        generic,
+        bookTitle: contentBook?.title,
+    };
+}
+
+async function getBookData(
+    generic: ContentGenericData,
+): Promise<ContentBookData> {
+    return {
+        type: 'book',
+        generic,
+    };
+}

package/server/api/contributor/count.ts

@@ -0,0 +1,6 @@
+import { DbContributor } from '@server/db/entities/Contributor';
+import { ERUDIT_SERVER } from '@server/global';
+
+export default defineEventHandler(async () => {
+    return await ERUDIT_SERVER.DB.manager.count(DbContributor);
+});

package/server/api/fake/content.ts

@@ -0,0 +1,11 @@
+export default defineEventHandler(() => {
+    return {
+        commit: {
+            commit: {
+                author: {
+                    date: '2019-08-30T14:57:06.000Z'
+                }
+            }
+        }
+    }
+});

package/server/api/fake/shared/languages.ts

@@ -0,0 +1,12 @@
+export default defineEventHandler(() => {
+    return {
+        en: {
+            name: 'English',
+            link: 'https://en.omath.net',
+        },
+        ru: {
+            name: 'Русский',
+            link: 'https://omath.ru',
+        },
+    };
+});

package/server/api/language/functions.ts

@@ -0,0 +1,12 @@
+import { ERUDIT_SERVER } from '@server/global';
+
+export default defineEventHandler(() => {
+    const strFunctions: Record<string, string> = {};
+
+    for (const [key, func] of Object.entries(
+        ERUDIT_SERVER.LANGUAGE?.functions || {},
+    ))
+        strFunctions[key] = 'return ' + func.toString();
+
+    return strFunctions;
+});

package/server/api/language/phrase/[phraseId].ts

@@ -0,0 +1,19 @@
+import type { EruditPhraseId } from '@shared/types/language';
+import { ERUDIT_SERVER } from '@server/global';
+
+export default defineEventHandler((event) => {
+    const phraseId = getRouterParam(event, 'phraseId');
+    const phrase =
+        ERUDIT_SERVER.LANGUAGE?.phrases?.[phraseId as EruditPhraseId];
+
+    setResponseHeader(event, 'content-type', 'text/plain');
+
+    if (typeof phrase === 'string') return phrase;
+    else if (typeof phrase === 'function')
+        return '~!~FUNC~!~' + 'return ' + phrase.toString();
+
+    throw createError({
+        statusCode: 400,
+        statusText: `Unknown phrase id "${phraseId}"!`,
+    });
+});

package/server/api/language/phraseIds.ts

@@ -0,0 +1,8 @@
+import { ERUDIT_SERVER } from '@server/global';
+import type { EruditPhraseId } from '@shared/types/language';
+
+export default defineEventHandler(() => {
+    return Object.keys(
+        ERUDIT_SERVER.LANGUAGE?.phrases || [],
+    ) as EruditPhraseId[];
+});