bsmnt 0.10.0 → 0.12.0

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

@@ -0,0 +1,339 @@
+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,
+	gatedContentIcon,
+	heroIcon,
+	layoutFolderIcon,
+	pageBuilderCardIcon,
+	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("gatedContent")
+								.title("Gated Content")
+								.icon(gatedContentIcon),
+							S.documentTypeListItem("blogContent")
+								.title("Blog Content")
+								.icon(contentIcon),
+							S.divider(),
+							S.documentTypeListItem("studioPreview")
+								.title("Component Previews")
+								.icon(pageBuilderCardIcon),
+						]),
+				),
+
+			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-cache/files/lib/integrations/sanity/tags.ts

@@ -0,0 +1,89 @@
+// Cache tags shared by the `'use cache'` fetchers and the publish webhook.
+// Dependency-free on purpose: the modules owning these documents pull in the
+// Studio UI, and the webhook can't.
+
+// Layout singletons. Each tag is also its document `_type`, which is what lets
+// the webhook bust them without a lookup.
+export const SANITY_NAVBAR_TAG = "navbar";
+export const SANITY_FOOTER_TAG = "footer";
+export const SANITY_COMPANY_DATA_TAG = "companyData";
+export const SANITY_STRUCTURED_DATA_TAG = "structuredData";
+
+export const SANITY_LAYOUT_TAGS = [
+	SANITY_NAVBAR_TAG,
+	SANITY_FOOTER_TAG,
+	SANITY_COMPANY_DATA_TAG,
+	SANITY_STRUCTURED_DATA_TAG,
+] as const;
+
+export const SANITY_REDIRECTS_TAG = "redirect";
+
+// Tags whose name equals the document `_type` that invalidates them.
+export const SELF_TAGGED_TYPES = new Set<string>([
+	...SANITY_LAYOUT_TAGS,
+	SANITY_REDIRECTS_TAG,
+]);
+
+// Crawler routes: broader than any per-slug tag.
+export const SITEMAP_TAG = "sitemap";
+export const FEED_TAG = "feed";
+
+// The content-collection block caches each window of results separately.
+export const BLOG_CATEGORIES_TAG = "blog-categories";
+export const BLOG_ARTICLES_TAG = "blog-articles";
+export const BLOG_ARTICLES_COUNT_TAG = "blog-articles-count";
+
+export const BLOG_COLLECTION_TAGS = [
+	BLOG_CATEGORIES_TAG,
+	BLOG_ARTICLES_TAG,
+	BLOG_ARTICLES_COUNT_TAG,
+] as const;
+
+// Publishing a `page` revalidates its own path; nothing else reaches the cached
+// collection windows.
+export const BLOG_COLLECTION_TYPES = new Set<string>([
+	"page",
+	"blogContent",
+	"blogCategory",
+	"author",
+]);
+
+// Tags whose cached query reads a *different* document type. next-sanity's own
+// dependency tags are opaque Live API hashes only <SanityLive /> can expire, and
+// only with a browser connected — so the webhook needs this spelled out.
+export const CROSS_DOC_TAG_DEPENDENCIES: Record<string, readonly string[]> = {
+	// Redundant while LAYOUT_QUERY is merged; kept so splitting it can't lose this.
+	companyData: [SANITY_STRUCTURED_DATA_TAG],
+	// Nav links deref pages; sitemap and feed move whenever any page does.
+	page: [SANITY_NAVBAR_TAG, SITEMAP_TAG, FEED_TAG],
+	// ...plus the collections, which decide membership on the folder slug, so a
+	// rename changes which pages are articles at all.
+	pageFolder: [
+		SANITY_NAVBAR_TAG,
+		...BLOG_COLLECTION_TAGS,
+		SITEMAP_TAG,
+		FEED_TAG,
+	],
+	// The feed derefs the article's block, then its author and categories.
+	blogContent: [FEED_TAG],
+	author: [FEED_TAG],
+	blogCategory: [FEED_TAG],
+};
+
+// Types a page inlines by reference, so publishing one goes stale on every page
+// pointing at it. The route unions this with the page-builder block types.
+export const REFERENCEABLE_TYPES = new Set<string>([
+	"page",
+	"author",
+	"blogCategory",
+]);
+
+// Every fixed tag, for the `purgeAll` hatch. Per-slug tags are absent because
+// enumerating them needs a query; the route does that itself.
+export const PURGEABLE_TAGS = [
+	...SANITY_LAYOUT_TAGS,
+	SANITY_REDIRECTS_TAG,
+	...BLOG_COLLECTION_TAGS,
+	SITEMAP_TAG,
+	FEED_TAG,
+];

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

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

@@ -0,0 +1,140 @@
+import { getPinnedPageById } from "@/lib/integrations/sanity/pinned-pages";
+
+type PageReference = {
+	_id?: string;
+	_ref?: string;
+	_type?: string;
+	slug?: { current?: string | null } | null;
+	resolvedSlug?: string | null;
+	title?: string | null;
+};
+
+type PageReferenceLink = {
+	_type: "pageReference";
+	page?: PageReference | null;
+	text?: string | null;
+	openInNewTab?: boolean | null;
+};
+
+type ExternalLinkItem = {
+	_type: "externalLink";
+	href?: string | null;
+	text?: string | null;
+	openInNewTab?: boolean | null;
+};
+
+type LinkItem = PageReferenceLink | ExternalLinkItem;
+
+// Backward-compatible shape (old data without _type)
+type LegacyLink = {
+	page?: PageReference | null;
+	href?: string | null;
+	text?: string | null;
+	openInNewTab?: boolean | null;
+};
+
+type LinkLike = LinkItem | LegacyLink;
+
+type InternalReference = {
+	_id?: string;
+	_type: string;
+	slug?: { current?: string | null } | null;
+	resolvedSlug?: string | null;
+	title?: string;
+};
+
+/**
+ * Resolves a link object to a URL string.
+ *
+ * Supports both the new discriminated union shape (_type: "pageReference" | "externalLink")
+ * and the legacy flat shape (page + href without _type).
+ */
+export const urlForReference = (link: LinkLike | null): string => {
+	if (!link) return "#";
+
+	// New discriminated union
+	if ("_type" in link && link._type === "pageReference") {
+		if (
+			link.page &&
+			typeof link.page === "object" &&
+			("slug" in link.page || "_id" in link.page)
+		) {
+			const ref = link.page as InternalReference;
+			return resolveDocumentUrl(
+				ref._type,
+				ref.resolvedSlug ?? undefined,
+				ref.slug?.current ?? undefined,
+				ref._id,
+			);
+		}
+		return "#";
+	}
+
+	if ("_type" in link && link._type === "externalLink") {
+		return link.href || "#";
+	}
+
+	// Legacy fallback (flat shape without _type)
+	if (
+		"page" in link &&
+		link.page &&
+		typeof link.page === "object" &&
+		("slug" in link.page || "_id" in link.page)
+	) {
+		const ref = link.page as InternalReference;
+		return resolveDocumentUrl(
+			ref._type,
+			ref.resolvedSlug ?? undefined,
+			ref.slug?.current ?? undefined,
+			ref._id,
+		);
+	}
+
+	if ("href" in link && link.href) {
+		return link.href;
+	}
+
+	return "#";
+};
+
+function resolveDocumentUrl(
+	documentType: string,
+	resolvedSlug?: string,
+	slug?: string,
+	documentId?: string,
+): string {
+	if (documentType === "page") {
+		const pinned = getPinnedPageById(documentId);
+		if (pinned) return pinned.path;
+		if (resolvedSlug) return `/${resolvedSlug}`;
+		if (slug) return `/${slug}`;
+		return "#";
+	}
+
+	if (!slug) return "#";
+
+	console.warn("Unknown document type for URL resolution:", documentType);
+	return "#";
+}
+
+/**
+ * Returns href, target, and rel attributes for a link object.
+ *
+ * External detection: externalLink type, or URLs starting with "http".
+ */
+export const getLinkAttributes = (link: LinkLike | null) => {
+	if (!link) return { href: "#", target: undefined, rel: undefined };
+
+	const href = urlForReference(link);
+	const isExternal =
+		("_type" in link && link._type === "externalLink") ||
+		href.startsWith("http");
+
+	const shouldOpenNewTab = link.openInNewTab || isExternal;
+
+	return {
+		href,
+		target: shouldOpenNewTab ? "_blank" : undefined,
+		rel: shouldOpenNewTab ? "noopener noreferrer" : undefined,
+	};
+};

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

@@ -0,0 +1,113 @@
+import { portableTextToMarkdown } from "@portabletext/markdown";
+import type { PAGE_QUERY_RESULT } from "../sanity.types";
+
+const markdownOptions = {
+	types: {
+		table: ({ value }: { value: { rows?: Array<{ cells?: string[] }> } }) => {
+			const rows = value?.rows;
+			if (!rows?.length) return "";
+			return rows
+				.map((row) => `| ${(row.cells ?? []).join(" | ")} |`)
+				.join("\n");
+		},
+	},
+} satisfies Parameters<typeof portableTextToMarkdown>[1];
+
+type PageBuilderBlock = NonNullable<
+	NonNullable<PAGE_QUERY_RESULT>["pageBuilder"]
+>[number];
+
+export const renderPageBuilderMarkdown = (
+	blocks: PageBuilderBlock[] | null | undefined,
+) => {
+	if (!blocks?.length) return "";
+
+	return blocks
+		.flatMap((block) => {
+			switch (block._type) {
+				case "hero":
+					return block.headline ? [`## ${block.headline}`, ""] : [];
+				case "description":
+					return block.description ? [block.description, ""] : [];
+				case "richTextBlock":
+					return block.content
+						? [
+								portableTextToMarkdown(
+									block.content as Parameters<
+										typeof portableTextToMarkdown
+									>[0],
+									markdownOptions,
+								),
+								"",
+							]
+						: [];
+				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 =
+						"categories" in block ? block.categories : undefined;
+					const relatedPosts =
+						"relatedPosts" in block ? block.relatedPosts : undefined;
+
+					if (categories?.length) {
+						lines.push(
+							categories
+								.map((c) => c.title)
+								.filter(Boolean)
+								.join(", "),
+						);
+					}
+					if (block.author?.name) {
+						const authorParts = [block.author.name, block.author.role]
+							.filter(Boolean)
+							.join(", ");
+						lines.push(`**Author:** ${authorParts}`);
+					}
+					if (block.date) {
+						lines.push(`**Date:** ${block.date}`);
+					}
+					lines.push("");
+					if (block.body) {
+						lines.push(
+							portableTextToMarkdown(
+								block.body as Parameters<typeof portableTextToMarkdown>[0],
+								markdownOptions,
+							),
+						);
+					}
+					if (relatedPosts?.length) {
+						lines.push("", "## Related Articles", "");
+						for (const post of relatedPosts) {
+							if (post.title && post.resolvedSlug) {
+								lines.push(`- [${post.title}](/${post.resolvedSlug}.md)`);
+							}
+						}
+					}
+					lines.push("");
+					return lines.filter((l) => l !== null);
+				}
+				default:
+					return [];
+			}
+		})
+		.join("\n");
+};