erudit 3.0.0-dev.2 → 3.0.0-dev.20

package/server/plugin/bitran/toc.ts

@@ -1,83 +1,94 @@
-import { BlockErrorNode, type ElementNode } from '@bitran-js/core';
-import { IncludeNode } from '@erudit-js/bitran-elements/include/shared';
-import {
-    headingName,
-    HeadingNode,
-} from '@erudit-js/bitran-elements/heading/shared';
-
-import type { BitranLocation } from '@erudit/shared/bitran/location';
-import type { Toc } from '@erudit/shared/bitran/toc';
-import { ERUDIT_SERVER } from '@server/global';
-import { getRawBitranContent } from './content';
-import { createBitranTranspiler } from './transpiler';
-import { traverseInclude } from './products/include';
-
-export async function getBitranToc(location: BitranLocation) {
-    const rawContent = await getRawBitranContent(location);
-    const bitranCore = await createBitranTranspiler();
-
-    const toc: Toc = [];
-
-    await bitranCore.parser.parse(rawContent.biCode, {
-        async step(node) {
-            if (node instanceof IncludeNode) {
-                await traverseInclude(node, rawContent.context, {
-                    step: async ({ _node }) => tryAddToToc(_node),
-                });
-            } else tryAddToToc(node);
-        },
-    });
-
-    return toc;
-
-    function tryAddToToc(node: ElementNode) {
-        const tocItemBase = {
-            id: node.id,
-            productName: node.name,
-        };
-
-        // Check if node is manually excluded from TOC
-        if (typeof node.meta?.toc === 'boolean' && !node.meta?.toc) return;
-
-        if (node instanceof HeadingNode) {
-            toc.push({
-                ...tocItemBase,
-                level: node.parseData.level,
-                title: node.parseData.title,
-            });
-            return;
-        }
-
-        const notHeadingLevel = () => {
-            // Toc items without heading are at top level
-            if (toc.length === 0) return 0;
-
-            const lastTocItem = toc.at(-1)!;
-
-            // Going one level deep if previous item was a heading and copy deep level if not
-            return lastTocItem.productName === headingName
-                ? lastTocItem.level + 1
-                : lastTocItem.level;
-        };
-
-        if (ERUDIT_SERVER.BITRAN_CONFIG?.toc?.includes(node.name)) {
-            // Erudit Config says to add these products to TOC
-            toc.push({
-                ...tocItemBase,
-                level: notHeadingLevel(),
-                title: node.meta?.title || node.parseData?.title,
-            });
-            return;
-        }
-
-        if (node.meta?.toc) {
-            // Show in Toc any product with truthy `toc` meta property
-            toc.push({
-                ...tocItemBase,
-                level: notHeadingLevel(),
-                title: node.meta?.title || node.parseData?.title,
-            });
-            return;
-        }
-    }
-}
+import { type ElementNode } from '@bitran-js/core';
+import { NO_ALIASES, type BitranLocation } from '@erudit-js/cog/schema';
+import {
+    headingName,
+    HeadingNode,
+} from '@erudit-js/bitran-elements/heading/shared';
+import {
+    ProblemNode,
+    ProblemsNode,
+} from '@erudit-js/bitran-elements/problem/shared';
+
+import type { Toc } from '@erudit/shared/bitran/toc';
+import { ERUDIT_SERVER } from '@server/global';
+import { getBitranContent } from './content';
+import { createBitranTranspiler } from './transpiler';
+
+export async function getBitranToc(location: BitranLocation) {
+    const content = await getBitranContent(location, false);
+
+    const bitranCore = await createBitranTranspiler({
+        eruditConfig: ERUDIT_SERVER.CONFIG,
+        insideInclude: false,
+        context: { aliases: NO_ALIASES(), location },
+    });
+
+    const toc: Toc = [];
+
+    await bitranCore.parser.parse(content.biCode, {
+        async step(node) {
+            tryAddToToc(node as ElementNode);
+        },
+    });
+
+    return toc;
+
+    function tryAddToToc(node: ElementNode) {
+        const tocItemBase = {
+            id: node.id,
+            productName: node.name,
+        };
+
+        // Check if node is manually excluded from TOC
+        if (typeof node.meta?.toc === 'boolean' && !node.meta?.toc) return;
+
+        if (node instanceof HeadingNode) {
+            toc.push({
+                ...tocItemBase,
+                level: node.parseData.level - 1,
+                title: node.parseData.title,
+            });
+            return;
+        }
+
+        const notHeadingLevel = () => {
+            // If TOC is empty, we're at the root level
+            if (toc.length === 0) return 0;
+
+            // Find the most recent heading to determine parent level
+            for (let i = toc.length - 1; i >= 0; i--) {
+                if (toc[i].productName === headingName) {
+                    // Found a heading, return its level + 1
+                    return toc[i].level + 1;
+                }
+            }
+
+            // No heading found in TOC, place at root level
+            return 0;
+        };
+
+        // Problems by default are in TOC
+        if (node instanceof ProblemsNode || node instanceof ProblemNode) {
+            toc.push({
+                ...tocItemBase,
+                level: notHeadingLevel(),
+                title: node.meta?.title || node.parseData.info.title,
+            });
+            return;
+        }
+
+        if (
+            ERUDIT_SERVER.CONFIG.bitran?.toc?.includes(node.name) ||
+            node.meta?.toc
+        ) {
+            // Erudit Bitran config says to add these products to TOC
+            // Or show in TOC any product with truthy `toc` meta property
+            toc.push({
+                ...tocItemBase,
+                level: notHeadingLevel(),
+                title: node.meta?.title || node.parseData?.title,
+            });
+            return;
+        }
+    }
+}

package/server/plugin/bitran/transpiler.ts

@@ -1,46 +1,18 @@
-import {
-    defineBitranTranspiler,
-    type ElementTranspilers,
-} from '@bitran-js/transpiler';
-
-import { ERUDIT_SERVER } from '@server/global';
-
-// Default Elements
-import { aliasesName } from '@erudit-js/bitran-elements/aliases/shared';
-import { aliasesTranspiler } from '@erudit-js/bitran-elements/aliases/transpiler';
-import { headingName } from '@erudit-js/bitran-elements/heading/shared';
-import { headingTranspiler } from '@erudit-js/bitran-elements/heading/transpiler';
-import { includeName } from '@erudit-js/bitran-elements/include/shared';
-import { includeTranspiler } from '@erudit-js/bitran-elements/include/transpiler';
-import { linkName } from '@erudit/shared/bitran/link/shared';
-import { linkTranspiler } from '@erudit/shared/bitran/link/transpiler';
-
-export async function createBitranTranspiler() {
-    const projectTranspilers = await getProjectTranspilers();
-
-    const defaultTranspilers = {
-        [aliasesName]: aliasesTranspiler,
-        [includeName]: includeTranspiler,
-        [headingName]: headingTranspiler,
-        [linkName]: linkTranspiler,
-    };
-
-    const bitranTranspiler = defineBitranTranspiler({
-        ...projectTranspilers,
-        ...defaultTranspilers,
-    });
-
-    return bitranTranspiler;
-}
-
-async function getProjectTranspilers(): Promise<ElementTranspilers> {
-    const bitranElements = ERUDIT_SERVER?.BITRAN_CONFIG?.elements;
-
-    if (!bitranElements) return {};
-
-    const projectTranspilers: ElementTranspilers = {};
-    for (const [name, bitranElement] of Object.entries(bitranElements))
-        projectTranspilers[name] = await bitranElement.transpiler();
-
-    return projectTranspilers;
-}
+import { defineBitranTranspiler } from '@bitran-js/transpiler';
+import {
+    setEruditBitranRuntime,
+    type EruditBitranRuntime,
+} from '@erudit-js/cog/schema';
+
+import getServerTranspilers from '#erudit/bitran/server';
+
+export async function createBitranTranspiler(runtime: EruditBitranRuntime) {
+    const serverTranspiler = await getServerTranspilers();
+    const bitranTranspiler = defineBitranTranspiler(serverTranspiler);
+
+    [bitranTranspiler.parser, bitranTranspiler.stringifier].forEach((item) => {
+        setEruditBitranRuntime(item, runtime);
+    });
+
+    return bitranTranspiler;
+}

package/server/plugin/build/close.ts

@@ -1,10 +1,12 @@
-import { debug, logger } from '@server/logger';
-import { ERUDIT_SERVER } from '@server/global';
-
-export async function close() {
-    debug.start('Shutting down server...');
-
-    await ERUDIT_SERVER.DB?.destroy();
-
-    logger.success('Server shut down gracefully!');
-}
+import { debug, logger } from '@server/logger';
+import { ERUDIT_SERVER } from '@server/global';
+
+export async function close() {
+    debug.start('Shutting down server...');
+
+    if (ERUDIT_SERVER.DB && ERUDIT_SERVER.DB.isInitialized) {
+        await ERUDIT_SERVER.DB.destroy();
+    }
+
+    logger.success('Server shut down gracefully!');
+}

package/server/plugin/build/jobs/content/builderArgs.ts

@@ -1,8 +1,8 @@
-import type { DbContent } from '@server/db/entities/Content';
-import type { NavNode } from '@server/nav/node';
-
-export interface BuilderFunctionArgs<T = any> {
-    navNode: NavNode;
-    dbContent: DbContent;
-    config?: Partial<T>;
-}
+import type { DbContent } from '@server/db/entities/Content';
+import type { NavNode } from '@server/nav/node';
+
+export interface BuilderFunctionArgs<T = any> {
+    navNode: NavNode;
+    dbContent: DbContent;
+    config?: Partial<T>;
+}

package/server/plugin/build/jobs/content/generic.ts

@@ -1,176 +1,191 @@
-import { existsSync } from 'node:fs';
-import { globSync } from 'glob';
-import chalk from 'chalk';
-import sizeOf from 'image-size';
-import {
-    contentTypes,
-    type ContentConfig,
-    type ContentReferences,
-    type ContentType,
-} from 'erudit-cog/schema';
-import { resolvePaths } from 'erudit-cog/kit';
-
-import { PROJECT_DIR } from '#erudit/globalPaths';
-import { stress } from '@erudit/utils/stress';
-
-import { debug, logger } from '@server/logger';
-import { ERUDIT_SERVER } from '@server/global';
-import { walkNav } from '@server/nav/utils';
-import { isRootNode, type NavNode } from '@server/nav/node';
-import { DbContent } from '@server/db/entities/Content';
-import { IMPORT } from '@server/importer';
-import { contributorExists } from '@server/repository/contributor';
-import { DbContribution } from '@server/db/entities/Contribution';
-
-import { contentAsset } from '@erudit/shared/asset';
-import type { ImageData } from '@erudit/shared/image';
-
-import type { BuilderFunctionArgs } from './builderArgs';
-import { contentItemPath } from './path';
-import { buildBook } from './type/book';
-import { buildGroup } from './type/group';
-import { buildTopic } from './type/topic';
-
-const typeBuilders: Record<ContentType, Function> = {
-    book: buildBook,
-    group: buildGroup,
-    topic: buildTopic,
-};
-
-export async function buildContent() {
-    if (!ERUDIT_SERVER.NAV) return;
-
-    debug.start('Building content...');
-
-    const counters: Record<ContentType, number> = Object.fromEntries(
-        contentTypes.map((contentType) => [contentType, 0]),
-    ) as any;
-
-    await walkNav(async (node) => {
-        if (isRootNode(node)) return;
-        counters[node.type]++;
-        await addContentItem(node);
-    });
-
-    logger.success(
-        'Content built successfully!',
-        chalk.dim(
-            '(' +
-                Object.entries(counters)
-                    .map(([k, v]) => `${k.at(0)!.toUpperCase()}: ${v}`)
-                    .join(', ') +
-                ')',
-        ),
-    );
-}
-
-async function addContentItem(navNode: NavNode) {
-    debug.start(
-        `Adding ${stress(navNode.type)} content item ${stress(navNode.id)}...`,
-    );
-
-    const dbContent = new DbContent();
-    dbContent.contentId = navNode.id;
-    dbContent.fullId = navNode.fullId;
-    dbContent.type = navNode.type;
-    dbContent.decoration = getDecoration(navNode);
-    dbContent.ogImage = getOgImageData(navNode);
-    dbContent.references = await getContentReferences(navNode);
-
-    let config: Partial<ContentConfig> | undefined;
-
-    try {
-        config = (await IMPORT(contentItemPath(navNode, navNode.type), {
-            default: true,
-        })) as Partial<ContentConfig>;
-
-        dbContent.title = config.title;
-        dbContent.navTitle = config.navTitle;
-        dbContent.description = config.description;
-        dbContent.flags = config.flags;
-        dbContent.dependencies = config.dependencies;
-
-        if (config.seo) {
-            dbContent.seo = {
-                title: config.seo?.title,
-                description: config.seo?.description,
-            };
-        }
-
-        await addContributions(navNode, config.contributors);
-    } catch {}
-
-    await ERUDIT_SERVER.DB.manager.save(dbContent);
-
-    await typeBuilders[navNode.type](<BuilderFunctionArgs>{
-        navNode,
-        dbContent,
-        config,
-    });
-}
-
-function getDecoration(navNode: NavNode) {
-    if (existsSync(contentItemPath(navNode, 'decoration.svg')))
-        return `/${navNode.path}/decoration.svg`;
-
-    return undefined;
-}
-
-async function addContributions(navNode: NavNode, contributors?: string[]) {
-    if (!contributors || !contributors.length) {
-        if (navNode.type !== 'book' && navNode.type !== 'group')
-            logger.warn(
-                `${navNode.type.at(0)!.toUpperCase() + navNode.type.slice(1)} ${stress(navNode.id)} has no contributors!`,
-            );
-
-        return;
-    }
-
-    for (const contributorId of contributors) {
-        if (!(await contributorExists(contributorId))) {
-            logger.warn(
-                `Skipping unknown contributor ${stress(contributorId)} when adding ${navNode.type} ${stress(navNode.id)}!`,
-            );
-            continue;
-        }
-
-        const dbContribution = new DbContribution();
-        dbContribution.contentId = navNode.id;
-        dbContribution.contributorId = contributorId;
-        await ERUDIT_SERVER.DB.manager.save(dbContribution);
-    }
-}
-
-function getOgImageData(navNode: NavNode): ImageData | undefined {
-    const ogImagePath = globSync(
-        contentItemPath(navNode, 'og-image.{svg,webp,jpg,png}'),
-    ).pop();
-
-    if (ogImagePath) {
-        const size = sizeOf(ogImagePath);
-        return {
-            src: contentAsset(
-                resolvePaths(ogImagePath).replace(
-                    PROJECT_DIR + '/content/',
-                    '',
-                ),
-            ),
-            width: size.width!,
-            height: size.height!,
-        };
-    }
-
-    return undefined;
-}
-
-async function getContentReferences(navNode: NavNode) {
-    try {
-        const references = await IMPORT(
-            contentItemPath(navNode, `references`),
-            { default: true },
-        );
-        return references as ContentReferences;
-    } catch (error) {}
-
-    return undefined;
-}
+import { existsSync } from 'node:fs';
+import { globSync } from 'glob';
+import chalk from 'chalk';
+import { imageSizeFromFile } from 'image-size/fromFile';
+import {
+    contentTypes,
+    type ContentConfig,
+    type ContentReferences,
+    type ContentType,
+} from '@erudit-js/cog/schema';
+import { resolvePaths } from '@erudit-js/cog/kit';
+
+import { PROJECT_DIR } from '#erudit/globalPaths';
+import { scanContentPaths } from '@erudit/utils/contentPath';
+import { stress } from '@erudit/utils/stress';
+
+import { debug, logger } from '@server/logger';
+import { ERUDIT_SERVER } from '@server/global';
+import { walkNav } from '@server/nav/utils';
+import { isRootNode, type NavNode } from '@server/nav/node';
+import { DbContent } from '@server/db/entities/Content';
+import { IMPORT } from '@server/importer';
+import { contributorExists } from '@server/repository/contributor';
+import { DbContribution } from '@server/db/entities/Contribution';
+import { DbFile } from '@server/db/entities/File';
+
+import { contentAsset } from '@erudit/shared/asset';
+import type { ImageData } from '@erudit/shared/image';
+
+import type { BuilderFunctionArgs } from './builderArgs';
+import { contentItemPath } from './path';
+import { buildBook } from './type/book';
+import { buildGroup } from './type/group';
+import { buildTopic } from './type/topic';
+
+const typeBuilders: Record<ContentType, Function> = {
+    book: buildBook,
+    group: buildGroup,
+    topic: buildTopic,
+};
+
+export async function buildContent() {
+    if (!ERUDIT_SERVER.NAV) return;
+
+    debug.start('Building content...');
+
+    await scanContentFiles();
+
+    const counters: Record<ContentType, number> = Object.fromEntries(
+        contentTypes.map((contentType) => [contentType, 0]),
+    ) as any;
+
+    await walkNav(async (node) => {
+        if (isRootNode(node)) return;
+        counters[node.type]++;
+        await addContentItem(node);
+    });
+
+    logger.success(
+        'Content built successfully!',
+        chalk.dim(
+            '(' +
+                Object.entries(counters)
+                    .map(([k, v]) => `${k.at(0)!.toUpperCase()}: ${v}`)
+                    .join(', ') +
+                ')',
+        ),
+    );
+}
+
+async function scanContentFiles() {
+    const contentFiles = scanContentPaths(PROJECT_DIR + '/content');
+    for (const [path, fullPath] of Object.entries(contentFiles)) {
+        const dbFile = new DbFile();
+        dbFile.path = path;
+        dbFile.fullPath = fullPath;
+        await ERUDIT_SERVER.DB.manager.save(dbFile);
+    }
+}
+
+async function addContentItem(navNode: NavNode) {
+    debug.start(
+        `Adding ${stress(navNode.type)} content item ${stress(navNode.shortId)}...`,
+    );
+
+    const dbContent = new DbContent();
+    dbContent.contentId = navNode.fullId;
+    dbContent.type = navNode.type;
+    dbContent.decoration = getDecoration(navNode);
+    dbContent.ogImage = await getOgImageData(navNode);
+    dbContent.references = await getContentReferences(navNode);
+
+    let config: Partial<ContentConfig> | undefined;
+
+    try {
+        config = (await IMPORT(contentItemPath(navNode, navNode.type), {
+            default: true,
+        })) as Partial<ContentConfig>;
+
+        dbContent.title = config.title;
+        dbContent.navTitle = config.navTitle;
+        dbContent.description = config.description;
+        dbContent.flags = config.flags;
+        dbContent.dependencies = config.dependencies;
+
+        if (config.seo) {
+            dbContent.seo = {
+                title: config.seo?.title,
+                description: config.seo?.description,
+            };
+        }
+
+        await addContributions(navNode, config.contributors);
+    } catch {}
+
+    await ERUDIT_SERVER.DB.manager.save(dbContent);
+
+    await typeBuilders[navNode.type](<BuilderFunctionArgs>{
+        navNode,
+        dbContent,
+        config,
+    });
+}
+
+function getDecoration(navNode: NavNode) {
+    if (existsSync(contentItemPath(navNode, 'decoration.svg')))
+        return `/${navNode.fsPath}/decoration.svg`;
+
+    return undefined;
+}
+
+async function addContributions(navNode: NavNode, contributors?: string[]) {
+    if (!contributors || !contributors.length) {
+        if (navNode.type !== 'book' && navNode.type !== 'group')
+            logger.warn(
+                `${navNode.type.at(0)!.toUpperCase() + navNode.type.slice(1)} ${stress(navNode.fullId)} has no contributors!`,
+            );
+
+        return;
+    }
+
+    for (const contributorId of contributors) {
+        if (!(await contributorExists(contributorId))) {
+            logger.warn(
+                `Skipping unknown contributor ${stress(contributorId)} when adding ${navNode.type} ${stress(navNode.fullId)}!`,
+            );
+            continue;
+        }
+
+        const dbContribution = new DbContribution();
+        dbContribution.contentId = navNode.fullId;
+        dbContribution.contributorId = contributorId;
+        await ERUDIT_SERVER.DB.manager.save(dbContribution);
+    }
+}
+
+async function getOgImageData(
+    navNode: NavNode,
+): Promise<ImageData | undefined> {
+    const ogImagePath = globSync(
+        contentItemPath(navNode, 'og-image.{svg,webp,jpg,png}'),
+    ).pop();
+
+    if (ogImagePath) {
+        const size = await imageSizeFromFile(ogImagePath);
+        return {
+            src: contentAsset(
+                resolvePaths(ogImagePath).replace(
+                    PROJECT_DIR + '/content/',
+                    '',
+                ),
+            ),
+            width: size.width,
+            height: size.height,
+        };
+    }
+
+    return undefined;
+}
+
+async function getContentReferences(navNode: NavNode) {
+    try {
+        const references = await IMPORT(
+            contentItemPath(navNode, `references`),
+            { default: true },
+        );
+        return references as ContentReferences;
+    } catch (error) {}
+
+    return undefined;
+}