bsmnt 0.10.0 → 0.11.0

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

@@ -0,0 +1,522 @@
+import type {
+	Article,
+	BreadcrumbList,
+	Event as EventSchema,
+	FAQPage,
+	ItemList,
+	JobPosting,
+	Organization,
+	SoftwareApplication,
+	Thing,
+	VideoObject,
+	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"
+		// biome-ignore lint/security/noDangerouslySetInnerHtml: serialized JSON-LD, not user HTML; `<` is escaped
+		dangerouslySetInnerHTML={{ __html: serializeJsonLd(data) }}
+	/>
+);
+
+interface WebSiteJsonLdOptions {
+	name: string;
+	url?: string | undefined;
+	description?: string | undefined;
+}
+
+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 }),
+	};
+};
+
+// Sanity asset URLs are already absolute (cdn.sanity.io); only prefix the
+// origin for app-relative paths like "/logo.svg".
+const toAbsoluteUrl = (value: string) =>
+	/^https?:\/\//.test(value) ? value : `${BASE_URL}${value}`;
+
+interface OrganizationContactPoint {
+	email?: string | null;
+	telephone?: string | null;
+	contactType?: string | null;
+}
+
+interface OrganizationAddress {
+	streetAddress?: string | null;
+	locality?: string | null;
+	region?: string | null;
+	postalCode?: string | null;
+	country?: string | null;
+}
+
+interface OrganizationJsonLdOptions {
+	name: string;
+	url?: string | undefined;
+	logo?: string | undefined;
+	description?: string | undefined;
+	sameAs?: string[] | undefined;
+	legalName?: string | undefined;
+	contactPoint?: OrganizationContactPoint | null | undefined;
+	address?: OrganizationAddress | null | undefined;
+}
+
+export const generateOrganizationJsonLd = (
+	options: OrganizationJsonLdOptions,
+): WithContext<Organization> => {
+	const {
+		name,
+		url = BASE_URL,
+		logo,
+		description,
+		sameAs,
+		legalName,
+		contactPoint,
+		address,
+	} = options;
+
+	const contactPointNode =
+		contactPoint &&
+		(contactPoint.email || contactPoint.telephone || contactPoint.contactType)
+			? {
+					"@type": "ContactPoint" as const,
+					...(contactPoint.email && { email: contactPoint.email }),
+					...(contactPoint.telephone && {
+						telephone: contactPoint.telephone,
+					}),
+					...(contactPoint.contactType && {
+						contactType: contactPoint.contactType,
+					}),
+				}
+			: undefined;
+
+	const addressNode =
+		address &&
+		(address.streetAddress ||
+			address.locality ||
+			address.region ||
+			address.postalCode ||
+			address.country)
+			? {
+					"@type": "PostalAddress" as const,
+					...(address.streetAddress && {
+						streetAddress: address.streetAddress,
+					}),
+					...(address.locality && { addressLocality: address.locality }),
+					...(address.region && { addressRegion: address.region }),
+					...(address.postalCode && { postalCode: address.postalCode }),
+					...(address.country && { addressCountry: address.country }),
+				}
+			: undefined;
+
+	return {
+		"@context": "https://schema.org",
+		"@type": "Organization",
+		name,
+		...(url ? { url } : {}),
+		...(logo && { logo: toAbsoluteUrl(logo) }),
+		...(description && { description }),
+		...(legalName && { legalName }),
+		...(sameAs?.length && { sameAs }),
+		...(contactPointNode && { contactPoint: contactPointNode }),
+		...(addressNode && { address: addressNode }),
+	};
+};
+
+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 — flat options instead of document shapes, so they fit any type.
+
+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);
+}
+
+// Page-level generators for the schema.org blocks editors attach via
+// `metadata.jsonLd`. Plain options keep them CMS-independent.
+
+export interface FaqJsonLdItem {
+	question: string;
+	answer: string;
+}
+
+export function generateFaqJsonLd(
+	items: FaqJsonLdItem[],
+): WithContext<FAQPage> {
+	return {
+		"@context": "https://schema.org",
+		"@type": "FAQPage",
+		mainEntity: items.map((item) => ({
+			"@type": "Question" as const,
+			name: item.question,
+			acceptedAnswer: {
+				"@type": "Answer" as const,
+				text: item.answer,
+			},
+		})),
+	};
+}
+
+export interface JobPostingJsonLdOptions {
+	title: string;
+	description: string;
+	datePosted: string;
+	validThrough?: string | undefined;
+	employmentType?: string | undefined;
+	organizationName?: string | undefined;
+	organizationUrl?: string | undefined;
+	remote?: boolean | undefined;
+	locality?: string | undefined;
+	region?: string | undefined;
+	country?: string | undefined;
+}
+
+export function generateJobPostingJsonLd(
+	options: JobPostingJsonLdOptions,
+): WithContext<JobPosting> {
+	const {
+		title,
+		description,
+		datePosted,
+		validThrough,
+		employmentType,
+		organizationName,
+		organizationUrl,
+		remote,
+		locality,
+		region,
+		country,
+	} = options;
+
+	const hiringOrganization = organizationName
+		? {
+				"@type": "Organization" as const,
+				name: organizationName,
+				...(organizationUrl && { url: toAbsoluteUrl(organizationUrl) }),
+			}
+		: undefined;
+
+	const jobLocation =
+		locality || region || country
+			? {
+					"@type": "Place" as const,
+					address: {
+						"@type": "PostalAddress" as const,
+						...(locality && { addressLocality: locality }),
+						...(region && { addressRegion: region }),
+						...(country && { addressCountry: country }),
+					},
+				}
+			: undefined;
+
+	return {
+		"@context": "https://schema.org",
+		"@type": "JobPosting",
+		title,
+		description,
+		datePosted,
+		...(validThrough && { validThrough }),
+		...(employmentType && { employmentType }),
+		...(hiringOrganization && { hiringOrganization }),
+		...(remote && { jobLocationType: "TELECOMMUTE" }),
+		...(jobLocation && { jobLocation }),
+	};
+}
+
+export interface SoftwareApplicationJsonLdOptions {
+	name: string;
+	description?: string | undefined;
+	applicationCategory?: string | undefined;
+	operatingSystem?: string | undefined;
+	price?: number | undefined;
+	currency?: string | undefined;
+	url?: string | undefined;
+	image?: string | undefined;
+}
+
+export function generateSoftwareApplicationJsonLd(
+	options: SoftwareApplicationJsonLdOptions,
+): WithContext<SoftwareApplication> {
+	const {
+		name,
+		description,
+		applicationCategory,
+		operatingSystem,
+		price,
+		currency,
+		url,
+		image,
+	} = options;
+
+	const offers =
+		typeof price === "number"
+			? {
+					"@type": "Offer" as const,
+					price: price.toString(),
+					...(currency && { priceCurrency: currency }),
+				}
+			: undefined;
+
+	return {
+		"@context": "https://schema.org",
+		"@type": "SoftwareApplication",
+		name,
+		...(description && { description }),
+		...(applicationCategory && { applicationCategory }),
+		...(operatingSystem && { operatingSystem }),
+		...(url && { url: toAbsoluteUrl(url) }),
+		...(image && { image: toAbsoluteUrl(image) }),
+		...(offers && { offers }),
+	};
+}
+
+export interface ItemListEntry {
+	name: string;
+	url?: string | undefined;
+}
+
+export interface ItemListJsonLdOptions {
+	name?: string | undefined;
+	items: ItemListEntry[];
+}
+
+export function generateItemListJsonLd(
+	options: ItemListJsonLdOptions,
+): WithContext<ItemList> {
+	const { name, items } = options;
+
+	return {
+		"@context": "https://schema.org",
+		"@type": "ItemList",
+		...(name && { name }),
+		itemListElement: items.map((item, index) => ({
+			"@type": "ListItem" as const,
+			position: index + 1,
+			name: item.name,
+			...(item.url && { url: toAbsoluteUrl(item.url) }),
+		})),
+	};
+}
+
+export interface EventJsonLdOptions {
+	name: string;
+	description?: string | undefined;
+	startDate: string;
+	endDate?: string | undefined;
+	locationName?: string | undefined;
+	locationAddress?: string | undefined;
+	url?: string | undefined;
+	image?: string | undefined;
+}
+
+export function generateEventJsonLd(
+	options: EventJsonLdOptions,
+): WithContext<EventSchema> {
+	const {
+		name,
+		description,
+		startDate,
+		endDate,
+		locationName,
+		locationAddress,
+		url,
+		image,
+	} = options;
+
+	const location =
+		locationName || locationAddress
+			? {
+					"@type": "Place" as const,
+					...(locationName && { name: locationName }),
+					...(locationAddress && { address: locationAddress }),
+				}
+			: undefined;
+
+	return {
+		"@context": "https://schema.org",
+		"@type": "Event",
+		name,
+		startDate,
+		...(endDate && { endDate }),
+		...(description && { description }),
+		...(url && { url: toAbsoluteUrl(url) }),
+		...(image && { image: toAbsoluteUrl(image) }),
+		...(location && { location }),
+	};
+}
+
+export interface VideoJsonLdOptions {
+	name: string;
+	description: string;
+	thumbnail: string;
+	uploadDate: string;
+	contentUrl?: string | undefined;
+	embedUrl?: string | undefined;
+}
+
+export function generateVideoJsonLd(
+	options: VideoJsonLdOptions,
+): WithContext<VideoObject> {
+	const { name, description, thumbnail, uploadDate, contentUrl, embedUrl } =
+		options;
+
+	return {
+		"@context": "https://schema.org",
+		"@type": "VideoObject",
+		name,
+		description,
+		thumbnailUrl: toAbsoluteUrl(thumbnail),
+		uploadDate,
+		...(contentUrl && { contentUrl }),
+		...(embedUrl && { embedUrl }),
+	};
+}

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

@@ -0,0 +1,189 @@
+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;
+	ogTitle?: string | undefined;
+	ogDescription?: string | undefined;
+	canonicalUrl?: 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;
+	keywords?: string[] | null;
+	ogTitle?: string | null;
+	ogDescription?: string | null;
+	canonicalUrl?: 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,
+		ogTitle,
+		ogDescription,
+		canonicalUrl,
+		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;
+
+	// Social title/description fall back to the SEO meta title/description.
+	const socialTitle = ogTitle || title;
+	const socialDescription = ogDescription || description;
+
+	const metadata: Metadata = {
+		metadataBase: new URL(APP_BASE_URL),
+		title,
+		description,
+		keywords,
+		alternates: { canonical: canonicalUrl || url || "/" },
+		openGraph: {
+			description: socialDescription,
+			url: fullUrl,
+			siteName,
+			locale: "en_US",
+			type,
+			images: [{ url: imageUrl, width, height }],
+			...(socialTitle && { title: socialTitle }),
+			...(publishedTime && { publishedTime }),
+			...(modifiedTime && { modifiedTime }),
+			...(authors && { authors }),
+		},
+		twitter: {
+			card: "summary_large_image",
+			description: socialDescription,
+			images: [{ url: imageUrl, width, height }],
+			...(socialTitle && { title: socialTitle }),
+		},
+		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);
+
+	const keywords = pageMetadata?.keywords?.length
+		? pageMetadata.keywords
+		: undefined;
+
+	return generatePageMetadata({
+		title,
+		description,
+		keywords,
+		ogTitle: pageMetadata?.ogTitle || undefined,
+		ogDescription: pageMetadata?.ogDescription || undefined,
+		canonicalUrl: pageMetadata?.canonicalUrl || undefined,
+		image: imageUrl ? { url: imageUrl, width: 1200, height: 630 } : undefined,
+		url,
+		siteName,
+		index,
+		type,
+	});
+};