bsmnt 0.2.10 → 0.3.0

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

@@ -0,0 +1,453 @@
+import type {
+  ListBuilder,
+  ListItemBuilder,
+  StructureBuilder,
+  StructureResolver,
+  StructureResolverContext,
+} from "sanity/structure"
+import { apiVersion } from "./env"
+import {
+  authorIcon,
+  blogCategoryIcon,
+  componentsFolderIcon,
+  contentFolderIcon,
+  contentIcon,
+  descriptionIcon,
+  heroIcon,
+  layoutFolderIcon,
+  pageFolderIcon,
+  pageIcon,
+  pagesFolderIcon,
+} from "./icons"
+import {
+  getPageCategoryIcon,
+  type PageBuilderGroupName,
+} from "./page-builder-config"
+import { pageCategoryExpression } from "./page-category"
+import { singletonComponents, singletonLayout } from "./singletons"
+
+type PageTreeItem = {
+  _id: string
+  _type: "page" | "pageFolder"
+  title?: string | null
+  slug?: string | null
+  pageType?: PageBuilderGroupName | null
+}
+
+const PAGE_TREE_ITEM_ID_PREFIX = {
+  page: "page-tree-",
+  pageFolder: "page-folder-tree-",
+} as const
+
+const PAGE_TREE_QUERY = `
+  *[
+    (
+      _type == "pageFolder" &&
+      (
+        ($folderId == null && !defined(parentFolder._ref)) ||
+        parentFolder._ref == $folderId
+      )
+    ) ||
+    (
+      _type == "page" &&
+      (
+        ($folderId == null && !defined(pageFolder._ref)) ||
+        pageFolder._ref == $folderId
+      )
+    )
+  ]{
+    _id,
+    _type,
+    title,
+    "slug": slug.current,
+    "pageType": ${pageCategoryExpression}
+  }
+`
+
+const normalizeDocumentId = (documentId: string) =>
+  documentId.replace(/^drafts\./, "")
+
+const getPageTreeItemId = (item: Pick<PageTreeItem, "_id" | "_type">) => {
+  const normalizedId = normalizeDocumentId(item._id)
+
+  return `${PAGE_TREE_ITEM_ID_PREFIX[item._type]}${normalizedId}`
+}
+
+export const getDocumentIdFromPageTreeItemId = (itemId: string) =>
+  normalizeDocumentId(
+    itemId
+      .replace(PAGE_TREE_ITEM_ID_PREFIX.page, "")
+      .replace(PAGE_TREE_ITEM_ID_PREFIX.pageFolder, "")
+  )
+
+const getPageTreeTemplateIds = (folderId: string | null) =>
+  folderId === null
+    ? ["page", "pageFolder"]
+    : ["page-with-folder", "page-folder-with-parent"]
+
+const buildPageTreeCreateChild = (
+  S: StructureBuilder,
+  documentId: string,
+  folderId: string | null,
+  templateId: string
+) => {
+  if (templateId === "page") {
+    return S.documentWithInitialValueTemplate("page").documentId(documentId)
+  }
+
+  if (templateId === "pageFolder") {
+    return S.documentWithInitialValueTemplate("pageFolder").documentId(
+      documentId
+    )
+  }
+
+  if (templateId === "page-with-folder") {
+    return S.documentWithInitialValueTemplate("page-with-folder", {
+      pageFolderId: folderId,
+    }).documentId(documentId)
+  }
+
+  if (templateId === "page-folder-with-parent") {
+    return S.documentWithInitialValueTemplate("page-folder-with-parent", {
+      parentFolderId: folderId,
+    }).documentId(documentId)
+  }
+
+  return undefined
+}
+
+const getPageTreeClient = (context: StructureResolverContext) =>
+  context
+    .getClient({ apiVersion })
+    .withConfig({ perspective: context.perspectiveStack })
+
+const getPageItemTitle = (page: PageTreeItem) => {
+  return `${page.title || "Untitled Page"} (${`/${page.slug || ""}`})`
+}
+
+const getFolderItemTitle = (folder: PageTreeItem) =>
+  folder.slug
+    ? `${folder.title || "Untitled Folder"} (${`/${folder.slug}`})`
+    : folder.title || "Untitled Folder"
+
+const sortPageTreeItems = (items: PageTreeItem[]) =>
+  [...items].sort((left, right) => {
+    if (left._type !== right._type) {
+      return left._type === "page" ? -1 : 1
+    }
+
+    const leftLabel =
+      left._type === "page" ? getPageItemTitle(left) : getFolderItemTitle(left)
+    const rightLabel =
+      right._type === "page"
+        ? getPageItemTitle(right)
+        : getFolderItemTitle(right)
+
+    if (leftLabel === "/") return -1
+    if (rightLabel === "/") return 1
+
+    return leftLabel.localeCompare(rightLabel)
+  })
+
+async function fetchPageTreeItems(
+  context: StructureResolverContext,
+  folderId: string | null
+) {
+  return getPageTreeClient(context).fetch<PageTreeItem[]>(PAGE_TREE_QUERY, {
+    folderId,
+  })
+}
+
+function buildPageTreeList(
+  S: StructureBuilder,
+  context: StructureResolverContext,
+  folderId: string | null,
+  title: string
+): Promise<ListBuilder> {
+  return fetchPageTreeItems(context, folderId).then((items) => {
+    const currentFolderId = folderId
+    const sortedItems = sortPageTreeItems(items)
+    const allowedTemplateIds = getPageTreeTemplateIds(currentFolderId)
+    const childItems: ListItemBuilder[] = sortedItems.map((item) => {
+      const normalizedId = normalizeDocumentId(item._id)
+
+      if (item._type === "pageFolder") {
+        return S.listItem()
+          .id(getPageTreeItemId(item))
+          .title(getFolderItemTitle(item))
+          .icon(pageFolderIcon)
+          .child(() =>
+            buildPageTreeList(
+              S,
+              context,
+              item._id,
+              item.title || "Untitled Folder"
+            )
+          )
+      }
+
+      return S.listItem()
+        .id(getPageTreeItemId(item))
+        .title(getPageItemTitle(item))
+        .icon(getPageCategoryIcon(item.pageType))
+        .child(S.document().schemaType("page").documentId(normalizedId))
+    })
+
+    const initialValueTemplates =
+      currentFolderId === null
+        ? [
+            S.initialValueTemplateItem("page"),
+            S.initialValueTemplateItem("pageFolder"),
+          ]
+        : [
+            S.initialValueTemplateItem("page-with-folder", {
+              pageFolderId: currentFolderId,
+            }),
+            S.initialValueTemplateItem("page-folder-with-parent", {
+              parentFolderId: currentFolderId,
+            }),
+          ]
+
+    const createMenuItems =
+      currentFolderId === null
+        ? [
+            S.menuItem()
+              .title("Create Page")
+              .icon(pageIcon)
+              .intent({
+                type: "create",
+                params: {
+                  type: "page",
+                  template: "page",
+                },
+              }),
+            S.menuItem()
+              .title("Create Folder")
+              .icon(pageFolderIcon)
+              .intent({
+                type: "create",
+                params: {
+                  type: "pageFolder",
+                  template: "pageFolder",
+                },
+              }),
+          ]
+        : [
+            S.menuItem()
+              .title("Create Page")
+              .icon(pageIcon)
+              .intent({
+                type: "create",
+                params: [
+                  {
+                    type: "page",
+                    template: "page-with-folder",
+                  },
+                  {
+                    pageFolderId: currentFolderId,
+                  },
+                ],
+              }),
+            S.menuItem()
+              .title("Create Folder")
+              .icon(pageFolderIcon)
+              .intent({
+                type: "create",
+                params: [
+                  {
+                    type: "pageFolder",
+                    template: "page-folder-with-parent",
+                  },
+                  {
+                    parentFolderId: currentFolderId,
+                  },
+                ],
+              }),
+          ]
+
+    const folderMenuItems =
+      currentFolderId === null
+        ? []
+        : [
+            S.menuItem()
+              .title("Folder Settings")
+              .icon(pageFolderIcon)
+              .intent({
+                type: "edit",
+                params: {
+                  id: currentFolderId,
+                  type: "pageFolder",
+                },
+              }),
+          ]
+
+    return S.list()
+      .title(title)
+      .canHandleIntent((intentName, params) => {
+        if (intentName === "create") {
+          return (
+            typeof params.template === "string" &&
+            allowedTemplateIds.includes(params.template)
+          )
+        }
+
+        if (intentName !== "edit") {
+          return false
+        }
+
+        const normalizedId =
+          typeof params.id === "string" ? normalizeDocumentId(params.id) : null
+
+        if (!normalizedId || typeof params.type !== "string") {
+          return false
+        }
+
+        if (
+          params.type === "pageFolder" &&
+          currentFolderId !== null &&
+          normalizedId === normalizeDocumentId(currentFolderId)
+        ) {
+          return true
+        }
+
+        return sortedItems.some(
+          (item) =>
+            normalizeDocumentId(item._id) === normalizedId &&
+            item._type === params.type
+        )
+      })
+      .child((itemId, options) => {
+        const normalizedId = getDocumentIdFromPageTreeItemId(itemId)
+        const matchedItem = sortedItems.find(
+          (item) => normalizeDocumentId(item._id) === normalizedId
+        )
+
+        if (matchedItem?._type === "pageFolder") {
+          return buildPageTreeList(
+            S,
+            context,
+            matchedItem._id,
+            matchedItem.title || "Untitled Folder"
+          )
+        }
+
+        if (matchedItem?._type === "page") {
+          return S.document().schemaType("page").documentId(normalizedId)
+        }
+
+        if (
+          currentFolderId !== null &&
+          normalizedId === normalizeDocumentId(currentFolderId)
+        ) {
+          return S.document().schemaType("pageFolder").documentId(normalizedId)
+        }
+
+        const templateId =
+          typeof options.params?.template === "string"
+            ? options.params.template
+            : null
+
+        if (!templateId) {
+          return undefined
+        }
+
+        return buildPageTreeCreateChild(
+          S,
+          normalizedId,
+          currentFolderId,
+          templateId
+        )
+      })
+      .menuItems([...folderMenuItems, ...createMenuItems])
+      .initialValueTemplates(initialValueTemplates)
+      .items(childItems)
+  })
+}
+
+// https://www.sanity.io/docs/structure-builder-cheat-sheet
+export const structure: StructureResolver = (S, context) =>
+  S.list()
+    .title("Content")
+    .items([
+      // GROUP 1: Pages -- root page tree with page/folder creation
+      S.listItem()
+        .title("Pages")
+        .icon(pagesFolderIcon)
+        .child(() => buildPageTreeList(S, context, null, "Pages")),
+
+      S.divider(),
+
+      // GROUP 2: Content -- authors, blog categories
+      S.listItem()
+        .title("Content")
+        .icon(contentFolderIcon)
+        .child(
+          S.list()
+            .title("Content")
+            .items([
+              S.documentTypeListItem("author")
+                .title("Authors")
+                .icon(authorIcon),
+              S.documentTypeListItem("blogCategory")
+                .title("Blog Categories")
+                .icon(blogCategoryIcon),
+            ])
+        ),
+
+      S.divider(),
+
+      // GROUP 3: Components -- singleton and reusable components
+      S.listItem()
+        .title("Components")
+        .icon(componentsFolderIcon)
+        .child(
+          S.list()
+            .title("Components")
+            .items([
+              S.divider().title("Singleton Components"),
+              ...singletonComponents.map((item) =>
+                S.listItem()
+                  .title(item.title)
+                  .id(item.documentId)
+                  .icon(item.icon)
+                  .child(
+                    S.document()
+                      .schemaType(item.schemaType)
+                      .documentId(item.documentId)
+                  )
+              ),
+              S.divider().title("Reusable Components"),
+              S.documentTypeListItem("hero").title("Headings").icon(heroIcon),
+              S.documentTypeListItem("description")
+                .title("Descriptions")
+                .icon(descriptionIcon),
+              S.documentTypeListItem("blogContent")
+                .title("Blog Content")
+                .icon(contentIcon),
+            ])
+        ),
+
+      S.divider(),
+
+      // GROUP 4: Layout -- global layout singletons
+      S.listItem()
+        .title("Layout")
+        .icon(layoutFolderIcon)
+        .child(
+          S.list()
+            .title("Layout")
+            .items([
+              ...singletonLayout.map((item) =>
+                S.listItem()
+                  .title(item.title)
+                  .id(item.documentId)
+                  .icon(item.icon)
+                  .child(
+                    S.document()
+                      .schemaType(item.schemaType)
+                      .documentId(item.documentId)
+                  )
+              ),
+            ])
+        ),
+    ])

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

@@ -0,0 +1,8 @@
+import { createImageUrlBuilder } from "@sanity/image-url"
+import { dataset, projectId } from "../env"
+
+const builder = createImageUrlBuilder({ projectId, dataset })
+
+export const urlForImage = (source: Parameters<typeof builder.image>[0]) => {
+  return builder.image(source)
+}

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

@@ -0,0 +1,137 @@
+type PageReference = {
+  _id?: string
+  _ref?: string
+  _type?: string
+  slug?: { current?: string | null } | null
+  resolvedSlug?: string | null
+  title?: string | null
+}
+
+type PageReferenceLink = {
+  _type: "pageReference"
+  page?: PageReference | null
+  text?: string | null
+  openInNewTab?: boolean | null
+}
+
+type ExternalLinkItem = {
+  _type: "externalLink"
+  href?: string | null
+  text?: string | null
+  openInNewTab?: boolean | null
+}
+
+type LinkItem = PageReferenceLink | ExternalLinkItem
+
+// Backward-compatible shape (old data without _type)
+type LegacyLink = {
+  page?: PageReference | null
+  href?: string | null
+  text?: string | null
+  openInNewTab?: boolean | null
+}
+
+type LinkLike = LinkItem | LegacyLink
+
+type InternalReference = {
+  _id?: string
+  _type: string
+  slug?: { current?: string | null } | null
+  resolvedSlug?: string | null
+  title?: string
+}
+
+/**
+ * Resolves a link object to a URL string.
+ *
+ * Supports both the new discriminated union shape (_type: "pageReference" | "externalLink")
+ * and the legacy flat shape (page + href without _type).
+ */
+export const urlForReference = (link: LinkLike | null): string => {
+  if (!link) return "#"
+
+  // New discriminated union
+  if ("_type" in link && link._type === "pageReference") {
+    if (
+      link.page &&
+      typeof link.page === "object" &&
+      ("slug" in link.page || "_id" in link.page)
+    ) {
+      const ref = link.page as InternalReference
+      return resolveDocumentUrl(
+        ref._type,
+        ref.resolvedSlug ?? undefined,
+        ref.slug?.current ?? undefined,
+        ref._id
+      )
+    }
+    return "#"
+  }
+
+  if ("_type" in link && link._type === "externalLink") {
+    return link.href || "#"
+  }
+
+  // Legacy fallback (flat shape without _type)
+  if (
+    "page" in link &&
+    link.page &&
+    typeof link.page === "object" &&
+    ("slug" in link.page || "_id" in link.page)
+  ) {
+    const ref = link.page as InternalReference
+    return resolveDocumentUrl(
+      ref._type,
+      ref.resolvedSlug ?? undefined,
+      ref.slug?.current ?? undefined,
+      ref._id
+    )
+  }
+
+  if ("href" in link && link.href) {
+    return link.href
+  }
+
+  return "#"
+}
+
+function resolveDocumentUrl(
+  documentType: string,
+  resolvedSlug?: string,
+  slug?: string,
+  documentId?: string
+): string {
+  if (documentType === "page") {
+    if (documentId === "page-homepage") return "/"
+    if (resolvedSlug) return `/${resolvedSlug}`
+    if (slug) return `/${slug}`
+    return "#"
+  }
+
+  if (!slug) return "#"
+
+  console.warn("Unknown document type for URL resolution:", documentType)
+  return "#"
+}
+
+/**
+ * Returns href, target, and rel attributes for a link object.
+ *
+ * External detection: externalLink type, or URLs starting with "http".
+ */
+export const getLinkAttributes = (link: LinkLike | null) => {
+  if (!link) return { href: "#", target: undefined, rel: undefined }
+
+  const href = urlForReference(link)
+  const isExternal =
+    ("_type" in link && link._type === "externalLink") ||
+    href.startsWith("http")
+
+  const shouldOpenNewTab = link.openInNewTab || isExternal
+
+  return {
+    href,
+    target: shouldOpenNewTab ? "_blank" : undefined,
+    rel: shouldOpenNewTab ? "noopener noreferrer" : undefined,
+  }
+}

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

@@ -0,0 +1,81 @@
+import { portableTextToMarkdown } from "@portabletext/markdown"
+import type { PAGE_QUERY_RESULT } from "../sanity.types"
+
+const markdownOptions = {
+  types: {
+    table: ({ value }: { value: { rows?: Array<{ cells?: string[] }> } }) => {
+      const rows = value?.rows
+      if (!rows?.length) return ""
+      return rows
+        .map((row) => `| ${(row.cells ?? []).join(" | ")} |`)
+        .join("\n")
+    },
+  },
+} satisfies Parameters<typeof portableTextToMarkdown>[1]
+
+type PageBuilderBlock = NonNullable<
+  NonNullable<PAGE_QUERY_RESULT>["pageBuilder"]
+>[number]
+
+export const renderPageBuilderMarkdown = (
+  blocks: PageBuilderBlock[] | null | undefined
+) => {
+  if (!blocks?.length) return ""
+
+  return blocks
+    .flatMap((block) => {
+      switch (block._type) {
+        case "hero":
+          return block.headline ? [`## ${block.headline}`, ""] : []
+        case "description":
+          return block.description ? [block.description, ""] : []
+        case "blogContent": {
+          const lines: (string | null)[] = []
+          const categories =
+            "categories" in block ? block.categories : undefined
+          const relatedPosts =
+            "relatedPosts" in block ? block.relatedPosts : undefined
+
+          if (categories?.length) {
+            lines.push(
+              categories
+                .map((c) => c.title)
+                .filter(Boolean)
+                .join(", ")
+            )
+          }
+          if (block.author?.name) {
+            const authorParts = [block.author.name, block.author.role]
+              .filter(Boolean)
+              .join(", ")
+            lines.push(`**Author:** ${authorParts}`)
+          }
+          if (block.date) {
+            lines.push(`**Date:** ${block.date}`)
+          }
+          lines.push("")
+          if (block.body) {
+            lines.push(
+              portableTextToMarkdown(
+                block.body as Parameters<typeof portableTextToMarkdown>[0],
+                markdownOptions
+              )
+            )
+          }
+          if (relatedPosts?.length) {
+            lines.push("", "## Related Articles", "")
+            for (const post of relatedPosts) {
+              if (post.title && post.resolvedSlug) {
+                lines.push(`- [${post.title}](/${post.resolvedSlug}.md)`)
+              }
+            }
+          }
+          lines.push("")
+          return lines.filter((l) => l !== null)
+        }
+        default:
+          return []
+      }
+    })
+    .join("\n")
+}