bsmnt 0.9.0 → 0.11.0

package/src/modules/features/cms/sanity-pagebuilder-cache/files/app/feed.xml/route.ts

@@ -0,0 +1,66 @@
+import { cacheLife, cacheTag } from "next/cache";
+import { ALL_BLOG_ARTICLES_QUERY } from "@/lib/integrations/sanity/queries";
+import type { ALL_BLOG_ARTICLES_QUERY_RESULT } from "@/lib/integrations/sanity/sanity.types";
+import { FEED_TAG } from "@/lib/integrations/sanity/tags";
+import { generateRssFeed, rssErrorResponse } from "@/lib/utils/rss";
+import { getPageUrl, getSitemapBaseUrl } from "@/lib/utils/sitemap";
+
+// Cached and tagged rather than read per request: feed readers poll.
+const getArticles = async () => {
+	"use cache";
+	const sanityModule = await import("@/lib/integrations/sanity/client");
+	const client = sanityModule?.client;
+
+	if (!client) return null;
+
+	// Explicit generic: next-sanity 13.3 doesn't infer it for a dynamic import.
+	const articles = await client
+		.fetch<ALL_BLOG_ARTICLES_QUERY_RESULT>(ALL_BLOG_ARTICLES_QUERY)
+		.catch((error) => {
+			console.error("Error fetching articles for the feed:", error);
+			return null;
+		});
+
+	if (articles) {
+		cacheTag(FEED_TAG);
+	} else {
+		// No publish clears a failed read, and this prerenders — otherwise a build-time
+		// outage would serve an error feed for the full ~1y cacheLife.
+		cacheLife("hours");
+	}
+
+	return articles;
+};
+
+// No `Cache-Control`: a CDN copy is a second cache the webhook can't purge.
+export async function GET() {
+	const baseUrl = getSitemapBaseUrl();
+
+	try {
+		const articles = await getArticles();
+		if (!articles) return rssErrorResponse();
+
+		const items = articles
+			.filter((article) => article.resolvedSlug && !article.noIndex)
+			.map((article) => ({
+				title: article.title ?? "Untitled",
+				link: getPageUrl(baseUrl, article.resolvedSlug),
+				description: article.metadata?.metaDescription ?? undefined,
+				pubDate: article.blogContent?.date ?? undefined,
+				authors: article.blogContent?.author?.name
+					? [article.blogContent.author.name]
+					: undefined,
+			}));
+
+		return generateRssFeed({
+			title: `${new URL(baseUrl).hostname} Blog`,
+			link: `${baseUrl}/blog`,
+			description: "Latest articles",
+			feedUrl: `${baseUrl}/feed.xml`,
+			items,
+		});
+	} catch (error) {
+		console.error("Error generating RSS feed:", error);
+		return rssErrorResponse();
+	}
+}

package/src/modules/features/cms/sanity-pagebuilder-cache/files/app/sitemap.md/route.ts

@@ -0,0 +1,132 @@
+import { NextResponse } from "next/server";
+import { isSanityConfigured } from "@/lib/integrations/check-integration";
+import type { PAGE_SITEMAP_QUERY_RESULT } from "@/lib/integrations/sanity/sanity.types";
+import {
+	getMarkdownPath,
+	getSitemap,
+	getSitemapBaseUrl,
+} from "@/lib/utils/sitemap";
+
+type PageDoc = PAGE_SITEMAP_QUERY_RESULT[number];
+
+const ROOT_GROUP = "__root__";
+
+const getFolderGroup = (slug: string | null) => {
+	if (!slug) return ROOT_GROUP;
+
+	const segments = slug.split("/").filter(Boolean);
+
+	if (segments.length <= 1) return ROOT_GROUP;
+
+	return segments.slice(0, -1).join("/");
+};
+
+const getGroupHeading = (group: string) => {
+	if (group === ROOT_GROUP) return "### Root Pages";
+
+	return `### /${group}`;
+};
+
+const sortPages = (left: PageDoc, right: PageDoc) => {
+	const leftLabel = left.title || left.slug || "Homepage";
+	const rightLabel = right.title || right.slug || "Homepage";
+
+	return leftLabel.localeCompare(rightLabel);
+};
+
+// Cached, not per-request: this bills itself as being for AI agents, so its
+// traffic is crawler-driven. `getSitemap` tags the read; the webhook busts it.
+export const GET = async () => {
+	const baseUrl = getSitemapBaseUrl();
+
+	if (!isSanityConfigured()) {
+		return new NextResponse(
+			[
+				"# Sitemap",
+				"",
+				"## Pages",
+				"",
+				`- [Homepage](${baseUrl}/index.md)`,
+				"",
+				"CMS not configured. No additional content available.",
+			].join("\n"),
+			{
+				headers: { "Content-Type": "text/markdown; charset=utf-8" },
+			},
+		);
+	}
+
+	try {
+		const allPages = await getSitemap();
+
+		if (!allPages) {
+			return new NextResponse("# Sitemap\n\nUnable to connect to CMS.", {
+				status: 503,
+				headers: { "Content-Type": "text/markdown; charset=utf-8" },
+			});
+		}
+
+		const pages = (allPages ?? []).filter((page) => !page.noIndex);
+		const pageGroups = new Map<string, PageDoc[]>();
+
+		for (const page of pages) {
+			const group = getFolderGroup(page.slug ?? null);
+			const groupedPages = pageGroups.get(group) ?? [];
+
+			groupedPages.push(page);
+			pageGroups.set(group, groupedPages);
+		}
+
+		const sortedGroupNames = [...pageGroups.keys()].sort((left, right) => {
+			if (left === ROOT_GROUP) return -1;
+			if (right === ROOT_GROUP) return 1;
+
+			return left.localeCompare(right);
+		});
+
+		const parts = [
+			`# ${new URL(baseUrl).hostname} - Content Sitemap`,
+			"",
+			"> This sitemap lists all available markdown content for AI agents.",
+			"",
+			"## Pages",
+			"",
+		];
+
+		if (pages.length > 0) {
+			for (const groupName of sortedGroupNames) {
+				const groupedPages = (pageGroups.get(groupName) ?? []).sort(sortPages);
+
+				if (groupedPages.length === 0) continue;
+
+				parts.push(getGroupHeading(groupName), "");
+
+				for (const page of groupedPages) {
+					parts.push(
+						`- [${page.title || page.slug || "Homepage"}](${getMarkdownPath(baseUrl, page.slug ?? null)})`,
+					);
+				}
+
+				parts.push("");
+			}
+		}
+
+		if (pages.length === 0) parts.push("No content published yet.", "");
+
+		// No `Cache-Control`: an `s-maxage` would be a second cache the webhook can't
+		// purge, so a publish would clear this entry and the CDN would serve the old
+		// markdown for another hour regardless.
+		return new NextResponse(parts.join("\n"), {
+			headers: {
+				"Content-Type": "text/markdown; charset=utf-8",
+				"X-Content-Type-Options": "nosniff",
+			},
+		});
+	} catch (error) {
+		console.error("Error generating sitemap.md:", error);
+		return new NextResponse("# Sitemap\n\nError fetching content.", {
+			status: 500,
+			headers: { "Content-Type": "text/markdown; charset=utf-8" },
+		});
+	}
+};

package/src/modules/features/cms/sanity-pagebuilder-cache/files/app/studio/[[...tool]]/layout.tsx

@@ -0,0 +1,26 @@
+import { connection } from "next/server";
+import { type ReactNode, Suspense } from "react";
+
+// Re-export next-sanity's static metadata (incl. robots: noindex) — the
+// "use client" Studio page can't export metadata itself.
+export { metadata, viewport } from "next-sanity/studio";
+
+// File-based metadata on a catch-all depends on the route param, so the Studio's
+// metadata is dynamic while its body is static — which Cache Components rejects.
+// It's an interactive SPA with no SEO value, so mark it dynamic behind its own
+// boundary and let the rest of the shell prerender.
+async function DynamicMarker() {
+	await connection();
+	return null;
+}
+
+export default function StudioLayout({ children }: { children: ReactNode }) {
+	return (
+		<>
+			{children}
+			<Suspense>
+				<DynamicMarker />
+			</Suspense>
+		</>
+	);
+}

package/src/modules/features/cms/sanity-pagebuilder-cache/files/app/studio/[[...tool]]/page.tsx

@@ -0,0 +1,23 @@
+"use client";
+
+import { NextStudio } from "next-sanity/studio";
+import { isSanityConfigured } from "@/lib/integrations/check-integration";
+import config from "@/lib/integrations/sanity/sanity.config";
+
+// The Studio throws on an empty `projectId`, which `env.ts` falls back to when
+// Sanity isn't configured — so this route would fail `next build`.
+const StudioPage = () =>
+	isSanityConfigured() ? (
+		<NextStudio config={config} />
+	) : (
+		<main style={{ padding: "2rem", fontFamily: "system-ui, sans-serif" }}>
+			<h1>Studio unavailable</h1>
+			<p>
+				Set <code>NEXT_PUBLIC_SANITY_PROJECT_ID</code> and{" "}
+				<code>NEXT_PUBLIC_SANITY_DATASET</code>, then restart, to load the
+				embedded Studio.
+			</p>
+		</main>
+	);
+
+export default StudioPage;

package/src/modules/features/cms/sanity-pagebuilder-cache/files/components/sanity/draft-mode-toggle.tsx

@@ -0,0 +1,27 @@
+"use client";
+
+import { useRouter } from "next/navigation";
+import { useTransition } from "react";
+
+export function DraftModeToggle() {
+	const router = useRouter();
+	const [isPending, startTransition] = useTransition();
+
+	const handleDisable = () => {
+		startTransition(async () => {
+			await fetch("/api/draft-mode/disable");
+			router.refresh();
+		});
+	};
+
+	return (
+		<button
+			type="button"
+			onClick={handleDisable}
+			disabled={isPending}
+			className="fixed bottom-4 left-1/2 z-50 -translate-x-1/2 rounded-full border border-white/10 bg-black/80 px-2 py-1 font-medium text-sm text-white shadow-lg backdrop-blur-sm transition-colors hover:bg-black/90 disabled:opacity-50"
+		>
+			{isPending ? "Disabling..." : "Disable Draft Mode"}
+		</button>
+	);
+}

package/src/modules/features/cms/sanity-pagebuilder-cache/files/components/sanity/rich-text.tsx

@@ -0,0 +1,88 @@
+import { PortableText, type PortableTextProps } from "@portabletext/react";
+import { Link } from "@/components/ui/link";
+import { SanityImage } from "@/components/ui/sanity-image";
+import {
+	getLinkAttributes,
+	urlForReference,
+} from "../../lib/integrations/sanity/utils/link";
+
+interface RichTextProps {
+	content: PortableTextProps["value"];
+}
+
+type LinkMarkProps = {
+	children: React.ReactNode;
+	value?: unknown;
+};
+
+const LinkMark = ({ children, value }: LinkMarkProps) => {
+	const href = urlForReference(value as Parameters<typeof urlForReference>[0]);
+	const attrs = getLinkAttributes(
+		value as Parameters<typeof getLinkAttributes>[0],
+	);
+
+	return (
+		<Link
+			href={href}
+			target={attrs.target}
+			rel={attrs.rel}
+			className="text-blue underline underline-offset-2 transition-opacity hover:opacity-70"
+			data-sanity-edit-target
+		>
+			{children}
+		</Link>
+	);
+};
+
+export const RichText = ({ content }: RichTextProps) => {
+	if (!content) return null;
+
+	return (
+		<PortableText
+			value={content}
+			components={{
+				types: {
+					image: ({ value }) => <SanityImage image={value} maxWidth={1920} />,
+					table: ({ value }) => {
+						const rows = value?.rows as
+							| Array<{ _key?: string; cells?: string[] }>
+							| undefined;
+						if (!rows?.length) return null;
+						return (
+							<table>
+								<tbody>
+									{rows.map((row, i) => (
+										<tr key={row._key ?? `row-${i}`}>
+											{row.cells?.map((cell) => {
+												const cellKey = `${row._key}-${cell}`;
+												return i === 0 ? (
+													<th key={cellKey}>{cell}</th>
+												) : (
+													<td key={cellKey}>{cell}</td>
+												);
+											})}
+										</tr>
+									))}
+								</tbody>
+							</table>
+						);
+					},
+				},
+				marks: {
+					link: LinkMark,
+					pageReference: LinkMark,
+					externalLink: LinkMark,
+				},
+				block: {
+					h1: ({ children }) => <h1 className="h1">{children}</h1>,
+					h2: ({ children }) => <h2 className="h2">{children}</h2>,
+					h3: ({ children }) => <h3 className="h3">{children}</h3>,
+					h4: ({ children }) => <h4 className="h4">{children}</h4>,
+					h5: ({ children }) => <h5 className="h5">{children}</h5>,
+					h6: ({ children }) => <h6 className="h6">{children}</h6>,
+					normal: ({ children }) => <p className="p">{children}</p>,
+				},
+			}}
+		/>
+	);
+};

package/src/modules/features/cms/sanity-pagebuilder-cache/files/components/sanity/visual-editing.tsx

@@ -0,0 +1,11 @@
+import { VisualEditing } from "next-sanity/visual-editing";
+import { DraftModeToggle } from "@/components/sanity/draft-mode-toggle";
+
+// Rendered by the content layout only when draft mode is enabled. <SanityLive>
+// lives in the layout so there is exactly one of each across the tree.
+export const SanityVisualEditing = () => (
+	<>
+		<DraftModeToggle />
+		<VisualEditing />
+	</>
+);

package/src/modules/features/cms/sanity-pagebuilder-cache/files/components/ui/sanity-image/index.tsx

@@ -0,0 +1,51 @@
+import { getImageDimensions } from "@sanity/asset-utils";
+import { Image, type ImageProps } from "@/components/ui/image";
+import { urlForImage } from "@/lib/integrations/sanity/utils/image";
+
+interface SanityImageProps extends Omit<ImageProps, "src" | "aspectRatio"> {
+	image: {
+		asset?: {
+			_ref: string;
+			_type: "reference";
+		};
+		alt?: string;
+		hotspot?: object;
+		crop?: { left?: number; right?: number; top?: number; bottom?: number };
+	};
+	maxWidth?: number;
+}
+
+export function SanityImage({
+	image,
+	maxWidth = 1920,
+	alt,
+	fill,
+	...props
+}: SanityImageProps) {
+	if (!image?.asset) return null;
+
+	// getImageDimensions is uncropped; the URL builder applies the crop.
+	// Rounding order must match @sanity/image-url: origin first, then subtract.
+	const { width, height } = getImageDimensions(image.asset);
+	const { left = 0, right = 0, top = 0, bottom = 0 } = image.crop ?? {};
+	const cropLeft = Math.round(left * width);
+	const cropTop = Math.round(top * height);
+	const sourceWidth = Math.round(width - right * width - cropLeft);
+	const sourceHeight = Math.round(height - bottom * height - cropTop);
+
+	const imageProps = fill
+		? { fill: true }
+		: { width: sourceWidth, height: sourceHeight };
+
+	return (
+		<Image
+			src={urlForImage(image)
+				.width(Math.min(maxWidth, sourceWidth))
+				.url()}
+			alt={alt || image.alt || ""}
+			aspectRatio={sourceWidth / sourceHeight}
+			{...imageProps}
+			{...props}
+		/>
+	);
+}

package/src/modules/features/cms/sanity-pagebuilder-cache/files/lib/integrations/check-integration.ts

@@ -0,0 +1,6 @@
+import { dataset, projectId } from "@/lib/integrations/sanity/env";
+
+// Derived from env.ts, not a second read of `process.env`. Read directly these
+// disagreed — env.ts also accepts `SANITY_STUDIO_PROJECT_ID` and defaults the
+// dataset — so a resolvable project reported itself unconfigured.
+export const isSanityConfigured = () => Boolean(projectId && dataset);

package/src/modules/features/cms/sanity-pagebuilder-cache/files/lib/integrations/sanity/client.ts

@@ -0,0 +1,37 @@
+import { createClient, type SanityClient } from "next-sanity";
+import { isSanityConfigured } from "@/lib/integrations/check-integration";
+import { apiVersion, dataset, projectId, sanityToken, studioUrl } from "./env";
+
+/**
+ * Sanity client instance
+ *
+ * Returns null if Sanity is not configured (missing env vars).
+ * Always check with isSanityConfigured() before using.
+ */
+export const client: SanityClient | null = isSanityConfigured()
+	? createClient({
+			projectId,
+			dataset,
+			apiVersion,
+			useCdn: true,
+			perspective: "published",
+			token: sanityToken,
+			stega: {
+				studioUrl,
+				filter: (props) => {
+					if (props.sourcePath.at(-1) === "title") return true;
+					return props.filterDefault(props);
+				},
+			},
+		})
+	: null;
+
+/**
+ * Non-CDN clone for the publish webhook, and only for it: a CDN hit would return
+ * the pre-mutation slug, so it would invalidate the old path and miss the new one.
+ *
+ * Elsewhere outside a `'use cache'` scope, use plain `client.fetch` — bypassing
+ * the CDN costs uncached-API quota for no freshness anyone needs.
+ */
+export const directClient: SanityClient | null =
+	client?.withConfig({ useCdn: false }) ?? null;

package/src/modules/features/cms/sanity-pagebuilder-cache/files/lib/integrations/sanity/components/block-actions-item.tsx

@@ -0,0 +1,81 @@
+import { EyeClosedIcon, EyeOpenIcon } from "@sanity/icons";
+import { Badge, Box, Button, Flex, Text, Tooltip, useToast } from "@sanity/ui";
+import { useState } from "react";
+import { type ObjectItemProps, useClient, useFormValue } from "sanity";
+import { apiVersion } from "@/lib/integrations/sanity/env";
+
+const HIDDEN_KEYS_FIELD = "hiddenPageBuilderKeys";
+
+type ReferenceItem = { _key: string; _ref: string; _type: string };
+
+/**
+ * Eye-icon toggle for a page builder placement's per-page visibility. Adds the
+ * placement's `_key` to the owning document's `hiddenPageBuilderKeys`; GROQ
+ * filters those keys out at query time. Standalone control because Sanity's
+ * built-in item menu isn't extensible via public props.
+ */
+export function BlockActionsItem(props: ObjectItemProps<ReferenceItem>) {
+	const { value, renderDefault } = props;
+	const client = useClient({ apiVersion });
+	const toast = useToast();
+	const [busy, setBusy] = useState(false);
+
+	// Open document id (draft while editing).
+	const documentId = useFormValue(["_id"]) as string | undefined;
+	const hiddenKeys =
+		(useFormValue([HIDDEN_KEYS_FIELD]) as string[] | undefined) ?? [];
+	const itemKey = value._key;
+	const hidden = hiddenKeys.includes(itemKey);
+	const label = hidden ? "Show on this page" : "Hide on this page";
+
+	async function handleToggleHidden() {
+		if (busy || !documentId) return;
+		setBusy(true);
+		try {
+			// Atomic array ops (not read-modify-write) so concurrent toggles
+			// of different blocks don't clobber each other.
+			const patch = client.patch(documentId);
+			if (hidden) {
+				patch.unset([`${HIDDEN_KEYS_FIELD}[@ == "${itemKey}"]`]);
+			} else {
+				patch
+					.setIfMissing({ [HIDDEN_KEYS_FIELD]: [] })
+					.insert("after", `${HIDDEN_KEYS_FIELD}[-1]`, [itemKey]);
+			}
+			await patch.commit();
+			toast.push({
+				status: "success",
+				title: hidden ? "Block shown" : "Block hidden",
+			});
+		} catch {
+			toast.push({ status: "error", title: "Failed to update visibility" });
+		} finally {
+			setBusy(false);
+		}
+	}
+
+	return (
+		<Flex align="center" gap={1} paddingLeft={1}>
+			<Tooltip content={<Text size={1}>{label}</Text>} placement="top" portal>
+				<Button
+					mode="bleed"
+					// Open eye = visible, closed eye = hidden.
+					icon={hidden ? EyeClosedIcon : EyeOpenIcon}
+					tone={hidden ? "caution" : "default"}
+					aria-label={label}
+					// Unsaved doc has no id to patch — disable, don't no-op.
+					disabled={busy || !documentId}
+					onClick={handleToggleHidden}
+				/>
+			</Tooltip>
+			{hidden && (
+				<Badge fontSize={0} mode="outline" tone="caution">
+					Hidden
+				</Badge>
+			)}
+			<Box flex={1} style={hidden ? { opacity: 0.5 } : undefined}>
+				{renderDefault(props)}
+			</Box>
+		</Flex>
+	);
+}

package/src/modules/features/cms/sanity-pagebuilder-cache/files/lib/integrations/sanity/components/disable-draft-mode.tsx

@@ -0,0 +1,23 @@
+"use client";
+
+import Link from "next/link";
+import { usePathname } from "next/navigation";
+import { useIsPresentationTool } from "next-sanity/hooks";
+
+export function DisableDraftMode() {
+	const isPresentationTool = useIsPresentationTool();
+	const pathname = usePathname();
+
+	if (isPresentationTool) return null;
+	if (pathname.startsWith("/studio")) return null;
+
+	return (
+		<Link
+			href="/api/draft-mode/disable"
+			scroll={false}
+			className="dr-p-4 fixed top-safe right-safe z-50 bg-red font-mono text-primary text-sm uppercase"
+		>
+			Disable Draft Mode
+		</Link>
+	);
+}

package/src/modules/features/cms/sanity-pagebuilder-cache/files/lib/integrations/sanity/components/page-builder-input.tsx

@@ -0,0 +1,39 @@
+import { type ArrayOfObjectsInputProps, useFormValue } from "sanity";
+import {
+	getVisiblePageBuilderInsertMenuGroups,
+	getVisiblePageBuilderReferenceMembers,
+	type PageBuilderGroupName,
+} from "@/lib/integrations/sanity/page-builder-config";
+
+export function PageBuilderInput(props: ArrayOfObjectsInputProps) {
+	const pageTypeValue = useFormValue(["type"]);
+	const pageType =
+		typeof pageTypeValue === "string"
+			? (pageTypeValue as PageBuilderGroupName)
+			: undefined;
+
+	const visibleMemberNames = new Set(
+		getVisiblePageBuilderReferenceMembers(pageType).map(
+			(member) => member.name,
+		),
+	);
+
+	return props.renderDefault({
+		...props,
+		schemaType: {
+			...props.schemaType,
+			of: props.schemaType.of.filter(
+				(member) =>
+					typeof member.name === "string" &&
+					visibleMemberNames.has(member.name),
+			),
+			options: {
+				...props.schemaType.options,
+				insertMenu: {
+					...props.schemaType.options?.insertMenu,
+					groups: getVisiblePageBuilderInsertMenuGroups(pageType),
+				},
+			},
+		},
+	});
+}

package/src/modules/features/cms/sanity-pagebuilder-cache/files/lib/integrations/sanity/components/page-category-input.tsx

@@ -0,0 +1,50 @@
+import { Select } from "@sanity/ui";
+import { useEffect } from "react";
+import { type StringInputProps, set, setIfMissing } from "sanity";
+
+type PageCategoryOption = {
+	title: string;
+	value: string;
+};
+
+const isPageCategoryOption = (option: unknown): option is PageCategoryOption =>
+	typeof option === "object" &&
+	option !== null &&
+	"title" in option &&
+	"value" in option &&
+	typeof option.title === "string" &&
+	typeof option.value === "string";
+
+export function PageCategoryInput(props: StringInputProps) {
+	useEffect(() => {
+		if (props.value === undefined) {
+			props.onChange(setIfMissing("generic"));
+		}
+	}, [props.onChange, props.value]);
+
+	const options = Array.isArray(props.schemaType.options?.list)
+		? props.schemaType.options.list.filter(isPageCategoryOption)
+		: [];
+
+	if (options.length === 0) {
+		return props.renderDefault({ ...props, value: props.value ?? "generic" });
+	}
+
+	return (
+		<Select
+			{...props.elementProps}
+			disabled={props.readOnly}
+			onChange={(event) => props.onChange(set(event.currentTarget.value))}
+			value={props.value ?? "generic"}
+			{...(props.validationError
+				? { customValidity: props.validationError }
+				: {})}
+		>
+			{options.map((option) => (
+				<option key={option.value} value={option.value}>
+					{option.title}
+				</option>
+			))}
+		</Select>
+	);
+}