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

package/server/api/content/data.ts

@@ -1,72 +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,
-    };
-}
+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/fake/content.ts

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

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

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

package/server/api/language/functions.ts

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

@@ -1,19 +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}"!`,
-    });
-});
+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

@@ -1,8 +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[];
-});
+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[];
+});

package/server/api/preview/page/[...parts].ts

@@ -1,51 +1,51 @@
-import {
-    getContentContext,
-    getTopicPartContext,
-    getContributorContext,
-} from '@erudit/server/plugin/content/context';
-
-import type { PreviewDataPageLink } from '@app/scripts/preview/data/pageLink';
-import type { LinkTargetPageType } from '@erudit/shared/bitran/products/link/target';
-import type { Context, ContextItem } from '@erudit/shared/content/context';
-
-export default defineEventHandler<Promise<PreviewDataPageLink>>(
-    async (event) => {
-        const urlParts = (event.context.params?.parts || '').split('/');
-        const pageType: LinkTargetPageType = urlParts.shift() as any;
-        const contentId: string = urlParts.join('/');
-
-        const context: Context = await (async () => {
-            switch (pageType) {
-                case 'book':
-                case 'group':
-                    return await getContentContext(contentId);
-                case 'article':
-                case 'summary':
-                case 'practice':
-                    return await getTopicPartContext(pageType, contentId);
-                case 'contributor':
-                    return await getContributorContext(contentId);
-            }
-
-            throw createError(`Can't handle "${pageType}" page type!`);
-        })();
-
-        const lastContextItem = context.pop() as ContextItem;
-        const contextStr = context
-            .filter((c) => !c.hidden)
-            .map((c) => c.title)
-            .join(' / ');
-
-        return <PreviewDataPageLink>{
-            type: 'page-link',
-            footer: {
-                secondary:
-                    (contextStr ? contextStr + ' • ' : '') +
-                    lastContextItem.type,
-                primary: lastContextItem.title,
-                href: lastContextItem.href,
-                iconName: lastContextItem.icon,
-            },
-        };
-    },
-);
+import {
+    getContentContext,
+    getTopicPartContext,
+    getContributorContext,
+} from '@erudit/server/plugin/content/context';
+
+import type { PreviewDataPageLink } from '../../../../app/scripts/preview/data/pageLink';
+import type { LinkTargetPageType } from '@erudit/shared/bitran/link/target';
+import type { Context, ContextItem } from '@erudit/shared/content/context';
+
+export default defineEventHandler<Promise<PreviewDataPageLink>>(
+    async (event) => {
+        const urlParts = (event.context.params?.parts || '').split('/');
+        const pageType: LinkTargetPageType = urlParts.shift() as any;
+        const contentId: string = urlParts.join('/');
+
+        const context: Context = await (async () => {
+            switch (pageType) {
+                case 'book':
+                case 'group':
+                    return await getContentContext(contentId);
+                case 'article':
+                case 'summary':
+                case 'practice':
+                    return await getTopicPartContext(pageType, contentId);
+                case 'contributor':
+                    return await getContributorContext(contentId);
+            }
+
+            throw createError(`Can't handle "${pageType}" page type!`);
+        })();
+
+        const lastContextItem = context.pop() as ContextItem;
+        const contextStr = context
+            .filter((c) => !c.hidden)
+            .map((c) => c.title)
+            .join(' / ');
+
+        return <PreviewDataPageLink>{
+            type: 'page-link',
+            footer: {
+                secondary:
+                    (contextStr ? contextStr + ' • ' : '') +
+                    lastContextItem.type,
+                primary: lastContextItem.title,
+                href: lastContextItem.href,
+                iconName: lastContextItem.icon,
+            },
+        };
+    },
+);

package/server/api/preview/unique/[location].ts

@@ -1,55 +1,55 @@
-import type { BitranContent } from 'bitran';
-
-import { parseUrlLocation } from '@server/bitran/location';
-import { getLocationContext } from '@server/content/context';
-import { ERUDIT_SERVER } from '@server/global';
-import { DbUnique } from '@server/db/entities/Unique';
-import { getBitranContent } from '@server/bitran/content';
-
-import type { Context } from '@shared/content/context';
-import type { BitranContext } from '@shared/bitran/context';
-import { stringifyBitranLocation } from '@shared/bitran/location';
-
-interface ReturnType {
-    context: Context;
-    productTitle?: string;
-    bitran: {
-        productName: string;
-        context: BitranContext;
-        content: BitranContent;
-    };
-}
-
-export default defineEventHandler<Promise<ReturnType>>(async (event) => {
-    const location = parseUrlLocation(getRouterParam(event, 'location') || '');
-
-    const context = await getLocationContext(location);
-
-    const dbUnique = await (async () => {
-        const dbUnique = ERUDIT_SERVER.DB.manager.findOne(DbUnique, {
-            select: ['productName', 'title', 'context'],
-            where: { location: stringifyBitranLocation(location) },
-        });
-
-        if (!dbUnique)
-            throw createError(
-                `Missing unique "${stringifyBitranLocation(location)}"!`,
-            );
-
-        return dbUnique as any as DbUnique;
-    })();
-
-    const bitran = await (async () => {
-        return {
-            content: await getBitranContent(location),
-            context: dbUnique.context,
-            productName: dbUnique.productName,
-        };
-    })();
-
-    return <ReturnType>{
-        context,
-        productTitle: dbUnique.title,
-        bitran,
-    };
-});
+import type { BitranContent } from 'bitran';
+
+import { parseUrlLocation } from '@server/bitran/location';
+import { getLocationContext } from '@server/content/context';
+import { ERUDIT_SERVER } from '@server/global';
+import { DbUnique } from '@server/db/entities/Unique';
+import { getBitranContent } from '@server/bitran/content';
+
+import type { Context } from '@shared/content/context';
+import type { BitranContext } from '@shared/bitran/context';
+import { stringifyBitranLocation } from '@shared/bitran/location';
+
+interface ReturnType {
+    context: Context;
+    productTitle?: string;
+    bitran: {
+        productName: string;
+        context: BitranContext;
+        content: BitranContent;
+    };
+}
+
+export default defineEventHandler<Promise<ReturnType>>(async (event) => {
+    const location = parseUrlLocation(getRouterParam(event, 'location') || '');
+
+    const context = await getLocationContext(location);
+
+    const dbUnique = await (async () => {
+        const dbUnique = ERUDIT_SERVER.DB.manager.findOne(DbUnique, {
+            select: ['productName', 'title', 'context'],
+            where: { location: stringifyBitranLocation(location) },
+        });
+
+        if (!dbUnique)
+            throw createError(
+                `Missing unique "${stringifyBitranLocation(location)}"!`,
+            );
+
+        return dbUnique as any as DbUnique;
+    })();
+
+    const bitran = await (async () => {
+        return {
+            content: await getBitranContent(location),
+            context: dbUnique.context,
+            productName: dbUnique.productName,
+        };
+    })();
+
+    return <ReturnType>{
+        context,
+        productTitle: dbUnique.title,
+        bitran,
+    };
+});

package/server/plugin/bitran/content.ts

@@ -1,23 +1,28 @@
-import type { BitranContent, BitranPreRenderData } from 'bitran';
-import { createRenderData } from 'bitran/core';
-import { BlockNode } from 'bitran/dom';
-import { BlocksNode, ErrorNode } from 'bitran/default';
+import { isTopicPart, type TopicPart } from 'erudit-cog/schema';
+import { createPreRenderData, type PreRenderData } from '@bitran-js/transpiler';
+import { BlockNode, BlocksNode } from '@bitran-js/core';
+import { type BitranContent } from '@bitran-js/renderer-vue';
+import {
+    AliasesNode,
+    mergeAliases,
+    NO_ALIASES,
+} from '@erudit-js/bitran-elements/aliases/shared';
+import { IncludeNode } from '@erudit-js/bitran-elements/include/shared';
+
+import { ERUDIT_SERVER } from '@server/global';
+import { DbUnique } from '@server/db/entities/Unique';
+import { DbTopic } from '@server/db/entities/Topic';
+import { DbGroup } from '@server/db/entities/Group';
+import { resolveLinkTarget } from '@server/bitran/products/link';
+import { traverseInclude } from '@server/bitran/products/include';
+import { createBitranTranspiler } from '@server/bitran/transpiler';
+
 import type { BitranContext } from '@erudit/shared/bitran/context';
 import {
     stringifyBitranLocation,
     type BitranLocation,
 } from '@erudit/shared/bitran/location';
-import { ERUDIT_SERVER } from '../global';
-import { DbUnique } from '../db/entities/Unique';
-import { isTopicPart, type TopicPart } from 'erudit-cog/schema';
-import { DbTopic } from '../db/entities/Topic';
-import { DbGroup } from '../db/entities/Group';
-import { NO_ALIASES } from '@erudit/shared/bitran/alias';
-import { createBitranCore } from './core';
-import { IncludeNode } from '@erudit/shared/bitran/products/include/core';
-import { LinkNode } from '@erudit/shared/bitran/products/link/core';
-import { resolveLinkTarget } from './products/link';
-import { traverseInclude } from './products/include';
+import { LinkNode } from '@erudit/shared/bitran/link/shared';
 
 interface RawBitranContent {
     context: BitranContext;
@@ -37,7 +42,6 @@ export async function getBitranContent(
 
 export async function getRawBitranContent(
     location: BitranLocation,
-    // @ts-ignore
 ): Promise<RawBitranContent> {
     const throwNotFound = () => {
         throw createError({
@@ -89,82 +93,89 @@ export async function getRawBitranContent(
         };
     }
 
-    throwNotFound();
+    return throwNotFound();
 }
 
 async function createBitranContent(
     context: BitranContext,
     biCode: string,
 ): Promise<BitranContent> {
-    const bitranCore = await createBitranCore(context);
+    const bitranTranspiler = await createBitranTranspiler();
 
-    const root = await bitranCore.parser.parse(biCode, {
-        step: async (productNode) => {
-            if (productNode instanceof IncludeNode)
-                await resolveInclude(productNode, context);
+    const root = await bitranTranspiler.parser.parse(biCode, {
+        async step(node) {
+            if (node instanceof AliasesNode) {
+                mergeAliases(context.aliases, node.parseData);
+                return;
+            }
+
+            if (node instanceof IncludeNode) {
+                await resolveInclude(node, context);
+                return;
+            }
         },
     });
 
-    const finalContent = bitranCore.stringifier.stringify(root);
+    const finalContent = await bitranTranspiler.stringifier.stringify(root);
 
     // Building render data
-    const renderData: BitranPreRenderData = {};
-    await bitranCore.parser.parse(finalContent, {
-        step: async (productNode) => {
-            const id = productNode.getId();
-            const productCore = bitranCore.products[productNode.name]!;
+    const preRenderDataMap: Record<string, PreRenderData> = {};
+    await bitranTranspiler.parser.parse(finalContent, {
+        step: async (node) => {
+            const id = node.id;
+            const elementTranspiler = bitranTranspiler.transpilers[node.name]!;
 
-            if (productNode instanceof LinkNode) {
+            if (node instanceof LinkNode) {
                 try {
-                    renderData[id] = {
-                        status: 'success',
-                        data: await resolveLinkTarget(productNode.parseData, {
+                    preRenderDataMap[id] = {
+                        type: 'success',
+                        data: await resolveLinkTarget(node.parseData, {
                             location: context.location,
                             aliases: context.aliases ?? {},
                         }),
                     };
                 } catch (error: any) {
-                    renderData[id] = {
-                        status: 'error',
-                        errorMessage: error?.message || error,
+                    preRenderDataMap[id] = {
+                        type: 'error',
+                        message: error?.message || String(error),
                     };
                 }
                 return;
             }
 
-            if (id)
-                renderData[id] = await createRenderData(
-                    'pre',
-                    productNode,
-                    productCore,
+            if (id) {
+                const preRenderData = await createPreRenderData(
+                    node,
+                    elementTranspiler,
                 );
+                if (preRenderData) preRenderDataMap[id] = preRenderData;
+            }
         },
     });
 
     return {
         biCode: finalContent,
-        renderData,
+        preRenderData: preRenderDataMap,
     };
 }
 
 async function resolveInclude(
     includeNode: IncludeNode,
     context: BitranContext,
-): Promise<IncludeNode | ErrorNode> {
+): Promise<IncludeNode> {
     let _blocks;
 
     try {
         const blocks: BlockNode[] = [];
 
         await traverseInclude(includeNode, context, {
-            step: async ({ _location, _node, _bitranCore }) => {
+            step: async ({ _node }) => {
                 if (_node instanceof BlockNode) blocks.push(_node);
             },
         });
 
         const blocksNode = new BlocksNode(includeNode);
         blocksNode.setNodes(blocks);
-
         _blocks = blocksNode;
         includeNode.parseData.blocks = _blocks;
     } catch (error: any) {