@primer/react 37.32.0-rc.f8e94f384 → 38.0.0-rc.09f015db1

package/dist/PageLayout/PageLayout.js

@@ -0,0 +1,1215 @@
+import { c } from 'react-compiler-runtime';
+import React, { useRef } from 'react';
+import { clsx } from 'clsx';
+import { useId } from '../hooks/useId.js';
+import { useRefObjectAsForwardedRef } from '../hooks/useRefObjectAsForwardedRef.js';
+import { isResponsiveValue, useResponsiveValue } from '../hooks/useResponsiveValue.js';
+import { useSlots } from '../hooks/useSlots.js';
+import { canUseDOM } from '../utils/environment.js';
+import { useOverflow } from '../hooks/useOverflow.js';
+import { warning } from '../utils/warning.js';
+import classes from './PageLayout.module.css.js';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+const PageLayoutContext = /*#__PURE__*/React.createContext({
+  padding: 'normal',
+  rowGap: 'normal',
+  columnGap: 'normal',
+  paneRef: {
+    current: null
+  }
+});
+
+// TODO: refs
+const Root = t0 => {
+  const $ = c(26);
+  const {
+    containerWidth: t1,
+    padding: t2,
+    rowGap: t3,
+    columnGap: t4,
+    children,
+    className,
+    style,
+    _slotsConfig: slotsConfig
+  } = t0;
+  const containerWidth = t1 === undefined ? "xlarge" : t1;
+  const padding = t2 === undefined ? "normal" : t2;
+  const rowGap = t3 === undefined ? "normal" : t3;
+  const columnGap = t4 === undefined ? "normal" : t4;
+  const paneRef = useRef(null);
+  let t5;
+  if ($[0] !== slotsConfig) {
+    t5 = slotsConfig !== null && slotsConfig !== void 0 ? slotsConfig : {
+      header: Header,
+      footer: Footer
+    };
+    $[0] = slotsConfig;
+    $[1] = t5;
+  } else {
+    t5 = $[1];
+  }
+  const [slots, rest] = useSlots(children, t5);
+  let t6;
+  if ($[2] !== columnGap || $[3] !== padding || $[4] !== rowGap) {
+    t6 = {
+      padding,
+      rowGap,
+      columnGap,
+      paneRef
+    };
+    $[2] = columnGap;
+    $[3] = padding;
+    $[4] = rowGap;
+    $[5] = t6;
+  } else {
+    t6 = $[5];
+  }
+  const memoizedContextValue = t6;
+  const t7 = `var(--spacing-${padding})`;
+  let t8;
+  if ($[6] !== style || $[7] !== t7) {
+    t8 = {
+      "--spacing": t7,
+      ...style
+    };
+    $[6] = style;
+    $[7] = t7;
+    $[8] = t8;
+  } else {
+    t8 = $[8];
+  }
+  const t9 = t8;
+  let t10;
+  if ($[9] !== className) {
+    t10 = clsx(classes.PageLayoutRoot, className);
+    $[9] = className;
+    $[10] = t10;
+  } else {
+    t10 = $[10];
+  }
+  const t11 = slots.header;
+  let t12;
+  if ($[11] === Symbol.for("react.memo_cache_sentinel")) {
+    t12 = clsx(classes.PageLayoutContent);
+    $[11] = t12;
+  } else {
+    t12 = $[11];
+  }
+  let t13;
+  if ($[12] !== rest) {
+    t13 = /*#__PURE__*/jsx("div", {
+      className: t12,
+      children: rest
+    });
+    $[12] = rest;
+    $[13] = t13;
+  } else {
+    t13 = $[13];
+  }
+  let t14;
+  if ($[14] !== containerWidth || $[15] !== slots.footer || $[16] !== slots.header || $[17] !== t13) {
+    t14 = /*#__PURE__*/jsxs("div", {
+      className: classes.PageLayoutWrapper,
+      "data-width": containerWidth,
+      children: [t11, t13, slots.footer]
+    });
+    $[14] = containerWidth;
+    $[15] = slots.footer;
+    $[16] = slots.header;
+    $[17] = t13;
+    $[18] = t14;
+  } else {
+    t14 = $[18];
+  }
+  let t15;
+  if ($[19] !== t10 || $[20] !== t14 || $[21] !== t9) {
+    t15 = /*#__PURE__*/jsx("div", {
+      style: t9,
+      className: t10,
+      children: t14
+    });
+    $[19] = t10;
+    $[20] = t14;
+    $[21] = t9;
+    $[22] = t15;
+  } else {
+    t15 = $[22];
+  }
+  let t16;
+  if ($[23] !== memoizedContextValue || $[24] !== t15) {
+    t16 = /*#__PURE__*/jsx(PageLayoutContext.Provider, {
+      value: memoizedContextValue,
+      children: t15
+    });
+    $[23] = memoizedContextValue;
+    $[24] = t15;
+    $[25] = t16;
+  } else {
+    t16 = $[25];
+  }
+  return t16;
+};
+Root.displayName = 'PageLayout';
+
+// ----------------------------------------------------------------------------
+// Divider (internal)
+
+const HorizontalDivider = t0 => {
+  const $ = c(10);
+  const {
+    variant: t1,
+    className,
+    position,
+    style
+  } = t0;
+  const variant = t1 === undefined ? "none" : t1;
+  const {
+    padding
+  } = React.useContext(PageLayoutContext);
+  const responsiveVariant = useResponsiveValue(variant, "none");
+  let t2;
+  if ($[0] !== className) {
+    t2 = clsx(classes.HorizontalDivider, className);
+    $[0] = className;
+    $[1] = t2;
+  } else {
+    t2 = $[1];
+  }
+  const t3 = `var(--spacing-${padding})`;
+  let t4;
+  if ($[2] !== style || $[3] !== t3) {
+    t4 = {
+      "--spacing-divider": t3,
+      ...style
+    };
+    $[2] = style;
+    $[3] = t3;
+    $[4] = t4;
+  } else {
+    t4 = $[4];
+  }
+  const t5 = t4;
+  let t6;
+  if ($[5] !== position || $[6] !== responsiveVariant || $[7] !== t2 || $[8] !== t5) {
+    t6 = /*#__PURE__*/jsx("div", {
+      className: t2,
+      "data-variant": responsiveVariant,
+      "data-position": position,
+      style: t5
+    });
+    $[5] = position;
+    $[6] = responsiveVariant;
+    $[7] = t2;
+    $[8] = t5;
+    $[9] = t6;
+  } else {
+    t6 = $[9];
+  }
+  return t6;
+};
+const VerticalDivider = t0 => {
+  const $ = c(36);
+  const {
+    variant: t1,
+    draggable: t2,
+    onDragStart,
+    onDrag,
+    onDragEnd,
+    onDoubleClick,
+    position,
+    className,
+    style
+  } = t0;
+  const variant = t1 === undefined ? "none" : t1;
+  const draggable = t2 === undefined ? false : t2;
+  const [isDragging, setIsDragging] = React.useState(false);
+  const [isKeyboardDrag, setIsKeyboardDrag] = React.useState(false);
+  const responsiveVariant = useResponsiveValue(variant, "none");
+  const stableOnDrag = React.useRef(onDrag);
+  const stableOnDragEnd = React.useRef(onDragEnd);
+  const {
+    paneRef
+  } = React.useContext(PageLayoutContext);
+  const [minWidth, setMinWidth] = React.useState(0);
+  const [maxWidth, setMaxWidth] = React.useState(0);
+  const [currentWidth, setCurrentWidth] = React.useState(0);
+  let t3;
+  if ($[0] !== paneRef) {
+    t3 = () => {
+      if (paneRef.current !== null) {
+        const paneStyles = getComputedStyle(paneRef.current);
+        const maxPaneWidthDiffPixels = paneStyles.getPropertyValue("--pane-max-width-diff");
+        const minWidthPixels = paneStyles.getPropertyValue("--pane-min-width");
+        const paneWidth = paneRef.current.getBoundingClientRect().width;
+        const maxPaneWidthDiff = Number(maxPaneWidthDiffPixels.split("px")[0]);
+        const minPaneWidth = Number(minWidthPixels.split("px")[0]);
+        const viewportWidth = window.innerWidth;
+        const maxPaneWidth = viewportWidth > maxPaneWidthDiff ? viewportWidth - maxPaneWidthDiff : viewportWidth;
+        setMinWidth(minPaneWidth);
+        setMaxWidth(maxPaneWidth);
+        setCurrentWidth(paneWidth || 0);
+      }
+    };
+    $[0] = paneRef;
+    $[1] = t3;
+  } else {
+    t3 = $[1];
+  }
+  let t4;
+  if ($[2] !== isDragging || $[3] !== isKeyboardDrag || $[4] !== paneRef) {
+    t4 = [paneRef, isKeyboardDrag, isDragging];
+    $[2] = isDragging;
+    $[3] = isKeyboardDrag;
+    $[4] = paneRef;
+    $[5] = t4;
+  } else {
+    t4 = $[5];
+  }
+  React.useEffect(t3, t4);
+  let t5;
+  let t6;
+  if ($[6] !== onDrag) {
+    t5 = () => {
+      stableOnDrag.current = onDrag;
+    };
+    t6 = [onDrag];
+    $[6] = onDrag;
+    $[7] = t5;
+    $[8] = t6;
+  } else {
+    t5 = $[7];
+    t6 = $[8];
+  }
+  React.useEffect(t5, t6);
+  let t7;
+  let t8;
+  if ($[9] !== onDragEnd) {
+    t7 = () => {
+      stableOnDragEnd.current = onDragEnd;
+    };
+    t8 = [onDragEnd];
+    $[9] = onDragEnd;
+    $[10] = t7;
+    $[11] = t8;
+  } else {
+    t7 = $[10];
+    t8 = $[11];
+  }
+  React.useEffect(t7, t8);
+  let t10;
+  let t9;
+  if ($[12] !== currentWidth || $[13] !== isDragging || $[14] !== isKeyboardDrag || $[15] !== maxWidth || $[16] !== minWidth) {
+    t9 = () => {
+      const handleDrag = function handleDrag(event) {
+        var _stableOnDrag$current;
+        (_stableOnDrag$current = stableOnDrag.current) === null || _stableOnDrag$current === void 0 ? void 0 : _stableOnDrag$current.call(stableOnDrag, event.movementX, false);
+        event.preventDefault();
+      };
+      const handleDragEnd = function handleDragEnd(event_0) {
+        var _stableOnDragEnd$curr;
+        setIsDragging(false);
+        (_stableOnDragEnd$curr = stableOnDragEnd.current) === null || _stableOnDragEnd$curr === void 0 ? void 0 : _stableOnDragEnd$curr.call(stableOnDragEnd);
+        event_0.preventDefault();
+      };
+      const handleKeyDrag = function handleKeyDrag(event_1) {
+        var _stableOnDrag$current2;
+        let delta;
+        if ((event_1.key === "ArrowLeft" || event_1.key === "ArrowDown") && currentWidth > minWidth) {
+          delta = -3;
+        } else {
+          if ((event_1.key === "ArrowRight" || event_1.key === "ArrowUp") && currentWidth < maxWidth) {
+            delta = 3;
+          } else {
+            return;
+          }
+        }
+        setCurrentWidth(currentWidth + delta);
+        (_stableOnDrag$current2 = stableOnDrag.current) === null || _stableOnDrag$current2 === void 0 ? void 0 : _stableOnDrag$current2.call(stableOnDrag, delta, true);
+        event_1.preventDefault();
+      };
+      const handleKeyDragEnd = function handleKeyDragEnd(event_2) {
+        var _stableOnDragEnd$curr2;
+        setIsKeyboardDrag(false);
+        (_stableOnDragEnd$curr2 = stableOnDragEnd.current) === null || _stableOnDragEnd$curr2 === void 0 ? void 0 : _stableOnDragEnd$curr2.call(stableOnDragEnd);
+        event_2.preventDefault();
+      };
+      if (isDragging || isKeyboardDrag) {
+        window.addEventListener("mousemove", handleDrag);
+        window.addEventListener("keydown", handleKeyDrag);
+        window.addEventListener("mouseup", handleDragEnd);
+        window.addEventListener("keyup", handleKeyDragEnd);
+        const body = document.body;
+        body === null || body === void 0 ? void 0 : body.setAttribute("data-page-layout-dragging", "true");
+      } else {
+        window.removeEventListener("mousemove", handleDrag);
+        window.removeEventListener("mouseup", handleDragEnd);
+        window.removeEventListener("keydown", handleKeyDrag);
+        window.removeEventListener("keyup", handleKeyDragEnd);
+        const body_0 = document.body;
+        body_0 === null || body_0 === void 0 ? void 0 : body_0.removeAttribute("data-page-layout-dragging");
+      }
+      return () => {
+        window.removeEventListener("mousemove", handleDrag);
+        window.removeEventListener("mouseup", handleDragEnd);
+        window.removeEventListener("keydown", handleKeyDrag);
+        window.removeEventListener("keyup", handleKeyDragEnd);
+        const body_1 = document.body;
+        body_1 === null || body_1 === void 0 ? void 0 : body_1.removeAttribute("data-page-layout-dragging");
+      };
+    };
+    t10 = [isDragging, isKeyboardDrag, currentWidth, minWidth, maxWidth];
+    $[12] = currentWidth;
+    $[13] = isDragging;
+    $[14] = isKeyboardDrag;
+    $[15] = maxWidth;
+    $[16] = minWidth;
+    $[17] = t10;
+    $[18] = t9;
+  } else {
+    t10 = $[17];
+    t9 = $[18];
+  }
+  React.useEffect(t9, t10);
+  let t11;
+  if ($[19] !== className) {
+    t11 = clsx(classes.VerticalDivider, className);
+    $[19] = className;
+    $[20] = t11;
+  } else {
+    t11 = $[20];
+  }
+  let t12;
+  if ($[21] !== currentWidth || $[22] !== draggable || $[23] !== isDragging || $[24] !== isKeyboardDrag || $[25] !== maxWidth || $[26] !== minWidth || $[27] !== onDoubleClick || $[28] !== onDragStart) {
+    t12 = draggable ? /*#__PURE__*/jsx("div", {
+      className: classes.DraggableHandle,
+      "data-dragging": isDragging || isKeyboardDrag,
+      role: "slider",
+      "aria-label": "Draggable pane splitter",
+      "aria-valuemin": minWidth,
+      "aria-valuemax": maxWidth,
+      "aria-valuenow": currentWidth,
+      "aria-valuetext": `Pane width ${currentWidth} pixels`,
+      tabIndex: 0,
+      onMouseDown: event_3 => {
+        if (event_3.button === 0) {
+          setIsDragging(true);
+          onDragStart === null || onDragStart === void 0 ? void 0 : onDragStart();
+        }
+      },
+      onKeyDown: event_4 => {
+        if (event_4.key === "ArrowLeft" || event_4.key === "ArrowRight" || event_4.key === "ArrowUp" || event_4.key === "ArrowDown") {
+          setIsKeyboardDrag(true);
+          onDragStart === null || onDragStart === void 0 ? void 0 : onDragStart();
+        }
+      },
+      onDoubleClick: onDoubleClick
+    }) : null;
+    $[21] = currentWidth;
+    $[22] = draggable;
+    $[23] = isDragging;
+    $[24] = isKeyboardDrag;
+    $[25] = maxWidth;
+    $[26] = minWidth;
+    $[27] = onDoubleClick;
+    $[28] = onDragStart;
+    $[29] = t12;
+  } else {
+    t12 = $[29];
+  }
+  let t13;
+  if ($[30] !== position || $[31] !== responsiveVariant || $[32] !== style || $[33] !== t11 || $[34] !== t12) {
+    t13 = /*#__PURE__*/jsx("div", {
+      className: t11,
+      "data-variant": responsiveVariant,
+      "data-position": position,
+      style: style,
+      children: t12
+    });
+    $[30] = position;
+    $[31] = responsiveVariant;
+    $[32] = style;
+    $[33] = t11;
+    $[34] = t12;
+    $[35] = t13;
+  } else {
+    t13 = $[35];
+  }
+  return t13;
+};
+
+// ----------------------------------------------------------------------------
+// PageLayout.Header
+
+const Header = t0 => {
+  const $ = c(26);
+  const {
+    "aria-label": label,
+    "aria-labelledby": labelledBy,
+    padding: t1,
+    divider: t2,
+    dividerWhenNarrow: t3,
+    hidden: t4,
+    children,
+    style,
+    className
+  } = t0;
+  const padding = t1 === undefined ? "none" : t1;
+  const divider = t2 === undefined ? "none" : t2;
+  const dividerWhenNarrow = t3 === undefined ? "inherit" : t3;
+  const hidden = t4 === undefined ? false : t4;
+  let t5;
+  if ($[0] !== divider || $[1] !== dividerWhenNarrow) {
+    t5 = !isResponsiveValue(divider) && dividerWhenNarrow !== "inherit" ? {
+      regular: divider,
+      narrow: dividerWhenNarrow
+    } : divider;
+    $[0] = divider;
+    $[1] = dividerWhenNarrow;
+    $[2] = t5;
+  } else {
+    t5 = $[2];
+  }
+  const dividerProp = t5;
+  const dividerVariant = useResponsiveValue(dividerProp, "none");
+  const isHidden = useResponsiveValue(hidden, false);
+  const {
+    rowGap
+  } = React.useContext(PageLayoutContext);
+  let t6;
+  if ($[3] !== className) {
+    t6 = clsx(classes.Header, className);
+    $[3] = className;
+    $[4] = t6;
+  } else {
+    t6 = $[4];
+  }
+  const t7 = `var(--spacing-${rowGap})`;
+  let t8;
+  if ($[5] !== style || $[6] !== t7) {
+    t8 = {
+      "--spacing": t7,
+      ...style
+    };
+    $[5] = style;
+    $[6] = t7;
+    $[7] = t8;
+  } else {
+    t8 = $[7];
+  }
+  const t9 = t8;
+  const t10 = `var(--spacing-${padding})`;
+  let t11;
+  if ($[8] !== t10) {
+    t11 = {
+      "--spacing": t10
+    };
+    $[8] = t10;
+    $[9] = t11;
+  } else {
+    t11 = $[9];
+  }
+  const t12 = t11;
+  let t13;
+  if ($[10] !== children || $[11] !== t12) {
+    t13 = /*#__PURE__*/jsx("div", {
+      className: classes.HeaderContent,
+      style: t12,
+      children: children
+    });
+    $[10] = children;
+    $[11] = t12;
+    $[12] = t13;
+  } else {
+    t13 = $[12];
+  }
+  const t14 = `var(--spacing-${rowGap})`;
+  let t15;
+  if ($[13] !== t14) {
+    t15 = {
+      "--spacing": t14
+    };
+    $[13] = t14;
+    $[14] = t15;
+  } else {
+    t15 = $[14];
+  }
+  const t16 = t15;
+  let t17;
+  if ($[15] !== dividerVariant || $[16] !== t16) {
+    t17 = /*#__PURE__*/jsx(HorizontalDivider, {
+      variant: dividerVariant,
+      className: classes.HeaderHorizontalDivider,
+      style: t16
+    });
+    $[15] = dividerVariant;
+    $[16] = t16;
+    $[17] = t17;
+  } else {
+    t17 = $[17];
+  }
+  let t18;
+  if ($[18] !== isHidden || $[19] !== label || $[20] !== labelledBy || $[21] !== t13 || $[22] !== t17 || $[23] !== t6 || $[24] !== t9) {
+    t18 = /*#__PURE__*/jsxs("header", {
+      "aria-label": label,
+      "aria-labelledby": labelledBy,
+      hidden: isHidden,
+      className: t6,
+      style: t9,
+      children: [t13, t17]
+    });
+    $[18] = isHidden;
+    $[19] = label;
+    $[20] = labelledBy;
+    $[21] = t13;
+    $[22] = t17;
+    $[23] = t6;
+    $[24] = t9;
+    $[25] = t18;
+  } else {
+    t18 = $[25];
+  }
+  return t18;
+};
+Header.displayName = 'PageLayout.Header';
+const Content = t0 => {
+  const $ = c(16);
+  const {
+    as: t1,
+    "aria-label": label,
+    "aria-labelledby": labelledBy,
+    width: t2,
+    padding: t3,
+    hidden: t4,
+    children,
+    className,
+    style
+  } = t0;
+  const as = t1 === undefined ? "main" : t1;
+  const width = t2 === undefined ? "full" : t2;
+  const padding = t3 === undefined ? "none" : t3;
+  const hidden = t4 === undefined ? false : t4;
+  const isHidden = useResponsiveValue(hidden, false);
+  const Component = as;
+  let t5;
+  if ($[0] !== className) {
+    t5 = clsx(classes.ContentWrapper, className);
+    $[0] = className;
+    $[1] = t5;
+  } else {
+    t5 = $[1];
+  }
+  const t6 = `var(--spacing-${padding})`;
+  let t7;
+  if ($[2] !== t6) {
+    t7 = {
+      "--spacing": t6
+    };
+    $[2] = t6;
+    $[3] = t7;
+  } else {
+    t7 = $[3];
+  }
+  const t8 = t7;
+  let t9;
+  if ($[4] !== children || $[5] !== t8 || $[6] !== width) {
+    t9 = /*#__PURE__*/jsx("div", {
+      className: classes.Content,
+      "data-width": width,
+      style: t8,
+      children: children
+    });
+    $[4] = children;
+    $[5] = t8;
+    $[6] = width;
+    $[7] = t9;
+  } else {
+    t9 = $[7];
+  }
+  let t10;
+  if ($[8] !== Component || $[9] !== isHidden || $[10] !== label || $[11] !== labelledBy || $[12] !== style || $[13] !== t5 || $[14] !== t9) {
+    t10 = /*#__PURE__*/jsx(Component, {
+      "aria-label": label,
+      "aria-labelledby": labelledBy,
+      style: style,
+      className: t5,
+      "data-is-hidden": isHidden,
+      children: t9
+    });
+    $[8] = Component;
+    $[9] = isHidden;
+    $[10] = label;
+    $[11] = labelledBy;
+    $[12] = style;
+    $[13] = t5;
+    $[14] = t9;
+    $[15] = t10;
+  } else {
+    t10 = $[15];
+  }
+  return t10;
+};
+Content.displayName = 'PageLayout.Content';
+
+// ----------------------------------------------------------------------------
+// PageLayout.Pane
+
+const isCustomWidthOptions = width => {
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  return width.default !== undefined;
+};
+const isPaneWidth = width => {
+  return ['small', 'medium', 'large'].includes(width);
+};
+const defaultPaneWidth = {
+  small: 256,
+  medium: 296,
+  large: 320
+};
+const overflowProps = {
+  tabIndex: 0,
+  role: 'region'
+};
+const Pane = /*#__PURE__*/React.forwardRef((t0, forwardRef) => {
+  const $ = c(81);
+  const {
+    "aria-label": label,
+    "aria-labelledby": labelledBy,
+    position: t1,
+    positionWhenNarrow: t2,
+    width: t3,
+    minWidth: t4,
+    padding: t5,
+    resizable: t6,
+    widthStorageKey: t7,
+    divider: t8,
+    dividerWhenNarrow: t9,
+    sticky: t10,
+    offsetHeader: t11,
+    hidden: t12,
+    children,
+    id,
+    className,
+    style
+  } = t0;
+  const responsivePosition = t1 === undefined ? "end" : t1;
+  const positionWhenNarrow = t2 === undefined ? "inherit" : t2;
+  const width = t3 === undefined ? "medium" : t3;
+  const minWidth = t4 === undefined ? 256 : t4;
+  const padding = t5 === undefined ? "none" : t5;
+  const resizable = t6 === undefined ? false : t6;
+  const widthStorageKey = t7 === undefined ? "paneWidth" : t7;
+  const responsiveDivider = t8 === undefined ? "none" : t8;
+  const dividerWhenNarrow = t9 === undefined ? "inherit" : t9;
+  const sticky = t10 === undefined ? false : t10;
+  const offsetHeader = t11 === undefined ? 0 : t11;
+  const responsiveHidden = t12 === undefined ? false : t12;
+  let t13;
+  if ($[0] !== positionWhenNarrow || $[1] !== responsivePosition) {
+    t13 = !isResponsiveValue(responsivePosition) && positionWhenNarrow !== "inherit" ? {
+      regular: responsivePosition,
+      narrow: positionWhenNarrow
+    } : responsivePosition;
+    $[0] = positionWhenNarrow;
+    $[1] = responsivePosition;
+    $[2] = t13;
+  } else {
+    t13 = $[2];
+  }
+  const positionProp = t13;
+  const position = useResponsiveValue(positionProp, "end");
+  let t14;
+  if ($[3] !== dividerWhenNarrow || $[4] !== responsiveDivider) {
+    t14 = !isResponsiveValue(responsiveDivider) && dividerWhenNarrow !== "inherit" ? {
+      regular: responsiveDivider,
+      narrow: dividerWhenNarrow
+    } : responsiveDivider;
+    $[3] = dividerWhenNarrow;
+    $[4] = responsiveDivider;
+    $[5] = t14;
+  } else {
+    t14 = $[5];
+  }
+  const dividerProp = t14;
+  const dividerVariant = useResponsiveValue(dividerProp, "none");
+  const isHidden = useResponsiveValue(responsiveHidden, false);
+  const {
+    rowGap,
+    columnGap,
+    paneRef
+  } = React.useContext(PageLayoutContext);
+  const getDefaultPaneWidth = _temp;
+  let t15;
+  if ($[6] !== width || $[7] !== widthStorageKey) {
+    t15 = () => {
+      if (!canUseDOM) {
+        return getDefaultPaneWidth(width);
+      }
+      let storedWidth;
+      try {
+        storedWidth = localStorage.getItem(widthStorageKey);
+      } catch (t16) {
+        storedWidth = null;
+      }
+      return storedWidth && !isNaN(Number(storedWidth)) ? Number(storedWidth) : getDefaultPaneWidth(width);
+    };
+    $[6] = width;
+    $[7] = widthStorageKey;
+    $[8] = t15;
+  } else {
+    t15 = $[8];
+  }
+  const [paneWidth, setPaneWidth] = React.useState(t15);
+  let t16;
+  if ($[9] !== widthStorageKey) {
+    t16 = width_1 => {
+      setPaneWidth(width_1);
+      try {
+        localStorage.setItem(widthStorageKey, width_1.toString());
+      } catch (t17) {
+      }
+    };
+    $[9] = widthStorageKey;
+    $[10] = t16;
+  } else {
+    t16 = $[10];
+  }
+  const updatePaneWidth = t16;
+  useRefObjectAsForwardedRef(forwardRef, paneRef);
+  const hasOverflow = useOverflow(paneRef);
+  const paneId = useId(id);
+  let labelProp;
+  if ($[11] !== hasOverflow || $[12] !== label || $[13] !== labelledBy) {
+    labelProp = {};
+    if (hasOverflow) {
+      process.env.NODE_ENV !== "production" ? warning(label === undefined && labelledBy === undefined, "The <PageLayout.Pane> has overflow and `aria-label` or `aria-labelledby` has not been set. Please provide `aria-label` or `aria-labelledby` to <PageLayout.Pane> in order to label this region.") : void 0;
+      if (labelledBy) {
+        labelProp["aria-labelledby"] = labelledBy;
+      } else {
+        if (label) {
+          labelProp["aria-label"] = label;
+        }
+      }
+    }
+    $[11] = hasOverflow;
+    $[12] = label;
+    $[13] = labelledBy;
+    $[14] = labelProp;
+  } else {
+    labelProp = $[14];
+  }
+  let t17;
+  if ($[15] !== className) {
+    t17 = clsx(classes.PaneWrapper, className);
+    $[15] = className;
+    $[16] = t17;
+  } else {
+    t17 = $[16];
+  }
+  const t18 = typeof offsetHeader === "number" ? `${offsetHeader}px` : offsetHeader;
+  const t19 = `var(--spacing-${rowGap})`;
+  const t20 = `var(--spacing-${columnGap})`;
+  let t21;
+  if ($[17] !== style || $[18] !== t18 || $[19] !== t19 || $[20] !== t20) {
+    t21 = {
+      "--offset-header": t18,
+      "--spacing-row": t19,
+      "--spacing-column": t20,
+      ...style
+    };
+    $[17] = style;
+    $[18] = t18;
+    $[19] = t19;
+    $[20] = t20;
+    $[21] = t21;
+  } else {
+    t21 = $[21];
+  }
+  const t22 = t21;
+  const t23 = sticky || undefined;
+  let t24;
+  if ($[22] !== dividerVariant) {
+    t24 = {
+      narrow: dividerVariant,
+      regular: "none"
+    };
+    $[22] = dividerVariant;
+    $[23] = t24;
+  } else {
+    t24 = $[23];
+  }
+  const t25 = `var(--spacing-${rowGap})`;
+  let t26;
+  if ($[24] !== t25) {
+    t26 = {
+      "--spacing": t25
+    };
+    $[24] = t25;
+    $[25] = t26;
+  } else {
+    t26 = $[25];
+  }
+  const t27 = t26;
+  let t28;
+  if ($[26] !== position || $[27] !== t24 || $[28] !== t27) {
+    t28 = /*#__PURE__*/jsx(HorizontalDivider, {
+      variant: t24,
+      className: classes.PaneHorizontalDivider,
+      style: t27,
+      position: position
+    });
+    $[26] = position;
+    $[27] = t24;
+    $[28] = t27;
+    $[29] = t28;
+  } else {
+    t28 = $[29];
+  }
+  let t29;
+  if ($[30] !== hasOverflow) {
+    t29 = hasOverflow ? overflowProps : {};
+    $[30] = hasOverflow;
+    $[31] = t29;
+  } else {
+    t29 = $[31];
+  }
+  let t30;
+  if ($[32] !== id || $[33] !== paneId) {
+    t30 = id && {
+      id: paneId
+    };
+    $[32] = id;
+    $[33] = paneId;
+    $[34] = t30;
+  } else {
+    t30 = $[34];
+  }
+  const t31 = resizable || undefined;
+  const t32 = `var(--spacing-${padding})`;
+  const t33 = isCustomWidthOptions(width) ? width.min : `${minWidth}px`;
+  const t34 = isCustomWidthOptions(width) ? width.max : "calc(100vw - var(--pane-max-width-diff))";
+  const t35 = isCustomWidthOptions(width) ? width.default : undefined;
+  const t36 = `var(--pane-width-${isPaneWidth(width) ? width : "custom"})`;
+  const t37 = `${paneWidth}px`;
+  let t38;
+  if ($[35] !== t32 || $[36] !== t33 || $[37] !== t34 || $[38] !== t35 || $[39] !== t36 || $[40] !== t37) {
+    t38 = {
+      "--spacing": t32,
+      "--pane-min-width": t33,
+      "--pane-max-width": t34,
+      "--pane-width-custom": t35,
+      "--pane-width-size": t36,
+      "--pane-width": t37
+    };
+    $[35] = t32;
+    $[36] = t33;
+    $[37] = t34;
+    $[38] = t35;
+    $[39] = t36;
+    $[40] = t37;
+    $[41] = t38;
+  } else {
+    t38 = $[41];
+  }
+  const t39 = t38;
+  let t40;
+  if ($[42] !== children || $[43] !== labelProp || $[44] !== paneRef || $[45] !== t29 || $[46] !== t30 || $[47] !== t31 || $[48] !== t39) {
+    t40 = /*#__PURE__*/jsx("div", {
+      ref: paneRef,
+      ...t29,
+      ...labelProp,
+      ...t30,
+      className: classes.Pane,
+      "data-resizable": t31,
+      style: t39,
+      children: children
+    });
+    $[42] = children;
+    $[43] = labelProp;
+    $[44] = paneRef;
+    $[45] = t29;
+    $[46] = t30;
+    $[47] = t31;
+    $[48] = t39;
+    $[49] = t40;
+  } else {
+    t40 = $[49];
+  }
+  const t41 = resizable ? "line" : dividerVariant;
+  let t42;
+  if ($[50] !== t41) {
+    t42 = {
+      narrow: "none",
+      regular: t41
+    };
+    $[50] = t41;
+    $[51] = t42;
+  } else {
+    t42 = $[51];
+  }
+  let t43;
+  if ($[52] !== paneWidth || $[53] !== position || $[54] !== updatePaneWidth) {
+    t43 = (delta, t44) => {
+      const isKeyboard = t44 === undefined ? false : t44;
+      let deltaWithDirection;
+      if (isKeyboard) {
+        deltaWithDirection = delta;
+      } else {
+        deltaWithDirection = position === "end" ? -delta : delta;
+      }
+      updatePaneWidth(paneWidth + deltaWithDirection);
+    };
+    $[52] = paneWidth;
+    $[53] = position;
+    $[54] = updatePaneWidth;
+    $[55] = t43;
+  } else {
+    t43 = $[55];
+  }
+  let t44;
+  if ($[56] !== paneRef || $[57] !== updatePaneWidth) {
+    t44 = () => {
+      var _paneRef$current;
+      const paneRect = (_paneRef$current = paneRef.current) === null || _paneRef$current === void 0 ? void 0 : _paneRef$current.getBoundingClientRect();
+      if (!paneRect) {
+        return;
+      }
+      updatePaneWidth(paneRect.width);
+    };
+    $[56] = paneRef;
+    $[57] = updatePaneWidth;
+    $[58] = t44;
+  } else {
+    t44 = $[58];
+  }
+  let t45;
+  if ($[59] !== updatePaneWidth || $[60] !== width) {
+    t45 = () => updatePaneWidth(getDefaultPaneWidth(width));
+    $[59] = updatePaneWidth;
+    $[60] = width;
+    $[61] = t45;
+  } else {
+    t45 = $[61];
+  }
+  const t46 = `var(--spacing-${columnGap})`;
+  let t47;
+  if ($[62] !== t46) {
+    t47 = {
+      "--spacing": t46
+    };
+    $[62] = t46;
+    $[63] = t47;
+  } else {
+    t47 = $[63];
+  }
+  const t48 = t47;
+  let t49;
+  if ($[64] !== position || $[65] !== resizable || $[66] !== t42 || $[67] !== t43 || $[68] !== t44 || $[69] !== t45 || $[70] !== t48) {
+    t49 = /*#__PURE__*/jsx(VerticalDivider, {
+      variant: t42,
+      draggable: resizable,
+      onDrag: t43,
+      onDragEnd: t44,
+      position: position,
+      onDoubleClick: t45,
+      className: classes.PaneVerticalDivider,
+      style: t48
+    });
+    $[64] = position;
+    $[65] = resizable;
+    $[66] = t42;
+    $[67] = t43;
+    $[68] = t44;
+    $[69] = t45;
+    $[70] = t48;
+    $[71] = t49;
+  } else {
+    t49 = $[71];
+  }
+  let t50;
+  if ($[72] !== isHidden || $[73] !== position || $[74] !== t17 || $[75] !== t22 || $[76] !== t23 || $[77] !== t28 || $[78] !== t40 || $[79] !== t49) {
+    t50 = /*#__PURE__*/jsxs("div", {
+      className: t17,
+      style: t22,
+      "data-is-hidden": isHidden,
+      "data-position": position,
+      "data-sticky": t23,
+      children: [t28, t40, t49]
+    });
+    $[72] = isHidden;
+    $[73] = position;
+    $[74] = t17;
+    $[75] = t22;
+    $[76] = t23;
+    $[77] = t28;
+    $[78] = t40;
+    $[79] = t49;
+    $[80] = t50;
+  } else {
+    t50 = $[80];
+  }
+  return t50;
+});
+Pane.displayName = 'PageLayout.Pane';
+
+// ----------------------------------------------------------------------------
+// PageLayout.Footer
+
+const Footer = t0 => {
+  const $ = c(26);
+  const {
+    "aria-label": label,
+    "aria-labelledby": labelledBy,
+    padding: t1,
+    divider: t2,
+    dividerWhenNarrow: t3,
+    hidden: t4,
+    children,
+    className,
+    style
+  } = t0;
+  const padding = t1 === undefined ? "none" : t1;
+  const divider = t2 === undefined ? "none" : t2;
+  const dividerWhenNarrow = t3 === undefined ? "inherit" : t3;
+  const hidden = t4 === undefined ? false : t4;
+  let t5;
+  if ($[0] !== divider || $[1] !== dividerWhenNarrow) {
+    t5 = !isResponsiveValue(divider) && dividerWhenNarrow !== "inherit" ? {
+      regular: divider,
+      narrow: dividerWhenNarrow
+    } : divider;
+    $[0] = divider;
+    $[1] = dividerWhenNarrow;
+    $[2] = t5;
+  } else {
+    t5 = $[2];
+  }
+  const dividerProp = t5;
+  const dividerVariant = useResponsiveValue(dividerProp, "none");
+  const isHidden = useResponsiveValue(hidden, false);
+  const {
+    rowGap
+  } = React.useContext(PageLayoutContext);
+  let t6;
+  if ($[3] !== className) {
+    t6 = clsx(classes.FooterWrapper, className);
+    $[3] = className;
+    $[4] = t6;
+  } else {
+    t6 = $[4];
+  }
+  const t7 = `var(--spacing-${rowGap})`;
+  let t8;
+  if ($[5] !== style || $[6] !== t7) {
+    t8 = {
+      "--spacing": t7,
+      ...style
+    };
+    $[5] = style;
+    $[6] = t7;
+    $[7] = t8;
+  } else {
+    t8 = $[7];
+  }
+  const t9 = t8;
+  const t10 = `var(--spacing-${rowGap})`;
+  let t11;
+  if ($[8] !== t10) {
+    t11 = {
+      "--spacing": t10
+    };
+    $[8] = t10;
+    $[9] = t11;
+  } else {
+    t11 = $[9];
+  }
+  const t12 = t11;
+  let t13;
+  if ($[10] !== dividerVariant || $[11] !== t12) {
+    t13 = /*#__PURE__*/jsx(HorizontalDivider, {
+      className: classes.FooterHorizontalDivider,
+      style: t12,
+      variant: dividerVariant
+    });
+    $[10] = dividerVariant;
+    $[11] = t12;
+    $[12] = t13;
+  } else {
+    t13 = $[12];
+  }
+  const t14 = `var(--spacing-${padding})`;
+  let t15;
+  if ($[13] !== t14) {
+    t15 = {
+      "--spacing": t14
+    };
+    $[13] = t14;
+    $[14] = t15;
+  } else {
+    t15 = $[14];
+  }
+  const t16 = t15;
+  let t17;
+  if ($[15] !== children || $[16] !== t16) {
+    t17 = /*#__PURE__*/jsx("div", {
+      className: classes.FooterContent,
+      style: t16,
+      children: children
+    });
+    $[15] = children;
+    $[16] = t16;
+    $[17] = t17;
+  } else {
+    t17 = $[17];
+  }
+  let t18;
+  if ($[18] !== isHidden || $[19] !== label || $[20] !== labelledBy || $[21] !== t13 || $[22] !== t17 || $[23] !== t6 || $[24] !== t9) {
+    t18 = /*#__PURE__*/jsxs("footer", {
+      "aria-label": label,
+      "aria-labelledby": labelledBy,
+      hidden: isHidden,
+      className: t6,
+      style: t9,
+      children: [t13, t17]
+    });
+    $[18] = isHidden;
+    $[19] = label;
+    $[20] = labelledBy;
+    $[21] = t13;
+    $[22] = t17;
+    $[23] = t6;
+    $[24] = t9;
+    $[25] = t18;
+  } else {
+    t18 = $[25];
+  }
+  return t18;
+};
+Footer.displayName = 'PageLayout.Footer';
+
+// ----------------------------------------------------------------------------
+// Export
+
+const PageLayout = Object.assign(Root, {
+  __SLOT__: Symbol('PageLayout'),
+  Header,
+  Content,
+  Pane: Pane,
+  Footer
+});
+Header.__SLOT__ = Symbol('PageLayout.Header');
+Content.__SLOT__ = Symbol('PageLayout.Content');
+Pane.__SLOT__ = Symbol('PageLayout.Pane');
+Footer.__SLOT__ = Symbol('PageLayout.Footer');
+function _temp(width_0) {
+  if (isPaneWidth(width_0)) {
+    return defaultPaneWidth[width_0];
+  } else {
+    if (isCustomWidthOptions(width_0)) {
+      return Number(width_0.default.split("px")[0]);
+    }
+  }
+  return 0;
+}
+
+export { PageLayout };