bsmnt 0.2.11 → 0.3.1

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

@@ -0,0 +1,211 @@
+import { table } from "@sanity/table"
+import { defineConfig } from "sanity"
+import {
+  defineDocuments,
+  defineLocations,
+  presentationTool,
+} from "sanity/presentation"
+import { structureTool } from "sanity/structure"
+import { media } from "sanity-plugin-media"
+import { createConfirmPublishAction } from "./confirm-publish-action"
+import { dataset, previewURL, projectId } from "./env"
+import { schema } from "./schemas"
+import { singletonComponentTypes } from "./singletons"
+import { structure } from "./structure"
+
+const isProd = process.env.NODE_ENV === "production"
+
+const singletonDocumentActions = new Set([
+  "publish",
+  "discardChanges",
+  "restore",
+])
+
+const isSingletonDocument = (schemaType: string, documentId?: string) =>
+  singletonComponentTypes.has(schemaType) ||
+  (schemaType === "page" && documentId === "page-homepage")
+
+const MAX_FOLDER_DEPTH = 6
+
+const buildNestedSlugExpression = (
+  parentReferenceField: string,
+  leafSlugField: string
+) => {
+  const cases = Array.from({ length: MAX_FOLDER_DEPTH }, (_, index) => {
+    const depth = MAX_FOLDER_DEPTH - index
+    const parentSlugRefs = Array.from({ length: depth }, (_, parentIndex) => {
+      const remainingDepth = depth - parentIndex - 1
+      return `${parentReferenceField}${"->parentFolder".repeat(remainingDepth)}->slug.current`
+    })
+
+    const pathDefinedChecks = parentSlugRefs
+      .map((field) => `defined(${field})`)
+      .join(" && ")
+
+    const childPath = [...parentSlugRefs, leafSlugField].join(' + "/" + ')
+    const folderRootPath = parentSlugRefs.join(' + "/" + ')
+
+    return [
+      `${pathDefinedChecks} && ${leafSlugField} == "/" => ${folderRootPath}`,
+      `${pathDefinedChecks} && defined(${leafSlugField}) => ${childPath}`,
+    ]
+  }).flat()
+
+  return `
+    select(
+      ${cases.join(",\n      ")},
+      ${leafSlugField}
+    )
+  `
+}
+
+const pageResolvedSlugExpression = buildNestedSlugExpression(
+  "pageFolder",
+  "slug.current"
+)
+
+export default defineConfig({
+  basePath: "/studio",
+  projectId,
+  dataset,
+  schema: {
+    ...schema,
+    templates: (previousTemplates) => [
+      ...previousTemplates.filter(
+        (template) =>
+          ![
+            "page-homepage",
+            "page-with-folder",
+            "page-folder-with-parent",
+          ].includes(template.id)
+      ),
+      {
+        id: "page-homepage",
+        title: "Homepage",
+        schemaType: "page",
+        value: {
+          title: "Homepage",
+        },
+      },
+      {
+        id: "page-with-folder",
+        title: "Page in Folder",
+        schemaType: "page",
+        parameters: [
+          { name: "pageFolderId", title: "Page Folder ID", type: "string" },
+        ],
+        value: ({ pageFolderId }: { pageFolderId?: string }) => ({
+          pageFolder: pageFolderId
+            ? {
+                _type: "reference",
+                _ref: pageFolderId,
+              }
+            : undefined,
+        }),
+      },
+      {
+        id: "page-folder-with-parent",
+        title: "Page Folder in Folder",
+        schemaType: "pageFolder",
+        parameters: [
+          { name: "parentFolderId", title: "Parent Folder ID", type: "string" },
+        ],
+        value: ({ parentFolderId }: { parentFolderId?: string }) => ({
+          parentFolder: parentFolderId
+            ? {
+                _type: "reference",
+                _ref: parentFolderId,
+              }
+            : undefined,
+        }),
+      },
+    ],
+  },
+  document: {
+    actions: (previousActions, context) => {
+      const filtered = isSingletonDocument(
+        context.schemaType,
+        context.documentId
+      )
+        ? previousActions.filter(
+            (action) =>
+              action.action !== undefined &&
+              singletonDocumentActions.has(action.action)
+          )
+        : previousActions
+
+      if (!isProd) return filtered
+
+      return filtered.map((action) =>
+        action.action === "publish"
+          ? createConfirmPublishAction(action)
+          : action
+      )
+    },
+    newDocumentOptions: (previousOptions) =>
+      previousOptions.filter(
+        (option) =>
+          !singletonComponentTypes.has(option.templateId) &&
+          option.templateId !== "page-homepage"
+      ),
+  },
+  plugins: [
+    structureTool({ structure }),
+
+    presentationTool({
+      name: "preview",
+      title: "Preview",
+      resolve: {
+        // Map routes to documents and GROQ filters
+        mainDocuments: defineDocuments([
+          {
+            route: "/",
+            filter: '_type == "page" && _id == "page-homepage"',
+          },
+          // Page builder pages - all other slugs (supports nested paths)
+          {
+            route: "/:slug+",
+            filter: `_type == "page" && ${pageResolvedSlugExpression} == $slug`,
+          },
+        ]),
+        locations: {
+          page: defineLocations({
+            select: {
+              _id: "_id",
+              title: "title",
+              slug: "slug.current",
+              resolvedSlug: pageResolvedSlugExpression,
+            },
+            resolve: (doc) => {
+              if (doc?._id === "page-homepage") {
+                return {
+                  locations: [{ title: doc?.title || "Homepage", href: "/" }],
+                }
+              }
+              if (doc?.resolvedSlug) {
+                return {
+                  locations: [
+                    {
+                      title: doc?.title || "Page",
+                      href: `/${doc.resolvedSlug}`,
+                    },
+                  ],
+                }
+              }
+              return { locations: [] }
+            },
+          }),
+        },
+      },
+      previewUrl: {
+        origin: previewURL,
+        draftMode: {
+          enable: "/api/draft-mode/enable",
+          disable: "/api/draft-mode/disable",
+        },
+      },
+    }),
+    media(),
+    table(),
+  ],
+})

package/src/templates/next-pagebuilder/lib/integrations/sanity/schemas/components/index.ts

@@ -0,0 +1,4 @@
+export { blogContent } from "./reusable/blog-content"
+export { description } from "./reusable/description"
+export { hero } from "./reusable/hero"
+export { blogCollection } from "./singleton/content-collection"

package/src/templates/next-pagebuilder/lib/integrations/sanity/schemas/components/reusable/blog-content.ts

@@ -0,0 +1,89 @@
+import { defineField, defineType } from "sanity"
+import { contentIcon } from "@/lib/integrations/sanity/icons"
+
+export const blogContent = defineType({
+  name: "blogContent",
+  title: "Blog Content",
+  type: "document",
+  icon: contentIcon,
+  fields: [
+    defineField({
+      name: "title",
+      title: "Title",
+      type: "string",
+      validation: (Rule) => Rule.required(),
+    }),
+    defineField({
+      name: "thumbnail",
+      title: "Thumbnail",
+      type: "image",
+      description: "Featured image for the article",
+      options: { hotspot: true },
+      fields: [
+        {
+          name: "alt",
+          title: "Alt Text",
+          type: "string",
+          description: "Alternative text for screen readers",
+          validation: (Rule) => Rule.required(),
+        },
+      ],
+    }),
+    defineField({
+      name: "categories",
+      title: "Categories",
+      type: "array",
+      of: [{ type: "reference", to: [{ type: "blogCategory" }] }],
+      description: "Category tags for filtering",
+    }),
+    defineField({
+      name: "date",
+      title: "Publication Date",
+      type: "date",
+      options: { dateFormat: "YYYY-MM-DD" },
+    }),
+    defineField({
+      name: "author",
+      title: "Author",
+      type: "reference",
+      to: [{ type: "author" }],
+    }),
+    defineField({
+      name: "body",
+      title: "Body",
+      type: "richText",
+      description: "Article content",
+    }),
+    defineField({
+      name: "relatedPosts",
+      title: "Related Posts",
+      type: "array",
+      of: [
+        {
+          type: "reference",
+          to: [{ type: "page" }],
+          options: {
+            filter:
+              'pageFolder->slug.current == "blog" && defined(slug.current) && slug.current != ""',
+          },
+        },
+      ],
+      description: "Manually curated related blog pages",
+      validation: (Rule) => Rule.max(3),
+    }),
+  ],
+  preview: {
+    select: {
+      title: "title",
+      date: "date",
+      media: "thumbnail",
+    },
+    prepare({ title, date, media }) {
+      return {
+        title: title || "Blog Content",
+        subtitle: date || "No date set",
+        media,
+      }
+    },
+  },
+})

package/src/templates/next-pagebuilder/lib/integrations/sanity/schemas/components/reusable/description.ts

@@ -0,0 +1,29 @@
+import { defineField, defineType } from "sanity"
+import { descriptionIcon } from "@/lib/integrations/sanity/icons"
+
+export const description = defineType({
+  name: "description",
+  title: "Description",
+  type: "document",
+  icon: descriptionIcon,
+  fields: [
+    defineField({
+      name: "description",
+      title: "Description",
+      type: "text",
+      rows: 4,
+      validation: (Rule) => Rule.required(),
+    }),
+  ],
+  preview: {
+    select: {
+      description: "description",
+    },
+    prepare({ description }) {
+      return {
+        title: "Description",
+        subtitle: description || "Untitled",
+      }
+    },
+  },
+})

package/src/templates/next-pagebuilder/lib/integrations/sanity/schemas/components/reusable/hero.ts

@@ -0,0 +1,28 @@
+import { defineField, defineType } from "sanity"
+import { heroIcon } from "@/lib/integrations/sanity/icons"
+
+export const hero = defineType({
+  name: "hero",
+  title: "Heading",
+  type: "document",
+  icon: heroIcon,
+  fields: [
+    defineField({
+      name: "headline",
+      title: "Heading",
+      type: "string",
+      validation: (Rule) => Rule.required(),
+    }),
+  ],
+  preview: {
+    select: {
+      title: "headline",
+    },
+    prepare({ title }) {
+      return {
+        title: title || "Untitled",
+        subtitle: "Heading",
+      }
+    },
+  },
+})

package/src/templates/next-pagebuilder/lib/integrations/sanity/schemas/components/singleton/content-collection.ts

@@ -0,0 +1,45 @@
+import { defineField, defineType } from "sanity"
+import type { SanityStudioIcon } from "@/lib/integrations/sanity/icons"
+import { pageListIcon } from "@/lib/integrations/sanity/icons"
+
+function createContentCollection(config: {
+  name: string
+  title: string
+  icon: SanityStudioIcon
+  label: string
+}) {
+  return defineType({
+    name: config.name,
+    title: config.title,
+    type: "document",
+    icon: config.icon,
+    description: `This component contains all the ${config.label}`,
+    fields: [
+      defineField({
+        name: "subtitle",
+        title: "Subtitle",
+        type: "string",
+        description:
+          "Text displayed between the featured articles and the rest of the collection",
+      }),
+    ],
+    preview: {
+      select: {
+        title: "title",
+      },
+      prepare({ title }) {
+        return {
+          title: title || config.title,
+          subtitle: `${config.title} with search and category filters`,
+        }
+      },
+    },
+  })
+}
+
+export const blogCollection = createContentCollection({
+  name: "blogCollection",
+  title: "Blog Collection",
+  icon: pageListIcon,
+  label: "blog articles",
+})

package/src/templates/next-pagebuilder/lib/integrations/sanity/schemas/content/author.ts

@@ -0,0 +1,70 @@
+import { defineField, defineType } from "sanity"
+import { authorIcon } from "@/lib/integrations/sanity/icons"
+
+export const author = defineType({
+  name: "author",
+  title: "Author",
+  type: "document",
+  icon: authorIcon,
+  fields: [
+    defineField({
+      name: "name",
+      title: "Name",
+      type: "string",
+      validation: (Rule) => Rule.required(),
+    }),
+    defineField({
+      name: "avatar",
+      title: "Avatar",
+      type: "image",
+      options: {
+        hotspot: true,
+      },
+      fields: [
+        {
+          name: "alt",
+          title: "Alt Text",
+          type: "string",
+          description: "Alternative text for screen readers",
+        },
+      ],
+      validation: (Rule) => Rule.required(),
+    }),
+    defineField({
+      name: "role",
+      title: "Role",
+      type: "string",
+      description: "Job title or role (e.g. CEO, Engineering Lead)",
+    }),
+    defineField({
+      name: "description",
+      title: "Description",
+      type: "text",
+      rows: 3,
+      description: "Short bio displayed on blog articles",
+    }),
+    defineField({
+      name: "linkedInUrl",
+      title: "LinkedIn URL",
+      type: "url",
+      validation: (Rule) =>
+        Rule.uri({
+          scheme: ["https"],
+        }),
+    }),
+  ],
+  preview: {
+    select: {
+      title: "name",
+      subtitle: "role",
+      media: "avatar",
+    },
+  },
+  orderings: [
+    {
+      title: "Name A-Z",
+      name: "nameAsc",
+      by: [{ field: "name", direction: "asc" }],
+    },
+  ],
+})

package/src/templates/next-pagebuilder/lib/integrations/sanity/schemas/content/blog-category.ts

@@ -0,0 +1,55 @@
+import { defineField, defineType } from "sanity"
+import { blogCategoryIcon } from "@/lib/integrations/sanity/icons"
+
+export const blogCategory = defineType({
+  name: "blogCategory",
+  title: "Blog Category",
+  type: "document",
+  icon: blogCategoryIcon,
+  fields: [
+    defineField({
+      name: "title",
+      title: "Title",
+      type: "string",
+      description: "Category name (e.g. AI, Product Updates, Engineering)",
+      validation: (Rule) => Rule.required(),
+    }),
+    defineField({
+      name: "slug",
+      title: "Slug",
+      type: "slug",
+      description: "URL-friendly identifier used for filtering",
+      options: {
+        source: "title",
+        maxLength: 96,
+      },
+      validation: (Rule) =>
+        Rule.required().custom((slug) => {
+          if (!slug?.current) return "Required"
+          if (!/^[a-z0-9-]+$/.test(slug.current)) {
+            return "Slug must be lowercase with hyphens only"
+          }
+          return true
+        }),
+    }),
+    defineField({
+      name: "description",
+      title: "Description",
+      type: "text",
+      rows: 2,
+      description: "Brief description of this category",
+    }),
+  ],
+  preview: {
+    select: {
+      title: "title",
+    },
+  },
+  orderings: [
+    {
+      title: "Title A-Z",
+      name: "titleAsc",
+      by: [{ field: "title", direction: "asc" }],
+    },
+  ],
+})

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

@@ -0,0 +1,96 @@
+/**
+ * Sanity Schema Types
+ *
+ * All schema definitions for Sanity CMS.
+ * Shared schemas live in `schemas/shared`, content documents live in
+ * `schemas/content`, component documents live in `schemas/components`, and
+ * layout documents live in `schemas/layout`.
+ */
+
+import type { SchemaTypeDefinition } from "sanity"
+import {
+  blogCollection,
+  blogContent,
+  description,
+  hero,
+} from "./components"
+import { author } from "./content/author"
+import { blogCategory } from "./content/blog-category"
+import { companyData } from "./layout/company-data"
+import { footer } from "./layout/footer"
+import { navbar } from "./layout/navbar"
+import { externalLink, link, pageReference } from "./shared/link"
+import { metadata } from "./shared/metadata"
+import {
+  navColumn,
+  navItem,
+  navLeafItem,
+  navMegaMenu,
+} from "./shared/nav-objects"
+import { page } from "./shared/page"
+import { pageBuilder } from "./shared/page-builder"
+import { pageFolder } from "./shared/page-folder"
+import { richText } from "./shared/richText"
+
+// Re-export all schemas for convenience
+export {
+  author,
+  blogCategory,
+  blogCollection,
+  blogContent,
+  companyData,
+  description,
+  externalLink,
+  footer,
+  hero,
+  link,
+  metadata,
+  navbar,
+  navColumn,
+  navItem,
+  navLeafItem,
+  navMegaMenu,
+  page,
+  pageBuilder,
+  pageFolder,
+  pageReference,
+  richText,
+}
+
+// Schema collection for Sanity configuration
+export const schema: { types: SchemaTypeDefinition[] } = {
+  types: [
+    // Object types (reusable field types)
+    pageReference,
+    externalLink,
+    link,
+    metadata,
+    pageBuilder,
+    richText,
+
+    // Navigation object types (used by navbar)
+    navLeafItem,
+    navColumn,
+    navMegaMenu,
+    navItem,
+
+    // Component types (reusable document components)
+    blogCollection,
+    blogContent,
+    hero,
+    description,
+
+    // Layout types (singletons for site-wide layout)
+    companyData,
+    navbar,
+    footer,
+
+    // Document types (content pages)
+    page,
+    pageFolder,
+
+    // Content types (reusable content)
+    author,
+    blogCategory,
+  ],
+}

package/src/templates/next-pagebuilder/lib/integrations/sanity/schemas/layout/company-data.ts

@@ -0,0 +1,62 @@
+import { defineArrayMember, defineField, defineType } from "sanity"
+import { socialLinksIcon } from "@/lib/integrations/sanity/icons"
+
+export const companyData = defineType({
+  name: "companyData",
+  title: "Company Data",
+  type: "document",
+  fields: [
+    defineField({
+      name: "socialLinks",
+      title: "Social Links",
+      type: "array",
+      of: [
+        defineArrayMember({
+          type: "object",
+          icon: socialLinksIcon,
+          fields: [
+            defineField({
+              name: "name",
+              title: "Name",
+              type: "string",
+              description: "Platform name (e.g. LinkedIn, TikTok, Bluesky)",
+              validation: (Rule) => Rule.required(),
+            }),
+            defineField({
+              name: "icon",
+              title: "Icon",
+              type: "image",
+              description: "Platform icon (SVG, PNG, WebP, etc.)",
+              validation: (Rule) => Rule.required(),
+            }),
+            defineField({
+              name: "url",
+              title: "URL",
+              type: "url",
+              validation: (Rule) => Rule.required(),
+            }),
+            defineField({
+              name: "label",
+              title: "Label",
+              type: "string",
+              description:
+                "Accessible label for the link (e.g. 'Follow us on LinkedIn')",
+            }),
+          ],
+          preview: {
+            select: {
+              title: "name",
+              subtitle: "url",
+              media: "icon",
+            },
+          },
+        }),
+      ],
+    }),
+  ],
+  preview: {
+    prepare() {
+      return { title: "Company Data" }
+    },
+  },
+})