bsmnt 0.10.0 → 0.11.0

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

@@ -0,0 +1,124 @@
+import { defineField, defineType } from "sanity";
+import { apiVersion } from "@/lib/integrations/sanity/env";
+import { pageFolderIcon } from "@/lib/integrations/sanity/icons";
+
+type FolderValidationDocument = {
+	_id?: string;
+};
+
+export const pageFolder = defineType({
+	name: "pageFolder",
+	title: "Page Folder",
+	type: "document",
+	icon: pageFolderIcon,
+	fields: [
+		defineField({
+			name: "title",
+			title: "Title",
+			type: "string",
+			validation: (Rule) => Rule.required(),
+		}),
+		defineField({
+			name: "parentFolder",
+			title: "Parent Folder",
+			type: "reference",
+			to: [{ type: "pageFolder" }],
+			description: "Optional parent folder for nesting inside the Pages tree.",
+			hidden: true,
+			options: {
+				disableNew: true,
+				filter: ({ document }) => {
+					const currentId = (document as FolderValidationDocument | undefined)
+						?._id;
+					const normalizedId = currentId?.replace(/^drafts\./, "");
+
+					return normalizedId
+						? {
+								filter: `_type == "pageFolder" && !(_id in [$id, "drafts." + $id])`,
+								params: { id: normalizedId },
+							}
+						: { filter: `_type == "pageFolder"` };
+				},
+			},
+			validation: (Rule) =>
+				Rule.custom((value, context) => {
+					const document = context.document as
+						| FolderValidationDocument
+						| undefined;
+					const currentId = document?._id?.replace(/^drafts\./, "");
+
+					if (value?._ref && currentId && value._ref === currentId) {
+						return "A folder cannot be its own parent";
+					}
+
+					return true;
+				}),
+		}),
+		defineField({
+			name: "slug",
+			title: "Slug",
+			type: "slug",
+			description:
+				"Required full folder path for organization, for example blog or blog/guides.",
+			options: {
+				source: "title",
+				maxLength: 200,
+			},
+			validation: (Rule) =>
+				Rule.required().custom(async (slug, context) => {
+					if (!slug?.current) {
+						return "Slug is required";
+					}
+
+					if (!/^[a-z0-9-/]+$/.test(slug.current)) {
+						return "Slug must be lowercase with hyphens, letters, numbers, and forward slashes only";
+					}
+
+					if (slug.current.startsWith("/") || slug.current.endsWith("/")) {
+						return "Slug must not start or end with a forward slash";
+					}
+
+					const document = context.document as
+						| FolderValidationDocument
+						| undefined;
+					const id = document?._id?.replace(/^drafts\./, "");
+
+					if (!id) return true;
+
+					const client = context.getClient({ apiVersion });
+					const existing = await client.fetch<number>(
+						`count(*[
+              _type == "pageFolder" &&
+              slug.current == $slug &&
+              !(_id in [$id, "drafts." + $id])
+            ])`,
+						{
+							slug: slug.current,
+							id,
+						},
+					);
+
+					return existing === 0 || "Another page folder already uses this slug";
+				}),
+		}),
+	],
+	preview: {
+		select: {
+			title: "title",
+			slug: "slug.current",
+		},
+		prepare({ title, slug }) {
+			return {
+				title: title || "Untitled Folder",
+				subtitle: slug ? `/${slug}` : "Folder",
+			};
+		},
+	},
+	orderings: [
+		{
+			title: "Title A-Z",
+			name: "titleAsc",
+			by: [{ field: "title", direction: "asc" }],
+		},
+	],
+});

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

@@ -0,0 +1,265 @@
+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: "collectionCategory",
+			title: "Pinned Collection Category",
+			type: "reference",
+			to: [{ type: "blogCategory" }],
+			// Lives on the page because the collection block is deliberately a
+			// singleton (see `singletonComponents`) — editors reuse one block rather
+			// than creating them, so a category set there would apply site-wide. Move
+			// the block to the reusable list if you'd rather scope it per instance.
+			description:
+				"Turns this page into a category page: the content collection shows only this category. Leave empty to show everything.",
+		}),
+		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",
+			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-cache/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",
+				},
+			],
+		},
+	],
+});