@cedros/data-react 0.1.6 → 0.1.8

package/README.md

@@ -217,13 +217,18 @@ Tipping:
 Docs templates:
 - `DocsIndexTemplate`
 - `DocArticleTemplate` (GitBook-style left nav + right TOC)
+- both accept `headless` to skip the built-in `SiteLayout`, or `renderLayout={(content) => ...}` to wrap the docs UI in an existing app shell
 
 Content rendering and helpers:
 - `MarkdownContent`
 - `Breadcrumbs`
 - `ContentPagination`
 - `withActiveRouteState`
+- `fetchDocEntry`
 - `buildDocsSidebarSections`
+- `buildDocsTree`
+- `buildHierarchicalDocsSidebarSections`
+- `buildDocsPrevNext`
 - `withActiveDocsSidebar`
 - `prepareBlogIndex`
 - `prepareDocsIndex`
@@ -319,6 +324,8 @@ Docs/blog templates default to `bodyMarkdown`.
 
 This keeps markdown as the safe default and avoids unsafe HTML rendering by default.
 
+Docs search helpers also inspect optional `bodyMarkdown`, `bodyText`, `bodyHtml`, and `searchText` fields on docs entries, so callers can opt into body/full-text matching without changing the query API.
+
 ## Server helpers and API key
 
 `@cedros/data-react/server` provides Next.js data-fetching helpers that call cedros-data directly:

package/dist/docsContract.d.ts

@@ -0,0 +1,56 @@
+export interface DocsTocHeading {
+    id: string;
+    label: string;
+    depth?: 2 | 3 | 4;
+}
+export interface DocsBreadcrumb {
+    label: string;
+    href: string;
+}
+export interface DocsEntryRecord {
+    slug: string;
+    title: string;
+    description?: string;
+    category?: string;
+    tags?: string[];
+    lastUpdated?: string;
+    bodyMarkdown?: string;
+    bodyHtml?: string;
+    bodyText?: string;
+    searchText?: string;
+    status?: string;
+    productSlug?: string;
+    productLabel?: string;
+    productOrder?: number;
+    sectionKey?: string;
+    sectionLabel?: string;
+    sectionOrder?: number;
+    order?: number;
+    readingMinutes?: number;
+    toc?: DocsTocHeading[];
+    breadcrumbs?: DocsBreadcrumb[];
+    editHref?: string;
+    sourcePath?: string;
+    sourceHref?: string;
+    navLabel?: string;
+    navOrder?: number;
+    aliases?: string[];
+    badge?: string;
+}
+export interface DocsNormalizationOptions {
+    aliases?: Record<string, string>;
+    basePath?: string;
+}
+export interface DocsFilterOptions extends DocsNormalizationOptions {
+    productSlug?: string;
+    sectionKey?: string;
+    includeDrafts?: boolean;
+}
+export interface SortDocsEntriesOptions {
+    preserveSourceOrder?: boolean;
+}
+export declare function normalizeDocsSlug(value: string, options?: DocsNormalizationOptions): string;
+export declare function normalizeDocsHref(href: string, options?: DocsNormalizationOptions): string;
+export declare function matchesDocsEntryFilter(entry: DocsEntryRecord, options?: DocsFilterOptions): boolean;
+export declare function compareDocsEntriesByOrder(left: DocsEntryRecord, right: DocsEntryRecord): number;
+export declare function sortDocsEntries<T extends DocsEntryRecord>(entries: T[], options?: SortDocsEntriesOptions): T[];

package/dist/docsContract.js

@@ -0,0 +1,136 @@
+const DEFAULT_DOCS_BASE_PATH = "/docs";
+const ABSOLUTE_URL_PATTERN = /^[a-z][a-z\d+\-.]*:\/\//iu;
+export function normalizeDocsSlug(value, options = {}) {
+    const { pathname } = splitHref(value);
+    const basePath = normalizeBasePath(options.basePath);
+    let relativePath = trimSlashes(pathname);
+    if (!relativePath) {
+        return "";
+    }
+    const normalizedBase = trimSlashes(basePath);
+    if (normalizedBase) {
+        if (relativePath === normalizedBase) {
+            relativePath = "";
+        }
+        else if (relativePath.startsWith(`${normalizedBase}/`)) {
+            relativePath = relativePath.slice(normalizedBase.length + 1);
+        }
+    }
+    const segments = relativePath
+        .split("/")
+        .filter(Boolean)
+        .map(slugifySegment);
+    if (segments.length === 0) {
+        return "";
+    }
+    const aliasMap = normalizeAliasMap(options.aliases);
+    if (segments[0] && aliasMap[segments[0]]) {
+        segments[0] = aliasMap[segments[0]];
+    }
+    return segments.join("/");
+}
+export function normalizeDocsHref(href, options = {}) {
+    const { origin, suffix } = splitHref(href);
+    const slug = normalizeDocsSlug(href, options);
+    const basePath = normalizeBasePath(options.basePath);
+    const path = slug ? `${basePath}/${slug}`.replace(/\/+/gu, "/") : basePath;
+    if (origin) {
+        return `${origin}${path}${suffix}`;
+    }
+    return `${path}${suffix}`;
+}
+export function matchesDocsEntryFilter(entry, options = {}) {
+    if (!options.includeDrafts && entry.status?.trim().toLowerCase() === "draft") {
+        return false;
+    }
+    if (options.productSlug) {
+        const entryProduct = normalizeDocsSlug(entry.productSlug ?? "", options);
+        const expectedProduct = normalizeDocsSlug(options.productSlug, options);
+        if (!entryProduct || entryProduct !== expectedProduct) {
+            return false;
+        }
+    }
+    if (options.sectionKey) {
+        const entrySection = normalizeFragment(entry.sectionKey);
+        const expectedSection = normalizeFragment(options.sectionKey);
+        if (!entrySection || entrySection !== expectedSection) {
+            return false;
+        }
+    }
+    return true;
+}
+export function compareDocsEntriesByOrder(left, right) {
+    return (compareOptionalNumber(left.productOrder, right.productOrder) ||
+        compareOptionalText(left.productSlug, right.productSlug) ||
+        compareOptionalNumber(left.sectionOrder, right.sectionOrder) ||
+        compareOptionalText(left.sectionKey, right.sectionKey) ||
+        compareOptionalNumber(left.order, right.order) ||
+        compareOptionalNumber(left.navOrder, right.navOrder));
+}
+export function sortDocsEntries(entries, options = {}) {
+    const preserveSourceOrder = options.preserveSourceOrder !== false;
+    return entries
+        .map((entry, index) => ({ entry, index }))
+        .sort((left, right) => {
+        const byOrder = compareDocsEntriesByOrder(left.entry, right.entry);
+        if (byOrder !== 0) {
+            return byOrder;
+        }
+        if (preserveSourceOrder) {
+            return left.index - right.index;
+        }
+        return (compareOptionalText(left.entry.navLabel ?? left.entry.title, right.entry.navLabel ?? right.entry.title) ||
+            compareOptionalText(left.entry.slug, right.entry.slug) ||
+            left.index - right.index);
+    })
+        .map(({ entry }) => entry);
+}
+function splitHref(value) {
+    const [withoutHash, hash = ""] = value.split("#", 2);
+    const [withoutQuery, query = ""] = withoutHash.split("?", 2);
+    const suffix = `${query ? `?${query}` : ""}${hash ? `#${hash}` : ""}`;
+    if (ABSOLUTE_URL_PATTERN.test(withoutQuery)) {
+        const url = new URL(withoutQuery);
+        return {
+            origin: url.origin,
+            pathname: url.pathname,
+            suffix,
+        };
+    }
+    return {
+        origin: "",
+        pathname: withoutQuery,
+        suffix,
+    };
+}
+function normalizeBasePath(basePath = DEFAULT_DOCS_BASE_PATH) {
+    const trimmed = `/${trimSlashes(basePath)}`;
+    return trimmed === "/" ? DEFAULT_DOCS_BASE_PATH : trimmed;
+}
+function normalizeAliasMap(aliases) {
+    if (!aliases) {
+        return {};
+    }
+    return Object.fromEntries(Object.entries(aliases)
+        .map(([from, to]) => [slugifySegment(from), slugifySegment(to)])
+        .filter(([from, to]) => from && to));
+}
+function trimSlashes(value) {
+    return value.trim().replace(/^\/+|\/+$/gu, "");
+}
+function slugifySegment(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/gu, "-")
+        .replace(/^-+|-+$/gu, "");
+}
+function normalizeFragment(value) {
+    return slugifySegment(value ?? "");
+}
+function compareOptionalNumber(left, right) {
+    return (left ?? Number.MAX_SAFE_INTEGER) - (right ?? Number.MAX_SAFE_INTEGER);
+}
+function compareOptionalText(left, right) {
+    return (left ?? "").localeCompare(right ?? "");
+}

package/dist/react/contentCollections.d.ts

@@ -0,0 +1,4 @@
+import type { ContentType } from "./types.js";
+export declare function collectionNameForContentType(contentType: ContentType): string;
+export declare function collectionNamesForContentType(contentType: ContentType): string[];
+export declare function queryEntriesByContentType<T>(serverUrl: string, contentType: ContentType, buildBody: (collectionName: string) => Record<string, unknown>, apiKey?: string): Promise<T>;

package/dist/react/contentCollections.js

@@ -0,0 +1,48 @@
+import { fetchJson } from "./fetch.js";
+const CANONICAL_CONTENT_TYPE_COLLECTIONS = {
+    page: "pages",
+    blog: "blog",
+    docs: "docs",
+    learn: "learn",
+    project: "projects",
+    airdrop: "airdrops",
+};
+const CONTENT_TYPE_COLLECTION_ALIASES = {
+    blog: ["blogs"],
+    learn: ["courses"],
+};
+export function collectionNameForContentType(contentType) {
+    return CANONICAL_CONTENT_TYPE_COLLECTIONS[contentType];
+}
+export function collectionNamesForContentType(contentType) {
+    const canonicalName = collectionNameForContentType(contentType);
+    const aliases = CONTENT_TYPE_COLLECTION_ALIASES[contentType] ?? [];
+    return [canonicalName, ...aliases.filter((alias) => alias !== canonicalName)];
+}
+export async function queryEntriesByContentType(serverUrl, contentType, buildBody, apiKey) {
+    return queryEntriesByCollectionNames(serverUrl, collectionNamesForContentType(contentType), buildBody, apiKey);
+}
+async function queryEntriesByCollectionNames(serverUrl, collectionNames, buildBody, apiKey) {
+    let lastCollectionNotFoundError;
+    const lastCollectionName = collectionNames[collectionNames.length - 1];
+    for (const collectionName of collectionNames) {
+        try {
+            return await fetchJson(serverUrl, "/entries/query", {
+                method: "POST",
+                body: buildBody(collectionName),
+                apiKey,
+            });
+        }
+        catch (error) {
+            if (!isCollectionNotFoundError(error) || collectionName === lastCollectionName) {
+                throw error;
+            }
+            lastCollectionNotFoundError = error;
+        }
+    }
+    throw (lastCollectionNotFoundError ??
+        new Error("@cedros/data-react: no collection names were configured"));
+}
+function isCollectionNotFoundError(error) {
+    return error instanceof Error && /collection not found/i.test(error.message);
+}

package/dist/react/docs.d.ts

@@ -0,0 +1,14 @@
+import { type DocsEntryRecord } from "../docsContract.js";
+import type { DocsFetchOptions } from "./types.js";
+/**
+ * Loads the normalized docs corpus from cedros-data and applies product/section filters.
+ *
+ * Returns docs in package ordering, excluding drafts unless `includeDrafts` is true.
+ */
+export declare function fetchDocsIndex(options?: DocsFetchOptions): Promise<DocsEntryRecord[]>;
+/**
+ * Resolves a single docs article by canonical slug, current route, or any declared alias.
+ *
+ * Returns `null` when the requested doc does not exist after normalization.
+ */
+export declare function fetchDocsEntry(slugOrPath: string, options?: DocsFetchOptions): Promise<DocsEntryRecord | null>;

package/dist/react/docs.js

@@ -0,0 +1,207 @@
+import { fetchDocEntry as findDocEntry } from "../site-templates/docsNavigation.js";
+import { matchesDocsEntryFilter, normalizeDocsHref, normalizeDocsSlug, sortDocsEntries, } from "../docsContract.js";
+import { resolveApiKey, resolveServerUrl } from "./fetch.js";
+import { fetchJson } from "./fetch.js";
+const DEFAULT_DOCS_COLLECTION = "docs";
+const DOCS_BATCH_SIZE = 1_000;
+/**
+ * Loads the normalized docs corpus from cedros-data and applies product/section filters.
+ *
+ * Returns docs in package ordering, excluding drafts unless `includeDrafts` is true.
+ */
+export async function fetchDocsIndex(options = {}) {
+    const serverUrl = resolveServerUrl(options);
+    const apiKey = resolveApiKey(options);
+    const collectionName = options.collectionName ?? DEFAULT_DOCS_COLLECTION;
+    const records = await fetchAllDocsRecords(serverUrl, collectionName, apiKey);
+    const docs = sortDocsEntries(records
+        .map((record) => normalizeDocsEntry(record, options))
+        .filter((entry) => matchesDocsEntryFilter(entry, options)));
+    const offset = Math.max(0, Math.floor(options.offset ?? 0));
+    const end = options.limit === undefined
+        ? undefined
+        : offset + Math.max(0, Math.floor(options.limit));
+    return docs.slice(offset, end);
+}
+/**
+ * Resolves a single docs article by canonical slug, current route, or any declared alias.
+ *
+ * Returns `null` when the requested doc does not exist after normalization.
+ */
+export async function fetchDocsEntry(slugOrPath, options = {}) {
+    const docs = await fetchDocsIndex({
+        ...options,
+        limit: undefined,
+        offset: undefined,
+    });
+    return findDocEntry(docs, slugOrPath, options) ?? null;
+}
+async function fetchAllDocsRecords(serverUrl, collectionName, apiKey) {
+    const records = [];
+    let offset = 0;
+    for (;;) {
+        const batch = await fetchJson(serverUrl, "/entries/query", {
+            method: "POST",
+            body: {
+                collection_name: collectionName,
+                limit: DOCS_BATCH_SIZE,
+                offset,
+            },
+            apiKey,
+        });
+        records.push(...batch);
+        if (batch.length < DOCS_BATCH_SIZE) {
+            return records;
+        }
+        offset += batch.length;
+    }
+}
+function normalizeDocsEntry(record, options) {
+    const payload = record.payload;
+    const bodyMarkdown = readStringAny(payload, [
+        "bodyMarkdown",
+        "body_markdown",
+        "markdown",
+        "body",
+    ]);
+    const slug = normalizeDocsSlug(readStringAny(payload, ["slug", "routeSlug", "path", "route"]) ??
+        record.entry_key, options) || "index";
+    return {
+        slug,
+        title: readStringAny(payload, ["title", "navTitle"]) ?? humanizeDocsSlug(slug),
+        description: readStringAny(payload, ["description"]) ??
+            inferDescription(bodyMarkdown),
+        category: readStringAny(payload, ["category"]),
+        tags: readStringArray(payload, "tags"),
+        lastUpdated: readStringAny(payload, [
+            "lastUpdated",
+            "updatedAt",
+            "updated_at",
+            "publishedAt",
+        ]) ?? record.updated_at,
+        bodyMarkdown,
+        bodyHtml: readStringAny(payload, ["bodyHtml", "body_html"]),
+        bodyText: readStringAny(payload, ["bodyText", "body_text"]),
+        searchText: readStringAny(payload, ["searchText", "search_text"]),
+        status: readStringAny(payload, ["status"]),
+        productSlug: normalizeDocsSlug(readStringAny(payload, ["productSlug", "productKey", "product"]) ?? "", options) || undefined,
+        productLabel: readStringAny(payload, ["productLabel", "productTitle"]),
+        productOrder: readNumberAny(payload, ["productOrder"]),
+        sectionKey: normalizeSectionKey(readStringAny(payload, ["sectionKey", "section", "sidebarSection"])),
+        sectionLabel: readStringAny(payload, [
+            "sectionLabel",
+            "sectionTitle",
+            "section",
+            "sidebarSection",
+            "category",
+        ]),
+        sectionOrder: readNumberAny(payload, ["sectionOrder"]),
+        order: readNumberAny(payload, ["order", "navOrder"]),
+        readingMinutes: readNumberAny(payload, ["readingMinutes"]),
+        toc: readToc(payload),
+        breadcrumbs: readBreadcrumbs(payload, options),
+        editHref: readStringAny(payload, ["editHref", "editUrl", "sourceUrl"]),
+        sourcePath: readStringAny(payload, ["sourcePath"]),
+        sourceHref: readStringAny(payload, ["sourceHref", "sourceUrl"]),
+        navLabel: readStringAny(payload, ["navLabel", "navTitle"]),
+        navOrder: readNumberAny(payload, ["navOrder", "order"]),
+        aliases: readStringArray(payload, "aliases")
+            .map((value) => normalizeDocsSlug(value, options))
+            .filter(Boolean),
+        badge: readStringAny(payload, ["badge"]),
+    };
+}
+function readBreadcrumbs(payload, options) {
+    const raw = payload.breadcrumbs;
+    if (!Array.isArray(raw)) {
+        return undefined;
+    }
+    const breadcrumbs = raw
+        .map((value) => asObject(value))
+        .filter((entry) => entry !== undefined)
+        .map((entry) => {
+        const label = readStringAny(entry, ["label", "title"]);
+        const href = readStringAny(entry, ["href", "url", "path"]);
+        if (!label || !href) {
+            return undefined;
+        }
+        return {
+            label,
+            href: normalizeDocsHref(href, options),
+        };
+    })
+        .filter((entry) => entry !== undefined);
+    return breadcrumbs.length > 0 ? breadcrumbs : undefined;
+}
+function readToc(payload) {
+    const raw = payload.toc;
+    if (!Array.isArray(raw)) {
+        return undefined;
+    }
+    const headings = raw
+        .map((value) => asObject(value))
+        .filter((entry) => entry !== undefined)
+        .map((entry) => {
+        const id = readString(entry, "id");
+        const label = readString(entry, "label");
+        if (!id || !label) {
+            return undefined;
+        }
+        const depth = readNumber(entry, "depth");
+        const heading = {
+            id,
+            label,
+            depth: depth === 2 || depth === 3 || depth === 4
+                ? depth
+                : undefined,
+        };
+        return heading;
+    })
+        .filter((entry) => entry !== undefined);
+    return headings.length > 0 ? headings : undefined;
+}
+function inferDescription(markdown) {
+    const paragraph = markdown
+        ?.split(/\n{2,}/u)
+        .map((segment) => segment.replace(/^#+\s+/gmu, "").trim())
+        .find((segment) => segment && !segment.startsWith("```"));
+    return paragraph || undefined;
+}
+function humanizeDocsSlug(slug) {
+    const leaf = slug.split("/").pop() ?? slug;
+    return leaf.replace(/[-_]+/gu, " ").replace(/\b\w/gu, (char) => char.toUpperCase());
+}
+function normalizeSectionKey(value) {
+    return value
+        ?.trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/gu, "-")
+        .replace(/^-+|-+$/gu, "") || undefined;
+}
+function asObject(value) {
+    return value !== null && typeof value === "object" ? value : undefined;
+}
+function readString(payload, key) {
+    const value = payload[key];
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function readStringAny(payload, keys) {
+    return keys.map((key) => readString(payload, key)).find(Boolean);
+}
+function readNumber(payload, key) {
+    const value = payload[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function readNumberAny(payload, keys) {
+    return keys.map((key) => readNumber(payload, key)).find((value) => value !== undefined);
+}
+function readStringArray(payload, key) {
+    const value = payload[key];
+    if (typeof value === "string" && value.trim()) {
+        return [value.trim()];
+    }
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
+}

package/dist/react/entries.js

@@ -1,4 +1,5 @@
-import { fetchJson, resolveApiKey, resolveServerUrl } from "./fetch.js";
+import { resolveApiKey, resolveServerUrl } from "./fetch.js";
+import { queryEntriesByContentType } from "./contentCollections.js";
 /**
  * Fetches a single blog post by slug, optionally passing visitor_id for metered reads.
  *
@@ -10,7 +11,6 @@ export async function fetchBlogPost(slug, options) {
     const serverUrl = resolveServerUrl(options);
     const apiKey = resolveApiKey(options);
     const body = {
-        collection_name: "blog",
         entry_keys: [slug],
         limit: 1,
         offset: 0,
@@ -18,10 +18,9 @@ export async function fetchBlogPost(slug, options) {
     if (options?.visitorId) {
         body.visitor_id = options.visitorId;
     }
-    const entries = await fetchJson(serverUrl, "/entries/query", {
-        method: "POST",
-        body,
-        apiKey,
-    });
+    const entries = await queryEntriesByContentType(serverUrl, "blog", (collectionName) => ({
+        ...body,
+        collection_name: collectionName,
+    }), apiKey);
     return entries.length > 0 ? entries[0] : null;
 }

package/dist/react/index.d.ts

@@ -9,4 +9,5 @@ export type { ThemeMode, CedrosDataThemeOverrides, CedrosDataThemeValue, } from
 export { CmsContent, type CmsContentProps } from "./CmsContent.js";
 export { getOrCreateVisitorId } from "./visitor.js";
 export { sanitizeCmsHtml, renderCmsMarkdown } from "./sanitize.js";
-export type { CmsPageRecord, PageMetadataInput, SiteDataRecord, SanitizeOptions, ContentType, MeteredReadsInfo, } from "./types.js";
+export { normalizeDocsHref, normalizeDocsSlug } from "../docsContract.js";
+export type { CmsPageRecord, PageMetadataInput, SiteDataRecord, SanitizeOptions, ContentType, DocsBreadcrumb, DocsEntryRecord, DocsFetchOptions, DocsNormalizationOptions, DocsTocHeading, MeteredReadsInfo, } from "./types.js";

package/dist/react/index.js

@@ -8,3 +8,4 @@ export { CedrosDataProvider, useCedrosDataTheme, useCedrosDataThemeOptional, } f
 export { CmsContent } from "./CmsContent.js";
 export { getOrCreateVisitorId } from "./visitor.js";
 export { sanitizeCmsHtml, renderCmsMarkdown } from "./sanitize.js";
+export { normalizeDocsHref, normalizeDocsSlug } from "../docsContract.js";

package/dist/react/server.d.ts

@@ -8,7 +8,8 @@
  * Do not import this module in client components.
  */
 export { buildPageMetadata, generatePageMetadata, type PageMetadata, } from "./metadata.js";
+export { fetchDocsEntry, fetchDocsIndex } from "./docs.js";
 export { loadSitemapEntries } from "./sitemap.js";
 export { fetchBlogPost } from "./entries.js";
 export { listBlogSlugs, listContentSlugs, listLearnPathIds, } from "./slugs.js";
-export type { BuildPageMetadataOptions, CmsPageRecord, MeteredReadsInfo, PageMetadataInput, SiteDataRecord, SitemapEntry, ServerFetchOptions, ContentType, } from "./types.js";
+export type { BuildPageMetadataOptions, CmsPageRecord, MeteredReadsInfo, PageMetadataInput, SiteDataRecord, SitemapEntry, ServerFetchOptions, DocsBreadcrumb, DocsEntryRecord, DocsFetchOptions, DocsNormalizationOptions, DocsTocHeading, ContentType, } from "./types.js";

package/dist/react/server.js

@@ -8,6 +8,7 @@
  * Do not import this module in client components.
  */
 export { buildPageMetadata, generatePageMetadata, } from "./metadata.js";
+export { fetchDocsEntry, fetchDocsIndex } from "./docs.js";
 export { loadSitemapEntries } from "./sitemap.js";
 export { fetchBlogPost } from "./entries.js";
 export { listBlogSlugs, listContentSlugs, listLearnPathIds, } from "./slugs.js";

package/dist/react/sitemap.js

@@ -1,13 +1,5 @@
-import { fetchJson, resolveApiKey, resolveServerUrl } from "./fetch.js";
-/** Map of content types to their collection names in cedros-data. */
-const CONTENT_TYPE_COLLECTIONS = {
-    page: "pages",
-    blog: "blog",
-    docs: "docs",
-    learn: "learn",
-    project: "projects",
-    airdrop: "airdrops",
-};
+import { resolveApiKey, resolveServerUrl } from "./fetch.js";
+import { queryEntriesByContentType } from "./contentCollections.js";
 /** Default change frequency and priority for each content type. */
 const CONTENT_TYPE_DEFAULTS = {
     page: { changeFrequency: "monthly", priority: 0.8 },
@@ -67,17 +59,12 @@ export async function loadSitemapEntries(options) {
     return entries;
 }
 async function fetchCollectionSlugs(serverUrl, contentType, apiKey) {
-    const collectionName = CONTENT_TYPE_COLLECTIONS[contentType];
     const defaults = CONTENT_TYPE_DEFAULTS[contentType];
-    const records = await fetchJson(serverUrl, "/entries/query", {
-        method: "POST",
-        body: {
-            collection_name: collectionName,
-            limit: 1000,
-            offset: 0,
-        },
-        apiKey,
-    });
+    const records = await queryEntriesByContentType(serverUrl, contentType, (collectionName) => ({
+        collection_name: collectionName,
+        limit: 1000,
+        offset: 0,
+    }), apiKey);
     return records.map((record) => {
         const slug = record.payload.slug ??
             record.payload.route?.replace(/^\//, "") ??

package/dist/react/slugs.js

@@ -1,13 +1,5 @@
-import { fetchJson, resolveApiKey, resolveServerUrl } from "./fetch.js";
-/** Map of content types to their collection names in cedros-data. */
-const CONTENT_TYPE_COLLECTIONS = {
-    page: "pages",
-    blog: "blog",
-    docs: "docs",
-    learn: "learn",
-    project: "projects",
-    airdrop: "airdrops",
-};
+import { resolveApiKey, resolveServerUrl } from "./fetch.js";
+import { queryEntriesByContentType } from "./contentCollections.js";
 /**
  * Returns all slugs for a given content type, for use with
  * Next.js `generateStaticParams`.
@@ -26,16 +18,11 @@ const CONTENT_TYPE_COLLECTIONS = {
 export async function listContentSlugs(contentType, options) {
     const serverUrl = resolveServerUrl(options);
     const apiKey = resolveApiKey(options);
-    const collectionName = CONTENT_TYPE_COLLECTIONS[contentType];
-    const records = await fetchJson(serverUrl, "/entries/query", {
-        method: "POST",
-        body: {
-            collection_name: collectionName,
-            limit: 1000,
-            offset: 0,
-        },
-        apiKey,
-    });
+    const records = await queryEntriesByContentType(serverUrl, contentType, (collectionName) => ({
+        collection_name: collectionName,
+        limit: 1000,
+        offset: 0,
+    }), apiKey);
     return records.map((record) => record.payload.slug ?? record.entry_key);
 }
 /**

package/dist/react/types.d.ts

@@ -1,3 +1,4 @@
+import type { DocsBreadcrumb, DocsEntryRecord, DocsNormalizationOptions, DocsTocHeading } from "../docsContract.js";
 /** Content type identifiers used across cedros-data. */
 export type ContentType = "page" | "blog" | "docs" | "learn" | "project" | "airdrop";
 /**
@@ -97,3 +98,19 @@ export interface ServerFetchOptions {
     /** Visitor ID for metered-reads tracking. Use `getOrCreateVisitorId()` on the client. */
     visitorId?: string;
 }
+/** Options for loading docs entries from the cedros-data backend. */
+export interface DocsFetchOptions extends ServerFetchOptions, DocsNormalizationOptions {
+    /** Override the backend collection. Defaults to "docs". */
+    collectionName?: string;
+    /** Restrict results to a single product slug. */
+    productSlug?: string;
+    /** Restrict results to a single section key. */
+    sectionKey?: string;
+    /** Include draft docs. Defaults to false. */
+    includeDrafts?: boolean;
+    /** Final limit applied after docs are normalized and filtered. */
+    limit?: number;
+    /** Final offset applied after docs are normalized and filtered. */
+    offset?: number;
+}
+export type { DocsBreadcrumb, DocsEntryRecord, DocsNormalizationOptions, DocsTocHeading, };