erudit 3.0.0-dev.2 → 3.0.0-dev.21

package/server/plugin/nav/utils.ts

@@ -1,129 +1,179 @@
-import { ERUDIT_SERVER } from '@server/global';
-import { isRootNode, type NavNode } from '@server/nav/node';
-
-export async function walkNav(
-    step: (node: NavNode) => Promise<void | false>,
-    from: NavNode | typeof ERUDIT_SERVER.NAV = ERUDIT_SERVER.NAV,
-) {
-    if (!from) return;
-
-    const stepResult = isRootNode(from) ? true : await step(from);
-
-    if (stepResult !== false)
-        if (from.children)
-            for (const child of from.children) await walkNav(step, child);
-}
-
-//
-//
-//
-
-export function getNavBookOf(target: string | NavNode): NavNode | undefined {
-    const id = typeof target === 'string' ? target : target.id;
-
-    if (!id || !ERUDIT_SERVER.NAV_BOOKS) return undefined;
-
-    const idParts = id.split('/');
-
-    while (idParts.length > 0) {
-        const book = ERUDIT_SERVER.NAV_BOOKS[idParts.join('/')];
-
-        if (book) return book;
-
-        idParts.pop();
-    }
-
-    return undefined;
-}
-
-export async function getPreviousNextNav(contentId: string) {
-    let previousNav: NavNode | undefined, nextNav: NavNode | undefined;
-    let book: NavNode | undefined;
-    let finish = false;
-
-    await walkNav(async (navNode) => {
-        if (navNode.id === contentId) {
-            book = getNavBookOf(navNode);
-            finish = true;
-            return;
-        }
-
-        if (finish && !nextNav) {
-            nextNav = navNode;
-            return false;
-        }
-
-        if (!finish) previousNav = navNode;
-    });
-
-    if (book) {
-        //
-        // Can't lead out of current book (if givent content item is inside the book)
-        //
-
-        if (previousNav)
-            if (getNavBookOf(previousNav)?.fullId !== book.fullId)
-                previousNav = undefined;
-
-        if (nextNav)
-            if (getNavBookOf(nextNav)?.fullId !== book.fullId)
-                nextNav = undefined;
-    } else {
-        //
-        // If not inside the book and tries to lead inside a book, then force lead to book's about page
-        //
-
-        if (previousNav) previousNav = getNavBookOf(previousNav) || previousNav;
-
-        if (nextNav) nextNav = getNavBookOf(nextNav) || nextNav;
-    }
-
-    return {
-        previousNav,
-        nextNav,
-    };
-}
-
-export async function getNavNode(
-    contentId: string,
-): Promise<NavNode | undefined> {
-    let navNode: NavNode | undefined;
-
-    await walkNav(async (_navNode) => {
-        if (_navNode.id === contentId) {
-            navNode = _navNode;
-            return false;
-        }
-    });
-
-    return navNode;
-}
-
-export async function getIdsUp(contentId: string): Promise<string[]> {
-    const startNavNode = await getNavNode(contentId);
-
-    if (!startNavNode) return [];
-
-    const ids: string[] = [];
-
-    let currentNavNode: any = startNavNode;
-    while (currentNavNode?.id) {
-        ids.push(currentNavNode.id);
-        currentNavNode = currentNavNode.parent;
-    }
-
-    return ids;
-}
-
-export async function isSkipId(contentId: string) {
-    let hidden = false;
-
-    await walkNav(async (navNode) => {
-        if (navNode.id === contentId) {
-            hidden = navNode.skip;
-            return false;
-        }
-    });
-
-    return hidden;
-}
+import { ERUDIT_SERVER } from '@server/global';
+import { isRootNode, type NavNode, type RootNavNode } from '@server/nav/node';
+
+export async function walkNav(
+    step: (node: NavNode) => Promise<void | false>,
+    from: NavNode | typeof ERUDIT_SERVER.NAV = ERUDIT_SERVER.NAV,
+) {
+    if (!from) return;
+
+    const stepResult = isRootNode(from) ? true : await step(from);
+
+    if (stepResult !== false)
+        if (from.children)
+            for (const child of from.children) await walkNav(step, child);
+}
+
+//
+//
+//
+
+export function getNavBookIds(mode: 'full' | 'short'): string[] {
+    const bookIds: string[] = [];
+
+    if (!ERUDIT_SERVER.NAV_BOOKS) {
+        return bookIds;
+    }
+
+    for (const navBook of Object.values(ERUDIT_SERVER.NAV_BOOKS)) {
+        bookIds.push(mode === 'full' ? navBook.fullId : navBook.shortId);
+    }
+
+    return bookIds;
+}
+
+export function getNavBookOf(target: string | NavNode): NavNode | undefined {
+    const id = typeof target === 'string' ? target : target.fullId;
+
+    if (!id || !ERUDIT_SERVER.NAV_BOOKS) {
+        return undefined;
+    }
+
+    const idParts = id.split('/');
+
+    while (idParts.length > 0) {
+        const book = ERUDIT_SERVER.NAV_BOOKS[idParts.join('/')];
+
+        if (book) {
+            return book;
+        }
+
+        idParts.pop();
+    }
+
+    return undefined;
+}
+
+export async function getPreviousNextNav(contentId: string) {
+    let previousNav: NavNode | undefined, nextNav: NavNode | undefined;
+    let book: NavNode | undefined;
+    let finish = false;
+
+    await walkNav(async (navNode) => {
+        if (navNode.fullId === contentId) {
+            book = getNavBookOf(navNode);
+            finish = true;
+            return;
+        }
+
+        if (finish && !nextNav) {
+            nextNav = navNode;
+            return false;
+        }
+
+        if (!finish) previousNav = navNode;
+    });
+
+    if (book) {
+        //
+        // Can't lead out of current book (if givent content item is inside the book)
+        //
+
+        if (previousNav)
+            if (getNavBookOf(previousNav)?.fullId !== book.fullId)
+                previousNav = undefined;
+
+        if (nextNav)
+            if (getNavBookOf(nextNav)?.fullId !== book.fullId)
+                nextNav = undefined;
+    } else {
+        //
+        // If not inside the book and tries to lead inside a book, then force lead to book's about page
+        //
+
+        if (previousNav) previousNav = getNavBookOf(previousNav) || previousNav;
+
+        if (nextNav) nextNav = getNavBookOf(nextNav) || nextNav;
+    }
+
+    return {
+        previousNav,
+        nextNav,
+    };
+}
+
+/**
+ * Find navigation node by mixed content ID.
+ * It can be full ID, short ID or any combination of present and missing skipped parts.
+ */
+export function getNavNode(mixedContentId: string): NavNode {
+    const parts = mixedContentId.split('/');
+    let foundNode: NavNode | undefined;
+
+    function search(node: NavNode, partIdx: number): NavNode | undefined {
+        const targetIdPart = parts[partIdx];
+        const nodeIdPart = node.idPart;
+
+        if (nodeIdPart === targetIdPart) {
+            if (partIdx === parts.length - 1) {
+                return node;
+            }
+
+            for (const child of node.children || []) {
+                const deepResult = search(child, partIdx + 1);
+                if (deepResult) return deepResult;
+            }
+        }
+
+        if (node.skip) {
+            for (const child of node.children || []) {
+                const deepResult = search(child, partIdx);
+                if (deepResult) return deepResult;
+            }
+        }
+
+        return undefined;
+    }
+
+    for (const child of ERUDIT_SERVER.NAV?.children || []) {
+        foundNode = search(child, 0);
+        if (foundNode) break;
+    }
+
+    if (!foundNode) {
+        throw new Error(
+            `Failed to find navigation content node for ID: ${mixedContentId}`,
+        );
+    }
+
+    return foundNode;
+}
+
+export function getIdsUp(contentId: string): string[] {
+    const ids: string[] = [];
+    const startNavNode = getNavNode(contentId);
+
+    if (!startNavNode) return ids;
+
+    let currentNavNode: NavNode = startNavNode;
+
+    while (currentNavNode?.idPart) {
+        ids.push(currentNavNode.fullId);
+        currentNavNode = currentNavNode.parent as NavNode;
+    }
+
+    return ids;
+}
+
+export async function isSkipId(contentId: string) {
+    let hidden = false;
+
+    await walkNav(async (navNode) => {
+        if (navNode.fullId === contentId) {
+            hidden = navNode.skip;
+            return false;
+        }
+    });
+
+    return hidden;
+}

package/server/plugin/repository/asideMinor.ts

@@ -0,0 +1,51 @@
+import type { ContentType } from '@erudit-js/cog/schema';
+
+import type { NavNode } from '@server/nav/node';
+import { getNavNode } from '@server/nav/utils';
+import {
+    getContentContributors,
+    getPreviousNext,
+} from '@server/repository/content';
+
+import type { AsideMinorContentBase } from '@shared/aside/minor';
+
+export function getAsideMinorContentNode(
+    type: ContentType,
+    rawContentId?: string,
+) {
+    if (!rawContentId) {
+        throw createError({
+            statusCode: 400,
+            message: `Missing "${type}Id" parameter!`,
+        });
+    }
+
+    const contentNavNode = getNavNode(rawContentId);
+
+    if (contentNavNode.type !== type) {
+        throw createError({
+            statusCode: 400,
+            message: `Provided "${rawContentId}" is not a content ${type}!`,
+        });
+    }
+
+    return contentNavNode;
+}
+
+export async function getAsideMinorContentBase(
+    navNode: NavNode,
+): Promise<Omit<AsideMinorContentBase, 'type'>> {
+    const fullContentId = navNode.fullId;
+    const shortContentId = navNode.shortId;
+    const fsContentDirectory = navNode.fsPath;
+    const contributors = await getContentContributors(fullContentId);
+    const previousNext = await getPreviousNext(fullContentId);
+
+    return {
+        fullContentId,
+        shortContentId,
+        fsContentDirectory,
+        contributors,
+        previousNext,
+    };
+}

package/server/plugin/repository/book.ts

@@ -1,21 +1,39 @@
-import { ERUDIT_SERVER } from '@server/global';
-import { getNavBookOf } from '@server/nav/utils';
-import { DbContent } from '@server/db/entities/Content';
-
-export async function getContentBookFor(contentId: string) {
-    const navBook = getNavBookOf(contentId);
-
-    if (!navBook) return undefined;
-
-    const bookId = navBook.id;
-
-    const dbContent = await ERUDIT_SERVER.DB.manager.findOne(DbContent, {
-        select: ['title'],
-        where: { contentId: bookId },
-    });
-
-    return {
-        contentId: bookId,
-        title: dbContent?.title || bookId,
-    };
-}
+import { ERUDIT_SERVER } from '@server/global';
+import { getNavBookOf } from '@server/nav/utils';
+import { DbContent } from '@server/db/entities/Content';
+import { getFullContentId } from './contentId';
+
+export async function getContentBookFor(contentId: string) {
+    contentId = getFullContentId(contentId);
+    const navBook = getNavBookOf(contentId);
+
+    if (!navBook) return undefined;
+
+    const bookId = navBook.fullId;
+
+    const dbContent = await ERUDIT_SERVER.DB.manager.findOne(DbContent, {
+        select: ['title'],
+        where: { contentId: bookId },
+    });
+
+    return {
+        contentId: bookId,
+        title: dbContent?.title || bookId,
+    };
+}
+
+export async function getBookTitleFor(contentId: string) {
+    contentId = getFullContentId(contentId);
+    const navBook = getNavBookOf(contentId);
+
+    if (!navBook) return undefined;
+
+    const bookId = navBook.fullId;
+
+    const dbContent = await ERUDIT_SERVER.DB.manager.findOne(DbContent, {
+        select: ['title'],
+        where: { contentId: bookId },
+    });
+
+    return dbContent?.title || bookId;
+}

package/server/plugin/repository/cameo.ts

@@ -0,0 +1,16 @@
+import { readdir } from 'node:fs/promises';
+import { PROJECT_DIR } from '#erudit/globalPaths';
+
+export async function getCameoIds() {
+    try {
+        const dirents = await readdir(`${PROJECT_DIR}/cameos`, {
+            withFileTypes: true,
+        });
+
+        return dirents
+            .filter((dirent) => dirent.isDirectory())
+            .map((dirent) => dirent.name);
+    } catch {
+        return [];
+    }
+}