@lupinum/ginko-content 0.1.0

package/dist/runtime/server/query-api.js

@@ -0,0 +1,54 @@
+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 { getContentProvider } from "./providers/index.js";
+import { createContentProviderError } from "../../public/provider-errors";
+import { getContentRuntimeConfig } from "./runtime-config.js";
+export const createServerContentQueryContext = async (event) => {
+  const provider = await getContentProvider(event);
+  return {
+    runtime: getContentRuntimeConfig().content,
+    transport: async (endpoint, params) => {
+      if (endpoint === "navigation") {
+        if (!provider.navigationQuery) {
+          throw createContentProviderError("unsupported_provider_operation", `${provider.name} does not support navigation queries`, {
+            provider: provider.name
+          });
+        }
+        return await provider.navigationQuery(event, params);
+      }
+      return await provider.query(event, params);
+    }
+  };
+};
+export async function resolveOne(event, handle, options) {
+  return await resolveOneWithContext(await createServerContentQueryContext(event), handle, options);
+}
+export async function one(event, handle, options) {
+  return await oneWithContext(await createServerContentQueryContext(event), handle, options);
+}
+export async function many(event, handle, options = {}) {
+  return await manyWithContext(await createServerContentQueryContext(event), handle, options);
+}
+export async function paginate(event, handle, options) {
+  return await paginateWithContext(await createServerContentQueryContext(event), handle, options);
+}
+export async function backlinks(event, handle, options) {
+  return await backlinksWithContext(await createServerContentQueryContext(event), handle, options);
+}
+export async function variants(event, handle, options) {
+  return await variantsWithContext(await createServerContentQueryContext(event), handle, options);
+}
+export async function tree(event, handle, options = {}) {
+  return await treeWithContext(await createServerContentQueryContext(event), handle, options);
+}
+export async function neighbors(event, handle, options) {
+  return await neighborsWithContext(await createServerContentQueryContext(event), handle, options);
+}

package/dist/runtime/server/query-executor

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

package/dist/runtime/server/query-executor.d.ts

@@ -0,0 +1,4 @@
+import { type H3Event } from 'h3';
+import type { ContentQueryBuilderParams } from '../../types/query';
+export declare const executeFilesystemContentQuery: <T = unknown>(event: H3Event, inputQuery: ContentQueryBuilderParams) => Promise<T | T[]>;
+export declare const executeContentQuery: <T = unknown>(event: H3Event, inputQuery: ContentQueryBuilderParams) => Promise<T | T[]>;

package/dist/runtime/server/query-executor.js

@@ -0,0 +1,121 @@
+import { createError } from "h3";
+import { lowerQueryPlan } from "../../core/query/lower";
+import { executeQueryPlan } from "../../core/query/execute";
+import { ContentError } from "../../core/errors";
+import { normalizeContentQueryParams } from "../../core/query/params";
+import { compileWhere } from "../../core/query/filter";
+import { containsStandaloneRegexOptions, findUnsupportedQueryOperator } from "../../core/query/operators";
+import { withResolvedRefs, withResolvedRefsList } from "../../storage/references";
+import { getContentGraph } from "../../storage/graph";
+import { getContentRuntimeConfig } from "./runtime-config.js";
+import { isPreview } from "../../integrations/nitro/preview";
+import { createContentProviderError } from "../../public/provider-errors";
+import { MAX_PUBLIC_QUERY_LIMIT, MAX_PUBLIC_QUERY_SKIP } from "../query/public-limits.js";
+const notFound = (query, description = "Could not find document for the given query.") => {
+  throw createError({
+    statusMessage: "Document not found!",
+    statusCode: 404,
+    data: {
+      description,
+      query
+    }
+  });
+};
+const statusForContentError = {
+  INVALID_REF_VALUE: 422
+};
+const toHttpError = (error, query) => createError({
+  statusCode: statusForContentError[error.code] ?? 500,
+  statusMessage: error.code,
+  message: error.message,
+  data: { code: error.code, context: error.context, query }
+});
+const badQuery = (message) => {
+  throw createError({
+    statusCode: 400,
+    statusMessage: "Invalid content query",
+    message
+  });
+};
+const containsPublicRegex = (value) => {
+  if (value instanceof RegExp) {
+    return true;
+  }
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    return value.some(containsPublicRegex);
+  }
+  const record = value;
+  return Object.entries(record).some(([key, child]) => key === "$regex" || containsPublicRegex(child));
+};
+const normalizePublicQuery = (event, query, config) => {
+  if (!query.collection) {
+    badQuery("Public content queries must target a collection.");
+  }
+  if (containsPublicRegex(query.where)) {
+    badQuery("Public content queries do not accept RegExp filters.");
+  }
+  if (containsStandaloneRegexOptions(query.where)) {
+    badQuery("Query operator $options requires $regex.");
+  }
+  const enforceProductionVisibility = !import.meta.dev && !isPreview(event);
+  const normalized = normalizeContentQueryParams({
+    ...query,
+    limit: typeof query.limit === "number" ? Math.max(0, Math.min(query.limit, MAX_PUBLIC_QUERY_LIMIT)) : query.limit,
+    skip: typeof query.skip === "number" ? Math.max(0, Math.min(query.skip, MAX_PUBLIC_QUERY_SKIP)) : query.skip
+  }, {
+    collectionI18n: query.collection ? config.collections?.[query.collection]?.i18n : void 0,
+    defaultLocale: config.defaultLocale,
+    localeFallback: config.localeFallback,
+    includeDraftFilter: false
+  });
+  if (enforceProductionVisibility) {
+    normalized.where = [
+      ...normalized.where || [],
+      { _draft: { $ne: true } },
+      { _partial: { $ne: true } }
+    ];
+  }
+  normalized.where = (normalized.where || []).map((condition) => compileWhere(condition)).filter((condition) => Boolean(condition));
+  const unsupported = findUnsupportedQueryOperator(normalized.where);
+  if (unsupported) {
+    throw createContentProviderError("unsupported_query_operator", `Unsupported query operator: ${unsupported}`, {
+      operator: unsupported
+    });
+  }
+  return normalized;
+};
+export const executeFilesystemContentQuery = async (event, inputQuery) => {
+  const config = getContentRuntimeConfig().content || {};
+  const query = normalizePublicQuery(event, inputQuery, config);
+  let graph;
+  try {
+    graph = await getContentGraph(event);
+  } catch (cause) {
+    if (cause instanceof ContentError) {
+      throw toHttpError(cause, query);
+    }
+    throw cause;
+  }
+  const plan = lowerQueryPlan(query);
+  const response = executeQueryPlan(graph, plan, {
+    defaultLocale: config.defaultLocale,
+    localeFallback: config.localeFallback,
+    collections: config.collections
+  });
+  if (plan.mode === "count") {
+    return response.result;
+  }
+  const requestedLocale = plan.resolveVariant?.locale || plan.resolveLocale?.locale;
+  if (plan.mode === "first") {
+    const content = response.result;
+    if (!content) {
+      notFound(query, plan.resolveVariant ? "Could not find document for the given route variant." : void 0);
+    }
+    return await withResolvedRefs(event, content, requestedLocale);
+  }
+  return await withResolvedRefsList(event, Array.isArray(response.result) ? response.result : [], requestedLocale);
+};
+export const executeContentQuery = executeFilesystemContentQuery;

package/dist/runtime/server/runtime-config

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

package/dist/runtime/server/runtime-config.d.ts

@@ -0,0 +1 @@
+export { getContentRuntimeConfig } from '../../integrations/nitro/runtime-config';

package/dist/runtime/server/runtime-config.js

@@ -0,0 +1 @@
+export { getContentRuntimeConfig } from "../../integrations/nitro/runtime-config";

package/dist/runtime/server/search

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

package/dist/runtime/server/search.d.ts

@@ -0,0 +1,18 @@
+import type { H3Event } from 'h3';
+import type { ParsedContent } from '../../types/content';
+import type { ContentQueryBuilderWhere } from '../../types/query';
+import type { ContentSearchIndexRecord } from '../../types/search';
+export { searchRecords } from '../shared/search';
+type SearchablePage = Pick<ParsedContent, '_path' | '_locale' | 'title' | 'description' | 'body'> & Record<string, unknown>;
+export declare const clearSearchRecordsCache: () => void;
+export declare function serverSearchContent(event: H3Event, filterQuery?: ContentQueryBuilderWhere, locale?: string, collectionsOverride?: string[], opts?: {
+    allLocales?: boolean;
+}): Promise<SearchablePage[]>;
+export declare function buildSearchIndex(event: H3Event, opts?: {
+    collections?: string[];
+    ignoredTags?: string[];
+    extraFields?: string[];
+    filterQuery?: ContentQueryBuilderWhere;
+    locale?: string;
+    allLocales?: boolean;
+}): Promise<ContentSearchIndexRecord[]>;

package/dist/runtime/server/search.js

@@ -0,0 +1,134 @@
+import { useRuntimeConfig } from "nitropack/runtime";
+import { resolveCollectionI18n } from "../../features/localization/path";
+import { getContentProvider } from "./providers/index.js";
+import { serverQueryCollection } from "./provider-query.js";
+import { createContentProviderError } from "../../public/provider-errors";
+export { searchRecords } from "../shared/search.js";
+const unique = (values) => Array.from(new Set(values.filter(Boolean)));
+const searchRecordsCache = /* @__PURE__ */ new Map();
+const MAX_SEARCH_RECORDS_CACHE_ENTRIES = 12;
+export const clearSearchRecordsCache = () => {
+  searchRecordsCache.clear();
+};
+const rememberSearchRecords = (cacheKey, records) => {
+  if (searchRecordsCache.has(cacheKey)) {
+    searchRecordsCache.delete(cacheKey);
+  }
+  searchRecordsCache.set(cacheKey, records);
+  while (searchRecordsCache.size > MAX_SEARCH_RECORDS_CACHE_ENTRIES) {
+    const oldest = searchRecordsCache.keys().next().value;
+    if (typeof oldest !== "string") {
+      break;
+    }
+    searchRecordsCache.delete(oldest);
+  }
+};
+const mergeSearchFilter = (filterQuery, locale) => {
+  const localeFilter = locale ? { _locale: locale } : void 0;
+  if (filterQuery && localeFilter) {
+    return { $and: [filterQuery, localeFilter] };
+  }
+  return filterQuery || localeFilter;
+};
+export async function serverSearchContent(event, filterQuery, locale, collectionsOverride, opts = {}) {
+  const runtimeConfig = useRuntimeConfig(event);
+  const configuredCollections = collectionsOverride || runtimeConfig.content.search?.collections;
+  const contentCollections = Object.keys(runtimeConfig.content.collections || {});
+  const collections = (configuredCollections?.length ? configuredCollections : contentCollections).filter(Boolean);
+  const results = await Promise.all(collections.map(async (collection) => {
+    const loadPages = async (queryLocale) => {
+      const query = serverQueryCollection(event, collection).select("_path", "_locale", "title", "description", "body");
+      const mergedFilter = mergeSearchFilter(filterQuery, queryLocale);
+      if (mergedFilter) {
+        return await query.where(mergedFilter).find();
+      }
+      return await query.find();
+    };
+    if (locale) {
+      return await loadPages(locale);
+    }
+    const collectionI18n = opts.allLocales ? resolveCollectionI18n(collection, runtimeConfig.content) : void 0;
+    if (opts.allLocales && collectionI18n?.locales.length) {
+      const localizedResults = await Promise.all(collectionI18n.locales.map(async (collectionLocale) => await loadPages(collectionLocale)));
+      return localizedResults.flat();
+    }
+    return await loadPages();
+  }));
+  return results.flat();
+}
+const toSearchRecord = (section) => {
+  const [path = "", anchor = ""] = section.id.split("#");
+  const extraFields = Object.fromEntries(
+    Object.entries(section).filter(([key]) => !["id", "title", "titles", "content", "level"].includes(key))
+  );
+  return {
+    ...extraFields,
+    id: section.id,
+    path,
+    title: section.title,
+    excerpt: section.content.slice(0, 240),
+    content: section.content,
+    headings: section.titles,
+    anchor: anchor || void 0,
+    locale: typeof section._locale === "string" ? section._locale : void 0
+  };
+};
+const buildProviderSearchSections = async (event, collections, provider, opts) => {
+  const runtimeConfig = useRuntimeConfig(event);
+  const sections = await Promise.all(collections.map(async (collection) => {
+    const loadCollectionLocale = async (locale) => await provider.searchSections(event, collection, {
+      ignoredTags: opts.ignoredTags || [],
+      extraFields: unique(["_locale", ...opts.extraFields || []]),
+      filterQuery: opts.filterQuery,
+      locale
+    });
+    if (opts.locale) {
+      return await loadCollectionLocale(opts.locale);
+    }
+    const collectionI18n = opts.allLocales ? resolveCollectionI18n(collection, runtimeConfig.content) : void 0;
+    if (opts.allLocales && collectionI18n?.locales.length) {
+      const localizedSections = await Promise.all(collectionI18n.locales.map((locale) => loadCollectionLocale(locale)));
+      return localizedSections.flat();
+    }
+    return await loadCollectionLocale();
+  }));
+  return sections.flat();
+};
+export async function buildSearchIndex(event, opts = {}) {
+  const runtimeConfig = useRuntimeConfig(event);
+  const provider = await getContentProvider(event);
+  const cacheKey = JSON.stringify({
+    provider: provider.name,
+    integrity: runtimeConfig.content.cacheIntegrity || runtimeConfig.public.content?.integrity,
+    collections: opts.collections || runtimeConfig.content.search?.collections,
+    ignoredTags: opts.ignoredTags || [],
+    extraFields: opts.extraFields || runtimeConfig.content.search?.extraFields || [],
+    filterQuery: opts.filterQuery,
+    locale: opts.locale,
+    allLocales: opts.allLocales
+  });
+  const cached = searchRecordsCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  const collections = (opts.collections || runtimeConfig.content.search?.collections || Object.keys(runtimeConfig.content.collections || {})).filter(Boolean);
+  if (!provider.capabilities.searchSections) {
+    throw createContentProviderError("unsupported_provider_search_index", `${provider.name} does not support search index generation`, {
+      provider: provider.name
+    });
+  }
+  if (!provider.searchSections) {
+    throw createContentProviderError("unsupported_provider_search_index", `${provider.name} does not support search section generation`, {
+      provider: provider.name
+    });
+  }
+  const records = (await buildProviderSearchSections(event, collections, provider, {
+    ignoredTags: opts.ignoredTags,
+    extraFields: opts.extraFields || runtimeConfig.content.search?.extraFields || [],
+    filterQuery: opts.filterQuery,
+    locale: opts.locale,
+    allLocales: opts.allLocales
+  })).map(toSearchRecord);
+  rememberSearchRecords(cacheKey, records);
+  return records;
+}

package/dist/runtime/server/sitemap

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

package/dist/runtime/server/sitemap-provider

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

package/dist/runtime/server/sitemap-provider.d.ts

@@ -0,0 +1,10 @@
+import type { H3Event } from 'h3';
+import type { ContentSitemapEntry } from '../../types/query';
+import type { QueryCollectionsSitemapEntriesOptions } from './sitemap';
+/**
+ * Generate sitemap entries for one or more content collections.
+ *
+ * Entries include locale alternatives when i18n metadata is available and
+ * attempt to collect images from page metadata and markdown bodies.
+ */
+export declare function queryCollectionsSitemapEntries(event: H3Event, options?: QueryCollectionsSitemapEntriesOptions): Promise<ContentSitemapEntry[]>;

package/dist/runtime/server/sitemap-provider.js

@@ -0,0 +1,11 @@
+import { createContentProviderError } from "../../public/provider-errors";
+export async function queryCollectionsSitemapEntries(event, options = {}) {
+  const { getContentProvider } = await import("./providers/index.js");
+  const provider = await getContentProvider(event);
+  if (!provider.sitemapEntries) {
+    throw createContentProviderError("unsupported_provider_operation", `${provider.name} does not support sitemap entries`, {
+      provider: provider.name
+    });
+  }
+  return await provider.sitemapEntries(event, options);
+}

package/dist/runtime/server/sitemap.d.ts

@@ -0,0 +1,6 @@
+import type { H3Event } from 'h3';
+import type { ContentSitemapEntry } from '../../types/query';
+import { type QueryCollectionsSitemapEntriesOptions } from '../../features/sitemap/query';
+export type { QueryCollectionsSitemapEntriesOptions };
+export declare function queryFilesystemCollectionsSitemapEntries(event: H3Event, options?: QueryCollectionsSitemapEntriesOptions): Promise<ContentSitemapEntry[]>;
+export declare const queryCollectionsSitemapEntries: typeof queryFilesystemCollectionsSitemapEntries;

package/dist/runtime/server/sitemap.js

@@ -0,0 +1,45 @@
+import { getRequestURL } from "h3";
+import { useRuntimeConfig } from "nitropack/runtime";
+import { queryCollectionsSitemapEntriesData } from "../../features/sitemap/query";
+import { queryFilesystemCollectionPage, queryFilesystemCollectionRouteMeta } from "./collection-helpers.js";
+import { serverQueryCollection } from "./storage.js";
+import { contentConfig } from "./storage-access.js";
+import { resolveCollectionI18n } from "../../features/localization/path";
+const sitemapPageFields = [
+  "_path",
+  "_file",
+  "_locale",
+  "_draft",
+  "_canonicalKey",
+  "sitemap",
+  "image",
+  "seo",
+  "ogImage"
+];
+export async function queryFilesystemCollectionsSitemapEntries(event, options = {}) {
+  const runtimeConfig = useRuntimeConfig(event);
+  const requestUrl = event?.node?.req ? getRequestURL(event) : null;
+  return await queryCollectionsSitemapEntriesData({
+    collections: contentConfig().collections,
+    defaultLocale: contentConfig().defaultLocale,
+    runtimeSiteUrl: runtimeConfig.public.siteUrl,
+    localeConfigs: runtimeConfig.public.i18n?.locales || [],
+    requestSiteUrl: requestUrl ? `${requestUrl.protocol}//${requestUrl.host}` : void 0
+  }, {
+    loadCollectionPages: async (collection) => {
+      const config = contentConfig();
+      const collectionI18n = resolveCollectionI18n(collection, config);
+      const pages = collectionI18n.locales.length ? (await Promise.all(collectionI18n.locales.map(
+        (locale) => serverQueryCollection(event, collection).locale(locale).select(...sitemapPageFields).all()
+      ))).flat() : await serverQueryCollection(event, collection).select(...sitemapPageFields).all();
+      return pages;
+    },
+    loadRouteMeta: async (collection, path, locale) => {
+      return await queryFilesystemCollectionRouteMeta(event, collection, path, { locale });
+    },
+    loadPage: async (collection, path, locale) => {
+      return await queryFilesystemCollectionPage(event, collection, path, { locale });
+    }
+  }, options);
+}
+export const queryCollectionsSitemapEntries = queryFilesystemCollectionsSitemapEntries;

package/dist/runtime/server/storage

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

package/dist/runtime/server/storage-access

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

package/dist/runtime/server/storage-access.d.ts

@@ -0,0 +1 @@
+export { cacheParsedStorage, cacheStorage, contentConfig, contentIgnorePredicate, getContentsIds, resolveStorageId, sourceStorage } from '../../integrations/nitro/storage';

package/dist/runtime/server/storage-access.js

@@ -0,0 +1,9 @@
+export {
+  cacheParsedStorage,
+  cacheStorage,
+  contentConfig,
+  contentIgnorePredicate,
+  getContentsIds,
+  resolveStorageId,
+  sourceStorage
+} from "../../integrations/nitro/storage";

package/dist/runtime/server/storage.d.ts

@@ -0,0 +1,2 @@
+export * from '../../storage/content';
+export * from '../../storage/contents';

package/dist/runtime/server/storage.js

@@ -0,0 +1,2 @@
+export * from "../../storage/content";
+export * from "../../storage/contents";

package/dist/runtime/server/validation

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

package/dist/runtime/server/validation.d.ts

@@ -0,0 +1 @@
+export { createContentError, getCanonicalContentId, validateCollectionDocument, validateContentGraph } from '../../storage/validation';

package/dist/runtime/server/validation.js

@@ -0,0 +1,6 @@
+export {
+  createContentError,
+  getCanonicalContentId,
+  validateCollectionDocument,
+  validateContentGraph
+} from "../../storage/validation";

package/dist/runtime/shared/search

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

package/dist/runtime/shared/search.d.ts

@@ -0,0 +1,2 @@
+import type { ContentMiniSearchOptions, ContentSearchIndexRecord, ContentSearchResult } from '../../types/search';
+export declare const searchRecords: (records: ContentSearchIndexRecord[], term: string, locale?: string, searchOptions?: Partial<ContentMiniSearchOptions>) => ContentSearchResult[];

package/dist/runtime/shared/search.js

@@ -0,0 +1,89 @@
+import MiniSearch from "minisearch";
+const DEFAULT_SEARCH_OPTIONS = {
+  fields: ["title", "content", "headings"],
+  storeFields: ["path", "title", "excerpt", "anchor", "locale"],
+  boost: {
+    title: 4,
+    headings: 2,
+    content: 1
+  },
+  fuzzy: 0.2,
+  prefix: true
+};
+const REQUIRED_STORE_FIELDS = ["path", "title", "excerpt"];
+const MAX_SEARCH_INDEX_CACHE_ENTRIES = 12;
+const searchIndexCache = /* @__PURE__ */ new Map();
+const resolveSearchOptions = (options = {}) => {
+  const fields = options.fields?.length ? options.fields : DEFAULT_SEARCH_OPTIONS.fields;
+  const storeFields = options.storeFields?.length ? options.storeFields : DEFAULT_SEARCH_OPTIONS.storeFields;
+  return {
+    fields,
+    storeFields: Array.from(/* @__PURE__ */ new Set([...REQUIRED_STORE_FIELDS, ...storeFields])),
+    boost: options.boost && Object.keys(options.boost).length ? options.boost : DEFAULT_SEARCH_OPTIONS.boost,
+    fuzzy: typeof options.fuzzy === "boolean" || typeof options.fuzzy === "number" ? options.fuzzy : DEFAULT_SEARCH_OPTIONS.fuzzy,
+    prefix: typeof options.prefix === "boolean" ? options.prefix : DEFAULT_SEARCH_OPTIONS.prefix
+  };
+};
+const rememberSearchIndex = (cacheKey, index) => {
+  if (searchIndexCache.has(cacheKey)) {
+    searchIndexCache.delete(cacheKey);
+  }
+  searchIndexCache.set(cacheKey, index);
+  while (searchIndexCache.size > MAX_SEARCH_INDEX_CACHE_ENTRIES) {
+    const oldest = searchIndexCache.keys().next().value;
+    if (typeof oldest !== "string") {
+      break;
+    }
+    searchIndexCache.delete(oldest);
+  }
+};
+const createSearchIndex = (options) => {
+  return new MiniSearch({
+    fields: options.fields,
+    storeFields: options.storeFields,
+    searchOptions: {
+      prefix: options.prefix,
+      fuzzy: options.fuzzy,
+      boost: options.boost
+    }
+  });
+};
+const createCacheKey = (records, locale, options) => {
+  return JSON.stringify({
+    locale: locale || "",
+    records: records.map((record) => Object.fromEntries(["id", ...options.fields, ...options.storeFields].map((field) => [field, record[field]]))),
+    fields: options.fields,
+    storeFields: options.storeFields,
+    boost: options.boost,
+    fuzzy: options.fuzzy,
+    prefix: options.prefix
+  });
+};
+export const searchRecords = (records, term, locale, searchOptions) => {
+  if (!term.trim()) {
+    return [];
+  }
+  const options = resolveSearchOptions(searchOptions);
+  const scopedRecords = locale ? records.filter((record) => record.locale === locale) : records;
+  const cacheKey = createCacheKey(scopedRecords, locale, options);
+  let index = searchIndexCache.get(cacheKey);
+  if (!index) {
+    index = createSearchIndex(options);
+    index.addAll(scopedRecords);
+    rememberSearchIndex(cacheKey, index);
+  } else {
+    rememberSearchIndex(cacheKey, index);
+  }
+  return index.search(term).map((result) => {
+    const storedFields = Object.fromEntries(options.storeFields.map((field) => [field, result[field]]));
+    return {
+      ...storedFields,
+      path: typeof result.path === "string" ? result.path : "",
+      title: typeof result.title === "string" ? result.title : "",
+      excerpt: typeof result.excerpt === "string" ? result.excerpt : "",
+      score: result.score,
+      anchor: typeof result.anchor === "string" ? result.anchor : void 0,
+      locale: typeof result.locale === "string" ? result.locale : void 0
+    };
+  });
+};

package/dist/runtime/transformers/component-resolver

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

package/dist/runtime/transformers/component-resolver.d.ts

@@ -0,0 +1,10 @@
+import type { ParsedContent } from '../../types/content';
+export declare function resolveContentComponents(body: ParsedContent['body'], meta: Record<string, string>): Promise<any>;
+export declare function loadComponents(node: ParsedContent['body'] | {
+    type?: string;
+    tag?: string;
+    props?: Record<string, unknown>;
+    children?: Array<ParsedContent['body']>;
+} | null, tags: Record<string, string>): [string, unknown][];
+declare const _default: import("../../types").ContentTransformer;
+export default _default;

package/dist/runtime/transformers/component-resolver.js

@@ -0,0 +1,30 @@
+import { localComponents, localComponentLoaders } from "../utils/content-components.js";
+import { resolveDocumentContentComponents, loadContentComponentEntries } from "../../integrations/vue/content-components";
+import { defineTransformer } from "./utils.js";
+export async function resolveContentComponents(body, meta) {
+  return await resolveDocumentContentComponents(body, {
+    tags: meta,
+    catalog: {
+      localComponents,
+      localComponentLoaders
+    }
+  });
+}
+export function loadComponents(node, tags) {
+  return loadContentComponentEntries(node, tags);
+}
+export default defineTransformer({
+  name: "component-resolver",
+  extensions: [".*"],
+  async transform(content, options = {}) {
+    if (import.meta.server) {
+      return content;
+    }
+    const _components = await resolveContentComponents(content.body, {
+      ...options?.tags || {},
+      ...content._components || {}
+    });
+    content._components = _components;
+    return content;
+  }
+});

package/dist/runtime/transformers/csv/from-csv

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

package/dist/runtime/transformers/csv/from-csv.d.ts

@@ -0,0 +1 @@
+export * from '../../../parsers/from-csv';

package/dist/runtime/transformers/csv/from-csv.js

@@ -0,0 +1 @@
+export * from "../../../parsers/from-csv";

package/dist/runtime/transformers/csv/index

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

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

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

package/dist/runtime/transformers/csv/index.js

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

package/dist/runtime/transformers/define

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

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

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

package/dist/runtime/transformers/define.js

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