bsmnt 0.9.0 → 0.11.0

package/src/modules/features/cms/sanity-pagebuilder-cache/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-cache/files/lib/integrations/sanity/components/slug-field.tsx

@@ -0,0 +1,24 @@
+import { Stack } from "@sanity/ui";
+import { type FieldProps, useFormValue } from "sanity";
+import { SlugRedirectNotice } from "@/lib/integrations/sanity/components/slug-notices";
+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 on pinned pages (plain-string field, hence 📌).
+export function SlugField(props: FieldProps) {
+	const documentId = useFormValue(["_id"]) as string | undefined;
+	const pinned = getPinnedPageById(documentId);
+
+	return (
+		<Stack space={3}>
+			{props.renderDefault({
+				...props,
+				description: pinned ? PINNED_DESCRIPTION : DEFAULT_DESCRIPTION,
+			})}
+			<SlugRedirectNotice pinnedPath={pinned?.path} />
+		</Stack>
+	);
+}

package/src/modules/features/cms/sanity-pagebuilder-cache/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-cache/files/lib/integrations/sanity/components/slug-notices.tsx

@@ -0,0 +1,125 @@
+import { Box, Button, Card, Stack, Text } from "@sanity/ui";
+import { useEffect, useState } from "react";
+import { useClient, useFormValue } from "sanity";
+import { useRouter } from "sanity/router";
+import { apiVersion } from "@/lib/integrations/sanity/env";
+import { isEmptyPageSlug } from "@/lib/integrations/sanity/page-category";
+import { FOLDER_PATH_QUERY } from "@/lib/integrations/sanity/queries";
+
+const REDIRECT_QUERY = `*[_type == "redirect" && source.current == $source][0]._id`;
+
+// The slug field writes on every keystroke.
+const LOOKUP_DEBOUNCE_MS = 400;
+
+interface SlugRedirectNoticeProps {
+	/** Public path of a pinned page, whose URL is fixed rather than slug-derived. */
+	pinnedPath?: string | undefined;
+}
+
+/**
+ * Warns when a published redirect claims this page's URL — the catch-all
+ * route only runs `checkRedirect` after a page lookup misses, so the page
+ * wins and the redirect silently never fires.
+ *
+ * Reads the `page` form shape; don't reuse for other slug types.
+ */
+export function SlugRedirectNotice({ pinnedPath }: SlugRedirectNoticeProps) {
+	const client = useClient({ apiVersion });
+	const router = useRouter();
+	const slug = useFormValue(["slug", "current"]) as string | undefined;
+	const folderId = useFormValue(["pageFolder", "_ref"]) as string | undefined;
+	const [folderPath, setFolderPath] = useState("");
+	const [redirectId, setRedirectId] = useState<string | null>(null);
+
+	// Separate effect so the folder chain isn't re-resolved on every keystroke.
+	useEffect(() => {
+		if (!folderId) {
+			setFolderPath("");
+			return;
+		}
+
+		let active = true;
+		const published = client.withConfig({ perspective: "published" });
+
+		published
+			// Leaf joins in JS below, so this tracks the live slug rather than the
+			// last saved draft.
+			.fetch<{ path: string | null } | null>(FOLDER_PATH_QUERY, { folderId })
+			.then((folder) => {
+				if (active) setFolderPath(folder?.path ?? "");
+			})
+			.catch(() => {
+				if (active) setFolderPath("");
+			});
+
+		return () => {
+			active = false;
+		};
+	}, [client, folderId]);
+
+	useEffect(() => {
+		const leaf = isEmptyPageSlug(slug) ? "" : slug;
+		const source = pinnedPath
+			? pinnedPath.replace(/^\/+/, "")
+			: [folderPath, leaf].filter(Boolean).join("/");
+
+		if (!source) {
+			setRedirectId(null);
+			return;
+		}
+
+		let active = true;
+		// Drafts never reach visitors, so an unpublished redirect isn't a conflict.
+		const published = client.withConfig({ perspective: "published" });
+
+		const timer = setTimeout(async () => {
+			try {
+				const id = await published.fetch<string | null>(REDIRECT_QUERY, {
+					source,
+				});
+				if (active) setRedirectId(id);
+			} catch {
+				if (active) setRedirectId(null);
+			}
+		}, LOOKUP_DEBOUNCE_MS);
+
+		return () => {
+			active = false;
+			clearTimeout(timer);
+		};
+	}, [client, folderPath, pinnedPath, slug]);
+
+	if (!redirectId) return null;
+
+	return (
+		<Card border padding={3} radius={2} tone="caution">
+			<Stack space={3}>
+				<Stack space={2}>
+					<Text size={1} weight="semibold">
+						A redirect already claims this URL
+					</Text>
+					<Text muted size={1}>
+						Visitors reach this page instead — a redirect only runs when no page
+						matches its path. Remove the redirect, or move this page to another
+						slug.
+					</Text>
+				</Stack>
+				<Box>
+					<Button
+						fontSize={1}
+						mode="ghost"
+						onClick={() =>
+							router.navigateIntent("edit", {
+								id: redirectId,
+								type: "redirect",
+							})
+						}
+						padding={3}
+						text="Go to redirect"
+						tone="caution"
+					/>
+				</Box>
+			</Stack>
+		</Card>
+	);
+}

package/src/modules/features/cms/sanity-pagebuilder-cache/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-cache/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.
+ */
+
+/** Floor, not a preference: Content Releases need 2025-02-19 or later. */
+export const apiVersion =
+	process.env.NEXT_PUBLIC_SANITY_API_VERSION || "2025-02-19";
+
+/** 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-cache/files/lib/integrations/sanity/fetchers/layout.ts

@@ -0,0 +1,39 @@
+import {
+  type DynamicFetchOptions,
+  sanityFetch,
+  toSanityFetchOptions,
+} from "@/lib/integrations/sanity/live"
+import { LAYOUT_QUERY } from "@/lib/integrations/sanity/queries"
+import type { LAYOUT_QUERY_RESULT } from "@/lib/integrations/sanity/sanity.types"
+import { SANITY_LAYOUT_TAGS } from "@/lib/integrations/sanity/tags"
+
+export type LayoutData = LAYOUT_QUERY_RESULT
+export type NavbarData = NonNullable<LayoutData["navbar"]>
+export type FooterData = NonNullable<LayoutData["footer"]>
+export type CompanyData = NonNullable<LayoutData["companyData"]>
+export type StructuredData = NonNullable<LayoutData["structuredData"]>
+
+const EMPTY_LAYOUT: LayoutData = {
+  navbar: null,
+  footer: null,
+  companyData: null,
+  structuredData: null,
+}
+
+// One entry for all four layout singletons: header, footer and json-ld call this
+// with the same options, so they share one fetch instead of four.
+//
+// Don't cap the empty branch — this renders in every route's shell, and a nested
+// lifetime propagates upwards as a min().
+export async function getLayoutData(
+  fetchOptions: DynamicFetchOptions
+): Promise<LayoutData> {
+  "use cache"
+  const { data } = await sanityFetch({
+    query: LAYOUT_QUERY,
+    ...toSanityFetchOptions(fetchOptions),
+    tags: [...SANITY_LAYOUT_TAGS],
+  })
+
+  return (data as LayoutData | null) ?? EMPTY_LAYOUT
+}

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

@@ -0,0 +1,22 @@
+import {
+  PUBLISHED_FETCH_OPTIONS,
+  sanityFetch,
+  toSanityFetchOptions,
+} from "@/lib/integrations/sanity/live"
+import { REDIRECTS_QUERY } from "@/lib/integrations/sanity/queries"
+import type { REDIRECTS_QUERY_RESULT } from "@/lib/integrations/sanity/sanity.types"
+import { SANITY_REDIRECTS_TAG } from "@/lib/integrations/sanity/tags"
+
+export type RedirectEntry = REDIRECTS_QUERY_RESULT[number]
+
+// Routing infra, not preview content — always read published and cache it.
+export async function getRedirects(): Promise<REDIRECTS_QUERY_RESULT> {
+  "use cache"
+  const { data } = await sanityFetch({
+    query: REDIRECTS_QUERY,
+    ...toSanityFetchOptions(PUBLISHED_FETCH_OPTIONS),
+    tags: [SANITY_REDIRECTS_TAG],
+  })
+
+  return (data as REDIRECTS_QUERY_RESULT | null) ?? []
+}

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

@@ -0,0 +1,81 @@
+import type { Icon, IconProps } from "@phosphor-icons/react";
+import {
+	AppWindowIcon,
+	ArrowBendUpRightIcon,
+	ArticleNyTimesIcon,
+	BracketsCurlyIcon,
+	BriefcaseIcon,
+	BrowsersIcon,
+	BuildingsIcon,
+	CalendarBlankIcon,
+	CardsIcon,
+	FileTextIcon,
+	FolderOpenIcon,
+	FootprintsIcon,
+	LayoutIcon,
+	ListBulletsIcon,
+	ListIcon,
+	LockKeyIcon,
+	PackageIcon,
+	QuestionIcon,
+	RocketIcon,
+	ShapesIcon,
+	ShareNetworkIcon,
+	TagIcon,
+	TextAlignLeftIcon,
+	TextTIcon,
+	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 richTextIcon = asDuotoneIcon(TextTIcon);
+export const contentIcon = asDuotoneIcon(ArticleNyTimesIcon);
+export const gatedContentIcon = asDuotoneIcon(LockKeyIcon);
+
+export const pageIcon = asDuotoneIcon(FileTextIcon);
+export const pagesFolderIcon = asDuotoneIcon(BrowsersIcon);
+export const pageFolderIcon = asDuotoneIcon(FolderOpenIcon);
+export const contentFolderIcon = asDuotoneIcon(FolderOpenIcon);

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

@@ -0,0 +1,140 @@
+import { cacheLife, cacheTag } from "next/cache";
+import type { QueryParams } from "next-sanity";
+import {
+	defineLive,
+	type LivePerspective,
+	resolvePerspectiveFromCookies,
+	resolveVariantFromCookies,
+	type StrictDefinedFetchType,
+	type StrictDefinedLiveProps,
+} from "next-sanity/live";
+import { cookies, draftMode } from "next/headers";
+import type { ComponentType } from "react";
+import { isSanityConfigured } from "@/lib/integrations/check-integration";
+import { client } from "../client";
+import { sanityToken } from "../env";
+
+const isConfigured = isSanityConfigured() && client;
+
+// `strict: true` requires perspective/stega at every call site, resolved outside
+// the `'use cache'` boundary so published reads can land in the static shell.
+const liveExports =
+	isConfigured && client
+		? defineLive({
+				client,
+				browserToken: sanityToken ?? false,
+				serverToken: sanityToken ?? false,
+				strict: true,
+			})
+		: null;
+
+export interface DynamicFetchOptions {
+	perspective: LivePerspective;
+	stega: boolean;
+	// Required, not optional: absence is valid, but an optional key lets a call
+	// site drop it and serve base content to someone previewing a release.
+	variant: string | undefined;
+}
+
+// What every static branch reads. Shared so a new field can't be missed at one
+// call site.
+export const PUBLISHED_FETCH_OPTIONS: DynamicFetchOptions = {
+	perspective: "published",
+	stega: false,
+	variant: undefined,
+};
+
+// Under `exactOptionalPropertyTypes` an explicit `undefined` variant is a type
+// error, so raw `DynamicFetchOptions` can't be spread into a fetch. That's the
+// point: it forces call sites through here instead of dropping `variant`.
+export const toSanityFetchOptions = ({
+	perspective,
+	stega,
+	variant,
+}: DynamicFetchOptions) => ({
+	perspective,
+	stega,
+	...(variant === undefined ? {} : { variant }),
+});
+
+// Null-returning stubs keep the template buildable without Sanity env.
+const fallbackFetch = (async () => ({
+	data: null,
+	sourceMap: null,
+	tags: [],
+})) as unknown as StrictDefinedFetchType;
+
+export const sanityFetch: StrictDefinedFetchType =
+	liveExports?.sanityFetch ?? fallbackFetch;
+
+export const SanityLive: ComponentType<StrictDefinedLiveProps> =
+	liveExports?.SanityLive ?? (() => null);
+
+// Prerender-safe: `draftMode()` resolves false without bailing out, and
+// `cookies()` is only read once draft mode is on. `strict: true` disables
+// next-sanity's own cookie resolution, so the variant must be read here.
+export async function getDynamicFetchOptions(): Promise<DynamicFetchOptions> {
+	const { isEnabled: isDraftMode } = await draftMode();
+	if (!isDraftMode)
+		return { perspective: "published", stega: false, variant: undefined };
+
+	const jar = await cookies();
+	const [perspective, variant] = await Promise.all([
+		resolvePerspectiveFromCookies({ cookies: jar }),
+		resolveVariantFromCookies({ cookies: jar }),
+	]);
+	return { perspective: perspective ?? "drafts", stega: true, variant };
+}
+
+// For `generateStaticParams`: cookies aren't available at build time and stega
+// is never wanted in route params, so both are hardcoded.
+export async function sanityFetchStaticParams<T = unknown>({
+	query,
+	params = {},
+}: {
+	query: string;
+	params?: QueryParams;
+}): Promise<{ data: T | null }> {
+	"use cache";
+	const { data } = await sanityFetch({
+		query,
+		params,
+		...toSanityFetchOptions(PUBLISHED_FETCH_OPTIONS),
+	});
+	return { data: (data as T | null) ?? null };
+}
+
+// Cached read for contexts that render no DOM next to <VisualEditing>. `tags` is
+// required, not optional: the markdown route answers at /api/<slug>.md, which no
+// `revalidatePath` reaches, so an untagged entry is stranded for the ~1y lifetime.
+// Takes the whole options object and overrides `stega` itself, so call sites
+// can't hand-pick fields and drop `variant`.
+export async function sanityFetchCached<T = unknown>({
+	query,
+	params = {},
+	tags,
+	...fetchOptions
+}: {
+	query: string;
+	params?: QueryParams;
+	tags: string[];
+} & DynamicFetchOptions): Promise<{ data: T | null }> {
+	"use cache";
+	const { data } = await sanityFetch({
+		query,
+		params,
+		...toSanityFetchOptions(fetchOptions),
+		stega: false,
+	});
+	const result = (data as T | null) ?? null;
+
+	if (result === null) {
+		// No document, so no publish clears this — and any URL can mint one.
+		cacheLife("hours");
+	} else {
+		// Tagged on a hit only, for that same reason — mirrors `getCachedPage`.
+		cacheTag(...tags);
+	}
+
+	return { data: result };
+}

package/src/modules/features/cms/sanity-pagebuilder-cache/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",
+];