@lupinum/ginko-content 0.1.0

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

@@ -0,0 +1,150 @@
+import { computed, onScopeDispose, toValue, watch } from "vue";
+import { useRoute, useRouter, useState } from "#imports";
+import { useRouteBaseName, useSetI18nParams, useSwitchLocalePath } from "./content-i18n.js";
+const CONTENT_ROUTE_META_KEY = "__nuxt_content_route";
+const CONTENT_ROUTE_REGISTRY_KEY = "__nuxt_content_route_registry";
+const CONTENT_ROUTE_STATE_KEY = "nuxt-content-route";
+let contentRouteTokenId = 0;
+const getRouteMetaState = (meta) => meta[CONTENT_ROUTE_META_KEY];
+const getRoutePublisherRegistry = (meta) => meta[CONTENT_ROUTE_REGISTRY_KEY];
+const getActiveRoutePublisher = (meta) => {
+  const registry = getRoutePublisherRegistry(meta);
+  if (!registry) {
+    return void 0;
+  }
+  return Object.values(registry).sort((left, right) => right.order - left.order)[0];
+};
+const syncPublishedContentRoute = (meta, setI18nParams) => {
+  const activePublisher = getActiveRoutePublisher(meta);
+  if (!activePublisher) {
+    Reflect.deleteProperty(meta, CONTENT_ROUTE_META_KEY);
+    Reflect.deleteProperty(meta, CONTENT_ROUTE_REGISTRY_KEY);
+    setI18nParams({});
+    return;
+  }
+  meta[CONTENT_ROUTE_META_KEY] = {
+    token: activePublisher.token,
+    path: activePublisher.path,
+    canonicalPath: activePublisher.canonicalPath,
+    localePaths: activePublisher.localePaths
+  };
+  setI18nParams(activePublisher.localeParams);
+};
+const useActiveContentRouteState = () => useState(CONTENT_ROUTE_STATE_KEY, () => null);
+const normalizeRouteParams = (params) => {
+  return Object.fromEntries(
+    Object.entries(params).filter(([, value]) => value !== void 0)
+  );
+};
+const normalizeContentRoute = (value) => {
+  if (!value) {
+    return null;
+  }
+  const stringPaths = {};
+  for (const [locale, entry] of Object.entries(value.localePaths || {})) {
+    stringPaths[locale] = typeof entry === "string" ? entry : entry.path;
+  }
+  return {
+    path: value.path,
+    canonicalPath: value.canonicalPath,
+    localePaths: stringPaths
+  };
+};
+const normalizeLocalePath = (entry) => typeof entry === "string" ? entry : entry?.path;
+const normalizeRoutePath = (path) => {
+  if (typeof path !== "string") return void 0;
+  const normalized = path.replace(/\/+$/, "");
+  return normalized || "/";
+};
+const contentRouteMatches = (contentRoute, path) => {
+  const normalizedPath = normalizeRoutePath(path);
+  return normalizeRoutePath(contentRoute.path) === normalizedPath || normalizeRoutePath(contentRoute.canonicalPath) === normalizedPath || Object.values(contentRoute.localePaths).some((localePath) => normalizeRoutePath(localePath) === normalizedPath);
+};
+const resolveLocalizedRouteParams = (page, router, route, getRouteBaseName) => {
+  if (!page) {
+    return {};
+  }
+  const baseName = getRouteBaseName(route);
+  return Object.fromEntries(
+    Object.entries(page.localePaths || {}).map(([locale, entry]) => {
+      const path = normalizeLocalePath(entry);
+      if (!path) {
+        return [locale, {}];
+      }
+      const resolvedRoute = router.resolve(path);
+      const resolvedBaseName = getRouteBaseName(resolvedRoute);
+      if (baseName && resolvedBaseName && resolvedBaseName !== baseName) {
+        return [locale, {}];
+      }
+      return [locale, normalizeRouteParams(resolvedRoute.params)];
+    })
+  );
+};
+export function useContentSwitchLocalePath() {
+  const route = useRoute();
+  const switchLocalePath = useSwitchLocalePath();
+  const activeContentRoute = useActiveContentRouteState();
+  return (locale) => {
+    const active = activeContentRoute.value;
+    const contentRoute = active && contentRouteMatches(active, route.path) ? active : getRouteMetaState(route.meta);
+    return contentRoute?.localePaths[locale] || switchLocalePath(locale);
+  };
+}
+export function useContentRoute(value) {
+  const route = useRoute();
+  const router = useRouter();
+  const getRouteBaseName = useRouteBaseName();
+  const setI18nParams = useSetI18nParams();
+  const activeContentRouteState = useActiveContentRouteState();
+  const token = `content-route:${++contentRouteTokenId}`;
+  const order = contentRouteTokenId;
+  const activeContentRoute = computed(() => {
+    const contentRoute = normalizeContentRoute(toValue(value));
+    if (!contentRoute || !contentRouteMatches(contentRoute, route.path)) {
+      return null;
+    }
+    return {
+      ...contentRoute,
+      token
+    };
+  });
+  const localeParams = computed(() => {
+    const contentRoute = toValue(value);
+    const normalizedContentRoute = normalizeContentRoute(contentRoute);
+    if (!normalizedContentRoute || !contentRouteMatches(normalizedContentRoute, route.path)) {
+      return {};
+    }
+    return resolveLocalizedRouteParams(contentRoute, router, route, getRouteBaseName);
+  });
+  watch([activeContentRoute, localeParams], ([contentRoute, params]) => {
+    const meta = router.currentRoute.value.meta;
+    const registry = getRoutePublisherRegistry(meta) || {};
+    if (contentRoute) {
+      registry[token] = {
+        ...contentRoute,
+        localeParams: params,
+        order
+      };
+      meta[CONTENT_ROUTE_REGISTRY_KEY] = registry;
+    } else {
+      Reflect.deleteProperty(registry, token);
+    }
+    syncPublishedContentRoute(meta, setI18nParams);
+    activeContentRouteState.value = getRouteMetaState(meta) ?? null;
+  }, { immediate: true, flush: "sync" });
+  onScopeDispose(() => {
+    const meta = router.currentRoute.value.meta;
+    const registry = getRoutePublisherRegistry(meta);
+    if (registry) {
+      Reflect.deleteProperty(registry, token);
+    }
+    syncPublishedContentRoute(meta, setI18nParams);
+    activeContentRouteState.value = getRouteMetaState(meta) ?? null;
+  });
+  return {
+    switchLocalePath: useContentSwitchLocalePath(),
+    localePaths: computed(() => activeContentRoute.value?.localePaths || {}),
+    canonicalPath: computed(() => activeContentRoute.value?.canonicalPath),
+    path: computed(() => activeContentRoute.value?.path)
+  };
+}

package/dist/runtime/app/composables/runtime

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

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

@@ -0,0 +1,2 @@
+export declare function getContentRuntime(): any;
+export declare function getContentRoute(): any;

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

@@ -0,0 +1,7 @@
+import { useRoute, useRuntimeConfig } from "#imports";
+export function getContentRuntime() {
+  return useRuntimeConfig().public.content;
+}
+export function getContentRoute() {
+  return useRoute();
+}

package/dist/runtime/app/composables/search

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

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

@@ -0,0 +1,58 @@
+import type { ComputedRef, Ref } from 'vue';
+import type { MaybeRefOrGetter } from '#imports';
+import { ref } from '#imports';
+import type { ContentCollectionMap } from '@lupinum/ginko-content';
+import type { ContentNavigationItem } from '../../../types/content';
+import type { ContentSearchSection } from '../../../types/query';
+import type { ContentSearchResult } from '../../../types/search';
+export interface UseContentSearchResultsOptions {
+    locale?: MaybeRefOrGetter<string | undefined>;
+}
+export interface UseContentSearchOptions extends UseContentSearchResultsOptions {
+    /**
+     * Initial search term for the controlled query ref.
+     */
+    initialQuery?: MaybeRefOrGetter<string | undefined>;
+    /**
+     * Maximum number of results exposed by the headless controller.
+     */
+    limit?: MaybeRefOrGetter<number | undefined>;
+}
+export interface UseContentSearchResultsResult {
+    results: ComputedRef<ContentSearchResult[]>;
+    pending: ComputedRef<boolean>;
+    error: ComputedRef<unknown>;
+}
+export interface UseContentSearchResult extends UseContentSearchResultsResult {
+    query: Ref<string>;
+    activeIndex: Ref<number>;
+    activeResult: ComputedRef<ContentSearchResult | null>;
+    hasQuery: ComputedRef<boolean>;
+    hasResults: ComputedRef<boolean>;
+    isEmpty: ComputedRef<boolean>;
+    setQuery: (value: string) => void;
+    setActiveIndex: (index: number) => void;
+    next: () => void;
+    previous: () => void;
+    reset: () => void;
+    select: (index?: number) => ContentSearchResult | null;
+}
+export interface UseContentSearchDataOptions {
+    locale?: MaybeRefOrGetter<string | undefined>;
+}
+export interface UseContentSearchDataResult {
+    files: ComputedRef<ContentSearchSection[]>;
+    searchNavigation: ComputedRef<ContentNavigationItem[]>;
+    /**
+     * Compatibility alias for `searchNavigation`.
+     *
+     * Prefer `searchNavigation` so layout navigation and search navigation are
+     * not confused.
+     */
+    navigation: ComputedRef<ContentNavigationItem[]>;
+    searchTerm: ReturnType<typeof ref<string>>;
+}
+export declare function useContentSearchData<K extends keyof ContentCollectionMap & string>(collection: K, options?: UseContentSearchDataOptions): Promise<UseContentSearchDataResult>;
+export declare function useContentSearchData(collection: string, options?: UseContentSearchDataOptions): Promise<UseContentSearchDataResult>;
+export declare const useContentSearchResults: (search: MaybeRefOrGetter<string>, options?: UseContentSearchResultsOptions) => Promise<UseContentSearchResultsResult>;
+export declare const useContentSearch: (options?: UseContentSearchOptions) => Promise<UseContentSearchResult>;

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

@@ -0,0 +1,321 @@
+import { computed, ref, shallowRef, toValue, useAsyncData, useFetch, useRuntimeConfig, watchEffect } from "#imports";
+import { withBase } from "ufo";
+import { searchRecords } from "../../shared/search.js";
+import { createContentSearchNavigation } from "../../../features/search/navigation";
+import { resolveCollectionSearchSectionsData } from "../../../features/collections/resolve";
+import { resolveCollectionI18n } from "../../../features/localization/path";
+import { many, tree } from "./query-api.js";
+import { resolveActiveLocale } from "./locale.js";
+import { getContentRuntime } from "./runtime.js";
+const defaultSearchConfig = {
+  apiBaseURL: "/api/_content/search",
+  indexURL: "/api/_content/search/index.json",
+  engine: "minisearch",
+  minisearch: {
+    fields: ["title", "content", "headings"],
+    storeFields: ["path", "title", "excerpt", "anchor", "locale"],
+    boost: {
+      title: 4,
+      headings: 2,
+      content: 1
+    },
+    fuzzy: 0.2,
+    prefix: true
+  }
+};
+const disabledSearchError = new Error("Ginko search is disabled. Enable it with `content.search`.");
+const isRecord = (value) => {
+  return value !== null && typeof value === "object";
+};
+const resolveSearchConfig = (runtimeConfig) => {
+  const contentValue = runtimeConfig.public.content;
+  if (!isRecord(contentValue)) {
+    return defaultSearchConfig;
+  }
+  const value = contentValue.search;
+  if (value === false) {
+    return false;
+  }
+  if (!isRecord(value)) {
+    return defaultSearchConfig;
+  }
+  return {
+    apiBaseURL: typeof value.apiBaseURL === "string" ? value.apiBaseURL : defaultSearchConfig.apiBaseURL,
+    indexURL: typeof value.indexURL === "string" ? value.indexURL : defaultSearchConfig.indexURL,
+    engine: value.engine === "pagefind" || value.engine === "cms" ? value.engine : "minisearch",
+    minisearch: resolveMiniSearchRuntimeOptions(value.minisearch)
+  };
+};
+const resolveMiniSearchRuntimeOptions = (value) => {
+  if (!isRecord(value)) {
+    return defaultSearchConfig.minisearch;
+  }
+  const fields = Array.isArray(value.fields) ? value.fields.filter((field) => typeof field === "string" && field.length > 0) : [];
+  const storeFields = Array.isArray(value.storeFields) ? value.storeFields.filter((field) => typeof field === "string" && field.length > 0) : [];
+  const boost = isRecord(value.boost) ? Object.fromEntries(Object.entries(value.boost).filter((entry) => typeof entry[1] === "number" && Number.isFinite(entry[1]))) : {};
+  return {
+    fields: fields.length ? fields : defaultSearchConfig.minisearch.fields,
+    storeFields: storeFields.length ? storeFields : defaultSearchConfig.minisearch.storeFields,
+    boost: Object.keys(boost).length ? boost : defaultSearchConfig.minisearch.boost,
+    fuzzy: typeof value.fuzzy === "boolean" || typeof value.fuzzy === "number" ? value.fuzzy : defaultSearchConfig.minisearch.fuzzy,
+    prefix: typeof value.prefix === "boolean" ? value.prefix : defaultSearchConfig.minisearch.prefix
+  };
+};
+const resolveContentConfig = (runtimeConfig) => {
+  const value = runtimeConfig.public.content;
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  return {
+    locales: Array.isArray(value.locales) ? value.locales.filter((locale) => typeof locale === "string") : void 0,
+    search: value.search === false ? false : isRecord(value.search) ? {
+      apiBaseURL: typeof value.search.apiBaseURL === "string" ? value.search.apiBaseURL : defaultSearchConfig.apiBaseURL,
+      indexURL: typeof value.search.indexURL === "string" ? value.search.indexURL : defaultSearchConfig.indexURL,
+      engine: value.search.engine === "pagefind" || value.search.engine === "cms" ? value.search.engine : "minisearch",
+      minisearch: resolveMiniSearchRuntimeOptions(value.search.minisearch)
+    } : void 0
+  };
+};
+const resolveAppConfig = (runtimeConfig) => {
+  const value = runtimeConfig.app;
+  return value || {};
+};
+const loadSearchSections = async (collection, options) => {
+  const runtime = getContentRuntime();
+  const { locales, defaultLocale } = resolveCollectionI18n(collection, runtime);
+  const locale = toValue(options.locale);
+  return await resolveCollectionSearchSectionsData(collection, runtime, {
+    locale,
+    activeLocale: locale || resolveActiveLocale(locales, defaultLocale),
+    loadPages: async (extraFields) => {
+      return await many(collection, {
+        ...locale ? { locale } : {},
+        select: ["_path", "title", "description", "body", ...extraFields]
+      });
+    }
+  });
+};
+export async function useContentSearchData(collection, options = {}) {
+  const searchTerm = ref("");
+  const locale = computed(() => toValue(options.locale));
+  const payload = await useAsyncData(computed(() => `content-search-data:${collection}:${locale.value || "default"}`), async () => {
+    const locale2 = toValue(options.locale);
+    const [navigation, files2] = await Promise.all([
+      tree(collection, locale2 ? { locale: locale2 } : {}),
+      loadSearchSections(collection, options)
+    ]);
+    return {
+      files: files2,
+      navigation: createContentSearchNavigation(navigation)
+    };
+  }, {
+    watch: [locale]
+  });
+  const files = computed(() => payload.data.value?.files || []);
+  const searchNavigation = computed(() => payload.data.value?.navigation || []);
+  return {
+    files,
+    searchNavigation,
+    navigation: searchNavigation,
+    searchTerm
+  };
+}
+export const useContentSearchResults = async (search, options = {}) => {
+  const runtimeConfig = useRuntimeConfig();
+  const config = resolveSearchConfig(runtimeConfig);
+  const appConfig = resolveAppConfig(runtimeConfig);
+  if (config === false) {
+    return {
+      results: computed(() => []),
+      pending: computed(() => false),
+      error: computed(() => disabledSearchError)
+    };
+  }
+  if (config.engine === "pagefind") {
+    return usePagefindSearch(search, withBase("/pagefind/pagefind.js", appConfig.baseURL || "/"), options);
+  }
+  if (config.engine === "cms") {
+    return await useCmsSearch(search, config.apiBaseURL, options);
+  }
+  return await useMiniSearch(search, config.indexURL, config.minisearch, options);
+};
+export const useContentSearch = async (options = {}) => {
+  const query = ref(String(toValue(options.initialQuery) || ""));
+  const activeIndex = ref(-1);
+  const search = await useContentSearchResults(query, options);
+  const limit = computed(() => {
+    const value = toValue(options.limit);
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : void 0;
+  });
+  const results = computed(() => {
+    const items = search.results.value;
+    return typeof limit.value === "number" ? items.slice(0, limit.value) : items;
+  });
+  const hasQuery = computed(() => query.value.trim().length > 0);
+  const hasResults = computed(() => results.value.length > 0);
+  const isEmpty = computed(() => hasQuery.value && !search.pending.value && !search.error.value && !results.value.length);
+  const activeResult = computed(() => results.value[activeIndex.value] || null);
+  let lastQuery = query.value;
+  const setActiveIndex = (index) => {
+    const lastIndex = results.value.length - 1;
+    if (!Number.isFinite(index)) {
+      activeIndex.value = -1;
+      return;
+    }
+    activeIndex.value = lastIndex < 0 ? -1 : Math.max(-1, Math.min(Math.floor(index), lastIndex));
+  };
+  const setQuery = (value) => {
+    query.value = value;
+    setActiveIndex(-1);
+  };
+  const next = () => setActiveIndex(activeIndex.value + 1);
+  const previous = () => setActiveIndex(activeIndex.value <= -1 ? -1 : activeIndex.value - 1);
+  const reset = () => {
+    query.value = "";
+    activeIndex.value = -1;
+  };
+  const select = (index = activeIndex.value) => results.value[index] || null;
+  watchEffect(() => {
+    const currentQuery = query.value;
+    const resultCount = results.value.length;
+    if (currentQuery !== lastQuery) {
+      lastQuery = currentQuery;
+      activeIndex.value = -1;
+    }
+    if (!Number.isInteger(activeIndex.value) || activeIndex.value < -1) {
+      activeIndex.value = -1;
+      return;
+    }
+    if (!resultCount) {
+      activeIndex.value = -1;
+      return;
+    }
+    if (activeIndex.value >= resultCount) {
+      activeIndex.value = resultCount - 1;
+    }
+  });
+  return {
+    query,
+    results,
+    pending: search.pending,
+    error: search.error,
+    activeIndex,
+    activeResult,
+    hasQuery,
+    hasResults,
+    isEmpty,
+    setQuery,
+    setActiveIndex,
+    next,
+    previous,
+    reset,
+    select
+  };
+};
+const useMiniSearch = async (search, indexURL, minisearch, options) => {
+  const locale = computed(() => toValue(options.locale));
+  const requestUrl = computed(() => locale.value ? `${indexURL}?locale=${encodeURIComponent(locale.value)}` : indexURL);
+  const { data, pending, error } = await useFetch(requestUrl);
+  const results = computed(() => searchRecords(data.value || [], toValue(search), locale.value, minisearch));
+  return {
+    results,
+    pending: computed(() => pending.value),
+    error: computed(() => error.value)
+  };
+};
+const useCmsSearch = async (search, apiBaseURL, options) => {
+  const locale = computed(() => toValue(options.locale));
+  const requestUrl = computed(() => {
+    const params = new URLSearchParams();
+    const term = String(toValue(search) || "");
+    if (term) {
+      params.set("q", term);
+    }
+    if (locale.value) {
+      params.set("locale", locale.value);
+    }
+    const query = params.toString();
+    return query ? `${apiBaseURL}?${query}` : apiBaseURL;
+  });
+  const { data, pending, error } = await useFetch(requestUrl);
+  return {
+    results: computed(() => data.value || []),
+    pending: computed(() => pending.value),
+    error: computed(() => error.value)
+  };
+};
+let pagefindModulePromise = null;
+const loadPagefindModule = (pagefindUrl) => {
+  pagefindModulePromise = pagefindModulePromise || import(
+    /* @vite-ignore */
+    pagefindUrl
+  );
+  return pagefindModulePromise;
+};
+const deriveLocale = (path, locales = []) => {
+  const segments = path.split("/").filter(Boolean);
+  return segments[0] && locales.includes(segments[0]) ? segments[0] : void 0;
+};
+const usePagefindSearch = (search, pagefindUrl, options) => {
+  const runtimeConfig = useRuntimeConfig();
+  const contentConfig = resolveContentConfig(runtimeConfig);
+  const locale = computed(() => toValue(options.locale));
+  const results = ref([]);
+  const pending = ref(false);
+  const error = shallowRef(null);
+  if (contentConfig?.search === false) {
+    return {
+      results: computed(() => []),
+      pending: computed(() => false),
+      error: computed(() => disabledSearchError)
+    };
+  }
+  watchEffect(async (onCleanup) => {
+    const term = toValue(search).trim();
+    let cancelled = false;
+    onCleanup(() => {
+      cancelled = true;
+    });
+    if (!term) {
+      results.value = [];
+      pending.value = false;
+      error.value = null;
+      return;
+    }
+    pending.value = true;
+    error.value = null;
+    try {
+      const pagefind = await loadPagefindModule(pagefindUrl);
+      const response = await pagefind.search(term);
+      const normalized = await Promise.all((response?.results || []).map(async (result) => {
+        const data = await result.data();
+        const [path = "", anchor] = String(data?.url || "").split("#");
+        return {
+          path,
+          title: data?.meta?.title || path,
+          excerpt: data?.excerpt || "",
+          score: result.score,
+          anchor: anchor || void 0,
+          locale: data?.meta?.locale || deriveLocale(path, contentConfig?.locales || [])
+        };
+      }));
+      if (!cancelled) {
+        results.value = locale.value ? normalized.filter((result) => result.locale === locale.value) : normalized;
+      }
+    } catch (err) {
+      if (!cancelled) {
+        error.value = err;
+        results.value = [];
+      }
+    } finally {
+      if (!cancelled) {
+        pending.value = false;
+      }
+    }
+  });
+  return {
+    results: computed(() => results.value),
+    pending: computed(() => pending.value),
+    error: computed(() => error.value)
+  };
+};

package/dist/runtime/app/composables/site-data

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

package/dist/runtime/app/composables/site-data.d.ts

@@ -0,0 +1,12 @@
+import { type ContentApiFetcher } from './utils';
+export interface QuerySiteDataOptions {
+    locale?: string;
+    fetcher?: ContentApiFetcher;
+}
+export interface ContentSiteDataResponse<T = unknown> {
+    key?: string;
+    locale?: string;
+    data?: T | null;
+    updatedAt?: number;
+}
+export declare function querySiteData<T = unknown>(key: string, options?: QuerySiteDataOptions): Promise<ContentSiteDataResponse<T>>;

package/dist/runtime/app/composables/site-data.js

@@ -0,0 +1,12 @@
+import { withQuery } from "ufo";
+import { withContentBase, getContentApiFetcher } from "./utils.js";
+export async function querySiteData(key, options = {}) {
+  const fetcher = getContentApiFetcher(options.fetcher);
+  return await fetcher(withContentBase(withQuery("/site-data", {
+    key,
+    ...options.locale ? { locale: options.locale } : {}
+  })), {
+    method: "GET",
+    responseType: "json"
+  });
+}

package/dist/runtime/app/composables/toc

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

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

@@ -0,0 +1,10 @@
+import type { Ref } from 'vue';
+import type { Toc, TocLink } from '../../../types/content';
+export type { Toc, TocLink };
+export interface ContentTocOptions {
+    depth?: number;
+    title?: string;
+    searchDepth?: number;
+}
+export declare function extractContentToc(content: string, options?: ContentTocOptions): Toc;
+export declare function useContentToc(content: Ref<string | null | undefined>, options?: ContentTocOptions): Ref<TocLink[]>;

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

@@ -0,0 +1,31 @@
+import { computed } from "vue";
+function slugHeading(value) {
+  return value.toLowerCase().replace(/[^\w\s-]/g, "").trim().replace(/\s+/g, "-");
+}
+export function extractContentToc(content, options = {}) {
+  const maxDepth = options.depth ?? 4;
+  const links = [];
+  const headingRegex = /^(#{2,4})\s+(\S.*)$/gm;
+  let match = headingRegex.exec(content);
+  while (match !== null) {
+    const depth = match[1].length;
+    const text = match[2].trim();
+    if (depth <= maxDepth) {
+      links.push({ id: slugHeading(text), text, depth });
+    }
+    match = headingRegex.exec(content);
+  }
+  return {
+    title: options.title ?? "",
+    depth: 2,
+    searchDepth: options.searchDepth ?? maxDepth,
+    links
+  };
+}
+export function useContentToc(content, options = {}) {
+  return computed(() => {
+    const raw = content.value;
+    if (!raw) return [];
+    return extractContentToc(raw, options).links;
+  });
+}

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

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