bsmnt 0.7.0 → 0.9.0

package/src/modules/features/cms/sanity-pagebuilder/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/files/lib/integrations/sanity/icons.ts

@@ -15,6 +15,7 @@ import {
 	LayoutIcon,
 	ListBulletsIcon,
 	ListIcon,
+	LockKeyIcon,
 	PackageIcon,
 	PushPinIcon,
 	QuestionIcon,
@@ -71,6 +72,7 @@ export const customJsonLdIcon = asDuotoneIcon(BracketsCurlyIcon);
 export const heroIcon = asDuotoneIcon(RocketIcon);
 export const descriptionIcon = asDuotoneIcon(TextAlignLeftIcon);
 export const contentIcon = asDuotoneIcon(ArticleNyTimesIcon);
+export const gatedContentIcon = asDuotoneIcon(LockKeyIcon);
 
 export const pageIcon = asDuotoneIcon(FileTextIcon);
 export const pinIcon = asDuotoneIcon(PushPinIcon);

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

@@ -4,6 +4,7 @@ import { singletonComponents } from "./singletons";
 export type PageBuilderDocumentType =
 	| "hero"
 	| "description"
+	| "gatedContent"
 	| "blogContent"
 	| (typeof singletonComponents)[number]["schemaType"];
 
@@ -47,6 +48,12 @@ const reusablePageBuilderReferenceMembers: PageBuilderReferenceMember[] = [
 		title: "Description",
 		groups: ["generic"],
 	},
+	{
+		documentType: "gatedContent",
+		name: "gatedContentReference",
+		title: "Gated Content",
+		groups: ["generic"],
+	},
 	{
 		documentType: "blogContent",
 		name: "blogContentReference",

package/src/modules/features/cms/sanity-pagebuilder/files/lib/integrations/sanity/page-tree-pane.tsx

@@ -198,12 +198,10 @@ export const PageTreePane = ({ options }: PageTreePaneProps) => {
 			{showPinned && (
 				<Stack>
 					{PINNED_PAGE_ENTRIES.map((entry) => {
-						const activeState: ActiveState =
-							activeChildId === entry.id
-								? isLeafPane
-									? "leaf"
-									: "ancestor"
-								: "none";
+						let activeState: ActiveState = "none";
+						if (activeChildId === entry.id) {
+							activeState = isLeafPane ? "leaf" : "ancestor";
+						}
 						return (
 							<PinnedRow
 								key={entry.id}

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

@@ -54,38 +54,89 @@ const richTextLinkProjection = `
   }
 `;
 
+// `^` is the owning page document, so blocks whose `_key` is in the page's
+// `hiddenPageBuilderKeys` list are filtered out here — a single choke point, so
+// hidden blocks never reach the renderer, the preview, or any derived output
+// built from this projection. `coalesce(..., [])` keeps pages that predate the
+// field (no hidden blocks) rendering normally.
 const pageBuilderProjection = `
-  pageBuilder[]{
+  pageBuilder[!(_key in coalesce(^.hiddenPageBuilderKeys, []))]{
     _key,
     ...@->{
-      ...,
-      _type == "blogContent" => {
-        ...,
-        categories[]->{
-          _id,
-          title,
-          slug
-        },
-        author->{
-          _id,
-          name,
-          avatar,
-          role
-        },
-        body[]{
+      // Gated content withholds its payload from the page query — only the
+      // teaser and gate config ship to the client. GROQ has no field exclusion,
+      // so this branch lists safe fields explicitly rather than spreading every
+      // field. The payload is fetched separately via GATED_CONTENT_QUERY.
+      _type == "gatedContent" => {
+        _id,
+        _type,
+        internalTitle,
+        teaserHeading,
+        teaserBody[]{
           ${richTextLinkProjection}
         },
-        relatedPosts[]->{
-          _id,
-          title,
-          "resolvedSlug": ${pageResolvedSlugExpression},
-          metadata
+        gateType,
+        gateHeadline,
+        gateDescription,
+        submitLabel,
+        successMessage,
+        kind
+      },
+      _type != "gatedContent" => {
+        ...,
+        _type == "blogContent" => {
+          ...,
+          categories[]->{
+            _id,
+            title,
+            slug
+          },
+          author->{
+            _id,
+            name,
+            avatar,
+            role
+          },
+          body[]{
+            ${richTextLinkProjection}
+          },
+          relatedPosts[]->{
+            _id,
+            title,
+            "resolvedSlug": ${pageResolvedSlugExpression},
+            metadata
+          }
         }
       }
     }
   }
 `;
 
+// Gated content payload — fetched on demand by the unlock server action, keyed
+// by the block's document id. Kept out of the page query so it never ships to
+// the client until the visitor completes the gate.
+export const GATED_CONTENT_QUERY = defineQuery(`
+  *[_type == "gatedContent" && _id == $id][0]{
+    kind,
+    content[]{
+      ${richTextLinkProjection}
+    },
+    "file": file.asset->{
+      url,
+      originalFilename,
+      mimeType,
+      size
+    },
+    "video": {
+      "url": videoUrl,
+      "file": videoFile.asset->{
+        url,
+        mimeType
+      }
+    }
+  }
+`);
+
 const pageProjection = `
   _id,
   _type,

package/src/modules/features/cms/sanity-pagebuilder/files/lib/integrations/sanity/schemas/components/index.ts

@@ -1,4 +1,5 @@
 export { blogContent } from "./reusable/blog-content";
 export { description } from "./reusable/description";
+export { gatedContent } from "./reusable/gated-content";
 export { hero } from "./reusable/hero";
 export { blogCollection } from "./singleton/content-collection";

package/src/modules/features/cms/sanity-pagebuilder/files/lib/integrations/sanity/schemas/components/reusable/gated-content.ts

@@ -0,0 +1,178 @@
+import { defineField, defineType } from "sanity";
+import { gatedContentIcon } from "@/lib/integrations/sanity/icons";
+
+type GatedContentParent = { kind?: string };
+
+const getKindLabel = (kind: unknown) => {
+	if (kind === "file") return "File";
+	if (kind === "video") return "Video";
+	return "Rich Text";
+};
+
+const requiredForKind =
+	(kind: string, message: string) =>
+	(value: unknown, context: { parent?: unknown }) => {
+		const parent = context.parent as GatedContentParent | undefined;
+		if (parent?.kind !== kind) return true;
+		const isEmpty =
+			value == null || (Array.isArray(value) && value.length === 0);
+		return isEmpty ? message : true;
+	};
+
+export const gatedContent = defineType({
+	name: "gatedContent",
+	title: "Gated Content",
+	type: "document",
+	icon: gatedContentIcon,
+	description:
+		"Content hidden behind a lead-capture gate. Everyone sees the teaser; the payload is withheld from the page until the visitor submits the form.",
+	groups: [
+		{ name: "teaser", title: "Teaser", default: true },
+		{ name: "gate", title: "Gate" },
+		{ name: "content", title: "Gated Content" },
+	],
+	fields: [
+		defineField({
+			name: "internalTitle",
+			title: "Internal Title",
+			type: "string",
+			description: "Only used to identify this block in the Studio.",
+			validation: (Rule) => Rule.required(),
+		}),
+		defineField({
+			name: "teaserHeading",
+			title: "Teaser Heading",
+			type: "string",
+			group: "teaser",
+		}),
+		defineField({
+			name: "teaserBody",
+			title: "Teaser Body",
+			type: "richText",
+			group: "teaser",
+			description: "Shown to everyone, above the gate.",
+		}),
+		defineField({
+			name: "gateType",
+			title: "Unlock With",
+			type: "string",
+			group: "gate",
+			initialValue: "form",
+			options: {
+				list: [{ title: "Form submission", value: "form" }],
+				layout: "radio",
+			},
+			validation: (Rule) => Rule.required(),
+		}),
+		defineField({
+			name: "gateHeadline",
+			title: "Gate Headline",
+			type: "string",
+			group: "gate",
+			initialValue: "Unlock the full content",
+		}),
+		defineField({
+			name: "gateDescription",
+			title: "Gate Description",
+			type: "text",
+			rows: 3,
+			group: "gate",
+		}),
+		defineField({
+			name: "submitLabel",
+			title: "Submit Button Label",
+			type: "string",
+			group: "gate",
+			initialValue: "Unlock",
+		}),
+		defineField({
+			name: "successMessage",
+			title: "Success Message",
+			type: "string",
+			group: "gate",
+			description: "Shown briefly after the gate is unlocked.",
+		}),
+		defineField({
+			name: "kind",
+			title: "Content Type",
+			type: "string",
+			group: "content",
+			initialValue: "richText",
+			options: {
+				list: [
+					{ title: "Rich Text", value: "richText" },
+					{ title: "File (PDF, etc.)", value: "file" },
+					{ title: "Video", value: "video" },
+				],
+				layout: "radio",
+			},
+			validation: (Rule) => Rule.required(),
+		}),
+		defineField({
+			name: "content",
+			title: "Rich Text",
+			type: "richText",
+			group: "content",
+			description: "Revealed once the visitor completes the unlock action.",
+			hidden: ({ parent }) => (parent as GatedContentParent)?.kind !== "richText",
+			validation: (Rule) =>
+				Rule.custom(requiredForKind("richText", "Rich text is required.")),
+		}),
+		defineField({
+			name: "file",
+			title: "File",
+			type: "file",
+			group: "content",
+			description: "PDF or other downloadable asset, revealed on unlock.",
+			options: { accept: ".pdf,.doc,.docx,.zip,.epub,.csv,.xlsx" },
+			hidden: ({ parent }) => (parent as GatedContentParent)?.kind !== "file",
+			validation: (Rule) =>
+				Rule.custom((value: unknown, context) => {
+					const parent = context.parent as GatedContentParent | undefined;
+					if (parent?.kind !== "file") return true;
+					const asset = (value as { asset?: unknown } | undefined)?.asset;
+					return asset ? true : "A file is required.";
+				}),
+		}),
+		defineField({
+			name: "videoUrl",
+			title: "Video URL",
+			type: "url",
+			group: "content",
+			description: "External embed URL (YouTube, Vimeo, Mux…).",
+			hidden: ({ parent }) => (parent as GatedContentParent)?.kind !== "video",
+		}),
+		defineField({
+			name: "videoFile",
+			title: "Video File",
+			type: "file",
+			group: "content",
+			description: "Uploaded video, used when no Video URL is set.",
+			options: { accept: "video/*" },
+			hidden: ({ parent }) => (parent as GatedContentParent)?.kind !== "video",
+			validation: (Rule) =>
+				Rule.custom((value: unknown, context) => {
+					const parent = context.parent as
+						| (GatedContentParent & { videoUrl?: string })
+						| undefined;
+					if (parent?.kind !== "video") return true;
+					const asset = (value as { asset?: unknown } | undefined)?.asset;
+					if (parent?.videoUrl || asset) return true;
+					return "Add a Video URL or upload a video file.";
+				}),
+		}),
+	],
+	preview: {
+		select: {
+			title: "internalTitle",
+			heading: "teaserHeading",
+			kind: "kind",
+		},
+		prepare({ title, heading, kind }) {
+			return {
+				title: title || heading || "Gated Content",
+				subtitle: `Gated Content · ${getKindLabel(kind)}`,
+			};
+		},
+	},
+});

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

@@ -8,7 +8,13 @@
  */
 
 import type { SchemaTypeDefinition } from "sanity";
-import { blogCollection, blogContent, description, hero } from "./components";
+import {
+	blogCollection,
+	blogContent,
+	description,
+	gatedContent,
+	hero,
+} from "./components";
 import { author } from "./content/author";
 import { blogCategory } from "./content/blog-category";
 import { companyData } from "./layout/company-data";
@@ -51,6 +57,7 @@ export {
 	externalLink,
 	faqJsonLd,
 	footer,
+	gatedContent,
 	hero,
 	itemListJsonLd,
 	jobPostingJsonLd,
@@ -103,6 +110,7 @@ export const schema: { types: SchemaTypeDefinition[] } = {
 		blogContent,
 		hero,
 		description,
+		gatedContent,
 
 		// Layout types (singletons for site-wide layout)
 		companyData,

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

@@ -106,11 +106,12 @@ export const redirect = defineType({
 			permanent: "permanent",
 		},
 		prepare({ source, destination, permanent }) {
-			const target = destination
-				? /^https?:\/\//.test(destination)
+			let target = "?";
+			if (destination) {
+				target = /^https?:\/\//.test(destination)
 					? destination
-					: `/${destination}`
-				: "?";
+					: `/${destination}`;
+			}
 			return {
 				title: source ? `/${source}` : "Untitled redirect",
 				subtitle: `→ ${target} (${permanent ? "308" : "307"})`,

package/src/modules/features/cms/sanity-pagebuilder/files/lib/integrations/sanity/schemas/shared/metadata.ts

@@ -9,12 +9,18 @@ export const metadata = defineType({
 		collapsible: true,
 		collapsed: true,
 	},
+	groups: [
+		{ name: "search", title: "Search", default: true },
+		{ name: "social", title: "Social sharing" },
+		{ name: "advanced", title: "Advanced" },
+	],
 	fields: [
 		defineField({
 			name: "metaTitle",
 			title: "Meta Title",
 			type: "string",
-			description: "Title used by search engines",
+			group: "search",
+			description: "Title used by search engines and browser tabs",
 			validation: (Rule) =>
 				Rule.max(60).warning(
 					"Title should be under 60 characters for optimal SEO",
@@ -25,25 +31,71 @@ export const metadata = defineType({
 			title: "Meta Description",
 			type: "text",
 			rows: 3,
+			group: "search",
 			description: "Description used by search engines",
 			validation: (Rule) =>
 				Rule.max(160).warning(
 					"Description should be under 160 characters for optimal SEO",
 				),
 		}),
+		defineField({
+			name: "keywords",
+			title: "Keywords",
+			type: "array",
+			group: "search",
+			of: [defineArrayMember({ type: "string" })],
+			options: { layout: "tags" },
+			description:
+				"Optional keywords/topics for this page. Press Enter after each.",
+		}),
 		defineField({
 			name: "image",
 			title: "OG Image",
 			type: "image",
+			group: "social",
 			description: "Image for social sharing previews (1200x630px recommended)",
 			options: {
 				hotspot: true,
 			},
 		}),
+		defineField({
+			name: "ogTitle",
+			title: "Social Title",
+			type: "string",
+			group: "social",
+			description:
+				"Title shown when shared on social (Open Graph & Twitter). Falls back to Meta Title.",
+			validation: (Rule) =>
+				Rule.max(70).warning("Social titles are often truncated past ~70 chars"),
+		}),
+		defineField({
+			name: "ogDescription",
+			title: "Social Description",
+			type: "text",
+			rows: 3,
+			group: "social",
+			description:
+				"Description shown when shared on social. Falls back to Meta Description.",
+			validation: (Rule) =>
+				Rule.max(200).warning(
+					"Social descriptions are often truncated past ~200 chars",
+				),
+		}),
+		defineField({
+			name: "canonicalUrl",
+			title: "Canonical URL",
+			type: "url",
+			group: "advanced",
+			description:
+				"Override the canonical URL for this page. Leave blank to use the page's own URL. Use for duplicate/syndicated content.",
+			validation: (Rule) =>
+				Rule.uri({ scheme: ["http", "https"], allowRelative: true }),
+		}),
 		defineField({
 			name: "index",
 			title: "Index",
 			type: "boolean",
+			group: "advanced",
 			description: "Allow search engines to index this page",
 			initialValue: true,
 		}),
@@ -51,6 +103,7 @@ export const metadata = defineType({
 			name: "jsonLd",
 			title: "Structured Data (JSON-LD)",
 			type: "array",
+			group: "advanced",
 			description:
 				"Page-level schema.org structured data emitted as JSON-LD. Pick a predefined type, or add a Custom JSON-LD block for anything not listed.",
 			of: pageJsonLdMembers.map((member) =>

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

@@ -1,4 +1,5 @@
 import { defineArrayMember, defineType } from "sanity";
+import { BlockActionsItem } from "@/lib/integrations/sanity/components/block-actions-item";
 import { PageBuilderInput } from "@/lib/integrations/sanity/components/page-builder-input";
 import {
 	pageBuilderInsertMenuGroups,
@@ -22,6 +23,9 @@ export const pageBuilder = defineType({
 			title: member.title,
 			type: "reference",
 			to: [{ type: member.documentType }],
+			// Per-placement Hide/Show action; hidden state lives in the owning
+			// document's `hiddenPageBuilderKeys`, not on the ref itself.
+			components: { item: BlockActionsItem },
 			...(member.documentId
 				? {
 						options: {

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

@@ -204,6 +204,17 @@ export const page = defineType({
 					return `These page builder components do not belong to the "${pageType ?? "generic"}" category: ${invalidMemberTitles.join(", ")}`;
 				}),
 		}),
+		defineField({
+			name: "hiddenPageBuilderKeys",
+			title: "Hidden Blocks",
+			type: "array",
+			of: [{ type: "string" }],
+			// The `_key`s of page builder placements hidden on this page. Managed
+			// via each block's Hide/Show action (see BlockActionsItem); never edited
+			// directly. Declaring it keeps the Studio from warning about an unknown
+			// field. Filtered out at query time in `pageBuilderProjection`.
+			hidden: true,
+		}),
 		defineField({
 			name: "metadata",
 			title: "SEO & Metadata",

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

@@ -14,6 +14,7 @@ import {
 	contentFolderIcon,
 	contentIcon,
 	descriptionIcon,
+	gatedContentIcon,
 	heroIcon,
 	layoutFolderIcon,
 	pageFolderIcon,
@@ -294,6 +295,9 @@ export const structure: StructureResolver = (S, context) =>
 							S.documentTypeListItem("description")
 								.title("Descriptions")
 								.icon(descriptionIcon),
+							S.documentTypeListItem("gatedContent")
+								.title("Gated Content")
+								.icon(gatedContentIcon),
 							S.documentTypeListItem("blogContent")
 								.title("Blog Content")
 								.icon(contentIcon),

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

@@ -29,6 +29,26 @@ export const renderPageBuilderMarkdown = (
 					return block.headline ? [`## ${block.headline}`, ""] : [];
 				case "description":
 					return block.description ? [block.description, ""] : [];
+				case "gatedContent": {
+					// The gated payload is withheld from the page query, so it is not
+					// available here either — only the teaser is emitted, matching what
+					// the page ships before the gate is unlocked.
+					const lines: string[] = [];
+					if (block.teaserHeading) lines.push(`## ${block.teaserHeading}`, "");
+					if (block.teaserBody) {
+						lines.push(
+							portableTextToMarkdown(
+								block.teaserBody as Parameters<
+									typeof portableTextToMarkdown
+								>[0],
+								markdownOptions,
+							),
+							"",
+						);
+					}
+					lines.push("> Gated content — unlock on the page to view.", "");
+					return lines;
+				}
 				case "blogContent": {
 					const lines: (string | null)[] = [];
 					const categories =

package/src/modules/features/cms/sanity-pagebuilder/files/lib/scripts/sanity-typegen.ts

@@ -10,7 +10,7 @@ import { resolve } from "node:path";
 const sanityDir = resolve(import.meta.dir, "../integrations/sanity");
 
 if (!process.env.NEXT_PUBLIC_SANITY_PROJECT_ID) {
-	console.log(
+	console.info(
 		"  Skipping sanity:typegen — NEXT_PUBLIC_SANITY_PROJECT_ID not set",
 	);
 	process.exit(0);

package/src/modules/features/cms/sanity-pagebuilder/files/lib/utils/json-ld.tsx

@@ -27,6 +27,7 @@ const serializeJsonLd = <T extends Thing>(data: WithContext<T>) =>
 export const JsonLd = <T extends Thing>({ data }: JsonLdProps<T>) => (
 	<script
 		type="application/ld+json"
+		// biome-ignore lint/security/noDangerouslySetInnerHtml: serialized JSON-LD, not user HTML; `<` is escaped
 		dangerouslySetInnerHTML={{ __html: serializeJsonLd(data) }}
 	/>
 );