Cleanup

apps/web/app/(marketing)/docs/utils/build-documentation-tree.ts

@@ -0,0 +1,53 @@
+import { cache } from 'react';
+
+import type { DocumentationPage } from 'contentlayer/generated';
+
+export interface ProcessedDocumentationPage extends DocumentationPage {
+  collapsible: boolean;
+  pathSegments: string[];
+  nextPage: ProcessedDocumentationPage | DocumentationPage | null;
+  previousPage: ProcessedDocumentationPage | DocumentationPage | null;
+  children: DocsTree;
+}
+
+export type DocsTree = ProcessedDocumentationPage[];
+
+/**
+ * Build a tree of documentation pages from a flat list of pages with path segments
+ * @param docs
+ * @param parentPathNames
+ */
+export const buildDocumentationTree = cache(
+  (docs: DocumentationPage[], parentPathNames: string[] = []): DocsTree => {
+    const level = parentPathNames.length;
+
+    const pages = docs
+      .filter(
+        (_) =>
+          _.pathSegments.length === level + 1 &&
+          _.pathSegments
+            .map(({ pathName }: { pathName: string }) => pathName)
+            .join('/')
+            .startsWith(parentPathNames.join('/')),
+      )
+      .sort(
+        (a, b) => a.pathSegments[level].order - b.pathSegments[level].order,
+      );
+
+    return pages.map((doc, index) => {
+      const children = buildDocumentationTree(
+        docs,
+        doc.pathSegments.map(({ pathName }: { pathName: string }) => pathName),
+      );
+
+      return {
+        ...doc,
+        pathSegments: doc.pathSegments || ([] as string[]),
+        collapsible: children.length > 0,
+        nextPage: children[0] || pages[index + 1],
+        previousPage: pages[index - 1],
+        children,
+      };
+    });
+  },
+);

apps/web/app/(marketing)/docs/utils/get-documentation-page-tree.ts

@@ -0,0 +1,45 @@
+import { cache } from 'react';
+
+import type { DocumentationPage } from 'contentlayer/generated';
+import { allDocumentationPages } from 'contentlayer/generated';
+
+import { buildDocumentationTree } from './build-documentation-tree';
+
+/**
+ * Retrieves a specific documentation page from the page tree by its path.
+ *
+ * @param {string} pagePath - The path of the documentation page to retrieve.
+ * @returns {DocumentationPageWithChildren | undefined} The documentation page found in the tree, if any.
+ */
+export const getDocumentationPageTree = cache((pagePath: string) => {
+  const tree = buildDocumentationTree(allDocumentationPages);
+
+  type DocumentationPageWithChildren = DocumentationPage & {
+    previousPage?: DocumentationPage | null;
+    nextPage?: DocumentationPage | null;
+    children?: DocumentationPage[];
+  };
+
+  const findPageInTree = (
+    pages: DocumentationPageWithChildren[],
+    path: string,
+  ): DocumentationPageWithChildren | undefined => {
+    for (const page of pages) {
+      if (page.resolvedPath === path) {
+        return page;
+      }
+
+      const hasChildren = page.children && page.children.length > 0;
+
+      if (hasChildren) {
+        const foundPage = findPageInTree(page.children ?? [], path);
+
+        if (foundPage) {
+          return foundPage;
+        }
+      }
+    }
+  };
+
+  return findPageInTree(tree, pagePath);
+});