bsmnt 0.4.2 → 0.5.0

package/src/modules/features/cms/sanity-pagebuilder/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/files/lib/integrations/sanity/utils/page-builder-markdown.ts

@@ -0,0 +1,81 @@
+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 "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");
+};

package/src/modules/features/cms/sanity-pagebuilder/files/lib/scripts/sanity-typegen.ts

@@ -0,0 +1,45 @@
+/**
+ * Wrapper around `sanity schema extract && sanity typegen generate`
+ * that gracefully skips when Sanity is not configured.
+ */
+import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+
+const sanityDir = resolve(import.meta.dir, "../integrations/sanity");
+const envFile = resolve(import.meta.dir, "../../.env.local");
+
+// Check if Sanity project ID is configured
+const hasEnvFile = existsSync(envFile);
+
+if (!hasEnvFile) {
+	console.log("  Skipping sanity:typegen — .env.local not found");
+	process.exit(0);
+}
+
+// Read .env.local to check for project ID
+const envContent = Bun.file(envFile);
+const text = await envContent.text();
+const hasProjectId = text
+	.split("\n")
+	.some(
+		(line) =>
+			line.startsWith("NEXT_PUBLIC_SANITY_PROJECT_ID=") &&
+			line.split("=")[1]?.trim() !== "",
+	);
+
+if (!hasProjectId) {
+	console.log(
+		"  Skipping sanity:typegen — NEXT_PUBLIC_SANITY_PROJECT_ID not set",
+	);
+	process.exit(0);
+}
+
+try {
+	execSync(
+		`cd ${sanityDir} && bun --env-file ../../../.env.local sanity schema extract && bun --env-file ../../../.env.local sanity typegen generate && bun biome check --write --unsafe`,
+		{ stdio: "inherit" },
+	);
+} catch {
+	console.warn("  sanity:typegen failed — continuing anyway");
+}

package/src/modules/features/cms/sanity-pagebuilder/files/lib/utils/check-redirect.ts

@@ -0,0 +1,30 @@
+import { stegaClean } from "@sanity/client/stega";
+import type { Route } from "next";
+import { permanentRedirect, redirect } from "next/navigation";
+import { getRedirects } from "@/lib/integrations/sanity/fetchers/redirects";
+
+const normalize = (path: string) =>
+	path.replace(/^\/+/, "").replace(/\/+$/, "");
+
+/** Redirect (308 permanent / 307 temporary) if `path` matches a redirect source. */
+export const checkRedirect = async (path: string | null): Promise<void> => {
+	const redirects = await getRedirects();
+	if (redirects.length === 0) return;
+
+	const source = normalize(path ?? "");
+	const match = redirects.find(
+		(entry) =>
+			entry.source && normalize(stegaClean(entry.source) ?? "") === source,
+	);
+	if (!match?.destination) return;
+
+	const destination = stegaClean(match.destination) ?? "";
+	const href = (
+		/^https?:\/\//.test(destination)
+			? destination
+			: `/${normalize(destination)}`
+	) as Route;
+
+	if (match.permanent === false) redirect(href);
+	permanentRedirect(href);
+};

package/src/modules/features/cms/sanity-pagebuilder/files/lib/utils/json-ld.tsx

@@ -0,0 +1,212 @@
+import type {
+	Article,
+	BreadcrumbList,
+	Organization,
+	Thing,
+	WebPage,
+	WebSite,
+	WithContext,
+} from "schema-dts";
+import { getBaseUrl } from "./base-url";
+
+const BASE_URL = getBaseUrl();
+
+interface JsonLdProps<T extends Thing> {
+	data: WithContext<T>;
+}
+
+const serializeJsonLd = <T extends Thing>(data: WithContext<T>) =>
+	JSON.stringify(data).replace(/</g, "\\u003c");
+
+export const JsonLd = <T extends Thing>({ data }: JsonLdProps<T>) => (
+	<script
+		type="application/ld+json"
+		dangerouslySetInnerHTML={{ __html: serializeJsonLd(data) }}
+	/>
+);
+
+interface WebSiteJsonLdOptions {
+	name: string;
+	url?: string;
+	description?: string;
+}
+
+export const generateWebSiteJsonLd = (
+	options: WebSiteJsonLdOptions,
+): WithContext<WebSite> => {
+	const { name, url = BASE_URL, description } = options;
+	return {
+		"@context": "https://schema.org",
+		"@type": "WebSite",
+		name,
+		...(url ? { url } : {}),
+		...(description && { description }),
+	};
+};
+
+interface OrganizationJsonLdOptions {
+	name: string;
+	url?: string;
+	logo?: string;
+	description?: string;
+	sameAs?: string[];
+}
+
+export const generateOrganizationJsonLd = (
+	options: OrganizationJsonLdOptions,
+): WithContext<Organization> => {
+	const { name, url = BASE_URL, logo, description, sameAs } = options;
+
+	return {
+		"@context": "https://schema.org",
+		"@type": "Organization",
+		name,
+		...(url ? { url } : {}),
+		...(logo && { logo: `${BASE_URL}${logo}` }),
+		...(description && { description }),
+		...(sameAs && { sameAs }),
+	};
+};
+
+interface WebPageJsonLdOptions {
+	title: string;
+	url?: string;
+	description?: string;
+	image?: string;
+	datePublished?: string;
+	dateModified?: string;
+}
+
+export const generateWebPageJsonLd = (
+	options: WebPageJsonLdOptions,
+): WithContext<WebPage> => {
+	const { title, url, description, image, datePublished, dateModified } =
+		options;
+	const fullUrl = url ? `${BASE_URL}${url}` : BASE_URL;
+
+	return {
+		"@context": "https://schema.org",
+		"@type": "WebPage",
+		name: title,
+		...(fullUrl ? { url: fullUrl } : {}),
+		...(description && { description }),
+		...(image && { image }),
+		...(datePublished && { datePublished }),
+		...(dateModified && { dateModified }),
+	};
+};
+
+interface ArticleJsonLdOptions {
+	title: string;
+	url?: string;
+	description?: string;
+	image?: string;
+	datePublished?: string;
+	dateModified?: string;
+	authorName?: string;
+	authorUrl?: string;
+}
+
+export function generateArticleJsonLd(
+	options: ArticleJsonLdOptions,
+): WithContext<Article> {
+	const {
+		title,
+		url,
+		description,
+		image,
+		datePublished,
+		dateModified,
+		authorName,
+		authorUrl,
+	} = options;
+	const fullUrl = url ? `${BASE_URL}${url}` : BASE_URL;
+	return {
+		"@context": "https://schema.org",
+		"@type": "Article",
+		headline: title,
+		...(fullUrl ? { url: fullUrl } : {}),
+		...(description && { description }),
+		...(image && { image }),
+		...(datePublished && { datePublished }),
+		...(dateModified && { dateModified }),
+		...(authorName && {
+			author: {
+				"@type": "Person",
+				name: authorName,
+				...(authorUrl && { url: authorUrl }),
+			},
+		}),
+	};
+}
+
+interface BreadcrumbItem {
+	name: string;
+	url: string;
+}
+
+export function generateBreadcrumbJsonLd(
+	items: BreadcrumbItem[],
+): WithContext<BreadcrumbList> {
+	return {
+		"@context": "https://schema.org",
+		"@type": "BreadcrumbList",
+		itemListElement: items.map((item, index) => ({
+			"@type": "ListItem" as const,
+			position: index + 1,
+			name: item.name,
+			item: `${BASE_URL}${item.url}`,
+		})),
+	};
+}
+
+/* ——————————————————————————————————————————————————————————
+ * Sanity helpers
+ *
+ * Accept flat options instead of a document shape so they
+ * work with any Sanity type without interface mismatches.
+ * —————————————————————————————————————————————————————————— */
+
+interface SanityArticleJsonLdOptions {
+	title: string;
+	url: string;
+	description?: string | null | undefined;
+	image?: string | null | undefined;
+	datePublished?: string | null | undefined;
+	dateModified?: string;
+	authorName?: string | null | undefined;
+	authorUrl?: string | null | undefined;
+}
+
+export function generateSanityArticleJsonLd(
+	options: SanityArticleJsonLdOptions,
+): WithContext<Article> {
+	const opts: ArticleJsonLdOptions = { title: options.title, url: options.url };
+	if (options.description) opts.description = options.description;
+	if (options.image) opts.image = options.image;
+	if (options.datePublished) opts.datePublished = options.datePublished;
+	if (options.dateModified) opts.dateModified = options.dateModified;
+	if (options.authorName) opts.authorName = options.authorName;
+	if (options.authorUrl) opts.authorUrl = options.authorUrl;
+	return generateArticleJsonLd(opts);
+}
+
+interface SanityWebPageJsonLdOptions {
+	title: string;
+	url: string;
+	description?: string | null | undefined;
+	image?: string | null | undefined;
+	datePublished?: string | null | undefined;
+	dateModified?: string;
+}
+
+export function generateSanityWebPageJsonLd(
+	options: SanityWebPageJsonLdOptions,
+): WithContext<WebPage> {
+	const opts: WebPageJsonLdOptions = { title: options.title, url: options.url };
+	if (options.description) opts.description = options.description;
+	if (options.image) opts.image = options.image;
+	if (options.datePublished) opts.datePublished = options.datePublished;
+	if (options.dateModified) opts.dateModified = options.dateModified;
+	return generateWebPageJsonLd(opts);
+}

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

@@ -0,0 +1,167 @@
+import type { Metadata } from "next";
+import { urlForImage } from "@/lib/integrations/sanity/utils/image";
+import { getBaseUrl } from "./base-url";
+
+interface GenerateMetadataOptions {
+	title?: string | undefined;
+	description?: string | undefined;
+	keywords?: string[] | undefined;
+	image?:
+		| {
+				url?: string | undefined;
+				width?: number | undefined;
+				height?: number | undefined;
+		  }
+		| undefined;
+	url?: string | undefined;
+	siteName?: string | undefined;
+	index?: boolean | undefined;
+	noIndex?: boolean | undefined;
+	type?: "website" | "article";
+	publishedTime?: string | undefined;
+	modifiedTime?: string | undefined;
+	authors?: string[] | undefined;
+}
+
+interface SanityMetadataImage {
+	asset?: {
+		_ref?: string;
+		_type?: "reference";
+	};
+}
+
+interface SanityPageMetadata {
+	metaTitle?: string | null;
+	metaDescription?: string | null;
+	og?: {
+		image?: SanityMetadataImage | null;
+	} | null;
+	index?: boolean | null;
+	title?: string | null;
+	description?: string | null;
+	image?: SanityMetadataImage | null;
+	noIndex?: boolean | null;
+}
+
+interface SanityMetadataDocument {
+	title?: string | null;
+	subtitle?: string | null;
+	metadata?: SanityPageMetadata | null;
+}
+
+interface GenerateSanityMetadataOptions {
+	document: SanityMetadataDocument;
+	url?: string;
+	siteName?: string;
+	type?: "website" | "article";
+}
+
+const APP_BASE_URL = getBaseUrl();
+
+/**
+ * Generate complete metadata object for pages
+ *
+ * @example
+ * ```ts
+ * export async function generateMetadata({ params }) {
+ *   const page = await fetchPage(params.slug)
+ *
+ *   return generatePageMetadata({
+ *     title: page.metadata?.title || page.title,
+ *     description: page.metadata?.description,
+ *     image: { url: page.metadata?.image?.asset?.url },
+ *     url: `/page/${params.slug}`,
+ *     noIndex: page.metadata?.noIndex,
+ *   })
+ * }
+ * ```
+ */
+const generatePageMetadata = (options: GenerateMetadataOptions): Metadata => {
+	const {
+		title,
+		description,
+		keywords,
+		image,
+		url,
+		siteName = "Basement",
+		index,
+		noIndex = false,
+		type = "website",
+		publishedTime,
+		modifiedTime,
+		authors,
+	} = options;
+
+	const shouldIndex = index ?? !noIndex;
+	const fullUrl = url ? `${APP_BASE_URL}${url}` : APP_BASE_URL;
+	const imageUrl = image?.url || "/opengraph-image.jpg";
+	const width = image?.width || 1200;
+	const height = image?.height || 630;
+
+	const metadata: Metadata = {
+		metadataBase: new URL(APP_BASE_URL),
+		title,
+		description,
+		keywords,
+		alternates: { canonical: url || "/" },
+		openGraph: {
+			title,
+			description,
+			url: fullUrl,
+			siteName,
+			locale: "en_US",
+			type,
+			images: [{ url: imageUrl, width, height }],
+			...(publishedTime && { publishedTime }),
+			...(modifiedTime && { modifiedTime }),
+			...(authors && { authors }),
+		},
+		twitter: {
+			card: "summary_large_image",
+			title,
+			description,
+			images: [{ url: imageUrl, width, height }],
+		},
+		other: { "fb:app_id": process.env.NEXT_PUBLIC_FACEBOOK_APP_ID || "" },
+	};
+
+	if (!shouldIndex) metadata.robots = { index: false, follow: false };
+
+	return metadata;
+};
+
+export const generateSanityMetadata = ({
+	document,
+	url,
+	siteName,
+	type = "website",
+}: GenerateSanityMetadataOptions): Metadata => {
+	const pageMetadata = document.metadata;
+	const title =
+		pageMetadata?.metaTitle ||
+		pageMetadata?.title ||
+		document.title ||
+		undefined;
+	const description =
+		pageMetadata?.metaDescription ||
+		pageMetadata?.description ||
+		document.subtitle ||
+		undefined;
+	const socialImageSource = pageMetadata?.image || pageMetadata?.og?.image;
+	const imageUrl = socialImageSource
+		? urlForImage(socialImageSource).width(1200).height(630).url()
+		: undefined;
+	const index =
+		pageMetadata?.index ??
+		(pageMetadata?.noIndex != null ? !pageMetadata.noIndex : true);
+
+	return generatePageMetadata({
+		title,
+		description,
+		image: imageUrl ? { url: imageUrl, width: 1200, height: 630 } : undefined,
+		url,
+		siteName,
+		index,
+		type,
+	});
+};