@lupinum/ginko-content 0.1.0

package/dist/features/localization/translated-slugs.js

@@ -0,0 +1,80 @@
+const TRANSLATED_SLUG_SEGMENT_RE = /^(\d+)\.(.+)$/;
+const getTranslatedSlugEntries = (document, locales = []) => {
+  const file = (document._file || "").replace(/^\/+/, "");
+  const parts = file.split("/").filter(Boolean);
+  const localizedParts = parts[0] && locales.includes(parts[0]) ? parts.slice(1) : parts;
+  if (!localizedParts.length) {
+    return [];
+  }
+  const locale = document._locale || "";
+  const directories = localizedParts.slice(0, -1);
+  const basename = localizedParts[localizedParts.length - 1] || "";
+  const entries = [];
+  let parentKey = "/";
+  for (const directory of directories) {
+    const match = directory.match(TRANSLATED_SLUG_SEGMENT_RE);
+    entries.push({
+      locale,
+      file: document._file || document._id,
+      parentKey,
+      raw: directory,
+      number: match?.[1],
+      kind: "dir"
+    });
+    parentKey = match?.[1] ? `${parentKey}${parentKey === "/" ? "" : "/"}${match[1]}` : `${parentKey}${parentKey === "/" ? "" : "/"}${directory}`;
+  }
+  if (!/^index\./.test(basename) && !/^\.(navigation)(\.[^.]+)?$/.test(basename)) {
+    const match = basename.match(TRANSLATED_SLUG_SEGMENT_RE);
+    entries.push({
+      locale,
+      file: document._file || document._id,
+      parentKey,
+      raw: basename,
+      number: match?.[1],
+      kind: "file"
+    });
+  }
+  return entries;
+};
+export const collectTranslatedSlugValidationIssues = (contents, options) => {
+  if (!options.translatedSlugs) {
+    return [];
+  }
+  const issues = [];
+  const seenEntries = /* @__PURE__ */ new Set();
+  const siblingNumbers = /* @__PURE__ */ new Map();
+  for (const document of contents) {
+    const entries = getTranslatedSlugEntries(document, options.locales || []);
+    const hasMissingPrefix = entries.some((entry) => !entry.number);
+    if (hasMissingPrefix) {
+      issues.push({
+        level: "warn",
+        file: document._file || document._id,
+        reason: "translated slug mode expects numeric prefixes for localized route segments"
+      });
+    }
+    for (const entry of entries) {
+      if (!entry.number) {
+        continue;
+      }
+      const entryKey = `${entry.locale}:${entry.parentKey}:${entry.kind}:${entry.raw}`;
+      if (seenEntries.has(entryKey)) {
+        continue;
+      }
+      seenEntries.add(entryKey);
+      const siblingKey = `${entry.locale}:${entry.parentKey}:${entry.number}`;
+      const previous = siblingNumbers.get(siblingKey);
+      if (previous && previous.raw !== entry.raw) {
+        issues.push({
+          level: "error",
+          file: entry.file,
+          reason: `duplicate numeric prefix "${entry.number}" among localized siblings`,
+          details: `conflicts with ${previous.file}`
+        });
+        continue;
+      }
+      siblingNumbers.set(siblingKey, entry);
+    }
+  }
+  return issues;
+};

package/dist/features/navigation/build

@@ -0,0 +1 @@
+export * from './build.js'

package/dist/features/navigation/build.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Build the navigation tree from a flat list of content metadata.
+ *
+ * The input is a flat list of content rows with `title`, `_path`, `_file`, and
+ * optional extra fields; the output is a `NavItem[]` tree where parent folders
+ * are synthesized from path segments and `/.navigation.yml` config entries
+ * can override titles and metadata per directory.
+ *
+ * Key behaviors to know before touching this code:
+ *
+ *  - **Index-file promotion** — a `guide/index.md` becomes the `guide`
+ *    folder's own nav entry, not a child. Its siblings-under-`guide`
+ *    become its children.
+ *  - **`.navigation.yml`** — `configs['/guide']` can set `navigation: false`
+ *    on a directory to hide the entire subtree from navigation; or
+ *    override `title`/other fields.
+ *  - **Natural sort** — siblings sort by `_file` (filename without the
+ *    extension) via `Intl.Collator({ numeric: true })`, so `10-foo` comes
+ *    after `2-foo`, not between `1-foo` and `20-foo`.
+ *  - **Two-pass shaping** — we build a mutable canonical tree, then project it
+ *    into the public navigation contract. Synthetic folders keep canonical
+ *    identity internally and become pathless public groups at the projection
+ *    boundary.
+ */
+import type { NavItem, ParsedContentMeta } from '../../types/content';
+import { type CanonicalNavigationItem } from './canonical';
+export declare const buildCanonicalNavigation: (contents: ParsedContentMeta[], configs: Record<string, ParsedContentMeta>, fields?: string[]) => CanonicalNavigationItem[];
+export declare const buildNavigation: (contents: ParsedContentMeta[], configs: Record<string, ParsedContentMeta>, fields?: string[]) => NavItem[];

package/dist/features/navigation/build.js

@@ -0,0 +1,104 @@
+import { generateTitle } from "../../core/content/path";
+import { projectNavigationTree } from "./canonical.js";
+const collator = new Intl.Collator(void 0, { numeric: true, sensitivity: "base" });
+const pick = (keys) => (obj) => {
+  const target = obj || {};
+  if (!keys?.length) {
+    return target;
+  }
+  return keys.filter((key) => typeof target[key] !== "undefined").reduce((newObject, key) => Object.assign(newObject, { [key]: target[key] }), {});
+};
+const isObject = (value) => Object.prototype.toString.call(value) === "[object Object]";
+const parentCanonicalKey = (content, depth) => {
+  const canonicalKey = content._canonicalKey;
+  if (typeof canonicalKey !== "string" || !canonicalKey) {
+    return void 0;
+  }
+  return canonicalKey.split("/").slice(0, depth + 1).join("/") || void 0;
+};
+const sortCanonicalTree = (items) => {
+  items.forEach((item) => {
+    if (item._file) {
+      item._file = item._file.split(".").slice(0, -1).join(".");
+    }
+  });
+  const sorted = items.sort((left, right) => collator.compare(left._file || "", right._file || ""));
+  for (const item of sorted) {
+    if (item.children?.length) {
+      sortCanonicalTree(item.children);
+    } else {
+      delete item.children;
+    }
+  }
+  return items;
+};
+export const buildCanonicalNavigation = (contents, configs, fields = []) => {
+  const pickNavigationFields = (content) => ({
+    ...pick(["title", ...fields])(content),
+    ...isObject(content?.navigation) ? content.navigation : {}
+  });
+  const navigation = contents.sort((left, right) => left._path.localeCompare(right._path)).reduce((nav, content) => {
+    const parts = content._path.substring(1).split("/");
+    const idParts = content._id.split(":").slice(1);
+    const isIndex = Boolean(idParts[idParts.length - 1]?.match(/([1-9][0-9]*\.)?index.md/g));
+    const navItem = {
+      title: content.title,
+      _path: content._path,
+      path: content._path,
+      _file: content._file,
+      _id: content._id,
+      _canonicalKey: content._canonicalKey,
+      _locale: content._locale,
+      _navigationKind: "page",
+      _navigationPath: content._path,
+      children: [],
+      ...pickNavigationFields(content),
+      ...content._draft ? { _draft: true } : {}
+    };
+    if (isIndex) {
+      const dirConfig = configs[navItem._path];
+      if (typeof dirConfig?.navigation !== "undefined" && !dirConfig.navigation) {
+        return nav;
+      }
+      if (dirConfig) {
+        Object.assign(navItem, pickNavigationFields(dirConfig));
+      }
+    }
+    if (parts.length === 1) {
+      nav.push(navItem);
+      return nav;
+    }
+    const siblings = parts.slice(0, -1).reduce((nodes, part, index) => {
+      const currentPathPart = `/${parts.slice(0, index + 1).join("/")}`;
+      const config = configs[currentPathPart];
+      if (typeof config?.navigation !== "undefined" && !config.navigation) {
+        return [];
+      }
+      let parent = nodes.find((node) => node.path === currentPathPart);
+      if (!parent) {
+        const canonicalKey = parentCanonicalKey(content, index);
+        parent = {
+          title: generateTitle(part),
+          _path: currentPathPart,
+          path: currentPathPart,
+          _file: content._file,
+          _navigationKind: "folder",
+          _navigationPath: currentPathPart,
+          page: false,
+          ...canonicalKey ? { _canonicalKey: canonicalKey } : {},
+          ...content._locale ? { _locale: content._locale } : {},
+          children: [],
+          ...config && pickNavigationFields(config)
+        };
+        nodes.push(parent);
+      }
+      return parent.children;
+    }, nav);
+    siblings.push(navItem);
+    return nav;
+  }, []);
+  return sortCanonicalTree(navigation);
+};
+export const buildNavigation = (contents, configs, fields = []) => {
+  return projectNavigationTree(buildCanonicalNavigation(contents, configs, fields));
+};

package/dist/features/navigation/canonical

@@ -0,0 +1 @@
+export * from './canonical.js'

package/dist/features/navigation/canonical.d.ts

@@ -0,0 +1,33 @@
+import type { ContentNavigationItem, NavItem } from '../../types/content';
+import { type RouteMounts } from '../localization/path';
+export type NavigationNodeKind = 'page' | 'folder';
+export interface CanonicalNavigationItem {
+    title: string;
+    path?: string;
+    _path?: string;
+    stem?: string;
+    page?: false;
+    _id?: string;
+    _canonicalKey?: string;
+    _locale?: string;
+    _fallback?: boolean;
+    _draft?: boolean;
+    _file?: string;
+    _navigationKind?: NavigationNodeKind;
+    _navigationPath?: string;
+    _collectionRoot?: string;
+    children?: CanonicalNavigationItem[];
+    [key: string]: unknown;
+}
+export interface ProjectNavigationOptions {
+    locale?: string;
+    defaultLocale?: string;
+    routeMounts?: RouteMounts;
+    collection?: string;
+    canonical?: boolean;
+}
+export declare const getNavigationIdentity: (node: Pick<CanonicalNavigationItem, "_canonicalKey" | "_path" | "_id">) => string | undefined;
+export declare const mergeCanonicalNavigation: (primary?: CanonicalNavigationItem[], fallback?: CanonicalNavigationItem[]) => CanonicalNavigationItem[];
+export declare const markCollectionNavigationRoot: (navigation?: CanonicalNavigationItem[], collection?: string, options?: Pick<ProjectNavigationOptions, "routeMounts">) => CanonicalNavigationItem[];
+export declare const scopeNavigationTree: (navigation?: CanonicalNavigationItem[], collection?: string) => CanonicalNavigationItem[];
+export declare const projectNavigationTree: (navigation?: CanonicalNavigationItem[] | NavItem[], options?: ProjectNavigationOptions) => ContentNavigationItem[];

package/dist/features/navigation/canonical.js

@@ -0,0 +1,149 @@
+import { getContentStem, normalizeContentPath, projectContentPathToLocale } from "../localization/path.js";
+const isString = (value) => typeof value === "string" && value.length > 0;
+export const getNavigationIdentity = (node) => {
+  if (isString(node._canonicalKey)) {
+    return node._canonicalKey;
+  }
+  return void 0;
+};
+const cloneFallbackNode = (node) => ({
+  ...node,
+  _fallback: true,
+  children: node.children?.map(cloneFallbackNode)
+});
+export const mergeCanonicalNavigation = (primary = [], fallback = []) => {
+  const merged = primary.map((item) => ({
+    ...item,
+    children: item.children ? mergeCanonicalNavigation(item.children, []) : void 0
+  }));
+  const index = /* @__PURE__ */ new Map();
+  for (const item of merged) {
+    const identity = getNavigationIdentity(item);
+    if (identity) {
+      index.set(identity, item);
+    }
+  }
+  for (const fallbackItem of fallback) {
+    const identity = getNavigationIdentity(fallbackItem);
+    if (!identity) {
+      merged.push(cloneFallbackNode(fallbackItem));
+      continue;
+    }
+    const existing = index.get(identity);
+    if (!existing) {
+      const clone = cloneFallbackNode(fallbackItem);
+      merged.push(clone);
+      index.set(identity, clone);
+      continue;
+    }
+    for (const [field, value] of Object.entries(fallbackItem)) {
+      if (field === "children") {
+        continue;
+      }
+      if (typeof existing[field] === "undefined" && typeof value !== "undefined") {
+        existing[field] = value;
+      }
+    }
+    existing.children = mergeCanonicalNavigation(existing.children || [], fallbackItem.children || []);
+  }
+  return merged;
+};
+const normalizeRoutePath = (path) => {
+  if (!isString(path)) {
+    return void 0;
+  }
+  return normalizeContentPath(path);
+};
+const isFolderNode = (item) => {
+  if (item._navigationKind === "folder") {
+    return true;
+  }
+  if (item._navigationKind === "page") {
+    return false;
+  }
+  return Boolean(item.children?.length && !item._id && !item._path && !item.path);
+};
+const matchesCollectionRootConfig = (collection, root, options) => {
+  if (!root.children?.length) {
+    return false;
+  }
+  const identity = getNavigationIdentity(root);
+  if (identity === collection || identity === `/${collection}`) {
+    return true;
+  }
+  const rootPath = normalizeRoutePath(root._path || root._navigationPath || root.path);
+  if (rootPath === "/" || rootPath === `/${collection}`) {
+    return true;
+  }
+  if (rootPath && Object.values(options.routeMounts || {}).map(normalizeContentPath).includes(rootPath)) {
+    return true;
+  }
+  return false;
+};
+export const markCollectionNavigationRoot = (navigation = [], collection, options = {}) => {
+  if (!collection || navigation.length !== 1) {
+    return navigation;
+  }
+  const [root] = navigation;
+  if (!root || root._collectionRoot === collection || !matchesCollectionRootConfig(collection, root, options)) {
+    return navigation;
+  }
+  return [{ ...root, _collectionRoot: collection }];
+};
+export const scopeNavigationTree = (navigation = [], collection) => {
+  if (!collection || navigation.length !== 1) {
+    return navigation;
+  }
+  const [root] = navigation;
+  if (!root?.children?.length || root._collectionRoot !== collection) {
+    return navigation;
+  }
+  return root.children;
+};
+const publicFields = (item) => {
+  const {
+    children: _children,
+    path: _path,
+    _path: _canonicalPath,
+    stem: _stem,
+    _file,
+    _navigationKind,
+    _navigationPath,
+    _collectionRoot,
+    ...fields
+  } = item;
+  return fields;
+};
+const projectNavigationItem = (item, options) => {
+  const children = item.children?.map((child) => projectNavigationItem(child, options)).filter(Boolean);
+  const hasChildren = Boolean(children?.length);
+  const base = {
+    ...publicFields(item),
+    _fallback: item._fallback === true
+  };
+  if (isFolderNode(item)) {
+    return {
+      ...base,
+      ...hasChildren ? { children } : {}
+    };
+  }
+  const rawPath = item._path || item._navigationPath || item.path;
+  if (!rawPath) {
+    return {
+      ...base,
+      ...hasChildren ? { children } : {}
+    };
+  }
+  const canonicalPath = normalizeContentPath(rawPath);
+  return {
+    ...base,
+    _path: canonicalPath,
+    path: options.canonical ? canonicalPath : projectContentPathToLocale(canonicalPath, options.locale || item._locale, options.defaultLocale, options.routeMounts),
+    canonicalPath,
+    stem: item.stem || getContentStem(canonicalPath, item._file),
+    ...hasChildren ? { children } : {}
+  };
+};
+export const projectNavigationTree = (navigation = [], options = {}) => {
+  return scopeNavigationTree(navigation, options.collection).map((item) => projectNavigationItem(item, options));
+};

package/dist/features/navigation/query

@@ -0,0 +1 @@
+export * from './query.js'

package/dist/features/navigation/query.d.ts

@@ -0,0 +1,19 @@
+import type { NavItem } from '../../types/content';
+import type { ContentQueryBuilderParams } from '../../types/query';
+export interface ResolveNavigationRuntime {
+    defaultLocale?: string;
+    localeFallback?: Record<string, string[]>;
+    navigation: false | {
+        fields: string[];
+    };
+    cacheEnabled: boolean;
+    isPreview: boolean;
+}
+export interface ResolveNavigationOptions {
+    query?: ContentQueryBuilderParams;
+    readCache?: () => Promise<NavItem[] | null>;
+    loadLocaleNavigation: (locale?: string) => Promise<NavItem[]>;
+    resolveLocaleChain: (requestedLocale?: string, defaultLocale?: string, fallback?: Record<string, string[]>) => string[];
+    localizeNavigation?: (items: NavItem[], locale?: string, fallback?: string[], collection?: string, canonical?: boolean) => Promise<NavItem[]>;
+}
+export declare const resolveContentNavigationData: (runtime: ResolveNavigationRuntime, { query: inputQuery, readCache, loadLocaleNavigation, resolveLocaleChain, localizeNavigation }: ResolveNavigationOptions) => Promise<NavItem[]>;

package/dist/features/navigation/query.js

@@ -0,0 +1,51 @@
+import { buildLocaleFallbackChain } from "../../core/content/locale";
+import { mergeCanonicalNavigation, projectNavigationTree } from "./canonical.js";
+export const resolveContentNavigationData = async (runtime, {
+  query: inputQuery = {},
+  readCache,
+  loadLocaleNavigation,
+  resolveLocaleChain,
+  localizeNavigation
+}) => {
+  const query = { ...inputQuery };
+  const resolveLocale = query.resolveLocale;
+  if (resolveLocale) {
+    delete query.resolveLocale;
+  }
+  const canonical = query.canonical === true;
+  if ("canonical" in query) {
+    delete query.canonical;
+  }
+  if ("navigationFields" in query) {
+    delete query.navigationFields;
+  }
+  if (runtime.navigation === false) {
+    return [];
+  }
+  if (runtime.cacheEnabled && !runtime.isPreview && !resolveLocale && Object.keys(query).length === 0 && readCache) {
+    const cache = await readCache();
+    if (cache) {
+      return cache;
+    }
+  }
+  const requestedLocale = resolveLocale?.locale;
+  const collection = typeof query.collection === "string" ? query.collection : void 0;
+  const fallback = requestedLocale && resolveLocale?.fallback === true ? buildLocaleFallbackChain(requestedLocale, runtime.defaultLocale, runtime.localeFallback) : Array.isArray(resolveLocale?.fallback) ? resolveLocale.fallback : [];
+  const localeChain = resolveLocale ? resolveLocale.exact || resolveLocale.fallback === false ? [requestedLocale].filter(Boolean) : resolveLocaleChain(
+    requestedLocale,
+    runtime.defaultLocale,
+    requestedLocale ? { [requestedLocale]: fallback } : {}
+  ) : [requestedLocale].filter(Boolean);
+  if (!localeChain.length) {
+    const navigation = await loadLocaleNavigation(requestedLocale);
+    return localizeNavigation ? await localizeNavigation(navigation, requestedLocale, [], collection, canonical) : projectNavigationTree(navigation, { locale: requestedLocale, defaultLocale: runtime.defaultLocale, collection, canonical });
+  }
+  let mergedNavigation = [];
+  let first = true;
+  for (const locale of localeChain) {
+    const navigation = await loadLocaleNavigation(locale);
+    mergedNavigation = first ? navigation : mergeCanonicalNavigation(mergedNavigation, navigation);
+    first = false;
+  }
+  return localizeNavigation ? await localizeNavigation(mergedNavigation, requestedLocale, fallback, collection, canonical) : projectNavigationTree(mergedNavigation, { locale: requestedLocale, defaultLocale: runtime.defaultLocale, collection, canonical });
+};

package/dist/features/navigation/resolve

@@ -0,0 +1 @@
+export * from './resolve.js'

package/dist/features/navigation/resolve.d.ts

@@ -0,0 +1,20 @@
+import type { ContentNavigationItem } from '../../types/content';
+export type ContentNavigationMatch = {
+    path?: string;
+    stem?: string;
+    title?: string;
+};
+export type ResolvedContentNavigationItem = ContentNavigationItem & {
+    path: string;
+};
+export declare const getNavigationItemPath: (item: ContentNavigationItem | null | undefined) => string | undefined;
+export declare const resolveNavigationItem: (item: ContentNavigationItem | null | undefined) => ResolvedContentNavigationItem | null;
+export declare const matchesNavigationItem: (item: ContentNavigationItem, match: string | ContentNavigationMatch) => boolean;
+export declare const findFirstNavigationPage: (items?: ContentNavigationItem[]) => ResolvedContentNavigationItem | null;
+export declare const findFirstNavigationChild: (item: ContentNavigationItem | null | undefined) => ResolvedContentNavigationItem | null;
+export declare const findNavigationItem: (items: ContentNavigationItem[] | undefined, match: number | string | ContentNavigationMatch, options?: {
+    recursive?: boolean;
+}) => ContentNavigationItem | null;
+export declare const resolveNavigationPaths: (items?: ContentNavigationItem[]) => string[];
+export declare const resolveNavigationFirstPages: (items?: ContentNavigationItem[]) => ResolvedContentNavigationItem[];
+export declare const resolveNavigationFirstChildren: (items?: ContentNavigationItem[]) => ResolvedContentNavigationItem[];

package/dist/features/navigation/resolve.js

@@ -0,0 +1,79 @@
+const normalizePath = (path) => path !== "/" && path.endsWith("/") ? path.slice(0, -1) : path;
+const stringValue = (value) => typeof value === "string" && value.length ? value : void 0;
+export const getNavigationItemPath = (item) => {
+  if (!item || item.page === false) {
+    return void 0;
+  }
+  return stringValue(item.path) || stringValue(item._path);
+};
+export const resolveNavigationItem = (item) => {
+  const path = getNavigationItemPath(item);
+  return item && path ? { ...item, path } : null;
+};
+const fieldMatches = (item, field, value) => {
+  const candidate = stringValue(item[field]);
+  if (!candidate) {
+    return false;
+  }
+  if (field === "path" || field === "_path" || field === "canonicalPath") {
+    return normalizePath(candidate) === normalizePath(value);
+  }
+  return candidate === value;
+};
+export const matchesNavigationItem = (item, match) => {
+  if (typeof match === "string") {
+    return fieldMatches(item, "path", match) || fieldMatches(item, "_path", match) || fieldMatches(item, "canonicalPath", match) || fieldMatches(item, "stem", match) || fieldMatches(item, "title", match);
+  }
+  if (match.path && !(fieldMatches(item, "path", match.path) || fieldMatches(item, "_path", match.path) || fieldMatches(item, "canonicalPath", match.path))) {
+    return false;
+  }
+  if (match.stem && !fieldMatches(item, "stem", match.stem)) {
+    return false;
+  }
+  if (match.title && !fieldMatches(item, "title", match.title)) {
+    return false;
+  }
+  return Boolean(match.path || match.stem || match.title);
+};
+export const findFirstNavigationPage = (items = []) => {
+  for (const item of items) {
+    const resolved = resolveNavigationItem(item);
+    if (resolved) {
+      return resolved;
+    }
+    const child = findFirstNavigationPage(item.children);
+    if (child) {
+      return child;
+    }
+  }
+  return null;
+};
+export const findFirstNavigationChild = (item) => {
+  return findFirstNavigationPage(item?.children || []);
+};
+export const findNavigationItem = (items = [], match, options = {}) => {
+  if (typeof match === "number") {
+    return items[match] || null;
+  }
+  for (const item of items) {
+    if (matchesNavigationItem(item, match)) {
+      return item;
+    }
+    if (options.recursive) {
+      const child = findNavigationItem(item.children, match, options);
+      if (child) {
+        return child;
+      }
+    }
+  }
+  return null;
+};
+export const resolveNavigationPaths = (items = []) => {
+  return items.map((item) => resolveNavigationItem(item)?.path).filter((path) => Boolean(path));
+};
+export const resolveNavigationFirstPages = (items = []) => {
+  return items.map((item) => resolveNavigationItem(item) || findFirstNavigationChild(item)).filter((item) => Boolean(item));
+};
+export const resolveNavigationFirstChildren = (items = []) => {
+  return items.map((item) => findFirstNavigationChild(item)).filter((item) => Boolean(item));
+};

package/dist/features/navigation/tree

@@ -0,0 +1 @@
+export * from './tree.js'

package/dist/features/navigation/tree.d.ts

@@ -0,0 +1,6 @@
+import type { ContentNavigationItem } from '../../types/content';
+export declare function flattenCollectionNavigation(navigation?: ContentNavigationItem[]): ContentNavigationItem[];
+export declare function createCollectionSurroundings(navigation: ContentNavigationItem[] | undefined, path: string, options?: Partial<{
+    before: number;
+    after: number;
+}>): Array<ContentNavigationItem | null>;

package/dist/features/navigation/tree.js

@@ -0,0 +1,32 @@
+export function flattenCollectionNavigation(navigation = []) {
+  return navigation.flatMap((item) => {
+    const children = item.children ? flattenCollectionNavigation(item.children) : [];
+    if (!item._path && !item.path) {
+      return children;
+    }
+    if (item.page === false || children.length && children.find((child) => child._path === item._path)) {
+      return children;
+    }
+    return [{ ...item, children: void 0 }, ...children];
+  });
+}
+export function createCollectionSurroundings(navigation = [], path, options = {}) {
+  const before = options.before ?? 1;
+  const after = options.after ?? 1;
+  const items = flattenCollectionNavigation(navigation);
+  const normalizedPath = path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
+  const index = items.findIndex((item) => {
+    const itemPath = typeof item.path === "string" ? item.path : item._path;
+    if (!itemPath) {
+      return false;
+    }
+    const normalizedItemPath = itemPath.endsWith("/") && itemPath !== "/" ? itemPath.slice(0, -1) : itemPath;
+    return normalizedItemPath === normalizedPath;
+  });
+  const beforeItems = index === -1 ? [] : items.slice(Math.max(0, index - before), index);
+  const afterItems = index === -1 ? [] : items.slice(index + 1, index + after + 1);
+  return [
+    ...Array.from({ length: before }).fill(null).concat(beforeItems).slice(beforeItems.length),
+    ...afterItems.concat(Array.from({ length: after }).fill(null)).slice(0, after)
+  ];
+}

package/dist/features/search/navigation

@@ -0,0 +1 @@
+export * from './navigation.js'

package/dist/features/search/navigation.d.ts

@@ -0,0 +1,6 @@
+import type { ContentNavigationItem } from '../../types/content';
+/**
+ * Convert normal content navigation into the leaf-oriented shape expected by
+ * Nuxt UI's UContentSearch without mutating the source navigation tree.
+ */
+export declare function createContentSearchNavigation(items?: ContentNavigationItem[], depth?: number): ContentNavigationItem[];

package/dist/features/search/navigation.js

@@ -0,0 +1,21 @@
+const itemPath = (item) => item.path || item._path;
+const searchGroupId = (item, depth, index) => `content-search-group:${String(item._canonicalKey || item.stem || `${depth}:${index}`)}`;
+export function createContentSearchNavigation(items = [], depth = 0) {
+  return items.map((item, index) => {
+    const children = item.children ? createContentSearchNavigation(item.children, depth + 1) : [];
+    const path = itemPath(item);
+    const hasSelfChild = children.some((child) => itemPath(child) === path);
+    const normalizedItem = {
+      ...item,
+      ...path && !item.path ? { path } : {},
+      ...!path ? { searchGroupId: searchGroupId(item, depth, index) } : {}
+    };
+    return {
+      ...normalizedItem,
+      children: children.length ? [
+        ...path && !hasSelfChild ? [{ ...normalizedItem, children: void 0 }] : [],
+        ...children
+      ] : void 0
+    };
+  });
+}

package/dist/features/search/sections

@@ -0,0 +1 @@
+export * from './sections.js'