bsmnt 0.2.11 → 0.3.0

package/src/templates/next-pagebuilder/app/api/draft-mode/enable/route.ts

@@ -0,0 +1,20 @@
+import { NextResponse } from "next/server"
+import { defineEnableDraftMode } from "next-sanity/draft-mode"
+import { isSanityConfigured } from "@/lib/integrations/check-integration"
+import { client } from "@/lib/integrations/sanity/client"
+import { sanityToken } from "@/lib/integrations/sanity/env"
+
+const draftModeHandler =
+  isSanityConfigured() && client
+    ? defineEnableDraftMode({
+        client: client.withConfig({ token: sanityToken }),
+      })
+    : {
+        GET: () =>
+          NextResponse.json(
+            { error: "Sanity is not configured" },
+            { status: 503 }
+          ),
+      }
+
+export const { GET } = draftModeHandler

package/src/templates/next-pagebuilder/app/api/revalidate/route.ts

@@ -0,0 +1,121 @@
+import { revalidatePath, revalidateTag } from "next/cache"
+import { type NextRequest, NextResponse } from "next/server"
+import { parseBody } from "next-sanity/webhook"
+import { client } from "@/lib/integrations/sanity/client"
+import { SANITY_LAYOUT_TAGS } from "@/lib/integrations/sanity/fetchers/layout"
+import { pageBuilderReferenceMembers as pbrm } from "@/lib/integrations/sanity/page-builder-config"
+import {
+  P_REF_PB_COMP_QUERY,
+  P_REV_SLUGS_QUERY,
+} from "@/lib/integrations/sanity/queries"
+import type { P_REF_PB_COMP_QUERY_RESULT } from "@/lib/integrations/sanity/sanity.types"
+import { getPagePath } from "@/lib/utils/sitemap"
+
+const ERRORS = {
+  BAD_REQ: ["Bad Request", { status: 400 }],
+  INVALID_SIG: ["Invalid signature", { status: 401 }],
+} as const
+
+type WebhookSlug = {
+  current?: string | null
+}
+
+type WebhookDocument = {
+  _id: string
+  _type: string
+  resolvedSlug?: string | null
+  slug?: WebhookSlug | null
+}
+
+type MutationOperation = "create" | "update" | "delete"
+
+type RevalidateWebhookBody = WebhookDocument & {
+  operation?: MutationOperation
+  before?: Partial<WebhookDocument> | null
+  after?: Partial<WebhookDocument> | null
+}
+
+const pageBuilderComponent = new Set<string>(pbrm.map((m) => m.documentType))
+
+const normalizeRevalidationSlug = (slug: string | null | undefined) => {
+  if (slug === undefined) return null
+  if (slug === null) return "/"
+  return `/${slug}`
+}
+
+const getCanonicalPageSlug = async (documentId: string) => {
+  if (!client) return null
+
+  const pageSlugs = await client.fetch<Array<{ slug: string | null }>>(
+    P_REV_SLUGS_QUERY,
+    { documentIds: [documentId] }
+  )
+
+  return normalizeRevalidationSlug(
+    pageSlugs.find((page) => page.slug !== undefined)?.slug
+  )
+}
+
+const getPagesThatReferenceComp = async (documentId: string) => {
+  if (!client) return []
+
+  const pages = await client.fetch<P_REF_PB_COMP_QUERY_RESULT>(
+    P_REF_PB_COMP_QUERY,
+    {
+      documentId,
+    }
+  )
+
+  return (pages ?? []).map((page) => normalizeRevalidationSlug(page.slug))
+}
+
+const getAffectedPageSlugsForWebhook = async (body: RevalidateWebhookBody) => {
+  const pages: Array<string | null> = []
+
+  if (body.operation === "delete" && body?.before?.slug?.current) {
+    revalidateTag(body.before.slug.current, "max")
+  }
+
+  // If the document is a page, get its slug
+  if (body._type === "page") {
+    const data = await getCanonicalPageSlug(body._id)
+    if (data !== null) pages.push(data)
+  }
+
+  // If the document is a page builder component, get the page slugs that reference it
+  if (pageBuilderComponent.has(body._type)) {
+    const data = await getPagesThatReferenceComp(body._id)
+    pages.push(...data)
+  }
+
+  return pages.filter((page): page is string => page !== null)
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    const { body, isValidSignature } = await parseBody<RevalidateWebhookBody>(
+      request,
+      process.env.SANITY_REVALIDATE_SECRET
+    )
+
+    if (!isValidSignature) return new Response(...ERRORS.INVALID_SIG)
+    if (!(body?._type && body._id)) return new Response(...ERRORS.BAD_REQ)
+    if (body._id.startsWith("drafts."))
+      return NextResponse.json({ status: 200, now: Date.now(), skipped: true })
+
+    const affectedPageSlugs = await getAffectedPageSlugsForWebhook(body)
+
+    for (const slug of affectedPageSlugs) {
+      revalidatePath(getPagePath(slug))
+    }
+
+    if (SANITY_LAYOUT_TAGS.includes(body?._type)) {
+      revalidateTag(body._type, "max")
+    }
+
+    return NextResponse.json({ status: 200, now: Date.now() })
+  } catch (error) {
+    console.error("Revalidation error:", error)
+    return new Response("Internal Server Error", { status: 500 })
+  }
+}

package/src/templates/next-pagebuilder/app/layout.tsx

@@ -0,0 +1,80 @@
+import "@/lib/styles/global.css"
+
+import type { Metadata } from "next"
+import { Geist } from "next/font/google"
+import type { PropsWithChildren } from "react"
+import { cn } from "@/lib/styles/cn"
+import { getBaseUrl } from "@/lib/utils/base-url"
+import AppData from "@/package.json"
+
+const APP_NAME = AppData.name
+const APP_DEFAULT_TITLE = "My Site"
+const APP_TITLE_TEMPLATE = "%s"
+const APP_DESCRIPTION = AppData.description
+const APP_BASE_URL = getBaseUrl()
+
+const geist = Geist({
+  subsets: ["latin"],
+  variable: "--font-geist-variable",
+})
+
+export const metadata: Metadata = {
+  alternates: {
+    canonical: "/",
+    languages: {
+      "en-US": "/en-US",
+    },
+  },
+  appleWebApp: {
+    capable: true,
+    statusBarStyle: "default",
+    title: APP_DEFAULT_TITLE,
+  },
+  applicationName: APP_NAME,
+  authors: [{ name: "basement.studio", url: "https://basement.studio" }],
+  description: APP_DESCRIPTION,
+  formatDetection: { telephone: false },
+  metadataBase: new URL(APP_BASE_URL),
+  openGraph: {
+    description: APP_DESCRIPTION,
+    images: [
+      {
+        alt: APP_DEFAULT_TITLE,
+        height: 630,
+        url: "/opengraph-image.jpg",
+        width: 1200,
+      },
+    ],
+    locale: "en_US",
+    siteName: APP_NAME,
+    title: {
+      default: APP_DEFAULT_TITLE,
+      template: APP_TITLE_TEMPLATE,
+    },
+    type: "website",
+    url: APP_BASE_URL,
+  },
+  other: {
+    "fb:app_id": process.env.NEXT_PUBLIC_FACEBOOK_APP_ID || "",
+  },
+  title: {
+    default: APP_DEFAULT_TITLE,
+    template: APP_TITLE_TEMPLATE,
+  },
+  twitter: {
+    card: "summary_large_image",
+    description: APP_DESCRIPTION,
+    title: {
+      default: APP_DEFAULT_TITLE,
+      template: APP_TITLE_TEMPLATE,
+    },
+  },
+}
+
+const Layout = ({ children }: PropsWithChildren) => (
+  <html lang="en" dir="ltr" className={cn(geist.variable)}>
+    <body className="text-black">{children}</body>
+  </html>
+)
+
+export default Layout

package/src/templates/next-pagebuilder/app/robots.ts

@@ -0,0 +1,15 @@
+import type { MetadataRoute } from "next";
+
+const APP_BASE_URL =
+  process.env.NEXT_PUBLIC_BASE_URL ?? "http://localhost:3000";
+
+export default function robots(): MetadataRoute.Robots {
+  return {
+    rules: {
+      userAgent: "*",
+      allow: "/",
+      disallow: [],
+    },
+    sitemap: `${APP_BASE_URL}/sitemap.xml`,
+  };
+}

package/src/templates/next-pagebuilder/app/sitemap.md/route.ts

@@ -0,0 +1,124 @@
+import { NextResponse } from "next/server"
+import { isSanityConfigured } from "@/lib/integrations/check-integration"
+import type { PAGE_SITEMAP_QUERY_RESULT } from "@/lib/integrations/sanity/sanity.types"
+import {
+  getMarkdownPath,
+  getSitemap,
+  getSitemapBaseUrl,
+} from "@/lib/utils/sitemap"
+
+export const dynamic = "force-dynamic"
+
+type PageDoc = PAGE_SITEMAP_QUERY_RESULT[number]
+
+const ROOT_GROUP = "__root__"
+
+const getFolderGroup = (slug: string | null) => {
+  if (!slug) return ROOT_GROUP
+
+  const segments = slug.split("/").filter(Boolean)
+
+  if (segments.length <= 1) return ROOT_GROUP
+
+  return segments.slice(0, -1).join("/")
+}
+
+const getGroupHeading = (group: string) => {
+  if (group === ROOT_GROUP) return "### Root Pages"
+
+  return `### /${group}`
+}
+
+const sortPages = (left: PageDoc, right: PageDoc) => {
+  const leftLabel = left.title || left.slug || "Homepage"
+  const rightLabel = right.title || right.slug || "Homepage"
+
+  return leftLabel.localeCompare(rightLabel)
+}
+
+export const GET = async () => {
+  const baseUrl = getSitemapBaseUrl()
+
+  if (!isSanityConfigured()) {
+    return new NextResponse(
+      [
+        "# Sitemap",
+        "",
+        "## Pages",
+        "",
+        `- [Homepage](${baseUrl}/index.md)`,
+        "",
+        "CMS not configured. No additional content available.",
+      ].join("\n"),
+      {
+        headers: { "Content-Type": "text/markdown; charset=utf-8" },
+      }
+    )
+  }
+
+  try {
+    const allPages = await getSitemap()
+
+    if (!allPages) {
+      return new NextResponse("# Sitemap\n\nUnable to connect to CMS.", {
+        status: 503,
+        headers: { "Content-Type": "text/markdown; charset=utf-8" },
+      })
+    }
+
+    const pages = (allPages ?? []).filter((page) => !page.noIndex)
+    const pageGroups = new Map<string, PageDoc[]>()
+
+    for (const page of pages) {
+      const group = getFolderGroup(page.slug ?? null)
+      const groupedPages = pageGroups.get(group) ?? []
+
+      groupedPages.push(page)
+      pageGroups.set(group, groupedPages)
+    }
+
+    const sortedGroupNames = [...pageGroups.keys()].sort((left, right) => {
+      if (left === ROOT_GROUP) return -1
+      if (right === ROOT_GROUP) return 1
+
+      return left.localeCompare(right)
+    })
+
+    const parts = [
+      `# ${new URL(baseUrl).hostname} - Content Sitemap`,
+      "",
+      "> This sitemap lists all available markdown content for AI agents.",
+      "",
+      "## Pages",
+      "",
+    ]
+
+    if (pages.length > 0) {
+      for (const groupName of sortedGroupNames) {
+        const groupedPages = (pageGroups.get(groupName) ?? []).sort(sortPages)
+
+        if (groupedPages.length === 0) continue
+
+        parts.push(getGroupHeading(groupName), "")
+
+        for (const page of groupedPages) {
+          parts.push(
+            `- [${page.title || page.slug || "Homepage"}](${getMarkdownPath(baseUrl, page.slug ?? null)})`
+          )
+        }
+
+        parts.push("")
+      }
+    }
+
+    if (pages.length === 0) parts.push("No content published yet.", "")
+
+    return new NextResponse(parts.join("\n"))
+  } catch (error) {
+    console.error("Error generating sitemap.md:", error)
+    return new NextResponse("# Sitemap\n\nError fetching content.", {
+      status: 500,
+      headers: { "Content-Type": "text/markdown; charset=utf-8" },
+    })
+  }
+}

package/src/templates/next-pagebuilder/app/sitemap.xml/route.ts

@@ -0,0 +1,80 @@
+import { NextResponse } from "next/server"
+import { isSanityConfigured } from "@/lib/integrations/check-integration"
+import type { PAGE_SITEMAP_QUERY_RESULT } from "@/lib/integrations/sanity/sanity.types"
+import { getPageUrl, getSitemap, getSitemapBaseUrl } from "@/lib/utils/sitemap"
+
+export const dynamic = "force-dynamic"
+
+type PageDoc = PAGE_SITEMAP_QUERY_RESULT[number]
+
+interface SitemapEntry {
+  url: string
+  lastModified?: string | null
+}
+
+const createPageEntry = (
+  baseUrl: string,
+  slug: string | null,
+  updatedAt?: string | null
+): SitemapEntry => ({
+  url: getPageUrl(baseUrl, slug),
+  lastModified: updatedAt ?? null,
+})
+
+const escapeXml = (value: string) =>
+  value
+    .replaceAll("&", "&")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&apos;")
+
+const renderUrl = (entry: SitemapEntry) => {
+  const parts = ["  <url>", `    <loc>${escapeXml(entry.url)}</loc>`]
+
+  if (entry.lastModified) {
+    parts.push(
+      `    <lastmod>${new Date(entry.lastModified).toISOString()}</lastmod>`
+    )
+  }
+
+  parts.push("  </url>")
+
+  return parts.join("\n")
+}
+
+const renderSitemap = (entries: SitemapEntry[]) =>
+  [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
+    ...entries.map(renderUrl),
+    "</urlset>",
+  ].join("\n")
+
+const getSitemapResponse = (entries: SitemapEntry[]) =>
+  new NextResponse(renderSitemap(entries))
+
+export const GET = async () => {
+  const baseUrl = getSitemapBaseUrl()
+  const homepageEntry = createPageEntry(baseUrl, null)
+
+  if (!isSanityConfigured()) return getSitemapResponse([homepageEntry])
+
+  try {
+    const allPages = await getSitemap()
+
+    if (!allPages) return getSitemapResponse([homepageEntry])
+
+    const pages = (allPages ?? []).filter((page) => !page.noIndex)
+    const sitemapEntries = pages.map((page: PageDoc) =>
+      createPageEntry(baseUrl, page.slug ?? null, page._updatedAt)
+    )
+
+    return getSitemapResponse(
+      sitemapEntries.length > 0 ? sitemapEntries : [homepageEntry]
+    )
+  } catch (error) {
+    console.error("Error generating sitemap.xml:", error)
+    return getSitemapResponse([homepageEntry])
+  }
+}

package/src/templates/next-pagebuilder/app/studio/[[...tool]]/page.tsx

@@ -0,0 +1,8 @@
+"use client"
+
+import { NextStudio } from "next-sanity/studio"
+import config from "@/lib/integrations/sanity/sanity.config"
+
+const StudioPage = () => <NextStudio config={config} />
+
+export default StudioPage

package/src/templates/next-pagebuilder/biome.json

@@ -0,0 +1,239 @@
+{
+  "root": true,
+  "$schema": "node_modules/@biomejs/biome/configuration_schema.json",
+  "assist": {
+    "actions": {
+      "source": {
+        "organizeImports": "on"
+      }
+    }
+  },
+  "css": {
+    "formatter": {
+      "enabled": true
+    },
+    "linter": {
+      "enabled": true
+    },
+    "parser": {
+      "cssModules": true,
+      "tailwindDirectives": true
+    }
+  },
+  "files": {
+    "ignoreUnknown": true,
+    "includes": [
+      "**",
+      "!node_modules",
+      "!**/.next",
+      "!**/dist",
+      "!**/public",
+      "!.github",
+      "!.vercel",
+      "!pnpm-lock.yaml",
+      "!bun.lock",
+      "!**/*.md",
+      "!**/*.mdx",
+      "!**/tailwind.css",
+      "!**/*.grit"
+    ]
+  },
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "space",
+    "indentWidth": 2,
+    "lineEnding": "lf",
+    "lineWidth": 80
+  },
+  "javascript": {
+    "formatter": {
+      "enabled": true,
+      "quoteStyle": "double",
+      "semicolons": "asNeeded",
+      "trailingCommas": "es5"
+    }
+  },
+  "json": {
+    "parser": {
+      "allowComments": true
+    }
+  },
+  "linter": {
+    "domains": {
+      "next": "recommended",
+      "react": "recommended"
+    },
+    "enabled": true,
+    "rules": {
+      "a11y": {
+        "noAriaUnsupportedElements": "error",
+        "noAutofocus": "warn",
+        "noDistractingElements": "error",
+        "noRedundantAlt": "error",
+        "useAltText": "error",
+        "useButtonType": "error",
+        "useKeyWithClickEvents": "warn",
+        "useSemanticElements": "warn",
+        "useValidAnchor": "warn",
+        "useValidAriaProps": "error",
+        "useValidAriaRole": "error",
+        "useValidAriaValues": "error"
+      },
+      "complexity": {
+        "noForEach": "off",
+        "useFlatMap": "warn",
+        "useSimplifiedLogicExpression": "warn"
+      },
+      "correctness": {
+        "noInvalidUseBeforeDeclaration": "error",
+        "noUnknownMediaFeatureName": "off",
+        "noUnusedFunctionParameters": "warn",
+        "noUnusedImports": "error",
+        "noUnusedVariables": "error",
+        "useExhaustiveDependencies": "warn"
+      },
+      "nursery": {
+        "useSortedClasses": {
+          "level": "warn",
+          "options": {
+            "attributes": ["class", "className"],
+            "functions": ["cn", "cva"]
+          }
+        }
+      },
+      "performance": {
+        "noImgElement": "error"
+      },
+      "recommended": true,
+      "security": {
+        "noDangerouslySetInnerHtml": "warn",
+        "noDangerouslySetInnerHtmlWithChildren": "error",
+        "noGlobalEval": "error"
+      },
+      "style": {
+        "noInferrableTypes": "error",
+        "noNestedTernary": "error",
+        "noNonNullAssertion": "off",
+        "noParameterAssign": "error",
+        "noUnusedTemplateLiteral": "off",
+        "noUselessElse": "error",
+        "useAsConstAssertion": "error",
+        "useCollapsedElseIf": "warn",
+        "useConsistentArrayType": "error",
+        "useConsistentBuiltinInstantiation": "error",
+        "useDefaultParameterLast": "error",
+        "useEnumInitializers": "error",
+        "useExponentiationOperator": "error",
+        "useFilenamingConvention": {
+          "level": "warn",
+          "options": {
+            "filenameCases": ["kebab-case", "camelCase"],
+            "strictCase": false
+          }
+        },
+        "useForOf": "warn",
+        "useNumberNamespace": "error",
+        "useSelfClosingElements": "error",
+        "useShorthandAssign": "error",
+        "useSingleVarDeclarator": "error",
+        "useTemplate": "warn"
+      },
+      "suspicious": {
+        "noDebugger": "warn",
+        "noDoubleEquals": "error",
+        "noEmptyBlockStatements": "warn",
+        "noExplicitAny": "error",
+        "noGlobalIsFinite": "error",
+        "noGlobalIsNan": "error",
+        "noMisleadingCharacterClass": "error",
+        "noPrototypeBuiltins": "warn",
+        "noSelfCompare": "error",
+        "noSparseArray": "error",
+        "useAwait": "off"
+      }
+    }
+  },
+  "overrides": [
+    {
+      "includes": ["**/*.css"],
+      "linter": {
+        "rules": {
+          "correctness": {
+            "noUnknownFunction": "off"
+          }
+        }
+      }
+    },
+    {
+      "includes": ["**/*.tsx", "**/*.jsx"],
+      "linter": {
+        "rules": {
+          "a11y": {
+            "useKeyWithClickEvents": "error",
+            "useKeyWithMouseEvents": "error",
+            "useValidAnchor": "error"
+          },
+          "correctness": {
+            "useJsxKeyInIterable": "error"
+          }
+        }
+      }
+    },
+    {
+      "includes": ["**/*.ts", "**/*.tsx"],
+      "linter": {
+        "rules": {
+          "correctness": {
+            "noUndeclaredVariables": "off"
+          },
+          "style": {
+            "useConsistentArrayType": "error",
+            "useExportType": "error",
+            "useImportType": "error"
+          }
+        }
+      }
+    },
+    {
+      "includes": [
+        "app/**/*.tsx",
+        "app/**/*.ts",
+        "app/**/*.jsx",
+        "app/**/*.js"
+      ],
+      "linter": {
+        "rules": {
+          "style": {
+            "noDefaultExport": "off"
+          },
+          "suspicious": {
+            "useAwait": "off"
+          }
+        }
+      }
+    },
+    {
+      "includes": ["**/*.module.css"],
+      "linter": {
+        "rules": {
+          "correctness": {
+            "noUnknownProperty": "off"
+          },
+          "style": {
+            "noDescendingSpecificity": "off"
+          }
+        }
+      }
+    }
+  ],
+  "plugins": [
+    "./.biome/plugins/no-anchor-element.grit",
+    "./.biome/plugins/no-unnecessary-forwardref.grit",
+    "./.biome/plugins/no-relative-parent-imports.grit"
+  ],
+  "vcs": {
+    "clientKind": "git",
+    "enabled": true,
+    "useIgnoreFile": false
+  }
+}