@kirchdev/duxt 0.8.0 → 0.8.1

package/app/components/DuxtHeader.vue

@@ -98,9 +98,19 @@ watch(
 );
 
 // One tree instead of two lists: the sections become children of the entry
-// that stands for the documentation. See `buildSheetNavigation`.
+// that stands for the documentation. See `buildSheetNavigation`. Without the
+// sections the edition being read does not have — see `sectionsInEdition`.
 const sheet = computed(() =>
-  buildSheetNavigation(duxt.navigation, duxt.sections, duxt.resolvedSources)
+  buildSheetNavigation(
+    duxt.navigation,
+    sectionsInEdition(
+      duxt.sections ?? [],
+      duxt.resolvedSources ?? [],
+      path.value,
+      navigation.value
+    ),
+    duxt.resolvedSources
+  )
 );
 
 /** A group owns the page when any of its children does. */

package/app/composables/useDuxtSectionRow.ts

@@ -12,18 +12,36 @@
 export function useDuxtSectionRow() {
   const duxt = useDuxtConfig();
   const path = useDuxtPath();
+  const { data: navigation } = useDuxtNavigation();
 
   /**
    * THIS AREA'S ENTRIES, not every entry the site declared — see
    * `sectionsForPath`. A second source has top-level parts of its own, and the
    * row is "the parts of what you are reading" rather than a site index.
    */
-  const sections = computed(() =>
+  const scoped = computed(() =>
     sectionsForPath(duxt.sections ?? [], duxt.resolvedSources ?? [], path.value)
   );
 
+  /**
+   * AND ONLY THOSE THIS EDITION HAS — see `sectionsInEdition`. Read from the
+   * same navigation the sidebar and the header already load, so it costs no
+   * query of its own.
+   */
+  const sections = computed(() =>
+    sectionsInEdition(
+      scoped.value,
+      duxt.resolvedSources ?? [],
+      path.value,
+      navigation.value
+    )
+  );
+
+  // From the unfiltered list: the page being read exists, so its own entry is
+  // never one the edition lacks, and the header must not move while the tree
+  // is still loading.
   const visible = computed(() =>
-    sections.value.some(
+    scoped.value.some(
       (section) => section.to && path.value.startsWith(section.to)
     )
   );

package/app/utils/section-scope.ts

@@ -208,6 +208,67 @@ export function sectionsForPath<T extends { to?: string }>(
   });
 }
 
+/** The least of a navigation node this file reads: where it is, and below. */
+interface NavigationNode {
+  path: string;
+  children?: NavigationNode[];
+}
+
+/**
+ * The entries whose page EXISTS in the edition being read.
+ *
+ * The row is declared once, for the site as it is today, and every edition
+ * shares it. A section added after a release — `/add-ons` beside the guides —
+ * is therefore offered on that release and on every older one, where its page
+ * was never written, and the entry is a link to a 404 on every page of them.
+ *
+ * So an entry pointing into the reader's own edition is kept only when that
+ * edition's navigation has its page, or a page under it. Everything this cannot
+ * judge stays: an entry without `to`, one at the site root, one into another
+ * source or a generated section (which has no place in this tree), one at a
+ * different edition than the reader's, and every entry while the tree is still
+ * unknown — an entry hidden by a lookup that has not answered yet is a part of
+ * the site that disappears for no reason.
+ */
+export function sectionsInEdition<T extends { to?: string }>(
+  sections: T[],
+  sources: Area[],
+  path: string,
+  navigation: readonly NavigationNode[] | null | undefined
+): T[] {
+  // The tree is the one the reader's page is in. On a generated section's page
+  // — a release, an endpoint — that is the section's own, and judging the
+  // documentation's entries against it would empty the row.
+  const reader = sourceForPath(path, sources);
+  if (!navigation || !reader || reader.generated) return sections;
+
+  const pages: string[] = [];
+  const walk = (nodes: readonly NavigationNode[]) => {
+    for (const node of nodes) {
+      pages.push(node.path);
+      if (node.children) walk(node.children);
+    }
+  };
+  walk(navigation);
+
+  return sections.filter((section) => {
+    const to = section.to;
+    if (!to || to === '/') return true;
+
+    const target = sourceForPath(to, sources);
+    if (
+      !target ||
+      target.generated ||
+      !sameTree(target, reader, sources) ||
+      target.version !== reader.version
+    ) {
+      return true;
+    }
+
+    return pages.some((page) => isInside(page, to));
+  });
+}
+
 /**
  * WHICH ONE of an area's entries is the one being read.
  *

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://www.schemastore.org/package.json",
   "name": "@kirchdev/duxt",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "duxt is a Nuxt layer: extend it and your docs/ folder becomes a site, with theme, search, API reference and llms.txt included. Point it at other repositories, or at tags of the same one, and each becomes a version.",
   "keywords": [
     "content-v3",