erudit 2.0.0-dev.7 → 2.0.0-dev.9

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

@@ -1,38 +1,39 @@
-import type { BitranCore } from 'bitran/core';
-import { BlockNode, type ProductNode } from 'bitran/dom';
+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 { IncludeNode } from '@erudit/shared/bitran/products/include/core';
 import {
     parseBitranLocation,
     parsePartialBitranLocation,
     stringifyBitranLocation,
 } from '@erudit/shared/bitran/location';
-import {
-    tryReplaceAlias,
-    type BitranAliases,
-} from '@erudit/shared/bitran/alias';
-import {
-    toAbsoluteContentId,
-    toAbsoluteContentLocation,
-} from '../../content/absoluteId';
-import { ERUDIT_SERVER } from '../../global';
-import { DbUnique } from '../../db/entities/Unique';
-import { createBitranCore } from '../core';
-import { AliasNode } from '@erudit/shared/bitran/products/alias/core';
-import { LinkNode } from '@erudit/shared/bitran/products/link/core';
-import { createLinkTarget } from '@erudit/shared/bitran/products/link/target';
+import { createLinkTarget } from '@erudit/shared/bitran/link/target';
+import { LinkNode } from '@erudit/shared/bitran/link/shared';
 
 export type TraverseEnterFn = (payload: {
     _location: string;
-    _bitranCore: BitranCore;
+    _bitranTranspiler: BitranTranspiler;
     _biCode: string;
 }) => Promise<any>;
 
 export type TraverseStepFn = (payload: {
     _location: string;
-    _bitranCore: BitranCore;
-    _node: ProductNode;
+    _bitranTranspiler: BitranTranspiler;
+    _node: ElementNode;
 }) => Promise<any>;
 
 export type TraverseLeaveFn = (payload: { _location: string }) => Promise<any>;
@@ -52,7 +53,7 @@ export async function traverseInclude(
     },
 ) {
     const entryLocation = stringifyBitranLocation(
-        parsePartialBitranLocation(includeNode.getId(), context.location),
+        parsePartialBitranLocation(includeNode.id, context.location),
     );
 
     const travelMap: Record<string, string | null> = {
@@ -86,7 +87,7 @@ export async function traverseInclude(
 async function _traverseStep(
     includeNode: IncludeNode,
     location: string,
-    aliases: BitranAliases,
+    aliases: Aliases,
     listeners: {
         enter?: TraverseEnterFn;
         step?: TraverseStepFn;
@@ -140,13 +141,13 @@ async function _traverseStep(
         aliases: dbUnique.context.aliases,
     };
 
-    const bitranCore = await createBitranCore(context);
+    const bitranTranspiler = await createBitranTranspiler();
 
     listeners.enter &&
         (await listeners.enter({
             _biCode: dbUnique.content,
             _location: includeTargetLocation,
-            _bitranCore: bitranCore,
+            _bitranTranspiler: bitranTranspiler,
         }));
 
     //
@@ -155,12 +156,12 @@ async function _traverseStep(
 
     let stepErrorMessage: string | undefined;
 
-    await bitranCore.parser.parse(dbUnique.content, {
+    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 AliasNode) return;
+            if (node instanceof AliasesNode) return;
 
             // Replacing block ids with absolute ones to make possible to link to them
             if (node instanceof BlockNode)
@@ -192,7 +193,7 @@ async function _traverseStep(
                     (await listeners.step({
                         _location: includeTargetLocation,
                         _node: node,
-                        _bitranCore: bitranCore,
+                        _bitranTranspiler: bitranTranspiler,
                     }));
 
                 return;

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

@@ -1,15 +1,19 @@
+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/products/link/target';
+} from '@erudit/shared/bitran/link/target';
 import {
     toAbsoluteContentId,
     toAbsoluteContentLocation,
-} from '../../content/absoluteId';
+} from '@server/content/absoluteId';
 import type { BitranContext } from '@erudit/shared/bitran/context';
-import type { LinkData } from '@erudit/shared/bitran/products/link/shared';
-import { DbUnique } from '../../db/entities/Unique';
-import { ERUDIT_SERVER } from '../../global';
 import {
     parseBitranLocation,
     stringifyBitranLocation,
@@ -20,12 +24,10 @@ import {
     createContributorLink,
     createTopicPartLink,
 } from '@erudit/shared/link';
-import { DbContent } from '../../db/entities/Content';
-import { isTopicPart } from 'erudit-cog/schema';
-import { DbContributor } from '../../db/entities/Contributor';
+import type { LinkParseData } from '@erudit/shared/bitran/link/shared';
 
 export async function resolveLinkTarget(
-    linkData: LinkData,
+    linkData: LinkParseData,
     context: BitranContext,
 ): Promise<LinkTarget> {
     const linkTarget = createLinkTarget(linkData.target, context);

package/server/plugin/bitran/setup.ts

@@ -5,6 +5,5 @@ import { ERUDIT_SERVER } from '@server/global';
 export async function setupBitranConfig() {
     try {
         ERUDIT_SERVER.BITRAN_CONFIG = await IMPORT(PROJECT_DIR + '/bitran.ts');
-        console.log(ERUDIT_SERVER.BITRAN_CONFIG);
     } catch {}
 }

package/server/plugin/bitran/toc.ts

@@ -1,48 +1,49 @@
-import type { ProductNode } from 'bitran/dom';
+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 { getRawBitranContent } from './content';
-import { createBitranCore } from './core';
 import type { BitranLocation } from '@erudit/shared/bitran/location';
 import type { Toc } from '@erudit/shared/bitran/toc';
-import { IncludeNode } from '@erudit/shared/bitran/products/include/core';
+import { ERUDIT_SERVER } from '@server/global';
+import { getRawBitranContent } from './content';
+import { createBitranTranspiler } from './transpiler';
 import { traverseInclude } from './products/include';
-import { HeadingNode } from '@erudit/shared/bitran/products/heading/core';
-import { headingName } from '@erudit/shared/bitran/products/heading/shared';
-import { ERUDIT_SERVER } from '../global';
 
 export async function getBitranToc(location: BitranLocation) {
     const rawContent = await getRawBitranContent(location);
-    const bitranCore = await createBitranCore(rawContent.context);
+    const bitranCore = await createBitranTranspiler();
 
     const toc: Toc = [];
 
     await bitranCore.parser.parse(rawContent.biCode, {
-        step: async (productNode) => {
-            if (productNode instanceof IncludeNode) {
-                await traverseInclude(productNode, rawContent.context, {
+        async step(node) {
+            if (node instanceof IncludeNode) {
+                await traverseInclude(node, rawContent.context, {
                     step: async ({ _node }) => tryAddToToc(_node),
                 });
-            } else tryAddToToc(productNode);
+            } else tryAddToToc(node);
         },
     });
 
     return toc;
 
-    function tryAddToToc(product: ProductNode) {
+    function tryAddToToc(node: ElementNode) {
         const tocItemBase = {
-            id: product.getId(),
-            productName: product.name,
+            id: node.id,
+            productName: node.name,
         };
 
         // Check if node is manually excluded from TOC
-        if (typeof product.meta?.toc === 'boolean' && !product.meta?.toc)
-            return;
+        if (typeof node.meta?.toc === 'boolean' && !node.meta?.toc) return;
 
-        if (product instanceof HeadingNode) {
+        if (node instanceof HeadingNode) {
             toc.push({
                 ...tocItemBase,
-                level: product.parseData.level,
-                title: product.parseData.title,
+                level: node.parseData.level,
+                title: node.parseData.title,
             });
             return;
         }
@@ -59,22 +60,22 @@ export async function getBitranToc(location: BitranLocation) {
                 : lastTocItem.level;
         };
 
-        if (ERUDIT_SERVER.BITRAN_CONFIG?.toc?.includes(product.name)) {
+        if (ERUDIT_SERVER.BITRAN_CONFIG?.toc?.includes(node.name)) {
             // Erudit Config says to add these products to TOC
             toc.push({
                 ...tocItemBase,
                 level: notHeadingLevel(),
-                title: product.meta?.title || product.parseData?.title,
+                title: node.meta?.title || node.parseData?.title,
             });
             return;
         }
 
-        if (product.meta?.toc) {
+        if (node.meta?.toc) {
             // Show in Toc any product with truthy `toc` meta property
             toc.push({
                 ...tocItemBase,
                 level: notHeadingLevel(),
-                title: product.meta?.title || product.parseData?.title,
+                title: node.meta?.title || node.parseData?.title,
             });
             return;
         }

package/server/plugin/bitran/transpiler.ts

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

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/parse.ts

@@ -1,21 +1,24 @@
-import type { BitranCore } from 'bitran/core';
-import { assumeGroupItem, type ProductNode } from 'bitran/dom';
+import { ElementNode, walkForward } from '@bitran-js/core';
+import { type BitranTranspiler } from '@bitran-js/transpiler';
+import {
+    AliasesNode,
+    mergeAliases,
+    NO_ALIASES,
+} from '@erudit-js/bitran-elements/aliases/shared';
+import { HeadingNode } from '@erudit-js/bitran-elements/heading/shared';
 
-import { createBitranCore } from '@server/bitran/core';
-import { DbUnique } from '@server/db/entities/Unique';
+import { createBitranTranspiler } from '@server/bitran/transpiler';
 import { ERUDIT_SERVER } from '@server/global';
+import { DbUnique } from '@server/db/entities/Unique';
 
-import { NO_ALIASES } from '@shared/bitran/alias';
 import type { BitranContext } from '@shared/bitran/context';
 import {
     stringifyBitranLocation,
     type BitranLocation,
 } from '@shared/bitran/location';
-import { AliasNode } from '@shared/bitran/products/alias/core';
-import { HeadingNode } from '@shared/bitran/products/heading/core';
 
 let context: BitranContext = {} as any;
-let bitranCore: BitranCore;
+let bitranTranspiler: BitranTranspiler;
 
 const blocksAfterHeading = 2;
 
@@ -27,39 +30,45 @@ export async function parseBitranContent(
     context.location = location;
     context.aliases = NO_ALIASES();
 
-    bitranCore ||= await createBitranCore(context);
+    bitranTranspiler ||= await createBitranTranspiler();
 
     // Tracking heading nodes to deal with them later
-    let headings: HeadingNode[] = [];
+    const headings: HeadingNode[] = [];
 
-    await bitranCore.parser.parse(biCode, {
-        async step(product) {
-            const meta = product.meta;
+    await bitranTranspiler.parser.parse(biCode, {
+        async step(node) {
+            const meta = node.meta;
             const uniqueId = meta?.id;
 
+            if (node instanceof AliasesNode) {
+                mergeAliases(context.aliases, node.parseData);
+            }
+
             if (uniqueId) {
-                if (product instanceof HeadingNode) {
-                    headings.push(product);
+                if (node instanceof HeadingNode) {
+                    headings.push(node);
                     return;
                 }
 
-                await addUnique(product);
+                await addUnique(node);
             }
         },
     });
 
     for (const heading of headings) {
         let blocksAfter = 0;
-        let content = bitranCore.stringifier.stringify(heading);
+        let content = await bitranTranspiler.stringifier.stringify(heading);
 
-        assumeGroupItem(heading).walkForward((product) => {
+        await walkForward(heading, async (node) => {
             if (blocksAfter >= blocksAfterHeading) return false;
 
-            if (product instanceof AliasNode) return;
+            if (node instanceof AliasesNode) return;
             // Spoiler
             // Todo
 
-            content += '\n\n' + bitranCore.stringifier.stringify(product);
+            content +=
+                '\n\n' + (await bitranTranspiler.stringifier.stringify(node));
+
             blocksAfter++;
         });
 
@@ -70,19 +79,20 @@ export async function parseBitranContent(
     //
     //
 
-    function createUniqueLocation(product: ProductNode) {
+    function createUniqueLocation(node: ElementNode) {
         return stringifyBitranLocation({
             ...location,
-            ...{ unique: product.meta.id! },
+            ...{ unique: node.meta.id! },
         });
     }
 
-    async function addUnique(product: ProductNode, content?: string) {
+    async function addUnique(node: ElementNode, content?: string) {
         const dbUnique = new DbUnique();
-        dbUnique.location = createUniqueLocation(product);
-        dbUnique.content = content || bitranCore.stringifier.stringify(product);
-        dbUnique.title = product.parseData?.title || product.meta?.title;
-        dbUnique.productName = product.name;
+        dbUnique.location = createUniqueLocation(node);
+        dbUnique.content =
+            content || (await bitranTranspiler.stringifier.stringify(node));
+        dbUnique.title = node.parseData?.title || node.meta?.title;
+        dbUnique.productName = node.name;
         dbUnique.context = context;
 
         await ERUDIT_SERVER.DB.manager.save(dbUnique);

package/server/plugin/build/jobs/language.ts

@@ -1,36 +1,36 @@
-import { existsSync } from 'node:fs';
-
-import { ERUDIT_DIR } from '#erudit/globalPaths';
-import { stress } from '@erudit/utils/stress';
-import { ERUDIT_SERVER } from '@server/global';
-import { IMPORT } from '@server/importer';
-
-export async function setupLanguage() {
-    const languageCode = ERUDIT_SERVER.CONFIG?.language || 'en';
-    const languageFilePath = ERUDIT_DIR + `/languages/${languageCode}.ts`;
-
-    if (!existsSync(languageFilePath))
-        throw new Error(`Language file for ${stress(languageCode)} not found!`);
-
-    try {
-        const languageModule = await IMPORT(languageFilePath);
-
-        if (!languageModule.default)
-            throw new Error(
-                `Language file for ${stress(languageCode)} is missing default export with phrases!`,
-            );
-
-        const { default: phrases, ...context } = { ...languageModule };
-
-        ERUDIT_SERVER.LANGUAGE = {
-            phrases,
-            functions: Object.entries(context)
-                .filter(([, value]) => typeof value === 'function')
-                .reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {}),
-        };
-    } catch (error) {
-        throw new Error(
-            `Error while loading language ${stress(languageCode)}!\n\n${error}`,
-        );
-    }
-}
+import { existsSync } from 'node:fs';
+
+import { ERUDIT_DIR } from '#erudit/globalPaths';
+import { stress } from '@erudit/utils/stress';
+import { ERUDIT_SERVER } from '@server/global';
+import { IMPORT } from '@server/importer';
+
+export async function setupLanguage() {
+    const languageCode = ERUDIT_SERVER.CONFIG?.language || 'en';
+    const languageFilePath = ERUDIT_DIR + `/languages/${languageCode}.ts`;
+
+    if (!existsSync(languageFilePath))
+        throw new Error(`Language file for ${stress(languageCode)} not found!`);
+
+    try {
+        const languageModule = await IMPORT(languageFilePath);
+
+        if (!languageModule.default)
+            throw new Error(
+                `Language file for ${stress(languageCode)} is missing default export with phrases!`,
+            );
+
+        const { default: phrases, ...context } = { ...languageModule };
+
+        ERUDIT_SERVER.LANGUAGE = {
+            phrases,
+            functions: Object.entries(context)
+                .filter(([, value]) => typeof value === 'function')
+                .reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {}),
+        };
+    } catch (error) {
+        throw new Error(
+            `Error while loading language ${stress(languageCode)}!\n\n${error}`,
+        );
+    }
+}

package/server/plugin/build/process.ts

@@ -1,25 +1,25 @@
-import { debug, logger } from '@server/logger';
-
-import { setup } from './setup';
-import { setupLanguage } from './jobs/language';
-import { buildContributors } from './jobs/contributors';
-import { buildNav } from './jobs/nav';
-import { buildContent } from './jobs/content/generic';
-
-let initial = true;
-
-export async function build() {
-    debug.start('Building data...');
-
-    if (initial) {
-        await setup();
-        initial = false;
-    }
-
-    await setupLanguage();
-    await buildContributors();
-    await buildNav();
-    await buildContent();
-
-    logger.success('Build successful!');
-}
+import { debug, logger } from '@server/logger';
+
+import { setup } from './setup';
+import { setupLanguage } from './jobs/language';
+import { buildContributors } from './jobs/contributors';
+import { buildNav } from './jobs/nav';
+import { buildContent } from './jobs/content/generic';
+
+let initial = true;
+
+export async function build() {
+    debug.start('Building data...');
+
+    if (initial) {
+        await setup();
+        initial = false;
+    }
+
+    await setupLanguage();
+    await buildContributors();
+    await buildNav();
+    await buildContent();
+
+    logger.success('Build successful!');
+}