bsmnt 0.4.0 → 0.4.2

package/src/templates/next-pagebuilder/lib/scripts/sanity-typegen.ts

@@ -1,45 +0,0 @@
-/**
- * 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/utils/json-ld.tsx

@@ -1,213 +0,0 @@
-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

@@ -1,167 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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/proxy.ts

@@ -1,81 +0,0 @@
-import type { NextRequest } from "next/server"
-import { NextResponse } from "next/server"
-import {
-  acceptHeaderRoutes,
-  ignoredPaths,
-  mdExtensionRoutes,
-} from "@/lib/integrations/sanity/markdown-proxy.config"
-
-export function proxy(request: NextRequest) {
-  const { pathname } = request.nextUrl
-  const acceptHeader = request.headers.get("accept") || ""
-
-  if (ignoredPaths.some((p) => pathname.startsWith(p))) {
-    return NextResponse.next()
-  }
-
-  if (pathname === "/" && acceptHeader.includes("text/markdown")) {
-    const url = request.nextUrl.clone()
-    url.pathname = "/api/index.md"
-    return NextResponse.rewrite(url)
-  }
-
-  // 1. Rewrite .md extension URLs to API routes
-  //    e.g. /about.md → /api/about.md
-  for (const route of mdExtensionRoutes) {
-    const match = route.regex.exec(pathname)
-    if (match) {
-      const slug = match[1]
-      const url = request.nextUrl.clone()
-      url.pathname = route.apiPath.replace("[slug]", slug!)
-      return NextResponse.rewrite(url)
-    }
-  }
-
-  // 2. Accept: text/markdown — rewrite to markdown API route
-  if (acceptHeader.includes("text/markdown")) {
-    for (const route of acceptHeaderRoutes) {
-      const match = route.regex.exec(pathname)
-      if (match) {
-        const slug = match[1]
-        const url = request.nextUrl.clone()
-        url.pathname = route.apiPath.replace("[slug]", slug!)
-        return NextResponse.rewrite(url)
-      }
-    }
-  }
-
-  // 3. Add Link header for markdown discoverability on HTML page requests
-  const response = NextResponse.next()
-
-  if (pathname === "/") {
-    response.headers.set(
-      "Link",
-      '</index.md>; rel="alternate"; type="text/markdown"'
-    )
-    response.headers.set("Vary", "Accept")
-    return response
-  }
-
-  for (const route of acceptHeaderRoutes) {
-    const match = route.regex.exec(pathname)
-    if (match) {
-      const slug = match[1]
-      const mdUrl = route.publicPath.replace("[slug]", slug!)
-      response.headers.set(
-        "Link",
-        `<${mdUrl}>; rel="alternate"; type="text/markdown"`
-      )
-      response.headers.set("Vary", "Accept")
-      break
-    }
-  }
-
-  return response
-}
-
-export const config = {
-  matcher: [
-    "/((?!_next/static|_next/image|favicon.ico|sitemap.xml|sitemap.md|robots.txt).*)",
-  ],
-}

package/src/templates/next-webgl/css.d.ts

@@ -1 +0,0 @@
-declare module "*.css"

package/src/templates/next-webgl/lib/utils/portable-text-to-markdown.ts

@@ -1,83 +0,0 @@
-export interface PortableTextMarkDefinition {
-  _key?: string;
-  _type?: string;
-  href?: string;
-}
-
-export interface PortableTextSpan {
-  _type?: string;
-  text?: string;
-  marks?: string[];
-}
-
-export interface PortableTextBlock {
-  _type?: string;
-  style?: string;
-  listItem?: "bullet" | "number";
-  level?: number;
-  children?: PortableTextSpan[];
-  markDefs?: PortableTextMarkDefinition[];
-}
-
-const headingStyles: Record<string, string> = {
-  h1: "#",
-  h2: "##",
-  h3: "###",
-  h4: "####",
-  h5: "#####",
-  h6: "######",
-}
-
-function applyMarks(
-  text: string,
-  marks: string[] | undefined,
-  markDefs: PortableTextMarkDefinition[]
-) {
-  return (marks ?? []).reduce((result, mark) => {
-    if (mark === "strong") return `**${result}**`
-    if (mark === "em") return `*${result}*`
-    if (mark === "code") return `\`${result}\``
-
-    const link = markDefs.find((definition) => definition._key === mark)
-    if (link?._type === "link" && link.href) {
-      return `[${result}](${link.href})`
-    }
-
-    return result
-  }, text)
-}
-
-function serializeBlock(block: PortableTextBlock) {
-  const text = (block.children ?? [])
-    .map((child) =>
-      applyMarks(child.text ?? "", child.marks, block.markDefs ?? [])
-    )
-    .join("")
-    .trim()
-
-  if (!text) return ""
-
-  if (block.listItem) {
-    const level = Math.max((block.level ?? 1) - 1, 0)
-    const indent = "  ".repeat(level)
-    const marker = block.listItem === "number" ? "1." : "-"
-    return `${indent}${marker} ${text}`
-  }
-
-  if (block.style === "blockquote") {
-    return `> ${text}`
-  }
-
-  const headingPrefix = headingStyles[block.style ?? ""]
-  if (headingPrefix) {
-    return `${headingPrefix} ${text}`
-  }
-
-  return text
-}
-
-export function portableTextToMarkdown(
-  value: PortableTextBlock[] | null | undefined
-) {
-  return (value ?? []).map(serializeBlock).filter(Boolean).join("\n\n")
-}

package/src/{helpers/integrate → modules/features/cms}/sanity/files/lib/integrations/sanity/live/index.tsx

@@ -1,5 +1,5 @@
-import { defineLive } from "next-sanity/live";
 import { NextResponse } from "next/server";
+import { defineLive } from "next-sanity/live";
 import { isSanityConfigured } from "@/lib/integrations/check-integration";
 import { client } from "../client";
 import { sanityToken } from "../env";