@lupinum/ginko-content 0.1.0

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

@@ -0,0 +1,188 @@
+import type { ComputedRef, MaybeRefOrGetter } from 'vue';
+import { createError } from '#imports';
+import type { ContentCollectionHandle } from '../../../types/config';
+import type { BacklinksOptions, BacklinksResult, BacklinkSource, 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 ContentCollectionHandle | string, 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 neighbor 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> {
+    page: ComputedRef<LocalizedDoc<T> | undefined>;
+    surround: ComputedRef<Array<ContentTreeItem<T> | null>>;
+    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 ContentCollectionHandle | string, 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 ContentCollectionHandle | string, 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 ContentCollectionHandle | string, 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 ContentCollectionHandle | string, 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 ContentCollectionHandle | string, 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 ContentCollectionHandle | string>(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>;
+}
+/**
+ * Reactively resolve the navigation tree for a collection.
+ */
+export declare function useContentTree<H extends ContentCollectionHandle | string>(handle: H, options?: Reactive<TreeOptions<H>>): Promise<UseContentTreeReturn<ContentTreeItem<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 ContentCollectionHandle | string>(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:
+ *
+ * ```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 ContentCollectionHandle | string, 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, DocumentFromHandle, NeighborsOptions, NeighborsResult, PaginationOptions, PaginationResult, PopulateSpec, PopulateFromOptions, PopulatedDocument, ResolveOneOptions, ResolveOneResult, SortSpec, TreeOptions, VariantsOptions, ContentVariant };

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

@@ -0,0 +1,307 @@
+import { computed, shallowRef, toValue, watch } from "vue";
+import { hash } from "ohash";
+import { createError, useAsyncData, useRoute } from "#imports";
+import { createClientContentQueryContext } from "./query-api.js";
+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 { useContentRoute } from "./route.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)}`;
+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 normalizeSurround = (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 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,
+    by: routeSelector
+  });
+  const surroundOptions = normalizeSurround(surround);
+  const neighborResultPromise = surroundOptions ? useContentNeighbors(handle, {
+    ...surroundOptions,
+    ..."locale" in oneOptions ? { locale: oneOptions.locale } : {},
+    ..."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 neighborResult = neighborResultPromise ? await neighborResultPromise : void 0;
+  const pending = computed(() => pageResult.pending.value || Boolean(neighborResult?.pending.value));
+  const pageError = computed(() => {
+    if (pageResult.error.value) return pageResult.error.value;
+    if (neighborResult?.error.value) return neighborResult.error.value;
+    if (pending.value || resolvingRoute.value || page.value || notFound === false) return void 0;
+    return normalizePageNotFound(notFound);
+  });
+  if (!isBrowser && pageError.value) {
+    throw pageError.value;
+  }
+  return {
+    page,
+    surround: computed(() => {
+      if (!page.value || !neighborResult) return [];
+      const neighbors = neighborResult.data.value;
+      return [neighbors.prev, neighbors.next];
+    }),
+    pending,
+    status: computed(() => pageResult.status.value),
+    error: pageError,
+    refresh: async () => {
+      await pageResult.refresh();
+      if (neighborResult) await neighborResult.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()
+  };
+}
+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 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 };
+}

package/dist/runtime/app/composables/useUnwrap

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

package/dist/runtime/app/composables/useUnwrap.d.ts

@@ -0,0 +1,8 @@
+import type { MarkdownNode, MarkdownRoot } from '../../../types/content';
+declare function flatUnwrap(value: MarkdownRoot | MarkdownNode[], unwrap?: boolean | string | string[]): MarkdownNode[];
+declare function unwrap(value: MarkdownRoot | MarkdownNode[], tags?: boolean | string | string[]): MarkdownRoot;
+export declare const useUnwrap: () => {
+    unwrap: typeof unwrap;
+    flatUnwrap: typeof flatUnwrap;
+};
+export {};

package/dist/runtime/app/composables/useUnwrap.js

@@ -0,0 +1,35 @@
+function normalizeUnwrap(unwrap2) {
+  if (!unwrap2 || unwrap2 === true) {
+    return [];
+  }
+  return Array.isArray(unwrap2) ? unwrap2 : unwrap2.split(/\s+/).filter(Boolean);
+}
+function flatUnwrap(value, unwrap2 = false) {
+  const tags = normalizeUnwrap(unwrap2);
+  const nodes = Array.isArray(value) ? value : value.children;
+  if (!tags.length || nodes.length !== 1) {
+    return nodes;
+  }
+  const first = nodes[0];
+  if (!first?.tag || !tags.includes(first.tag)) {
+    return nodes;
+  }
+  return first.children || [];
+}
+function unwrap(value, tags = false) {
+  const nodes = flatUnwrap(value, tags);
+  if (Array.isArray(value)) {
+    return {
+      type: "root",
+      children: nodes
+    };
+  }
+  return {
+    ...value,
+    children: nodes
+  };
+}
+export const useUnwrap = () => ({
+  unwrap,
+  flatUnwrap
+});

package/dist/runtime/app/composables/utils

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

package/dist/runtime/app/composables/utils.d.ts

@@ -0,0 +1,22 @@
+import type { ContentQueryBuilderParams } from '../../../types/query';
+interface ContentRuntimeShape {
+    integrity?: string | number;
+    api: {
+        baseURL: string;
+    };
+}
+export declare const withContentBase: (url: string) => string;
+export declare const navigationDisabled: () => never;
+export declare const addPrerenderPath: (path: string) => void;
+export type ContentApiEndpoint = 'query' | 'navigation';
+export type ContentApiFetcher = (request: string, init?: Record<string, unknown>) => Promise<unknown>;
+export declare const getPreviewToken: () => string | undefined;
+export declare const getContentApiFetcher: (fetcher?: ContentApiFetcher) => ContentApiFetcher;
+export declare const buildContentApiPath: (endpoint: ContentApiEndpoint, params: ContentQueryBuilderParams, runtime?: ContentRuntimeShape) => string;
+export declare const isHtmlFallbackResponse: (data: unknown) => data is string;
+export declare function fetchContentApi<T>(endpoint: ContentApiEndpoint, params: ContentQueryBuilderParams, options?: {
+    fetcher?: ContentApiFetcher;
+    runtime?: ContentRuntimeShape;
+    notFoundMessage?: string;
+}): Promise<T>;
+export {};

package/dist/runtime/app/composables/utils.js

@@ -0,0 +1,76 @@
+import { withBase } from "ufo";
+import { hash } from "ohash";
+import { useRequestEvent, useRequestFetch } from "#imports";
+import { encodeQueryParams } from "../../utils/query.js";
+import { useContentPreview } from "./preview.js";
+import { getContentRuntime } from "./runtime.js";
+const readContentRuntime = () => getContentRuntime();
+export const withContentBase = (url) => withBase(url, readContentRuntime().api.baseURL);
+export const navigationDisabled = () => {
+  console.warn("Navigation is only accessible when you enable it in module options.");
+  console.warn("Learn more in the Ginko navigation documentation.");
+  throw new Error("Navigation is only accessible when you enable it in module options.");
+};
+const lookupRequestEvent = () => {
+  try {
+    return useRequestEvent();
+  } catch {
+    return void 0;
+  }
+};
+const addPathToEvent = (event, path) => {
+  event.node.res.setHeader(
+    "x-nitro-prerender",
+    [
+      event.node.res.getHeader("x-nitro-prerender"),
+      path
+    ].filter(Boolean).join(",")
+  );
+};
+const createPrerenderPathAdder = () => {
+  const event = lookupRequestEvent();
+  return event ? (path) => addPathToEvent(event, path) : void 0;
+};
+export const addPrerenderPath = (path) => {
+  const event = lookupRequestEvent();
+  if (event) {
+    addPathToEvent(event, path);
+  }
+};
+export const getPreviewToken = () => useContentPreview().getPreviewToken();
+export const getContentApiFetcher = (fetcher) => {
+  if (fetcher) {
+    return fetcher;
+  }
+  if (import.meta.server) {
+    return useRequestFetch();
+  }
+  return $fetch;
+};
+export const buildContentApiPath = (endpoint, params, runtime) => {
+  const content = runtime || readContentRuntime();
+  const encodedParams = encodeQueryParams(params);
+  const requestKey = import.meta.dev ? "_" : `${hash(params)}.${content.integrity}`;
+  return withBase(`/${endpoint}/${requestKey}/${encodedParams}.json`, content.api.baseURL);
+};
+export const isHtmlFallbackResponse = (data) => {
+  return typeof data === "string" && data.startsWith("<!DOCTYPE html>");
+};
+export async function fetchContentApi(endpoint, params, options = {}) {
+  const apiPath = buildContentApiPath(endpoint, params, options.runtime);
+  const previewToken = getPreviewToken();
+  const addPrerenderPathOnSuccess = !import.meta.dev && import.meta.server ? createPrerenderPathAdder() : void 0;
+  const fetcher = getContentApiFetcher(options.fetcher);
+  const data = await fetcher(apiPath, {
+    method: "GET",
+    responseType: "json",
+    ...previewToken ? { headers: { "x-nuxt-content-preview": previewToken } } : {}
+  });
+  if (isHtmlFallbackResponse(data)) {
+    throw new Error(options.notFoundMessage || "Not found");
+  }
+  if (!import.meta.dev && import.meta.server) {
+    addPrerenderPathOnSuccess?.(apiPath);
+  }
+  return data;
+}

package/dist/runtime/app/composables/web-socket

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

package/dist/runtime/app/composables/web-socket.d.ts

@@ -0,0 +1,3 @@
+export declare function useContentWebSocket(): {
+    connect: (retry?: boolean) => void;
+} | undefined;