bsmnt 0.2.11 → 0.3.1

package/src/templates/next-pagebuilder/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/templates/next-pagebuilder/lib/styles/cn.ts

@@ -0,0 +1,5 @@
+import { cx } from "class-variance-authority"
+import type { ClassValue } from "class-variance-authority/types"
+import { twMerge } from "tailwind-merge"
+
+export const cn = (...inputs: ClassValue[]) => twMerge(cx(inputs))

package/src/templates/next-pagebuilder/lib/styles/global.css

@@ -0,0 +1,70 @@
+@import "tailwindcss";
+
+@theme {
+  --breakpoint-*: initial;
+  --breakpoint-desktop-large: 1920px;
+  --breakpoint-desktop: 1440px;
+  --breakpoint-tablet-lg: 1024px;
+  --breakpoint-tablet: 768px;
+  --breakpoint-mobile: 640px;
+
+  --color-*: initial;
+  --color-primary: #ffffff;
+  --color-secondary: #000000;
+  --color-contrast: #ff4d00;
+  --color-black: #000000;
+  --color-white: #ffffff;
+  --color-orange: #ff4d00;
+  --color-blue: #487cff;
+  --color-green: #00ff9b;
+  --color-violet: #f101a5;
+  --color-pink: #ff73a6;
+  --color-gray: #666666;
+
+  /* gray */
+  --color-gray-50: #f5f5f5;
+  --color-gray-100: #e0e0e0;
+  --color-gray-200: #c2c2c2;
+  --color-gray-300: #a3a3a3;
+  --color-gray-400: #858585;
+  --color-gray-500: #666666;
+  --color-gray-600: #4d4d4d;
+  --color-gray-700: #333333;
+  --color-gray-800: #1a1a1a;
+}
+
+@theme inline {
+  --font-geist: var(--font-geist-variable);
+}
+
+html {
+  --scrollbar-gutter: 0px;
+  scrollbar-gutter: stable;
+}
+
+body {
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+
+  @apply flex flex-col bg-primary text-secondary overscroll-none min-h-svh;
+}
+
+*:focus-visible {
+  outline: 2px solid var(--color-contrast);
+  @apply outline-2 outline-contrast;
+}
+
+img {
+  -webkit-touch-callout: none;
+  -webkit-user-select: none;
+  -moz-user-select: none;
+  -ms-user-select: none;
+  -o-user-select: none;
+  user-select: none;
+}
+
+button {
+  cursor: pointer;
+  user-select: none;
+}
+

package/src/templates/next-pagebuilder/lib/utils/base-url.ts

@@ -0,0 +1,17 @@
+/**
+ * Centralized base URL resolution.
+ *
+ * Priority:
+ * 1. NEXT_PUBLIC_BASE_URL (explicit production URL)
+ * 2. VERCEL_PROJECT_PRODUCTION_URL (Vercel production domain)
+ * 3. VERCEL_URL (Vercel preview/deployment URL)
+ * 4. http://localhost:3000 (local development)
+ */
+export const getBaseUrl = () =>
+  process.env.NEXT_PUBLIC_BASE_URL ||
+  (process.env.VERCEL_PROJECT_PRODUCTION_URL
+    ? `https://${process.env.VERCEL_PROJECT_PRODUCTION_URL}`
+    : undefined) ||
+  (process.env.VERCEL_URL
+    ? `https://${process.env.VERCEL_URL}`
+    : "http://localhost:3000")

package/src/templates/next-pagebuilder/lib/utils/format-date.ts

@@ -0,0 +1,8 @@
+const options: Intl.DateTimeFormatOptions = {
+  year: "numeric",
+  month: "long",
+  day: "numeric",
+}
+
+export const formatDate = (date: Date | string | number) =>
+  new Date(date).toLocaleDateString("en-US", options)

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

@@ -0,0 +1,213 @@
+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"
+    // biome-ignore lint/security/noDangerouslySetInnerHtml: JSON-LD must be emitted as raw script text, and the payload is serialized and `<`-escaped first.
+    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/templates/next-pagebuilder/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,
+  })
+}

package/src/templates/next-pagebuilder/lib/utils/sitemap.ts

@@ -0,0 +1,37 @@
+import { PAGE_SITEMAP_QUERY } from "@/lib/integrations/sanity/queries"
+import type { PAGE_SITEMAP_QUERY_RESULT } from "@/lib/integrations/sanity/sanity.types"
+import { getBaseUrl } from "./base-url"
+
+export const getSitemapBaseUrl = getBaseUrl
+
+const getNormalizedPageSlug = (slug: string | null) => {
+  if (!slug || slug === "/") return ""
+  return slug.replace(/^\/+|\/+$/g, "")
+}
+
+export const getPagePath = (slug: string | null) => {
+  const normalizedSlug = getNormalizedPageSlug(slug)
+  return normalizedSlug ? `/${normalizedSlug}` : "/"
+}
+
+export const getPageUrl = (baseUrl: string, slug: string | null) =>
+  new URL(getPagePath(slug), baseUrl).toString()
+
+export const getMarkdownPath = (baseUrl: string, slug: string | null) => {
+  const normalizedSlug = getNormalizedPageSlug(slug)
+
+  return normalizedSlug
+    ? `${baseUrl}/${normalizedSlug}.md`
+    : `${baseUrl}/index.md`
+}
+
+export const getSitemap = async () => {
+  const sanityModule = await import("@/lib/integrations/sanity/client")
+  const client = sanityModule?.client
+
+  if (!client) return null
+
+  const p = await client.fetch<PAGE_SITEMAP_QUERY_RESULT>(PAGE_SITEMAP_QUERY)
+
+  return p
+}

package/src/templates/next-pagebuilder/lib/utils/slug-tag.ts

@@ -0,0 +1,6 @@
+export const getSlugTag = (slug: string | null | undefined) => {
+  const normalizedSlug = slug?.replace(/^\/+|\/+$/g, "") ?? ""
+  const lastSlugSegment = normalizedSlug.split("/").filter(Boolean).at(-1)
+
+  return lastSlugSegment ?? "homepage"
+}

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

@@ -0,0 +1,134 @@
+import withBundleAnalyzer from "@next/bundle-analyzer"
+import type { NextConfig } from "next"
+
+const nextConfig: NextConfig = {
+  reactStrictMode: true,
+  reactCompiler: true,
+  typedRoutes: true,
+  turbopack: {
+    rules: {
+      "*.svg": {
+        loaders: [
+          {
+            loader: "@svgr/webpack",
+            options: {
+              memo: true,
+              dimensions: false,
+              svgoConfig: {
+                multipass: true,
+                plugins: [
+                  "removeDimensions",
+                  "removeOffCanvasPaths",
+                  "reusePaths",
+                  "removeElementsByAttr",
+                  "removeStyleElement",
+                  "removeScriptElement",
+                  "prefixIds",
+                  "cleanupIds",
+                  {
+                    name: "cleanupNumericValues",
+                    params: {
+                      floatPrecision: 1,
+                    },
+                  },
+                  {
+                    name: "convertPathData",
+                    params: {
+                      floatPrecision: 1,
+                    },
+                  },
+                  {
+                    name: "convertTransform",
+                    params: {
+                      floatPrecision: 1,
+                    },
+                  },
+                  {
+                    name: "cleanupListOfValues",
+                    params: {
+                      floatPrecision: 1,
+                    },
+                  },
+                ],
+              },
+            },
+          },
+        ],
+        as: "*.js",
+      },
+    },
+  },
+  logging: {
+    browserToTerminal: true,
+  },
+  experimental: {
+    optimizePackageImports: [
+      "@react-three/drei",
+      "@react-three/fiber",
+      "gsap",
+      "three",
+      "postprocessing",
+      "lenis",
+    ],
+  },
+  images: {
+    dangerouslyAllowSVG: true,
+    remotePatterns: [
+      {
+        protocol: "https",
+        hostname: "cdn.sanity.io",
+      },
+    ],
+    minimumCacheTTL: 60 * 60 * 24 * 30, // 30 days
+    qualities: [90],
+    formats: ["image/avif", "image/webp"],
+    deviceSizes: [640, 750, 828, 1080, 1200, 1920, 2048, 3840],
+    imageSizes: [16, 32, 48, 64, 96, 128, 256, 384],
+  },
+  headers: async () => [
+    {
+      source: "/(.*)",
+      headers: [
+        {
+          key: "X-Content-Type-Options",
+          value: "nosniff",
+        },
+        {
+          key: "Content-Security-Policy",
+          value: "frame-ancestors 'self';",
+        },
+        {
+          key: "X-Frame-Options",
+          value: "SAMEORIGIN",
+        },
+        {
+          key: "X-XSS-Protection",
+          value: "1; mode=block",
+        },
+        {
+          key: "X-DNS-Prefetch-Control",
+          value: "on",
+        },
+        {
+          key: "Strict-Transport-Security",
+          value: "max-age=63072000; includeSubDomains; preload",
+        },
+        {
+          key: "Permissions-Policy",
+          value: "camera=(), microphone=(), geolocation=()",
+        },
+      ],
+    },
+  ],
+}
+
+const bundleAnalyzerPlugin = withBundleAnalyzer({
+  enabled: process.env.ANALYZE === "true",
+})
+
+const NextApp = () => {
+  const plugins = [bundleAnalyzerPlugin]
+  return plugins.reduce((config, plugin) => plugin(config), nextConfig)
+}
+
+export default NextApp