bsmnt 0.2.10 → 0.3.0

package/src/templates/next-pagebuilder/lib/integrations/sanity/schemas/shared/nav-objects.ts

@@ -0,0 +1,192 @@
+import { defineArrayMember, defineField, defineType } from "sanity"
+
+/**
+ * Nav Leaf Item
+ *
+ * Individual navigation link within a menu column.
+ */
+export const navLeafItem = defineType({
+  name: "navLeafItem",
+  title: "Navigation Link",
+  type: "object",
+  fields: [
+    defineField({
+      name: "title",
+      title: "Title",
+      type: "string",
+      description: "Display text for the navigation link",
+      validation: (Rule) => Rule.required(),
+    }),
+    defineField({
+      name: "link",
+      title: "Link",
+      type: "link",
+      description:
+        "Optional -- leave empty for items with pages not yet created",
+    }),
+  ],
+  preview: {
+    select: {
+      title: "title",
+      internalTitle: "link.0.page.title",
+      externalHref: "link.0.href",
+    },
+    prepare({ title, internalTitle, externalHref }) {
+      return {
+        title: title || "Untitled Link",
+        subtitle: internalTitle || externalHref || "",
+      }
+    },
+  },
+})
+
+/**
+ * Nav Column
+ *
+ * A column within a mega-menu containing a group of leaf items.
+ * Title is optional to support unnamed column groups (e.g. Company's first column).
+ * Link is optional -- some column headers are clickable (Products), some are labels only (Solutions).
+ */
+export const navColumn = defineType({
+  name: "navColumn",
+  title: "Menu Column",
+  type: "object",
+  fields: [
+    defineField({
+      name: "title",
+      title: "Column Title",
+      type: "string",
+      description:
+        "Column header text. Leave empty for unnamed groups (e.g. Company's first column).",
+    }),
+    defineField({
+      name: "link",
+      title: "Column Link",
+      type: "link",
+      description:
+        "Optional -- makes the column header clickable (e.g. Products column headers link to section pages)",
+    }),
+    defineField({
+      name: "items",
+      title: "Items",
+      type: "array",
+      of: [defineArrayMember({ type: "navLeafItem" })],
+      description: "Navigation links within this column",
+    }),
+  ],
+  preview: {
+    select: {
+      title: "title",
+      items: "items",
+    },
+    prepare({ title, items }) {
+      const itemCount = items?.length ?? 0
+      return {
+        title: title || "Unnamed Column",
+        subtitle: `${itemCount} item${itemCount === 1 ? "" : "s"}`,
+      }
+    },
+  },
+})
+
+/**
+ * Nav Menu
+ *
+ * The content of a menu dropdown panel.
+ * Contains columns of navigation links.
+ */
+export const navMegaMenu = defineType({
+  name: "navMegaMenu",
+  title: "Menu",
+  type: "object",
+  fields: [
+    defineField({
+      name: "columns",
+      title: "Columns",
+      type: "array",
+      of: [defineArrayMember({ type: "navColumn" })],
+      validation: (Rule) => Rule.required().min(1),
+      description: "Column groups within the menu dropdown",
+    }),
+  ],
+  preview: {
+    select: {
+      columns: "columns",
+    },
+    prepare({ columns }) {
+      const colCount = columns?.length ?? 0
+      return {
+        title: "Menu",
+        subtitle: `${colCount} column${colCount === 1 ? "" : "s"}`,
+      }
+    },
+  },
+})
+
+/**
+ * Nav Item
+ *
+ * A top-level navigation item. Discriminated union:
+ * - "link" type: a simple direct navigation link (e.g. Customers, Resources, Pricing)
+ * - "mega-menu" type: opens a multi-column dropdown panel (e.g. Products, Solutions, Company)
+ */
+export const navItem = defineType({
+  name: "navItem",
+  title: "Navigation Item",
+  type: "object",
+  fields: [
+    defineField({
+      name: "title",
+      title: "Title",
+      type: "string",
+      description: "Display text in the navigation bar",
+      validation: (Rule) => Rule.required(),
+    }),
+    defineField({
+      name: "itemType",
+      title: "Item Type",
+      type: "string",
+      options: {
+        list: [
+          { title: "Direct Link", value: "link" },
+          { title: "Menu", value: "mega-menu" },
+        ],
+        layout: "radio",
+      },
+      initialValue: "link",
+      validation: (Rule) => Rule.required(),
+    }),
+    defineField({
+      name: "link",
+      title: "Link",
+      type: "link",
+      description: "Destination for direct link items",
+      hidden: ({ parent }) => parent?.itemType !== "link",
+    }),
+    defineField({
+      name: "megaMenu",
+      title: "Menu",
+      type: "navMegaMenu",
+      description: "Dropdown menu content with columns",
+      hidden: ({ parent }) => parent?.itemType !== "mega-menu",
+    }),
+  ],
+  preview: {
+    select: {
+      title: "title",
+      itemType: "itemType",
+      columns: "megaMenu.columns",
+    },
+    prepare({ title, itemType, columns }) {
+      const colCount = columns?.length ?? 0
+      const subtitle =
+        itemType === "mega-menu"
+          ? `Menu (${colCount} column${colCount === 1 ? "" : "s"})`
+          : "Direct Link"
+      return {
+        title: title || "Untitled Item",
+        subtitle,
+      }
+    },
+  },
+})

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

@@ -0,0 +1,39 @@
+import { defineArrayMember, defineType } from "sanity"
+import { PageBuilderInput } from "@/lib/integrations/sanity/components/page-builder-input"
+import {
+  pageBuilderInsertMenuGroups,
+  pageBuilderReferenceMembers,
+} from "@/lib/integrations/sanity/page-builder-config"
+
+export const pageBuilder = defineType({
+  name: "pageBuilder",
+  title: "Page Builder",
+  type: "array",
+  components: { input: PageBuilderInput },
+  options: {
+    insertMenu: {
+      filter: true,
+      groups: pageBuilderInsertMenuGroups,
+    },
+  },
+  of: pageBuilderReferenceMembers.map((member) =>
+    defineArrayMember({
+      name: member.name,
+      title: member.title,
+      type: "reference",
+      to: [{ type: member.documentType }],
+      ...(member.documentId
+        ? {
+            options: {
+              disableNew: true,
+              filter: "_id in [$documentId, $draftDocumentId]",
+              filterParams: {
+                documentId: member.documentId,
+                draftDocumentId: `drafts.${member.documentId}`,
+              },
+            },
+          }
+        : {}),
+    })
+  ),
+})

package/src/templates/next-pagebuilder/lib/integrations/sanity/schemas/shared/page-folder.ts

@@ -0,0 +1,124 @@
+import { defineField, defineType } from "sanity"
+import { apiVersion } from "@/lib/integrations/sanity/env"
+import { pageFolderIcon } from "@/lib/integrations/sanity/icons"
+
+type FolderValidationDocument = {
+  _id?: string
+}
+
+export const pageFolder = defineType({
+  name: "pageFolder",
+  title: "Page Folder",
+  type: "document",
+  icon: pageFolderIcon,
+  fields: [
+    defineField({
+      name: "title",
+      title: "Title",
+      type: "string",
+      validation: (Rule) => Rule.required(),
+    }),
+    defineField({
+      name: "parentFolder",
+      title: "Parent Folder",
+      type: "reference",
+      to: [{ type: "pageFolder" }],
+      description: "Optional parent folder for nesting inside the Pages tree.",
+      hidden: true,
+      options: {
+        disableNew: true,
+        filter: ({ document }) => {
+          const currentId = (document as FolderValidationDocument | undefined)
+            ?._id
+          const normalizedId = currentId?.replace(/^drafts\./, "")
+
+          return normalizedId
+            ? {
+                filter: `_type == "pageFolder" && !(_id in [$id, "drafts." + $id])`,
+                params: { id: normalizedId },
+              }
+            : { filter: `_type == "pageFolder"` }
+        },
+      },
+      validation: (Rule) =>
+        Rule.custom((value, context) => {
+          const document = context.document as
+            | FolderValidationDocument
+            | undefined
+          const currentId = document?._id?.replace(/^drafts\./, "")
+
+          if (value?._ref && currentId && value._ref === currentId) {
+            return "A folder cannot be its own parent"
+          }
+
+          return true
+        }),
+    }),
+    defineField({
+      name: "slug",
+      title: "Slug",
+      type: "slug",
+      description:
+        "Required full folder path for organization, for example blog or blog/guides.",
+      options: {
+        source: "title",
+        maxLength: 200,
+      },
+      validation: (Rule) =>
+        Rule.required().custom(async (slug, context) => {
+          if (!slug?.current) {
+            return "Slug is required"
+          }
+
+          if (!/^[a-z0-9-/]+$/.test(slug.current)) {
+            return "Slug must be lowercase with hyphens, letters, numbers, and forward slashes only"
+          }
+
+          if (slug.current.startsWith("/") || slug.current.endsWith("/")) {
+            return "Slug must not start or end with a forward slash"
+          }
+
+          const document = context.document as
+            | FolderValidationDocument
+            | undefined
+          const id = document?._id?.replace(/^drafts\./, "")
+
+          if (!id) return true
+
+          const client = context.getClient({ apiVersion })
+          const existing = await client.fetch<number>(
+            `count(*[
+              _type == "pageFolder" &&
+              slug.current == $slug &&
+              !(_id in [$id, "drafts." + $id])
+            ])`,
+            {
+              slug: slug.current,
+              id,
+            }
+          )
+
+          return existing === 0 || "Another page folder already uses this slug"
+        }),
+    }),
+  ],
+  preview: {
+    select: {
+      title: "title",
+      slug: "slug.current",
+    },
+    prepare({ title, slug }) {
+      return {
+        title: title || "Untitled Folder",
+        subtitle: slug ? `/${slug}` : "Folder",
+      }
+    },
+  },
+  orderings: [
+    {
+      title: "Title A-Z",
+      name: "titleAsc",
+      by: [{ field: "title", direction: "asc" }],
+    },
+  ],
+})

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

@@ -0,0 +1,232 @@
+import { defineField, defineType } from "sanity"
+import { apiVersion } from "@/lib/integrations/sanity/env"
+import { pageIcon } from "@/lib/integrations/sanity/icons"
+import {
+  getInvalidPageBuilderDocumentTypes,
+  getPageBuilderReferenceMemberByDocumentType,
+  getPageCategoryIcon,
+  type PageBuilderDocumentType,
+  type PageBuilderGroupName,
+  pageBuilderPageTypes,
+} from "@/lib/integrations/sanity/page-builder-config"
+import { getGeneratedPageCategory } from "@/lib/integrations/sanity/page-category"
+
+type PageValidationDocument = {
+  _id?: string
+  type?: PageBuilderGroupName
+  pageFolder?: {
+    _ref?: string
+  }
+  slug?: { current?: string | null }
+  pageBuilder?: Array<{
+    _key?: string
+    _type?: string
+    _ref?: string
+  }>
+}
+
+type PageSlugValidationContext = {
+  document?: PageValidationDocument | undefined
+  getClient: (options: { apiVersion: string }) => {
+    fetch: <T>(query: string, params?: Record<string, unknown>) => Promise<T>
+  }
+}
+
+type ReferencedPageBuilderDocument = {
+  _id: string
+  _type: PageBuilderDocumentType
+}
+
+const PAGE_FOLDER_QUERY = `*[_type == "pageFolder" && _id in [$publishedId, $draftId]][0].slug.current`
+
+async function getGeneratedPageCategoryForDocument(
+  document: PageValidationDocument | undefined,
+  getClient: PageSlugValidationContext["getClient"]
+) {
+  const pageFolderId = document?.pageFolder?._ref?.replace(/^drafts\./, "")
+  let folder: string | null = null
+
+  if (pageFolderId) {
+    folder = await getClient({ apiVersion }).fetch<string | null>(
+      PAGE_FOLDER_QUERY,
+      { draftId: `drafts.${pageFolderId}`, publishedId: pageFolderId }
+    )
+  }
+
+  return getGeneratedPageCategory({
+    folder,
+    slug: document?.slug?.current ?? null,
+  })
+}
+
+async function isPageSlugUniqueInFolder(
+  slug: string | null,
+  context: PageSlugValidationContext
+) {
+  const id = context.document?._id?.replace(/^drafts\./, "")
+
+  if (!id) return true
+
+  const pageFolderId = context.document?.pageFolder?._ref ?? null
+  const client = context.getClient({ apiVersion })
+  const existing = await client.fetch<number>(
+    `count(*[
+      _type == "page" &&
+      !(_id in [$id, "drafts." + $id]) &&
+      (
+        ($pageFolderId == null && !defined(pageFolder._ref)) ||
+        pageFolder._ref == $pageFolderId
+      ) &&
+      (
+        ($slug == null && !defined(slug.current)) ||
+        slug.current == $slug
+      )
+    ])`,
+    {
+      id,
+      pageFolderId,
+      slug,
+    }
+  )
+
+  return existing === 0
+}
+
+export const page = defineType({
+  name: "page",
+  title: "Page",
+  type: "document",
+  icon: pageIcon,
+  fields: [
+    defineField({
+      name: "title",
+      title: "Title",
+      type: "string",
+      validation: (Rule) => Rule.required(),
+    }),
+    defineField({
+      name: "type",
+      title: "Page Category",
+      type: "string",
+      options: { list: pageBuilderPageTypes },
+      initialValue: "generic",
+      hidden: true,
+      readOnly: true,
+    }),
+    defineField({
+      name: "pageFolder",
+      title: "Folder",
+      type: "reference",
+      to: [{ type: "pageFolder" }],
+      description: "Optional Studio folder for organizing this page.",
+      hidden: true,
+    }),
+    defineField({
+      name: "slug",
+      title: "Slug",
+      type: "slug",
+      description: "URL path without leading slash. Leave blank for homepage.",
+      options: {
+        source: "title",
+        maxLength: 200,
+        isUnique: (slug, context) => isPageSlugUniqueInFolder(slug, context),
+      },
+      validation: (Rule) =>
+        Rule.custom(async (slug, context) => {
+          return (
+            (await isPageSlugUniqueInFolder(slug?.current ?? null, {
+              document: context.document as PageValidationDocument | undefined,
+              getClient: context.getClient,
+            })) || "Another page in this folder already uses this slug"
+          )
+        }),
+    }),
+    defineField({
+      name: "pageBuilder",
+      title: "Page Builder",
+      type: "pageBuilder",
+      description: "Composable content blocks for this page",
+      validation: (Rule) =>
+        Rule.custom(async (value, context) => {
+          const document = context.document as
+            | PageValidationDocument
+            | undefined
+          const pageType = await getGeneratedPageCategoryForDocument(
+            document,
+            context.getClient
+          )
+          const pageBuilderItems = Array.isArray(value)
+            ? (value as Array<{ _ref?: string }>)
+            : []
+          const referenceIds = pageBuilderItems
+            .map((item) => item?._ref?.replace(/^drafts\./, ""))
+            .filter((item): item is string => typeof item === "string")
+
+          if (referenceIds.length === 0) return true
+
+          const referencedDocuments = await context
+            .getClient({ apiVersion })
+            .fetch<ReferencedPageBuilderDocument[]>(
+              `*[
+                _id in $publishedIds || _id in $draftIds
+              ]{
+                _id,
+                _type
+              }`,
+              {
+                publishedIds: referenceIds,
+                draftIds: referenceIds.map((id) => `drafts.${id}`),
+              }
+            )
+
+          const invalidDocumentTypes = getInvalidPageBuilderDocumentTypes(
+            pageType,
+            referencedDocuments.map((entry) => entry._type)
+          )
+
+          if (invalidDocumentTypes.length === 0) return true
+
+          const invalidMemberTitles = invalidDocumentTypes.map(
+            (documentType) =>
+              getPageBuilderReferenceMemberByDocumentType(documentType)
+                ?.title ?? documentType
+          )
+
+          return `These page builder components do not belong to the "${pageType ?? "generic"}" category: ${invalidMemberTitles.join(", ")}`
+        }),
+    }),
+    defineField({
+      name: "metadata",
+      title: "SEO & Metadata",
+      type: "metadata",
+    }),
+  ],
+  preview: {
+    select: {
+      id: "_id",
+      title: "title",
+      folder: "pageFolder->slug.current",
+      slug: "slug.current",
+    },
+    prepare({ folder, id, title, slug }) {
+      let path = "No slug"
+      if (id === "page-homepage") {
+        path = "/"
+      } else if (slug) {
+        path = `/${slug}`
+      }
+      return {
+        title: title || "Untitled",
+        subtitle: path,
+        media: getPageCategoryIcon(getGeneratedPageCategory({ folder, slug })),
+      }
+    },
+  },
+  orderings: [
+    {
+      title: "Title A-Z",
+      name: "titleAsc",
+      by: [{ field: "title", direction: "asc" }],
+    },
+  ],
+})

package/src/templates/next-pagebuilder/lib/integrations/sanity/schemas/shared/richText.ts

@@ -0,0 +1,63 @@
+import { defineType } from "sanity"
+import { linkAnnotations } from "./link"
+
+export const richText = defineType({
+  name: "richText",
+  title: "Rich Text",
+  type: "array",
+  of: [
+    {
+      type: "block",
+      styles: [
+        { title: "Normal", value: "normal" },
+        { title: "H1", value: "h1" },
+        { title: "H2", value: "h2" },
+        { title: "H3", value: "h3" },
+        { title: "H4", value: "h4" },
+        { title: "H5", value: "h5" },
+        { title: "H6", value: "h6" },
+        { title: "Quote", value: "blockquote" },
+      ],
+      lists: [
+        { title: "Bullet", value: "bullet" },
+        { title: "Number", value: "number" },
+      ],
+      marks: {
+        decorators: [
+          { title: "Strong", value: "strong" },
+          { title: "Emphasis", value: "em" },
+          { title: "Code", value: "code" },
+          { title: "Underline", value: "underline" },
+          { title: "Strike", value: "strike-through" },
+        ],
+        annotations: linkAnnotations,
+      },
+    },
+    {
+      type: "table",
+      title: "Table",
+    },
+    {
+      type: "image",
+      title: "Image",
+      options: {
+        hotspot: true,
+      },
+      fields: [
+        {
+          name: "alt",
+          title: "Alt Text",
+          type: "string",
+          description: "Alternative text for screen readers",
+          validation: (Rule) => Rule.required(),
+        },
+        {
+          name: "caption",
+          title: "Caption",
+          type: "string",
+          description: "Optional caption displayed below the image",
+        },
+      ],
+    },
+  ],
+})

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

@@ -0,0 +1,44 @@
+import {
+  companyDataIcon,
+  footerIcon,
+  navbarIcon,
+  pageListIcon,
+} from "./icons"
+
+export const singletonComponents = [
+  {
+    schemaType: "blogCollection",
+    documentId: "blogCollection",
+    title: "Blog Collection",
+    icon: pageListIcon,
+  },
+] as const
+
+export const singletonLayout = [
+  {
+    schemaType: "companyData",
+    documentId: "companyData",
+    title: "Company Data",
+    icon: companyDataIcon,
+  },
+  {
+    schemaType: "navbar",
+    documentId: "navbar",
+    title: "Navbar",
+    icon: navbarIcon,
+  },
+  {
+    schemaType: "footer",
+    documentId: "footer",
+    title: "Footer",
+    icon: footerIcon,
+  },
+] as const
+
+export const singletonComponentTypes: Set<string> = new Set(
+  singletonComponents.map((item) => item.schemaType)
+)
+
+export const singletonLayoutTypes: Set<string> = new Set(
+  singletonLayout.map((item) => item.schemaType)
+)