bsmnt 0.10.0 → 0.12.0

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

@@ -0,0 +1,116 @@
+import { table } from "@sanity/table";
+import { defineConfig } from "sanity";
+import { structureTool } from "sanity/structure";
+import { media } from "sanity-plugin-media";
+import { createConfirmPublishAction } from "./confirm-publish-action";
+import { dataset, projectId } from "./env";
+import { PINNED_PAGE_ENTRIES, PINNED_PAGE_IDS } from "./pinned-pages";
+import { presentation } from "./presentation";
+import { schema } from "./schemas";
+import { singletonComponentTypes } from "./singletons";
+import { structure } from "./structure";
+
+const isProd = process.env.NODE_ENV === "production";
+
+const singletonDocumentActions = new Set([
+	"publish",
+	"discardChanges",
+	"restore",
+]);
+
+const isSingletonDocument = (schemaType: string, documentId?: string) =>
+	singletonComponentTypes.has(schemaType) ||
+	(schemaType === "page" &&
+		documentId !== undefined &&
+		PINNED_PAGE_IDS.has(documentId));
+
+export default defineConfig({
+	basePath: "/studio",
+	projectId,
+	dataset,
+	// Content Releases is an Enterprise-only feature; hide it from the Studio.
+	releases: { enabled: false },
+	scheduledDrafts: { enabled: false },
+	schema: {
+		...schema,
+		templates: (previousTemplates) => [
+			...previousTemplates.filter(
+				(template) =>
+					!PINNED_PAGE_IDS.has(template.id) &&
+					!["page-with-folder", "page-folder-with-parent"].includes(
+						template.id,
+					),
+			),
+			...PINNED_PAGE_ENTRIES.map((entry) => ({
+				id: entry.id,
+				title: entry.title,
+				schemaType: "page",
+				value: {
+					title: entry.title,
+					...(entry.slug ? { slug: { current: entry.slug } } : {}),
+				},
+			})),
+			{
+				id: "page-with-folder",
+				title: "Page in Folder",
+				schemaType: "page",
+				parameters: [
+					{ name: "pageFolderId", title: "Page Folder ID", type: "string" },
+				],
+				value: ({ pageFolderId }: { pageFolderId?: string }) => ({
+					pageFolder: pageFolderId
+						? {
+								_type: "reference",
+								_ref: pageFolderId,
+							}
+						: undefined,
+				}),
+			},
+			{
+				id: "page-folder-with-parent",
+				title: "Page Folder in Folder",
+				schemaType: "pageFolder",
+				parameters: [
+					{ name: "parentFolderId", title: "Parent Folder ID", type: "string" },
+				],
+				value: ({ parentFolderId }: { parentFolderId?: string }) => ({
+					parentFolder: parentFolderId
+						? {
+								_type: "reference",
+								_ref: parentFolderId,
+							}
+						: undefined,
+				}),
+			},
+		],
+	},
+	document: {
+		actions: (previousActions, context) => {
+			const filtered = isSingletonDocument(
+				context.schemaType,
+				context.documentId,
+			)
+				? previousActions.filter(
+						(action) =>
+							action.action !== undefined &&
+							singletonDocumentActions.has(action.action),
+					)
+				: previousActions;
+
+			if (!isProd) return filtered;
+
+			return filtered.map((action) =>
+				action.action === "publish"
+					? createConfirmPublishAction(action)
+					: action,
+			);
+		},
+		newDocumentOptions: (previousOptions) =>
+			previousOptions.filter(
+				(option) =>
+					!singletonComponentTypes.has(option.templateId) &&
+					!PINNED_PAGE_IDS.has(option.templateId),
+			),
+	},
+	plugins: [structureTool({ structure }), presentation, media(), table()],
+});

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

@@ -0,0 +1,7 @@
+export { blogContent } from "./reusable/blog-content";
+export { description } from "./reusable/description";
+export { gatedContent } from "./reusable/gated-content";
+export { hero } from "./reusable/hero";
+export { richTextBlock } from "./reusable/rich-text-block";
+export { blogCollection } from "./singleton/content-collection";
+export { studioPreview } from "./studio-preview";

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

@@ -0,0 +1,89 @@
+import { defineField, defineType } from "sanity";
+import { contentIcon } from "@/lib/integrations/sanity/icons";
+
+export const blogContent = defineType({
+	name: "blogContent",
+	title: "Blog Content",
+	type: "document",
+	icon: contentIcon,
+	fields: [
+		defineField({
+			name: "title",
+			title: "Title",
+			type: "string",
+			validation: (Rule) => Rule.required(),
+		}),
+		defineField({
+			name: "thumbnail",
+			title: "Thumbnail",
+			type: "image",
+			description: "Featured image for the article",
+			options: { hotspot: true },
+			fields: [
+				{
+					name: "alt",
+					title: "Alt Text",
+					type: "string",
+					description: "Alternative text for screen readers",
+					validation: (Rule) => Rule.required(),
+				},
+			],
+		}),
+		defineField({
+			name: "categories",
+			title: "Categories",
+			type: "array",
+			of: [{ type: "reference", to: [{ type: "blogCategory" }] }],
+			description: "Category tags for filtering",
+		}),
+		defineField({
+			name: "date",
+			title: "Publication Date",
+			type: "date",
+			options: { dateFormat: "YYYY-MM-DD" },
+		}),
+		defineField({
+			name: "author",
+			title: "Author",
+			type: "reference",
+			to: [{ type: "author" }],
+		}),
+		defineField({
+			name: "body",
+			title: "Body",
+			type: "richText",
+			description: "Article content",
+		}),
+		defineField({
+			name: "relatedPosts",
+			title: "Related Posts",
+			type: "array",
+			of: [
+				{
+					type: "reference",
+					to: [{ type: "page" }],
+					options: {
+						filter:
+							'pageFolder->slug.current == "blog" && defined(slug.current) && slug.current != ""',
+					},
+				},
+			],
+			description: "Manually curated related blog pages",
+			validation: (Rule) => Rule.max(3),
+		}),
+	],
+	preview: {
+		select: {
+			title: "title",
+			date: "date",
+			media: "thumbnail",
+		},
+		prepare({ title, date, media }) {
+			return {
+				title: title || "Blog Content",
+				subtitle: date || "No date set",
+				media,
+			};
+		},
+	},
+});

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

@@ -0,0 +1,29 @@
+import { defineField, defineType } from "sanity";
+import { descriptionIcon } from "@/lib/integrations/sanity/icons";
+
+export const description = defineType({
+	name: "description",
+	title: "Description",
+	type: "document",
+	icon: descriptionIcon,
+	fields: [
+		defineField({
+			name: "description",
+			title: "Description",
+			type: "text",
+			rows: 4,
+			validation: (Rule) => Rule.required(),
+		}),
+	],
+	preview: {
+		select: {
+			description: "description",
+		},
+		prepare({ description }) {
+			return {
+				title: "Description",
+				subtitle: description || "Untitled",
+			};
+		},
+	},
+});

package/src/modules/features/cms/sanity-pagebuilder-cache/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-cache/files/lib/integrations/sanity/schemas/components/reusable/hero.ts

@@ -0,0 +1,28 @@
+import { defineField, defineType } from "sanity";
+import { heroIcon } from "@/lib/integrations/sanity/icons";
+
+export const hero = defineType({
+	name: "hero",
+	title: "Heading",
+	type: "document",
+	icon: heroIcon,
+	fields: [
+		defineField({
+			name: "headline",
+			title: "Heading",
+			type: "string",
+			validation: (Rule) => Rule.required(),
+		}),
+	],
+	preview: {
+		select: {
+			title: "headline",
+		},
+		prepare({ title }) {
+			return {
+				title: title || "Untitled",
+				subtitle: "Heading",
+			};
+		},
+	},
+});

package/src/modules/features/cms/sanity-pagebuilder-cache/files/lib/integrations/sanity/schemas/components/reusable/rich-text-block.ts

@@ -0,0 +1,39 @@
+import { defineField, defineType } from "sanity";
+import { richTextIcon } from "@/lib/integrations/sanity/icons";
+
+export const richTextBlock = defineType({
+	name: "richTextBlock",
+	title: "Rich Text",
+	type: "document",
+	icon: richTextIcon,
+	fields: [
+		defineField({
+			name: "content",
+			title: "Content",
+			type: "richText",
+			validation: (Rule) => Rule.required(),
+		}),
+	],
+	preview: {
+		select: {
+			content: "content",
+		},
+		prepare({ content }) {
+			// Portable Text has no plain-text field, so derive a subtitle from the
+			// first block's spans.
+			const firstBlock = Array.isArray(content) ? content[0] : null;
+			const spans = Array.isArray(firstBlock?.children)
+				? firstBlock.children
+				: [];
+			const text = spans
+				.map((span: { text?: string }) => span?.text ?? "")
+				.join("")
+				.trim();
+
+			return {
+				title: "Rich Text",
+				subtitle: text || "Empty",
+			};
+		},
+	},
+});

package/src/modules/features/cms/sanity-pagebuilder-cache/files/lib/integrations/sanity/schemas/components/singleton/content-collection.ts

@@ -0,0 +1,45 @@
+import { defineField, defineType } from "sanity";
+import type { SanityStudioIcon } from "@/lib/integrations/sanity/icons";
+import { pageListIcon } from "@/lib/integrations/sanity/icons";
+
+function createContentCollection(config: {
+	name: string;
+	title: string;
+	icon: SanityStudioIcon;
+	label: string;
+}) {
+	return defineType({
+		name: config.name,
+		title: config.title,
+		type: "document",
+		icon: config.icon,
+		description: `This component contains all the ${config.label}`,
+		fields: [
+			defineField({
+				name: "subtitle",
+				title: "Subtitle",
+				type: "string",
+				description:
+					"Text displayed between the featured articles and the rest of the collection",
+			}),
+		],
+		preview: {
+			select: {
+				title: "title",
+			},
+			prepare({ title }) {
+				return {
+					title: title || config.title,
+					subtitle: `${config.title} with search and category filters`,
+				};
+			},
+		},
+	});
+}
+
+export const blogCollection = createContentCollection({
+	name: "blogCollection",
+	title: "Blog Collection",
+	icon: pageListIcon,
+	label: "blog articles",
+});

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

@@ -0,0 +1,37 @@
+import { defineField, defineType } from "sanity";
+import { pageBuilderCardIcon } from "@/lib/integrations/sanity/icons";
+import { pageBuilderBlockPreviewOptions } from "@/lib/integrations/sanity/page-builder-config";
+
+export const studioPreview = defineType({
+	name: "studioPreview",
+	title: "Component Preview",
+	type: "document",
+	icon: pageBuilderCardIcon,
+	fields: [
+		defineField({
+			name: "key",
+			title: "Component",
+			type: "string",
+			options: { list: pageBuilderBlockPreviewOptions },
+			validation: (Rule) => Rule.required(),
+		}),
+		defineField({
+			name: "preview",
+			title: "Preview image",
+			type: "image",
+			options: { hotspot: true },
+			validation: (Rule) => Rule.required(),
+		}),
+	],
+	preview: {
+		select: { key: "key", media: "preview" },
+		prepare({ key, media }) {
+			return {
+				title:
+					pageBuilderBlockPreviewOptions.find((option) => option.value === key)
+						?.title ?? "Component Preview",
+				media,
+			};
+		},
+	},
+});

package/src/modules/features/cms/sanity-pagebuilder-cache/files/lib/integrations/sanity/schemas/content/author.ts

@@ -0,0 +1,70 @@
+import { defineField, defineType } from "sanity";
+import { authorIcon } from "@/lib/integrations/sanity/icons";
+
+export const author = defineType({
+	name: "author",
+	title: "Author",
+	type: "document",
+	icon: authorIcon,
+	fields: [
+		defineField({
+			name: "name",
+			title: "Name",
+			type: "string",
+			validation: (Rule) => Rule.required(),
+		}),
+		defineField({
+			name: "avatar",
+			title: "Avatar",
+			type: "image",
+			options: {
+				hotspot: true,
+			},
+			fields: [
+				{
+					name: "alt",
+					title: "Alt Text",
+					type: "string",
+					description: "Alternative text for screen readers",
+				},
+			],
+			validation: (Rule) => Rule.required(),
+		}),
+		defineField({
+			name: "role",
+			title: "Role",
+			type: "string",
+			description: "Job title or role (e.g. CEO, Engineering Lead)",
+		}),
+		defineField({
+			name: "description",
+			title: "Description",
+			type: "text",
+			rows: 3,
+			description: "Short bio displayed on blog articles",
+		}),
+		defineField({
+			name: "linkedInUrl",
+			title: "LinkedIn URL",
+			type: "url",
+			validation: (Rule) =>
+				Rule.uri({
+					scheme: ["https"],
+				}),
+		}),
+	],
+	preview: {
+		select: {
+			title: "name",
+			subtitle: "role",
+			media: "avatar",
+		},
+	},
+	orderings: [
+		{
+			title: "Name A-Z",
+			name: "nameAsc",
+			by: [{ field: "name", direction: "asc" }],
+		},
+	],
+});

package/src/modules/features/cms/sanity-pagebuilder-cache/files/lib/integrations/sanity/schemas/content/blog-category.ts

@@ -0,0 +1,55 @@
+import { defineField, defineType } from "sanity";
+import { blogCategoryIcon } from "@/lib/integrations/sanity/icons";
+
+export const blogCategory = defineType({
+	name: "blogCategory",
+	title: "Blog Category",
+	type: "document",
+	icon: blogCategoryIcon,
+	fields: [
+		defineField({
+			name: "title",
+			title: "Title",
+			type: "string",
+			description: "Category name (e.g. AI, Product Updates, Engineering)",
+			validation: (Rule) => Rule.required(),
+		}),
+		defineField({
+			name: "slug",
+			title: "Slug",
+			type: "slug",
+			description: "URL-friendly identifier used for filtering",
+			options: {
+				source: "title",
+				maxLength: 96,
+			},
+			validation: (Rule) =>
+				Rule.required().custom((slug) => {
+					if (!slug?.current) return "Required";
+					if (!/^[a-z0-9-]+$/.test(slug.current)) {
+						return "Slug must be lowercase with hyphens only";
+					}
+					return true;
+				}),
+		}),
+		defineField({
+			name: "description",
+			title: "Description",
+			type: "text",
+			rows: 2,
+			description: "Brief description of this category",
+		}),
+	],
+	preview: {
+		select: {
+			title: "title",
+		},
+	},
+	orderings: [
+		{
+			title: "Title A-Z",
+			name: "titleAsc",
+			by: [{ field: "title", direction: "asc" }],
+		},
+	],
+});