@riverbankcms/sdk 0.72.0 → 0.75.0

package/dist/client/headerSection-TOT5MGTF.mjs

@@ -0,0 +1,729 @@
+"use client";
+import { useCommerceCart } from './chunk-ZLMS67RR.mjs';
+import { resolveDedicatedCheckoutPath, ModalShell } from './chunk-3PEDD5KJ.mjs';
+import { defineIslandPropsDecoder, buildCartDisplay, themeButtonClassName } from './chunk-FU2QRZMX.mjs';
+import './chunk-PMAIXMAB.mjs';
+import * as React2 from 'react';
+import { createPortal } from 'react-dom';
+import { createRoot } from 'react-dom/client';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+
+var NAV_DROPDOWN_VIEWPORT_GUTTER_PX = 16;
+var NAV_DROPDOWN_SHIFT_PROPERTY = "--nav-dropdown-shift-x";
+function normalizeQuantityInput(value) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? Math.max(1, parsed || 1) : 1;
+}
+function HeaderCartDrawerItems(props) {
+  return /* @__PURE__ */ jsx("div", { className: "rb-flex rb-flex-col rb-gap-4", children: props.items.map((item) => /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "rb-flex rb-items-start rb-justify-between rb-gap-4 rb-border-b rb-py-4",
+      style: { borderColor: "rgba(var(--tb-border, 226 232 240), 0.75)" },
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "rb-flex rb-flex-1 rb-flex-col rb-gap-2", children: [
+          /* @__PURE__ */ jsxs("div", { children: [
+            /* @__PURE__ */ jsx("strong", { children: item.title }),
+            /* @__PURE__ */ jsx("p", { className: "rb-caption status-muted", children: item.priceLabel })
+          ] }),
+          item.quantityEditable ? /* @__PURE__ */ jsxs("label", { className: "rb-flex rb-flex-col rb-gap-1", children: [
+            /* @__PURE__ */ jsx("span", { className: "rb-label", children: "Quantity" }),
+            /* @__PURE__ */ jsx(
+              "input",
+              {
+                type: "number",
+                min: 1,
+                className: "form-input rb-w-24",
+                value: item.quantity,
+                onChange: (event) => props.cart.updateQuantity(item.key, normalizeQuantityInput(event.target.value))
+              }
+            )
+          ] }) : /* @__PURE__ */ jsxs("p", { className: "rb-caption status-muted", children: [
+            "Quantity: ",
+            item.quantity
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            className: themeButtonClassName({ variant: "secondary", size: "sm" }),
+            onClick: () => props.cart.removeItem(item.key),
+            children: "Remove"
+          }
+        )
+      ]
+    },
+    item.key
+  )) });
+}
+function HeaderCartDrawer(props) {
+  const titleId = React2.useId();
+  const display = React2.useMemo(
+    () => buildCartDisplay(props.cart.items, {
+      heading: "Cart",
+      emptyMessage: "Your cart is empty.",
+      checkoutButtonText: "Checkout",
+      clearButtonText: "Clear cart"
+    }),
+    [props.cart.items]
+  );
+  if (!props.open) {
+    return null;
+  }
+  const checkoutUnavailable = props.checkoutHref === null;
+  return /* @__PURE__ */ jsxs(
+    ModalShell,
+    {
+      title: "Cart",
+      titleId,
+      onClose: props.onClose,
+      portal: true,
+      portalRoot: props.portalRoot,
+      overlayClassName: "rb-fixed rb-inset-0 rb-z-50 rb-flex rb-justify-end rb-bg-black-40",
+      modalClassName: "rb-flex rb-h-full rb-w-full rb-max-w-xl rb-flex-col",
+      renderHeader: ({ title, titleId: resolvedTitleId, onClose, closeButtonRef }) => /* @__PURE__ */ jsxs(
+        "div",
+        {
+          className: "rb-flex rb-items-center rb-justify-between rb-gap-4 rb-border-b rb-px-6 rb-py-5",
+          style: {
+            background: "rgb(var(--tb-surface, 255 255 255))",
+            color: "rgb(var(--tb-foreground, 15 23 42))",
+            borderColor: "rgba(var(--tb-border, 226 232 240), 0.9)"
+          },
+          children: [
+            /* @__PURE__ */ jsx("h2", { id: resolvedTitleId, children: title }),
+            /* @__PURE__ */ jsx(
+              "button",
+              {
+                ref: closeButtonRef,
+                type: "button",
+                className: "header-nav-link rb-inline-flex rb-items-center rb-justify-center",
+                onClick: onClose,
+                "aria-label": "Close cart",
+                children: "\xD7"
+              }
+            )
+          ]
+        }
+      ),
+      children: [
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: "rb-flex-1 rb-overflow-y-auto rb-px-6 rb-py-6",
+            style: {
+              background: "rgb(var(--tb-surface, 255 255 255))",
+              color: "rgb(var(--tb-foreground, 15 23 42))",
+              boxShadow: "0 24px 80px rgba(var(--tb-foreground, 15 23 42), 0.22)"
+            },
+            children: display.state === "empty" ? /* @__PURE__ */ jsx("p", { className: "rb-caption status-muted", children: display.emptyMessage }) : /* @__PURE__ */ jsx(HeaderCartDrawerItems, { cart: props.cart, items: display.items })
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          "div",
+          {
+            className: "rb-border-t rb-px-6 rb-py-5",
+            style: {
+              borderColor: "rgba(var(--tb-border, 226 232 240), 0.9)",
+              background: "rgb(var(--tb-surface, 255 255 255))",
+              color: "rgb(var(--tb-foreground, 15 23 42))"
+            },
+            children: [
+              /* @__PURE__ */ jsxs("div", { className: "rb-mb-4 rb-flex rb-items-center rb-justify-between", children: [
+                /* @__PURE__ */ jsx("span", { className: "rb-label", children: "Subtotal" }),
+                /* @__PURE__ */ jsx("strong", { children: display.subtotalLabel ?? "\u2014" })
+              ] }),
+              checkoutUnavailable ? /* @__PURE__ */ jsx("p", { className: "rb-mb-4 rb-caption status-muted", children: "Checkout preview is not available for this internal published route yet." }) : null,
+              /* @__PURE__ */ jsxs("div", { className: "rb-flex rb-flex-wrap rb-gap-3", children: [
+                /* @__PURE__ */ jsx(
+                  "button",
+                  {
+                    type: "button",
+                    className: themeButtonClassName({ variant: "secondary", size: "md" }),
+                    onClick: () => props.cart.clear(),
+                    disabled: display.state === "empty",
+                    children: display.clearButtonText
+                  }
+                ),
+                props.checkoutHref && display.state === "ready" ? /* @__PURE__ */ jsx(
+                  "a",
+                  {
+                    className: themeButtonClassName({ variant: "default", size: "md" }),
+                    href: props.checkoutHref,
+                    onClick: props.onClose,
+                    children: display.checkoutButtonText
+                  }
+                ) : /* @__PURE__ */ jsx(
+                  "button",
+                  {
+                    type: "button",
+                    className: themeButtonClassName({ variant: "default", size: "md" }),
+                    disabled: true,
+                    children: display.checkoutButtonText
+                  }
+                )
+              ] })
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+
+// ../blocks/src/system/runtime/header/headerCartRuntime.shared.ts
+function getCartItemCount(items) {
+  return items.reduce((total, item) => total + item.quantity, 0);
+}
+function getHeaderCartTriggerClassName(context) {
+  return context === "mobile" ? "nav-mobile-link rb-flex rb-w-full rb-items-center rb-justify-between rb-py-3 rb-nav-text-mobile transition-theme-standard" : "header-nav-link rb-inline-flex rb-items-center rb-gap-2 rb-px-4 rb-py-2 rb-nav-text transition-theme-standard";
+}
+function resolveHeaderCartCheckoutHref(mounts, pathname) {
+  const configuredHrefs = Array.from(new Set(
+    mounts.map((mount) => mount.checkoutHref).filter((href) => href !== null)
+  )).sort();
+  const configuredHref = configuredHrefs[0];
+  if (configuredHref) {
+    return configuredHref;
+  }
+  return pathname ? resolveDedicatedCheckoutPath(pathname) : null;
+}
+function snapshotHeaderCartMounts(mounts) {
+  return mounts.map((mount) => ({
+    mount,
+    fallbackNodes: Array.from(mount.element.childNodes)
+  }));
+}
+function clearHeaderCartMounts(mounts) {
+  mounts.forEach(({ mount }) => {
+    mount.element.replaceChildren();
+  });
+}
+function restoreHeaderCartMounts(mounts) {
+  mounts.forEach(({ mount, fallbackNodes }) => {
+    mount.element.replaceChildren(...fallbackNodes);
+  });
+}
+function CartIcon() {
+  return /* @__PURE__ */ jsxs(
+    "svg",
+    {
+      "aria-hidden": "true",
+      viewBox: "0 0 24 24",
+      width: "20",
+      height: "20",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "1.8",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      children: [
+        /* @__PURE__ */ jsx("path", { d: "M6 7h13l-1.4 7.1a2 2 0 0 1-2 1.6H10a2 2 0 0 1-2-1.6L6 4H3" }),
+        /* @__PURE__ */ jsx("circle", { cx: "10", cy: "19", r: "1.25" }),
+        /* @__PURE__ */ jsx("circle", { cx: "16", cy: "19", r: "1.25" })
+      ]
+    }
+  );
+}
+function HeaderCartTrigger(props) {
+  return /* @__PURE__ */ jsxs(
+    "button",
+    {
+      type: "button",
+      className: getHeaderCartTriggerClassName(props.mount.context),
+      onClick: props.onOpen,
+      "aria-label": props.mount.ariaLabel,
+      "data-nav-cart-trigger": "true",
+      children: [
+        /* @__PURE__ */ jsxs("span", { className: "rb-inline-flex rb-items-center rb-gap-2", children: [
+          /* @__PURE__ */ jsx(CartIcon, {}),
+          props.mount.visibleLabel ? /* @__PURE__ */ jsx("span", { children: props.mount.visibleLabel }) : null
+        ] }),
+        props.mount.badge === "show-count" && props.itemCount > 0 ? /* @__PURE__ */ jsx(
+          "span",
+          {
+            className: "rb-inline-flex rb-min-w-0 rb-items-center rb-justify-center rb-rounded-full rb-px-2 rb-py-1 rb-text-xs",
+            style: {
+              background: "rgba(var(--tb-foreground, 15 23 42), 0.12)"
+            },
+            children: props.itemCount
+          }
+        ) : null
+      ]
+    }
+  );
+}
+function HeaderCartRuntime(props) {
+  const cart = useCommerceCart(props.siteId);
+  const itemCount = React2.useMemo(() => getCartItemCount(cart.items), [cart.items]);
+  const [open, setOpen] = React2.useState(false);
+  const checkoutHref = React2.useMemo(
+    () => resolveHeaderCartCheckoutHref(
+      props.mounts,
+      typeof window === "undefined" ? null : window.location.pathname
+    ),
+    [props.mounts]
+  );
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    props.mounts.map(
+      (mount) => createPortal(
+        /* @__PURE__ */ jsx(
+          HeaderCartTrigger,
+          {
+            mount,
+            itemCount,
+            onOpen: () => setOpen(true)
+          }
+        ),
+        mount.element,
+        mount.context === "mobile" ? `mobile:${mount.ariaLabel}` : `desktop:${mount.ariaLabel}`
+      )
+    ),
+    /* @__PURE__ */ jsx(
+      HeaderCartDrawer,
+      {
+        portalRoot: props.portalRoot,
+        open,
+        checkoutHref,
+        onClose: () => setOpen(false),
+        cart
+      }
+    )
+  ] });
+}
+function mountHeaderCartRuntime(root, siteId, mounts) {
+  if (mounts.length === 0) {
+    return;
+  }
+  const preparedMounts = snapshotHeaderCartMounts(mounts);
+  clearHeaderCartMounts(preparedMounts);
+  const mountNode = document.createElement("div");
+  mountNode.hidden = true;
+  root.appendChild(mountNode);
+  const reactRoot = createRoot(mountNode);
+  try {
+    reactRoot.render(
+      /* @__PURE__ */ jsx(
+        HeaderCartRuntime,
+        {
+          portalRoot: root,
+          siteId,
+          mounts: preparedMounts.map(({ mount }) => mount)
+        }
+      )
+    );
+  } catch (error) {
+    reactRoot.unmount();
+    mountNode.remove();
+    restoreHeaderCartMounts(preparedMounts);
+    throw error;
+  }
+  return () => {
+    reactRoot.unmount();
+    mountNode.remove();
+    restoreHeaderCartMounts(preparedMounts);
+  };
+}
+
+// ../blocks/src/system/runtime/header/enhanceHeaderSection.ts
+var SELECTORS = {
+  dropdown: ".nav-dropdown",
+  dropdownMenu: ".nav-dropdown-menu",
+  dropdownTrigger: ".nav-dropdown-trigger",
+  mobileOverlay: "[data-nav-mobile-overlay]",
+  mobileToggle: "[data-nav-mobile-toggle]",
+  mobileBackdrop: "[data-nav-mobile-backdrop]",
+  mobileClose: "[data-nav-mobile-close]",
+  mobileTrigger: "[data-nav-mobile-trigger]",
+  mobileDropdown: "[data-nav-mobile-dropdown]",
+  mobileChildren: "[data-nav-mobile-children]",
+  cartPlaceholder: "[data-nav-cart-placeholder]"
+};
+var CLASSES = {
+  hidden: "rb-hidden",
+  headerShrink: "rb-header-shrink",
+  headerScrolled: "header-scrolled",
+  mobileOpen: "nav-mobile-open"
+};
+var FOCUSABLE_SELECTOR = 'a[href], button:not([disabled]), [tabindex]:not([tabindex="-1"])';
+function planDropdownViewportShift(input) {
+  const { left, right, viewportWidth, gutter } = input;
+  if (!Number.isFinite(left) || !Number.isFinite(right) || !Number.isFinite(viewportWidth) || !Number.isFinite(gutter)) {
+    return { kind: "unchanged" };
+  }
+  const normalizedGutter = Math.max(0, gutter);
+  const viewportLeft = normalizedGutter;
+  const viewportRight = Math.max(viewportLeft, viewportWidth - normalizedGutter);
+  const menuWidth = right - left;
+  const availableWidth = viewportRight - viewportLeft;
+  if (menuWidth >= availableWidth) {
+    const x2 = viewportLeft - left;
+    return x2 === 0 ? { kind: "unchanged" } : { kind: "shift", x: x2 };
+  }
+  let x = 0;
+  if (right > viewportRight) x = viewportRight - right;
+  if (left + x < viewportLeft) x += viewportLeft - (left + x);
+  return x === 0 ? { kind: "unchanged" } : { kind: "shift", x };
+}
+function applyDropdownPlacementPlan(menu, plan) {
+  switch (plan.kind) {
+    case "unchanged":
+      menu.style.removeProperty(NAV_DROPDOWN_SHIFT_PROPERTY);
+      return;
+    case "shift":
+      menu.style.setProperty(NAV_DROPDOWN_SHIFT_PROPERTY, `${plan.x}px`);
+      return;
+    default: {
+      const _exhaustive = plan;
+      return _exhaustive;
+    }
+  }
+}
+function getFirstNonScriptChild(root) {
+  const children = Array.from(root.children);
+  for (const child of children) {
+    if (child.tagName.toLowerCase() === "script") continue;
+    return child;
+  }
+  return null;
+}
+function enhanceDesktopDropdownAria(root) {
+  const cleanups = [];
+  const dropdowns = Array.from(root.querySelectorAll(SELECTORS.dropdown));
+  const setExpanded = (trigger, expanded) => {
+    trigger.setAttribute("aria-expanded", expanded ? "true" : "false");
+  };
+  dropdowns.forEach((dropdown) => {
+    const trigger = dropdown.querySelector(SELECTORS.dropdownTrigger);
+    if (!trigger) return;
+    const menu = dropdown.querySelector(SELECTORS.dropdownMenu);
+    let placementRafId = null;
+    let placementRafScheduled = false;
+    const cancelPlacementFrame = () => {
+      if (placementRafId !== null) {
+        window.cancelAnimationFrame(placementRafId);
+        placementRafId = null;
+      }
+      placementRafScheduled = false;
+    };
+    const resetPlacement = () => {
+      cancelPlacementFrame();
+      menu?.style.removeProperty(NAV_DROPDOWN_SHIFT_PROPERTY);
+    };
+    const schedulePlacement = () => {
+      if (!menu) return;
+      resetPlacement();
+      placementRafScheduled = true;
+      const id = window.requestAnimationFrame(() => {
+        placementRafScheduled = false;
+        placementRafId = null;
+        const rect = menu.getBoundingClientRect();
+        const plan = planDropdownViewportShift({
+          left: rect.left,
+          right: rect.right,
+          viewportWidth: document.documentElement.clientWidth,
+          gutter: NAV_DROPDOWN_VIEWPORT_GUTTER_PX
+        });
+        applyDropdownPlacementPlan(menu, plan);
+      });
+      placementRafId = placementRafScheduled ? id : null;
+    };
+    setExpanded(trigger, false);
+    const handleEnter = () => {
+      setExpanded(trigger, true);
+      schedulePlacement();
+    };
+    const handleLeave = () => {
+      if (dropdown.contains(document.activeElement)) return;
+      setExpanded(trigger, false);
+      resetPlacement();
+    };
+    const handleFocusIn = () => {
+      setExpanded(trigger, true);
+      schedulePlacement();
+    };
+    const handleFocusOut = (event) => {
+      const next = event.relatedTarget;
+      if (!next || !dropdown.contains(next)) {
+        setExpanded(trigger, false);
+        resetPlacement();
+      }
+    };
+    dropdown.addEventListener("mouseenter", handleEnter);
+    dropdown.addEventListener("mouseleave", handleLeave);
+    dropdown.addEventListener("focusin", handleFocusIn);
+    dropdown.addEventListener("focusout", handleFocusOut);
+    cleanups.push(() => {
+      dropdown.removeEventListener("mouseenter", handleEnter);
+      dropdown.removeEventListener("mouseleave", handleLeave);
+      dropdown.removeEventListener("focusin", handleFocusIn);
+      dropdown.removeEventListener("focusout", handleFocusOut);
+      resetPlacement();
+    });
+  });
+  return cleanups;
+}
+function enhanceMobileDropdowns(root) {
+  const cleanups = [];
+  const triggers = Array.from(root.querySelectorAll(SELECTORS.mobileTrigger));
+  const reset = () => {
+    triggers.forEach((trigger) => {
+      const dropdown = trigger.closest(SELECTORS.mobileDropdown);
+      const children = dropdown?.querySelector(SELECTORS.mobileChildren);
+      trigger.setAttribute("aria-expanded", "false");
+      children?.classList.add(CLASSES.hidden);
+      dropdown?.classList.remove(CLASSES.mobileOpen);
+    });
+  };
+  triggers.forEach((trigger) => {
+    const dropdown = trigger.closest(SELECTORS.mobileDropdown);
+    const children = dropdown?.querySelector(SELECTORS.mobileChildren);
+    if (!children) return;
+    trigger.setAttribute("aria-expanded", "false");
+    const handleClick = () => {
+      const isOpen = trigger.getAttribute("aria-expanded") === "true";
+      trigger.setAttribute("aria-expanded", isOpen ? "false" : "true");
+      children.classList.toggle(CLASSES.hidden, isOpen);
+      dropdown?.classList.toggle(CLASSES.mobileOpen, !isOpen);
+    };
+    trigger.addEventListener("click", handleClick);
+    cleanups.push(() => trigger.removeEventListener("click", handleClick));
+  });
+  return { cleanups, reset };
+}
+function enhanceMobileOverlay(root, resetMobileDropdowns) {
+  const cleanups = [];
+  const overlay = root.querySelector(SELECTORS.mobileOverlay);
+  const toggles = Array.from(root.querySelectorAll(SELECTORS.mobileToggle));
+  const backdrop = root.querySelector(SELECTORS.mobileBackdrop);
+  const closeBtn = root.querySelector(SELECTORS.mobileClose);
+  if (!overlay || toggles.length === 0) return { cleanups };
+  overlay.classList.remove(CLASSES.hidden);
+  overlay.setAttribute("aria-hidden", "true");
+  overlay.setAttribute("inert", "");
+  toggles.forEach((toggle) => toggle.setAttribute("aria-expanded", "false"));
+  const state = {
+    isOpen: overlay.getAttribute("aria-hidden") === "false",
+    previousBodyOverflow: null,
+    previousBodyPaddingRight: null,
+    lastActiveElement: null
+  };
+  const setOpen = (open) => {
+    state.isOpen = open;
+    overlay.setAttribute("aria-hidden", open ? "false" : "true");
+    toggles.forEach((toggle) => {
+      toggle.setAttribute("aria-expanded", open ? "true" : "false");
+      toggle.setAttribute("aria-label", open ? "Close menu" : "Open menu");
+    });
+    if (open) {
+      overlay.removeAttribute("inert");
+      state.previousBodyOverflow = document.body.style.overflow;
+      state.previousBodyPaddingRight = document.body.style.paddingRight;
+      const scrollbarWidth = window.innerWidth - document.documentElement.clientWidth;
+      if (scrollbarWidth > 0) {
+        document.body.style.paddingRight = `${scrollbarWidth}px`;
+      }
+      document.body.style.overflow = "hidden";
+      state.lastActiveElement = document.activeElement;
+      const overlayToggle = overlay.querySelector(SELECTORS.mobileToggle);
+      const focusTarget = overlayToggle ?? overlay.querySelector(FOCUSABLE_SELECTOR);
+      if (focusTarget) {
+        try {
+          focusTarget.focus({ preventScroll: true });
+        } catch {
+          focusTarget.focus();
+        }
+      }
+    } else {
+      overlay.setAttribute("inert", "");
+      if (state.previousBodyOverflow !== null) {
+        document.body.style.overflow = state.previousBodyOverflow;
+        state.previousBodyOverflow = null;
+        if (state.previousBodyPaddingRight !== null) {
+          document.body.style.paddingRight = state.previousBodyPaddingRight;
+          state.previousBodyPaddingRight = null;
+        }
+        if (state.lastActiveElement) {
+          try {
+            state.lastActiveElement.focus({ preventScroll: true });
+          } catch {
+            state.lastActiveElement.focus();
+          }
+        }
+      }
+    }
+  };
+  const handleClose = () => {
+    setOpen(false);
+    resetMobileDropdowns();
+  };
+  const handleToggleClick = () => {
+    if (state.isOpen) {
+      handleClose();
+      return;
+    }
+    setOpen(true);
+  };
+  const handleKeyDown = (event) => {
+    if (!state.isOpen) return;
+    if (event.key !== "Escape") return;
+    event.preventDefault();
+    handleClose();
+  };
+  const handleOverlayClick = (event) => {
+    const targetEl = event.target;
+    const link = targetEl?.closest("a[href]");
+    if (link) handleClose();
+  };
+  toggles.forEach((toggle) => toggle.addEventListener("click", handleToggleClick));
+  backdrop?.addEventListener("click", handleClose);
+  closeBtn?.addEventListener("click", handleClose);
+  document.addEventListener("keydown", handleKeyDown);
+  overlay.addEventListener("click", handleOverlayClick);
+  cleanups.push(() => {
+    setOpen(false);
+    toggles.forEach((toggle) => toggle.removeEventListener("click", handleToggleClick));
+    backdrop?.removeEventListener("click", handleClose);
+    closeBtn?.removeEventListener("click", handleClose);
+    document.removeEventListener("keydown", handleKeyDown);
+    overlay.removeEventListener("click", handleOverlayClick);
+    if (state.previousBodyOverflow !== null) document.body.style.overflow = state.previousBodyOverflow;
+    if (state.previousBodyPaddingRight !== null) document.body.style.paddingRight = state.previousBodyPaddingRight;
+  });
+  return { cleanups };
+}
+function getFirstParsedCartMount(mounts) {
+  return mounts[0] ?? null;
+}
+function readOptionalDatasetValue(element, key) {
+  const value = element.dataset[key];
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function parseCartMount(element) {
+  const siteId = readOptionalDatasetValue(element, "navCartSiteId");
+  const context = readOptionalDatasetValue(element, "navCartContext");
+  if (!siteId || context !== "desktop" && context !== "mobile") {
+    return null;
+  }
+  const badge = readOptionalDatasetValue(element, "navCartBadge") === "hidden" ? "hidden" : "show-count";
+  return {
+    siteId,
+    mount: {
+      element,
+      context,
+      badge,
+      ariaLabel: readOptionalDatasetValue(element, "navCartAriaLabel") ?? "Cart",
+      visibleLabel: readOptionalDatasetValue(element, "navCartVisibleLabel"),
+      checkoutHref: readOptionalDatasetValue(element, "navCartCheckoutHref")
+    }
+  };
+}
+function enhanceCartMounts(root) {
+  const cleanups = [];
+  const parsedMounts = Array.from(root.querySelectorAll(SELECTORS.cartPlaceholder)).map((element) => parseCartMount(element)).filter((mount) => mount !== null);
+  const firstMount = getFirstParsedCartMount(parsedMounts);
+  if (!firstMount) {
+    return { cleanups };
+  }
+  const siteId = firstMount.siteId;
+  const mounts = parsedMounts.filter((mount) => mount.siteId === siteId).map((mount) => mount.mount);
+  const cleanup = mountHeaderCartRuntime(root, siteId, mounts);
+  if (cleanup) {
+    cleanups.push(cleanup);
+  }
+  return { cleanups };
+}
+var SCROLL_THRESHOLD_PX = 8;
+var SCROLL_HYSTERESIS_PX = 4;
+var SCROLL_ON_THRESHOLD_PX = SCROLL_THRESHOLD_PX;
+var SCROLL_OFF_THRESHOLD_PX = Math.max(0, SCROLL_THRESHOLD_PX - SCROLL_HYSTERESIS_PX);
+function getScrollContainer(element) {
+  let parent = element.parentElement;
+  while (parent && parent !== document.body) {
+    const style = getComputedStyle(parent);
+    const overflowY = style.overflowY || style.overflow;
+    if (/auto|scroll|overlay/.test(overflowY)) {
+      if (parent.scrollHeight > parent.clientHeight) {
+        return parent;
+      }
+    }
+    parent = parent.parentElement;
+  }
+  return document.scrollingElement || window;
+}
+function getRootScrollTop() {
+  if (typeof window.scrollY === "number" && Number.isFinite(window.scrollY)) return window.scrollY;
+  const scrollingElement = document.scrollingElement;
+  if (scrollingElement) return scrollingElement.scrollTop;
+  return document.documentElement.scrollTop || document.body.scrollTop || 0;
+}
+function enhanceScrollBehavior(target, scrollEnabled) {
+  const cleanups = [];
+  const enabled = typeof scrollEnabled === "boolean" ? scrollEnabled : target.classList.contains(CLASSES.headerShrink);
+  if (!enabled) return cleanups;
+  const scrollContainer = getScrollContainer(target);
+  const isRootScroll = scrollContainer === window || scrollContainer instanceof HTMLElement && (scrollContainer === document.scrollingElement || scrollContainer === document.documentElement || scrollContainer === document.body);
+  const scrollEventTarget = isRootScroll ? window : scrollContainer;
+  const getScrollTop = () => isRootScroll ? getRootScrollTop() : scrollContainer.scrollTop;
+  const update = () => {
+    const scrollTop = Math.max(0, getScrollTop());
+    const isScrolled = target.classList.contains(CLASSES.headerScrolled);
+    if (isScrolled) {
+      if (scrollTop < SCROLL_OFF_THRESHOLD_PX) target.classList.remove(CLASSES.headerScrolled);
+      return;
+    }
+    if (scrollTop > SCROLL_ON_THRESHOLD_PX) target.classList.add(CLASSES.headerScrolled);
+  };
+  let rafId = null;
+  let rafScheduled = false;
+  const onScroll = () => {
+    if (rafScheduled) return;
+    rafScheduled = true;
+    const id = window.requestAnimationFrame(() => {
+      rafScheduled = false;
+      rafId = null;
+      update();
+    });
+    rafId = id;
+    if (!rafScheduled) rafId = null;
+  };
+  update();
+  scrollEventTarget.addEventListener("scroll", onScroll, { passive: true });
+  cleanups.push(() => {
+    scrollEventTarget.removeEventListener("scroll", onScroll);
+    if (rafId !== null) window.cancelAnimationFrame(rafId);
+  });
+  return cleanups;
+}
+function enhanceHeaderSection(root, options = {}) {
+  if (root.dataset.rbHeaderEnhanced === "true") return;
+  root.dataset.rbHeaderEnhanced = "true";
+  const cleanups = [];
+  cleanups.push(...enhanceDesktopDropdownAria(root));
+  const mobileDropdowns = enhanceMobileDropdowns(root);
+  cleanups.push(...mobileDropdowns.cleanups);
+  const overlay = enhanceMobileOverlay(root, mobileDropdowns.reset);
+  cleanups.push(...overlay.cleanups);
+  const cartMounts = enhanceCartMounts(root);
+  cleanups.push(...cartMounts.cleanups);
+  const target = options.scrollTarget ?? getFirstNonScriptChild(root);
+  if (target) {
+    cleanups.push(...enhanceScrollBehavior(target, options.scrollEnabled));
+  }
+  if (cleanups.length === 0) return;
+  return () => {
+    cleanups.forEach((fn) => fn());
+  };
+}
+
+// src/rendering/islands/enhancers/headerSection.ts
+var decode = defineIslandPropsDecoder("headerSection");
+var enhance = (root, props) => {
+  const scrollEnabled = typeof props?.scrollEnabled === "boolean" ? props.scrollEnabled : typeof props?.enabled === "boolean" ? props.enabled : void 0;
+  return enhanceHeaderSection(root, { scrollEnabled });
+};
+
+export { decode, enhance };