bsmnt 0.5.0 → 0.6.0

package/src/templates/next-webgl/lib/utils/json-ld.tsx

@@ -1,9 +1,15 @@
 import type {
   Article,
   BreadcrumbList,
+  Event as EventSchema,
+  FAQPage,
+  ItemList,
+  JobPosting,
   Organization,
   SearchAction,
+  SoftwareApplication,
   Thing,
+  VideoObject,
   WebPage,
   WebSite,
   WithContext,
@@ -41,10 +47,10 @@ export function JsonLd<T extends Thing>({ data }: { data: WithContext<T> }) {
 
 interface WebSiteJsonLdOptions {
   name: string
-  url?: string
-  description?: string
+  url?: string | undefined
+  description?: string | undefined
   /** URL to site-wide search (e.g. "/search?q={search_term_string}") */
-  searchUrl?: string
+  searchUrl?: string | undefined
 }
 
 export function generateWebSiteJsonLd(
@@ -70,21 +76,69 @@ export function generateWebSiteJsonLd(
   }
 }
 
+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
-  logo?: string
-  description?: string
-  sameAs?: 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 function generateOrganizationJsonLd(
   options: OrganizationJsonLdOptions
 ): WithContext<Organization> {
-  const { name, url, logo, description, sameAs } = options
+  const { name, url, logo, description, sameAs, legalName, contactPoint, address } =
+    options
   const resolvedUrl = resolveUrl(url)
   const resolvedLogo = resolveUrl(logo)
 
+  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",
@@ -92,17 +146,20 @@ export function generateOrganizationJsonLd(
     ...(resolvedUrl && { url: resolvedUrl }),
     ...(resolvedLogo && { logo: resolvedLogo }),
     ...(description && { description }),
-    ...(sameAs && { sameAs }),
+    ...(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
+  url?: string | undefined
+  description?: string | undefined
+  image?: string | undefined
+  datePublished?: string | undefined
+  dateModified?: string | undefined
 }
 
 export function generateWebPageJsonLd(
@@ -127,13 +184,13 @@ export function generateWebPageJsonLd(
 
 interface ArticleJsonLdOptions {
   title: string
-  url?: string
-  description?: string
-  image?: string
-  datePublished?: string
-  dateModified?: string
-  authorName?: string
-  authorUrl?: string
+  url?: string | undefined
+  description?: string | undefined
+  image?: string | undefined
+  datePublished?: string | undefined
+  dateModified?: string | undefined
+  authorName?: string | undefined
+  authorUrl?: string | undefined
 }
 
 export function generateArticleJsonLd(
@@ -194,3 +251,252 @@ export function generateBreadcrumbJsonLd(
     }),
   }
 }
+
+// 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 orgUrl = organizationUrl ? resolveUrl(organizationUrl) : undefined
+
+  const hiringOrganization = organizationName
+    ? {
+        "@type": "Organization" as const,
+        name: organizationName,
+        ...(orgUrl && { url: orgUrl }),
+      }
+    : 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 resolvedUrl = url ? resolveUrl(url) : undefined
+  const resolvedImage = image ? resolveUrl(image) : undefined
+
+  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 }),
+    ...(resolvedUrl && { url: resolvedUrl }),
+    ...(resolvedImage && { image: resolvedImage }),
+    ...(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) => {
+      const itemUrl = item.url ? resolveUrl(item.url) : undefined
+      return {
+        "@type": "ListItem" as const,
+        position: index + 1,
+        name: item.name,
+        ...(itemUrl && { url: itemUrl }),
+      }
+    }),
+  }
+}
+
+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 resolvedUrl = resolveUrl(url)
+  const resolvedImage = resolveUrl(image)
+
+  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 }),
+    ...(resolvedUrl && { url: resolvedUrl }),
+    ...(resolvedImage && { image: resolvedImage }),
+    ...(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
+  const resolvedThumbnail = resolveUrl(thumbnail) ?? thumbnail
+
+  return {
+    "@context": "https://schema.org",
+    "@type": "VideoObject",
+    name,
+    description,
+    thumbnailUrl: resolvedThumbnail,
+    uploadDate,
+    ...(contentUrl && { contentUrl }),
+    ...(embedUrl && { embedUrl }),
+  }
+}

package/src/templates/next-webgl/next.config.ts

@@ -5,6 +5,12 @@ const nextConfig: NextConfig = {
   reactStrictMode: true,
   reactCompiler: true,
   typedRoutes: true,
+  // Bundle the committed encrypted env files into serverless functions so
+  // instrumentation.ts can decrypt them at runtime. .env.keys is never listed
+  // (and is git/vercel-ignored); missing files are skipped.
+  outputFileTracingIncludes: {
+    "/**": ["./.env", "./.env.production", "./.env.preview"],
+  },
   turbopack: {
     rules: {
       "*.svg": {

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

@@ -1,244 +0,0 @@
-import type {
-	Article,
-	BreadcrumbList,
-	Organization,
-	SearchAction,
-	Thing,
-	WebPage,
-	WebSite,
-	WithContext,
-} from "schema-dts";
-
-const APP_BASE_URL = process.env.NEXT_PUBLIC_BASE_URL;
-
-function isAbsoluteUrl(value: string) {
-	return /^https?:\/\//.test(value);
-}
-
-function resolveUrl(value?: string) {
-	if (!value) return APP_BASE_URL;
-	if (isAbsoluteUrl(value)) return value;
-	if (!APP_BASE_URL) return undefined;
-
-	return new URL(value, APP_BASE_URL).toString();
-}
-
-/* -------------------------------- Component ------------------------------- */
-
-export function JsonLd<T extends Thing>({ data }: { data: WithContext<T> }) {
-	return (
-		<script
-			type="application/ld+json"
-			dangerouslySetInnerHTML={{
-				__html: JSON.stringify(data).replace(/</g, "\\u003c"),
-			}}
-		/>
-	);
-}
-
-/* -------------------------------- Generators ------------------------------ */
-
-interface WebSiteJsonLdOptions {
-	name: string;
-	url?: string;
-	description?: string;
-	/** URL to site-wide search (e.g. "/search?q={search_term_string}") */
-	searchUrl?: string;
-}
-
-export function generateWebSiteJsonLd(
-	options: WebSiteJsonLdOptions,
-): WithContext<WebSite> {
-	const { name, url, description, searchUrl } = options;
-	const resolvedUrl = resolveUrl(url);
-	const resolvedSearchUrl = resolveUrl(searchUrl);
-
-	return {
-		"@context": "https://schema.org",
-		"@type": "WebSite",
-		name,
-		...(resolvedUrl && { url: resolvedUrl }),
-		...(description && { description }),
-		...(resolvedSearchUrl && {
-			potentialAction: {
-				"@type": "SearchAction",
-				target: resolvedSearchUrl,
-				"query-input": "required name=search_term_string",
-			} as SearchAction & { "query-input": string },
-		}),
-	};
-}
-
-interface OrganizationJsonLdOptions {
-	name: string;
-	url?: string;
-	logo?: string;
-	description?: string;
-	sameAs?: string[];
-}
-
-export function generateOrganizationJsonLd(
-	options: OrganizationJsonLdOptions,
-): WithContext<Organization> {
-	const { name, url, logo, description, sameAs } = options;
-	const resolvedUrl = resolveUrl(url);
-	const resolvedLogo = resolveUrl(logo);
-
-	return {
-		"@context": "https://schema.org",
-		"@type": "Organization",
-		name,
-		...(resolvedUrl && { url: resolvedUrl }),
-		...(resolvedLogo && { logo: resolvedLogo }),
-		...(description && { description }),
-		...(sameAs && { sameAs }),
-	};
-}
-
-interface WebPageJsonLdOptions {
-	title: string;
-	url?: string;
-	description?: string;
-	image?: string;
-	datePublished?: string;
-	dateModified?: string;
-}
-
-export function generateWebPageJsonLd(
-	options: WebPageJsonLdOptions,
-): WithContext<WebPage> {
-	const { title, url, description, image, datePublished, dateModified } =
-		options;
-	const resolvedUrl = resolveUrl(url);
-	const resolvedImage = resolveUrl(image);
-
-	return {
-		"@context": "https://schema.org",
-		"@type": "WebPage",
-		name: title,
-		...(resolvedUrl && { url: resolvedUrl }),
-		...(description && { description }),
-		...(resolvedImage && { image: resolvedImage }),
-		...(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 resolvedUrl = resolveUrl(url);
-	const resolvedImage = resolveUrl(image);
-
-	return {
-		"@context": "https://schema.org",
-		"@type": "Article",
-		headline: title,
-		...(resolvedUrl && { url: resolvedUrl }),
-		...(description && { description }),
-		...(resolvedImage && { image: resolvedImage }),
-		...(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) => {
-			const resolvedItemUrl = resolveUrl(item.url);
-
-			return {
-				"@type": "ListItem",
-				position: index + 1,
-				name: item.name,
-				...(resolvedItemUrl && { item: resolvedItemUrl }),
-			};
-		}),
-	};
-}
-
-/* ----------------------------- Sanity Helpers ----------------------------- */
-
-interface SanityDocument {
-	title?: string;
-	metadata?: {
-		title?: string;
-		description?: string;
-		image?: { asset?: { url?: string } };
-	};
-	_updatedAt?: string;
-	publishedAt?: string;
-}
-
-export function generateSanityArticleJsonLd(options: {
-	document: SanityDocument;
-	url?: string;
-	authorName?: string;
-	authorUrl?: string;
-}): WithContext<Article> {
-	const { document, url, authorName, authorUrl } = options;
-
-	return generateArticleJsonLd({
-		title: document.metadata?.title || document.title || "",
-		url,
-		description: document.metadata?.description,
-		image: document.metadata?.image?.asset?.url,
-		datePublished: document.publishedAt,
-		dateModified: document._updatedAt,
-		authorName,
-		authorUrl,
-	});
-}
-
-export function generateSanityWebPageJsonLd(options: {
-	document: SanityDocument;
-	url?: string;
-}): WithContext<WebPage> {
-	const { document, url } = options;
-
-	return generateWebPageJsonLd({
-		title: document.metadata?.title || document.title || "",
-		url,
-		description: document.metadata?.description,
-		image: document.metadata?.image?.asset?.url,
-		datePublished: document.publishedAt,
-		dateModified: document._updatedAt,
-	});
-}