bsmnt 0.2.11 → 0.3.0

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