@driftime/sanity-plugin-handbook 0.1.0

package/dist/index.js

@@ -0,0 +1,1870 @@
+import { LightbulbIcon, InfoIcon, TriangleAlertIcon, BookOpenTextIcon, BookTextIcon, LayoutGridIcon, MessageCircleQuestionMarkIcon, CodeIcon, MinusIcon, ImageIcon, VideoIcon, ListPlusIcon } from "lucide-react";
+import { useClient, useSchema, defineArrayMember, defineField, defineType, useCurrentUser, definePlugin } from "sanity";
+import { jsxs, jsx, Fragment } from "react/jsx-runtime";
+import { forwardRef, useState, useEffect, createContext, useContext, useRef, createElement, useCallback, useMemo } from "react";
+import { Card, Flex, Text, Box, Stack, Heading, useClickOutsideEvent, Popover, Code, Button } from "@sanity/ui";
+const ArrowLeftIcon = /* @__PURE__ */ forwardRef(function(props, ref) {
+  return /* @__PURE__ */ jsxs(
+    "svg",
+    {
+      "data-sanity-icon": "arrow-left",
+      width: "1em",
+      height: "1em",
+      viewBox: "0 0 25 25",
+      fill: "none",
+      xmlns: "http://www.w3.org/2000/svg",
+      ...props,
+      ref,
+      children: [
+        /* @__PURE__ */ jsx("path", { d: "M5.5 12.5H20", stroke: "currentColor", strokeWidth: 1.2, strokeLinejoin: "round" }),
+        /* @__PURE__ */ jsx(
+          "path",
+          {
+            d: "M11 18L5.5 12.5L11 7",
+            stroke: "currentColor",
+            strokeWidth: 1.2,
+            strokeLinejoin: "round"
+          }
+        )
+      ]
+    }
+  );
+}), ChevronDownIcon = /* @__PURE__ */ forwardRef(function(props, ref) {
+  return /* @__PURE__ */ jsx(
+    "svg",
+    {
+      "data-sanity-icon": "chevron-down",
+      width: "1em",
+      height: "1em",
+      viewBox: "0 0 25 25",
+      fill: "none",
+      xmlns: "http://www.w3.org/2000/svg",
+      ...props,
+      ref,
+      children: /* @__PURE__ */ jsx(
+        "path",
+        {
+          d: "M17 10L12.5 14.5L8 10",
+          stroke: "currentColor",
+          strokeWidth: 1.2,
+          strokeLinejoin: "round"
+        }
+      )
+    }
+  );
+}), ChevronRightIcon = /* @__PURE__ */ forwardRef(function(props, ref) {
+  return /* @__PURE__ */ jsx(
+    "svg",
+    {
+      "data-sanity-icon": "chevron-right",
+      width: "1em",
+      height: "1em",
+      viewBox: "0 0 25 25",
+      fill: "none",
+      xmlns: "http://www.w3.org/2000/svg",
+      ...props,
+      ref,
+      children: /* @__PURE__ */ jsx(
+        "path",
+        {
+          d: "M10 8L14.5 12.5L10 17",
+          stroke: "currentColor",
+          strokeWidth: 1.2,
+          strokeLinejoin: "round"
+        }
+      )
+    }
+  );
+});
+function PaneHeader({ title }) {
+  return /* @__PURE__ */ jsx("div", { style: { position: "sticky", top: 0, zIndex: 1, lineHeight: 0 }, children: /* @__PURE__ */ jsx(Card, { tone: "inherit", children: /* @__PURE__ */ jsx(Flex, { direction: "column", padding: 3, style: { boxSizing: "border-box" }, children: /* @__PURE__ */ jsx(Flex, { align: "flex-start", children: /* @__PURE__ */ jsx(Card, { flex: 1, paddingLeft: 2, padding: 2, children: /* @__PURE__ */ jsx(Flex, { align: "center", gap: 1, children: /* @__PURE__ */ jsx(Text, { size: 1, textOverflow: "ellipsis", weight: "semibold", style: { cursor: "default", outline: "none" }, children: title }) }) }) }) }) }) });
+}
+const query = `*[_type == "handbook.handbook"][0]{
+  groups[]{
+    _key,
+    title,
+    guides[]{
+      _key,
+      ...@->{
+        _id,
+        _type,
+        title,
+        description,
+        content[]{
+          ...,
+          _type == "handbook.image" => {
+            ...,
+            "asset": { "url": asset.asset->url }
+          },
+          _type == "handbook.video" => {
+            ...,
+            "asset": { "url": asset.asset->url }
+          }
+        }
+      }
+    }
+  }
+}`, listenQuery = '*[_type == "handbook.handbook" || _type == "handbook.guide"]';
+function useHandbookConfiguration() {
+  const client = useClient({ apiVersion: "2026-01-01" }), [configuration, setConfiguration] = useState(null), [loading, setLoading] = useState(!0);
+  return useEffect(() => {
+    async function fetchConfiguration() {
+      const result = await client.fetch(query);
+      setConfiguration(result), setLoading(!1);
+    }
+    fetchConfiguration();
+    const subscription = client.listen(listenQuery).subscribe(() => {
+      fetchConfiguration();
+    });
+    return () => {
+      subscription.unsubscribe();
+    };
+  }, [client]), { configuration, loading };
+}
+function isDefined(value) {
+  return value == null || value === !1 ? !1 : typeof value == "string" ? value.trim() !== "" : Array.isArray(value) ? value.some((element) => isDefined(element)) : typeof value == "object" ? Object.keys(value).length > 0 : !0;
+}
+function isPermittedEditor(editors, email) {
+  return isDefined(editors) ? isDefined(email) ? editors.includes(email) : !1 : !0;
+}
+function convertCase(value, format) {
+  const words = value.replaceAll(/([a-z0-9])([A-Z])/g, "$1 $2").replaceAll(/[-_\s]+/g, " ").trim().toLowerCase();
+  switch (format) {
+    case "kebab":
+      return words.replaceAll(/\s+/g, "-");
+    case "snake":
+      return words.replaceAll(/\s+/g, "_");
+    case "camel":
+      return words.replaceAll(/\s+(.)/g, (_match, character) => character.toUpperCase());
+    case "pascal":
+      return words.replaceAll(/(?:^|\s+)(.)/g, (_match, character) => character.toUpperCase());
+    case "title":
+      return words.replaceAll(/\b\w/g, (character) => character.toUpperCase());
+    case "sentence":
+      return words.replaceAll(/^(.)/g, (character) => character.toUpperCase());
+    default:
+      return value;
+  }
+}
+const HandbookContext = createContext(void 0);
+function HandbookProvider({
+  sidebarTitle,
+  groups,
+  blocks,
+  undocumentedFieldMessage,
+  children
+}) {
+  const [activeTab, setActiveTab] = useState(null), [sidebarExpanded, setSidebarExpanded] = useState(!0), { configuration, loading } = useHandbookConfiguration();
+  return /* @__PURE__ */ jsx(
+    HandbookContext,
+    {
+      value: {
+        sidebarTitle,
+        activeTab,
+        sidebarExpanded,
+        loading,
+        groups,
+        configuration,
+        blocks,
+        undocumentedFieldMessage,
+        setActiveTab,
+        setSidebarExpanded
+      },
+      children
+    }
+  );
+}
+function useHandbookContext() {
+  const handbookContext = useContext(HandbookContext);
+  if (!isDefined(handbookContext)) throw new Error("useHandbookContext can only be used within <HandbookProvider>");
+  return handbookContext;
+}
+function useContainerWidth() {
+  const reference = useRef(null), [width, setWidth] = useState(void 0);
+  return useEffect(() => {
+    const element = reference.current;
+    if (!isDefined(element)) return;
+    const observer = new ResizeObserver((entries2) => {
+      for (const entry of entries2)
+        setWidth(entry.contentRect.width);
+    });
+    return observer.observe(element), () => {
+      observer.disconnect();
+    };
+  }, []), { reference, width };
+}
+function ContentPanel({ id, title, description, children }) {
+  const { activeTab } = useHandbookContext();
+  return activeTab !== id ? null : /* @__PURE__ */ jsxs(
+    "div",
+    {
+      id: `panel-${id}`,
+      "aria-labelledby": id,
+      role: "tabpanel",
+      style: { display: "flex", flexDirection: "column", height: "100%" },
+      children: [
+        /* @__PURE__ */ jsx(PaneHeader, { title }),
+        /* @__PURE__ */ jsx("div", { style: { flex: 1, overflowY: "auto" }, children: /* @__PURE__ */ jsxs(
+          Box,
+          {
+            style: {
+              maxWidth: "640px",
+              boxSizing: "border-box",
+              marginInline: "auto",
+              paddingInline: "20px",
+              paddingBlockStart: "32px",
+              paddingBlockEnd: "220px"
+            },
+            children: [
+              /* @__PURE__ */ jsxs(Stack, { marginBottom: 6, space: 5, children: [
+                /* @__PURE__ */ jsx(Heading, { as: "h2", size: 4, children: title }),
+                isDefined(description) && /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: description })
+              ] }),
+              children
+            ]
+          }
+        ) })
+      ]
+    }
+  );
+}
+const defaultIconProps = { width: "1em", height: "1em", strokeWidth: 1.5 };
+function createSanityIcon(icon, props) {
+  return () => createElement(icon, { ...defaultIconProps, ...props });
+}
+const opaqueTypes = /* @__PURE__ */ new Set([
+  "block",
+  "boolean",
+  "crossDatasetReference",
+  "date",
+  "datetime",
+  "file",
+  "geopoint",
+  "image",
+  "number",
+  "reference",
+  "slug",
+  "string",
+  "text",
+  "url"
+]), inheritedFieldNames = {
+  block: /* @__PURE__ */ new Set(["children", "level", "listItem", "markDefs", "style"]),
+  file: /* @__PURE__ */ new Set(["asset", "media"]),
+  geopoint: /* @__PURE__ */ new Set(["alt", "lat", "lng"]),
+  image: /* @__PURE__ */ new Set(["asset", "crop", "hotspot", "media"]),
+  slug: /* @__PURE__ */ new Set(["current", "source"])
+};
+function isCompiledField(value) {
+  return typeof value != "object" || value === null || !("name" in value) || !("type" in value) ? !1 : typeof value.type == "object" && value.type !== null;
+}
+function hasFieldsArray(value) {
+  return typeof value != "object" || value === null || !("fields" in value) ? !1 : Array.isArray(value.fields);
+}
+function hasOfArray(value) {
+  return typeof value != "object" || value === null || !("of" in value) ? !1 : Array.isArray(value.of);
+}
+function getTypeName(value) {
+  if (!(typeof value != "object" || value === null || !("type" in value)))
+    return typeof value.type == "string" ? value.type : void 0;
+}
+function isOpaqueType(typeName) {
+  return opaqueTypes.has(typeName);
+}
+function getParentTypeName(resolvedType) {
+  if (!(typeof resolvedType != "object" || resolvedType === null || !("type" in resolvedType)) && !(typeof resolvedType.type != "object" || resolvedType.type === null || !("name" in resolvedType.type)))
+    return String(resolvedType.type.name);
+}
+function normaliseField(field, visited = /* @__PURE__ */ new Set()) {
+  if (isCompiledField(field)) {
+    const typeName = field.type.name, result = {
+      name: field.name,
+      type: typeName,
+      title: field.title ?? field.type.title,
+      description: field.description ?? field.type.description,
+      handbook: field.handbook
+    };
+    if (!visited.has(typeName)) {
+      const next = !opaqueTypes.has(typeName) && typeName !== "object" && typeName !== "array" ? /* @__PURE__ */ new Set([...visited, typeName]) : visited, fieldSource = hasFieldsArray(field) ? field : field.type, ofSource = hasOfArray(field) ? field : field.type;
+      hasFieldsArray(fieldSource) && (result.fields = fieldSource.fields.map((subfield) => normaliseField(subfield, next))), hasOfArray(ofSource) && (result.of = ofSource.of.map((member) => normaliseField(member, next)));
+    }
+    return result;
+  }
+  return field;
+}
+function resolveCustomFields(resolvedType, parentName) {
+  if (!hasFieldsArray(resolvedType)) return;
+  const inherited = inheritedFieldNames[parentName], customFields = resolvedType.fields.map((field) => normaliseField(field)).filter((field) => inherited === void 0 || !inherited.has(field.name));
+  return isDefined(customFields) ? customFields : void 0;
+}
+function resolveNormalisedFields(items) {
+  const normalised = items.map((item) => normaliseField(item));
+  return isDefined(normalised) ? normalised : void 0;
+}
+function resolveNormalisedMembers(members) {
+  const normalised = members.map((member) => normaliseField(member)).filter((member) => !isOpaqueType(member.type));
+  return isDefined(normalised) ? normalised : void 0;
+}
+function resolveParentName(value, schema) {
+  const direct = getParentTypeName(value);
+  if (isDefined(direct)) return direct;
+  const typeName = getTypeName(value);
+  if (!isDefined(typeName)) return;
+  const resolvedType = schema.get(typeName);
+  return isDefined(resolvedType) ? getParentTypeName(resolvedType) : void 0;
+}
+function resolveFields(value, schema) {
+  if (hasFieldsArray(value)) {
+    const parentName = resolveParentName(value, schema);
+    return isDefined(parentName) && isOpaqueType(parentName) ? resolveCustomFields(value, parentName) : resolveNormalisedFields(value.fields);
+  }
+  if (hasOfArray(value)) {
+    const members = value.of;
+    if (members.length === 1) {
+      const [member] = members, normalised = normaliseField(member);
+      if (isOpaqueType(normalised.type)) return;
+      if (hasFieldsArray(normalised)) {
+        const parentName = resolveParentName(normalised, schema);
+        return isDefined(parentName) && isOpaqueType(parentName) ? resolveCustomFields(normalised, parentName) : resolveNormalisedFields(normalised.fields);
+      }
+      const memberType = schema.get(normalised.type);
+      if (isDefined(memberType)) return resolveFields(memberType, schema);
+    }
+    return resolveNormalisedMembers(members);
+  }
+}
+function getSubfields(field, schema) {
+  if (isOpaqueType(field.type)) return;
+  const directFields = resolveFields(field, schema);
+  if (directFields !== void 0) return directFields;
+  const resolvedType = schema.get(field.type);
+  if (!isDefined(resolvedType)) return;
+  const parentName = getParentTypeName(resolvedType);
+  return isDefined(parentName) && isOpaqueType(parentName) ? resolveCustomFields(resolvedType, parentName) : resolveFields(resolvedType, schema);
+}
+function FieldHint({ label, icon, color, open, children, onToggle, onClose }) {
+  const buttonReference = useRef(null), popoverReference = useRef(null);
+  return useClickOutsideEvent(open ? onClose : void 0, () => [buttonReference.current, popoverReference.current]), /* @__PURE__ */ jsx(
+    Popover,
+    {
+      open,
+      placement: "top",
+      portal: !0,
+      radius: 2,
+      shadow: 2,
+      content: /* @__PURE__ */ jsx("div", { ref: popoverReference, children: /* @__PURE__ */ jsx(Box, { padding: 3, style: { maxWidth: "280px" }, children: /* @__PURE__ */ jsxs(Stack, { space: 3, children: [
+        /* @__PURE__ */ jsx(Text, { size: 1, weight: "semibold", children: label }),
+        /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children })
+      ] }) }) }),
+      children: /* @__PURE__ */ jsx(
+        "button",
+        {
+          ref: buttonReference,
+          "aria-label": label,
+          type: "button",
+          onClick: onToggle,
+          onMouseEnter: onToggle,
+          onMouseLeave: onClose,
+          style: {
+            display: "flex",
+            alignItems: "center",
+            padding: "2px",
+            fontSize: "16px",
+            color,
+            background: "none",
+            border: "none",
+            cursor: "pointer"
+          },
+          children: icon
+        }
+      )
+    }
+  );
+}
+function FieldHints({ tip, info, caution }) {
+  const [openHint, setOpenHint] = useState(null), closeHint = useCallback(() => {
+    setOpenHint(null);
+  }, []);
+  return /* @__PURE__ */ jsxs(Flex, { align: "center", gap: 2, children: [
+    isDefined(tip) && /* @__PURE__ */ jsx(
+      FieldHint,
+      {
+        label: "Tip",
+        icon: /* @__PURE__ */ jsx(LightbulbIcon, { ...defaultIconProps }),
+        color: "var(--card-icon-color)",
+        open: openHint === "tip",
+        onToggle: () => {
+          setOpenHint(openHint === "tip" ? null : "tip");
+        },
+        onClose: closeHint,
+        children: tip
+      }
+    ),
+    isDefined(info) && /* @__PURE__ */ jsx(
+      FieldHint,
+      {
+        label: "Information",
+        icon: /* @__PURE__ */ jsx(InfoIcon, { ...defaultIconProps }),
+        color: "var(--card-icon-color)",
+        open: openHint === "info",
+        onToggle: () => {
+          setOpenHint(openHint === "info" ? null : "info");
+        },
+        onClose: closeHint,
+        children: info
+      }
+    ),
+    isDefined(caution) && /* @__PURE__ */ jsx(
+      FieldHint,
+      {
+        label: "Caution",
+        icon: /* @__PURE__ */ jsx(TriangleAlertIcon, { ...defaultIconProps }),
+        color: "var(--card-icon-color)",
+        open: openHint === "caution",
+        onToggle: () => {
+          setOpenHint(openHint === "caution" ? null : "caution");
+        },
+        onClose: closeHint,
+        children: caution
+      }
+    )
+  ] });
+}
+function Field({ field, depth = 0, ancestors = /* @__PURE__ */ new Set() }) {
+  const schema = useSchema(), { undocumentedFieldMessage } = useHandbookContext(), [expanded, setExpanded] = useState(!1), effectiveTitle = field.handbook?.title ?? field.title ?? (field.name && convertCase(field.name, "title")), effectiveDescription = field.handbook?.description ?? field.description ?? undocumentedFieldMessage, { example, tip, info, caution } = field.handbook ?? {}, hasHints = isDefined([tip, info, caution]), isCycle = ancestors.has(field.type), subfields = isCycle ? void 0 : getSubfields(field, schema), hasSubfields = isDefined(subfields);
+  return /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
+    /* @__PURE__ */ jsxs(Stack, { space: 3, children: [
+      /* @__PURE__ */ jsxs(Flex, { align: "center", paddingY: 1, gap: 2, children: [
+        /* @__PURE__ */ jsx(Box, { flex: 1, children: /* @__PURE__ */ jsxs(Flex, { align: "center", gap: 2, children: [
+          /* @__PURE__ */ jsx(Text, { size: 1, weight: "medium", children: effectiveTitle }),
+          /* @__PURE__ */ jsx(Text, { size: 0, muted: !0, style: { marginTop: "2px" }, children: field.type })
+        ] }) }),
+        hasHints && /* @__PURE__ */ jsx(FieldHints, { tip, info, caution })
+      ] }),
+      isDefined(effectiveDescription) && /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: effectiveDescription }),
+      isDefined(example) && /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsxs(Text, { size: 1, muted: !0, style: { fontStyle: "italic" }, children: [
+        "e.g. ",
+        example
+      ] }) })
+    ] }),
+    isCycle && /* @__PURE__ */ jsx(Box, { marginTop: 2, children: /* @__PURE__ */ jsxs(Text, { size: 1, muted: !0, style: { fontStyle: "italic" }, children: [
+      "See ",
+      convertCase(field.type, "title"),
+      " above."
+    ] }) }),
+    hasSubfields && /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(
+        Card,
+        {
+          as: "button",
+          padding: 3,
+          radius: 2,
+          tone: "transparent",
+          onClick: () => {
+            setExpanded(!expanded);
+          },
+          style: { width: "100%", marginTop: "1rem", textAlign: "left", border: "none", cursor: "pointer" },
+          children: /* @__PURE__ */ jsxs(Flex, { align: "center", gap: 2, children: [
+            /* @__PURE__ */ jsx(Text, { size: 0, children: expanded ? /* @__PURE__ */ jsx(ChevronDownIcon, {}) : /* @__PURE__ */ jsx(ChevronRightIcon, {}) }),
+            /* @__PURE__ */ jsxs(Text, { size: 1, muted: !0, weight: "medium", children: [
+              subfields.length,
+              " subfield",
+              subfields.length === 1 ? "" : "s"
+            ] })
+          ] })
+        }
+      ),
+      expanded && /* @__PURE__ */ jsx(
+        "div",
+        {
+          style: {
+            marginTop: "16px",
+            marginBottom: "8px",
+            paddingLeft: "16px",
+            borderLeft: "1px solid var(--card-border-color)"
+          },
+          children: /* @__PURE__ */ jsx(Stack, { space: 5, children: subfields.map((subfield) => /* @__PURE__ */ jsx(
+            Field,
+            {
+              field: subfield,
+              depth: depth + 1,
+              ancestors: /* @__PURE__ */ new Set([...ancestors, field.type])
+            },
+            subfield.name
+          )) })
+        }
+      )
+    ] })
+  ] });
+}
+function SidebarGroup({ heading, children }) {
+  return /* @__PURE__ */ jsxs("div", { children: [
+    /* @__PURE__ */ jsx(Box, { paddingY: 2, children: /* @__PURE__ */ jsx(Card, { paddingLeft: 2, padding: 2, children: /* @__PURE__ */ jsx(Flex, { align: "center", gap: 1, children: /* @__PURE__ */ jsx(
+      Text,
+      {
+        size: 1,
+        muted: !0,
+        textOverflow: "ellipsis",
+        weight: "semibold",
+        style: { cursor: "default", outline: "none" },
+        children: heading
+      }
+    ) }) }) }),
+    children
+  ] });
+}
+function SidebarTab({ id, label, icon: Icon }) {
+  const { activeTab, setActiveTab, setSidebarExpanded } = useHandbookContext(), selected = activeTab === id;
+  return /* @__PURE__ */ jsx(
+    Card,
+    {
+      id,
+      "aria-controls": `panel-${id}`,
+      "aria-selected": selected,
+      role: "option",
+      as: "button",
+      selected,
+      marginBottom: 1,
+      radius: 2,
+      sizing: "border",
+      tabIndex: -1,
+      tone: "inherit",
+      onClick: () => {
+        setActiveTab(id), setSidebarExpanded(!1);
+      },
+      style: { width: "100%", textAlign: "left", border: "none", cursor: "pointer" },
+      children: /* @__PURE__ */ jsx(
+        Flex,
+        {
+          align: "center",
+          paddingLeft: isDefined(Icon) ? 1 : 2,
+          paddingRight: 2,
+          paddingY: 1,
+          style: { height: "1.5625rem", boxSizing: "content-box" },
+          children: /* @__PURE__ */ jsxs(Flex, { align: "center", flex: 1, gap: 2, children: [
+            isDefined(Icon) && /* @__PURE__ */ jsx(
+              "div",
+              {
+                style: {
+                  display: "flex",
+                  alignItems: "center",
+                  justifyContent: "center",
+                  width: "25px",
+                  height: "25px",
+                  color: "var(--card-icon-color)"
+                },
+                children: /* @__PURE__ */ jsx(Icon, {})
+              }
+            ),
+            /* @__PURE__ */ jsx(Stack, { flex: 1, space: 2, children: /* @__PURE__ */ jsx(Text, { size: 1, textOverflow: "ellipsis", weight: "medium", style: { color: "inherit" }, children: label }) }),
+            /* @__PURE__ */ jsx(Box, { paddingLeft: 4, paddingRight: 1, children: /* @__PURE__ */ jsx(Box, { style: { opacity: 0.5 }, children: /* @__PURE__ */ jsx(Text, { muted: !0, size: 1, children: /* @__PURE__ */ jsx(ChevronRightIcon, {}) }) }) })
+          ] })
+        }
+      )
+    }
+  );
+}
+function DocumentTypesTabs() {
+  const { groups } = useHandbookContext();
+  return groups.map((group) => {
+    const { title, documents } = group;
+    return /* @__PURE__ */ jsx(SidebarGroup, { heading: title, children: documents.map((document) => {
+      const effectiveTitle = document.handbook?.title ?? document.title ?? convertCase(document.name, "title"), icon = typeof document.icon == "function" ? document.icon : void 0;
+      return /* @__PURE__ */ jsx(SidebarTab, { id: document.name, label: effectiveTitle, icon }, document.name);
+    }) }, title);
+  });
+}
+function DocumentTypesPanels() {
+  const { groups } = useHandbookContext();
+  return groups.map((group) => {
+    const { documents } = group;
+    return documents.map((document) => {
+      const effectiveTitle = document.handbook?.title ?? document.title ?? convertCase(document.name, "title"), effectiveDescription = document.handbook?.description ?? (typeof document.description == "string" ? document.description : void 0);
+      return /* @__PURE__ */ jsx(ContentPanel, { id: document.name, title: effectiveTitle, description: effectiveDescription, children: /* @__PURE__ */ jsx("div", { style: { display: "flex", flexDirection: "column", gap: "3.25rem" }, children: document.fields.map((field) => /* @__PURE__ */ jsx(Field, { field }, field.name)) }) }, document.name);
+    });
+  });
+}
+function isPortableTextSpan(node) {
+  return node._type === "span" && "text" in node && typeof node.text == "string" && (node.marks === void 0 || Array.isArray(node.marks) && node.marks.every((mark) => typeof mark == "string"));
+}
+function isPortableTextBlock(node) {
+  return typeof node._type == "string" && node._type[0] !== "@" && (!("markDefs" in node) || !node.markDefs || Array.isArray(node.markDefs) && node.markDefs.every((def) => typeof def._key == "string")) && "children" in node && Array.isArray(node.children) && node.children.every((child) => typeof child == "object" && "_type" in child);
+}
+function isPortableTextListItemBlock(block) {
+  return isPortableTextBlock(block) && "listItem" in block && typeof block.listItem == "string" && (block.level === void 0 || typeof block.level == "number");
+}
+function isPortableTextToolkitList(block) {
+  return block._type === "@list";
+}
+function isPortableTextToolkitSpan(span) {
+  return span._type === "@span";
+}
+function isPortableTextToolkitTextNode(node) {
+  return node._type === "@text";
+}
+const knownDecorators = [
+  "strong",
+  "em",
+  "code",
+  "underline",
+  "strike-through"
+];
+function sortMarksByOccurences(span, index, blockChildren) {
+  if (!isPortableTextSpan(span) || !span.marks || !span.marks.length) return [];
+  let marks = span.marks.slice(), occurences = {};
+  return marks.forEach((mark) => {
+    occurences[mark] = 1;
+    for (let siblingIndex = index + 1; siblingIndex < blockChildren.length; siblingIndex++) {
+      let sibling = blockChildren[siblingIndex];
+      if (sibling && isPortableTextSpan(sibling) && Array.isArray(sibling.marks) && sibling.marks.indexOf(mark) !== -1) occurences[mark]++;
+      else break;
+    }
+  }), marks.sort((markA, markB) => sortMarks(occurences, markA, markB));
+}
+function sortMarks(occurences, markA, markB) {
+  let aOccurences = occurences[markA], bOccurences = occurences[markB];
+  if (aOccurences !== bOccurences) return bOccurences - aOccurences;
+  let aKnownPos = knownDecorators.indexOf(markA), bKnownPos = knownDecorators.indexOf(markB);
+  return aKnownPos === bKnownPos ? markA.localeCompare(markB) : aKnownPos - bKnownPos;
+}
+function buildMarksTree(block) {
+  let { children } = block, markDefs = block.markDefs ?? [];
+  if (!children || !children.length) return [];
+  let sortedMarks = children.map(sortMarksByOccurences), rootNode = {
+    _type: "@span",
+    children: [],
+    markType: "<unknown>"
+  }, nodeStack = [rootNode];
+  for (let i = 0; i < children.length; i++) {
+    let span = children[i];
+    if (!span) continue;
+    let marksNeeded = sortedMarks[i] || [], pos = 1;
+    if (nodeStack.length > 1) for (; pos < nodeStack.length; pos++) {
+      let mark = nodeStack[pos]?.markKey || "", index = marksNeeded.indexOf(mark);
+      if (index === -1) break;
+      marksNeeded.splice(index, 1);
+    }
+    nodeStack = nodeStack.slice(0, pos);
+    let currentNode = nodeStack[nodeStack.length - 1];
+    if (currentNode) {
+      for (let markKey of marksNeeded) {
+        let markDef = markDefs?.find((def) => def._key === markKey), node = {
+          _type: "@span",
+          _key: span._key,
+          children: [],
+          markDef,
+          markType: markDef ? markDef._type : markKey,
+          markKey
+        };
+        currentNode.children.push(node), nodeStack.push(node), currentNode = node;
+      }
+      if (isPortableTextSpan(span)) {
+        let lines = span.text.split(`
+`);
+        for (let line = lines.length; line-- > 1; ) lines.splice(line, 0, `
+`);
+        currentNode.children = currentNode.children.concat(lines.map((text) => ({
+          _type: "@text",
+          text
+        })));
+      } else currentNode.children = currentNode.children.concat(span);
+    }
+  }
+  return rootNode.children;
+}
+function nestLists(blocks, mode) {
+  let tree = [], currentList;
+  for (let i = 0; i < blocks.length; i++) {
+    let block = blocks[i];
+    if (block) {
+      if (!isPortableTextListItemBlock(block)) {
+        tree.push(block), currentList = void 0;
+        continue;
+      }
+      if (!currentList) {
+        currentList = listFromBlock(block, i, mode), tree.push(currentList);
+        continue;
+      }
+      if (blockMatchesList(block, currentList)) {
+        currentList.children.push(block);
+        continue;
+      }
+      if ((block.level || 1) > currentList.level) {
+        let newList = listFromBlock(block, i, mode);
+        if (mode === "html") {
+          let lastListItem = currentList.children[currentList.children.length - 1], newLastChild = {
+            ...lastListItem,
+            children: [...lastListItem.children, newList]
+          };
+          currentList.children[currentList.children.length - 1] = newLastChild;
+        } else currentList.children.push(newList);
+        currentList = newList;
+        continue;
+      }
+      if ((block.level || 1) < currentList.level) {
+        let matchingBranch = tree[tree.length - 1], match = matchingBranch && findListMatching(matchingBranch, block);
+        if (match) {
+          currentList = match, currentList.children.push(block);
+          continue;
+        }
+        currentList = listFromBlock(block, i, mode), tree.push(currentList);
+        continue;
+      }
+      if (block.listItem !== currentList.listItem) {
+        let matchingBranch = tree[tree.length - 1], match = matchingBranch && findListMatching(matchingBranch, { level: block.level || 1 });
+        if (match && match.listItem === block.listItem) {
+          currentList = match, currentList.children.push(block);
+          continue;
+        } else {
+          currentList = listFromBlock(block, i, mode), tree.push(currentList);
+          continue;
+        }
+      }
+      console.warn("Unknown state encountered for block", block), tree.push(block);
+    }
+  }
+  return tree;
+}
+function blockMatchesList(block, list) {
+  return (block.level || 1) === list.level && block.listItem === list.listItem;
+}
+function listFromBlock(block, index, mode) {
+  return {
+    _type: "@list",
+    _key: `${block._key || `${index}`}-parent`,
+    mode,
+    level: block.level || 1,
+    listItem: block.listItem,
+    children: [block]
+  };
+}
+function findListMatching(rootNode, matching) {
+  let level = matching.level || 1, style = matching.listItem || "normal", filterOnType = typeof matching.listItem == "string";
+  if (isPortableTextToolkitList(rootNode) && (rootNode.level || 1) === level && filterOnType && (rootNode.listItem || "normal") === style) return rootNode;
+  if (!("children" in rootNode)) return;
+  let node = rootNode.children[rootNode.children.length - 1];
+  return node && !isPortableTextSpan(node) ? findListMatching(node, matching) : void 0;
+}
+function spanToPlainText(span) {
+  let text = "";
+  return span.children.forEach((current) => {
+    isPortableTextToolkitTextNode(current) ? text += current.text : isPortableTextToolkitSpan(current) && (text += spanToPlainText(current));
+  }), text;
+}
+const LIST_NEST_MODE_HTML = "html", defaultLists = {
+  number: ({ children }) => /* @__PURE__ */ jsx("ol", { children }),
+  bullet: ({ children }) => /* @__PURE__ */ jsx("ul", { children })
+}, DefaultListItem = ({ children }) => /* @__PURE__ */ jsx("li", { children }), link = ({ children, value }) => /* @__PURE__ */ jsx("a", {
+  href: value?.href,
+  children
+}), underlineStyle = { textDecoration: "underline" }, defaultMarks = {
+  em: ({ children }) => /* @__PURE__ */ jsx("em", { children }),
+  strong: ({ children }) => /* @__PURE__ */ jsx("strong", { children }),
+  code: ({ children }) => /* @__PURE__ */ jsx("code", { children }),
+  underline: ({ children }) => /* @__PURE__ */ jsx("span", {
+    style: underlineStyle,
+    children
+  }),
+  "strike-through": ({ children }) => /* @__PURE__ */ jsx("del", { children }),
+  link
+}, getTemplate = (type, prop) => `[@portabletext/react] Unknown ${type}, specify a component for it in the \`components.${prop}\` prop`, unknownTypeWarning = (typeName) => getTemplate(`block type "${typeName}"`, "types"), unknownMarkWarning = (markType) => getTemplate(`mark type "${markType}"`, "marks"), unknownBlockStyleWarning = (blockStyle) => getTemplate(`block style "${blockStyle}"`, "block"), unknownListStyleWarning = (listStyle) => getTemplate(`list style "${listStyle}"`, "list"), unknownListItemStyleWarning = (listStyle) => getTemplate(`list item style "${listStyle}"`, "listItem");
+function printWarning(message) {
+  console.warn(message);
+}
+const hidden = { display: "none" }, defaultComponents = {
+  types: {},
+  block: {
+    normal: ({ children }) => /* @__PURE__ */ jsx("p", { children }),
+    blockquote: ({ children }) => /* @__PURE__ */ jsx("blockquote", { children }),
+    h1: ({ children }) => /* @__PURE__ */ jsx("h1", { children }),
+    h2: ({ children }) => /* @__PURE__ */ jsx("h2", { children }),
+    h3: ({ children }) => /* @__PURE__ */ jsx("h3", { children }),
+    h4: ({ children }) => /* @__PURE__ */ jsx("h4", { children }),
+    h5: ({ children }) => /* @__PURE__ */ jsx("h5", { children }),
+    h6: ({ children }) => /* @__PURE__ */ jsx("h6", { children })
+  },
+  marks: defaultMarks,
+  list: defaultLists,
+  listItem: DefaultListItem,
+  hardBreak: () => /* @__PURE__ */ jsx("br", {}),
+  unknownType: ({ value, isInline }) => {
+    let warning = unknownTypeWarning(value._type);
+    return jsx(isInline ? "span" : "div", {
+      style: hidden,
+      children: warning
+    });
+  },
+  unknownMark: ({ markType, children }) => /* @__PURE__ */ jsx("span", {
+    className: `unknown__pt__mark__${markType}`,
+    children
+  }),
+  unknownList: ({ children }) => /* @__PURE__ */ jsx("ul", { children }),
+  unknownListItem: ({ children }) => /* @__PURE__ */ jsx("li", { children }),
+  unknownBlockStyle: ({ children }) => /* @__PURE__ */ jsx("p", { children })
+};
+function mergeComponents(parent, overrides) {
+  let { block: _block, list: _list, listItem: _listItem, marks: _marks, types: _types, ...rest } = overrides;
+  return {
+    ...parent,
+    block: mergeDeeply(parent, overrides, "block"),
+    list: mergeDeeply(parent, overrides, "list"),
+    listItem: mergeDeeply(parent, overrides, "listItem"),
+    marks: mergeDeeply(parent, overrides, "marks"),
+    types: mergeDeeply(parent, overrides, "types"),
+    ...rest
+  };
+}
+function mergeDeeply(parent, overrides, key) {
+  let override = overrides[key], parentVal = parent[key];
+  return typeof override == "function" || override && typeof parentVal == "function" ? override : override ? {
+    ...parentVal,
+    ...override
+  } : parentVal;
+}
+function PortableText({ value: input, components: componentOverrides, listNestingMode, onMissingComponent: missingComponentHandler = printWarning }) {
+  let handleMissingComponent = missingComponentHandler || noop, nested = nestLists(Array.isArray(input) ? input : [input], listNestingMode || LIST_NEST_MODE_HTML), components = useMemo(() => componentOverrides ? mergeComponents(defaultComponents, componentOverrides) : defaultComponents, [componentOverrides]), renderNode = useMemo(() => getNodeRenderer(components, handleMissingComponent), [components, handleMissingComponent]);
+  return /* @__PURE__ */ jsx(Fragment, { children: nested.map((node, index) => renderNode({
+    node,
+    index,
+    isInline: !1,
+    renderNode
+  })) });
+}
+const getNodeRenderer = (components, handleMissingComponent) => {
+  function renderNode(options) {
+    let { node, index, isInline } = options, key = node._key || `node-${index}`;
+    return isPortableTextToolkitList(node) ? renderList(node, index, key) : isPortableTextListItemBlock(node) ? renderListItem(node, index, key) : isPortableTextToolkitSpan(node) ? renderSpan(node, index, key) : hasCustomComponentForNode(node) ? renderCustomBlock(node, index, key, isInline) : isPortableTextBlock(node) ? renderBlock(node, index, key, isInline) : isPortableTextToolkitTextNode(node) ? renderText(node, key) : renderUnknownType(node, index, key, isInline);
+  }
+  function hasCustomComponentForNode(node) {
+    return node._type in components.types;
+  }
+  function renderListItem(node, index, key) {
+    let tree = serializeBlock({
+      node,
+      index,
+      isInline: !1,
+      renderNode
+    }), renderer = components.listItem, Li = (typeof renderer == "function" ? renderer : renderer[node.listItem]) || components.unknownListItem;
+    if (Li === components.unknownListItem) {
+      let style = node.listItem || "bullet";
+      handleMissingComponent(unknownListItemStyleWarning(style), {
+        type: style,
+        nodeType: "listItemStyle"
+      });
+    }
+    let children = tree.children;
+    if (node.style && node.style !== "normal") {
+      let { listItem: _listItem, ...blockNode } = node;
+      children = renderNode({
+        node: blockNode,
+        index,
+        isInline: !1
+      });
+    }
+    return /* @__PURE__ */ jsx(Li, {
+      value: node,
+      index,
+      isInline: !1,
+      renderNode,
+      children
+    }, key);
+  }
+  function renderList(node, index, key) {
+    let children = node.children.map((child, childIndex) => renderNode({
+      node: child._key ? child : {
+        ...child,
+        _key: `li-${index}-${childIndex}`
+      },
+      index: childIndex,
+      isInline: !1
+    })), component = components.list, List = (typeof component == "function" ? component : component[node.listItem]) || components.unknownList;
+    if (List === components.unknownList) {
+      let style = node.listItem || "bullet";
+      handleMissingComponent(unknownListStyleWarning(style), {
+        nodeType: "listStyle",
+        type: style
+      });
+    }
+    return /* @__PURE__ */ jsx(List, {
+      value: node,
+      index,
+      isInline: !1,
+      renderNode,
+      children
+    }, key);
+  }
+  function renderSpan(node, _index, key) {
+    let { markDef, markType, markKey } = node, Span = components.marks[markType] || components.unknownMark, children = node.children.map((child, childIndex) => renderNode({
+      node: child,
+      index: childIndex,
+      isInline: !0
+    }));
+    return Span === components.unknownMark && handleMissingComponent(unknownMarkWarning(markType), {
+      nodeType: "mark",
+      type: markType
+    }), /* @__PURE__ */ jsx(Span, {
+      text: spanToPlainText(node),
+      value: markDef,
+      markType,
+      markKey,
+      renderNode,
+      children
+    }, key);
+  }
+  function renderBlock(node, index, key, isInline) {
+    let { _key, ...props } = serializeBlock({
+      node,
+      index,
+      isInline,
+      renderNode
+    }), style = props.node.style || "normal", Block = (typeof components.block == "function" ? components.block : components.block[style]) || components.unknownBlockStyle;
+    return Block === components.unknownBlockStyle && handleMissingComponent(unknownBlockStyleWarning(style), {
+      nodeType: "blockStyle",
+      type: style
+    }), /* @__PURE__ */ jsx(Block, {
+      ...props,
+      value: props.node,
+      renderNode
+    }, key);
+  }
+  function renderText(node, key) {
+    if (node.text === `
+`) {
+      let HardBreak = components.hardBreak;
+      return HardBreak ? /* @__PURE__ */ jsx(HardBreak, {}, key) : `
+`;
+    }
+    return node.text;
+  }
+  function renderUnknownType(node, index, key, isInline) {
+    let nodeOptions = {
+      value: node,
+      isInline,
+      index,
+      renderNode
+    };
+    handleMissingComponent(unknownTypeWarning(node._type), {
+      nodeType: "block",
+      type: node._type
+    });
+    let UnknownType = components.unknownType;
+    return /* @__PURE__ */ jsx(UnknownType, { ...nodeOptions }, key);
+  }
+  function renderCustomBlock(node, index, key, isInline) {
+    let nodeOptions = {
+      value: node,
+      isInline,
+      index,
+      renderNode
+    }, Node = components.types[node._type];
+    return Node ? /* @__PURE__ */ jsx(Node, { ...nodeOptions }, key) : null;
+  }
+  return renderNode;
+};
+function serializeBlock(options) {
+  let { node, index, isInline, renderNode } = options, children = buildMarksTree(node).map((child, i) => renderNode({
+    node: child,
+    isInline: !0,
+    index: i,
+    renderNode
+  }));
+  return {
+    _key: node._key || `block-${index}`,
+    children,
+    index,
+    isInline,
+    node
+  };
+}
+function noop() {
+}
+const variantConfig = {
+  tip: { icon: LightbulbIcon, tone: "positive" },
+  info: { icon: InfoIcon, tone: "primary" },
+  warning: { icon: TriangleAlertIcon, tone: "caution" }
+};
+function CalloutContent({ variant, children }) {
+  const config = variantConfig[variant], Icon = config.icon;
+  return /* @__PURE__ */ jsx(Card, { padding: 4, radius: 2, tone: config.tone, children: /* @__PURE__ */ jsxs(Flex, { align: "flex-start", gap: 3, children: [
+    /* @__PURE__ */ jsx("div", { style: { flexShrink: 0, marginTop: "-2px", fontSize: "16px", color: "var(--card-icon-color)" }, children: /* @__PURE__ */ jsx(Icon, { ...defaultIconProps }) }),
+    /* @__PURE__ */ jsx(Text, { size: 1, style: { color: "var(--card-icon-color)" }, children })
+  ] }) });
+}
+function CalloutBlock({ value }) {
+  return /* @__PURE__ */ jsx("div", { style: { marginBlock: "2rem" }, children: /* @__PURE__ */ jsx(CalloutContent, { variant: value.variant, children: /* @__PURE__ */ jsx(
+    PortableText,
+    {
+      value: value.body,
+      components: {
+        block: { normal: ({ children }) => /* @__PURE__ */ jsx(Fragment, { children }) },
+        marks: {
+          strong: ({ children }) => /* @__PURE__ */ jsx("strong", { children }),
+          em: ({ children }) => /* @__PURE__ */ jsx("em", { children }),
+          code: ({ children }) => /* @__PURE__ */ jsx(
+            "code",
+            {
+              style: {
+                padding: "0.125rem 0.25rem",
+                fontSize: "0.875em",
+                backgroundColor: "var(--card-code-bg-color)",
+                borderRadius: "0.125rem"
+              },
+              children
+            }
+          ),
+          link: ({ children, value: mark }) => /* @__PURE__ */ jsx(
+            "a",
+            {
+              href: mark?.href,
+              target: "_blank",
+              rel: "noopener noreferrer",
+              style: { color: "var(--card-fg-color)" },
+              children
+            }
+          )
+        }
+      }
+    }
+  ) }) });
+}
+function CodeContent({ code, language }) {
+  return /* @__PURE__ */ jsx(Card, { padding: 4, radius: 2, tone: "transparent", style: { overflowX: "auto" }, children: /* @__PURE__ */ jsx(Code, { size: 1, language, children: code }) });
+}
+function CodeBlock({ value }) {
+  return /* @__PURE__ */ jsx("div", { style: { marginBlock: "1.5rem" }, children: /* @__PURE__ */ jsx(CodeContent, { code: value.code, language: value.language }) });
+}
+function HorizontalRuleContent({ marginBlock = "0" }) {
+  return /* @__PURE__ */ jsx("hr", { style: { marginBlock, border: "none", borderTop: "1px solid var(--card-border-color)" } });
+}
+function HorizontalRuleBlock() {
+  return /* @__PURE__ */ jsx(HorizontalRuleContent, { marginBlock: "2.5rem" });
+}
+function ImageContent({ url, alt, caption }) {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      "img",
+      {
+        src: url,
+        alt: alt ?? "",
+        style: { display: "block", maxWidth: "100%", borderRadius: "0.25rem", overflow: "hidden" }
+      }
+    ),
+    isDefined(caption) && /* @__PURE__ */ jsx("div", { style: { marginBlockStart: "0.75rem" }, children: /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, style: { fontStyle: "italic" }, children: caption }) })
+  ] });
+}
+function ImageBlock({ value }) {
+  return isDefined(value.asset?.url) ? /* @__PURE__ */ jsx("div", { style: { marginBlock: "1.5rem" }, children: /* @__PURE__ */ jsx(ImageContent, { url: value.asset.url, alt: value.alt, caption: value.caption }) }) : null;
+}
+function VideoContent({ url, caption }) {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      "video",
+      {
+        src: url,
+        controls: !0,
+        style: {
+          display: "block",
+          maxWidth: "100%",
+          borderRadius: "0.25rem",
+          overflow: "hidden",
+          WebkitTransform: "translateZ(0)"
+        },
+        children: /* @__PURE__ */ jsx("track", { kind: "captions", label: caption ?? "Video" })
+      }
+    ),
+    isDefined(caption) && /* @__PURE__ */ jsx("div", { style: { marginBlockStart: "0.75rem" }, children: /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, style: { fontStyle: "italic" }, children: caption }) })
+  ] });
+}
+function VideoBlock({ value }) {
+  return isDefined(value.asset?.url) ? /* @__PURE__ */ jsx("div", { style: { marginBlock: "1.5rem" }, children: /* @__PURE__ */ jsx(VideoContent, { url: value.asset.url, caption: value.caption }) }) : null;
+}
+const portableTextComponents = {
+  block: {
+    h2: ({ children }) => /* @__PURE__ */ jsx("div", { style: { marginBlockStart: "3rem", marginBlockEnd: "0.25rem" }, children: /* @__PURE__ */ jsx(Text, { as: "h2", size: 1, weight: "medium", children }) }),
+    normal: ({ children }) => /* @__PURE__ */ jsx("div", { style: { marginBlock: "1rem" }, children: /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children }) }),
+    blockquote: ({ children }) => /* @__PURE__ */ jsx("div", { style: { marginBlock: "2rem" }, children: /* @__PURE__ */ jsx(Box, { paddingLeft: 3, paddingY: 1, style: { borderLeft: "2px solid var(--card-border-color)" }, children: /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, style: { fontStyle: "italic" }, children }) }) })
+  },
+  list: {
+    bullet: ({ children, value }) => /* @__PURE__ */ jsx("div", { style: { marginBlock: value.level > 1 ? "0.75rem" : "2rem" }, children: /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: /* @__PURE__ */ jsx("ul", { style: { display: "flex", flexDirection: "column", gap: "0.375rem", margin: 0, paddingLeft: "1.25em" }, children }) }) }),
+    number: ({ children, value }) => /* @__PURE__ */ jsx("div", { style: { marginBlock: value.level > 1 ? "0.75rem" : "2rem" }, children: /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: /* @__PURE__ */ jsx("ol", { style: { display: "flex", flexDirection: "column", gap: "0.375rem", margin: 0, paddingLeft: "1.25em" }, children }) }) })
+  },
+  listItem: {
+    bullet: ({ children }) => /* @__PURE__ */ jsx("li", { children }),
+    number: ({ children }) => /* @__PURE__ */ jsx("li", { children })
+  },
+  marks: {
+    strong: ({ children }) => /* @__PURE__ */ jsx("strong", { children }),
+    em: ({ children }) => /* @__PURE__ */ jsx("em", { children }),
+    code: ({ children }) => /* @__PURE__ */ jsx(
+      "code",
+      {
+        style: {
+          padding: "0.125rem 0.25rem",
+          fontSize: "0.875em",
+          backgroundColor: "var(--card-code-bg-color)",
+          borderRadius: "0.125rem"
+        },
+        children
+      }
+    ),
+    link: ({ children, value }) => /* @__PURE__ */ jsx("a", { href: value?.href, target: "_blank", rel: "noopener noreferrer", style: { color: "var(--card-link-fg-color)" }, children }),
+    "strike-through": ({ children }) => /* @__PURE__ */ jsx("del", { children })
+  }
+};
+function GuideContent({ content }) {
+  const { blocks: customBlocks } = useHandbookContext(), components = useMemo(() => {
+    const customTypes = {};
+    for (const block of customBlocks)
+      customTypes[block.schema.name] = block.component;
+    return {
+      ...portableTextComponents,
+      types: {
+        "handbook.image": ImageBlock,
+        "handbook.video": VideoBlock,
+        "handbook.code": CodeBlock,
+        "handbook.callout": CalloutBlock,
+        "handbook.horizontalRule": HorizontalRuleBlock,
+        ...customTypes
+      }
+    };
+  }, [customBlocks]);
+  return /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsx(PortableText, { value: content, components }) });
+}
+function GuidesTabs() {
+  const { configuration, loading } = useHandbookContext();
+  return loading || !isDefined(configuration) ? null : configuration.groups.map((group) => /* @__PURE__ */ jsx(SidebarGroup, { heading: group.title, children: group.guides.map((guide) => /* @__PURE__ */ jsx(SidebarTab, { id: guide._key, label: guide.title, icon: createSanityIcon(BookOpenTextIcon) }, guide._key)) }, group._key));
+}
+function GuidesPanels() {
+  const { configuration, loading } = useHandbookContext();
+  return loading || !isDefined(configuration) ? null : configuration.groups.flatMap(
+    (group) => group.guides.map((guide) => /* @__PURE__ */ jsx(ContentPanel, { id: guide._key, title: guide.title, description: guide.description, children: /* @__PURE__ */ jsx(GuideContent, { content: guide.content }) }, guide._key))
+  );
+}
+function DocumentTypesOverview() {
+  const { groups, setActiveTab, setSidebarExpanded } = useHandbookContext();
+  return /* @__PURE__ */ jsx("div", { style: { display: "flex", flexDirection: "column", gap: "2.5rem" }, children: groups.map((group) => {
+    const { title, description, documents } = group;
+    return /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
+      /* @__PURE__ */ jsxs(Stack, { space: 3, children: [
+        /* @__PURE__ */ jsx(Flex, { align: "center", paddingY: 1, children: /* @__PURE__ */ jsx(Text, { size: 1, weight: "medium", children: title }) }),
+        isDefined(description) && /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: description })
+      ] }),
+      /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Stack, { space: 2, children: documents.map((document) => {
+        const Icon = typeof document.icon == "function" ? document.icon : void 0, documentDescription = document.handbook?.description ?? (typeof document.description == "string" ? document.description : void 0);
+        return /* @__PURE__ */ jsx(
+          Card,
+          {
+            as: "button",
+            padding: 3,
+            radius: 2,
+            sizing: "border",
+            tone: "inherit",
+            onClick: () => {
+              setActiveTab(document.name), setSidebarExpanded(!1);
+            },
+            style: {
+              width: "calc(100% + 24px)",
+              marginLeft: "-12px",
+              textAlign: "left",
+              border: "none",
+              cursor: "pointer"
+            },
+            children: /* @__PURE__ */ jsxs(Flex, { align: "center", gap: 3, children: [
+              /* @__PURE__ */ jsx(Box, { flex: 1, children: /* @__PURE__ */ jsxs(Stack, { space: 3, children: [
+                /* @__PURE__ */ jsxs(Flex, { align: "center", gap: 2, style: { marginLeft: "-4px" }, children: [
+                  isDefined(Icon) && /* @__PURE__ */ jsx(
+                    "div",
+                    {
+                      style: {
+                        display: "flex",
+                        alignItems: "center",
+                        justifyContent: "center",
+                        width: "25px",
+                        height: "25px",
+                        color: "var(--card-icon-color)"
+                      },
+                      children: /* @__PURE__ */ jsx(Icon, {})
+                    }
+                  ),
+                  /* @__PURE__ */ jsx(Text, { size: 1, weight: "medium", children: document.title ?? document.name })
+                ] }),
+                isDefined(documentDescription) && /* @__PURE__ */ jsx(Box, { paddingBottom: 1, children: /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: documentDescription }) })
+              ] }) }),
+              /* @__PURE__ */ jsx(Box, { flex: "none", style: { opacity: 0.5 }, children: /* @__PURE__ */ jsx(Text, { muted: !0, size: 1, children: /* @__PURE__ */ jsx(ChevronRightIcon, {}) }) })
+            ] })
+          },
+          document.name
+        );
+      }) }) })
+    ] }, title);
+  }) });
+}
+function HintRow({ icon, children }) {
+  return /* @__PURE__ */ jsxs(Flex, { align: "center", gap: 3, children: [
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        style: {
+          display: "flex",
+          alignItems: "center",
+          flexShrink: 0,
+          fontSize: "16px",
+          color: "var(--card-icon-color)"
+        },
+        children: icon
+      }
+    ),
+    /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children })
+  ] });
+}
+function HowToUse() {
+  return /* @__PURE__ */ jsxs("div", { style: { display: "flex", flexDirection: "column", gap: "3rem" }, children: [
+    /* @__PURE__ */ jsxs(Stack, { space: 3, children: [
+      /* @__PURE__ */ jsx(Flex, { align: "center", paddingY: 1, children: /* @__PURE__ */ jsx(Text, { size: 1, weight: "medium", children: "Navigating the Handbook" }) }),
+      /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: "Use the sidebar to browse document types and guides. Each entry opens a detailed view in the main panel showing field descriptions, examples, and tips." })
+    ] }),
+    /* @__PURE__ */ jsxs(Stack, { space: 3, children: [
+      /* @__PURE__ */ jsx(Flex, { align: "center", paddingY: 1, children: /* @__PURE__ */ jsx(Text, { size: 1, weight: "medium", children: "Understanding Fields" }) }),
+      /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: "Each document type lists its fields with a name and type label. Below the name you will find a description explaining what the field is for and how to use it. Some fields include an example value shown in italics." }),
+      /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, style: { fontStyle: "italic" }, children: "e.g. Acme Inc." }) })
+    ] }),
+    /* @__PURE__ */ jsxs(Stack, { space: 3, children: [
+      /* @__PURE__ */ jsx(Flex, { align: "center", paddingY: 1, children: /* @__PURE__ */ jsx(Text, { size: 1, weight: "medium", children: "Hints and Warnings" }) }),
+      /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: "Look for these icons next to field names. Hover or click them to reveal additional guidance." }),
+      /* @__PURE__ */ jsxs(Stack, { space: 3, marginTop: 2, children: [
+        /* @__PURE__ */ jsx(HintRow, { icon: /* @__PURE__ */ jsx(LightbulbIcon, { ...defaultIconProps }), children: "Helpful tips and best practices for content editors." }),
+        /* @__PURE__ */ jsx(HintRow, { icon: /* @__PURE__ */ jsx(InfoIcon, { ...defaultIconProps }), children: "Additional context about how the field is used." }),
+        /* @__PURE__ */ jsx(HintRow, { icon: /* @__PURE__ */ jsx(TriangleAlertIcon, { ...defaultIconProps }), children: "Important warnings about constraints or potential issues." })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs(Stack, { space: 3, children: [
+      /* @__PURE__ */ jsx(Flex, { align: "center", paddingY: 1, children: /* @__PURE__ */ jsx(Text, { size: 1, weight: "medium", children: "Nested Fields" }) }),
+      /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: "Some fields contain subfields \u2014 for example, a content block might include a heading and body text. These are shown as collapsible sections you can expand to explore the full structure." })
+    ] })
+  ] });
+}
+const entries = [
+  {
+    name: "how-to-use-this-handbook",
+    title: "How to Use This Handbook",
+    icon: createSanityIcon(BookTextIcon),
+    description: "A quick guide to navigating the Handbook, understanding the information presented for each field, and making the most of tips, hints, and warnings.",
+    component: HowToUse
+  },
+  {
+    name: "document-types",
+    title: "Document Types",
+    icon: createSanityIcon(LayoutGridIcon),
+    description: "An overview of all document types, organised by group. Select a document type to view its fields, descriptions, and examples.",
+    component: DocumentTypesOverview
+  }
+];
+function GettingStartedTabs() {
+  return /* @__PURE__ */ jsx(SidebarGroup, { heading: "Getting Started", children: entries.map((entry) => /* @__PURE__ */ jsx(SidebarTab, { id: entry.name, label: entry.title, icon: entry.icon }, entry.name)) });
+}
+function GettingStartedPanels() {
+  return entries.map((entry) => {
+    const { name, title, description, component: Component } = entry;
+    return /* @__PURE__ */ jsx(ContentPanel, { id: name, title, description, children: /* @__PURE__ */ jsx(Component, {}) }, name);
+  });
+}
+function Content() {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(GettingStartedPanels, {}),
+    /* @__PURE__ */ jsx(DocumentTypesPanels, {}),
+    /* @__PURE__ */ jsx(GuidesPanels, {})
+  ] });
+}
+function Sidebar() {
+  return /* @__PURE__ */ jsxs(Box, { paddingX: 3, paddingBottom: 1, children: [
+    /* @__PURE__ */ jsx(GettingStartedTabs, {}),
+    /* @__PURE__ */ jsx(DocumentTypesTabs, {}),
+    /* @__PURE__ */ jsx(GuidesTabs, {})
+  ] });
+}
+const defaultUndocumentedFieldMessage = "This field has not been documented yet. Contact your development team for guidance.", wideBreakpoint = 920, narrowBreakpoint = 480, sidebarWidth = 320, collapsedSidebarWidth = 51;
+function CollapsedSidebar() {
+  const { sidebarTitle, setSidebarExpanded } = useHandbookContext();
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      style: {
+        width: `${collapsedSidebarWidth}px`,
+        minWidth: `${collapsedSidebarWidth}px`,
+        overflow: "hidden",
+        borderRight: "1px solid var(--card-border-color)"
+      },
+      children: /* @__PURE__ */ jsx(Card, { tone: "inherit", "data-collapsed": "", children: /* @__PURE__ */ jsx(
+        Flex,
+        {
+          direction: "column",
+          padding: 3,
+          onClick: () => {
+            setSidebarExpanded(!0);
+          },
+          style: {
+            width: "100vh",
+            boxSizing: "border-box",
+            transform: "rotate(90deg)",
+            transformOrigin: `calc(${collapsedSidebarWidth}px / 2)`,
+            cursor: "pointer"
+          },
+          children: /* @__PURE__ */ jsx(Flex, { align: "flex-start", children: /* @__PURE__ */ jsx(Card, { flex: 1, paddingLeft: 2, padding: 2, children: /* @__PURE__ */ jsx(Flex, { align: "center", gap: 1, children: /* @__PURE__ */ jsx(Text, { size: 1, textOverflow: "ellipsis", weight: "semibold", style: { cursor: "default", outline: "none" }, children: sidebarTitle }) }) }) })
+        }
+      ) })
+    }
+  );
+}
+function NarrowContentHeader() {
+  const { sidebarTitle, setSidebarExpanded } = useHandbookContext();
+  return /* @__PURE__ */ jsxs(Flex, { align: "center", gap: 2, padding: 3, children: [
+    /* @__PURE__ */ jsx(
+      Button,
+      {
+        icon: ArrowLeftIcon,
+        mode: "bleed",
+        onClick: () => {
+          setSidebarExpanded(!0);
+        }
+      }
+    ),
+    /* @__PURE__ */ jsx(Text, { size: 1, weight: "semibold", children: sidebarTitle })
+  ] });
+}
+function ExpandedSidebar() {
+  const { sidebarTitle } = useHandbookContext();
+  return /* @__PURE__ */ jsxs(
+    Card,
+    {
+      borderRight: !0,
+      style: { display: "flex", flexDirection: "column", width: `${sidebarWidth}px`, minWidth: `${sidebarWidth}px` },
+      children: [
+        /* @__PURE__ */ jsx(PaneHeader, { title: sidebarTitle }),
+        /* @__PURE__ */ jsx("div", { style: { flex: 1, paddingBottom: "4px", overflowY: "auto" }, children: /* @__PURE__ */ jsx(Sidebar, {}) })
+      ]
+    }
+  );
+}
+function NarrowLayout() {
+  const { sidebarTitle, sidebarExpanded } = useHandbookContext();
+  return sidebarExpanded ? /* @__PURE__ */ jsxs("div", { style: { display: "flex", flexDirection: "column", flex: 1 }, children: [
+    /* @__PURE__ */ jsx(PaneHeader, { title: sidebarTitle }),
+    /* @__PURE__ */ jsx("div", { style: { flex: 1, paddingBottom: "4px", overflowY: "auto" }, children: /* @__PURE__ */ jsx(Sidebar, {}) })
+  ] }) : /* @__PURE__ */ jsxs("div", { style: { display: "flex", flexDirection: "column", flex: 1 }, children: [
+    /* @__PURE__ */ jsx(NarrowContentHeader, {}),
+    /* @__PURE__ */ jsx(Content, {})
+  ] });
+}
+function MediumLayout() {
+  const { sidebarExpanded, setSidebarExpanded } = useHandbookContext();
+  return sidebarExpanded ? /* @__PURE__ */ jsxs(Flex, { style: { flex: 1 }, children: [
+    /* @__PURE__ */ jsx(ExpandedSidebar, {}),
+    /* @__PURE__ */ jsx(
+      Card,
+      {
+        flex: 1,
+        padding: 3,
+        onClick: () => {
+          setSidebarExpanded(!1);
+        },
+        style: { opacity: 0.4, overflowY: "auto", cursor: "pointer" }
+      }
+    )
+  ] }) : /* @__PURE__ */ jsxs(Flex, { style: { flex: 1 }, children: [
+    /* @__PURE__ */ jsx(CollapsedSidebar, {}),
+    /* @__PURE__ */ jsx(Card, { flex: 1, style: { display: "flex", flexDirection: "column" }, children: /* @__PURE__ */ jsx(Content, {}) })
+  ] });
+}
+function WideLayout() {
+  return /* @__PURE__ */ jsxs(Flex, { style: { flex: 1 }, children: [
+    /* @__PURE__ */ jsx(ExpandedSidebar, {}),
+    /* @__PURE__ */ jsx(Card, { flex: 1, style: { display: "flex", flexDirection: "column" }, children: /* @__PURE__ */ jsx(Content, {}) })
+  ] });
+}
+function HandbookLayout() {
+  const { reference: containerReference, width: containerWidth } = useContainerWidth(), isNarrow = isDefined(containerWidth) && containerWidth < narrowBreakpoint, isMedium = isDefined(containerWidth) && containerWidth >= narrowBreakpoint && containerWidth < wideBreakpoint;
+  function renderLayout() {
+    return isNarrow ? /* @__PURE__ */ jsx(NarrowLayout, {}) : isMedium ? /* @__PURE__ */ jsx(MediumLayout, {}) : /* @__PURE__ */ jsx(WideLayout, {});
+  }
+  return /* @__PURE__ */ jsx("div", { ref: containerReference, style: { display: "flex", flexDirection: "column", height: "100%" }, children: renderLayout() });
+}
+function createHandbookTool(config) {
+  return function() {
+    return /* @__PURE__ */ jsx(
+      HandbookProvider,
+      {
+        sidebarTitle: config.sidebarTitle ?? "Handbook",
+        groups: config.groups ?? [],
+        blocks: config.blocks ?? [],
+        undocumentedFieldMessage: config.undocumentedFieldMessage ?? defaultUndocumentedFieldMessage,
+        children: /* @__PURE__ */ jsx(HandbookLayout, {})
+      }
+    );
+  };
+}
+let registeredEditors;
+function setHandbookEditors(editors) {
+  registeredEditors = editors;
+}
+function handbookStructure(structureBuilder, context) {
+  if (!isPermittedEditor(registeredEditors, context.currentUser?.email)) return [];
+  const { listItem, document, documentTypeList } = structureBuilder;
+  return [
+    listItem().title("Handbook").icon(createSanityIcon(BookTextIcon)).child(document().id("handbook.handbook").schemaType("handbook.handbook").title("Handbook")),
+    listItem().title("Handbook Guides").icon(createSanityIcon(BookOpenTextIcon)).child(documentTypeList("handbook.guide").title("Handbook Guides"))
+  ];
+}
+function CalloutPreview({ variant, text }) {
+  return /* @__PURE__ */ jsx(CalloutContent, { variant: variant ?? "tip", children: text });
+}
+function ParagraphDecorator({ children }) {
+  return /* @__PURE__ */ jsx("span", { style: { fontSize: "0.8125rem" }, children });
+}
+function HeadingDecorator({ children }) {
+  return /* @__PURE__ */ jsx("span", { style: { fontSize: "0.8125rem", fontWeight: "500" }, children });
+}
+function BlockquoteDecorator({ children }) {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      style: {
+        paddingLeft: "0.75em",
+        fontSize: "0.8125rem",
+        fontStyle: "italic",
+        borderLeft: "2px solid var(--card-border-color)"
+      },
+      children
+    }
+  );
+}
+function BulletListDecorator({ children }) {
+  return /* @__PURE__ */ jsx("div", { style: { marginTop: "-0.25em", fontSize: "0.8125rem" }, children });
+}
+function NumberListDecorator({ children }) {
+  return /* @__PURE__ */ jsx("div", { style: { marginTop: "-0.25em", fontSize: "0.8125rem" }, children });
+}
+function InlineCodeDecorator({ children }) {
+  return /* @__PURE__ */ jsx(
+    "code",
+    {
+      style: {
+        padding: "0.125rem 0.25rem",
+        fontSize: "0.8125rem",
+        color: "var(--card-muted-fg-color)",
+        backgroundColor: "var(--card-code-bg-color)",
+        borderRadius: "0.125rem"
+      },
+      children
+    }
+  );
+}
+const linkAnnotation = defineArrayMember({
+  name: "link",
+  type: "object",
+  fields: [
+    defineField({
+      name: "href",
+      title: "URL",
+      type: "url",
+      description: "Web address for this link. Supports http, https, mailto, and tel schemes.",
+      validation: (rule) => rule.uri({ scheme: ["http", "https", "mailto", "tel"] })
+    })
+  ]
+}), handbookCalloutType = defineType({
+  name: "handbook.callout",
+  title: "Callout",
+  type: "object",
+  icon: createSanityIcon(MessageCircleQuestionMarkIcon),
+  description: "A highlighted message block used to draw attention to tips, supplementary information, or warnings.",
+  preview: {
+    select: { variant: "variant", body: "body" },
+    prepare({ variant, body }) {
+      const text = Array.isArray(body) ? body.flatMap((block) => (block.children ?? []).map((child) => child.text ?? "")).join("") : "";
+      return { variant, text };
+    }
+  },
+  components: {
+    preview: CalloutPreview
+  },
+  fields: [
+    defineField({
+      name: "variant",
+      title: "Variant",
+      type: "string",
+      description: "Visual style and intent of the callout.",
+      initialValue: "tip",
+      validation: (rule) => rule.required(),
+      options: {
+        list: [
+          { title: "Tip", value: "tip" },
+          { title: "Information", value: "info" },
+          { title: "Warning", value: "warning" }
+        ],
+        layout: "radio",
+        direction: "horizontal"
+      }
+    }),
+    defineField({
+      name: "body",
+      title: "Body",
+      type: "array",
+      description: "Content displayed inside the callout. Supports inline formatting and links.",
+      of: [
+        defineArrayMember({
+          type: "block",
+          styles: [{ title: "Normal", value: "normal", component: ParagraphDecorator }],
+          marks: {
+            decorators: [
+              { title: "Bold", value: "strong" },
+              { title: "Italic", value: "em" },
+              { title: "Strikethrough", value: "strike-through" },
+              { title: "Code", value: "code", component: InlineCodeDecorator }
+            ],
+            annotations: [linkAnnotation]
+          },
+          lists: []
+        })
+      ]
+    })
+  ]
+});
+function CodePreview({ code, language }) {
+  return isDefined(code) ? /* @__PURE__ */ jsx(CodeContent, { code, language }) : null;
+}
+const handbookCodeType = defineType({
+  name: "handbook.code",
+  title: "Code",
+  type: "object",
+  icon: createSanityIcon(CodeIcon),
+  description: "A syntax-highlighted code block with language selection.",
+  preview: {
+    select: { code: "code", language: "language" }
+  },
+  components: {
+    preview: CodePreview
+  },
+  fields: [
+    defineField({
+      name: "code",
+      title: "Code",
+      type: "text",
+      description: "The source code to display."
+    }),
+    defineField({
+      name: "language",
+      title: "Language",
+      type: "string",
+      description: "Programming language used for syntax highlighting.",
+      options: {
+        list: [
+          { title: "CSS", value: "css" },
+          { title: "GROQ", value: "groq" },
+          { title: "HTML", value: "html" },
+          { title: "JavaScript", value: "javascript" },
+          { title: "JSON", value: "json" },
+          { title: "Plain Text", value: "text" },
+          { title: "React", value: "tsx" },
+          { title: "Shell", value: "shell" },
+          { title: "TypeScript", value: "typescript" }
+        ]
+      }
+    })
+  ]
+});
+function HorizontalRulePreview() {
+  return /* @__PURE__ */ jsx(HorizontalRuleContent, { marginBlock: "0.5rem" });
+}
+const handbookHorizontalRuleType = defineType({
+  name: "handbook.horizontalRule",
+  title: "Horizontal Rule",
+  type: "object",
+  icon: createSanityIcon(MinusIcon),
+  description: "A visual divider between sections of content.",
+  preview: {
+    prepare() {
+      return { title: "Horizontal Rule" };
+    }
+  },
+  components: {
+    preview: HorizontalRulePreview
+  },
+  fields: [
+    defineField({
+      name: "style",
+      title: "Style",
+      type: "string",
+      description: "Presentation style for the divider.",
+      hidden: !0,
+      initialValue: "default"
+    })
+  ]
+});
+function ImagePreview({ url, alt, caption }) {
+  return isDefined(url) ? /* @__PURE__ */ jsx("div", { style: { padding: "0.5rem" }, children: /* @__PURE__ */ jsx(ImageContent, { url, alt, caption }) }) : null;
+}
+const handbookImageType = defineType({
+  name: "handbook.image",
+  title: "Image",
+  type: "object",
+  icon: createSanityIcon(ImageIcon),
+  description: "An image with optional caption and alternative text for accessibility.",
+  preview: {
+    select: { caption: "caption", alt: "alt", url: "asset.asset.url" }
+  },
+  components: {
+    preview: ImagePreview
+  },
+  fields: [
+    defineField({
+      name: "asset",
+      title: "Image",
+      type: "image",
+      description: "Upload or select an image from the media library.",
+      options: { hotspot: !0 }
+    }),
+    defineField({
+      name: "caption",
+      title: "Caption",
+      type: "string",
+      description: "Text displayed beneath the image in the handbook."
+    }),
+    defineField({
+      name: "alt",
+      title: "Alternative Text",
+      type: "string",
+      description: "Describes the image for screen readers and accessibility tools."
+    })
+  ]
+});
+function VideoPreview({ url, caption }) {
+  return isDefined(url) ? /* @__PURE__ */ jsx("div", { style: { padding: "0.5rem" }, children: /* @__PURE__ */ jsx(VideoContent, { url, caption }) }) : null;
+}
+const handbookVideoType = defineType({
+  name: "handbook.video",
+  title: "Video",
+  type: "object",
+  icon: createSanityIcon(VideoIcon),
+  description: "An uploaded video with optional caption.",
+  preview: {
+    select: { caption: "caption", url: "asset.asset.url" }
+  },
+  components: {
+    preview: VideoPreview
+  },
+  fields: [
+    defineField({
+      name: "asset",
+      title: "Video",
+      type: "file",
+      description: "Upload or select a video from the media library.",
+      options: { accept: "video/*" }
+    }),
+    defineField({
+      name: "caption",
+      title: "Caption",
+      type: "string",
+      description: "Text displayed beneath the video in the handbook."
+    })
+  ]
+});
+function createGuideContentField(customBlocks = []) {
+  return defineField({
+    name: "content",
+    title: "Content",
+    type: "array",
+    description: "Rich text content for this guide. Supports headings, lists, images, code blocks, and custom blocks.",
+    of: [
+      defineArrayMember({
+        name: "block",
+        type: "block",
+        styles: [
+          { title: "Paragraph", value: "normal", component: ParagraphDecorator },
+          { title: "Heading", value: "h2", component: HeadingDecorator },
+          { title: "Blockquote", value: "blockquote", component: BlockquoteDecorator }
+        ],
+        marks: {
+          decorators: [
+            { title: "Bold", value: "strong" },
+            { title: "Italic", value: "em" },
+            { title: "Strikethrough", value: "strike-through" },
+            { title: "Code", value: "code", component: InlineCodeDecorator }
+          ],
+          annotations: [linkAnnotation]
+        },
+        lists: [
+          { title: "Bullet", value: "bullet", component: BulletListDecorator },
+          { title: "Number", value: "number", component: NumberListDecorator }
+        ]
+      }),
+      defineArrayMember({ type: "handbook.image" }),
+      defineArrayMember({ type: "handbook.video" }),
+      defineArrayMember({ type: "handbook.code" }),
+      defineArrayMember({ type: "handbook.callout" }),
+      defineArrayMember({ type: "handbook.horizontalRule" }),
+      ...customBlocks.map((block) => defineArrayMember({ type: block.schema.name }))
+    ]
+  });
+}
+function createHandbookGuideType(customBlocks = []) {
+  return defineType({
+    name: "handbook.guide",
+    title: "Handbook Guide",
+    type: "document",
+    icon: createSanityIcon(BookOpenTextIcon),
+    description: "A handbook page authored with rich text, images, and custom blocks.",
+    preview: {
+      select: { title: "title", description: "description" },
+      prepare({ title, description }) {
+        return {
+          title: title ?? "Untitled Guide",
+          subtitle: description
+        };
+      }
+    },
+    fields: [
+      defineField({
+        name: "title",
+        title: "Title",
+        type: "string",
+        description: "Display title shown in the handbook sidebar and as the page heading.",
+        validation: (rule) => rule.required()
+      }),
+      defineField({
+        name: "description",
+        title: "Description",
+        type: "string",
+        description: "Brief summary displayed beneath the guide heading."
+      }),
+      createGuideContentField(customBlocks)
+    ]
+  });
+}
+const handbookType = defineType({
+  name: "handbook.handbook",
+  title: "Handbook",
+  type: "document",
+  icon: createSanityIcon(BookTextIcon),
+  description: "Defines the structure and ordering of the handbook, including groups and their guides.",
+  preview: {
+    prepare() {
+      return { title: "Handbook" };
+    }
+  },
+  fields: [
+    defineField({
+      name: "groups",
+      title: "Groups",
+      type: "array",
+      description: "Ordered list of groups displayed in the handbook sidebar. Each group contains a title and an ordered list of guide references.",
+      of: [
+        defineArrayMember({
+          name: "group",
+          type: "object",
+          icon: createSanityIcon(ListPlusIcon),
+          fields: [
+            defineField({
+              name: "title",
+              title: "Title",
+              type: "string",
+              description: "Heading displayed above this group of guides in the sidebar.",
+              validation: (rule) => rule.required()
+            }),
+            defineField({
+              name: "guides",
+              title: "Guides",
+              type: "array",
+              description: "Ordered list of guides within this group. Drag to reorder.",
+              of: [
+                defineArrayMember({
+                  type: "reference",
+                  to: [{ type: "handbook.guide" }]
+                })
+              ]
+            })
+          ],
+          preview: {
+            select: { title: "title", guide0: "guides.0.title", guide1: "guides.1.title", guide2: "guides.2.title" },
+            prepare({
+              title,
+              guide0,
+              guide1,
+              guide2
+            }) {
+              const shown = [guide0, guide1, guide2].filter((guide) => isDefined(guide)).slice(0, 2), hasMore = isDefined(guide2);
+              function formatSubtitle() {
+                return isDefined(shown) ? hasMore ? `${shown.join(", ")}, and others` : shown.join(" and ") : "No guides selected";
+              }
+              return {
+                title: title ?? "Untitled Group",
+                subtitle: formatSubtitle()
+              };
+            }
+          }
+        })
+      ]
+    })
+  ]
+});
+function useIsHandbookEditor(editors) {
+  const user = useCurrentUser();
+  return isPermittedEditor(editors, user?.email);
+}
+const handbookSingletonTypes = /* @__PURE__ */ new Set(["handbook.handbook"]), handbookDocumentTypes = /* @__PURE__ */ new Set(["handbook.handbook", "handbook.guide"]);
+function isHandbookTemplate(templateId, typeSet) {
+  return typeSet.has(templateId) || [...typeSet].some((type) => templateId.startsWith(`${type}-`));
+}
+function validateGroup(index, group) {
+  const prefix = `sanity-handbook: groups[${index}]`;
+  if (!isDefined(group.title)) throw new Error(`${prefix} is missing a required "title" property.`);
+  if (!Array.isArray(group.documents) || group.documents.length === 0)
+    throw new Error(`${prefix} must have a non-empty "documents" array.`);
+  for (const document of group.documents) {
+    if (!isDefined(document.name))
+      throw new Error(`${prefix}.documents contains a document without a "name" property.`);
+    if (!Array.isArray(document.fields))
+      throw new TypeError(`${prefix}.documents.${document.name} is missing a "fields" array.`);
+  }
+}
+function validateConfig(config) {
+  if (config.groups)
+    for (const [index, group] of config.groups.entries())
+      validateGroup(index, group);
+}
+function handbookPlugin(config) {
+  config && validateConfig(config);
+  const customBlocks = config?.blocks ?? [], editors = config?.editors;
+  setHandbookEditors(editors);
+  const guideType = createHandbookGuideType(customBlocks);
+  return definePlugin(() => ({
+    name: "@driftime/sanity-plugin-handbook",
+    schema: {
+      types: [
+        handbookType,
+        guideType,
+        handbookImageType,
+        handbookVideoType,
+        handbookCodeType,
+        handbookCalloutType,
+        handbookHorizontalRuleType,
+        ...customBlocks.map((block) => block.schema)
+      ]
+    },
+    document: {
+      newDocumentOptions: (templateItems, { creationContext, currentUser }) => creationContext.type === "global" || creationContext.type === "structure" ? isPermittedEditor(editors, currentUser?.email) ? templateItems.filter((item) => !isHandbookTemplate(item.templateId, handbookSingletonTypes)) : templateItems.filter((item) => !isHandbookTemplate(item.templateId, handbookDocumentTypes)) : templateItems,
+      actions: (actionComponents, { schemaType }) => handbookSingletonTypes.has(schemaType) ? actionComponents.filter(({ action }) => action !== "duplicate") : actionComponents
+    },
+    tools: [
+      {
+        name: "handbook",
+        title: config?.title ?? "Handbook",
+        icon: createSanityIcon(BookTextIcon),
+        component: createHandbookTool({ ...config, blocks: customBlocks })
+      }
+    ]
+  }))();
+}
+export {
+  handbookPlugin,
+  handbookStructure,
+  useIsHandbookEditor
+};
+//# sourceMappingURL=index.js.map