@lupinum/ginko-content 0.1.2 → 0.1.4

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

@@ -0,0 +1,43 @@
+import type { ComputedRef } from 'vue';
+import type { BacklinksOptions, BacklinksResult, BacklinkSource, ContentCollectionTarget, ContentVariant, DocumentFromHandle, ManyOptions, LocalizedDoc, PaginationOptions, PopulateSpec, PopulateFromOptions, PopulatedDocument, VariantsOptions } from '../../../types/query';
+import { type Reactive, type ReactiveValue } from './use-content-shared';
+type DocFromHandle<H> = DocumentFromHandle<H>;
+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>;
+}
+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>>>>;
+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>;
+}
+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>;
+}
+export declare function useContentVariants<H extends ContentCollectionTarget>(handle: H, options: Reactive<VariantsOptions<H>>): Promise<UseContentVariantsReturn<DocFromHandle<H>>>;
+export {};

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

@@ -0,0 +1,98 @@
+import { computed } from "vue";
+import { useAsyncData } from "#imports";
+import { createClientContentQueryContext } from "./query-api.js";
+import {
+  backlinks as backlinksWithContext,
+  many as manyWithContext,
+  paginate as paginateWithContext,
+  variants as variantsWithContext
+} from "../../query/unified.js";
+import { contentCollectionName, resolveOptions, stableKey } from "./use-content-shared.js";
+export async function useContentMany(handle, options = {}) {
+  const resolved = computed(() => resolveOptions(options));
+  const key = computed(() => stableKey("content-many", contentCollectionName(handle), resolved.value));
+  const context = createClientContentQueryContext();
+  const asyncDataPromise = useAsyncData(
+    key,
+    () => manyWithContext(context, handle, resolved.value),
+    { watch: [resolved], default: () => [] }
+  );
+  const asyncData = await asyncDataPromise;
+  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", contentCollectionName(handle), resolved.value));
+  const context = createClientContentQueryContext();
+  const asyncDataPromise = useAsyncData(
+    key,
+    () => paginateWithContext(context, handle, resolved.value),
+    { watch: [resolved], default: () => emptyPagination() }
+  );
+  const asyncData = await asyncDataPromise;
+  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", contentCollectionName(handle), resolved.value));
+  const context = createClientContentQueryContext();
+  const asyncDataPromise = useAsyncData(
+    key,
+    () => backlinksWithContext(context, handle, resolved.value),
+    { watch: [resolved], default: () => [] }
+  );
+  const asyncData = await asyncDataPromise;
+  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", contentCollectionName(handle), resolved.value));
+  const context = createClientContentQueryContext();
+  const asyncDataPromise = useAsyncData(
+    key,
+    () => variantsWithContext(context, handle, resolved.value),
+    { watch: [resolved], default: () => [] }
+  );
+  const asyncData = await asyncDataPromise;
+  return {
+    data: computed(() => asyncData.data.value || []),
+    status: computed(() => asyncData.status.value),
+    error: computed(() => asyncData.error.value),
+    refresh: () => asyncData.refresh()
+  };
+}

package/dist/runtime/app/composables/use-content-navigation

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

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

@@ -0,0 +1,40 @@
+import type { ComputedRef } from 'vue';
+import type { ContentCollectionTarget, ContentTreeItem, DocumentFromHandle, NeighborsOptions, NeighborsResult, TreeOptions } from '../../../types/query';
+import { type Reactive } from './use-content-shared';
+export type ContentNavigationNode<T> = Omit<ContentTreeItem<T>, 'children'> & {
+    id: string;
+    path: string;
+    title: string;
+    children: Array<ContentNavigationNode<T>>;
+};
+export declare const normalizeContentNavigation: <T>(items?: Array<ContentTreeItem<T>>) => Array<ContentNavigationNode<T>>;
+export declare const findFirstContentNavigationPage: <T>(items: Array<ContentNavigationNode<T>>) => ContentNavigationNode<T> | null;
+export declare const collectContentNavigationPaths: <T>(items: Array<ContentNavigationNode<T>>, paths?: Set<string>) => Set<string>;
+type DocFromHandle<H> = DocumentFromHandle<H>;
+interface UseContentTreeReturn<T> {
+    data: ComputedRef<T[]>;
+    pending: ComputedRef<boolean>;
+    status: ComputedRef<string>;
+    error: ComputedRef<unknown>;
+    refresh: () => Promise<void>;
+}
+interface UseContentNavigationReturn<T> {
+    data: ComputedRef<Array<ContentNavigationNode<T>>>;
+    firstPage: ComputedRef<ContentNavigationNode<T> | null>;
+    paths: ComputedRef<Set<string>>;
+    pending: ComputedRef<boolean>;
+    status: ComputedRef<string>;
+    error: ComputedRef<unknown>;
+    refresh: () => Promise<void>;
+}
+export declare function useContentTree<H extends ContentCollectionTarget>(handle: H, options?: Reactive<TreeOptions<H>>): Promise<UseContentTreeReturn<ContentTreeItem<DocFromHandle<H>>>>;
+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>;
+}
+export declare function useContentNeighbors<H extends ContentCollectionTarget>(handle: H, options: Reactive<NeighborsOptions<H>>): Promise<UseContentNeighborsReturn<DocFromHandle<H>>>;
+export {};

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

@@ -0,0 +1,102 @@
+import { computed } from "vue";
+import { useAsyncData } from "#imports";
+import { resolveCollectionI18n } from "../../../features/localization/path";
+import { createClientContentQueryContext } from "./query-api.js";
+import { neighbors as neighborsWithContext, tree as treeWithContext } from "../../query/unified.js";
+import { getContentRoute, getContentRuntime } from "./runtime.js";
+import { contentCollectionName, resolveLocaleFromRoutePath, resolveOptions, stableKey } from "./use-content-shared.js";
+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;
+};
+export 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 || [])
+    };
+  });
+};
+export const findFirstContentNavigationPage = (items) => {
+  for (const item of items) {
+    if (item.path) return item;
+    const child = findFirstContentNavigationPage(item.children);
+    if (child) return child;
+  }
+  return null;
+};
+export 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", contentCollectionName(handle), resolved.value));
+  const context = createClientContentQueryContext();
+  const asyncDataPromise = useAsyncData(
+    key,
+    () => treeWithContext(context, handle, resolved.value),
+    { watch: [resolved] }
+  );
+  const asyncData = await asyncDataPromise;
+  return {
+    data: computed(() => asyncData.data.value || []),
+    pending: computed(() => asyncData.pending.value),
+    status: computed(() => asyncData.status.value),
+    error: computed(() => asyncData.error.value),
+    refresh: () => asyncData.refresh()
+  };
+}
+export async function useContentNavigation(handle, options = {}) {
+  const route = getContentRoute();
+  const runtime = getContentRuntime();
+  const collectionI18n = resolveCollectionI18n(contentCollectionName(handle), runtime);
+  const routeAwareOptions = computed(() => {
+    const resolved = resolveOptions(options);
+    if (resolved.locale) {
+      return resolved;
+    }
+    const { locales, defaultLocale } = collectionI18n;
+    if (!locales.length && !defaultLocale) {
+      return resolved;
+    }
+    const locale = resolveLocaleFromRoutePath(route.path, locales, defaultLocale);
+    return locale ? { ...resolved, locale } : resolved;
+  });
+  const tree = await useContentTree(handle, routeAwareOptions);
+  const data = computed(() => normalizeContentNavigation(tree.data.value));
+  return {
+    data,
+    firstPage: computed(() => findFirstContentNavigationPage(data.value)),
+    paths: computed(() => collectContentNavigationPaths(data.value)),
+    pending: tree.pending,
+    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", contentCollectionName(handle), resolved.value));
+  const context = createClientContentQueryContext();
+  const asyncDataPromise = useAsyncData(
+    key,
+    () => neighborsWithContext(context, handle, resolved.value),
+    { watch: [resolved], default: () => ({ prev: null, next: null }) }
+  );
+  const asyncData = await asyncDataPromise;
+  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()
+  };
+}

package/dist/runtime/app/composables/use-content-page

@@ -0,0 +1 @@
+export * from './use-content-page.js'

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

@@ -0,0 +1,47 @@
+import type { ComputedRef } from 'vue';
+import { createError } from '#imports';
+import type { ContentCollectionTarget, ContentTreeItem, DocumentFromHandle, LocaleFallback, LocalizedDoc, NeighborsOptions, OneOptions, PopulateSpec, PopulatedDocument } from '../../../types/query';
+import { type Reactive } from './use-content-shared';
+type DocFromHandle<H> = DocumentFromHandle<H>;
+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>>>;
+export {};

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

@@ -0,0 +1,142 @@
+import { computed, shallowRef, toValue, watch } from "vue";
+import { createError, useRoute } from "#imports";
+import { resolveCollectionI18n } from "../../../features/localization/path";
+import { useContentRoute } from "./route.js";
+import { getContentRuntime } from "./runtime.js";
+import { contentCollectionName, resolveLocaleFromRoutePath } from "./use-content-shared.js";
+import { useContentOne } from "./use-content-document.js";
+import { useContentNeighbors } from "./use-content-navigation.js";
+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 collectionI18n = resolveCollectionI18n(contentCollectionName(handle), runtime);
+  const activeLocale = computed(() => {
+    const explicitLocale = toValue(oneOptions.locale);
+    if (explicitLocale) {
+      return explicitLocale;
+    }
+    const { locales, defaultLocale } = collectionI18n;
+    if (!locales.length && !defaultLocale) {
+      return void 0;
+    }
+    return resolveLocaleFromRoutePath(route.path, 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();
+    }
+  };
+}

package/dist/runtime/app/composables/use-content-shared

@@ -0,0 +1 @@
+export * from './use-content-shared.js'

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

@@ -0,0 +1,13 @@
+import type { MaybeRefOrGetter } from 'vue';
+import type { ContentCollectionTarget } from '../../../types/query';
+export type ReactiveLeaf<T> = T | MaybeRefOrGetter<T>;
+export 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>;
+export type Reactive<T> = {
+    [K in keyof T]: ReactiveValue<T[K]>;
+};
+export declare const resolveOptions: <T extends Record<string, unknown>>(reactive: Reactive<T>) => T;
+export declare const stableKey: (prefix: string, name: string, options: unknown) => string;
+export declare const contentCollectionName: (handle: ContentCollectionTarget) => string;
+export declare const resolveLocaleFromRoutePath: (path: string, locales: string[], defaultLocale?: string) => string | undefined;

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

@@ -0,0 +1,29 @@
+import { toValue } from "vue";
+import { hash } from "ohash";
+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;
+};
+export const resolveOptions = (reactive) => {
+  return unwrapDeep(reactive);
+};
+export const stableKey = (prefix, name, options) => `${prefix}:${name}:${hash(options)}`;
+export const contentCollectionName = (handle) => typeof handle === "string" ? handle : handle.name;
+export const resolveLocaleFromRoutePath = (path, locales, defaultLocale) => {
+  const firstSegment = path.split("/").filter(Boolean)[0];
+  return firstSegment && locales.includes(firstSegment) ? firstSegment : defaultLocale;
+};