@kirchdev/duxt 0.1.1-dev.15-83cfebe → 0.1.1-dev.17-509021b

package/app/composables/useDuxtSearch.ts

@@ -1,3 +1,5 @@
+import type { DuxtResolvedSource } from '../../sources-resolve';
+import { searchSources } from '../utils/search-scope';
 import type { DuxtSearchSection } from '@duxt/composables/useFuzzySearch';
 
 /** A hit, with the source it came out of. */
@@ -22,18 +24,19 @@ export interface DuxtSearchHit extends DuxtSearchSection {
  * The source being read goes first in each round, because a reader searching
  * inside a project usually means that project.
  *
- * ONE VERSION PER REPOSITORY. Searching every version returns each page as many
+ * ONE VERSION PER ARTEFACT. Searching every version returns each page as many
  * times as there are versions, which buries the answer under its own history.
- * So each repository contributes the version the reader is in, or its default.
+ * Each docs tree and generated declaration contributes its current or default edition.
  */
 export function useDuxtSearch() {
   const duxt = useDuxtConfig();
   const { source } = useDuxtCollection();
+  const { locale, fallbackLocale } = useI18n();
 
   const sources = computed(() => duxt.resolvedSources ?? []);
 
   /**
-   * The collections to search, one per repository.
+   * The available collections; only selected editions are initialized.
    *
    * Fixed at setup, deliberately: each one needs its own `useSearchCollection`,
    * and a composable list that grows with the route is not a thing. The
@@ -79,38 +82,54 @@ export function useDuxtSearch() {
     }).search
   }));
 
-  /** One entry per repository: the version being read, else that repo's default. */
-  const active = computed(() => {
-    const current = source.value;
-    const byRepo = new Map<string, (typeof searchable)[number]>();
-
-    for (const entry of searchable) {
-      const key = entry.repo ?? '';
-      const chosen = byRepo.get(key);
-
-      if (entry.collection === current?.collection) {
-        byRepo.set(key, entry);
-        continue;
-      }
-
-      if (chosen?.collection === current?.collection) continue;
-      if (!chosen || (entry.isDefault && !chosen.isDefault)) {
-        byRepo.set(key, entry);
-      }
+  /** Selected editions, ordered by artefact and then preferred language. */
+  const active = computed(() =>
+    searchSources(
+      searchable,
+      source.value,
+      locale.value,
+      fallbackLocale.value as string | string[] | undefined
+    )
+  );
+
+  const pagePaths = new Map<string, Promise<Set<string>>>();
+  function paths(collection: string) {
+    let pending = pagePaths.get(collection);
+    if (!pending) {
+      pending = queryCollection(collection as DuxtCollectionArg)
+        .select('path')
+        .all()
+        .then((pages) => new Set(pages.map((page) => page.path)))
+        .catch((error) => {
+          pagePaths.delete(collection);
+          throw error;
+        });
+      pagePaths.set(collection, pending);
     }
+    return pending;
+  }
 
-    // The source being read leads; the rest keep the config's own order.
-    return [...byRepo.values()].sort((a, b) =>
-      a.collection === current?.collection
-        ? -1
-        : b.collection === current?.collection
-          ? 1
-          : 0
+  // A fallback may answer only for a PAGE absent from every better language,
+  // even when a heading or the search term exists only in the original.
+  async function visiblePages(wanted: DuxtResolvedSource[]) {
+    return Promise.all(
+      wanted.map(async (entry, index) => {
+        const preferred = wanted
+          .slice(0, index)
+          .filter((other) => other.prefix === entry.prefix);
+        return new Set(
+          (
+            await Promise.all(preferred.map((other) => paths(other.collection)))
+          ).flatMap((pages) => [...pages])
+        );
+      })
     );
-  });
+  }
 
   /** Only worth a badge when there is more than one thing to tell apart. */
-  const labelled = computed(() => active.value.length > 1);
+  const labelled = computed(
+    () => new Set(active.value.map((entry) => entry.prefix)).size > 1
+  );
 
   const labelOf = (entry: (typeof searchable)[number]) =>
     [entry.repo, entry.version].filter(Boolean).join(' ') ||
@@ -119,8 +138,8 @@ export function useDuxtSearch() {
 
   async function init() {
     await Promise.all(
-      searches
-        .filter((search) => active.value.includes(search.entry))
+      active.value
+        .map((entry) => searches.find((search) => search.entry === entry)!)
         .filter((search) => search.status.value === 'idle')
         .map((search) => search.init())
     );
@@ -153,17 +172,41 @@ export function useDuxtSearch() {
     term: string,
     limit = 20
   ): Promise<{ hits: DuxtSearchHit[]; approximate: boolean }> {
-    if (!term.trim()) return { hits: [], approximate: false };
+    if (!term.trim() || limit <= 0) return { hits: [], approximate: false };
 
     const wanted = active.value;
+    const hidden = await visiblePages(wanted);
+    async function visible(
+      query: (requested: number) => Promise<DuxtSearchSection[]>,
+      index: number
+    ) {
+      let requested = limit;
+      while (true) {
+        const hits = await query(requested);
+        const shown = hits.filter(
+          (hit) => !hidden[index]!.has(hit.id.split('#')[0]!)
+        );
+        if (
+          shown.length >= limit ||
+          hits.length < requested ||
+          !hidden[index]!.size
+        )
+          return shown.slice(0, limit);
+        requested *= 2;
+      }
+    }
 
     const lists = await Promise.all(
-      searches
-        .filter((entry) => wanted.includes(entry.entry))
-        .map(async (entry) => {
-          const hits = (await entry.search(term, {
-            limit
-          })) as DuxtSearchSection[];
+      wanted
+        .map((source) => searches.find((entry) => entry.entry === source)!)
+        .map(async (entry, index) => {
+          const hits = await visible(
+            async (requested) =>
+              (await entry.search(term, {
+                limit: requested
+              })) as DuxtSearchSection[],
+            index
+          );
 
           return hits.map((hit) => ({
             ...hit,
@@ -184,10 +227,13 @@ export function useDuxtSearch() {
     // leaves the reader with an empty box. Fuse gets a second look, over the
     // same sources and merged the same way.
     const fuzzy = await Promise.all(
-      approximate
-        .filter((entry) => wanted.includes(entry.entry))
-        .map(async (entry) => {
-          const hits = await entry.search(term, limit);
+      wanted
+        .map((source) => approximate.find((entry) => entry.entry === source)!)
+        .map(async (entry, index) => {
+          const hits = await visible(
+            (requested) => entry.search(term, requested),
+            index
+          );
 
           return hits.map((hit) => ({
             ...hit,

package/app/utils/search-scope.ts

@@ -0,0 +1,41 @@
+import {
+  sourcesForRoute,
+  type DuxtResolvedSource
+} from '../../sources-resolve';
+
+/** Select the editions participating in site-wide search. */
+export function searchSources(
+  sources: DuxtResolvedSource[],
+  current: DuxtResolvedSource | undefined,
+  locale?: string,
+  fallbackLocale?: string | string[]
+): DuxtResolvedSource[] {
+  const byArtefact = new Map<string, DuxtResolvedSource>();
+  for (const entry of sources) {
+    const key = JSON.stringify([entry.repo, entry.generated?.declaration]);
+    const chosen = byArtefact.get(key);
+    if (entry.collection === current?.collection) {
+      byArtefact.set(key, entry);
+      continue;
+    }
+    if (chosen?.collection === current?.collection) continue;
+    if (!chosen || (entry.isDefault && !chosen.isDefault))
+      byArtefact.set(key, entry);
+  }
+  return [...byArtefact.values()]
+    .sort((a, b) =>
+      a.collection === current?.collection
+        ? -1
+        : b.collection === current?.collection
+          ? 1
+          : 0
+    )
+    .flatMap((edition) =>
+      sourcesForRoute(
+        edition.prefix,
+        locale ?? current?.locale,
+        sources.filter((entry) => entry.prefix === edition.prefix),
+        fallbackLocale
+      )
+    );
+}

package/package.json

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

package/sources-git.ts

@@ -1,6 +1,11 @@
 import { execFileSync } from 'node:child_process';
 import type { DuxtSource } from './sources-resolve';
-import { isLatestRef, newestTag, repoUrl } from './sources-resolve';
+import {
+  expandSources,
+  isLatestRef,
+  newestTag,
+  repoUrl
+} from './sources-resolve';
 
 /**
  * Resolve the `latest` shorthand into the tag it means.
@@ -81,6 +86,8 @@ function tagsOf(repo: string | undefined): string[] {
  * resolver itself stays pure and testable — it never learns that git exists.
  */
 export function resolveLatestRefs(sources: DuxtSource[]): DuxtSource[] {
+  // Reject local refs before a missing tag can hide the configuration error.
+  expandSources(sources);
   return sources.map((source) => {
     if (!source.refs?.some(isLatestRef)) return source;
 

package/sources-resolve.ts

@@ -12,10 +12,10 @@ import type {
 export interface DuxtSource {
   /** Folder holding the Markdown, relative to the repository root. */
   path?: string;
-  /** `owner/name` or a full git URL. Omitted means this repository. */
+  /** `owner/name` or a full git URL. Omitted reads the local checkout. */
   repo?: string;
   /**
-   * Refs to publish as versions. Omitted means the current checkout.
+   * Refs to publish as versions. Requires an explicit source or locale repo.
    *
    * A bare string is a branch. A tag has to say so — git keeps the two in
    * separate namespaces, and asking for a tag under refs/heads fails the
@@ -166,7 +166,7 @@ export type DuxtSourceLocale =
       path?: string;
       /** A repository of its own — `owner/name` or a git URL. */
       repo?: string;
-      /** A ref of its own, when the translation is versioned separately. */
+      /** A ref of its own; requires an explicit source or locale repo. */
       ref?: DuxtRef;
     };
 
@@ -488,12 +488,16 @@ export function expandSources(
 
   return sources.flatMap((source) =>
     (source.refs?.length ? source.refs : [undefined]).flatMap((ref) =>
-      localesOf(source, ref).map((locale) => ({
-        source,
-        ref,
-        locale,
-        effective: localeEntry(source, locale, defaultLocale)
-      }))
+      localesOf(source, ref).map((locale) => {
+        const effective = localeEntry(source, locale, defaultLocale);
+        if (!effective.repo && (effective.ref ?? ref)) {
+          throw new Error(
+            `duxt: source "${source.path ?? 'docs'}" reads the local checkout and cannot select a ref. ` +
+              'Set an explicit repo to publish Git refs, or use version folders without refs.'
+          );
+        }
+        return { source, ref, locale, effective };
+      })
     )
   );
 }