Fixes after review

Author: nolannbiron

packages/gitbook/src/lib/pages.ts

@@ -8,8 +8,8 @@ import {
 
 export type AncestorRevisionPage = RevisionPageDocument | RevisionPageGroup;
 
-type ResolvedPageDocument = {
-    page: RevisionPageDocument;
+type ResolvedPagePath<Page extends RevisionPageDocument | RevisionPageGroup> = {
+    page: Page;
     ancestors: AncestorRevisionPage[];
 };
 
@@ -19,7 +19,7 @@ type ResolvedPageDocument = {
 export function resolvePagePath(
     rootPages: Revision['pages'],
     pagePath: string
-): ResolvedPageDocument | undefined {
+): ResolvedPagePath<RevisionPageDocument> | undefined {
     const result = findPageByPath(rootPages, pagePath);
 
     if (!result) {
@@ -29,19 +29,14 @@ export function resolvePagePath(
     return resolvePageDocument(result.page, result.ancestors);
 }
 
-type ResolvedPageDocumentOrGroup = {
-    page: RevisionPageDocument | RevisionPageGroup;
-    ancestors: AncestorRevisionPage[];
-};
-
 /**
  * Resolve a page path to a page document or group.
  * Similar to resolvePagePath but returns both documents and groups.
  */
 export function resolvePagePathDocumentOrGroup(
     rootPages: Revision['pages'],
     pagePath: string
-): ResolvedPageDocumentOrGroup | undefined {
+): ResolvedPagePath<RevisionPageDocument | RevisionPageGroup> | undefined {
     const result = findPageByPath(rootPages, pagePath);
 
     if (!result) {
@@ -57,7 +52,7 @@ export function resolvePagePathDocumentOrGroup(
 function findPageByPath(
     rootPages: Revision['pages'],
     pagePath: string
-): ResolvedPageDocumentOrGroup | undefined {
+): ResolvedPagePath<RevisionPageDocument | RevisionPageGroup> | undefined {
     if (!pagePath) {
         const firstPage = resolveFirstDocument(rootPages, []);
         if (!firstPage) {
@@ -69,7 +64,7 @@ function findPageByPath(
     const iteratePages = (
         pages: RevisionPage[],
         ancestors: AncestorRevisionPage[]
-    ): ResolvedPageDocumentOrGroup | undefined => {
+    ): ResolvedPagePath<RevisionPageDocument | RevisionPageGroup> | undefined => {
         for (const page of pages) {
             if (page.type === RevisionPageType.Link || page.type === RevisionPageType.Computed) {
                 continue;

packages/gitbook/src/routes/llms.ts

@@ -141,12 +141,28 @@ async function getNodesFromSiteSpaces(
                 })
             );
             const pages = getIndexablePages(revision.pages);
-            return getMarkdownForPagesTree(pages, {
-                siteSpaceUrl,
-                linker,
-                heading: options.heading ? siteSpace.title : undefined,
-                withMarkdownPages: options.withMarkdownPages,
-            });
+
+            const nodes: RootContent[] = [];
+
+            // Add the space title as a heading
+            if (options.heading) {
+                nodes.push({
+                    type: 'heading',
+                    depth: 2,
+                    children: [{ type: 'text', value: siteSpace.title }],
+                });
+            }
+
+            // Add the pages as a list
+            nodes.push(
+                ...(await getMarkdownForPagesTree(pages, {
+                    siteSpaceUrl,
+                    linker,
+                    withMarkdownPages: options.withMarkdownPages,
+                }))
+            );
+
+            return nodes;
         })
     );
     return all.flat();
@@ -160,7 +176,6 @@ export async function getMarkdownForPagesTree(
     options: {
         siteSpaceUrl: string;
         linker: GitBookLinker;
-        heading?: string;
         withMarkdownPages?: boolean;
     }
 ): Promise<RootContent[]> {
@@ -192,13 +207,6 @@ export async function getMarkdownForPagesTree(
         })
     );
     const nodes: RootContent[] = [];
-    if (options.heading) {
-        nodes.push({
-            type: 'heading',
-            depth: 2,
-            children: [{ type: 'text', value: options.heading }],
-        });
-    }
     nodes.push({
         type: 'list',
         spread: false,

packages/gitbook/src/routes/markdownPage.ts

@@ -1,12 +1,17 @@
 import type { GitBookSiteContext } from '@/lib/context';
 import { throwIfDataError } from '@/lib/data';
-import { isNodeEmpty } from '@/lib/document';
 import { resolvePagePathDocumentOrGroup } from '@/lib/pages';
 import { getIndexablePages } from '@/lib/sitemap';
 import { getMarkdownForPagesTree } from '@/routes/llms';
 import { type RevisionPageDocument, type RevisionPageGroup, RevisionPageType } from '@gitbook/api';
 import type { Root } from 'mdast';
+import { fromMarkdown } from 'mdast-util-from-markdown';
+import { frontmatterFromMarkdown } from 'mdast-util-frontmatter';
+import { gfmFromMarkdown } from 'mdast-util-gfm';
 import { toMarkdown } from 'mdast-util-to-markdown';
+import { frontmatter } from 'micromark-extension-frontmatter';
+import { gfm } from 'micromark-extension-gfm';
+import { remove } from 'unist-util-remove';
 
 /**
  * Generate a markdown version of a page.
@@ -26,13 +31,11 @@ export async function servePageMarkdown(context: GitBookSiteContext, pagePath: s
         return new Response(`Page "${pagePath}" is not a document or group`, { status: 404 });
     }
 
-    // Handle group pages and empty document pages with children
-    const isGroupPage = await shouldTreatAsGroupPage(context, page);
-    if (isGroupPage) {
+    // Handle group pages
+    if (page.type === RevisionPageType.Group) {
         return servePageGroup(context, page);
     }
 
-    // Handle regular document pages
     const markdown = await throwIfDataError(
         context.dataFetcher.getRevisionPageMarkdown({
             spaceId: context.space.id,
@@ -41,6 +44,11 @@ export async function servePageMarkdown(context: GitBookSiteContext, pagePath: s
         })
     );
 
+    // Handle empty document pages which have children
+    if (isEmptyPage(markdown) && page.pages.length > 0) {
+        return servePageGroup(context, page);
+    }
+
     return new Response(markdown, {
         headers: {
             'Content-Type': 'text/markdown; charset=utf-8',
@@ -49,28 +57,33 @@ export async function servePageMarkdown(context: GitBookSiteContext, pagePath: s
 }
 
 /**
- * Determine if a page should be treated as a group page.
- * A page is treated as a group if:
- * 1. It's explicitly a group page type, OR
- * 2. It's a document page but has empty content (acts as a container)
+ * Determine if a page is empty.
+ * A page is empty if it has no content or only a title.
  */
-async function shouldTreatAsGroupPage(
-    context: GitBookSiteContext,
-    page: RevisionPageDocument | RevisionPageGroup
-): Promise<boolean> {
-    if (page.type === RevisionPageType.Group) {
+function isEmptyPage(pageMarkdown: string): boolean {
+    const trimmedMarkdown = pageMarkdown.trim();
+
+    // Check if the markdown is empty
+    if (!trimmedMarkdown) {
         return true;
     }
 
-    const document = await throwIfDataError(
-        context.dataFetcher.getRevisionPageDocument({
-            spaceId: context.space.id,
-            revisionId: context.revision.id,
-            pageId: page.id,
-        })
-    );
+    // Parse the markdown to check if it only contains a title
+
+    const tree = fromMarkdown(pageMarkdown, {
+        extensions: [frontmatter(['yaml']), gfm()],
+        mdastExtensions: [frontmatterFromMarkdown(['yaml']), gfmFromMarkdown()],
+    });
+
+    // Remove frontmatter
+    remove(tree, 'yaml');
+
+    // If the page has no content or only a title, it is empty
+    if (tree.children.length <= 1 && tree.children[0]?.type === 'heading') {
+        return true;
+    }
 
-    return isNodeEmpty(document);
+    return false;
 }
 
 /**
@@ -88,6 +101,7 @@ async function servePageGroup(
 
     const indexablePages = getIndexablePages(page.pages);
 
+    // Create a markdown tree with the page title as heading and a list of child pages
     const markdownTree: Root = {
         type: 'root',
         children: [