bsmnt 0.4.3 → 0.5.0

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

@@ -0,0 +1,62 @@
+import type { Icon, IconProps } from "@phosphor-icons/react";
+import {
+	ArrowBendUpRightIcon,
+	ArticleNyTimesIcon,
+	BrowsersIcon,
+	BuildingsIcon,
+	FileTextIcon,
+	FolderOpenIcon,
+	FootprintsIcon,
+	LayoutIcon,
+	ListBulletsIcon,
+	ListIcon,
+	PackageIcon,
+	PushPinIcon,
+	RocketIcon,
+	ShapesIcon,
+	ShareNetworkIcon,
+	TagIcon,
+	TextAlignLeftIcon,
+	UserCircleIcon,
+} from "@phosphor-icons/react/dist/ssr";
+import { createElement, forwardRef } from "react";
+
+export type SanityStudioIcon = Icon;
+
+const asDuotoneIcon = (IconComponent: Icon): SanityStudioIcon => {
+	const DuotoneIcon = forwardRef<SVGSVGElement, IconProps>((props, ref) =>
+		createElement(IconComponent, { ...props, ref, weight: "duotone" }),
+	);
+
+	DuotoneIcon.displayName = `${IconComponent.displayName ?? "Phosphor"}Duotone`;
+
+	return DuotoneIcon;
+};
+
+export const pageBuilderCardIcon = asDuotoneIcon(PackageIcon);
+export const pageBuilderCardListIcon = asDuotoneIcon(ListIcon);
+
+export const authorIcon = asDuotoneIcon(UserCircleIcon);
+
+export const pageListIcon = asDuotoneIcon(ListBulletsIcon);
+
+export const blogCategoryIcon = asDuotoneIcon(TagIcon);
+
+export const componentsFolderIcon = asDuotoneIcon(ShapesIcon);
+
+export const companyDataIcon = asDuotoneIcon(BuildingsIcon);
+export const socialLinksIcon = asDuotoneIcon(ShareNetworkIcon);
+export const navbarIcon = asDuotoneIcon(ListIcon);
+export const footerIcon = asDuotoneIcon(FootprintsIcon);
+export const redirectIcon = asDuotoneIcon(ArrowBendUpRightIcon);
+export const layoutFolderIcon = asDuotoneIcon(LayoutIcon);
+
+export const heroIcon = asDuotoneIcon(RocketIcon);
+export const descriptionIcon = asDuotoneIcon(TextAlignLeftIcon);
+export const contentIcon = asDuotoneIcon(ArticleNyTimesIcon);
+
+export const pageIcon = asDuotoneIcon(FileTextIcon);
+export const pinIcon = asDuotoneIcon(PushPinIcon);
+export const pagesFolderIcon = asDuotoneIcon(BrowsersIcon);
+export const pageFolderIcon = asDuotoneIcon(FolderOpenIcon);
+export const contentFolderIcon = asDuotoneIcon(FolderOpenIcon);

package/src/modules/features/cms/sanity-pagebuilder/files/lib/integrations/sanity/live/index.tsx

@@ -0,0 +1,88 @@
+import { NextResponse } from "next/server";
+import type { QueryParams } from "next-sanity";
+import { defineLive } from "next-sanity/live";
+import { isSanityConfigured } from "@/lib/integrations/check-integration";
+import { client } from "../client";
+import { sanityToken } from "../env";
+
+const isConfigured = isSanityConfigured() && client;
+
+const liveExports =
+	isConfigured && client
+		? defineLive({
+				client,
+				browserToken: sanityToken ?? false,
+				serverToken: sanityToken ?? false,
+			})
+		: null;
+
+export const sanityFetch =
+	liveExports?.sanityFetch ?? (async () => ({ data: null }));
+
+export const SanityLive = liveExports?.SanityLive ?? (() => null);
+
+type SanityFetchOptions = {
+	query: string;
+	params?: QueryParams;
+	tags?: string[];
+	stega?: boolean;
+	perspective?: "published" | "drafts" | "previewDrafts";
+};
+
+export async function fetchSanity<T = unknown>({
+	query,
+	params = {},
+	tags = [],
+	stega,
+	perspective,
+}: SanityFetchOptions): Promise<{ data: T | null }> {
+	const { data } = await sanityFetch({
+		query,
+		params,
+		tags,
+		...(typeof stega === "boolean" ? { stega } : {}),
+		...(perspective ? { perspective } : {}),
+	});
+
+	return { data: (data as T | null) ?? null };
+}
+
+export const SanityFetch = async <T,>(
+	slug: string,
+	query: string,
+	label = "Content",
+): Promise<T | NextResponse> => {
+	if (!client) {
+		return new NextResponse(`# 503 Unavailable\n\nCMS client unavailable.`, {
+			status: 503,
+			headers: { "Content-Type": "text/markdown; charset=utf-8" },
+		});
+	}
+
+	try {
+		const { data } = await sanityFetch({
+			query,
+			params: { slug },
+		});
+
+		const result = data as T | null;
+
+		if (!result) {
+			return new NextResponse(`# 404 Not Found\n\nPage not found.`, {
+				status: 404,
+				headers: { "Content-Type": "text/markdown; charset=utf-8" },
+			});
+		}
+
+		return result;
+	} catch (error) {
+		console.error(`Error fetching ${label.toLowerCase()}:`, error);
+		return new NextResponse(
+			`# 500 Error\n\nFailed to fetch ${label.toLowerCase()}.`,
+			{
+				status: 500,
+				headers: { "Content-Type": "text/markdown; charset=utf-8" },
+			},
+		);
+	}
+};

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

@@ -0,0 +1,50 @@
+export interface MarkdownRoute {
+	/** Regex to match the public-facing URL */
+	regex: RegExp;
+	/** API route path template (under /api/) */
+	apiPath: string;
+	/** Public markdown URL template (for Link headers) */
+	publicPath: string;
+}
+
+/**
+ * Routes that serve markdown versions for AI agents.
+ * All pages are backed by the shared `page` document type and resolved
+ * through the catch-all route handlers.
+ *
+ * How it works:
+ * - `regex`: match the public-facing URL (e.g. /about.md or /about)
+ * - `apiPath`: the internal API route that serves the markdown (e.g. /api/about.md)
+ * - Proxy rewrites .md URLs and Accept: text/markdown requests to the API route
+ * - Route handlers live under /api/ so page.tsx can coexist at the public path
+ */
+
+/** .md extension routes -- rewrite to API endpoints */
+export const mdExtensionRoutes: MarkdownRoute[] = [
+	{
+		regex: /^\/(.+)\.md$/,
+		apiPath: "/api/[slug].md",
+		publicPath: "/[slug].md",
+	},
+];
+
+/** Accept: text/markdown routes -- content negotiation for HTML pages */
+export const acceptHeaderRoutes: MarkdownRoute[] = [
+	{
+		regex: /^\/(.+)$/,
+		apiPath: "/api/[slug].md",
+		publicPath: "/[slug].md",
+	},
+];
+
+/**
+ * Paths the proxy should never process.
+ * Studio, static files, Next.js internals.
+ */
+export const ignoredPaths = [
+	"/studio",
+	"/api/",
+	"/_next/",
+	"/favicon.ico",
+	"/sitemap.md",
+];

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

@@ -0,0 +1,130 @@
+import { contentIcon, pageIcon, type SanityStudioIcon } from "./icons";
+import { singletonComponents } from "./singletons";
+
+export type PageBuilderDocumentType =
+	| "hero"
+	| "description"
+	| "blogContent"
+	| (typeof singletonComponents)[number]["schemaType"];
+
+type PageBuilderReferenceMember = {
+	documentType: PageBuilderDocumentType;
+	name: string;
+	title: string;
+	documentId?: string;
+	groups: PageBuilderGroupName[];
+};
+
+export type PageBuilderGroupName = "generic" | "blogEntry";
+
+export const pageBuilderPageTypes: Array<{
+	title: string;
+	value: PageBuilderGroupName;
+}> = [
+	{ title: "Generic", value: "generic" },
+	{ title: "Blog Entry", value: "blogEntry" },
+];
+
+const pageCategoryIcons: Record<PageBuilderGroupName, SanityStudioIcon> = {
+	generic: pageIcon,
+	blogEntry: contentIcon,
+};
+
+export const getPageCategoryIcon = (
+	pageType: PageBuilderGroupName | undefined | null,
+) => pageCategoryIcons[pageType ?? "generic"];
+
+const reusablePageBuilderReferenceMembers: PageBuilderReferenceMember[] = [
+	{
+		documentType: "hero",
+		name: "heroReference",
+		title: "Heading",
+		groups: ["generic"],
+	},
+	{
+		documentType: "description",
+		name: "descriptionReference",
+		title: "Description",
+		groups: ["generic"],
+	},
+	{
+		documentType: "blogContent",
+		name: "blogContentReference",
+		title: "Blog Content",
+		groups: ["blogEntry"],
+	},
+];
+
+const singletonPageBuilderReferenceMembers: PageBuilderReferenceMember[] =
+	singletonComponents.map((component) => ({
+		documentType: component.schemaType,
+		name: `${component.schemaType}Reference`,
+		title: component.title,
+		documentId: component.documentId,
+		groups: ["generic"],
+	}));
+
+export const pageBuilderReferenceMembers: PageBuilderReferenceMember[] = [
+	...reusablePageBuilderReferenceMembers,
+	...singletonPageBuilderReferenceMembers,
+];
+
+export const getPageBuilderReferenceMember = (name: string) =>
+	pageBuilderReferenceMembers.find((member) => member.name === name);
+
+export const getPageBuilderReferenceMemberByDocumentType = (
+	documentType: PageBuilderDocumentType,
+) =>
+	pageBuilderReferenceMembers.find(
+		(member) => member.documentType === documentType,
+	);
+
+const isPageBuilderGroupVisible = (
+	pageType: PageBuilderGroupName | undefined,
+	group: PageBuilderGroupName,
+) => (pageType ?? "generic") === group;
+
+export const getVisiblePageBuilderReferenceMembers = (
+	pageType: PageBuilderGroupName | undefined,
+) =>
+	pageBuilderReferenceMembers.filter((member) =>
+		member.groups.some((group) => isPageBuilderGroupVisible(pageType, group)),
+	);
+
+export const getVisiblePageBuilderInsertMenuGroups = (
+	pageType: PageBuilderGroupName | undefined,
+) =>
+	pageBuilderInsertMenuGroups.filter(
+		(group) => group.name === (pageType ?? "generic"),
+	);
+
+export const getInvalidPageBuilderDocumentTypes = (
+	pageType: PageBuilderGroupName | undefined,
+	documentTypes: PageBuilderDocumentType[],
+) =>
+	documentTypes.filter((documentType) => {
+		const member = getPageBuilderReferenceMemberByDocumentType(documentType);
+
+		if (!member) return false;
+
+		return !member.groups.some((group) =>
+			isPageBuilderGroupVisible(pageType, group),
+		);
+	});
+
+export const pageBuilderInsertMenuGroups = [
+	{
+		name: "generic",
+		title: "Generic",
+		of: pageBuilderReferenceMembers
+			.filter((member) => member.groups.includes("generic"))
+			.map((member) => member.name),
+	},
+	{
+		name: "blogEntry",
+		title: "Blog Entry",
+		of: pageBuilderReferenceMembers
+			.filter((member) => member.groups.includes("blogEntry"))
+			.map((member) => member.name),
+	},
+];

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

@@ -0,0 +1,28 @@
+import type { PageBuilderGroupName } from "@/lib/integrations/sanity/page-builder-config";
+
+type PageCategoryParams = {
+	slug?: string | null;
+	folder?: string | null;
+};
+
+export const isEmptyPageSlug = (slug?: string | null) =>
+	slug == null || slug === "" || slug === "/";
+
+export const getGeneratedPageCategory = ({
+	slug,
+	folder,
+}: PageCategoryParams): PageBuilderGroupName => {
+	if (!isEmptyPageSlug(slug) && folder === "blog") return "blogEntry";
+
+	return "generic";
+};
+
+export const pageCategoryExpression = `
+  select(
+    defined(slug.current) &&
+      slug.current != "" &&
+      slug.current != "/" &&
+      pageFolder->slug.current == "blog" => "blogEntry",
+    "generic"
+  )
+`;