bsmnt 0.4.2 → 0.5.0

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

@@ -0,0 +1,124 @@
+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";
+
+export const dynamic = "force-dynamic";
+
+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);
+};
+
+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.", "");
+
+		return new NextResponse(parts.join("\n"));
+	} 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/files/app/studio/[[...tool]]/page.tsx

@@ -0,0 +1,8 @@
+"use client";
+
+import { NextStudio } from "next-sanity/studio";
+import config from "@/lib/integrations/sanity/sanity.config";
+
+const StudioPage = () => <NextStudio config={config} />;
+
+export default StudioPage;

package/src/modules/features/cms/sanity-pagebuilder/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/files/components/sanity/rich-text.tsx

@@ -0,0 +1,87 @@
+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}
+			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/files/components/sanity/visual-editing.tsx

@@ -0,0 +1,28 @@
+import { draftMode } from "next/headers";
+import { VisualEditing } from "next-sanity/visual-editing";
+import { Suspense } from "react";
+import { refreshAction } from "@/app/actions/refresh";
+import { DraftModeToggle } from "@/components/sanity/draft-mode-toggle";
+import { isSanityConfigured } from "@/lib/integrations/check-integration";
+import { SanityLive } from "@/lib/integrations/sanity/live";
+
+async function VisualEditingInner() {
+	const { isEnabled: isDraftMode } = await draftMode();
+	const sanityConfigured = isSanityConfigured();
+
+	if (!(sanityConfigured && isDraftMode)) return null;
+
+	return (
+		<>
+			<DraftModeToggle />
+			<VisualEditing />
+			<SanityLive action={refreshAction} />
+		</>
+	);
+}
+
+export const SanityVisualEditing = () => (
+	<Suspense fallback={null}>
+		<VisualEditingInner />
+	</Suspense>
+);

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

@@ -0,0 +1,41 @@
+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?: object;
+	};
+	maxWidth?: number;
+}
+
+export function SanityImage({
+	image,
+	maxWidth = 1920,
+	alt,
+	fill,
+	...props
+}: SanityImageProps) {
+	if (!image?.asset) return null;
+
+	const { width, height } = getImageDimensions(image.asset);
+	const aspectRatio = width / height;
+
+	const imageProps = fill ? { fill: true } : { width, height };
+
+	return (
+		<Image
+			src={urlForImage(image).width(maxWidth).url()}
+			alt={alt || image.alt || ""}
+			aspectRatio={aspectRatio}
+			{...imageProps}
+			{...props}
+		/>
+	);
+}

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

@@ -0,0 +1,5 @@
+export const isSanityConfigured = () =>
+	Boolean(
+		process.env.NEXT_PUBLIC_SANITY_PROJECT_ID &&
+			process.env.NEXT_PUBLIC_SANITY_DATASET,
+	);

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

@@ -0,0 +1,27 @@
+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;

package/src/modules/features/cms/sanity-pagebuilder/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/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/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>
+	);
+}

package/src/modules/features/cms/sanity-pagebuilder/files/lib/integrations/sanity/components/slug-field.tsx

@@ -0,0 +1,18 @@
+import { type FieldProps, useFormValue } from "sanity";
+import { getPinnedPageById } from "@/lib/integrations/sanity/pinned-pages";
+
+const DEFAULT_DESCRIPTION = "URL path without leading slash.";
+const PINNED_DESCRIPTION =
+	"URL path without leading slash. Disabled on 📌 pinned pages.";
+
+// Swaps the slug description to a locked-state note on pinned pages.
+// (Sanity descriptions are plain strings, hence the 📌 character.)
+export function SlugField(props: FieldProps) {
+	const documentId = useFormValue(["_id"]) as string | undefined;
+	const isPinned = getPinnedPageById(documentId) !== null;
+
+	return props.renderDefault({
+		...props,
+		description: isPinned ? PINNED_DESCRIPTION : DEFAULT_DESCRIPTION,
+	});
+}

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

@@ -0,0 +1,14 @@
+import type { SlugInputProps } from "sanity";
+
+// Adds a not-allowed cursor to the slug field when it's read-only (pinned pages).
+export function SlugInput(props: SlugInputProps) {
+	if (!props.readOnly) {
+		return props.renderDefault(props);
+	}
+
+	return (
+		<div style={{ cursor: "not-allowed" }}>
+			<div style={{ pointerEvents: "none" }}>{props.renderDefault(props)}</div>
+		</div>
+	);
+}

package/src/modules/features/cms/sanity-pagebuilder/files/lib/integrations/sanity/confirm-publish-action.ts

@@ -0,0 +1,40 @@
+import { useState } from "react";
+import type {
+	DocumentActionComponent,
+	DocumentActionDialogProps,
+	DocumentActionProps,
+} from "sanity";
+
+export function createConfirmPublishAction(
+	originalPublishAction: DocumentActionComponent,
+): DocumentActionComponent {
+	const ConfirmPublishAction = (props: DocumentActionProps) => {
+		const original = originalPublishAction(props);
+		const [dialogOpen, setDialogOpen] = useState(false);
+
+		if (!original) return null;
+
+		const { dialog: _originalDialog, ...originalWithoutDialog } = original;
+		const dialog: DocumentActionDialogProps | false = dialogOpen
+			? {
+					type: "confirm",
+					tone: "critical",
+					message:
+						"This will make these changes live on the production site immediately. Continue?",
+					onCancel: () => setDialogOpen(false),
+					onConfirm: () => {
+						setDialogOpen(false);
+						original.onHandle?.();
+					},
+				}
+			: false;
+
+		return {
+			...originalWithoutDialog,
+			onHandle: () => setDialogOpen(true),
+			dialog,
+		};
+	};
+
+	return ConfirmPublishAction;
+}

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

@@ -0,0 +1,34 @@
+/**
+ * Sanity Environment Configuration
+ *
+ * All values have safe defaults to allow the app to build and run
+ * without Sanity configured. Use isSanityConfigured() to check
+ * if Sanity is properly set up before making API calls.
+ */
+
+/** Sanity API version - defaults to latest stable */
+export const apiVersion =
+	process.env.NEXT_PUBLIC_SANITY_API_VERSION || "2024-03-15";
+
+/** Sanity dataset name - defaults to 'production' */
+export const dataset = process.env.NEXT_PUBLIC_SANITY_DATASET || "production";
+
+/** Sanity project ID - empty string if not configured */
+export const projectId =
+	process.env.NEXT_PUBLIC_SANITY_PROJECT_ID ||
+	process.env.SANITY_STUDIO_PROJECT_ID ||
+	"";
+
+/** Sanity Studio URL for visual editing */
+export const studioUrl =
+	process.env.NODE_ENV === "development"
+		? "http://localhost:3000/studio"
+		: `${process.env.NEXT_PUBLIC_BASE_URL || ""}/studio`;
+
+export const sanityToken = process.env.SANITY_API_READ_TOKEN || "";
+
+/** Preview URL for draft mode */
+export const previewURL =
+	process.env.NODE_ENV === "development"
+		? "http://localhost:3000"
+		: process.env.NEXT_PUBLIC_BASE_URL || "";

package/src/modules/features/cms/sanity-pagebuilder/files/lib/integrations/sanity/fetchers/layout.ts

@@ -0,0 +1,48 @@
+import { cache } from "react";
+import { fetchSanity } from "@/lib/integrations/sanity/live";
+import {
+	COMPANY_DATA_QUERY,
+	FOOTER_QUERY,
+	NAVBAR_QUERY,
+} from "@/lib/integrations/sanity/queries";
+import type {
+	COMPANY_DATA_QUERY_RESULT,
+	FOOTER_QUERY_RESULT,
+	NAVBAR_QUERY_RESULT,
+} from "@/lib/integrations/sanity/sanity.types";
+
+export type NavbarData = NonNullable<NAVBAR_QUERY_RESULT>;
+export type FooterData = NonNullable<FOOTER_QUERY_RESULT>;
+export type CompanyData = NonNullable<COMPANY_DATA_QUERY_RESULT>;
+
+// Singleton document types that, when published, should bust the layout cache.
+export const SANITY_LAYOUT_TAGS = ["navbar", "footer", "companyData"];
+
+// Wrapped in React cache so components sharing a singleton (e.g. Footer + JsonLd
+// both reading companyData) only hit Sanity once per request.
+export const getNavbarData = cache(async (): Promise<NavbarData | null> => {
+	const { data } = await fetchSanity<NavbarData>({
+		query: NAVBAR_QUERY,
+		tags: ["navbar"],
+	});
+
+	return data ?? null;
+});
+
+export const getFooterData = cache(async (): Promise<FooterData | null> => {
+	const { data } = await fetchSanity<FooterData>({
+		query: FOOTER_QUERY,
+		tags: ["footer"],
+	});
+
+	return data ?? null;
+});
+
+export const getCompanyData = cache(async (): Promise<CompanyData | null> => {
+	const { data } = await fetchSanity<CompanyData>({
+		query: COMPANY_DATA_QUERY,
+		tags: ["companyData"],
+	});
+
+	return data ?? null;
+});

package/src/modules/features/cms/sanity-pagebuilder/files/lib/integrations/sanity/fetchers/redirects.ts

@@ -0,0 +1,17 @@
+import { fetchSanity } from "@/lib/integrations/sanity/live";
+import { REDIRECTS_QUERY } from "@/lib/integrations/sanity/queries";
+import type { REDIRECTS_QUERY_RESULT } from "@/lib/integrations/sanity/sanity.types";
+
+export type RedirectEntry = REDIRECTS_QUERY_RESULT[number];
+
+/** Cache tag invalidated by the revalidate webhook on publish. */
+export const SANITY_REDIRECTS_TAG = "redirect";
+
+export const getRedirects = async (): Promise<REDIRECTS_QUERY_RESULT> => {
+	const { data } = await fetchSanity<REDIRECTS_QUERY_RESULT>({
+		query: REDIRECTS_QUERY,
+		tags: [SANITY_REDIRECTS_TAG],
+	});
+
+	return data ?? [];
+};