bsmnt 0.4.3 → 0.6.0

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

@@ -0,0 +1,66 @@
+import { Badge, Card, Flex, Stack, Text } from "@sanity/ui";
+import { useEffect, useState } from "react";
+import { type ArrayOfPrimitivesInputProps, useClient } from "sanity";
+import { apiVersion } from "../env";
+
+type CompanyProfile = { name?: string | null; url?: string | null };
+
+// Draft-first so editors see unpublished toggle changes.
+export const INCLUDED_COMPANY_PROFILES_QUERY = `coalesce(
+	*[_id == "drafts.companyData"][0],
+	*[_id == "companyData"][0]
+).socialLinks[includeInStructuredData == true]{ name, url }`;
+
+// Shows which Company Data social links are merged into sameAs automatically.
+export function SameAsInput(props: ArrayOfPrimitivesInputProps) {
+	const { renderDefault } = props;
+	const client = useClient({ apiVersion });
+	const [included, setIncluded] = useState<CompanyProfile[]>([]);
+
+	useEffect(() => {
+		let active = true;
+		client
+			.fetch<CompanyProfile[] | null>(INCLUDED_COMPANY_PROFILES_QUERY)
+			.then((rows) => {
+				if (active) setIncluded(rows ?? []);
+			})
+			.catch(() => {
+				// Best-effort preview — never block editing.
+			});
+		return () => {
+			active = false;
+		};
+	}, [client]);
+
+	return (
+		<Stack space={3}>
+			<Card padding={3} radius={2} border tone="transparent">
+				<Stack space={3}>
+					{included.length > 0 ? (
+						<>
+							<Text size={1} muted>
+								Included from Company Data (toggle off there to remove):
+							</Text>
+							{included.map((profile) => (
+								<Flex key={profile.url} gap={2} align="center">
+									<Badge fontSize={0} mode="outline">
+										{profile.name ?? "Profile"}
+									</Badge>
+									<Text size={1} muted textOverflow="ellipsis">
+										{profile.url}
+									</Text>
+								</Flex>
+							))}
+						</>
+					) : (
+						<Text size={1} muted>
+							No Company Data social links are included yet — enable "Include in
+							Structured Data" on a social link to add it here.
+						</Text>
+					)}
+				</Stack>
+			</Card>
+			{renderDefault(props)}
+		</Stack>
+	);
+}

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,67 @@
+import { cache } from "react";
+import { fetchSanity } from "@/lib/integrations/sanity/live";
+import {
+	COMPANY_DATA_QUERY,
+	FOOTER_QUERY,
+	NAVBAR_QUERY,
+	STRUCTURED_DATA_QUERY,
+} from "@/lib/integrations/sanity/queries";
+import type {
+	COMPANY_DATA_QUERY_RESULT,
+	FOOTER_QUERY_RESULT,
+	NAVBAR_QUERY_RESULT,
+	STRUCTURED_DATA_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>;
+export type StructuredData = NonNullable<STRUCTURED_DATA_QUERY_RESULT>;
+
+// Singleton document types that, when published, should bust the layout cache.
+export const SANITY_LAYOUT_TAGS = [
+	"navbar",
+	"footer",
+	"companyData",
+	"structuredData",
+];
+
+// 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;
+});
+
+export const getStructuredData = cache(
+	async (): Promise<StructuredData | null> => {
+		const { data } = await fetchSanity<StructuredData>({
+			query: STRUCTURED_DATA_QUERY,
+			tags: ["structuredData"],
+		});
+
+		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 ?? [];
+};

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

@@ -0,0 +1,79 @@
+import type { Icon, IconProps } from "@phosphor-icons/react";
+import {
+	AppWindowIcon,
+	ArrowBendUpRightIcon,
+	ArticleNyTimesIcon,
+	BracketsCurlyIcon,
+	BriefcaseIcon,
+	BrowsersIcon,
+	BuildingsIcon,
+	CalendarBlankIcon,
+	CardsIcon,
+	FileTextIcon,
+	FolderOpenIcon,
+	FootprintsIcon,
+	LayoutIcon,
+	ListBulletsIcon,
+	ListIcon,
+	PackageIcon,
+	PushPinIcon,
+	QuestionIcon,
+	RocketIcon,
+	ShapesIcon,
+	ShareNetworkIcon,
+	TagIcon,
+	TextAlignLeftIcon,
+	TreeStructureIcon,
+	UserCircleIcon,
+	VideoCameraIcon,
+} from "@phosphor-icons/react/dist/ssr";
+import { createElement, forwardRef } from "react";
+
+export type SanityStudioIcon = Icon;
+
+const asDuotoneIcon = (IconComponent: Icon): SanityStudioIcon => {
+	const DuotoneIcon = forwardRef<SVGSVGElement, IconProps>((props, ref) =>
+		createElement(IconComponent, { ...props, ref, weight: "duotone" }),
+	);
+
+	DuotoneIcon.displayName = `${IconComponent.displayName ?? "Phosphor"}Duotone`;
+
+	return DuotoneIcon;
+};
+
+export const pageBuilderCardIcon = asDuotoneIcon(PackageIcon);
+export const pageBuilderCardListIcon = asDuotoneIcon(ListIcon);
+
+export const authorIcon = asDuotoneIcon(UserCircleIcon);
+
+export const pageListIcon = asDuotoneIcon(ListBulletsIcon);
+
+export const blogCategoryIcon = asDuotoneIcon(TagIcon);
+
+export const componentsFolderIcon = asDuotoneIcon(ShapesIcon);
+
+export const companyDataIcon = asDuotoneIcon(BuildingsIcon);
+export const socialLinksIcon = asDuotoneIcon(ShareNetworkIcon);
+export const navbarIcon = asDuotoneIcon(ListIcon);
+export const footerIcon = asDuotoneIcon(FootprintsIcon);
+export const redirectIcon = asDuotoneIcon(ArrowBendUpRightIcon);
+export const layoutFolderIcon = asDuotoneIcon(LayoutIcon);
+export const structuredDataIcon = asDuotoneIcon(TreeStructureIcon);
+
+export const faqJsonLdIcon = asDuotoneIcon(QuestionIcon);
+export const eventJsonLdIcon = asDuotoneIcon(CalendarBlankIcon);
+export const videoJsonLdIcon = asDuotoneIcon(VideoCameraIcon);
+export const jobPostingJsonLdIcon = asDuotoneIcon(BriefcaseIcon);
+export const softwareApplicationJsonLdIcon = asDuotoneIcon(AppWindowIcon);
+export const itemListJsonLdIcon = asDuotoneIcon(CardsIcon);
+export const customJsonLdIcon = asDuotoneIcon(BracketsCurlyIcon);
+
+export const heroIcon = asDuotoneIcon(RocketIcon);
+export const descriptionIcon = asDuotoneIcon(TextAlignLeftIcon);
+export const contentIcon = asDuotoneIcon(ArticleNyTimesIcon);
+
+export const pageIcon = asDuotoneIcon(FileTextIcon);
+export const pinIcon = asDuotoneIcon(PushPinIcon);
+export const pagesFolderIcon = asDuotoneIcon(BrowsersIcon);
+export const pageFolderIcon = asDuotoneIcon(FolderOpenIcon);
+export const contentFolderIcon = asDuotoneIcon(FolderOpenIcon);

package/src/modules/features/cms/sanity-pagebuilder/files/lib/integrations/sanity/live/index.tsx

@@ -0,0 +1,88 @@
+import { NextResponse } from "next/server";
+import type { QueryParams } from "next-sanity";
+import { defineLive } from "next-sanity/live";
+import { isSanityConfigured } from "@/lib/integrations/check-integration";
+import { client } from "../client";
+import { sanityToken } from "../env";
+
+const isConfigured = isSanityConfigured() && client;
+
+const liveExports =
+	isConfigured && client
+		? defineLive({
+				client,
+				browserToken: sanityToken ?? false,
+				serverToken: sanityToken ?? false,
+			})
+		: null;
+
+export const sanityFetch =
+	liveExports?.sanityFetch ?? (async () => ({ data: null }));
+
+export const SanityLive = liveExports?.SanityLive ?? (() => null);
+
+type SanityFetchOptions = {
+	query: string;
+	params?: QueryParams;
+	tags?: string[];
+	stega?: boolean;
+	perspective?: "published" | "drafts" | "previewDrafts";
+};
+
+export async function fetchSanity<T = unknown>({
+	query,
+	params = {},
+	tags = [],
+	stega,
+	perspective,
+}: SanityFetchOptions): Promise<{ data: T | null }> {
+	const { data } = await sanityFetch({
+		query,
+		params,
+		tags,
+		...(typeof stega === "boolean" ? { stega } : {}),
+		...(perspective ? { perspective } : {}),
+	});
+
+	return { data: (data as T | null) ?? null };
+}
+
+export const SanityFetch = async <T,>(
+	slug: string,
+	query: string,
+	label = "Content",
+): Promise<T | NextResponse> => {
+	if (!client) {
+		return new NextResponse(`# 503 Unavailable\n\nCMS client unavailable.`, {
+			status: 503,
+			headers: { "Content-Type": "text/markdown; charset=utf-8" },
+		});
+	}
+
+	try {
+		const { data } = await sanityFetch({
+			query,
+			params: { slug },
+		});
+
+		const result = data as T | null;
+
+		if (!result) {
+			return new NextResponse(`# 404 Not Found\n\nPage not found.`, {
+				status: 404,
+				headers: { "Content-Type": "text/markdown; charset=utf-8" },
+			});
+		}
+
+		return result;
+	} catch (error) {
+		console.error(`Error fetching ${label.toLowerCase()}:`, error);
+		return new NextResponse(
+			`# 500 Error\n\nFailed to fetch ${label.toLowerCase()}.`,
+			{
+				status: 500,
+				headers: { "Content-Type": "text/markdown; charset=utf-8" },
+			},
+		);
+	}
+};

package/src/modules/features/cms/sanity-pagebuilder/files/lib/integrations/sanity/markdown-proxy.config.ts

@@ -0,0 +1,50 @@
+export interface MarkdownRoute {
+	/** Regex to match the public-facing URL */
+	regex: RegExp;
+	/** API route path template (under /api/) */
+	apiPath: string;
+	/** Public markdown URL template (for Link headers) */
+	publicPath: string;
+}
+
+/**
+ * Routes that serve markdown versions for AI agents.
+ * All pages are backed by the shared `page` document type and resolved
+ * through the catch-all route handlers.
+ *
+ * How it works:
+ * - `regex`: match the public-facing URL (e.g. /about.md or /about)
+ * - `apiPath`: the internal API route that serves the markdown (e.g. /api/about.md)
+ * - Proxy rewrites .md URLs and Accept: text/markdown requests to the API route
+ * - Route handlers live under /api/ so page.tsx can coexist at the public path
+ */
+
+/** .md extension routes -- rewrite to API endpoints */
+export const mdExtensionRoutes: MarkdownRoute[] = [
+	{
+		regex: /^\/(.+)\.md$/,
+		apiPath: "/api/[slug].md",
+		publicPath: "/[slug].md",
+	},
+];
+
+/** Accept: text/markdown routes -- content negotiation for HTML pages */
+export const acceptHeaderRoutes: MarkdownRoute[] = [
+	{
+		regex: /^\/(.+)$/,
+		apiPath: "/api/[slug].md",
+		publicPath: "/[slug].md",
+	},
+];
+
+/**
+ * Paths the proxy should never process.
+ * Studio, static files, Next.js internals.
+ */
+export const ignoredPaths = [
+	"/studio",
+	"/api/",
+	"/_next/",
+	"/favicon.ico",
+	"/sitemap.md",
+];

package/src/modules/features/cms/sanity-pagebuilder/files/lib/integrations/sanity/page-builder-config.ts

@@ -0,0 +1,130 @@
+import { contentIcon, pageIcon, type SanityStudioIcon } from "./icons";
+import { singletonComponents } from "./singletons";
+
+export type PageBuilderDocumentType =
+	| "hero"
+	| "description"
+	| "blogContent"
+	| (typeof singletonComponents)[number]["schemaType"];
+
+type PageBuilderReferenceMember = {
+	documentType: PageBuilderDocumentType;
+	name: string;
+	title: string;
+	documentId?: string;
+	groups: PageBuilderGroupName[];
+};
+
+export type PageBuilderGroupName = "generic" | "blogEntry";
+
+export const pageBuilderPageTypes: Array<{
+	title: string;
+	value: PageBuilderGroupName;
+}> = [
+	{ title: "Generic", value: "generic" },
+	{ title: "Blog Entry", value: "blogEntry" },
+];
+
+const pageCategoryIcons: Record<PageBuilderGroupName, SanityStudioIcon> = {
+	generic: pageIcon,
+	blogEntry: contentIcon,
+};
+
+export const getPageCategoryIcon = (
+	pageType: PageBuilderGroupName | undefined | null,
+) => pageCategoryIcons[pageType ?? "generic"];
+
+const reusablePageBuilderReferenceMembers: PageBuilderReferenceMember[] = [
+	{
+		documentType: "hero",
+		name: "heroReference",
+		title: "Heading",
+		groups: ["generic"],
+	},
+	{
+		documentType: "description",
+		name: "descriptionReference",
+		title: "Description",
+		groups: ["generic"],
+	},
+	{
+		documentType: "blogContent",
+		name: "blogContentReference",
+		title: "Blog Content",
+		groups: ["blogEntry"],
+	},
+];
+
+const singletonPageBuilderReferenceMembers: PageBuilderReferenceMember[] =
+	singletonComponents.map((component) => ({
+		documentType: component.schemaType,
+		name: `${component.schemaType}Reference`,
+		title: component.title,
+		documentId: component.documentId,
+		groups: ["generic"],
+	}));
+
+export const pageBuilderReferenceMembers: PageBuilderReferenceMember[] = [
+	...reusablePageBuilderReferenceMembers,
+	...singletonPageBuilderReferenceMembers,
+];
+
+export const getPageBuilderReferenceMember = (name: string) =>
+	pageBuilderReferenceMembers.find((member) => member.name === name);
+
+export const getPageBuilderReferenceMemberByDocumentType = (
+	documentType: PageBuilderDocumentType,
+) =>
+	pageBuilderReferenceMembers.find(
+		(member) => member.documentType === documentType,
+	);
+
+const isPageBuilderGroupVisible = (
+	pageType: PageBuilderGroupName | undefined,
+	group: PageBuilderGroupName,
+) => (pageType ?? "generic") === group;
+
+export const getVisiblePageBuilderReferenceMembers = (
+	pageType: PageBuilderGroupName | undefined,
+) =>
+	pageBuilderReferenceMembers.filter((member) =>
+		member.groups.some((group) => isPageBuilderGroupVisible(pageType, group)),
+	);
+
+export const getVisiblePageBuilderInsertMenuGroups = (
+	pageType: PageBuilderGroupName | undefined,
+) =>
+	pageBuilderInsertMenuGroups.filter(
+		(group) => group.name === (pageType ?? "generic"),
+	);
+
+export const getInvalidPageBuilderDocumentTypes = (
+	pageType: PageBuilderGroupName | undefined,
+	documentTypes: PageBuilderDocumentType[],
+) =>
+	documentTypes.filter((documentType) => {
+		const member = getPageBuilderReferenceMemberByDocumentType(documentType);
+
+		if (!member) return false;
+
+		return !member.groups.some((group) =>
+			isPageBuilderGroupVisible(pageType, group),
+		);
+	});
+
+export const pageBuilderInsertMenuGroups = [
+	{
+		name: "generic",
+		title: "Generic",
+		of: pageBuilderReferenceMembers
+			.filter((member) => member.groups.includes("generic"))
+			.map((member) => member.name),
+	},
+	{
+		name: "blogEntry",
+		title: "Blog Entry",
+		of: pageBuilderReferenceMembers
+			.filter((member) => member.groups.includes("blogEntry"))
+			.map((member) => member.name),
+	},
+];

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

@@ -0,0 +1,28 @@
+import type { PageBuilderGroupName } from "@/lib/integrations/sanity/page-builder-config";
+
+type PageCategoryParams = {
+	slug?: string | null;
+	folder?: string | null;
+};
+
+export const isEmptyPageSlug = (slug?: string | null) =>
+	slug == null || slug === "" || slug === "/";
+
+export const getGeneratedPageCategory = ({
+	slug,
+	folder,
+}: PageCategoryParams): PageBuilderGroupName => {
+	if (!isEmptyPageSlug(slug) && folder === "blog") return "blogEntry";
+
+	return "generic";
+};
+
+export const pageCategoryExpression = `
+  select(
+    defined(slug.current) &&
+      slug.current != "" &&
+      slug.current != "/" &&
+      pageFolder->slug.current == "blog" => "blogEntry",
+    "generic"
+  )
+`;