bsmnt 0.10.0 → 0.12.0

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",
+];

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

@@ -0,0 +1,182 @@
+import { contentIcon, pageIcon, type SanityStudioIcon } from "./icons";
+import { singletonComponents } from "./singletons";
+
+export type PageBuilderDocumentType =
+	| "hero"
+	| "description"
+	| "richTextBlock"
+	| "gatedContent"
+	| "blogContent"
+	| (typeof singletonComponents)[number]["schemaType"];
+
+/**
+ * A block declares two orthogonal axes. `pageTypes` is which page documents may
+ * host it and drives validation; `category` is what the block structurally is
+ * and drives the insert menu. Never collapse them back into one field — that is
+ * what made the menu a single flat list.
+ */
+export type PageBuilderGroupName = "generic" | "blogEntry";
+
+export const componentCategories = [
+	{ name: "hero", title: "Hero" },
+	{ name: "text", title: "Text" },
+	{ name: "list", title: "List" },
+	{ name: "content", title: "Content" },
+	{ name: "misc", title: "Miscellaneous" },
+] as const satisfies ReadonlyArray<{ name: string; title: string }>;
+
+export type ComponentCategory = (typeof componentCategories)[number]["name"];
+
+type PageBuilderReferenceMember = {
+	documentType: PageBuilderDocumentType;
+	name: string;
+	title: string;
+	documentId?: string;
+	pageTypes: readonly PageBuilderGroupName[];
+	category: ComponentCategory;
+};
+
+export const blockPreviewKey = (schemaTypeName: string) =>
+	`block.${schemaTypeName}`;
+
+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",
+		pageTypes: ["generic"],
+		category: "hero",
+	},
+	{
+		documentType: "description",
+		name: "descriptionReference",
+		title: "Description",
+		pageTypes: ["generic"],
+		category: "text",
+	},
+	{
+		documentType: "richTextBlock",
+		name: "richTextBlockReference",
+		title: "Rich Text",
+		pageTypes: ["generic"],
+		category: "text",
+	},
+	{
+		documentType: "gatedContent",
+		name: "gatedContentReference",
+		title: "Gated Content",
+		pageTypes: ["generic"],
+		category: "misc",
+	},
+	{
+		documentType: "blogContent",
+		name: "blogContentReference",
+		title: "Blog Content",
+		pageTypes: ["blogEntry"],
+		category: "content",
+	},
+];
+
+const singletonPageBuilderReferenceMembers: PageBuilderReferenceMember[] =
+	singletonComponents.map((component) => ({
+		documentType: component.schemaType,
+		name: `${component.schemaType}Reference`,
+		title: component.title,
+		documentId: component.documentId,
+		pageTypes: ["generic"],
+		category: component.category,
+	}));
+
+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 isMemberVisibleForPageType = (
+	member: PageBuilderReferenceMember,
+	pageType: PageBuilderGroupName | undefined,
+) => member.pageTypes.includes(pageType ?? "generic");
+
+export const getVisiblePageBuilderReferenceMembers = (
+	pageType: PageBuilderGroupName | undefined,
+) =>
+	pageBuilderReferenceMembers.filter((member) =>
+		isMemberVisibleForPageType(member, pageType),
+	);
+
+export const getVisiblePageBuilderMemberNames = (
+	pageType: PageBuilderGroupName | undefined,
+) =>
+	new Set(
+		getVisiblePageBuilderReferenceMembers(pageType).map((member) => member.name),
+	);
+
+export const getVisiblePageBuilderInsertMenuGroups = (
+	pageType: PageBuilderGroupName | undefined,
+) => {
+	const visible = getVisiblePageBuilderMemberNames(pageType);
+	return pageBuilderInsertMenuGroups
+		.map((group) => ({
+			...group,
+			of: group.of.filter((name) => visible.has(name)),
+		}))
+		.filter((group) => group.of.length > 0);
+};
+
+export const getInvalidPageBuilderDocumentTypes = (
+	pageType: PageBuilderGroupName | undefined,
+	documentTypes: PageBuilderDocumentType[],
+) =>
+	documentTypes.filter((documentType) => {
+		const member = getPageBuilderReferenceMemberByDocumentType(documentType);
+
+		if (!member) return false;
+
+		return !isMemberVisibleForPageType(member, pageType);
+	});
+
+export const pageBuilderInsertMenuGroups: Array<{
+	name: ComponentCategory;
+	title: string;
+	of: string[];
+}> = componentCategories.map(({ name, title }) => ({
+	name,
+	title,
+	of: pageBuilderReferenceMembers
+		.filter((member) => member.category === name)
+		.map((member) => member.name),
+}));
+
+export const pageBuilderBlockPreviewOptions = pageBuilderReferenceMembers.map(
+	(member) => ({
+		title: `Block — ${member.title} · ${member.name}`,
+		value: blockPreviewKey(member.name),
+	}),
+);

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