perf(navigation): skip leaf scans without placeholders

Author: onmax

src/runtime/internal/navigation.ts

@@ -46,6 +46,24 @@ export async function generateNavigationTree<T extends PageCollectionItemBase>(q
     ...(isObject(content?.navigation) ? (content.navigation as Record<string, unknown>) : {}),
   })
 
+  const checkedChildren = new WeakMap<ContentNavigationItem[], number | false>()
+
+  // Existing child arrays only grow by appending; merges create new arrays.
+  function findPlaceholder(nodes: ContentNavigationItem[], path: string) {
+    let checked = checkedChildren.get(nodes) ?? 0
+    if (checked !== false) {
+      while (checked < nodes.length && nodes[checked]!.page !== false) {
+        checked++
+      }
+      if (checked === nodes.length) {
+        checkedChildren.set(nodes, checked)
+        return
+      }
+      checkedChildren.set(nodes, false)
+    }
+    return nodes.find(item => item.path === path && item.page === false)
+  }
+
   // Create navigation object
   const nav = contents
     .reduce((nav, content) => {
@@ -146,7 +164,7 @@ export async function generateNavigationTree<T extends PageCollectionItemBase>(q
       }, nav)
 
       // Check for duplicate link
-      const existed = siblings.find(item => item.path === navItem.path && item.page === false)
+      const existed = findPlaceholder(siblings, navItem.path)
       if (existed) {
         Object.assign(existed, {
           ...navItem,

test/unit/generateNavigationTree.test.ts

@@ -17,6 +17,83 @@ describe('generateNavigationTree', () => {
     all: async () => items,
   } as unknown as CollectionQueryBuilder<PageCollectionItemBase>)
 
+  const queryInOrder = (items: Partial<PageCollectionItemBase>[]) => ({
+    __params: { orderBy: ['caller order'] },
+    orWhere() { return this },
+    select() { return this },
+    all: async () => items,
+  } as unknown as CollectionQueryBuilder<PageCollectionItemBase>)
+
+  it.each([false, true])('skips leaf sibling searches with an explicit index: %s', async (withIndex) => {
+    const pages = Array.from({ length: 100 }, (_, i) => ({
+      title: `Page ${i}`,
+      path: `/guide/page-${100 - i}`,
+      stem: `guide/page-${100 - i}`,
+    }))
+    const items = withIndex ? [{ title: 'Guide', path: '/guide', stem: 'guide/index' }, ...pages] : pages
+    const find = vi.spyOn(Array.prototype, 'find')
+    try {
+      const tree = await generateNavigationTree(queryInOrder(items))
+      const searches = find.mock.calls.length
+      expect(searches).toBe(pages.length + Number(withIndex))
+      expect(tree[0]?.children?.map(item => item.path)).toEqual(items.map(item => item.path))
+    }
+    finally {
+      find.mockRestore()
+    }
+  })
+
+  it.each([false, true])('merges a placeholder appended after a leaf, from metadata: %s', async (fromMetadata) => {
+    const tree = await generateNavigationTree(queryInOrder([
+      { title: 'First', path: '/guide/first', stem: 'guide/first' },
+      fromMetadata
+        ? { title: 'Placeholder', path: '/guide/topic', stem: 'guide/topic', navigation: { page: false } }
+        : { title: 'Child', path: '/guide/topic/child', stem: 'guide/topic/child' },
+      { title: 'Topic', path: '/guide/topic', stem: 'guide/topic' },
+    ]))
+
+    expect(tree[0]?.children?.map(item => item.path)).toEqual(['/guide/first', '/guide/topic'])
+    expect(tree[0]?.children?.[1]).toMatchObject({ title: 'Topic', page: undefined })
+    expect(tree[0]?.children?.[1]?.children?.map(item => item.path)).toEqual(fromMetadata ? undefined : ['/guide/topic/child'])
+  })
+
+  it.each([false, true])('merges supplied duplicate placeholders in order, from directory config: %s', async (fromConfig) => {
+    const children = ['First', 'Second'].map(title => ({
+      title,
+      path: '/guide/topic',
+      page: false,
+      children: [{ title, path: `/guide/topic/${title.toLowerCase()}` }],
+    }))
+    const roots = fromConfig
+      ? [
+          { title: 'Config', path: '/guide/.navigation', stem: 'guide/.navigation', meta: { children } },
+          { title: 'Guide', path: '/guide', stem: 'guide/index' },
+        ]
+      : [{ title: 'Guide', path: '/guide', stem: 'guide', navigation: { children } }]
+    const tree = await generateNavigationTree(queryInOrder([
+      ...roots,
+      { title: 'Replacement 1', path: '/guide/topic', stem: 'guide/topic' },
+      { title: 'Replacement 2', path: '/guide/topic', stem: 'guide/topic' },
+    ]))
+
+    expect(tree[0]?.children?.map(item => item.title)).toEqual(['Replacement 1', 'Replacement 2'])
+    expect(tree[0]?.children?.map(item => item.page)).toEqual([undefined, undefined])
+    expect(tree[0]?.children?.map(item => item.children?.[0]?.path)).toEqual(['/guide/topic/first', '/guide/topic/second'])
+  })
+
+  it.each([false, true])('preserves index merging and later siblings, child first: %s', async (childFirst) => {
+    const index = { title: 'Topic', path: '/guide/topic', stem: 'guide/topic/index' }
+    const child = { title: 'First', path: '/guide/topic/first', stem: 'guide/topic/first' }
+    const tree = await generateNavigationTree(queryInOrder([
+      ...(childFirst ? [child, index] : [index, child]),
+      { title: 'Second', path: '/guide/topic/second', stem: 'guide/topic/second' },
+    ]))
+
+    expect(tree[0]?.children?.[0]?.children?.map(item => item.path)).toEqual([
+      '/guide/topic', '/guide/topic/first', '/guide/topic/second',
+    ])
+  })
+
   it('should generate a basic navigation tree', async () => {
     const items = [
       {