erudit 2.0.0-dev.9 → 3.0.0-dev.1

package/server/plugin/bitran/products/link.ts

@@ -1,116 +1,116 @@
-import { isTopicPart } from 'erudit-cog/schema';
-
-import { DbUnique } from '@server/db/entities/Unique';
-import { ERUDIT_SERVER } from '@server/global';
-import { DbContent } from '@server/db/entities/Content';
-import { DbContributor } from '@server/db/entities/Contributor';
-
-import {
-    createLinkTarget,
-    type LinkTarget,
-} from '@erudit/shared/bitran/link/target';
-import {
-    toAbsoluteContentId,
-    toAbsoluteContentLocation,
-} from '@server/content/absoluteId';
-import type { BitranContext } from '@erudit/shared/bitran/context';
-import {
-    parseBitranLocation,
-    stringifyBitranLocation,
-} from '@erudit/shared/bitran/location';
-import {
-    createBitranLocationLink,
-    createContentLink,
-    createContributorLink,
-    createTopicPartLink,
-} from '@erudit/shared/link';
-import type { LinkParseData } from '@erudit/shared/bitran/link/shared';
-
-export async function resolveLinkTarget(
-    linkData: LinkParseData,
-    context: BitranContext,
-): Promise<LinkTarget> {
-    const linkTarget = createLinkTarget(linkData.target, context);
-
-    if (linkTarget.type === 'unique') {
-        const absoluteLocation = toAbsoluteContentLocation(
-            linkTarget.strlocation,
-            context.location?.path!,
-        );
-
-        const dbUnique = await ERUDIT_SERVER.DB.manager.findOne(DbUnique, {
-            select: ['location', 'productName'],
-            where: { location: absoluteLocation },
-        });
-
-        if (!dbUnique)
-            throw new Error(
-                `Unique "${linkTarget.strlocation}" does not exist!`,
-            );
-
-        const targetLocation = parseBitranLocation(dbUnique.location);
-
-        linkTarget._productName = dbUnique.productName;
-        linkTarget._href = createBitranLocationLink(targetLocation);
-        linkTarget._absoluteStrLocation =
-            stringifyBitranLocation(targetLocation);
-    } else if (linkTarget.type === 'page') {
-        const absoluteContentId = toAbsoluteContentId(
-            linkTarget.path!,
-            context.location?.path,
-        );
-
-        switch (linkTarget.pageType) {
-            case 'article':
-            case 'summary':
-            case 'practice':
-            case 'group':
-            case 'book':
-                {
-                    const dbContent = await ERUDIT_SERVER.DB.manager.findOne(
-                        DbContent,
-                        {
-                            where: { contentId: absoluteContentId },
-                        },
-                    );
-
-                    if (!dbContent)
-                        throw new Error(
-                            `Page "${linkTarget.pageType}|${absoluteContentId}" does not exist!`,
-                        );
-
-                    linkTarget._href = isTopicPart(linkTarget.pageType)
-                        ? createTopicPartLink(
-                              linkTarget.pageType,
-                              absoluteContentId,
-                          )
-                        : createContentLink(
-                              linkTarget.pageType,
-                              absoluteContentId,
-                          );
-                }
-                break;
-
-            case 'contributor':
-                {
-                    const dbContributor =
-                        await ERUDIT_SERVER.DB.manager.findOne(DbContributor, {
-                            select: ['contributorId'],
-                            where: { contributorId: absoluteContentId },
-                        });
-
-                    if (!dbContributor)
-                        throw new Error(
-                            `Contributor "${absoluteContentId}" does not exist!`,
-                        );
-
-                    linkTarget._href = createContributorLink(
-                        dbContributor.contributorId,
-                    );
-                }
-                break;
-        }
-    }
-
-    return linkTarget;
-}
+import { isTopicPart } from 'erudit-cog/schema';
+
+import { DbUnique } from '@server/db/entities/Unique';
+import { ERUDIT_SERVER } from '@server/global';
+import { DbContent } from '@server/db/entities/Content';
+import { DbContributor } from '@server/db/entities/Contributor';
+
+import {
+    createLinkTarget,
+    type LinkTarget,
+} from '@erudit/shared/bitran/link/target';
+import {
+    toAbsoluteContentId,
+    toAbsoluteContentLocation,
+} from '@server/content/absoluteId';
+import type { BitranContext } from '@erudit/shared/bitran/context';
+import {
+    parseBitranLocation,
+    stringifyBitranLocation,
+} from '@erudit/shared/bitran/location';
+import {
+    createBitranLocationLink,
+    createContentLink,
+    createContributorLink,
+    createTopicPartLink,
+} from '@erudit/shared/link';
+import type { LinkParseData } from '@erudit/shared/bitran/link/shared';
+
+export async function resolveLinkTarget(
+    linkData: LinkParseData,
+    context: BitranContext,
+): Promise<LinkTarget> {
+    const linkTarget = createLinkTarget(linkData.target, context);
+
+    if (linkTarget.type === 'unique') {
+        const absoluteLocation = toAbsoluteContentLocation(
+            linkTarget.strlocation,
+            context.location?.path!,
+        );
+
+        const dbUnique = await ERUDIT_SERVER.DB.manager.findOne(DbUnique, {
+            select: ['location', 'productName'],
+            where: { location: absoluteLocation },
+        });
+
+        if (!dbUnique)
+            throw new Error(
+                `Unique "${linkTarget.strlocation}" does not exist!`,
+            );
+
+        const targetLocation = parseBitranLocation(dbUnique.location);
+
+        linkTarget._productName = dbUnique.productName;
+        linkTarget._href = createBitranLocationLink(targetLocation);
+        linkTarget._absoluteStrLocation =
+            stringifyBitranLocation(targetLocation);
+    } else if (linkTarget.type === 'page') {
+        const absoluteContentId = toAbsoluteContentId(
+            linkTarget.path!,
+            context.location?.path,
+        );
+
+        switch (linkTarget.pageType) {
+            case 'article':
+            case 'summary':
+            case 'practice':
+            case 'group':
+            case 'book':
+                {
+                    const dbContent = await ERUDIT_SERVER.DB.manager.findOne(
+                        DbContent,
+                        {
+                            where: { contentId: absoluteContentId },
+                        },
+                    );
+
+                    if (!dbContent)
+                        throw new Error(
+                            `Page "${linkTarget.pageType}|${absoluteContentId}" does not exist!`,
+                        );
+
+                    linkTarget._href = isTopicPart(linkTarget.pageType)
+                        ? createTopicPartLink(
+                              linkTarget.pageType,
+                              absoluteContentId,
+                          )
+                        : createContentLink(
+                              linkTarget.pageType,
+                              absoluteContentId,
+                          );
+                }
+                break;
+
+            case 'contributor':
+                {
+                    const dbContributor =
+                        await ERUDIT_SERVER.DB.manager.findOne(DbContributor, {
+                            select: ['contributorId'],
+                            where: { contributorId: absoluteContentId },
+                        });
+
+                    if (!dbContributor)
+                        throw new Error(
+                            `Contributor "${absoluteContentId}" does not exist!`,
+                        );
+
+                    linkTarget._href = createContributorLink(
+                        dbContributor.contributorId,
+                    );
+                }
+                break;
+        }
+    }
+
+    return linkTarget;
+}

package/server/plugin/bitran/setup.ts

@@ -1,9 +1,9 @@
-import { PROJECT_DIR } from '#erudit/globalPaths';
-import { IMPORT } from '@server/importer';
-import { ERUDIT_SERVER } from '@server/global';
-
-export async function setupBitranConfig() {
-    try {
-        ERUDIT_SERVER.BITRAN_CONFIG = await IMPORT(PROJECT_DIR + '/bitran.ts');
-    } catch {}
-}
+import { PROJECT_DIR } from '#erudit/globalPaths';
+import { IMPORT } from '@server/importer';
+import { ERUDIT_SERVER } from '@server/global';
+
+export async function setupBitranConfig() {
+    try {
+        ERUDIT_SERVER.BITRAN_CONFIG = await IMPORT(PROJECT_DIR + '/bitran.ts');
+    } catch {}
+}

package/server/plugin/bitran/toc.ts

@@ -1,83 +1,83 @@
-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 { 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;
+        }
+    }
+}

package/server/plugin/bitran/transpiler.ts

@@ -1,46 +1,46 @@
-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,
+    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;
+}

package/server/plugin/build/close.ts

@@ -1,10 +1,10 @@
-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...');
+
+    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>;
+}