erudit 3.0.0-dev.1 → 3.0.0-dev.10

package/server/plugin/bitran/{products → elements}/include.ts

@@ -1,230 +1,216 @@
-import { BlockNode, type ElementNode } from '@bitran-js/core';
-import type { BitranTranspiler } from '@bitran-js/transpiler';
-import { IncludeNode } from '@erudit-js/bitran-elements/include/shared';
-import {
-    AliasesNode,
-    tryReplaceAlias,
-    type Aliases,
-} from '@erudit-js/bitran-elements/aliases/shared';
-
-import { createBitranTranspiler } from '@server/bitran/transpiler';
-import { ERUDIT_SERVER } from '@server/global';
-import { DbUnique } from '@server/db/entities/Unique';
-import {
-    toAbsoluteContentId,
-    toAbsoluteContentLocation,
-} from '@server/content/absoluteId';
-
-import type { BitranContext } from '@erudit/shared/bitran/context';
-import {
-    parseBitranLocation,
-    parsePartialBitranLocation,
-    stringifyBitranLocation,
-} from '@erudit/shared/bitran/location';
-import { createLinkTarget } from '@erudit/shared/bitran/link/target';
-import { LinkNode } from '@erudit/shared/bitran/link/shared';
-
-export type TraverseEnterFn = (payload: {
-    _location: string;
-    _bitranTranspiler: BitranTranspiler;
-    _biCode: string;
-}) => Promise<any>;
-
-export type TraverseStepFn = (payload: {
-    _location: string;
-    _bitranTranspiler: BitranTranspiler;
-    _node: ElementNode;
-}) => Promise<any>;
-
-export type TraverseLeaveFn = (payload: { _location: string }) => Promise<any>;
-
-/**
- * This operation is heavy as fuck.
- * It consumes a lot of memory and is slow.
- * Use as rarely as possible!
- */
-export async function traverseInclude(
-    includeNode: IncludeNode,
-    context: BitranContext,
-    listeners: {
-        enter?: TraverseEnterFn;
-        step?: TraverseStepFn;
-        leave?: TraverseLeaveFn;
-    },
-) {
-    const entryLocation = stringifyBitranLocation(
-        parsePartialBitranLocation(includeNode.id, context.location),
-    );
-
-    const travelMap: Record<string, string | null> = {
-        // Not displayed when error, but needed for checking infinite loops
-        [entryLocation]: null,
-    };
-
-    try {
-        await _traverseStep(
-            includeNode,
-            entryLocation,
-            context.aliases,
-            listeners,
-            travelMap,
-        );
-    } catch (message) {
-        let finalMessage = `Include Traversal Error!\n\n${message}\n\n`;
-
-        for (const [location, includeTarget] of Object.entries(
-            travelMap,
-        ).reverse()) {
-            if (includeTarget === null) continue;
-
-            finalMessage += `at "${printIncludeTarget(includeTarget)}" in "${location}"\n`;
-        }
-
-        throw new Error(finalMessage);
-    }
-}
-
-async function _traverseStep(
-    includeNode: IncludeNode,
-    location: string,
-    aliases: Aliases,
-    listeners: {
-        enter?: TraverseEnterFn;
-        step?: TraverseStepFn;
-        leave?: TraverseLeaveFn;
-    },
-    travelMap: Record<string, string | null>,
-) {
-    let includeTargetLocation: string;
-
-    try {
-        const parsedLocation = parseBitranLocation(location);
-
-        includeTargetLocation = stringifyBitranLocation(
-            parsePartialBitranLocation(
-                tryReplaceAlias(includeNode.parseData.location, aliases),
-                parsedLocation,
-            ),
-        );
-
-        includeTargetLocation = toAbsoluteContentLocation(
-            includeTargetLocation,
-            parsedLocation.path!,
-        );
-    } catch (error) {
-        travelMap[location] = includeNode.parseData.location;
-        throw error;
-    }
-
-    if (includeTargetLocation in travelMap)
-        throw `Include "${printIncludeTarget(includeNode.parseData.location)}" targets "${includeTargetLocation}" which creates infinite loop!`;
-
-    travelMap[location] = includeNode.parseData.location;
-
-    //
-    // Loading Unique this Include is referencing to.
-    //
-
-    const dbUnique = await ERUDIT_SERVER.DB.manager.findOne(DbUnique, {
-        where: { location: includeTargetLocation },
-    });
-
-    if (!dbUnique)
-        throw `Include "${printIncludeTarget(includeNode.parseData.location)}" is targeting to non-existing unique "${includeTargetLocation}"!`;
-
-    //
-    // Creating Bitran core within loaded unique's location context.
-    //
-
-    const context: BitranContext = {
-        location: parseBitranLocation(includeTargetLocation),
-        aliases: dbUnique.context.aliases,
-    };
-
-    const bitranTranspiler = await createBitranTranspiler();
-
-    listeners.enter &&
-        (await listeners.enter({
-            _biCode: dbUnique.content,
-            _location: includeTargetLocation,
-            _bitranTranspiler: bitranTranspiler,
-        }));
-
-    //
-    // Parsing unique content and sub-traversing all includes if any.
-    //
-
-    let stepErrorMessage: string | undefined;
-
-    await bitranTranspiler.parser.parse(dbUnique.content, {
-        step: async (node) => {
-            if (stepErrorMessage) return;
-
-            // Skip Alias nodes to prevent them being injected into calling document context and possibly conflicting with other aliases, includes and links...
-            if (node instanceof AliasesNode) return;
-
-            // Replacing block ids with absolute ones to make possible to link to them
-            if (node instanceof BlockNode)
-                node.meta.id = Object.keys(travelMap)
-                    .concat([location])
-                    .join('__');
-
-            if (node instanceof LinkNode) {
-                const linkTarget = createLinkTarget(node.parseData.target, {
-                    location: context.location,
-                    aliases: context.aliases ?? {},
-                });
-
-                switch (linkTarget.type) {
-                    case 'unique':
-                        node.parseData.target = toAbsoluteContentLocation(
-                            linkTarget.strlocation,
-                            context.location?.path!,
-                        );
-                        break;
-                    case 'page':
-                        node.parseData.target = `page|${linkTarget.pageType}|${toAbsoluteContentId(linkTarget.path!, context.location?.path!)}`;
-                        break;
-                }
-            }
-
-            if (!(node instanceof IncludeNode)) {
-                listeners.step &&
-                    (await listeners.step({
-                        _location: includeTargetLocation,
-                        _node: node,
-                        _bitranTranspiler: bitranTranspiler,
-                    }));
-
-                return;
-            }
-
-            try {
-                await _traverseStep(
-                    node,
-                    includeTargetLocation,
-                    context.aliases,
-                    listeners,
-                    travelMap,
-                );
-            } catch (message: any) {
-                stepErrorMessage = message;
-            }
-        },
-    });
-
-    if (stepErrorMessage) throw stepErrorMessage;
-
-    //
-    // Leaving from current Include
-    //
-
-    listeners.leave &&
-        (await listeners.leave({
-            _location: includeTargetLocation,
-        }));
-}
-
-function printIncludeTarget(target: string) {
-    return `<~ ${target}`;
-}
+import { BlockNode, type ElementNode } from '@bitran-js/core';
+import type { BitranTranspiler } from '@bitran-js/transpiler';
+
+import {
+    parseBitranLocation,
+    parsePartialBitranLocation,
+    setEruditBitranRuntime,
+    stringifyBitranLocation,
+    tryReplaceAlias,
+    type BitranAliases,
+    type BitranContext,
+} from '@erudit-js/cog/schema';
+import { IncludeNode } from '@erudit-js/bitran-elements/include/shared';
+import { AliasesNode } from '@erudit-js/bitran-elements/aliases/shared';
+
+import { createBitranTranspiler } from '@server/bitran/transpiler';
+import { ERUDIT_SERVER } from '@server/global';
+import { DbUnique } from '@server/db/entities/Unique';
+import { getNavBookIds } from '@server/nav/utils';
+
+import { toAbsoluteLocation } from '@shared/bitran/contentId';
+
+export type TraverseEnterFn = (payload: {
+    _location: string;
+    _bitranTranspiler: BitranTranspiler;
+    _biCode: string;
+}) => Promise<any>;
+
+export type TraverseStepFn = (payload: {
+    _location: string;
+    _bitranTranspiler: BitranTranspiler;
+    _node: ElementNode;
+}) => Promise<any>;
+
+export type TraverseLeaveFn = (payload: { _location: string }) => Promise<any>;
+
+/**
+ * This operation is heavy as fuck.
+ * It consumes a lot of memory and is slow.
+ * Use as rarely as possible!
+ */
+export async function traverseInclude(
+    includeNode: IncludeNode,
+    context: BitranContext,
+    listeners: {
+        enter?: TraverseEnterFn;
+        step?: TraverseStepFn;
+        leave?: TraverseLeaveFn;
+    },
+) {
+    const entryLocation = stringifyBitranLocation(
+        parsePartialBitranLocation(includeNode.id, context.location),
+    );
+
+    const travelMap: Record<string, string | null> = {
+        // Not displayed when error, but needed for checking infinite loops
+        [entryLocation]: null,
+    };
+
+    try {
+        await _traverseStep(
+            includeNode,
+            entryLocation,
+            context.aliases,
+            listeners,
+            travelMap,
+        );
+    } catch (message) {
+        let finalMessage = `Include Traversal Error!\n\n${message}\n\n`;
+
+        for (const [location, includeTarget] of Object.entries(
+            travelMap,
+        ).reverse()) {
+            if (includeTarget === null) continue;
+
+            finalMessage += `at "${printIncludeTarget(includeTarget)}" in "${location}"\n`;
+        }
+
+        throw new Error(finalMessage);
+    }
+}
+
+async function _traverseStep(
+    includeNode: IncludeNode,
+    location: string,
+    aliases: BitranAliases,
+    listeners: {
+        enter?: TraverseEnterFn;
+        step?: TraverseStepFn;
+        leave?: TraverseLeaveFn;
+    },
+    travelMap: Record<string, string | null>,
+) {
+    let includeTargetLocation: string;
+
+    try {
+        const parsedLocation = parseBitranLocation(location);
+
+        includeTargetLocation = stringifyBitranLocation(
+            parsePartialBitranLocation(
+                tryReplaceAlias(includeNode.parseData.location, aliases),
+                parsedLocation,
+            ),
+        );
+
+        includeTargetLocation = toAbsoluteLocation(
+            includeTargetLocation,
+            parsedLocation.path!,
+            getNavBookIds(),
+        );
+    } catch (error) {
+        travelMap[location] = includeNode.parseData.location;
+        throw error;
+    }
+
+    if (includeTargetLocation in travelMap)
+        throw `Include "${printIncludeTarget(includeNode.parseData.location)}" targets "${includeTargetLocation}" which creates infinite loop!`;
+
+    travelMap[location] = includeNode.parseData.location;
+
+    //
+    // Loading Unique this Include is referencing to.
+    //
+
+    const dbUnique = await ERUDIT_SERVER.DB.manager.findOne(DbUnique, {
+        where: { location: includeTargetLocation },
+    });
+
+    if (!dbUnique)
+        throw `Include "${printIncludeTarget(includeNode.parseData.location)}" is targeting to non-existing unique "${includeTargetLocation}"!`;
+
+    //
+    // Creating Bitran core within loaded unique's location context.
+    //
+
+    const context: BitranContext = {
+        location: parseBitranLocation(includeTargetLocation),
+        aliases: dbUnique.context.aliases,
+    };
+
+    const bitranTranspiler = await createBitranTranspiler();
+
+    [bitranTranspiler.parser, bitranTranspiler.stringifier].forEach((item) =>
+        setEruditBitranRuntime(item, {
+            eruditConfig: ERUDIT_SERVER.CONFIG,
+            context: structuredClone(context),
+            insideInclude: true,
+        }),
+    );
+
+    listeners.enter &&
+        (await listeners.enter({
+            _biCode: dbUnique.content,
+            _location: includeTargetLocation,
+            _bitranTranspiler: bitranTranspiler,
+        }));
+
+    //
+    // Parsing unique content and sub-traversing all includes if any.
+    //
+
+    let stepErrorMessage: string | undefined;
+
+    await bitranTranspiler.parser.parse(dbUnique.content, {
+        step: async (node) => {
+            if (stepErrorMessage) return;
+
+            // Skip Alias nodes to prevent them being injected into calling document context and possibly conflicting with other aliases, includes and links...
+            if (node instanceof AliasesNode) return;
+
+            // Replacing block ids with absolute ones to make possible to link to them
+            if (node instanceof BlockNode)
+                node.meta.id = Object.keys(travelMap)
+                    .concat([location])
+                    .join('__');
+
+            if (!(node instanceof IncludeNode)) {
+                listeners.step &&
+                    (await listeners.step({
+                        _location: includeTargetLocation,
+                        _node: node,
+                        _bitranTranspiler: bitranTranspiler,
+                    }));
+
+                return;
+            }
+
+            try {
+                await _traverseStep(
+                    node,
+                    includeTargetLocation,
+                    context.aliases,
+                    listeners,
+                    travelMap,
+                );
+            } catch (message: any) {
+                stepErrorMessage = message;
+            }
+        },
+    });
+
+    if (stepErrorMessage) throw stepErrorMessage;
+
+    //
+    // Leaving from current Include
+    //
+
+    listeners.leave &&
+        (await listeners.leave({
+            _location: includeTargetLocation,
+        }));
+}
+
+function printIncludeTarget(target: string) {
+    return `<~ ${target}`;
+}

package/server/plugin/bitran/location.ts

@@ -1,25 +1,25 @@
-import {
-    decodeBitranLocation,
-    parseBitranLocation,
-} from '@erudit/shared/bitran/location';
-
-export function parseUrlLocation(urlLocation: string) {
-    urlLocation = decodeURIComponent(urlLocation);
-    urlLocation = decodeBitranLocation(urlLocation);
-
-    if (!urlLocation)
-        throw createError({
-            statusCode: 500,
-            statusText: 'Empty content location router parameter!',
-        });
-
-    try {
-        return parseBitranLocation(urlLocation);
-    } catch (error: any) {
-        throw createError({
-            statusCode: 404,
-            statusText:
-                error?.message || `Can't parse location "${urlLocation}"!`,
-        });
-    }
-}
+import {
+    decodeBitranLocation,
+    parseBitranLocation,
+} from '@erudit-js/cog/schema';
+
+export function parseUrlLocation(urlLocation: string) {
+    urlLocation = decodeURIComponent(urlLocation);
+    urlLocation = decodeBitranLocation(urlLocation);
+
+    if (!urlLocation)
+        throw createError({
+            statusCode: 500,
+            statusText: 'Empty content location router parameter!',
+        });
+
+    try {
+        return parseBitranLocation(urlLocation);
+    } catch (error: any) {
+        throw createError({
+            statusCode: 404,
+            statusText:
+                error?.message || `Can't parse location "${urlLocation}"!`,
+        });
+    }
+}

package/server/plugin/bitran/toc.ts

@@ -1,83 +1,75 @@
-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 type { BitranLocation } from '@erudit-js/cog/schema';
+import {
+    headingName,
+    HeadingNode,
+} from '@erudit-js/bitran-elements/heading/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();
+
+    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;
+        };
+
+        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;
+        }
+    }
+}