@lupinum/ginko-content 0.1.2 → 0.1.3

package/dist/runtime/app/composables/use-content.d.ts

@@ -1,208 +1,13 @@
-import type { ComputedRef, MaybeRefOrGetter } from 'vue';
-import { createError } from '#imports';
-import type { BacklinksOptions, BacklinksResult, BacklinkSource, ContentCollectionTarget, ContentVariant, ContentTreeItem, ContentResolvedMeta, DocumentFromHandle, LocalePathEntry, LocaleFallback, ManyOptions, LocalizedDoc, NeighborsOptions, NeighborsResult, OneOptions, PopulateSpec, PopulateFromOptions, PopulatedDocument, PaginationOptions, PaginationResult, ResolveOneOptions, ResolveOneResult, SortSpec, TreeOptions, VariantsOptions } from '../../../types/query';
-type ReactiveLeaf<T> = T | MaybeRefOrGetter<T>;
-type ReactiveValue<V> = V extends ((...args: never[]) => unknown) | readonly unknown[] ? ReactiveLeaf<V> : V extends object | undefined ? ReactiveLeaf<V> | {
-    [P in keyof NonNullable<V>]?: ReactiveLeaf<NonNullable<V>[P]>;
-} : ReactiveLeaf<V>;
-type Reactive<T> = {
-    [K in keyof T]: ReactiveValue<T[K]>;
-};
-type DocFromHandle<H> = DocumentFromHandle<H>;
-interface UseContentOneReturn<T> {
-    data: ComputedRef<LocalizedDoc<T> | null>;
-    pending: ComputedRef<boolean>;
-    status: ComputedRef<string>;
-    error: ComputedRef<unknown>;
-    refresh: () => Promise<void>;
-}
 /**
- * Reactively resolve a single document. Reruns when any reactive source on
- * `options` changes. Caching follows Nuxt's standard `useAsyncData` semantics
- * keyed by `${collection}:${stableHash(options)}`.
- */
-export declare function useContentOne<const H extends ContentCollectionTarget, O extends OneOptions<H, PopulateSpec | undefined>>(handle: H, options: Reactive<O>): Promise<UseContentOneReturn<PopulatedDocument<DocFromHandle<H>, PopulateFromOptions<O>>>>;
-type ContentPageSurroundOptions<H> = boolean | Omit<NeighborsOptions<H>, 'by' | 'locale' | 'fallback'>;
-type ContentPageOneOptions<H, P extends PopulateSpec | undefined> = Omit<OneOptions<H, P>, 'by' | 'locale' | 'fallback'> & {
-    /**
-     * Optional locale override. Route pages may omit this even for typed i18n
-     * handles because the route selector is the source of truth for the active
-     * public URL.
-     */
-    locale?: string;
-    fallback?: LocaleFallback;
-};
-export type UseContentPageOptions<H = unknown, P extends PopulateSpec | undefined = undefined> = Reactive<ContentPageOneOptions<H, P>> & {
-    /**
-     * Load previous/next items alongside the page.
-     *
-     * Pass `true` for the default surround query, or an options object to choose
-     * fields. The page query remains one request unless this is enabled.
-     */
-    surround?: ContentPageSurroundOptions<H>;
-    /**
-     * Override the error raised when the current route does not resolve to a
-     * content page. Set `false` to render a local empty/not-found state.
-     */
-    notFound?: false | (() => Parameters<typeof createError>[0]);
-};
-interface UseContentPageReturn<T> {
-    data: ComputedRef<LocalizedDoc<T> | undefined>;
-    page: ComputedRef<LocalizedDoc<T> | undefined>;
-    previous: ComputedRef<ContentTreeItem<T> | null>;
-    next: ComputedRef<ContentTreeItem<T> | null>;
-    surround: ComputedRef<Array<ContentTreeItem<T>>>;
-    pending: ComputedRef<boolean>;
-    status: ComputedRef<string>;
-    error: ComputedRef<unknown>;
-    refresh: () => Promise<void>;
-}
-/**
- * Ergonomic route-page helper. This is the product-level default for Nuxt page
- * components; the explicit `useContentOne` selector remains the lower-level
- * primitive for custom reads.
- */
-export declare function useContentPage<const H extends ContentCollectionTarget, P extends PopulateSpec | undefined = undefined>(handle: H, options?: UseContentPageOptions<H, P>): Promise<UseContentPageReturn<PopulatedDocument<DocFromHandle<H>, P>>>;
-interface UseContentResolveOneReturn<T> {
-    doc: ComputedRef<LocalizedDoc<T> | null>;
-    explain: ComputedRef<ResolveOneResult<T>['explain'] | null>;
-    status: ComputedRef<string>;
-    error: ComputedRef<unknown>;
-    refresh: () => Promise<void>;
-}
-/**
- * Reactively resolve a single document with a first-class diagnostic envelope.
- */
-export declare function useContentResolveOne<const H extends ContentCollectionTarget, O extends ResolveOneOptions<H, PopulateSpec | undefined>>(handle: H, options: Reactive<O>): Promise<UseContentResolveOneReturn<PopulatedDocument<DocFromHandle<H>, PopulateFromOptions<O>>>>;
-interface UseContentManyReturn<T> {
-    data: ComputedRef<Array<LocalizedDoc<T>>>;
-    status: ComputedRef<string>;
-    error: ComputedRef<unknown>;
-    refresh: () => Promise<void>;
-}
-interface UseContentPaginationReturn<T> {
-    data: ComputedRef<Array<LocalizedDoc<T>>>;
-    page: ComputedRef<number>;
-    limit: ComputedRef<number>;
-    total: ComputedRef<number>;
-    pageCount: ComputedRef<number>;
-    hasNext: ComputedRef<boolean>;
-    hasPrev: ComputedRef<boolean>;
-    nextPage: ComputedRef<number | null>;
-    prevPage: ComputedRef<number | null>;
-    status: ComputedRef<string>;
-    error: ComputedRef<unknown>;
-    refresh: () => Promise<void>;
-}
-/**
- * Reactively resolve a list of documents.
- */
-export declare function useContentMany<const H extends ContentCollectionTarget, O extends ManyOptions<H, PopulateSpec | undefined>>(handle: H, options?: Reactive<O>): Promise<UseContentManyReturn<PopulatedDocument<DocFromHandle<H>, PopulateFromOptions<O>>>>;
-/**
- * Reactively resolve one page of documents plus total/page navigation metadata.
- */
-export declare function useContentPagination<const H extends ContentCollectionTarget, O extends PaginationOptions<H, PopulateSpec | undefined>>(handle: H, options: Reactive<O>): Promise<UseContentPaginationReturn<PopulatedDocument<DocFromHandle<H>, PopulateFromOptions<O>>>>;
-interface UseContentBacklinksReturn<T> {
-    data: ComputedRef<T[]>;
-    status: ComputedRef<string>;
-    error: ComputedRef<unknown>;
-    refresh: () => Promise<void>;
-}
-/**
- * Reactively resolve source documents that reference a target document.
- */
-export declare function useContentBacklinks<const Target extends ContentCollectionTarget, const Source extends BacklinkSource | ReadonlyArray<BacklinkSource>, P extends PopulateSpec | undefined = undefined>(handle: Target, options: Reactive<BacklinksOptions<Target, Source, P>> & {
-    from: ReactiveValue<Source>;
-}): Promise<UseContentBacklinksReturn<BacklinksResult<Source, P>[number]>>;
-interface UseContentVariantsReturn<T> {
-    data: ComputedRef<Array<ContentVariant<T>>>;
-    status: ComputedRef<string>;
-    error: ComputedRef<unknown>;
-    refresh: () => Promise<void>;
-}
-/**
- * Reactively resolve every locale variant of a single document — used by
- * locale switchers. Returns one entry per configured locale, with a
- * `translated` flag.
- */
-export declare function useContentVariants<H extends ContentCollectionTarget>(handle: H, options: Reactive<VariantsOptions<H>>): Promise<UseContentVariantsReturn<DocFromHandle<H>>>;
-interface UseContentTreeReturn<T> {
-    data: ComputedRef<T[]>;
-    status: ComputedRef<string>;
-    error: ComputedRef<unknown>;
-    refresh: () => Promise<void>;
-}
-export type ContentNavigationNode<T> = Omit<ContentTreeItem<T>, 'children'> & {
-    id: string;
-    path: string;
-    title: string;
-    children: Array<ContentNavigationNode<T>>;
-};
-interface UseContentNavigationReturn<T> {
-    data: ComputedRef<Array<ContentNavigationNode<T>>>;
-    firstPage: ComputedRef<ContentNavigationNode<T> | null>;
-    paths: ComputedRef<Set<string>>;
-    status: ComputedRef<string>;
-    error: ComputedRef<unknown>;
-    refresh: () => Promise<void>;
-}
-/**
- * Reactively resolve the navigation tree for a collection.
- */
-export declare function useContentTree<H extends ContentCollectionTarget>(handle: H, options?: Reactive<TreeOptions<H>>): Promise<UseContentTreeReturn<ContentTreeItem<DocFromHandle<H>>>>;
-/**
- * Reactively resolve normalized navigation for sidebars and active-state UI.
- */
-export declare function useContentNavigation<H extends ContentCollectionTarget>(handle: H, options?: Reactive<TreeOptions<H>>): Promise<UseContentNavigationReturn<DocFromHandle<H>>>;
-interface UseContentNeighborsReturn<T> {
-    data: ComputedRef<NeighborsResult<T>>;
-    pending: ComputedRef<boolean>;
-    status: ComputedRef<string>;
-    error: ComputedRef<unknown>;
-    refresh: () => Promise<void>;
-}
-/**
- * Reactively resolve previous/next surroundings for a document.
- */
-export declare function useContentNeighbors<H extends ContentCollectionTarget>(handle: H, options: Reactive<NeighborsOptions<H>>): Promise<UseContentNeighborsReturn<DocFromHandle<H>>>;
-interface UseContentLocaleSwitchReturn<T> {
-    /**
-     * Per-locale path map of the resolved document, keyed by locale code.
-     * Empty object when the document hasn't resolved yet or returned `null`.
-     */
-    paths: ComputedRef<Record<string, LocalePathEntry>>;
-    /**
-     * Resolve a switch destination for a given locale. Returns the content's
-     * translated path when available; otherwise `null` so the caller can fall
-     * back to a route-only switch (e.g. `useSwitchLocalePath`).
-     */
-    switchTo: (locale: string) => string | null;
-    /**
-     * The resolved document, exposed so the caller can read additional fields
-     * (title, description, ...) from the same query without a second fetch.
-     */
-    data: ComputedRef<LocalizedDoc<T> | null>;
-}
-/**
- * Resolve every per-locale path for a content document. Thin wrapper over
- * `useContentOne` that exposes the document's `localePaths` plus a `switchTo`
- * helper for rendering locale switchers.
- *
- * Layouts and pages typically call this with the same options — `useAsyncData`
- * dedupes by key, so it's a single round-trip:
+ * Public facade for Layer 2 of the unified query API (ADR-0016).
  *
- * ```vue
- * <script setup>
- * const { switchTo } = useContentLocaleSwitch(docs, {
- *   locale: () => locale.value,
- *   by: { path: () => route.path },
- *   fallback: true
- * })
- *
- * // In the template:
- * // <a :href="switchTo('de') || useSwitchLocalePath()('de')">Deutsch</a>
- * </script>
- * ```
- */
-export declare function useContentLocaleSwitch<const H extends ContentCollectionTarget, O extends OneOptions<H, PopulateSpec | undefined>>(handle: H, options: Reactive<O>): Promise<UseContentLocaleSwitchReturn<PopulatedDocument<DocFromHandle<H>, PopulateFromOptions<O>>>>;
-export type { ManyOptions, OneOptions, BacklinksOptions, BacklinksResult, LocalizedDoc, ContentResolvedMeta, ContentCollectionTarget, DocumentFromHandle, NeighborsOptions, NeighborsResult, PaginationOptions, PaginationResult, PopulateSpec, PopulateFromOptions, PopulatedDocument, ResolveOneOptions, ResolveOneResult, SortSpec, TreeOptions, VariantsOptions, ContentVariant };
+ * Runtime imports and `#content/client` intentionally keep pointing at this
+ * module; focused implementation modules live beside it.
+ */
+export { useContentOne, useContentResolveOne } from './use-content-document';
+export { useContentPage } from './use-content-page';
+export type { UseContentPageOptions } from './use-content-page';
+export { useContentMany, useContentPagination, useContentBacklinks, useContentVariants } from './use-content-list';
+export { useContentTree, useContentNavigation, useContentNeighbors } from './use-content-navigation';
+export type { ContentNavigationNode } from './use-content-navigation';
+export type { ManyOptions, OneOptions, BacklinksOptions, BacklinksResult, LocalizedDoc, ContentResolvedMeta, ContentCollectionTarget, DocumentFromHandle, NeighborsOptions, NeighborsResult, PaginationOptions, PaginationResult, PopulateSpec, PopulateFromOptions, PopulatedDocument, ResolveOneOptions, ResolveOneResult, SortSpec, TreeOptions, VariantsOptions, ContentVariant } from '../../../types/query';

package/dist/runtime/app/composables/use-content.js

@@ -1,377 +1,4 @@
-import { computed, shallowRef, toValue, watch } from "vue";
-import { hash } from "ohash";
-import { createError, useAsyncData, useRoute } from "#imports";
-import { createClientContentQueryContext } from "./query-api.js";
-import { resolveCollectionI18n } from "../../../features/localization/path";
-import {
-  backlinks as backlinksWithContext,
-  many as manyWithContext,
-  neighbors as neighborsWithContext,
-  one as oneWithContext,
-  paginate as paginateWithContext,
-  resolveOne as resolveOneWithContext,
-  tree as treeWithContext,
-  variants as variantsWithContext
-} from "../../query/unified.js";
-import { resolveActiveLocale } from "./locale.js";
-import { useContentRoute } from "./route.js";
-import { getContentRuntime } from "./runtime.js";
-const unwrapDeep = (value, seen = /* @__PURE__ */ new WeakSet()) => {
-  if (value === null || value === void 0) return value;
-  if (typeof value === "function") return unwrapDeep(toValue(value), seen);
-  if (typeof value === "object" && "__v_isRef" in value) {
-    return unwrapDeep(toValue(value), seen);
-  }
-  if (Array.isArray(value)) return value.map((item) => unwrapDeep(item, seen));
-  if (typeof value === "object" && value.constructor === Object) {
-    if (seen.has(value)) return value;
-    seen.add(value);
-    const out = {};
-    for (const [k, v] of Object.entries(value)) {
-      out[k] = unwrapDeep(v, seen);
-    }
-    return out;
-  }
-  return value;
-};
-const resolveOptions = (reactive) => {
-  return unwrapDeep(reactive);
-};
-const stableKey = (prefix, name, options) => `${prefix}:${name}:${hash(options)}`;
-const contentCollectionName = (handle) => typeof handle === "string" ? handle : handle.name;
-export async function useContentOne(handle, options) {
-  const resolved = computed(() => resolveOptions(options));
-  const key = computed(() => stableKey("content-one", typeof handle === "string" ? handle : handle.name, resolved.value));
-  const context = createClientContentQueryContext();
-  const asyncData = await useAsyncData(
-    key,
-    () => oneWithContext(context, handle, resolved.value),
-    { watch: [resolved], default: () => null }
-  );
-  return {
-    data: computed(() => asyncData.data.value),
-    pending: computed(() => asyncData.pending.value),
-    status: computed(() => asyncData.status.value),
-    error: computed(() => asyncData.error.value),
-    refresh: () => asyncData.refresh()
-  };
-}
-const defaultPageNotFound = () => createError({
-  statusCode: 404,
-  statusMessage: "Page not found",
-  fatal: true
-});
-const normalizePageNotFound = (notFound) => {
-  if (notFound === false) return void 0;
-  return createError(notFound ? notFound() : defaultPageNotFound());
-};
-const normalizePageSurround = (surround) => {
-  if (!surround) return void 0;
-  return surround === true ? {} : surround;
-};
-const normalizeRoutePath = (path) => {
-  if (typeof path !== "string") return void 0;
-  const normalized = path.replace(/\/+$/, "");
-  return normalized || "/";
-};
-const localePathMatches = (entry, path) => {
-  const normalizedPath = normalizeRoutePath(path);
-  if (typeof entry === "string") return normalizeRoutePath(entry) === normalizedPath;
-  return Boolean(entry && typeof entry === "object" && "path" in entry && normalizeRoutePath(entry.path) === normalizedPath);
-};
-const routeMetaMatchesPath = (value, path) => {
-  if (!value) return false;
-  const normalizedPath = normalizeRoutePath(path);
-  const legacyPath = value;
-  if (normalizeRoutePath(legacyPath._path) === normalizedPath || normalizeRoutePath(legacyPath._requestedPath) === normalizedPath || normalizeRoutePath(legacyPath._requestedRoute) === normalizedPath) return true;
-  const requestedRoute = value.resolved?.requestedRoute ?? value._requestedRoute;
-  return normalizeRoutePath(value.path) === normalizedPath || normalizeRoutePath(value.canonicalPath) === normalizedPath || normalizeRoutePath(requestedRoute) === normalizedPath || Object.values(value.localePaths || {}).some((entry) => localePathMatches(entry, path));
-};
-export async function useContentPage(handle, options = {}) {
-  const route = useRoute();
-  const isBrowser = import.meta.client && typeof window !== "undefined";
-  const { notFound, surround, ...oneOptions } = options;
-  const routeSelector = { route: () => normalizeRoutePath(route.path) };
-  const runtime = getContentRuntime();
-  const activeLocale = computed(() => {
-    const explicitLocale = toValue(oneOptions.locale);
-    if (explicitLocale) {
-      return explicitLocale;
-    }
-    const { locales, defaultLocale } = resolveCollectionI18n(contentCollectionName(handle), runtime);
-    if (!locales.length && !defaultLocale) {
-      return void 0;
-    }
-    return resolveActiveLocale(locales, defaultLocale);
-  });
-  const rawPage = shallowRef(null);
-  const resolvingRoute = shallowRef(false);
-  const sawRouteQueryPending = shallowRef(false);
-  const page = computed(() => {
-    const current = rawPage.value;
-    return routeMetaMatchesPath(current, route.path) ? current : void 0;
-  });
-  useContentRoute(page);
-  const pageResultPromise = useContentOne(handle, {
-    ...oneOptions,
-    locale: () => activeLocale.value,
-    by: routeSelector
-  });
-  const surroundOptions = normalizePageSurround(surround);
-  const surroundResultPromise = surroundOptions ? useContentNeighbors(handle, {
-    ...surroundOptions,
-    locale: () => activeLocale.value,
-    ..."fallback" in oneOptions ? { fallback: oneOptions.fallback } : {},
-    by: routeSelector
-  }) : void 0;
-  const pageResult = await pageResultPromise;
-  rawPage.value = pageResult.data.value;
-  if (isBrowser && rawPage.value && !routeMetaMatchesPath(rawPage.value, route.path)) {
-    resolvingRoute.value = true;
-  }
-  watch(() => route.path, () => {
-    resolvingRoute.value = true;
-    sawRouteQueryPending.value = false;
-  }, { flush: "sync" });
-  watch(pageResult.data, (value) => {
-    rawPage.value = value;
-    const resolved = value;
-    if (resolved && routeMetaMatchesPath(resolved, route.path)) {
-      resolvingRoute.value = false;
-    }
-  });
-  watch(() => pageResult.pending.value, (pending2) => {
-    if (pending2) {
-      sawRouteQueryPending.value = true;
-      return;
-    }
-    if (sawRouteQueryPending.value) {
-      const resolved = pageResult.data.value;
-      if (!resolved || routeMetaMatchesPath(resolved, route.path)) {
-        resolvingRoute.value = false;
-      }
-    }
-  });
-  const surroundResult = surroundResultPromise ? await surroundResultPromise : void 0;
-  const pending = computed(() => pageResult.pending.value || Boolean(surroundResult?.pending.value));
-  const pageError = computed(() => {
-    if (pageResult.error.value) return pageResult.error.value;
-    if (surroundResult?.error.value) return surroundResult.error.value;
-    if (pending.value || resolvingRoute.value || page.value || notFound === false) return void 0;
-    return normalizePageNotFound(notFound);
-  });
-  if (!isBrowser && pageError.value) {
-    throw pageError.value;
-  }
-  const previous = computed(() => {
-    if (!page.value || !surroundResult) return null;
-    return surroundResult.data.value.prev;
-  });
-  const next = computed(() => {
-    if (!page.value || !surroundResult) return null;
-    return surroundResult.data.value.next;
-  });
-  const pageSurround = computed(() => {
-    return [previous.value, next.value].filter((item) => Boolean(item));
-  });
-  return {
-    data: page,
-    page,
-    surround: pageSurround,
-    previous,
-    next,
-    pending,
-    status: computed(() => pageResult.status.value),
-    error: pageError,
-    refresh: async () => {
-      await pageResult.refresh();
-      if (surroundResult) await surroundResult.refresh();
-    }
-  };
-}
-export async function useContentResolveOne(handle, options) {
-  const resolved = computed(() => resolveOptions(options));
-  const key = computed(() => stableKey("content-resolve-one", typeof handle === "string" ? handle : handle.name, resolved.value));
-  const context = createClientContentQueryContext();
-  const asyncData = await useAsyncData(
-    key,
-    () => resolveOneWithContext(context, handle, resolved.value),
-    { watch: [resolved] }
-  );
-  return {
-    doc: computed(() => asyncData.data.value?.doc ?? null),
-    explain: computed(() => asyncData.data.value?.explain ?? null),
-    status: computed(() => asyncData.status.value),
-    error: computed(() => asyncData.error.value),
-    refresh: () => asyncData.refresh()
-  };
-}
-export async function useContentMany(handle, options = {}) {
-  const resolved = computed(() => resolveOptions(options));
-  const key = computed(() => stableKey("content-many", typeof handle === "string" ? handle : handle.name, resolved.value));
-  const context = createClientContentQueryContext();
-  const asyncData = await useAsyncData(
-    key,
-    () => manyWithContext(context, handle, resolved.value),
-    { watch: [resolved], default: () => [] }
-  );
-  return {
-    data: computed(() => asyncData.data.value || []),
-    status: computed(() => asyncData.status.value),
-    error: computed(() => asyncData.error.value),
-    refresh: () => asyncData.refresh()
-  };
-}
-const emptyPagination = () => ({
-  data: [],
-  page: 1,
-  limit: 10,
-  total: 0,
-  pageCount: 0,
-  hasNext: false,
-  hasPrev: false,
-  nextPage: null,
-  prevPage: null
-});
-export async function useContentPagination(handle, options) {
-  const resolved = computed(() => resolveOptions(options));
-  const key = computed(() => stableKey("content-pagination", typeof handle === "string" ? handle : handle.name, resolved.value));
-  const context = createClientContentQueryContext();
-  const asyncData = await useAsyncData(
-    key,
-    () => paginateWithContext(context, handle, resolved.value),
-    { watch: [resolved], default: () => emptyPagination() }
-  );
-  const result = computed(() => asyncData.data.value || emptyPagination());
-  return {
-    data: computed(() => result.value.data),
-    page: computed(() => result.value.page),
-    limit: computed(() => result.value.limit),
-    total: computed(() => result.value.total),
-    pageCount: computed(() => result.value.pageCount),
-    hasNext: computed(() => result.value.hasNext),
-    hasPrev: computed(() => result.value.hasPrev),
-    nextPage: computed(() => result.value.nextPage),
-    prevPage: computed(() => result.value.prevPage),
-    status: computed(() => asyncData.status.value),
-    error: computed(() => asyncData.error.value),
-    refresh: () => asyncData.refresh()
-  };
-}
-export async function useContentBacklinks(handle, options) {
-  const resolved = computed(() => resolveOptions(options));
-  const key = computed(() => stableKey("content-backlinks", typeof handle === "string" ? handle : handle.name, resolved.value));
-  const context = createClientContentQueryContext();
-  const asyncData = await useAsyncData(
-    key,
-    () => backlinksWithContext(context, handle, resolved.value),
-    { watch: [resolved], default: () => [] }
-  );
-  return {
-    data: computed(() => asyncData.data.value || []),
-    status: computed(() => asyncData.status.value),
-    error: computed(() => asyncData.error.value),
-    refresh: () => asyncData.refresh()
-  };
-}
-export async function useContentVariants(handle, options) {
-  const resolved = computed(() => resolveOptions(options));
-  const key = computed(() => stableKey("content-variants", typeof handle === "string" ? handle : handle.name, resolved.value));
-  const context = createClientContentQueryContext();
-  const asyncData = await useAsyncData(
-    key,
-    () => variantsWithContext(context, handle, resolved.value),
-    { watch: [resolved], default: () => [] }
-  );
-  return {
-    data: computed(() => asyncData.data.value || []),
-    status: computed(() => asyncData.status.value),
-    error: computed(() => asyncData.error.value),
-    refresh: () => asyncData.refresh()
-  };
-}
-const navigationNodeId = (item) => {
-  const id = item.id ?? item._id ?? item._canonicalKey ?? item.path ?? item._path ?? item.title;
-  return typeof id === "string" && id.length ? id : item.title;
-};
-const normalizeContentNavigation = (items = []) => {
-  return items.map((item) => {
-    const source = item;
-    return {
-      ...item,
-      id: navigationNodeId(source),
-      path: item.path,
-      title: item.title,
-      children: normalizeContentNavigation(item.children || [])
-    };
-  });
-};
-const findFirstContentNavigationPage = (items) => {
-  for (const item of items) {
-    if (item.path) return item;
-    const child = findFirstContentNavigationPage(item.children);
-    if (child) return child;
-  }
-  return null;
-};
-const collectContentNavigationPaths = (items, paths = /* @__PURE__ */ new Set()) => {
-  for (const item of items) {
-    if (item.path) paths.add(item.path);
-    collectContentNavigationPaths(item.children, paths);
-  }
-  return paths;
-};
-export async function useContentTree(handle, options = {}) {
-  const resolved = computed(() => resolveOptions(options));
-  const key = computed(() => stableKey("content-tree", typeof handle === "string" ? handle : handle.name, resolved.value));
-  const context = createClientContentQueryContext();
-  const asyncData = await useAsyncData(
-    key,
-    () => treeWithContext(context, handle, resolved.value),
-    { watch: [resolved], default: () => [] }
-  );
-  return {
-    data: computed(() => asyncData.data.value || []),
-    status: computed(() => asyncData.status.value),
-    error: computed(() => asyncData.error.value),
-    refresh: () => asyncData.refresh()
-  };
-}
-export async function useContentNavigation(handle, options = {}) {
-  const tree = await useContentTree(handle, options);
-  const data = computed(() => normalizeContentNavigation(tree.data.value));
-  return {
-    data,
-    firstPage: computed(() => findFirstContentNavigationPage(data.value)),
-    paths: computed(() => collectContentNavigationPaths(data.value)),
-    status: tree.status,
-    error: tree.error,
-    refresh: tree.refresh
-  };
-}
-export async function useContentNeighbors(handle, options) {
-  const resolved = computed(() => resolveOptions(options));
-  const key = computed(() => stableKey("content-neighbors", typeof handle === "string" ? handle : handle.name, resolved.value));
-  const context = createClientContentQueryContext();
-  const asyncData = await useAsyncData(
-    key,
-    () => neighborsWithContext(context, handle, resolved.value),
-    { watch: [resolved], default: () => ({ prev: null, next: null }) }
-  );
-  return {
-    data: computed(() => asyncData.data.value || { prev: null, next: null }),
-    pending: computed(() => asyncData.pending.value),
-    status: computed(() => asyncData.status.value),
-    error: computed(() => asyncData.error.value),
-    refresh: () => asyncData.refresh()
-  };
-}
-export async function useContentLocaleSwitch(handle, options) {
-  const { data } = await useContentOne(handle, options);
-  const paths = computed(() => {
-    const localePaths = data.value?.localePaths;
-    return localePaths || {};
-  });
-  const switchTo = (locale) => paths.value?.[locale]?.path ?? null;
-  return { paths, switchTo, data };
-}
+export { useContentOne, useContentResolveOne } from "./use-content-document.js";
+export { useContentPage } from "./use-content-page.js";
+export { useContentMany, useContentPagination, useContentBacklinks, useContentVariants } from "./use-content-list.js";
+export { useContentTree, useContentNavigation, useContentNeighbors } from "./use-content-navigation.js";

package/dist/runtime/app/plugins/hot-reload

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

package/dist/runtime/app/plugins/hot-reload.js

@@ -0,0 +1,6 @@
+import { defineNuxtPlugin } from "#imports";
+export default defineNuxtPlugin(() => {
+  if (import.meta.client && import.meta.hot) {
+    import("../composables/hot-reload.js").then(({ registerContentHotReload }) => registerContentHotReload());
+  }
+});

package/dist/runtime/query/backlinks

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

package/dist/runtime/query/backlinks.d.ts

@@ -0,0 +1,8 @@
+import type { ParsedContent } from '../../types/content';
+import type { ContentCollectionHandle } from '../../types/config';
+import type { BacklinkSource, BacklinksOptions, BacklinksResult, LocalizedDoc, ManyOptions, OneOptions, PopulateSpec } from '../../types/query';
+import type { ContentQueryContext } from './context';
+type OneResolver = <H extends ContentCollectionHandle | string>(context: ContentQueryContext, handle: H, options: OneOptions<H>) => Promise<LocalizedDoc<ParsedContent> | null>;
+type ManyResolver = <H extends ContentCollectionHandle | string, P extends PopulateSpec | undefined>(context: ContentQueryContext, handle: H, options: ManyOptions<H, P>) => Promise<Array<LocalizedDoc<ParsedContent>>>;
+export declare function resolveBacklinks<const Target extends ContentCollectionHandle | string, const Source extends BacklinkSource | ReadonlyArray<BacklinkSource>, P extends PopulateSpec | undefined = undefined>(context: ContentQueryContext, one: OneResolver, many: ManyResolver, targetHandle: Target, options: BacklinksOptions<Target, Source, P>): Promise<BacklinksResult<Source, P>>;
+export {};