@lupinum/ginko-content 0.1.0

package/dist/runtime/transformers/index

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

package/dist/runtime/transformers/index.d.ts

@@ -0,0 +1 @@
+export { transformContent, defineTransformer } from '../../parsers/index';

package/dist/runtime/transformers/index.js

@@ -0,0 +1 @@
+export { transformContent, defineTransformer } from "../../parsers/index";

package/dist/runtime/transformers/json

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

package/dist/runtime/transformers/json.d.ts

@@ -0,0 +1 @@
+export { default } from '../../parsers/json';

package/dist/runtime/transformers/json.js

@@ -0,0 +1 @@
+export { default } from "../../parsers/json";

package/dist/runtime/transformers/markdown

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

package/dist/runtime/transformers/markdown.d.ts

@@ -0,0 +1 @@
+export { default } from '../../parsers/markdown';

package/dist/runtime/transformers/markdown.js

@@ -0,0 +1 @@
+export { default } from "../../parsers/markdown";

package/dist/runtime/transformers/path-meta

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

package/dist/runtime/transformers/path-meta.d.ts

@@ -0,0 +1,2 @@
+export { default } from '../../parsers/path-meta';
+export { describeId, generateCanonicalKey, generatePath, generateTitle, refineUrlPart } from '../../parsers/path-meta';

package/dist/runtime/transformers/path-meta.js

@@ -0,0 +1,2 @@
+export { default } from "../../parsers/path-meta";
+export { describeId, generateCanonicalKey, generatePath, generateTitle, refineUrlPart } from "../../parsers/path-meta";

package/dist/runtime/transformers/utils

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

package/dist/runtime/transformers/utils.d.ts

@@ -0,0 +1 @@
+export { defineTransformer } from '../../parsers/utils';

package/dist/runtime/transformers/utils.js

@@ -0,0 +1 @@
+export { defineTransformer } from "../../parsers/utils";

package/dist/runtime/transformers/yaml

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

package/dist/runtime/transformers/yaml.d.ts

@@ -0,0 +1 @@
+export { default } from '../../parsers/yaml';

package/dist/runtime/transformers/yaml.js

@@ -0,0 +1 @@
+export { default } from "../../parsers/yaml";

package/dist/runtime/utils/content-components

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

package/dist/runtime/utils/content-components.d.ts

@@ -0,0 +1,9 @@
+import type { AsyncComponentLoader } from 'vue';
+declare module '#build/content-components' {
+    const globalComponents: string[];
+    const localComponents: string[];
+    const localComponentLoaders: Record<string, AsyncComponentLoader>;
+}
+export declare const globalComponents: string[];
+export declare const localComponents: string[];
+export declare const localComponentLoaders: Record<string, AsyncComponentLoader>;

package/dist/runtime/utils/content-components.js

@@ -0,0 +1,16 @@
+const fallbackContentComponents = {
+  globalComponents: [],
+  localComponents: [],
+  localComponentLoaders: {}
+};
+async function loadContentComponents() {
+  try {
+    return await import("#build/content-components");
+  } catch {
+    return fallbackContentComponents;
+  }
+}
+const contentComponents = await loadContentComponents();
+export const globalComponents = contentComponents.globalComponents;
+export const localComponents = contentComponents.localComponents;
+export const localComponentLoaders = contentComponents.localComponentLoaders;

package/dist/runtime/utils/query

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

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

@@ -0,0 +1,5 @@
+import { type H3Event } from 'h3';
+import type { ContentQueryBuilderParams } from '../../types/query';
+import { decodeQueryParams, encodeQueryParams, ensureQueryWhereArray, findQueryWhere, collectQueryWhere, normalizeContentQueryParams } from '../../core/query/params';
+export declare const getContentQuery: (event: H3Event) => ContentQueryBuilderParams;
+export { collectQueryWhere, decodeQueryParams, encodeQueryParams, ensureQueryWhereArray, findQueryWhere, normalizeContentQueryParams };

package/dist/runtime/utils/query.js

@@ -0,0 +1,18 @@
+import { createError } from "h3";
+import { decodeQueryParams, encodeQueryParams, ensureQueryWhereArray, findQueryWhere, collectQueryWhere, normalizeContentQueryParams } from "../../core/query/params";
+const safeDecodeQueryParams = (encoded) => {
+  try {
+    return decodeQueryParams(encoded);
+  } catch {
+    throw createError({ statusCode: 400, message: "Invalid _params query" });
+  }
+};
+export const getContentQuery = (event) => {
+  const encoded = event.context.params?.params;
+  if (!encoded) {
+    return {};
+  }
+  const normalized = encoded.replace(/\.json$/, "").replace(/^[^/]+\//, "");
+  return safeDecodeQueryParams(normalized);
+};
+export { collectQueryWhere, decodeQueryParams, encodeQueryParams, ensureQueryWhereArray, findQueryWhere, normalizeContentQueryParams };

package/dist/runtime/virtual/transformers.d.ts

@@ -0,0 +1,4 @@
+import type { ContentTransformer } from '../../types/content'
+
+export const getParser: (extension: string) => ContentTransformer | undefined
+export const getTransformers: (extension: string) => ContentTransformer[]

package/dist/runtime/virtual.d.ts

@@ -0,0 +1,7 @@
+declare module '#build/content-i18n.mjs' {
+  export function useRouteBaseName(): (route: { name?: unknown } | unknown) => string | undefined
+  export function useSetI18nParams(): (params: Record<string, unknown>) => void
+  export function useSwitchLocalePath(): (locale: string) => string
+}
+
+export {}

package/dist/storage/cache

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

package/dist/storage/cache.d.ts

@@ -0,0 +1,32 @@
+import type { H3Event } from 'h3';
+import type { ParsedContent } from '../types/content';
+import type { ContentCacheStore, SingleFlightMap } from '../core/cache';
+/**
+ * Single-flight primitive. Each factory for a given key resolves exactly once;
+ * concurrent callers share the same promise. The entry clears on settle so the
+ * next call after resolution re-runs the factory.
+ *
+ * Intentionally kept as a pure factory — no module-level state — so the store
+ * factory below can create per-store instances without cross-store leakage.
+ */
+export declare const createSingleFlightMap: <T>() => SingleFlightMap<T>;
+/**
+ * Build a fresh content cache store. Every store has its own contents map and
+ * its own pair of single-flight maps — they do not share state with other
+ * instances. Tests should create one store per test to stay isolated.
+ */
+export declare const createContentCacheStore: () => ContentCacheStore<ParsedContent>;
+/**
+ * Resolve the cache store for a given request. Each event gets its own store,
+ * lazily created on first access and retained only for the request lifetime.
+ */
+export declare const cacheStoreFor: (event: H3Event) => ContentCacheStore<ParsedContent>;
+/**
+ * Clear the parsed-contents cache for the active request. Useful in tests that
+ * want to force a cold read inside the same request. With request-scoped
+ * stores there is nothing meaningful to clear globally, so the eventless form
+ * is intentionally a no-op.
+ */
+export declare const cleanCachedContents: (event?: H3Event) => void;
+export declare const getCachedContents: (event: H3Event, key: string) => ParsedContent[] | undefined;
+export declare const setCachedContents: (event: H3Event, key: string, contents: ParsedContent[]) => void;

package/dist/storage/cache.js

@@ -0,0 +1,42 @@
+import { getContentRuntimeContext } from "../integrations/nitro/context";
+export const createSingleFlightMap = () => {
+  const pending = /* @__PURE__ */ new Map();
+  return {
+    run(key, factory) {
+      if (!pending.has(key)) {
+        pending.set(key, Promise.resolve().then(factory).finally(() => {
+          pending.delete(key);
+        }));
+      }
+      return pending.get(key);
+    }
+  };
+};
+export const createContentCacheStore = () => {
+  const contents = /* @__PURE__ */ new Map();
+  return {
+    getContents: (key) => contents.get(key),
+    setContents: (key, value) => {
+      contents.set(key, value);
+    },
+    clearContents: () => {
+      contents.clear();
+    },
+    inflightContents: createSingleFlightMap(),
+    inflightContentsList: createSingleFlightMap()
+  };
+};
+export const cacheStoreFor = (event) => {
+  const runtime = getContentRuntimeContext(event);
+  runtime.caches ||= createContentCacheStore();
+  return runtime.caches;
+};
+export const cleanCachedContents = (event) => {
+  if (event) {
+    cacheStoreFor(event).clearContents();
+  }
+};
+export const getCachedContents = (event, key) => cacheStoreFor(event).getContents(key);
+export const setCachedContents = (event, key, contents) => {
+  cacheStoreFor(event).setContents(key, contents);
+};

package/dist/storage/content

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

package/dist/storage/content.d.ts

@@ -0,0 +1,41 @@
+import type { H3Event } from 'h3';
+import type { ParsedContent } from '../types/content';
+import type { ContentCollectionMap, ContentLocaleEntry, ContentQueryBuilderParams, ContentQueryRequest, CollectionQueryBuilder, ResolveContentReferenceOptions } from '../types/query';
+export declare const createServerQueryFetch: <T = ParsedContent>(event: H3Event) => (query: ContentQueryRequest) => Promise<import("../types/api").ContentQueryCountResponse | {
+    result: T | T[] | undefined;
+} | {
+    result: T | T[] | undefined;
+    skip: number;
+    limit: number;
+    total: number;
+}>;
+/**
+ * Resolve an authored content reference value to a concrete document.
+ *
+ * This understands locale variants, locale fallback, and collection scoping,
+ * and it augments the returned document with metadata about how the variant was
+ * resolved.
+ *
+ * @example
+ * ```ts
+ * const author = await resolveContentReference(event, 'authors/evan', {
+ *   collection: 'authors',
+ *   locale: 'de',
+ *   fallback: true
+ * })
+ * ```
+ */
+export declare const resolveContentReference: <T = ParsedContent>(event: H3Event, reference: string, options?: ResolveContentReferenceOptions) => Promise<(T & {
+    _requestedLocale?: string;
+    _resolvedLocale?: string;
+    _fallback?: boolean;
+    _availableLocales?: string[];
+    _variantPaths?: Record<string, string>;
+}) | null>;
+export declare const createServerContentQuery: <T = ParsedContent>(event: H3Event, query?: string | ContentQueryBuilderParams, ...pathParts: string[]) => import("../types/query").ContentQueryBuilder<T>;
+export declare function serverQueryCollection<K extends keyof ContentCollectionMap & string>(event: H3Event, collection: K): CollectionQueryBuilder<ContentCollectionMap[K]>;
+export declare function serverQueryCollection<T = ParsedContent>(event: H3Event, collection: string): CollectionQueryBuilder<T>;
+/**
+ * List every locale variant available for a collection entry on the server.
+ */
+export declare const queryCollectionLocales: <K extends keyof ContentCollectionMap & string>(event: H3Event, collection: K, identity: string) => Promise<ContentLocaleEntry[]>;

package/dist/storage/content.js

@@ -0,0 +1,86 @@
+import { joinURL, withLeadingSlash } from "ufo";
+import { createQuery, wrapQueryBuilder } from "../core/query/builder";
+import { resolveGraphCanonicalKey, resolveGraphCollectionLocales, resolveGraphVariant } from "../core/content/graph";
+import { normalizeReferenceValue } from "../core/references/resolve";
+import { executeQueryPlan } from "../core/query/execute";
+import { lowerQueryPlan } from "../core/query/lower";
+import { normalizeContentQueryParams } from "../core/query/params";
+import { normalizeI18nConfig, resolveRuntimeCollectionI18nConfig } from "../features/localization/config";
+import { contentConfig } from "./driver.js";
+import { withResolvedRefsQueryResponse } from "./references.js";
+import { getContentGraph } from "./graph.js";
+export const createServerQueryFetch = (event) => (query) => {
+  const config = contentConfig();
+  return getContentGraph(event).then((graph) => {
+    const response = executeQueryPlan(graph, lowerQueryPlan(query.params()), {
+      defaultLocale: config.defaultLocale,
+      localeFallback: config.localeFallback
+    });
+    return withResolvedRefsQueryResponse(event, response, query.params());
+  });
+};
+export const resolveContentReference = async (event, reference, options = {}) => {
+  const config = contentConfig();
+  const graph = await getContentGraph(event);
+  const normalizedReference = normalizeReferenceValue(reference);
+  const canonicalId = normalizedReference ? resolveGraphCanonicalKey(graph, normalizedReference, options.collection) : null;
+  if (!canonicalId) {
+    return null;
+  }
+  const variants = Object.values(graph.byCanonical[canonicalId] || {}).map((entry) => entry.document).filter((document) => !options.collection || document._collection === options.collection);
+  if (!variants.length) {
+    return null;
+  }
+  const resolvedVariant = resolveGraphVariant(graph, canonicalId, options.locale, {
+    defaultLocale: config.defaultLocale,
+    fallback: Array.isArray(options.fallback) ? options.fallback : options.fallback ? config.localeFallback?.[options.locale || ""] || [] : [],
+    exact: options.exact,
+    localeFallback: config.localeFallback
+  });
+  const resolved = resolvedVariant ? graph.byId[resolvedVariant.contentId] : void 0;
+  if (!resolved || !resolvedVariant) {
+    return null;
+  }
+  const availableLocales = Array.from(new Set(variants.map((document) => document._locale).filter(Boolean)));
+  const variantPaths = Object.fromEntries(
+    variants.filter((document) => document._locale && document._path).map((document) => [document._locale, document._path])
+  );
+  return {
+    ...resolved,
+    _requestedLocale: resolvedVariant.requestedLocale,
+    _resolvedLocale: resolvedVariant.resolvedLocale,
+    _fallback: resolvedVariant.fallback,
+    _availableLocales: availableLocales,
+    _variantPaths: variantPaths
+  };
+};
+const getServerCollectionI18n = (collection) => {
+  const config = contentConfig();
+  return collection ? resolveRuntimeCollectionI18nConfig(collection, config) : normalizeI18nConfig(config);
+};
+export const createServerContentQuery = (event, query, ...pathParts) => {
+  const config = contentConfig();
+  const queryBuilder = createQuery(createServerQueryFetch(event), { initialParams: typeof query !== "string" ? query || {} : {} });
+  let path;
+  if (typeof query === "string") {
+    path = withLeadingSlash(joinURL(query, ...pathParts));
+  }
+  return wrapQueryBuilder(queryBuilder, (params) => {
+    const collectionI18n = getServerCollectionI18n(params.collection);
+    return normalizeContentQueryParams(params, {
+      path,
+      collectionI18n,
+      defaultLocale: config.defaultLocale,
+      localeFallback: config.localeFallback,
+      activeLocale: collectionI18n?.defaultLocale,
+      includeDraftFilter: !import.meta.dev
+    });
+  });
+};
+export function serverQueryCollection(event, collection) {
+  return createServerContentQuery(event, { collection });
+}
+export const queryCollectionLocales = async (event, collection, identity) => {
+  const graph = await getContentGraph(event);
+  return resolveGraphCollectionLocales(graph, identity, collection);
+};

package/dist/storage/contents

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

package/dist/storage/contents.d.ts

@@ -0,0 +1,5 @@
+import type { H3Event } from 'h3';
+import type { ParsedContent } from '../types/content';
+export declare function chunksFromArray<T>(arr: T[], n: number): Generator<T[], void>;
+export declare const getContentsList: (event: H3Event, prefix?: string) => Promise<ParsedContent[]>;
+export declare const getContent: (event: H3Event, id: string) => Promise<ParsedContent>;

package/dist/storage/contents.js

@@ -0,0 +1,116 @@
+import { hash as ohash } from "ohash";
+import { splitInlineLocaleVariantId } from "../core/content/locale";
+import { memoizeRuntimeValue } from "../integrations/nitro/context";
+import { parseContentVariants } from "../integrations/nitro/ingest";
+import { cacheStoreFor, getCachedContents, setCachedContents } from "./cache.js";
+import { contentConfig, contentIgnorePredicate, getContentStorageRuntime, getContentsIds, resolveStorageId } from "./driver.js";
+import { validateContentGraph } from "./validation.js";
+const isProduction = process.env.NODE_ENV === "production";
+const isPrerendering = import.meta.prerender;
+const shouldValidateAtRuntime = import.meta.dev || isPrerendering;
+const isContentCacheArtifact = (value) => {
+  return Boolean(value) && typeof value === "object" && Array.isArray(value.parsed) && typeof value.hash === "string";
+};
+export function* chunksFromArray(arr, n) {
+  for (let i = 0; i < arr.length; i += n) {
+    yield arr.slice(i, i + n);
+  }
+}
+const loadContentVariants = async (event, id) => {
+  const runtime = getContentStorageRuntime(event);
+  const config = contentConfig();
+  const { sourceId: contentId } = splitInlineLocaleVariantId(id);
+  if (!contentIgnorePredicate(contentId)) {
+    return [{ _id: contentId, body: null }];
+  }
+  const storageId = await resolveStorageId(event, contentId);
+  const cachedValue = await runtime.parsedCache.getItem(storageId);
+  const cached = isContentCacheArtifact(cachedValue) ? cachedValue : null;
+  if (isProduction && !isPrerendering && cached) {
+    return cached.parsed;
+  }
+  const meta = await runtime.source.getMeta(storageId);
+  const hash = ohash({
+    mtime: meta.mtime,
+    size: meta.size || 0,
+    version: runtime.config.cacheVersion,
+    integrity: runtime.config.cacheIntegrity,
+    collections: runtime.config.collections,
+    defaultLocale: runtime.config.defaultLocale,
+    locales: runtime.config.locales,
+    translatedSlugs: runtime.config.translatedSlugs,
+    strictTranslatedSlugs: runtime.config.strictTranslatedSlugs,
+    respectPathCase: runtime.config.respectPathCase
+  });
+  if (cached?.hash === hash) {
+    return cached.parsed;
+  }
+  return cacheStoreFor(event).inflightContents.run(`${storageId}${hash}`, async () => {
+    const body = await runtime.source.getItem(storageId);
+    if (body === null) {
+      return [{ _id: contentId, body: null }];
+    }
+    const parsed = await parseContentVariants(contentId, body, config, { validate: true });
+    try {
+      await runtime.parsedCache.setItem(storageId, { parsed, hash });
+    } catch (error) {
+      if (import.meta.dev) {
+        console.warn(`[content] Failed to cache parsed content for "${storageId}"`, error);
+      }
+    }
+    return parsed;
+  });
+};
+const loadContents = async (event, prefix) => {
+  const keys = await getContentsIds(event, prefix);
+  const contents = [];
+  for (const chunk of [...chunksFromArray(keys, 10)]) {
+    const result = await Promise.all(chunk.map((key) => loadContentVariants(event, key)));
+    contents.push(...result.flat());
+  }
+  const filtered = contents.filter((document) => document && document._path);
+  if (shouldValidateAtRuntime) {
+    const outcome = validateContentGraph(filtered, contentConfig());
+    if (!outcome.ok) {
+      throw outcome.error;
+    }
+  }
+  return filtered;
+};
+export const getContentsList = (event, prefix) => {
+  const runtime = getContentStorageRuntime(event);
+  const cacheKey = JSON.stringify({
+    prefix,
+    sources: runtime.config.sources,
+    collections: runtime.config.collections,
+    defaultLocale: runtime.config.defaultLocale,
+    locales: runtime.config.locales,
+    translatedSlugs: runtime.config.translatedSlugs,
+    strictTranslatedSlugs: runtime.config.strictTranslatedSlugs
+  });
+  return memoizeRuntimeValue(event, `contents:${cacheKey}`, async () => {
+    const cached = getCachedContents(event, cacheKey);
+    if ((isPrerendering || !isProduction) && cached?.length) {
+      return cached;
+    }
+    return await cacheStoreFor(event).inflightContentsList.run(cacheKey, async () => {
+      const result = await loadContents(event, prefix);
+      if (isPrerendering || !isProduction) {
+        setCachedContents(event, cacheKey, result);
+      }
+      return result;
+    });
+  });
+};
+export const getContent = async (event, id) => {
+  const { sourceId, locale } = splitInlineLocaleVariantId(id);
+  const parsed = await loadContentVariants(event, sourceId);
+  if (!locale) {
+    return parsed[0];
+  }
+  const match = parsed.find((document) => document._locale === locale);
+  if (!match) {
+    console.warn(`[content] Locale variant "${locale}" not found for "${sourceId}", falling back to default`);
+  }
+  return match || parsed[0];
+};

package/dist/storage/driver

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

package/dist/storage/driver.d.ts

@@ -0,0 +1,28 @@
+import type { H3Event } from 'h3';
+import type { Storage, StorageValue } from 'unstorage';
+import { sourceStorage, cacheStorage, cacheParsedStorage, contentConfig, contentIgnorePredicate, getContentsIds, resolveStorageId } from '../integrations/nitro/storage';
+export interface ContentSourceDriver {
+    getKeys: (prefix?: string) => Promise<string[]>;
+    getItem: (key: string) => Promise<StorageValue | null>;
+    getMeta: (key: string) => Promise<{
+        mtime?: number;
+        size?: number;
+        [key: string]: unknown;
+    }>;
+}
+export interface ContentCacheDriver {
+    getItem: <T>(key: string) => Promise<T | null>;
+    setItem: (key: string, value: unknown) => Promise<void>;
+    removeItem?: (key: string) => Promise<void>;
+    getKeys?: (prefix?: string) => Promise<string[]>;
+}
+export interface ContentStorageRuntime {
+    event: H3Event;
+    config: ReturnType<typeof contentConfig>;
+    source: Storage;
+    cache: Storage;
+    parsedCache: Storage;
+    now: () => Date;
+}
+export declare const getContentStorageRuntime: (event: H3Event) => ContentStorageRuntime;
+export { cacheParsedStorage, cacheStorage, contentConfig, contentIgnorePredicate, getContentsIds, resolveStorageId, sourceStorage };

package/dist/storage/driver.js

@@ -0,0 +1,22 @@
+import { sourceStorage, cacheStorage, cacheParsedStorage, contentConfig, contentIgnorePredicate, getContentsIds, resolveStorageId } from "../integrations/nitro/storage";
+import { getContentRuntimeContext } from "../integrations/nitro/context";
+export const getContentStorageRuntime = (event) => {
+  const runtime = getContentRuntimeContext(event);
+  return {
+    event,
+    config: runtime.config || contentConfig(),
+    source: sourceStorage(event),
+    cache: cacheStorage(event),
+    parsedCache: cacheParsedStorage(event),
+    now: runtime.now || (() => /* @__PURE__ */ new Date())
+  };
+};
+export {
+  cacheParsedStorage,
+  cacheStorage,
+  contentConfig,
+  contentIgnorePredicate,
+  getContentsIds,
+  resolveStorageId,
+  sourceStorage
+};

package/dist/storage/graph

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

package/dist/storage/graph.d.ts

@@ -0,0 +1,3 @@
+import type { H3Event } from 'h3';
+import type { ContentGraph } from '../core/content/graph';
+export declare const getContentGraph: (event: H3Event) => Promise<ContentGraph>;

package/dist/storage/graph.js

@@ -0,0 +1,14 @@
+import { buildContentGraph } from "../core/content/graph";
+import { memoizeRuntimeValue } from "../integrations/nitro/context";
+import { contentConfig } from "./driver.js";
+import { getContentsList } from "./contents.js";
+export const getContentGraph = async (event) => {
+  return await memoizeRuntimeValue(event, "graph", async () => {
+    const config = contentConfig();
+    const contents = await getContentsList(event);
+    return buildContentGraph(contents, {
+      locales: config.locales,
+      defaultLocale: config.defaultLocale
+    });
+  });
+};

package/dist/storage/manifest

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

package/dist/storage/manifest.d.ts

@@ -0,0 +1,18 @@
+import type { H3Event } from 'h3';
+import type { ParsedContent } from '../types/content';
+import type { ContentLocaleEntry, ContentQueryRequest } from '../types/query';
+import type { ContentManifest } from '../types/runtime';
+import { resolveLocaleChain } from '../core/content/graph';
+export { resolveLocaleChain };
+export declare function getContentManifest(event: H3Event): Promise<ContentManifest>;
+export declare function resolveVariant(event: H3Event, canonicalKey: string, requestedLocale?: string, options?: {
+    fallback?: string[];
+    exact?: boolean;
+}): Promise<import("../types/runtime").ResolvedVariant | null>;
+export declare function resolveRouteVariant(event: H3Event, routePath: string, requestedLocale?: string, options?: {
+    fallback?: string[];
+    exact?: boolean;
+}): Promise<import("../types/runtime").ResolvedVariant | null>;
+export declare function resolveCanonicalKey(event: H3Event, identity: string, collection?: string): Promise<string | null>;
+export declare function resolveCollectionLocales(event: H3Event, identity: string, collection?: string): Promise<ContentLocaleEntry[]>;
+export declare function getIndexedContentsList(event: H3Event, query: ContentQueryRequest): Promise<ParsedContent[]>;

package/dist/storage/manifest.js

@@ -0,0 +1,68 @@
+import { resolveGraphCanonicalKey, resolveGraphCollectionLocales, resolveGraphRouteVariant, resolveGraphVariant, resolveLocaleChain, selectGraphDocuments } from "../core/content/graph";
+import { collectQueryWhere } from "../core/query/params";
+import { isPreview } from "../integrations/nitro/preview";
+import { getContentRuntimeConfig } from "../integrations/nitro/runtime-config";
+import { getContentsList } from "./contents.js";
+import { cacheStorage } from "./driver.js";
+import { getContentGraph } from "./graph.js";
+const isManifestCacheValid = (manifest) => {
+  return Boolean(
+    manifest && typeof manifest === "object" && manifest.byCanonical && manifest.byRef && manifest.byRoute && manifest.paths && manifest.collections
+  );
+};
+const hasRequestContext = (event) => {
+  return Boolean(event.node?.req);
+};
+export { resolveLocaleChain };
+export async function getContentManifest(event) {
+  if (!hasRequestContext(event) || !isPreview(event)) {
+    const cached = await cacheStorage(event).getItem("_manifest.json");
+    if (isManifestCacheValid(cached)) {
+      return cached;
+    }
+  }
+  const graph = await getContentGraph(event);
+  if (!hasRequestContext(event) || !isPreview(event)) {
+    await cacheStorage(event).setItem("_manifest.json", graph.manifest);
+  }
+  return graph.manifest;
+}
+export async function resolveVariant(event, canonicalKey, requestedLocale, options = {}) {
+  const config = getContentRuntimeConfig().content;
+  return resolveGraphVariant(await getContentGraph(event), canonicalKey, requestedLocale, {
+    defaultLocale: config.defaultLocale,
+    fallback: options.fallback,
+    exact: options.exact,
+    localeFallback: config.localeFallback
+  });
+}
+export async function resolveRouteVariant(event, routePath, requestedLocale, options = {}) {
+  const config = getContentRuntimeConfig().content;
+  return resolveGraphRouteVariant(await getContentGraph(event), routePath, requestedLocale, {
+    defaultLocale: config.defaultLocale,
+    fallback: options.fallback,
+    exact: options.exact,
+    localeFallback: config.localeFallback
+  });
+}
+export async function resolveCanonicalKey(event, identity, collection) {
+  return resolveGraphCanonicalKey(await getContentGraph(event), identity, collection);
+}
+export async function resolveCollectionLocales(event, identity, collection) {
+  return resolveGraphCollectionLocales(await getContentGraph(event), identity, collection);
+}
+export async function getIndexedContentsList(event, query) {
+  if (hasRequestContext(event) && isPreview(event)) {
+    return await getContentsList(event);
+  }
+  const params = query.params();
+  const paths = collectQueryWhere(params?.where, (where) => typeof where._path !== "undefined").map((where) => where._path).filter((path) => typeof path === "string" || path instanceof RegExp);
+  const graph = await getContentGraph(event);
+  if (!paths.length && !params?.collection) {
+    return graph.documents;
+  }
+  return selectGraphDocuments(graph, {
+    collection: params?.collection,
+    paths
+  });
+}