bsmnt 0.4.1 → 0.4.2

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

@@ -1,453 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,137 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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")
-}