bsmnt 0.4.2 → 0.5.0

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

@@ -0,0 +1,242 @@
+import { defineField, defineType } from "sanity";
+import { SlugField } from "@/lib/integrations/sanity/components/slug-field";
+import { SlugInput } from "@/lib/integrations/sanity/components/slug-input";
+import { apiVersion } from "@/lib/integrations/sanity/env";
+import { pageIcon } from "@/lib/integrations/sanity/icons";
+import {
+	getInvalidPageBuilderDocumentTypes,
+	getPageBuilderReferenceMemberByDocumentType,
+	getPageCategoryIcon,
+	type PageBuilderDocumentType,
+	type PageBuilderGroupName,
+	pageBuilderPageTypes,
+} from "@/lib/integrations/sanity/page-builder-config";
+import { getGeneratedPageCategory } from "@/lib/integrations/sanity/page-category";
+import { getPinnedPageById } from "@/lib/integrations/sanity/pinned-pages";
+
+type PageValidationDocument = {
+	_id?: string;
+	type?: PageBuilderGroupName;
+	pageFolder?: {
+		_ref?: string;
+	};
+	slug?: { current?: string | null };
+	pageBuilder?: Array<{
+		_key?: string;
+		_type?: string;
+		_ref?: string;
+	}>;
+};
+
+type PageSlugValidationContext = {
+	document?: PageValidationDocument | undefined;
+	getClient: (options: { apiVersion: string }) => {
+		fetch: <T>(query: string, params?: Record<string, unknown>) => Promise<T>;
+	};
+};
+
+type ReferencedPageBuilderDocument = {
+	_id: string;
+	_type: PageBuilderDocumentType;
+};
+
+const PAGE_FOLDER_QUERY = `*[_type == "pageFolder" && _id in [$publishedId, $draftId]][0].slug.current`;
+
+async function getGeneratedPageCategoryForDocument(
+	document: PageValidationDocument | undefined,
+	getClient: PageSlugValidationContext["getClient"],
+) {
+	const pageFolderId = document?.pageFolder?._ref?.replace(/^drafts\./, "");
+	let folder: string | null = null;
+
+	if (pageFolderId) {
+		folder = await getClient({ apiVersion }).fetch<string | null>(
+			PAGE_FOLDER_QUERY,
+			{ draftId: `drafts.${pageFolderId}`, publishedId: pageFolderId },
+		);
+	}
+
+	return getGeneratedPageCategory({
+		folder,
+		slug: document?.slug?.current ?? null,
+	});
+}
+
+async function isPageSlugUniqueInFolder(
+	slug: string | null,
+	context: PageSlugValidationContext,
+) {
+	const id = context.document?._id?.replace(/^drafts\./, "");
+
+	if (!id) return true;
+
+	const pageFolderId = context.document?.pageFolder?._ref ?? null;
+	const client = context.getClient({ apiVersion });
+	const existing = await client.fetch<number>(
+		`count(*[
+      _type == "page" &&
+      !(_id in [$id, "drafts." + $id]) &&
+      (
+        ($pageFolderId == null && !defined(pageFolder._ref)) ||
+        pageFolder._ref == $pageFolderId
+      ) &&
+      (
+        ($slug == null && !defined(slug.current)) ||
+        slug.current == $slug
+      )
+    ])`,
+		{
+			id,
+			pageFolderId,
+			slug,
+		},
+	);
+
+	return existing === 0;
+}
+
+export const page = defineType({
+	name: "page",
+	title: "Page",
+	type: "document",
+	icon: pageIcon,
+	fields: [
+		defineField({
+			name: "title",
+			title: "Title",
+			type: "string",
+			validation: (Rule) => Rule.required(),
+		}),
+		defineField({
+			name: "type",
+			title: "Page Category",
+			type: "string",
+			options: { list: pageBuilderPageTypes },
+			initialValue: "generic",
+			hidden: true,
+			readOnly: true,
+		}),
+		defineField({
+			name: "pageFolder",
+			title: "Folder",
+			type: "reference",
+			to: [{ type: "pageFolder" }],
+			description: "Optional Studio folder for organizing this page.",
+			hidden: true,
+		}),
+		defineField({
+			name: "slug",
+			title: "Slug",
+			type: "slug",
+			description: "URL path without leading slash.",
+			readOnly: ({ document }) =>
+				getPinnedPageById(document?._id as string | undefined) !== null,
+			components: {
+				field: SlugField,
+				input: SlugInput,
+			},
+			options: {
+				source: "title",
+				maxLength: 200,
+				isUnique: (slug, context) => isPageSlugUniqueInFolder(slug, context),
+			},
+			validation: (Rule) =>
+				Rule.custom(async (slug, context) => {
+					return (
+						(await isPageSlugUniqueInFolder(slug?.current ?? null, {
+							document: context.document as PageValidationDocument | undefined,
+							getClient: context.getClient,
+						})) || "Another page in this folder already uses this slug"
+					);
+				}),
+		}),
+		defineField({
+			name: "pageBuilder",
+			title: "Page Builder",
+			type: "pageBuilder",
+			description: "Composable content blocks for this page",
+			validation: (Rule) =>
+				Rule.custom(async (value, context) => {
+					const document = context.document as
+						| PageValidationDocument
+						| undefined;
+					const pageType = await getGeneratedPageCategoryForDocument(
+						document,
+						context.getClient,
+					);
+					const pageBuilderItems = Array.isArray(value)
+						? (value as Array<{ _ref?: string }>)
+						: [];
+					const referenceIds = pageBuilderItems
+						.map((item) => item?._ref?.replace(/^drafts\./, ""))
+						.filter((item): item is string => typeof item === "string");
+
+					if (referenceIds.length === 0) return true;
+
+					const referencedDocuments = await context
+						.getClient({ apiVersion })
+						.fetch<ReferencedPageBuilderDocument[]>(
+							`*[
+                _id in $publishedIds || _id in $draftIds
+              ]{
+                _id,
+                _type
+              }`,
+							{
+								publishedIds: referenceIds,
+								draftIds: referenceIds.map((id) => `drafts.${id}`),
+							},
+						);
+
+					const invalidDocumentTypes = getInvalidPageBuilderDocumentTypes(
+						pageType,
+						referencedDocuments.map((entry) => entry._type),
+					);
+
+					if (invalidDocumentTypes.length === 0) return true;
+
+					const invalidMemberTitles = invalidDocumentTypes.map(
+						(documentType) =>
+							getPageBuilderReferenceMemberByDocumentType(documentType)
+								?.title ?? documentType,
+					);
+
+					return `These page builder components do not belong to the "${pageType ?? "generic"}" category: ${invalidMemberTitles.join(", ")}`;
+				}),
+		}),
+		defineField({
+			name: "metadata",
+			title: "SEO & Metadata",
+			type: "metadata",
+		}),
+	],
+	preview: {
+		select: {
+			id: "_id",
+			title: "title",
+			folder: "pageFolder->slug.current",
+			slug: "slug.current",
+		},
+		prepare({ folder, id, title, slug }) {
+			let path = "No slug";
+			const pinned = getPinnedPageById(id as string | undefined);
+			if (pinned) {
+				path = pinned.path;
+			} else if (slug) {
+				path = `/${slug}`;
+			}
+			return {
+				title: title || "Untitled",
+				subtitle: path,
+				media: getPageCategoryIcon(getGeneratedPageCategory({ folder, slug })),
+			};
+		},
+	},
+	orderings: [
+		{
+			title: "Title A-Z",
+			name: "titleAsc",
+			by: [{ field: "title", direction: "asc" }],
+		},
+	],
+});

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

@@ -0,0 +1,63 @@
+import { defineType } from "sanity";
+import { linkAnnotations } from "./link";
+
+export const richText = defineType({
+	name: "richText",
+	title: "Rich Text",
+	type: "array",
+	of: [
+		{
+			type: "block",
+			styles: [
+				{ title: "Normal", value: "normal" },
+				{ title: "H1", value: "h1" },
+				{ title: "H2", value: "h2" },
+				{ title: "H3", value: "h3" },
+				{ title: "H4", value: "h4" },
+				{ title: "H5", value: "h5" },
+				{ title: "H6", value: "h6" },
+				{ title: "Quote", value: "blockquote" },
+			],
+			lists: [
+				{ title: "Bullet", value: "bullet" },
+				{ title: "Number", value: "number" },
+			],
+			marks: {
+				decorators: [
+					{ title: "Strong", value: "strong" },
+					{ title: "Emphasis", value: "em" },
+					{ title: "Code", value: "code" },
+					{ title: "Underline", value: "underline" },
+					{ title: "Strike", value: "strike-through" },
+				],
+				annotations: linkAnnotations,
+			},
+		},
+		{
+			type: "table",
+			title: "Table",
+		},
+		{
+			type: "image",
+			title: "Image",
+			options: {
+				hotspot: true,
+			},
+			fields: [
+				{
+					name: "alt",
+					title: "Alt Text",
+					type: "string",
+					description: "Alternative text for screen readers",
+					validation: (Rule) => Rule.required(),
+				},
+				{
+					name: "caption",
+					title: "Caption",
+					type: "string",
+					description: "Optional caption displayed below the image",
+				},
+			],
+		},
+	],
+});

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

@@ -0,0 +1,39 @@
+import { companyDataIcon, footerIcon, navbarIcon, pageListIcon } from "./icons";
+
+export const singletonComponents = [
+	{
+		schemaType: "blogCollection",
+		documentId: "blogCollection",
+		title: "Blog Collection",
+		icon: pageListIcon,
+	},
+] as const;
+
+export const singletonLayout = [
+	{
+		schemaType: "companyData",
+		documentId: "companyData",
+		title: "Company Data",
+		icon: companyDataIcon,
+	},
+	{
+		schemaType: "navbar",
+		documentId: "navbar",
+		title: "Navbar",
+		icon: navbarIcon,
+	},
+	{
+		schemaType: "footer",
+		documentId: "footer",
+		title: "Footer",
+		icon: footerIcon,
+	},
+] as const;
+
+export const singletonComponentTypes: Set<string> = new Set(
+	singletonComponents.map((item) => item.schemaType),
+);
+
+export const singletonLayoutTypes: Set<string> = new Set(
+	singletonLayout.map((item) => item.schemaType),
+);

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

@@ -0,0 +1,330 @@
+import { from } from "rxjs";
+import { map } from "rxjs/operators";
+import type {
+	ComponentBuilder,
+	StructureBuilder,
+	StructureResolver,
+	StructureResolverContext,
+} from "sanity/structure";
+import { apiVersion } from "./env";
+import {
+	authorIcon,
+	blogCategoryIcon,
+	componentsFolderIcon,
+	contentFolderIcon,
+	contentIcon,
+	descriptionIcon,
+	heroIcon,
+	layoutFolderIcon,
+	pageFolderIcon,
+	pageIcon,
+	pagesFolderIcon,
+	redirectIcon,
+} from "./icons";
+import { PageTreePane } from "./page-tree-pane";
+import { PINNED_PAGE_ENTRIES } from "./pinned-pages";
+import { singletonComponents, singletonLayout } from "./singletons";
+
+const PAGE_TREE_ITEM_ID_PREFIX = {
+	page: "page-tree-",
+	pageFolder: "page-folder-tree-",
+} as const;
+
+const normalizeDocumentId = (documentId: string) =>
+	documentId.replace(/^drafts\./, "");
+
+export const getDocumentIdFromPageTreeItemId = (itemId: string) =>
+	normalizeDocumentId(
+		itemId
+			.replace(PAGE_TREE_ITEM_ID_PREFIX.page, "")
+			.replace(PAGE_TREE_ITEM_ID_PREFIX.pageFolder, ""),
+	);
+
+const getPageTreeTemplateIds = (folderId: string | null) =>
+	folderId === null
+		? ["page", "pageFolder"]
+		: ["page-with-folder", "page-folder-with-parent"];
+
+const buildPageTreeCreateChild = (
+	S: StructureBuilder,
+	documentId: string,
+	folderId: string | null,
+	templateId: string,
+) => {
+	if (templateId === "page") {
+		return S.documentWithInitialValueTemplate("page").documentId(documentId);
+	}
+
+	if (templateId === "pageFolder") {
+		return S.documentWithInitialValueTemplate("pageFolder").documentId(
+			documentId,
+		);
+	}
+
+	if (templateId === "page-with-folder") {
+		return S.documentWithInitialValueTemplate("page-with-folder", {
+			pageFolderId: folderId,
+		}).documentId(documentId);
+	}
+
+	if (templateId === "page-folder-with-parent") {
+		return S.documentWithInitialValueTemplate("page-folder-with-parent", {
+			parentFolderId: folderId,
+		}).documentId(documentId);
+	}
+
+	return undefined;
+};
+
+const getPageTreeClient = (context: StructureResolverContext) =>
+	context
+		.getClient({ apiVersion })
+		.withConfig({ perspective: context.perspectiveStack });
+
+function buildPageTreeComponent(
+	S: StructureBuilder,
+	context: StructureResolverContext,
+	folderId: string | null,
+	title: string,
+): ComponentBuilder {
+	const allowedTemplateIds = getPageTreeTemplateIds(folderId);
+
+	const folderMenuItems =
+		folderId === null
+			? []
+			: [
+					S.menuItem()
+						.title("Folder Settings")
+						.icon(pageFolderIcon)
+						.intent({
+							type: "edit",
+							params: { id: folderId, type: "pageFolder" },
+						}),
+				];
+
+	const createMenuItems =
+		folderId === null
+			? [
+					S.menuItem()
+						.title("Create Page")
+						.icon(pageIcon)
+						.intent({
+							type: "create",
+							params: { type: "page", template: "page" },
+						}),
+					S.menuItem()
+						.title("Create Folder")
+						.icon(pageFolderIcon)
+						.intent({
+							type: "create",
+							params: { type: "pageFolder", template: "pageFolder" },
+						}),
+				]
+			: [
+					S.menuItem()
+						.title("Create Page")
+						.icon(pageIcon)
+						.intent({
+							type: "create",
+							params: [
+								{ type: "page", template: "page-with-folder" },
+								{ pageFolderId: folderId },
+							],
+						}),
+					S.menuItem()
+						.title("Create Folder")
+						.icon(pageFolderIcon)
+						.intent({
+							type: "create",
+							params: [
+								{ type: "pageFolder", template: "page-folder-with-parent" },
+								{ parentFolderId: folderId },
+							],
+						}),
+				];
+
+	return S.component()
+		.id(`page-tree-${folderId ?? "root"}`)
+		.title(title)
+		.component(PageTreePane)
+		.options({ folderId })
+		.canHandleIntent((intentName, params) => {
+			if (intentName === "create") {
+				return (
+					typeof params.template === "string" &&
+					allowedTemplateIds.includes(params.template)
+				);
+			}
+
+			if (intentName === "edit") {
+				const id =
+					typeof params.id === "string" ? normalizeDocumentId(params.id) : null;
+
+				// Pinned pages live at the root pane only.
+				if (
+					folderId === null &&
+					id !== null &&
+					params.type === "page" &&
+					PINNED_PAGE_ENTRIES.some((entry) => entry.id === id)
+				) {
+					return true;
+				}
+
+				return (
+					id !== null &&
+					folderId !== null &&
+					id === normalizeDocumentId(folderId) &&
+					params.type === "pageFolder"
+				);
+			}
+
+			return false;
+		})
+		.child((childId, childOptions) => {
+			const normalizedId = getDocumentIdFromPageTreeItemId(childId);
+
+			// Pinned pages open by their raw id; seed via template so a
+			// not-yet-created pinned page gets its title/slug.
+			const pinnedEntry = PINNED_PAGE_ENTRIES.find(
+				(entry) => entry.id === childId,
+			);
+			if (pinnedEntry) {
+				return S.documentWithInitialValueTemplate(pinnedEntry.id).documentId(
+					pinnedEntry.id,
+				);
+			}
+
+			if (childId.startsWith(PAGE_TREE_ITEM_ID_PREFIX.page)) {
+				return S.document().schemaType("page").documentId(normalizedId);
+			}
+
+			if (childId.startsWith(PAGE_TREE_ITEM_ID_PREFIX.pageFolder)) {
+				// Fetch the folder title so the recursive pane shows the right header.
+				return from(
+					getPageTreeClient(context).fetch<{ title: string | null } | null>(
+						`*[_id == $id || _id == "drafts." + $id][0]{ title }`,
+						{ id: normalizedId },
+					),
+				).pipe(
+					map((folder) =>
+						buildPageTreeComponent(
+							S,
+							context,
+							normalizedId,
+							folder?.title ?? "Untitled Folder",
+						),
+					),
+				);
+			}
+
+			// Current folder settings (edit intent for the folder itself).
+			if (folderId !== null && normalizedId === normalizeDocumentId(folderId)) {
+				return S.document().schemaType("pageFolder").documentId(normalizedId);
+			}
+
+			// Template-based document creation.
+			const templateId =
+				typeof childOptions.params?.template === "string"
+					? childOptions.params.template
+					: null;
+
+			if (templateId) {
+				return buildPageTreeCreateChild(S, normalizedId, folderId, templateId);
+			}
+
+			return undefined;
+		})
+		.menuItems([...folderMenuItems, ...createMenuItems]);
+}
+
+// https://www.sanity.io/docs/structure-builder-cheat-sheet
+export const structure: StructureResolver = (S, context) =>
+	S.list()
+		.title("Content")
+		.items([
+			// GROUP 1: Pages -- root page tree with inline search/filter
+			S.listItem()
+				.title("Pages")
+				.icon(pagesFolderIcon)
+				.child(() => buildPageTreeComponent(S, context, null, "Pages")),
+
+			S.divider(),
+
+			// GROUP 2: Content -- authors, blog categories
+			S.listItem()
+				.title("Content")
+				.icon(contentFolderIcon)
+				.child(
+					S.list()
+						.title("Content")
+						.items([
+							S.documentTypeListItem("author")
+								.title("Authors")
+								.icon(authorIcon),
+							S.documentTypeListItem("blogCategory")
+								.title("Blog Categories")
+								.icon(blogCategoryIcon),
+						]),
+				),
+
+			S.divider(),
+
+			// GROUP 3: Components -- singleton and reusable components
+			S.listItem()
+				.title("Components")
+				.icon(componentsFolderIcon)
+				.child(
+					S.list()
+						.title("Components")
+						.items([
+							S.divider().title("Singleton Components"),
+							...singletonComponents.map((item) =>
+								S.listItem()
+									.title(item.title)
+									.id(item.documentId)
+									.icon(item.icon)
+									.child(
+										S.document()
+											.schemaType(item.schemaType)
+											.documentId(item.documentId),
+									),
+							),
+							S.divider().title("Reusable Components"),
+							S.documentTypeListItem("hero").title("Headings").icon(heroIcon),
+							S.documentTypeListItem("description")
+								.title("Descriptions")
+								.icon(descriptionIcon),
+							S.documentTypeListItem("blogContent")
+								.title("Blog Content")
+								.icon(contentIcon),
+						]),
+				),
+
+			S.divider(),
+
+			// GROUP 4: Layout -- global layout singletons + managed collections
+			S.listItem()
+				.title("Layout")
+				.icon(layoutFolderIcon)
+				.child(
+					S.list()
+						.title("Layout")
+						.items([
+							...singletonLayout.map((item) =>
+								S.listItem()
+									.title(item.title)
+									.id(item.documentId)
+									.icon(item.icon)
+									.child(
+										S.document()
+											.schemaType(item.schemaType)
+											.documentId(item.documentId),
+									),
+							),
+							S.divider(),
+							S.documentTypeListItem("redirect")
+								.title("Redirects")
+								.icon(redirectIcon),
+						]),
+				),
+		]);

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

@@ -0,0 +1,8 @@
+import { createImageUrlBuilder } from "@sanity/image-url";
+import { dataset, projectId } from "../env";
+
+const builder = createImageUrlBuilder({ projectId, dataset });
+
+export const urlForImage = (source: Parameters<typeof builder.image>[0]) => {
+	return builder.image(source);
+};