@kirchdev/duxt 0.3.4-dev-main.40-7fa9937 → 0.3.4

package/app/components/DuxtVersion.vue

@@ -24,7 +24,7 @@ const props = withDefaults(defineProps<{ variant?: 'badge' | 'block' }>(), {
 const duxt = useDuxtConfig();
 const path = useDuxtPath();
 const localeLink = useDuxtLink();
-const { collection, source } = useDuxtCollection();
+const { source } = useDuxtCollection();
 
 /**
  * Versions come from the resolved source manifest, so the control can only
@@ -35,31 +35,13 @@ const { collection, source } = useDuxtCollection();
  */
 const { choices: versions } = useDuxtVersion();
 
-/**
- * A changelog is one global history, so it deliberately has no version
- * selector. Its current release is still useful context, though: read the
- * latest one from the overview's generated frontmatter instead of falling
- * back to the site's package version. The parser writes that value while
- * turning the changelog into the overview and release pages.
- */
+/** A global changelog switches between its source's documentation editions. */
 const changelog = computed(
   () =>
     source.value?.generated?.type === 'changelog' &&
     source.value.generated.versioning === 'global'
 );
 
-const { data: changelogPage } = await useAsyncData(
-  () => `duxt-changelog-version-${collection.value}-${path.value}`,
-  async () => {
-    if (!changelog.value) return undefined;
-
-    return (await queryCollection(collection.value as DuxtCollectionArg)
-      .path(path.value)
-      .first()) as { release?: string } | null;
-  },
-  { watch: [collection, path, changelog] }
-);
-
 const current = computed(() =>
   sourceForPath(
     path.value,
@@ -67,9 +49,7 @@ const current = computed(() =>
   )
 );
 
-const label = computed(
-  () => changelogPage.value?.release ?? current.value?.label ?? duxt.version
-);
+const label = computed(() => current.value?.label ?? duxt.version);
 
 const { t, te } = useI18n();
 
@@ -92,7 +72,12 @@ function caption(version: DuxtLink) {
 /** Same page, other version: swap the prefix rather than jumping to its root. */
 function pathIn(version: { to?: string }) {
   return localeLink(
-    versionPath(path.value, current.value?.to, version.to ?? '/')
+    versionPath(
+      path.value,
+      current.value?.to,
+      version.to ?? '/',
+      changelog.value
+    )
   );
 }
 </script>

package/app/utils/section-scope.ts

@@ -15,14 +15,60 @@
  * that lives there: prefix work done inline in a component can only be checked
  * by clicking.
  */
-import { isInside, sourceForPath } from './version-paths';
+import { isInside, sourceForPath, versionPath } from './version-paths';
 
 /** The minimum a source has to carry to place a path or an entry. */
 interface Area {
   prefix: string;
+  repo?: string;
+  version?: string;
   generated?: unknown;
 }
 
+/** The documentation source that owns an area, without a generated section. */
+function documentationFor(source: Area | undefined, sources: Area[]) {
+  if (!source?.generated) return source;
+
+  const candidates = source.repo
+    ? sources.filter(
+        (other) =>
+          !other.generated &&
+          other.repo === source.repo &&
+          (!source.version || other.version === source.version)
+      )
+    : sources.filter(
+        (other) => !other.generated && isInside(source.prefix, other.prefix)
+      );
+
+  // A generated section belongs to the deepest documentation source it hangs
+  // under. A global section has no version of its own, so its area is the
+  // shallowest edition of that source instead.
+  return candidates.sort((a, b) =>
+    source.version || !source.repo
+      ? b.prefix.length - a.prefix.length
+      : a.prefix.length - b.prefix.length
+  )[0];
+}
+
+/** The version-neutral root of a documentation area. */
+function areaRoot(source: Area | undefined, sources: Area[]): string {
+  const documentation = documentationFor(source, sources);
+  if (!documentation) return '';
+
+  // A slug is the source identity and survives the version segment. All
+  // versions of `/demo` are therefore one area, whose shallowest prefix is
+  // the default edition. Sources without an identity retain their own prefix.
+  if (!documentation.repo) return documentation.prefix;
+
+  return sources
+    .filter((other) => !other.generated && other.repo === documentation.repo)
+    .reduce(
+      (root, other) =>
+        other.prefix.length < root.prefix.length ? other : root,
+      documentation
+    ).prefix;
+}
+
 /**
  * The AREAS a site has — one per documentation tree, never per generated
  * section.
@@ -33,7 +79,11 @@ interface Area {
  * of the site and the row would empty out on it.
  */
 const areas = (sources: Area[]): string[] => [
-  ...new Set(sources.filter((source) => !source.generated).map((s) => s.prefix))
+  ...new Set(
+    sources
+      .filter((source) => !source.generated)
+      .map((source) => areaRoot(source, sources))
+  )
 ];
 
 /**
@@ -43,12 +93,7 @@ const areas = (sources: Area[]): string[] => [
  * never asked for any of this.
  */
 export function areaForPath(path: string, sources: Area[]): string {
-  return (
-    sourceForPath(
-      path,
-      areas(sources).map((prefix) => ({ prefix }))
-    )?.prefix ?? ''
-  );
+  return areaRoot(sourceForPath(path, sources), sources);
 }
 
 /**
@@ -66,13 +111,40 @@ export function sectionsForPath<T extends { to?: string }>(
   const area = areaForPath(path, sources);
   const all = areas(sources);
 
-  // Only when the site HAS two areas: with one, every entry is in it, and the
-  // filter is a walk over the list for an answer that cannot change.
-  if (all.length < 2) return sections;
+  // Only when the site HAS two areas does the filter change the membership.
+  // Even one area's hand-written entries may need their URL moved to the
+  // reader's version, so do not return before that mapping below.
+  const scoped =
+    all.length < 2
+      ? sections
+      : sections.filter(
+          (section) => !section.to || areaForPath(section.to, sources) === area
+        );
+
+  const reader = documentationFor(sourceForPath(path, sources), sources);
+  if (!reader?.version) return scoped;
+
+  return scoped.map((section) => {
+    const target = section.to ? sourceForPath(section.to, sources) : undefined;
+
+    // A consumer declares the overview once, at the default edition. It is a
+    // part of every version of the same documentation source, so move it to
+    // the reader's edition. Generated sections already resolve their own
+    // per-version destination, and global generated sections must stay global.
+    if (
+      target &&
+      !target.generated &&
+      target.repo === reader.repo &&
+      target.version !== reader.version
+    ) {
+      return {
+        ...section,
+        to: versionPath(section.to!, target.prefix, reader.prefix)
+      } as T;
+    }
 
-  return sections.filter(
-    (section) => !section.to || areaForPath(section.to, sources) === area
-  );
+    return section;
+  });
 }
 
 /**

package/app/utils/version-choices.ts

@@ -65,11 +65,22 @@ export function versionChoices(
   current: DuxtResolvedSource | undefined,
   configured: DuxtLink[] | undefined
 ): DuxtLink[] {
-  // A version-neutral generated section suppresses the control entirely, and
-  // that is the point of the policy rather than a tidy-up: a changelog is one
-  // global history, so every entry the switcher could offer would move the
-  // reader to a URL that section does not serve.
-  if (current?.generated?.versioning === 'global') return [];
+  // A global generated section has no version of its own, but its reader still
+  // needs the documentation context of the source that owns it. Start from
+  // that source's default edition: its choices lead to the version overviews,
+  // never to non-existent versioned copies of the generated section.
+  const global = current?.generated?.versioning === 'global';
+
+  if (global && current?.generated?.type !== 'changelog') return [];
+
+  const context = global
+    ? sources.find(
+        (source) =>
+          source.repo === current.repo && source.isDefault && !source.generated
+      )
+    : current;
+
+  if (!context) return [];
 
   // `versions` in the config still wins where a label needs to read differently
   // from the URL segment.
@@ -81,8 +92,8 @@ export function versionChoices(
     .filter(
       (source) =>
         source.version &&
-        source.repo === current?.repo &&
-        sameArtefact(source, current)
+        source.repo === context.repo &&
+        sameArtefact(source, context)
     )
     .filter((source) => {
       // Repository and artefact are scoped above; translations share the

package/app/utils/version-paths.ts

@@ -43,8 +43,11 @@ export function isInside(path: string, prefix: string): boolean {
 export function versionPath(
   path: string,
   from: string | undefined,
-  to: string
+  to: string,
+  overview = false
 ): string {
+  if (overview) return to || '/';
+
   const rest =
     from && from !== '/' && isInside(path, from)
       ? path.slice(from.length)

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://www.schemastore.org/package.json",
   "name": "@kirchdev/duxt",
-  "version": "0.3.4-dev-main.40-7fa9937",
+  "version": "0.3.4",
   "description": "Nuxt documentation layer on Content v3 — multi-repo, versioned docs from one compact source list.",
   "keywords": [
     "content-v3",