bsmnt 0.2.11 → 0.3.1

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

@@ -1,13 +1,8 @@
-import type {
-  Article,
-  BreadcrumbList,
-  Organization,
-  SearchAction,
-  Thing,
-  WebPage,
-  WebSite,
-  WithContext,
-} from "schema-dts";
+type JsonLdValue = {
+  "@context": "https://schema.org";
+  "@type": string;
+  [key: string]: unknown;
+};
 
 const APP_BASE_URL = process.env.NEXT_PUBLIC_BASE_URL;
 
@@ -25,10 +20,10 @@ function resolveUrl(value?: string) {
 
 /* -------------------------------- Component ------------------------------- */
 
-export function JsonLd<T extends Thing>({
+export function JsonLd<T extends JsonLdValue>({
   data,
 }: {
-  data: WithContext<T>;
+  data: T;
 }) {
   return (
     <script
@@ -52,7 +47,7 @@ interface WebSiteJsonLdOptions {
 
 export function generateWebSiteJsonLd(
   options: WebSiteJsonLdOptions
-): WithContext<WebSite> {
+): JsonLdValue {
   const { name, url, description, searchUrl } = options;
   const resolvedUrl = resolveUrl(url);
   const resolvedSearchUrl = resolveUrl(searchUrl);
@@ -68,7 +63,7 @@ export function generateWebSiteJsonLd(
         "@type": "SearchAction",
         target: resolvedSearchUrl,
         "query-input": "required name=search_term_string",
-      } as SearchAction & { "query-input": string },
+      },
     }),
   };
 }
@@ -83,7 +78,7 @@ interface OrganizationJsonLdOptions {
 
 export function generateOrganizationJsonLd(
   options: OrganizationJsonLdOptions
-): WithContext<Organization> {
+): JsonLdValue {
   const { name, url, logo, description, sameAs } = options;
   const resolvedUrl = resolveUrl(url);
   const resolvedLogo = resolveUrl(logo);
@@ -110,7 +105,7 @@ interface WebPageJsonLdOptions {
 
 export function generateWebPageJsonLd(
   options: WebPageJsonLdOptions
-): WithContext<WebPage> {
+): JsonLdValue {
   const { title, url, description, image, datePublished, dateModified } =
     options;
   const resolvedUrl = resolveUrl(url);
@@ -141,7 +136,7 @@ interface ArticleJsonLdOptions {
 
 export function generateArticleJsonLd(
   options: ArticleJsonLdOptions
-): WithContext<Article> {
+): JsonLdValue {
   const {
     title,
     url,
@@ -181,7 +176,7 @@ interface BreadcrumbItem {
 
 export function generateBreadcrumbJsonLd(
   items: BreadcrumbItem[]
-): WithContext<BreadcrumbList> {
+): JsonLdValue {
   return {
     "@context": "https://schema.org",
     "@type": "BreadcrumbList",

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

@@ -0,0 +1,83 @@
+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/templates/next-experiments/package.json

@@ -8,9 +8,9 @@
     "analyze": "cross-env ANALYZE=true bun run build",
     "analyze:experimental": "next experimental-analyze",
     "build": "next build",
-    "dev": "bun ./lib/scripts/dev.ts",
-    "dev:https": "bun ./lib/scripts/dev.ts --https",
-    "dev:inspect": "bun ./lib/scripts/dev.ts --inspect",
+    "dev": "next dev",
+    "dev:https": "next dev --experimental-https",
+    "dev:inspect": "next dev --inspect",
     "format": "biome format --write .",
     "lighthouse": "bunx @unlighthouse/cli --site http://localhost:3000",
     "lint": "biome lint --max-diagnostics=200",

package/src/templates/next-pagebuilder/.env.example

@@ -0,0 +1,11 @@
+# Base URL
+NEXT_PUBLIC_BASE_URL=http://localhost:3000
+
+# Draft Mode
+DRAFT_MODE_TOKEN=
+
+# Sanity CMS
+NEXT_PUBLIC_SANITY_PROJECT_ID=
+NEXT_PUBLIC_SANITY_DATASET=production
+SANITY_API_READ_TOKEN=
+SANITY_REVALIDATE_SECRET=

package/src/templates/next-pagebuilder/README.md

@@ -0,0 +1,23 @@
+# Page Builder Template
+
+Next.js + Sanity CMS page builder architecture. All URL structure is managed in Sanity, not in code.
+
+## Getting Started
+
+```bash
+bun dev
+```
+
+## Architecture
+
+- Single catch-all route `[[...slug]]` handles all pages
+- Sanity page builder with composable content blocks
+- Blog with categories, filtering, and pagination
+- Visual editing and live preview support
+
+## Commands
+
+- `bun dev` - Start dev server
+- `bun build` - Production build
+- `bun lint` - Run linter
+- `bun sanity:typegen` - Generate Sanity types

package/src/templates/next-pagebuilder/_gitignore

@@ -0,0 +1,67 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+/.pnp
+.pnp.*
+.turbo
+.npmrc
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/versions
+
+# testing
+/coverage
+
+# next.js
+/.next/
+/out/
+
+# TypeScript
+*.tsbuildinfo
+
+# production
+/build
+/public/sw.js
+
+# misc
+.DS_Store
+*.pem
+.cursor/scratchpad.md
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# local env files
+.env
+.env.local
+.env*.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# vercel
+.vercel
+
+# tldr
+.tldr
+
+# eslint
+.eslintcache
+
+# certificates
+certificates
+
+next-env.d.ts
+# claude
+.claude
+
+# unlighthouse
+.unlighthouse/
+
+# storybook
+*storybook.log

package/src/templates/next-pagebuilder/app/(content)/[[...slug]]/page.tsx

@@ -0,0 +1,68 @@
+import { notFound } from "next/navigation"
+import { client } from "@/lib/integrations/sanity/client"
+import { sanityFetch } from "@/lib/integrations/sanity/live"
+import {
+  ALL_PAGE_SLUGS_QUERY,
+  PAGE_QUERY,
+} from "@/lib/integrations/sanity/queries"
+import type {
+  ALL_PAGE_SLUGS_QUERY_RESULT,
+  PAGE_QUERY_RESULT,
+} from "@/lib/integrations/sanity/sanity.types"
+import { generateSanityMetadata } from "@/lib/utils/metadata"
+import { getSlugTag } from "@/lib/utils/slug-tag"
+import { PageDocument } from "@/components/page-document"
+
+const getPageDocument = async (slug: string | null, stega = true) =>
+  sanityFetch({
+    query: PAGE_QUERY,
+    params: { slug },
+    tags: [getSlugTag(slug)],
+    stega,
+  })
+
+const toPath = (segments?: string[]) =>
+  segments?.filter(Boolean).join("/") || null
+
+const getResolvedPage = async (
+  path: string | null,
+  stega = true
+): Promise<NonNullable<PAGE_QUERY_RESULT> | null> => {
+  const { data: page } = await getPageDocument(path, stega)
+  return (page as NonNullable<PAGE_QUERY_RESULT> | null) ?? null
+}
+
+export const generateStaticParams = async () => {
+  if (!client) return []
+
+  const slugs =
+    await client.fetch<ALL_PAGE_SLUGS_QUERY_RESULT>(ALL_PAGE_SLUGS_QUERY)
+
+  return (slugs ?? []).flatMap((page) => {
+    if (!page.slug) return []
+    return { slug: page.slug.split("/") }
+  })
+}
+
+type Props = { params: Promise<{ slug?: string[] }> }
+
+export const generateMetadata = async ({ params }: Props) => {
+  const { slug } = await params
+  const path = toPath(slug)
+  const page = await getResolvedPage(path, false)
+
+  return page
+    ? generateSanityMetadata({ document: page, url: path ? `/${path}` : "/" })
+    : {}
+}
+
+export default async function CatchAllPage({ params }: Props) {
+  const { slug } = await params
+
+  const path = toPath(slug)
+  const page = await getResolvedPage(path)
+
+  if (!page) return notFound()
+
+  return <PageDocument page={page} path={path} />
+}

package/src/templates/next-pagebuilder/app/(content)/layout.tsx

@@ -0,0 +1,13 @@
+import { JsonLd } from "@/components/layout/json-ld"
+import { Wrapper } from "@/components/layout/wrapper"
+import { SanityVisualEditing } from "@/components/sanity/visual-editing"
+
+const Layout = async ({ children }: { children: React.ReactNode }) => (
+  <>
+    <JsonLd />
+    <Wrapper>{children}</Wrapper>
+    <SanityVisualEditing />
+  </>
+)
+
+export default Layout

package/src/templates/next-pagebuilder/app/api/[[...slug]]/route.ts

@@ -0,0 +1,100 @@
+import { NextResponse } from "next/server"
+import { isSanityConfigured } from "@/lib/integrations/check-integration"
+import { sanityFetch } from "@/lib/integrations/sanity/live"
+import { PAGE_QUERY } from "@/lib/integrations/sanity/queries"
+import type { PAGE_QUERY_RESULT } from "@/lib/integrations/sanity/sanity.types"
+import { renderPageBuilderMarkdown } from "@/lib/integrations/sanity/utils/page-builder-markdown"
+import { getBaseUrl } from "@/lib/utils/base-url"
+
+type PageResult = NonNullable<PAGE_QUERY_RESULT>
+
+const getSlugPath = (slugParts?: string[]) => {
+  if (!slugParts?.length) return null
+
+  const lastSegment = slugParts.at(-1)
+
+  if (!lastSegment?.endsWith(".md")) return null
+
+  const pathSegments = [...slugParts]
+  pathSegments[pathSegments.length - 1] = lastSegment.slice(0, -3)
+
+  const slug = pathSegments.filter(Boolean).join("/")
+  if (!slug) return null
+
+  return slug === "index" ? null : slug
+}
+
+export async function GET(
+  _request: Request,
+  props: { params: Promise<{ slug?: string[] }> }
+) {
+  const { slug: rawSlugParts } = await props.params
+  const slug = getSlugPath(rawSlugParts)
+
+  if (
+    rawSlugParts?.length &&
+    slug === null &&
+    rawSlugParts.join("/") !== "index.md"
+  ) {
+    return new NextResponse(null, { status: 404 })
+  }
+
+  if (!rawSlugParts?.length) {
+    return new NextResponse(null, { status: 404 })
+  }
+
+  if (!isSanityConfigured()) {
+    return new NextResponse("# 404 Not Found\n\nCMS not configured.", {
+      status: 404,
+      headers: { "Content-Type": "text/markdown; charset=utf-8" },
+    })
+  }
+
+  const { data } = await sanityFetch({
+    query: PAGE_QUERY,
+    params: { slug },
+  })
+
+  const page = data as PageResult | null
+
+  const baseUrl = getBaseUrl()
+
+  if (!page) {
+    return new NextResponse("# 404 Not Found\n\nPage not found.", {
+      status: 404,
+      headers: { "Content-Type": "text/markdown; charset=utf-8" },
+    })
+  }
+
+  const body = renderPageBuilderMarkdown(page.pageBuilder)
+  const canonicalPath = slug ? `/${slug}` : "/"
+
+  return new NextResponse(
+    [
+      `# ${page.title}`,
+      "",
+      page._updatedAt
+        ? `**Updated:** ${new Date(page._updatedAt).toLocaleDateString()}`
+        : null,
+      "",
+      `Canonical URL: ${baseUrl}${canonicalPath}`,
+      "",
+      "---",
+      "",
+      body || "No page builder content yet.",
+      "",
+      "---",
+      "",
+      `[View all content](${baseUrl}/sitemap.md)`,
+    ]
+      .filter((part): part is string => part !== null)
+      .join("\n"),
+    {
+      headers: {
+        "Content-Type": "text/markdown; charset=utf-8",
+        Vary: "Accept",
+        "X-Content-Type-Options": "nosniff",
+      },
+    }
+  )
+}

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

@@ -0,0 +1,7 @@
+import { draftMode } from "next/headers"
+import { type NextRequest, NextResponse } from "next/server"
+
+export async function GET(request: NextRequest) {
+  ;(await draftMode()).disable()
+  return NextResponse.redirect(new URL("/", request.url))
+}

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 })
+  }
+}