@lupinum/ginko-content 0.1.0

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

@@ -0,0 +1,21 @@
+import type { ParsedContent } from '../../types/content';
+import type { ContentCollectionSearchSectionsOptions, ContentSearchSection } from '../../types/query';
+type SearchablePage = Pick<ParsedContent, '_path' | 'title' | 'description' | 'body'> & Record<string, unknown>;
+/**
+ * Backing option type for search-section generation.
+ *
+ * Re-exported through the public query surface as
+ * `ContentCollectionSearchSectionsOptions`.
+ */
+export type GenerateSearchSectionsOptions = ContentCollectionSearchSectionsOptions;
+/**
+ * Searchable content section emitted for one page heading range.
+ *
+ * Re-exported through the public query surface as `ContentSearchSection`.
+ */
+export type SearchSection = ContentSearchSection;
+/**
+ * Split pages into searchable sections for pagefind-like indexing.
+ */
+export declare function createSearchSections(pages: SearchablePage[], opts?: GenerateSearchSectionsOptions): SearchSection[];
+export {};

package/dist/features/search/sections.js

@@ -0,0 +1,98 @@
+const HEADING = /^h([1-6])$/;
+const headingLevel = (tag) => Number(tag.match(HEADING)?.[1] ?? 0);
+export function createSearchSections(pages, opts) {
+  const { ignoredTags = ["pre", "style", "script"], extraFields = [], minHeading = "h1", maxHeading = "h6" } = opts || {};
+  const minLevel = headingLevel(minHeading);
+  const maxLevel = headingLevel(maxHeading);
+  return pages.flatMap(
+    (page) => splitPageIntoSections(page, {
+      ignoredTags,
+      extraFields,
+      minLevel,
+      maxLevel
+    })
+  );
+}
+function splitPageIntoSections(page, {
+  ignoredTags,
+  extraFields,
+  minLevel,
+  maxLevel
+}) {
+  const path = page._path || "";
+  const extraFieldsData = pick(extraFields, page);
+  const body = page.body;
+  const sections = [{
+    ...extraFieldsData,
+    id: path,
+    title: normalizeSearchText(String(page.title || "")),
+    titles: [],
+    content: normalizeSearchText(String(page.description || "")),
+    level: 1
+  }];
+  if (!body?.children) {
+    return sections;
+  }
+  let section = 1;
+  let previousHeadingLevel = 0;
+  const titles = [normalizeSearchText(String(page.title || ""))];
+  for (const item of body.children) {
+    const tag = item.tag || "";
+    const level = headingLevel(tag);
+    if (level >= minLevel && level <= maxLevel) {
+      const title = extractTextFromAst(item).trim();
+      if (level === 1) {
+        titles.splice(0, titles.length);
+      } else if (level < previousHeadingLevel) {
+        titles.splice(level - 1, titles.length - 1);
+      } else if (level === previousHeadingLevel) {
+        titles.pop();
+      }
+      sections.push({
+        ...extraFieldsData,
+        id: `${path}#${item.props?.id || ""}`,
+        title,
+        titles: [...titles],
+        content: "",
+        level
+      });
+      titles.push(title);
+      previousHeadingLevel = level;
+      section += 1;
+    } else {
+      const content = normalizeSearchText(extractTextFromAst(item, ignoredTags));
+      if (section === 1 && sections[section - 1]?.content === content) {
+        continue;
+      }
+      sections[section - 1].content = `${sections[section - 1].content} ${content}`.trim();
+    }
+  }
+  return sections;
+}
+function extractTextFromAst(node, ignoredTags = []) {
+  let text = "";
+  if (node.type === "text") {
+    text += node.value || "";
+  }
+  if (ignoredTags.includes(node.tag || "")) {
+    return "";
+  }
+  if (node.children?.length) {
+    text += node.children.map((child) => extractTextFromAst(child, ignoredTags)).filter(Boolean).join("");
+  }
+  return text;
+}
+function normalizeSearchText(value) {
+  return value.replace(/\[([^\]]+)\x5D\x7B[^\x7D]+\x7D/g, "$1").replace(/\s+/g, " ").trim();
+}
+function pick(fields, page) {
+  if (!fields.length) {
+    return {};
+  }
+  return fields.reduce((result, field) => {
+    if (typeof page[field] !== "undefined") {
+      result[field] = page[field];
+    }
+    return result;
+  }, {});
+}

package/dist/features/sitemap/query

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

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

@@ -0,0 +1,68 @@
+import type { ContentSitemapEntry } from '../../types/query';
+type ContentLikePage = {
+    _path?: string;
+    _collection?: string;
+    _canonicalKey?: string;
+    _locale?: string;
+    _draft?: boolean;
+    sitemap?: unknown;
+    body?: unknown;
+    image?: unknown;
+    seo?: unknown;
+    ogImage?: unknown;
+};
+type LocaleConfig = {
+    code: string;
+    language?: string;
+};
+export interface QueryCollectionsSitemapEntriesOptions {
+    /**
+     * Restrict generation to these collection names.
+     */
+    include?: string[];
+    /**
+     * Exclude these collection names from generation.
+     */
+    exclude?: string[];
+    /**
+     * Include draft entries. Defaults to `true` in dev and `false` otherwise.
+     */
+    includeDrafts?: boolean;
+    /**
+     * Absolute site URL used to expand relative paths in the final entries.
+     */
+    siteUrl?: string;
+}
+export interface SitemapRuntime {
+    collections?: Record<string, {
+        sitemap?: boolean;
+    } | unknown>;
+    defaultLocale?: string;
+    runtimeSiteUrl?: string;
+    localeConfigs?: LocaleConfig[];
+    requestSiteUrl?: string;
+}
+export interface SitemapLoaders {
+    loadCollectionPages: (collection: string) => Promise<ContentLikePage[]>;
+    loadRouteMeta: (collection: string, path: string, locale?: string) => Promise<{
+        locale: string;
+        path: string;
+        defaultLocale: string;
+        variants: Array<{
+            locale: string;
+            path: string;
+        }>;
+    } | null>;
+    loadPage: (collection: string, path: string, locale?: string) => Promise<{
+        body?: unknown;
+    } | null>;
+}
+/**
+ * Build sitemap entries from collection pages plus route/page loaders.
+ *
+ * This is the pure implementation behind the public server helper. It keeps
+ * URL resolution, locale alternatives, and image extraction testable without
+ * coupling the logic to Nitro.
+ */
+export declare function queryCollectionsSitemapEntriesData(runtime: SitemapRuntime, loaders: SitemapLoaders, options?: QueryCollectionsSitemapEntriesOptions): Promise<ContentSitemapEntry[]>;
+export {};

package/dist/features/sitemap/query.js

@@ -0,0 +1,171 @@
+import { createContentProviderError } from "../../public/provider-errors";
+const normalizeSiteUrl = (siteUrl) => siteUrl?.replace(/\/$/, "");
+const resolveSiteUrl = (runtime, explicitSiteUrl) => {
+  const normalizedExplicitSiteUrl = normalizeSiteUrl(explicitSiteUrl);
+  if (normalizedExplicitSiteUrl) {
+    return normalizedExplicitSiteUrl;
+  }
+  const normalizedRuntimeSiteUrl = normalizeSiteUrl(runtime.runtimeSiteUrl);
+  if (normalizedRuntimeSiteUrl) {
+    return normalizedRuntimeSiteUrl;
+  }
+  if (runtime.requestSiteUrl && process.env.NODE_ENV !== "production") {
+    return runtime.requestSiteUrl;
+  }
+  if (process.env.NODE_ENV === "production") {
+    throw new Error("Content sitemap generation requires site.url or runtimeConfig.public.siteUrl in production.");
+  }
+  return "http://localhost";
+};
+const collectContentImageUrls = (body, urls = /* @__PURE__ */ new Set()) => {
+  if (!body) {
+    return urls;
+  }
+  if (typeof body !== "object") {
+    return urls;
+  }
+  const node = body;
+  if (node.tag === "img" && typeof node.props?.src === "string") {
+    urls.add(node.props.src);
+  }
+  if (Array.isArray(node.children)) {
+    for (const child of node.children) {
+      collectContentImageUrls(child, urls);
+    }
+  }
+  if (node.value) {
+    collectContentImageUrls(node.value, urls);
+  }
+  return urls;
+};
+const collectStructuredImageUrls = (value, urls = /* @__PURE__ */ new Set()) => {
+  if (!value || typeof value !== "object") {
+    return urls;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      collectStructuredImageUrls(item, urls);
+    }
+    return urls;
+  }
+  const record = value;
+  for (const key of ["src", "url", "loc"]) {
+    if (typeof record[key] === "string") {
+      urls.add(record[key]);
+    }
+  }
+  for (const nested of Object.values(record)) {
+    if (nested && typeof nested === "object") {
+      collectStructuredImageUrls(nested, urls);
+    }
+  }
+  return urls;
+};
+const toAbsoluteImageUrl = (siteUrl, loc) => {
+  try {
+    return new URL(loc).href;
+  } catch {
+    return loc.startsWith("/") ? `${siteUrl}${loc}` : loc;
+  }
+};
+const toPageSitemapImages = (siteUrl, page, body) => {
+  const urls = collectContentImageUrls(body);
+  if (page) {
+    collectStructuredImageUrls(page.sitemap, urls);
+    collectStructuredImageUrls(page.image, urls);
+    collectStructuredImageUrls(page.seo, urls);
+    collectStructuredImageUrls(page.ogImage, urls);
+  }
+  const images = Array.from(urls).map((loc) => ({ loc: toAbsoluteImageUrl(siteUrl, loc) }));
+  return images.length ? images : void 0;
+};
+const toAbsoluteUrl = (siteUrl, path) => `${siteUrl}${path}`;
+const buildAlternatives = (siteUrl, defaultLocale, localeToLanguage, variants) => {
+  const alternatives = variants.map((variant) => ({
+    hreflang: localeToLanguage[variant.locale] || variant.locale,
+    href: toAbsoluteUrl(siteUrl, variant.path)
+  }));
+  const defaultVariant = variants.find((variant) => variant.locale === defaultLocale);
+  if (defaultVariant) {
+    alternatives.unshift({
+      hreflang: "x-default",
+      href: toAbsoluteUrl(siteUrl, defaultVariant.path)
+    });
+  }
+  return alternatives;
+};
+const resolveSitemapCollections = (runtime, options = {}) => {
+  const hasExplicitInclude = Boolean(options.include?.length);
+  const include = hasExplicitInclude ? options.include : Object.keys(runtime.collections || {});
+  const excluded = new Set(options.exclude || []);
+  return include.filter((collection) => {
+    const config = runtime.collections?.[collection];
+    if (excluded.has(collection)) {
+      return false;
+    }
+    if (config?.sitemap === false) {
+      if (hasExplicitInclude) {
+        throw createContentProviderError("data_collection_sitemap_access", `${collection} is not sitemap-backed.`, {
+          collection
+        });
+      }
+      return false;
+    }
+    return true;
+  });
+};
+export async function queryCollectionsSitemapEntriesData(runtime, loaders, options = {}) {
+  const localeToLanguage = Object.fromEntries((runtime.localeConfigs || []).map((locale) => [locale.code, locale.language || locale.code]));
+  const collections = resolveSitemapCollections(runtime, options);
+  const siteUrl = resolveSiteUrl(runtime, options.siteUrl);
+  const shouldIncludeDrafts = typeof options.includeDrafts === "boolean" ? options.includeDrafts : import.meta.dev;
+  const pages = (await Promise.all(collections.map(async (collection) => {
+    const collectionPages = await loaders.loadCollectionPages(collection);
+    return collectionPages.map((page) => ({
+      ...page,
+      _collection: page._collection || collection
+    }));
+  }))).flat().filter((page) => {
+    if (page.sitemap === false) {
+      return false;
+    }
+    return shouldIncludeDrafts || !page._draft;
+  });
+  const uniquePages = Array.from(new Map(
+    pages.map((page) => [
+      `${page._collection || ""}:${page._canonicalKey || page._path || ""}`,
+      page
+    ])
+  ).values());
+  const rawEntries = await Promise.all(uniquePages.map(async (page) => {
+    if (!page._path || !page._collection) {
+      return [];
+    }
+    const meta = await loaders.loadRouteMeta(page._collection, page._path, page._locale);
+    if (!meta) {
+      return [];
+    }
+    const variants = (meta.variants.length ? meta.variants : [{ locale: meta.locale, path: meta.path }]).filter((variant) => variant.path);
+    const localizedVariants = variants.filter((variant) => variant.locale);
+    const alternatives = localizedVariants.length > 1 ? buildAlternatives(siteUrl, meta.defaultLocale, localeToLanguage, variants) : void 0;
+    return await Promise.all(variants.map(async (variant) => {
+      const variantPage = await loaders.loadPage(page._collection, variant.path, variant.locale);
+      const images = toPageSitemapImages(
+        siteUrl,
+        variantPage ? { ...page, ...variantPage } : page,
+        variantPage?.body ?? page.body
+      );
+      return {
+        loc: variant.path,
+        ...variant.locale ? { _sitemap: localeToLanguage[variant.locale] || variant.locale } : {},
+        ...alternatives ? { alternatives } : {},
+        ...images ? { images } : {}
+      };
+    }));
+  }));
+  const uniqueEntries = /* @__PURE__ */ new Map();
+  for (const entry of rawEntries.flat()) {
+    uniqueEntries.set(`${entry._sitemap || "default"}:${entry.loc}`, entry);
+  }
+  return Array.from(uniqueEntries.values());
+}

package/dist/integrations/nitro/context

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

package/dist/integrations/nitro/context.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Nitro request-scoped runtime context.
+ *
+ * This file defines the single place where mutable, request-scoped state lives.
+ * The hard rule is:
+ *
+ *   Anything request-scoped lives on `ContentRuntimeContext`.
+ *   Nowhere else. Not in module-level `let`s, not in cached imports.
+ *
+ * Why: Nitro reuses the process across requests. Module-level `let` leaks one
+ * request's parsed content, graph, or in-flight promises into another — a
+ * silent correctness bug that's near-impossible to reproduce locally.
+ *
+ * The context is attached to `event.context.__contentRuntime` and created
+ * lazily on first access. Memoization uses `memoizeRuntimeValue` so the
+ * `graph` / `contents` caches are shared across helpers within a single
+ * request but torn down with the event.
+ */
+import type { H3Event } from 'h3';
+import type { Storage } from 'unstorage';
+import type { ParsedContent } from '../../types/content';
+import type { ContentContext as RuntimeContentConfig } from '../../types/module';
+import type { ContentGraph } from '../../core/content/graph';
+import type { ContentCacheStore } from '../../core/cache';
+import type { ContentCacheHint } from '../../public/provider';
+/**
+ * Per-request runtime state. Everything request-scoped belongs here; nothing
+ * request-scoped belongs in module-level singletons.
+ *
+ * `caches` holds the request-local parsed-content store and single-flight maps.
+ * It is populated lazily on first access by
+ * `storage/cache.ts#cacheStoreFor()` so this module does not have to reach into
+ * the `storage` layer at construction time (that would break the allowed
+ * dependency direction `integrations/ → storage/`, never the reverse).
+ */
+export interface ContentRuntimeContext {
+    config: RuntimeContentConfig;
+    now: () => Date;
+    storages?: {
+        sourceStorage: Storage;
+        cacheStorage: Storage;
+        cacheParsedStorage: Storage;
+    };
+    memo: {
+        contents?: ParsedContent[] | Promise<ParsedContent[]>;
+        graph?: ContentGraph | Promise<ContentGraph>;
+    };
+    caches?: ContentCacheStore<ParsedContent>;
+    cacheHint?: ContentCacheHint | false;
+}
+export declare const getContentRuntimeContext: (event: H3Event) => ContentRuntimeContext;
+/**
+ * Memoize an expensive per-request value (typically `contents` or `graph`).
+ *
+ * Concurrent callers within a single request that hit the same key all await
+ * the one `create()` promise — we do not start a second compute. The cache
+ * lives on `runtime.memo` so it is freed when the event is garbage-collected.
+ *
+ * GOTCHA: `create` runs only on miss. If you need a fresh value mid-request,
+ * you cannot use this helper — mutate `runtime.memo[key]` directly. In
+ * practice, nothing we build mid-request invalidates the graph.
+ */
+export declare const memoizeRuntimeValue: <T>(event: H3Event, key: keyof ContentRuntimeContext["memo"], create: () => Promise<T>) => Promise<T>;

package/dist/integrations/nitro/context.js

@@ -0,0 +1,28 @@
+import { getContentRuntimeConfig } from "./runtime-config.js";
+const createRuntimeContext = () => ({
+  config: getContentRuntimeConfig().content,
+  now: () => /* @__PURE__ */ new Date(),
+  memo: {}
+});
+export const getContentRuntimeContext = (event) => {
+  const context = event.context ||= {};
+  context.__contentRuntime ||= createRuntimeContext();
+  return context.__contentRuntime;
+};
+export const memoizeRuntimeValue = async (event, key, create) => {
+  const runtime = getContentRuntimeContext(event);
+  const cached = runtime.memo[key];
+  if (typeof cached !== "undefined") {
+    return cached;
+  }
+  const pending = create();
+  runtime.memo[key] = pending;
+  try {
+    const value = await pending;
+    runtime.memo[key] = value;
+    return value;
+  } catch (error) {
+    runtime.memo[key] = void 0;
+    throw error;
+  }
+};

package/dist/integrations/nitro/ingest

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

package/dist/integrations/nitro/ingest.d.ts

@@ -0,0 +1,18 @@
+import type { StorageValue } from 'unstorage';
+import type { ParsedContent } from '../../types/content';
+import type { ParseContentOptions } from '../../types/runtime';
+import type { ContentContext } from '../../types/module';
+/**
+ * Ingest a single source file into an array of `ParsedContent` variants
+ * (one per locale, including the default).
+ *
+ * The returned array is the full variant fan-out. Callers that want a
+ * specific locale select from it; callers that want the canonical document
+ * take `[0]` (see `parseContent` below).
+ *
+ * Throws a typed `ContentError` on failure — parse errors, transform errors,
+ * schema violations, and collection-path ambiguity all surface as specific
+ * `ContentErrorCode`s so HTTP and build-time callers can branch on them.
+ */
+export declare const parseContentVariants: (id: string, content: StorageValue, runtimeContentConfig: ContentContext, opts?: ParseContentOptions) => Promise<ParsedContent[]>;
+export declare const parseContent: (id: string, content: StorageValue, runtimeContentConfig: ContentContext, opts?: ParseContentOptions) => Promise<ParsedContent>;

package/dist/integrations/nitro/ingest.js

@@ -0,0 +1,120 @@
+import defu from "defu";
+import { useNitroApp } from "nitropack/runtime";
+import { ContentError } from "../../core/errors";
+import { transformContent } from "../../parsers";
+import { resolveCollection, resolveCollections } from "../../core/content/collection";
+import { expandDataLocaleVariants } from "../../core/content/locale";
+import { createContentError, validateCollectionDocument } from "../../storage/validation";
+const loadCustomTransformers = async () => {
+  try {
+    const specifier = "#content/virtual/transformers";
+    const module = await import(
+      /* @vite-ignore */
+      specifier
+    );
+    return module.transformers || [];
+  } catch {
+    return [];
+  }
+};
+const invalidContentError = (id, cause) => new ContentError("INVALID_CONTENT", `Failed to ingest content "${id}"`, { id }, { cause });
+const parseSource = async (id, body, options) => {
+  try {
+    return await transformContent(id, body, {
+      ...options,
+      pathMeta: {
+        ...options.pathMeta,
+        collectionResolver: (filePath) => resolveCollection(filePath, options.pathMeta?.collections, options.pathMeta?.locales || [])
+      }
+    });
+  } catch (cause) {
+    throw new ContentError(
+      "PARSE_FAILED",
+      `Failed to parse content "${id}"`,
+      { id },
+      { cause }
+    );
+  }
+};
+const expandLocaleVariants = async (document, options) => {
+  try {
+    const collection = document._collection && options.pathMeta?.collections ? options.pathMeta.collections[document._collection] : void 0;
+    return expandDataLocaleVariants(document, collection?.i18n);
+  } catch (cause) {
+    throw new ContentError(
+      "TRANSFORM_FAILED",
+      `Failed to transform content "${document._file || document._id}"`,
+      { id: document._id, file: document._file },
+      { cause }
+    );
+  }
+};
+const validateVariants = (id, variants, options) => {
+  if (options.validate === false) {
+    return variants;
+  }
+  try {
+    return variants.map((variant) => {
+      const outcome = validateCollectionDocument(variant, options.pathMeta?.collections);
+      if (!outcome.ok) {
+        throw outcome.error;
+      }
+      return outcome.value;
+    });
+  } catch (cause) {
+    if (cause instanceof ContentError) {
+      throw cause;
+    }
+    throw invalidContentError(id, new ContentError(
+      "VALIDATION_FAILED",
+      "Failed to validate parsed content",
+      {
+        files: variants.map((document) => document._file || document._id)
+      },
+      { cause }
+    ));
+  }
+};
+export const parseContentVariants = async (id, content, runtimeContentConfig, opts = {}) => {
+  const nitroApp = useNitroApp();
+  const customTransformers = await loadCustomTransformers();
+  const options = defu(
+    opts,
+    {
+      markdown: runtimeContentConfig.markdown,
+      csv: runtimeContentConfig.csv,
+      yaml: runtimeContentConfig.yaml,
+      transformers: customTransformers,
+      pathMeta: {
+        defaultLocale: runtimeContentConfig.defaultLocale,
+        translatedSlugs: runtimeContentConfig.translatedSlugs,
+        locales: runtimeContentConfig.locales,
+        respectPathCase: runtimeContentConfig.respectPathCase,
+        collections: runtimeContentConfig.collections
+      }
+    }
+  );
+  const file = { _id: id, body: typeof content === "string" ? content.replace(/\r\n|\r/g, "\n") : content };
+  await nitroApp.hooks.callHook("content:file:beforeParse", file);
+  const parsedDocument = await parseSource(id, file.body, options);
+  const variants = validateVariants(id, await expandLocaleVariants(parsedDocument, options), options);
+  const parsed = variants[0];
+  const matchedCollections = resolveCollections(parsed?._file || id, options.pathMeta?.collections, options.pathMeta?.locales || []);
+  if (matchedCollections.length > 1) {
+    throw createContentError(
+      "CONFLICTING_COLLECTION_MATCH",
+      parsed?._file || id,
+      "conflicting collection matches",
+      matchedCollections.join(", "),
+      { collections: matchedCollections }
+    );
+  }
+  if (parsed) {
+    await nitroApp.hooks.callHook("content:file:afterParse", parsed);
+  }
+  return variants;
+};
+export const parseContent = async (id, content, runtimeContentConfig, opts = {}) => {
+  const variants = await parseContentVariants(id, content, runtimeContentConfig, opts);
+  return variants[0];
+};

package/dist/integrations/nitro/preview

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

package/dist/integrations/nitro/preview.d.ts

@@ -0,0 +1,5 @@
+import type { H3Event } from 'h3';
+export declare const isPreview: (event: H3Event) => boolean;
+export declare const getPreview: (event: H3Event) => {
+    key: string;
+};

package/dist/integrations/nitro/preview.js

@@ -0,0 +1,21 @@
+import { getCookie, getHeader, getQuery } from "h3";
+import { getContentRuntimeConfig } from "./runtime-config.js";
+const getIncomingPreviewToken = (event) => {
+  const queryToken = getQuery(event).previewToken;
+  if (typeof queryToken === "string") {
+    return queryToken;
+  }
+  return getHeader(event, "x-nuxt-content-preview") || getCookie(event, "previewToken");
+};
+const getConfiguredPreviewToken = () => {
+  const preview = getContentRuntimeConfig().content?.preview;
+  return preview && preview !== false && typeof preview.token === "string" && preview.token.length ? preview.token : void 0;
+};
+export const isPreview = (event) => {
+  const configuredToken = getConfiguredPreviewToken();
+  return Boolean(configuredToken && getIncomingPreviewToken(event) === configuredToken);
+};
+export const getPreview = (event) => {
+  const key = isPreview(event) ? getIncomingPreviewToken(event) : "";
+  return { key };
+};

package/dist/integrations/nitro/runtime-config

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

package/dist/integrations/nitro/runtime-config.d.ts

@@ -0,0 +1 @@
+export declare function getContentRuntimeConfig(): import("nitropack/types").NitroRuntimeConfig;

package/dist/integrations/nitro/runtime-config.js

@@ -0,0 +1,4 @@
+import { useRuntimeConfig } from "nitropack/runtime";
+export function getContentRuntimeConfig() {
+  return useRuntimeConfig();
+}

package/dist/integrations/nitro/storage

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

package/dist/integrations/nitro/storage.d.ts

@@ -0,0 +1,9 @@
+import { type Storage } from 'unstorage';
+import type { H3Event } from 'h3';
+export declare const sourceStorage: (event?: H3Event) => Storage<import("unstorage").StorageValue>;
+export declare const cacheStorage: (event?: H3Event) => Storage<import("unstorage").StorageValue>;
+export declare const cacheParsedStorage: (event?: H3Event) => Storage<import("unstorage").StorageValue>;
+export declare const contentConfig: () => any;
+export declare const contentIgnorePredicate: (key: string) => boolean;
+export declare const getContentsIds: (event: H3Event, prefix?: string) => Promise<string[]>;
+export declare const resolveStorageId: (event: H3Event, id: string) => Promise<string>;