bsmnt 0.2.10 → 0.3.0

package/src/templates/next-pagebuilder/lib/integrations/sanity/components/rich-text.tsx

@@ -0,0 +1,84 @@
+import { PortableText, type PortableTextProps } from "@portabletext/react"
+import { Link } from "@/components/ui/link"
+import { SanityImage } from "@/components/ui/sanity-image"
+import { getLinkAttributes, urlForReference } from "../utils/link"
+
+interface RichTextProps {
+  content: PortableTextProps["value"]
+}
+
+type LinkMarkProps = {
+  children: React.ReactNode
+  value?: unknown
+}
+
+const LinkMark = ({ children, value }: LinkMarkProps) => {
+  const href = urlForReference(value as Parameters<typeof urlForReference>[0])
+  const attrs = getLinkAttributes(
+    value as Parameters<typeof getLinkAttributes>[0]
+  )
+
+  return (
+    <Link
+      href={href}
+      target={attrs.target}
+      rel={attrs.rel}
+      data-sanity-edit-target
+    >
+      {children}
+    </Link>
+  )
+}
+
+export const RichText = ({ content }: RichTextProps) => {
+  if (!content) return null
+
+  return (
+    <PortableText
+      value={content}
+      components={{
+        types: {
+          image: ({ value }) => <SanityImage image={value} maxWidth={1920} />,
+          table: ({ value }) => {
+            const rows = value?.rows as
+              | Array<{ _key?: string; cells?: string[] }>
+              | undefined
+            if (!rows?.length) return null
+            return (
+              <table>
+                <tbody>
+                  {rows.map((row, i) => (
+                    <tr key={row._key ?? `row-${i}`}>
+                      {row.cells?.map((cell) => {
+                        const cellKey = `${row._key}-${cell}`
+                        return i === 0 ? (
+                          <th key={cellKey}>{cell}</th>
+                        ) : (
+                          <td key={cellKey}>{cell}</td>
+                        )
+                      })}
+                    </tr>
+                  ))}
+                </tbody>
+              </table>
+            )
+          },
+        },
+        marks: {
+          link: LinkMark,
+          pageReference: LinkMark,
+          externalLink: LinkMark,
+        },
+        block: {
+          h1: ({ children }) => <h1 className="h1">{children}</h1>,
+          h2: ({ children }) => <h2 className="h2">{children}</h2>,
+          h3: ({ children }) => <h3 className="h3">{children}</h3>,
+          h4: ({ children }) => <h4 className="h4">{children}</h4>,
+          h5: ({ children }) => <h5 className="h5">{children}</h5>,
+          h6: ({ children }) => <h6 className="h6">{children}</h6>,
+          normal: ({ children }) => <p className="p">{children}</p>,
+        },
+      }}
+    />
+  )
+}

package/src/templates/next-pagebuilder/lib/integrations/sanity/confirm-publish-action.ts

@@ -0,0 +1,40 @@
+import { useState } from "react";
+import type {
+  DocumentActionComponent,
+  DocumentActionDialogProps,
+  DocumentActionProps,
+} from "sanity";
+
+export function createConfirmPublishAction(
+  originalPublishAction: DocumentActionComponent,
+): DocumentActionComponent {
+  const ConfirmPublishAction = (props: DocumentActionProps) => {
+    const original = originalPublishAction(props);
+    const [dialogOpen, setDialogOpen] = useState(false);
+
+    if (!original) return null;
+
+    const { dialog: _originalDialog, ...originalWithoutDialog } = original;
+    const dialog: DocumentActionDialogProps | false = dialogOpen
+      ? {
+          type: "confirm",
+          tone: "critical",
+          message:
+            "This will make these changes live on the production site immediately. Continue?",
+          onCancel: () => setDialogOpen(false),
+          onConfirm: () => {
+            setDialogOpen(false);
+            original.onHandle?.();
+          },
+        }
+      : false;
+
+    return {
+      ...originalWithoutDialog,
+      onHandle: () => setDialogOpen(true),
+      dialog,
+    };
+  };
+
+  return ConfirmPublishAction;
+}

package/src/templates/next-pagebuilder/lib/integrations/sanity/env.ts

@@ -0,0 +1,34 @@
+/**
+ * Sanity Environment Configuration
+ *
+ * All values have safe defaults to allow the app to build and run
+ * without Sanity configured. Use isSanityConfigured() to check
+ * if Sanity is properly set up before making API calls.
+ */
+
+/** Sanity API version - defaults to latest stable */
+export const apiVersion =
+  process.env.NEXT_PUBLIC_SANITY_API_VERSION || "2024-03-15"
+
+/** Sanity dataset name - defaults to 'production' */
+export const dataset = process.env.NEXT_PUBLIC_SANITY_DATASET || "production"
+
+/** Sanity project ID - empty string if not configured */
+export const projectId =
+  process.env.NEXT_PUBLIC_SANITY_PROJECT_ID ||
+  process.env.SANITY_STUDIO_PROJECT_ID ||
+  ""
+
+/** Sanity Studio URL for visual editing */
+export const studioUrl =
+  process.env.NODE_ENV === "development"
+    ? "http://localhost:3000/studio"
+    : `${process.env.NEXT_PUBLIC_BASE_URL || ""}/studio`
+
+export const sanityToken = process.env.SANITY_API_READ_TOKEN || ""
+
+/** Preview URL for draft mode */
+export const previewURL =
+  process.env.NODE_ENV === "development"
+    ? "http://localhost:3000"
+    : process.env.NEXT_PUBLIC_BASE_URL || ""

package/src/templates/next-pagebuilder/lib/integrations/sanity/fetchers/layout.ts

@@ -0,0 +1,35 @@
+import { sanityFetch } from "@/lib/integrations/sanity/live"
+import {
+  COMPANY_DATA_QUERY,
+  FOOTER_QUERY,
+  NAVBAR_QUERY,
+} from "@/lib/integrations/sanity/queries"
+import type {
+  COMPANY_DATA_QUERY_RESULT,
+  FOOTER_QUERY_RESULT,
+  NAVBAR_QUERY_RESULT,
+} from "@/lib/integrations/sanity/sanity.types"
+
+export type NavbarData = NonNullable<NAVBAR_QUERY_RESULT>
+export type FooterData = NonNullable<FOOTER_QUERY_RESULT>
+export type CompanyData = NonNullable<COMPANY_DATA_QUERY_RESULT>
+
+export const SANITY_LAYOUT_TAGS = ["navbar", "footer", "companyData"]
+
+export const getNavbar = async (): Promise<NavbarData | null> => {
+  const { data } = await sanityFetch({ query: NAVBAR_QUERY, tags: ["navbar"] })
+  return data
+}
+
+export const getFooter = async (): Promise<FooterData | null> => {
+  const { data } = await sanityFetch({ query: FOOTER_QUERY, tags: ["footer"] })
+  return data
+}
+
+export const getCompanyData = async (): Promise<CompanyData | null> => {
+  const { data } = await sanityFetch({
+    query: COMPANY_DATA_QUERY,
+    tags: ["companyData"],
+  })
+  return data
+}

package/src/templates/next-pagebuilder/lib/integrations/sanity/icons.ts

@@ -0,0 +1,58 @@
+import type { Icon, IconProps } from "@phosphor-icons/react"
+import {
+  ArticleNyTimesIcon,
+  BrowsersIcon,
+  BuildingsIcon,
+  FileTextIcon,
+  FolderOpenIcon,
+  FootprintsIcon,
+  LayoutIcon,
+  ListBulletsIcon,
+  ListIcon,
+  PackageIcon,
+  RocketIcon,
+  ShapesIcon,
+  ShareNetworkIcon,
+  TagIcon,
+  TextAlignLeftIcon,
+  UserCircleIcon,
+} from "@phosphor-icons/react/dist/ssr"
+import { createElement, forwardRef } from "react"
+
+export type SanityStudioIcon = Icon
+
+const asDuotoneIcon = (IconComponent: Icon): SanityStudioIcon => {
+  const DuotoneIcon = forwardRef<SVGSVGElement, IconProps>((props, ref) =>
+    createElement(IconComponent, { ...props, ref, weight: "duotone" })
+  )
+
+  DuotoneIcon.displayName = `${IconComponent.displayName ?? "Phosphor"}Duotone`
+
+  return DuotoneIcon
+}
+
+export const pageBuilderCardIcon = asDuotoneIcon(PackageIcon)
+export const pageBuilderCardListIcon = asDuotoneIcon(ListIcon)
+
+export const authorIcon = asDuotoneIcon(UserCircleIcon)
+
+export const pageListIcon = asDuotoneIcon(ListBulletsIcon)
+
+export const blogCategoryIcon = asDuotoneIcon(TagIcon)
+
+export const componentsFolderIcon = asDuotoneIcon(ShapesIcon)
+
+export const companyDataIcon = asDuotoneIcon(BuildingsIcon)
+export const socialLinksIcon = asDuotoneIcon(ShareNetworkIcon)
+export const navbarIcon = asDuotoneIcon(ListIcon)
+export const footerIcon = asDuotoneIcon(FootprintsIcon)
+export const layoutFolderIcon = asDuotoneIcon(LayoutIcon)
+
+export const heroIcon = asDuotoneIcon(RocketIcon)
+export const descriptionIcon = asDuotoneIcon(TextAlignLeftIcon)
+export const contentIcon = asDuotoneIcon(ArticleNyTimesIcon)
+
+export const pageIcon = asDuotoneIcon(FileTextIcon)
+export const pagesFolderIcon = asDuotoneIcon(BrowsersIcon)
+export const pageFolderIcon = asDuotoneIcon(FolderOpenIcon)
+export const contentFolderIcon = asDuotoneIcon(FolderOpenIcon)

package/src/templates/next-pagebuilder/lib/integrations/sanity/live/index.tsx

@@ -0,0 +1,61 @@
+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"
+
+const isConfigured = isSanityConfigured() && client
+
+const liveExports =
+  isConfigured && client
+    ? defineLive({
+        client,
+        browserToken: sanityToken,
+        serverToken: sanityToken,
+      })
+    : null
+
+export const sanityFetch =
+  liveExports?.sanityFetch ?? (async () => ({ data: null }))
+
+export const SanityLive = liveExports?.SanityLive ?? (() => null)
+
+export const SanityFetch = async <T,>(
+  slug: string,
+  query: string,
+  label = "Content"
+): Promise<T | NextResponse> => {
+  if (!client) {
+    return new NextResponse(`# 503 Unavailable\n\nCMS client unavailable.`, {
+      status: 503,
+      headers: { "Content-Type": "text/markdown; charset=utf-8" },
+    })
+  }
+
+  try {
+    const { data } = await sanityFetch({
+      query,
+      params: { slug },
+    })
+
+    const result = data as T | null
+
+    if (!result) {
+      return new NextResponse(`# 404 Not Found\n\nPage not found.`, {
+        status: 404,
+        headers: { "Content-Type": "text/markdown; charset=utf-8" },
+      })
+    }
+
+    return result
+  } catch (error) {
+    console.error(`Error fetching ${label.toLowerCase()}:`, error)
+    return new NextResponse(
+      `# 500 Error\n\nFailed to fetch ${label.toLowerCase()}.`,
+      {
+        status: 500,
+        headers: { "Content-Type": "text/markdown; charset=utf-8" },
+      }
+    )
+  }
+}

package/src/templates/next-pagebuilder/lib/integrations/sanity/markdown-proxy.config.ts

@@ -0,0 +1,50 @@
+export interface MarkdownRoute {
+  /** Regex to match the public-facing URL */
+  regex: RegExp
+  /** API route path template (under /api/) */
+  apiPath: string
+  /** Public markdown URL template (for Link headers) */
+  publicPath: string
+}
+
+/**
+ * Routes that serve markdown versions for AI agents.
+ * All pages are backed by the shared `page` document type and resolved
+ * through the catch-all route handlers.
+ *
+ * How it works:
+ * - `regex`: match the public-facing URL (e.g. /about.md or /about)
+ * - `apiPath`: the internal API route that serves the markdown (e.g. /api/about.md)
+ * - Proxy rewrites .md URLs and Accept: text/markdown requests to the API route
+ * - Route handlers live under /api/ so page.tsx can coexist at the public path
+ */
+
+/** .md extension routes -- rewrite to API endpoints */
+export const mdExtensionRoutes: MarkdownRoute[] = [
+  {
+    regex: /^\/(.+)\.md$/,
+    apiPath: "/api/[slug].md",
+    publicPath: "/[slug].md",
+  },
+]
+
+/** Accept: text/markdown routes -- content negotiation for HTML pages */
+export const acceptHeaderRoutes: MarkdownRoute[] = [
+  {
+    regex: /^\/(.+)$/,
+    apiPath: "/api/[slug].md",
+    publicPath: "/[slug].md",
+  },
+]
+
+/**
+ * Paths the proxy should never process.
+ * Studio, static files, Next.js internals.
+ */
+export const ignoredPaths = [
+  "/studio",
+  "/api/",
+  "/_next/",
+  "/favicon.ico",
+  "/sitemap.md",
+]

package/src/templates/next-pagebuilder/lib/integrations/sanity/page-builder-config.ts

@@ -0,0 +1,132 @@
+import { contentIcon, pageIcon, type SanityStudioIcon } from "./icons"
+import { singletonComponents } from "./singletons"
+
+export type PageBuilderDocumentType =
+  | "hero"
+  | "description"
+  | "blogContent"
+  | (typeof singletonComponents)[number]["schemaType"]
+
+type PageBuilderReferenceMember = {
+  documentType: PageBuilderDocumentType
+  name: string
+  title: string
+  documentId?: string
+  groups: PageBuilderGroupName[]
+}
+
+export type PageBuilderGroupName =
+  | "generic"
+  | "blogEntry"
+
+export const pageBuilderPageTypes: Array<{
+  title: string
+  value: PageBuilderGroupName
+}> = [
+  { title: "Generic", value: "generic" },
+  { title: "Blog Entry", value: "blogEntry" },
+]
+
+const pageCategoryIcons: Record<PageBuilderGroupName, SanityStudioIcon> = {
+  generic: pageIcon,
+  blogEntry: contentIcon,
+}
+
+export const getPageCategoryIcon = (
+  pageType: PageBuilderGroupName | undefined | null
+) => pageCategoryIcons[pageType ?? "generic"]
+
+const reusablePageBuilderReferenceMembers: PageBuilderReferenceMember[] = [
+  {
+    documentType: "hero",
+    name: "heroReference",
+    title: "Heading",
+    groups: ["generic"],
+  },
+  {
+    documentType: "description",
+    name: "descriptionReference",
+    title: "Description",
+    groups: ["generic"],
+  },
+  {
+    documentType: "blogContent",
+    name: "blogContentReference",
+    title: "Blog Content",
+    groups: ["blogEntry"],
+  },
+]
+
+const singletonPageBuilderReferenceMembers: PageBuilderReferenceMember[] =
+  singletonComponents.map((component) => ({
+    documentType: component.schemaType,
+    name: `${component.schemaType}Reference`,
+    title: component.title,
+    documentId: component.documentId,
+    groups: ["generic"],
+  }))
+
+export const pageBuilderReferenceMembers: PageBuilderReferenceMember[] = [
+  ...reusablePageBuilderReferenceMembers,
+  ...singletonPageBuilderReferenceMembers,
+]
+
+export const getPageBuilderReferenceMember = (name: string) =>
+  pageBuilderReferenceMembers.find((member) => member.name === name)
+
+export const getPageBuilderReferenceMemberByDocumentType = (
+  documentType: PageBuilderDocumentType
+) =>
+  pageBuilderReferenceMembers.find(
+    (member) => member.documentType === documentType
+  )
+
+const isPageBuilderGroupVisible = (
+  pageType: PageBuilderGroupName | undefined,
+  group: PageBuilderGroupName
+) => (pageType ?? "generic") === group
+
+export const getVisiblePageBuilderReferenceMembers = (
+  pageType: PageBuilderGroupName | undefined
+) =>
+  pageBuilderReferenceMembers.filter((member) =>
+    member.groups.some((group) => isPageBuilderGroupVisible(pageType, group))
+  )
+
+export const getVisiblePageBuilderInsertMenuGroups = (
+  pageType: PageBuilderGroupName | undefined
+) =>
+  pageBuilderInsertMenuGroups.filter(
+    (group) => group.name === (pageType ?? "generic")
+  )
+
+export const getInvalidPageBuilderDocumentTypes = (
+  pageType: PageBuilderGroupName | undefined,
+  documentTypes: PageBuilderDocumentType[]
+) =>
+  documentTypes.filter((documentType) => {
+    const member = getPageBuilderReferenceMemberByDocumentType(documentType)
+
+    if (!member) return false
+
+    return !member.groups.some((group) =>
+      isPageBuilderGroupVisible(pageType, group)
+    )
+  })
+
+export const pageBuilderInsertMenuGroups = [
+  {
+    name: "generic",
+    title: "Generic",
+    of: pageBuilderReferenceMembers
+      .filter((member) => member.groups.includes("generic"))
+      .map((member) => member.name),
+  },
+  {
+    name: "blogEntry",
+    title: "Blog Entry",
+    of: pageBuilderReferenceMembers
+      .filter((member) => member.groups.includes("blogEntry"))
+      .map((member) => member.name),
+  },
+]

package/src/templates/next-pagebuilder/lib/integrations/sanity/page-category.ts

@@ -0,0 +1,28 @@
+import type { PageBuilderGroupName } from "@/lib/integrations/sanity/page-builder-config"
+
+type PageCategoryParams = {
+  slug?: string | null
+  folder?: string | null
+}
+
+export const isEmptyPageSlug = (slug?: string | null) =>
+  slug == null || slug === "" || slug === "/"
+
+export const getGeneratedPageCategory = ({
+  slug,
+  folder,
+}: PageCategoryParams): PageBuilderGroupName => {
+  if (!isEmptyPageSlug(slug) && folder === "blog") return "blogEntry"
+
+  return "generic"
+}
+
+export const pageCategoryExpression = `
+  select(
+    defined(slug.current) &&
+      slug.current != "" &&
+      slug.current != "/" &&
+      pageFolder->slug.current == "blog" => "blogEntry",
+    "generic"
+  )
+`