busabase-cms-sdk 0.1.3

package/dist/integration/index.js

@@ -0,0 +1,268 @@
+import { l as readCmsOrFallback, r as createCmsPathHelpers, s as normalizeCmsPath } from "../routing-C3lkVAZ8.js";
+import { createCachedBusabaseCms } from "../next.js";
+import "server-only";
+import { cache } from "react";
+//#region src/integration/config.ts
+/** Next data-cache `revalidate` used when an app does not override it. */
+const DEFAULT_CMS_REVALIDATE_SECONDS = 300;
+const trimValue = (value) => value?.trim() || null;
+/**
+* Pure `BUSABASE_CMS_*` env-var gate. All three of host/key/space are required: you genuinely
+* cannot talk to a Busabase space without an API key, so a partial configuration is treated as
+* "off" rather than as a guaranteed-failing read on every request.
+*
+* Re-reads the environment on every call — deliberately never memoized, unlike the client.
+*/
+const readCmsEnvConfig = (defaultBaseSlugs, env = process.env) => {
+	const baseUrl = trimValue(env.BUSABASE_CMS_BASE_URL);
+	const apiKey = trimValue(env.BUSABASE_CMS_API_KEY);
+	const spaceId = trimValue(env.BUSABASE_CMS_SPACE_ID);
+	if (!baseUrl || !apiKey || !spaceId) return null;
+	return {
+		baseUrl,
+		apiKey,
+		spaceId,
+		folderId: trimValue(env.BUSABASE_CMS_FOLDER_ID),
+		baseSlugs: {
+			posts: trimValue(env.BUSABASE_CMS_POSTS_BASE_SLUG) ?? defaultBaseSlugs.posts,
+			pages: trimValue(env.BUSABASE_CMS_PAGES_BASE_SLUG) ?? defaultBaseSlugs.pages,
+			categories: trimValue(env.BUSABASE_CMS_CATEGORIES_BASE_SLUG) ?? defaultBaseSlugs.categories,
+			tags: trimValue(env.BUSABASE_CMS_TAGS_BASE_SLUG) ?? defaultBaseSlugs.tags
+		}
+	};
+};
+//#endregion
+//#region src/integration/client.ts
+/**
+* Explicit Next data-cache key prefix. Two reasons it is never left to the SDK's default:
+*
+* 1. App identity — the SDK's own default prefix (see `resolveBusabaseCmsCacheKeyPrefix`) is
+*    derived purely from the CMS target (host / space / folder / profile / Base slugs) and
+*    carries no app identity at all. `cacheNamespace` (unique per app) is the first element
+*    here, so no two apps can ever share an entry even when they read the very same Bases.
+* 2. Re-pointing safety — folder id, schema profile and all four Base slugs are part of the
+*    key, so changing any of them at deploy time starts from a cold cache instead of serving
+*    content read out of a different Base.
+*
+* The API key is deliberately NOT part of the key (it is a secret, and it does not change
+* which records are addressed).
+*/
+const buildCmsCacheKeyPrefix = (config, resolved) => [
+	"busabase-cms-sdk",
+	config.cacheNamespace,
+	resolved.baseUrl,
+	resolved.spaceId,
+	resolved.folderId ?? "no-folder",
+	config.schemaProfile,
+	resolved.baseSlugs.posts,
+	resolved.baseSlugs.pages,
+	resolved.baseSlugs.categories,
+	resolved.baseSlugs.tags
+];
+/** `revalidateTag` targets per collection, defaulting to `<cacheNamespace>:cms-<collection>`. */
+const resolveCmsCacheTags = (config) => ({
+	posts: config.cache?.tags?.posts ?? [`${config.cacheNamespace}:cms-posts`],
+	pages: config.cache?.tags?.pages ?? [`${config.cacheNamespace}:cms-pages`],
+	categories: config.cache?.tags?.categories ?? [`${config.cacheNamespace}:cms-categories`],
+	tags: config.cache?.tags?.tags ?? [`${config.cacheNamespace}:cms-tags`]
+});
+const createCmsClientProvider = (config) => {
+	const getCmsConfig = () => readCmsEnvConfig(config.baseSlugs);
+	/**
+	* When this is false, every `*OrFallback` read skips calling the CMS entirely (see the
+	* `readCmsOrFallback(enabled ? op : null, ...)` calls in posts/pages/taxonomy) — zero network
+	* attempts, identical to pure-local-MDX behavior.
+	*/
+	const isBusabaseCmsEnabled = () => getCmsConfig() !== null;
+	let cachedCms;
+	const getCms = () => {
+		if (cachedCms !== void 0) return cachedCms;
+		const resolved = getCmsConfig();
+		if (!resolved) {
+			cachedCms = null;
+			return cachedCms;
+		}
+		cachedCms = createCachedBusabaseCms({
+			config: {
+				baseUrl: resolved.baseUrl,
+				apiKey: resolved.apiKey,
+				spaceId: resolved.spaceId
+			},
+			folderId: resolved.folderId ?? void 0,
+			lazyCreate: Boolean(resolved.folderId),
+			schemaProfile: config.schemaProfile,
+			baseSlugs: resolved.folderId ? void 0 : resolved.baseSlugs,
+			invalidRecords: config.invalidRecords,
+			onInvalidRecord: config.onInvalidRecord
+		}, {
+			revalidate: config.cache?.revalidate ?? 300,
+			tags: resolveCmsCacheTags(config),
+			keyPrefix: buildCmsCacheKeyPrefix(config, resolved)
+		});
+		return cachedCms;
+	};
+	const requireCms = () => {
+		const cms = getCms();
+		if (!cms) throw new Error(`[busabase-cms] ${config.appLabel}: BUSABASE_CMS_BASE_URL, BUSABASE_CMS_API_KEY and BUSABASE_CMS_SPACE_ID must all be set before reading CMS content`);
+		return cms;
+	};
+	return {
+		getCms,
+		requireCms,
+		getCmsConfig,
+		isBusabaseCmsEnabled
+	};
+};
+//#endregion
+//#region src/integration/pages.ts
+const createCmsPageReads = ({ getCms, requireCms }, appLabel) => ({
+	listBusabaseLandingPages: async () => requireCms().pages.list(),
+	getBusabaseLandingPageByPath: async (path) => requireCms().pages.getByPath(path),
+	listBusabaseLandingPagesOrFallback: async () => {
+		const cms = getCms();
+		return readCmsOrFallback(cms ? () => cms.pages.list() : null, [], `list ${appLabel} landing pages`);
+	},
+	getBusabaseLandingPageByPathOrFallback: async (path) => {
+		const cms = getCms();
+		return readCmsOrFallback(cms ? () => cms.pages.getByPath(path) : null, null, `get ${appLabel} landing page ${path}`);
+	}
+});
+const createCmsPageHelpers = ({ integration, generatePageMetadata }) => {
+	const { buildCmsPath, getBusabaseLandingPageByPathOrFallback, isCmsContentForLocale, parseCmsPath } = integration;
+	const getCmsPageForRequest = async (lang, path) => {
+		const canonicalPath = buildCmsPath(lang, path);
+		if (!canonicalPath) return null;
+		const page = await getBusabaseLandingPageByPathOrFallback(canonicalPath);
+		return page && isCmsContentForLocale(page, lang) ? page : null;
+	};
+	const generateCmsPageMetadata = (page, lang) => {
+		const parsed = parseCmsPath(page.path);
+		if (!parsed || parsed.locale !== lang) return {};
+		return generatePageMetadata({
+			title: page.seoTitle ?? page.title,
+			description: page.seoDescription ?? "",
+			path: parsed.pathWithoutLocale,
+			lang,
+			type: "website"
+		});
+	};
+	return {
+		getCmsPageForRequest,
+		generateCmsPageMetadata
+	};
+};
+//#endregion
+//#region src/integration/posts.ts
+const createCmsPostReads = ({ getCms, requireCms }, appLabel) => ({
+	listBusabaseBlogPosts: async () => requireCms().posts.list(),
+	getBusabaseBlogPostByPath: async (path) => requireCms().posts.getByPath(path),
+	listBusabaseBlogPostsOrFallback: async () => {
+		const cms = getCms();
+		return readCmsOrFallback(cms ? () => cms.posts.list() : null, [], `list ${appLabel} blog posts`);
+	},
+	getBusabaseBlogPostByPathOrFallback: async (path) => {
+		const cms = getCms();
+		return readCmsOrFallback(cms ? () => cms.posts.getByPath(path) : null, null, `get ${appLabel} blog post ${path}`);
+	}
+});
+/**
+* Merge Post card sources in priority order, using canonical paths as identity — the earliest
+* source to claim a path wins. Lets an app render CMS Posts and bundled MDX posts in one grid
+* without a CMS post and its local original showing up twice.
+*/
+const mergeBlogCardsByPath = (...sources) => {
+	const byPath = /* @__PURE__ */ new Map();
+	for (const source of sources) for (const post of source) {
+		const path = normalizeCmsPath(post.url);
+		if (path && !byPath.has(path)) byPath.set(path, {
+			...post,
+			url: path
+		});
+	}
+	return [...byPath.values()].sort((a, b) => new Date(b.date ?? 0).getTime() - new Date(a.date ?? 0).getTime());
+};
+const createCmsPostResolver = ({ integration, localSource }) => {
+	const { buildCmsPath, getBusabaseBlogPostByPathOrFallback, isCmsContentForLocale, parseCmsPath } = integration;
+	const getCachedCmsPost = cache(async (locale, slugPath) => {
+		const path = buildCmsPath(locale, ["blog", ...slugPath.split("/").filter(Boolean)]);
+		const post = path ? await getBusabaseBlogPostByPathOrFallback(path) : null;
+		return post && isCmsContentForLocale(post, locale) ? post : null;
+	});
+	const defaultDependencies = {
+		getCmsPost: (locale, slugs) => getCachedCmsPost(locale, slugs.join("/")),
+		getLocalPost: (locale, slugs) => localSource.getPage(slugs, locale)
+	};
+	const resolveForLocale = async (locale, slugs, dependencies) => {
+		const cmsPost = await dependencies.getCmsPost(locale, slugs);
+		if (cmsPost) return {
+			source: "busabase",
+			content: cmsPost,
+			canonicalPath: parseCmsPath(cmsPost.path)?.pathWithoutLocale ?? `/blog/${slugs.join("/")}`
+		};
+		const localPost = dependencies.getLocalPost(locale, slugs);
+		if (localPost) return {
+			source: "local",
+			content: localPost,
+			canonicalPath: `/blog/${slugs.join("/")}`
+		};
+		return null;
+	};
+	/**
+	* Resolve a Post detail page at the requested locale, falling back to English when the
+	* requested locale has no CMS or local-MDX content at that slug — a post not yet translated
+	* falls back to English rather than 404ing.
+	*/
+	const resolvePostPageWithDependencies = async (requestedLocale, slugPath, dependencies) => {
+		const slugs = slugPath.split("/").filter(Boolean);
+		const requested = await resolveForLocale(requestedLocale, slugs, dependencies);
+		const resolved = requested ?? (requestedLocale === "en" ? null : await resolveForLocale("en", slugs, dependencies));
+		return resolved ? {
+			...resolved,
+			requestedLocale,
+			contentLocale: requested ? requestedLocale : "en",
+			isLocaleFallback: !requested
+		} : null;
+	};
+	const resolvePostPageUncached = (requestedLocale, slugPath) => resolvePostPageWithDependencies(requestedLocale, slugPath, defaultDependencies);
+	return {
+		resolvePostPage: cache(resolvePostPageUncached),
+		resolvePostPageWithDependencies
+	};
+};
+//#endregion
+//#region src/integration/taxonomy.ts
+const createCmsTaxonomyReads = ({ getCms, requireCms }, appLabel) => ({
+	listBusabaseCategories: async () => requireCms().categories.list(),
+	listBusabaseCategoriesOrFallback: async () => {
+		const cms = getCms();
+		return readCmsOrFallback(cms ? () => cms.categories.list() : null, [], `list ${appLabel} categories`);
+	},
+	listBusabaseTags: async () => requireCms().tags.list(),
+	listBusabaseTagsOrFallback: async () => {
+		const cms = getCms();
+		return readCmsOrFallback(cms ? () => cms.tags.list() : null, [], `list ${appLabel} tags`);
+	}
+});
+//#endregion
+//#region src/integration/index.ts
+const createCmsIntegration = (config) => {
+	const cmsPathHelpers = createCmsPathHelpers({
+		supportedLocales: config.supportedLocales,
+		defaultLocale: config.defaultLocale
+	});
+	const provider = createCmsClientProvider(config);
+	return {
+		cmsPathHelpers,
+		buildCmsPath: cmsPathHelpers.buildPath,
+		parseCmsPath: cmsPathHelpers.parsePath,
+		isCmsContentForLocale: cmsPathHelpers.isForLocale,
+		buildCmsTaxonomyArchivePath: cmsPathHelpers.buildTaxonomyArchivePath,
+		isBusabaseCmsEnabled: provider.isBusabaseCmsEnabled,
+		getCmsConfig: provider.getCmsConfig,
+		...createCmsPostReads(provider, config.appLabel),
+		...createCmsPageReads(provider, config.appLabel),
+		...createCmsTaxonomyReads(provider, config.appLabel)
+	};
+};
+//#endregion
+export { DEFAULT_CMS_REVALIDATE_SECONDS, buildCmsCacheKeyPrefix, createCmsClientProvider, createCmsIntegration, createCmsPageHelpers, createCmsPageReads, createCmsPostReads, createCmsPostResolver, createCmsTaxonomyReads, mergeBlogCardsByPath, readCmsEnvConfig, resolveCmsCacheTags };

package/dist/next.d.ts

@@ -0,0 +1,34 @@
+import { m as BusabaseCmsOptions, p as BusabaseCms, r as CmsPathHelpers } from "./routing-VU56uuJ0.js";
+import "server-only";
+import { MetadataRoute } from "next";
+//#region src/next.d.ts
+interface BusabaseCmsCacheOptions {
+  revalidate?: number | false;
+  tags?: {
+    posts?: string[];
+    pages?: string[];
+    categories?: string[];
+    tags?: string[];
+  };
+  keyPrefix?: string[];
+}
+declare const resolveBusabaseCmsCacheKeyPrefix: (options: BusabaseCmsOptions, cache: BusabaseCmsCacheOptions) => string[];
+declare const createCachedBusabaseCms: (options?: BusabaseCmsOptions, cache?: BusabaseCmsCacheOptions) => BusabaseCms;
+type MinimalCmsItem = {
+  locale: string;
+  path: string;
+  updatedAt?: string;
+};
+interface CmsSitemapEntryOptions<T extends MinimalCmsItem> {
+  changeFrequency?: MetadataRoute.Sitemap[number]["changeFrequency"];
+  /** Static priority, or derive one per item from its own fields and canonical path. */
+  priority?: number | ((item: T, canonicalPath: string) => number);
+}
+/** Sitemap entries for Blog Posts — only paths under the `blog` segment are included. */
+declare const buildCmsBlogSitemapEntries: <T extends MinimalCmsItem>(posts: readonly T[], helpers: CmsPathHelpers, baseUrl: string, options?: CmsSitemapEntryOptions<T>, fallbackDate?: Date) => MetadataRoute.Sitemap;
+/** Sitemap entries for Pages — every valid-for-locale record is included, no path filter. */
+declare const buildCmsPageSitemapEntries: <T extends MinimalCmsItem>(pages: readonly T[], helpers: CmsPathHelpers, baseUrl: string, options?: CmsSitemapEntryOptions<T>, fallbackDate?: Date) => MetadataRoute.Sitemap;
+/** Merge sitemap sources, keeping the first entry seen for any duplicate URL. */
+declare const dedupeCmsSitemapEntries: (...sources: readonly MetadataRoute.Sitemap[]) => MetadataRoute.Sitemap;
+//#endregion
+export { BusabaseCmsCacheOptions, CmsSitemapEntryOptions, buildCmsBlogSitemapEntries, buildCmsPageSitemapEntries, createCachedBusabaseCms, dedupeCmsSitemapEntries, resolveBusabaseCmsCacheKeyPrefix };

package/dist/next.js

@@ -0,0 +1,107 @@
+import { a as createBusabaseCms } from "./content-BXgsWQjQ.js";
+import { resolveConfig } from "busabase-sdk";
+import "server-only";
+import { unstable_cache } from "next/cache.js";
+//#region src/next.ts
+const resolveBusabaseCmsCacheKeyPrefix = (options, cache) => {
+	if (cache.keyPrefix && cache.keyPrefix.length > 0) return cache.keyPrefix;
+	if (options.source || options.client) throw new Error("createCachedBusabaseCms requires cache.keyPrefix when using a custom source or client");
+	const config = resolveConfig(options.config);
+	if (config.headers || config.apiKey && !config.spaceId) throw new Error("createCachedBusabaseCms requires cache.keyPrefix when the target space cannot be represented without secrets");
+	const schemaProfile = options.schemaProfile ?? "standard";
+	return [
+		"busabase-cms-sdk",
+		config.baseUrl,
+		config.spaceId ?? "default-space",
+		...options.folderId ? [options.folderId, schemaProfile] : [
+			"no-folder",
+			schemaProfile,
+			options.baseSlugs?.posts ?? "busabase-cms-posts",
+			options.baseSlugs?.pages ?? "busabase-cms-pages",
+			options.baseSlugs?.categories ?? "busabase-cms-categories",
+			options.baseSlugs?.tags ?? "busabase-cms-tags"
+		]
+	];
+};
+const createCachedBusabaseCms = (options = {}, cache = {}) => {
+	const keyPrefix = resolveBusabaseCmsCacheKeyPrefix(options, cache);
+	const cms = createBusabaseCms(options);
+	const revalidate = cache.revalidate ?? 300;
+	const cachedList = (list, kind, slug) => unstable_cache(list, [
+		...keyPrefix,
+		kind,
+		slug
+	], {
+		revalidate,
+		tags: cache.tags?.[kind] ?? [`busabase-cms:${kind}`]
+	});
+	const listPosts = cachedList(cms.posts.list, "posts", options.baseSlugs?.posts ?? "busabase-cms-posts");
+	const listPages = cachedList(cms.pages.list, "pages", options.baseSlugs?.pages ?? "busabase-cms-pages");
+	const listCategories = cachedList(cms.categories.list, "categories", options.baseSlugs?.categories ?? "busabase-cms-categories");
+	const listTags = cachedList(cms.tags.list, "tags", options.baseSlugs?.tags ?? "busabase-cms-tags");
+	const cachedGetByArg = (get, kind, slug) => unstable_cache(get, [
+		...keyPrefix,
+		kind,
+		slug,
+		"by-arg"
+	], {
+		revalidate,
+		tags: cache.tags?.[kind] ?? [`busabase-cms:${kind}`]
+	});
+	return {
+		posts: {
+			list: listPosts,
+			getByPath: cachedGetByArg(cms.posts.getByPath, "posts", options.baseSlugs?.posts ?? "busabase-cms-posts")
+		},
+		pages: {
+			list: listPages,
+			getByPath: cachedGetByArg(cms.pages.getByPath, "pages", options.baseSlugs?.pages ?? "busabase-cms-pages")
+		},
+		categories: {
+			list: listCategories,
+			getBySlug: cachedGetByArg(cms.categories.getBySlug, "categories", options.baseSlugs?.categories ?? "busabase-cms-categories")
+		},
+		tags: {
+			list: listTags,
+			getBySlug: cachedGetByArg(cms.tags.getBySlug, "tags", options.baseSlugs?.tags ?? "busabase-cms-tags")
+		}
+	};
+};
+const validDateOr = (value, fallback) => {
+	if (!value) return fallback;
+	const parsed = new Date(value);
+	return Number.isNaN(parsed.getTime()) ? fallback : parsed;
+};
+const toCmsSitemapEntries = (items, helpers, baseUrl, isMatch, { changeFrequency = "monthly", priority = .7 }, fallbackDate) => items.flatMap((item) => {
+	const parsed = helpers.parsePath(item.path);
+	if (!parsed || !isMatch(parsed.canonicalPath) || !helpers.isForLocale(item, parsed.locale)) return [];
+	return [{
+		url: `${baseUrl}${parsed.canonicalPath}`,
+		lastModified: validDateOr(item.updatedAt, fallbackDate),
+		changeFrequency,
+		priority: typeof priority === "function" ? priority(item, parsed.canonicalPath) : priority
+	}];
+});
+/** Sitemap entries for Blog Posts — only paths under the `blog` segment are included. */
+const buildCmsBlogSitemapEntries = (posts, helpers, baseUrl, options = {}, fallbackDate = /* @__PURE__ */ new Date()) => toCmsSitemapEntries(posts, helpers, baseUrl, (canonicalPath) => helpers.isBlogPostPath(canonicalPath), {
+	changeFrequency: "weekly",
+	priority: .7,
+	...options
+}, fallbackDate);
+/** Sitemap entries for Pages — every valid-for-locale record is included, no path filter. */
+const buildCmsPageSitemapEntries = (pages, helpers, baseUrl, options = {}, fallbackDate = /* @__PURE__ */ new Date()) => toCmsSitemapEntries(pages, helpers, baseUrl, () => true, {
+	changeFrequency: "monthly",
+	priority: .8,
+	...options
+}, fallbackDate);
+/** Merge sitemap sources, keeping the first entry seen for any duplicate URL. */
+const dedupeCmsSitemapEntries = (...sources) => {
+	const byUrl = /* @__PURE__ */ new Map();
+	for (const source of sources) for (const entry of source) {
+		const key = entry.url.replace(/\/+$/, "") || entry.url;
+		if (!byUrl.has(key)) byUrl.set(key, entry);
+	}
+	return [...byUrl.values()];
+};
+//#endregion
+export { buildCmsBlogSitemapEntries, buildCmsPageSitemapEntries, createCachedBusabaseCms, dedupeCmsSitemapEntries, resolveBusabaseCmsCacheKeyPrefix };

package/dist/routing-C3lkVAZ8.js

@@ -0,0 +1,91 @@
+//#region src/fallback.ts
+/**
+* The "read from Busabase, fall back to bundled content on any failure" wrapper — every app
+* consuming busabase-cms re-implemented this same try/catch/console.warn a couple of times
+* (once for list-shaped reads, once for single-record reads). One generic version, one place
+* to change the log format.
+*/
+const readCmsOrFallback = async (operation, fallback, label) => {
+	if (!operation) return fallback;
+	try {
+		return await operation();
+	} catch (error) {
+		console.warn(`[busabase-cms] ${label} failed; using bundled content`, error);
+		return fallback;
+	}
+};
+//#endregion
+//#region src/routing.ts
+const normalizeSegment = (segment) => {
+	try {
+		const decoded = decodeURIComponent(segment);
+		if (!decoded || decoded === "." || decoded === ".." || /[\\/\0]/.test(decoded)) return null;
+		return decoded;
+	} catch {
+		return null;
+	}
+};
+/** Normalize a stored or requested path into a stable, decoded canonical key. */
+const normalizeCmsPath = (path) => {
+	if (!path.startsWith("/") || path.includes("?") || path.includes("#")) return null;
+	const segments = [];
+	for (const rawSegment of path.split("/").filter(Boolean)) {
+		const segment = normalizeSegment(rawSegment);
+		if (segment === null) return null;
+		segments.push(segment);
+	}
+	return segments.length === 0 ? "/" : `/${segments.join("/")}`;
+};
+/** Parse locale ownership from a canonical CMS path. The default locale is unprefixed. */
+const parseCmsCanonicalPath = (path, { supportedLocales, defaultLocale = "en" }) => {
+	if (!supportedLocales.includes(defaultLocale)) return null;
+	const canonicalPath = normalizeCmsPath(path);
+	if (!canonicalPath || canonicalPath === "/") return null;
+	const segments = canonicalPath.slice(1).split("/");
+	const first = segments[0];
+	if (first === defaultLocale) return null;
+	const hasLocalePrefix = supportedLocales.includes(first);
+	const locale = hasLocalePrefix ? first : defaultLocale;
+	const contentSegments = hasLocalePrefix ? segments.slice(1) : segments;
+	if (contentSegments.length === 0) return null;
+	const pathWithoutLocale = `/${contentSegments.join("/")}`;
+	return {
+		canonicalPath: locale === defaultLocale ? pathWithoutLocale : `/${locale}${pathWithoutLocale}`,
+		locale,
+		pathWithoutLocale,
+		segments: contentSegments
+	};
+};
+const buildCmsCanonicalPath = (locale, path, options) => {
+	if (!options.supportedLocales.includes(locale)) return null;
+	const contentPath = Array.isArray(path) ? path.join("/") : path;
+	const localePrefix = locale === (options.defaultLocale ?? "en") ? "" : `/${locale}`;
+	return parseCmsCanonicalPath(`${localePrefix}/${contentPath}`, options)?.canonicalPath ?? null;
+};
+const isCmsContentForLocale = (item, locale, options) => {
+	const parsed = parseCmsCanonicalPath(item.path, options);
+	return item.locale === locale && parsed?.locale === locale;
+};
+const isCmsBlogPostPath = (path, options) => {
+	const parsed = parseCmsCanonicalPath(path, options);
+	return parsed?.segments[0] === "blog" && parsed.segments.length > 1;
+};
+/** Build a locale-aware archive URL for a Category or Tag record. */
+const buildCmsTaxonomyArchivePath = (kind, taxonomy, options) => buildCmsCanonicalPath(taxonomy.locale, [kind, taxonomy.slug], options);
+const createCmsPathHelpers = (options) => ({
+	options,
+	normalizePath: normalizeCmsPath,
+	parsePath: (path) => parseCmsCanonicalPath(path, options),
+	buildPath: (locale, path) => buildCmsCanonicalPath(locale, path, options),
+	isForLocale: (item, locale) => isCmsContentForLocale(item, locale, options),
+	isValidContent: (item) => isCmsContentForLocale(item, item.locale, options),
+	isBlogPostPath: (path) => isCmsBlogPostPath(path, options),
+	buildTaxonomyArchivePath: (kind, taxonomy) => buildCmsTaxonomyArchivePath(kind, taxonomy, options)
+});
+/** Select Posts related to one taxonomy record without mixing locales. */
+const filterCmsPostsByTaxonomy = (posts, kind, taxonomy) => {
+	const relationKey = kind === "categories" ? "categoryIds" : "tagIds";
+	return posts.filter((post) => post.locale === taxonomy.locale && post[relationKey].includes(taxonomy.id));
+};
+//#endregion
+export { isCmsBlogPostPath as a, parseCmsCanonicalPath as c, filterCmsPostsByTaxonomy as i, readCmsOrFallback as l, buildCmsTaxonomyArchivePath as n, isCmsContentForLocale as o, createCmsPathHelpers as r, normalizeCmsPath as s, buildCmsCanonicalPath as t };