@neynar/ui 0.4.0 → 1.0.0

package/dist/node_modules/@base-ui/react/esm/utils/resolveStyle.js

@@ -0,0 +1,7 @@
+function resolveStyle(style, state) {
+  return typeof style === "function" ? style(state) : style;
+}
+export {
+  resolveStyle
+};
+//# sourceMappingURL=resolveStyle.js.map

package/dist/node_modules/@base-ui/react/esm/utils/resolveStyle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveStyle.js","sources":["../../../../../../node_modules/@base-ui/react/esm/utils/resolveStyle.js"],"sourcesContent":["/**\n * If the provided style is an object, it will be returned as is.\n * Otherwise, the function will call the style function with the state as the first argument.\n *\n * @param style\n * @param state\n */\nexport function resolveStyle(style, state) {\n  return typeof style === 'function' ? style(state) : style;\n}"],"names":[],"mappings":"AAOO,SAAS,aAAa,OAAO,OAAO;AACzC,SAAO,OAAO,UAAU,aAAa,MAAM,KAAK,IAAI;AACtD;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/utils/resolveValueLabel.js

@@ -0,0 +1,77 @@
+"use client";
+import { serializeValue } from "./serializeValue.js";
+function isGroupedItems(items) {
+  return items != null && items.length > 0 && typeof items[0] === "object" && items[0] != null && "items" in items[0];
+}
+function stringifyAsLabel(item, itemToStringLabel) {
+  if (itemToStringLabel && item != null) {
+    return itemToStringLabel(item) ?? "";
+  }
+  if (item && typeof item === "object") {
+    if ("label" in item && item.label != null) {
+      return String(item.label);
+    }
+    if ("value" in item) {
+      return String(item.value);
+    }
+  }
+  return serializeValue(item);
+}
+function stringifyAsValue(item, itemToStringValue) {
+  if (itemToStringValue && item != null) {
+    return itemToStringValue(item) ?? "";
+  }
+  if (item && typeof item === "object" && "value" in item && "label" in item) {
+    return serializeValue(item.value);
+  }
+  return serializeValue(item);
+}
+function resolveSelectedLabel(value, items, itemToStringLabel) {
+  if (itemToStringLabel && value != null) {
+    return itemToStringLabel(value);
+  }
+  if (value && typeof value === "object" && "label" in value && value.label != null) {
+    return value.label;
+  }
+  if (items && !Array.isArray(items)) {
+    return items[value] ?? stringifyAsLabel(value, itemToStringLabel);
+  }
+  if (Array.isArray(items)) {
+    const flatItems = isGroupedItems(items) ? items.flatMap((g) => g.items) : items;
+    if (value == null) {
+      const nullItem = flatItems.find((it) => it.value == null);
+      if (nullItem && nullItem.label != null) {
+        return nullItem.label;
+      }
+      return stringifyAsLabel(value, itemToStringLabel);
+    }
+    if (typeof value !== "object") {
+      const match = flatItems.find((it) => it && it.value === value);
+      if (match && match.label != null) {
+        return match.label;
+      }
+      return stringifyAsLabel(value, itemToStringLabel);
+    }
+    if ("value" in value) {
+      const match = flatItems.find((it) => it && it.value === value.value);
+      if (match && match.label != null) {
+        return match.label;
+      }
+    }
+  }
+  return stringifyAsLabel(value, itemToStringLabel);
+}
+function resolveMultipleLabels(values, itemToStringLabel) {
+  if (!Array.isArray(values) || values.length === 0) {
+    return "";
+  }
+  return values.map((v) => stringifyAsLabel(v, itemToStringLabel)).join(", ");
+}
+export {
+  isGroupedItems,
+  resolveMultipleLabels,
+  resolveSelectedLabel,
+  stringifyAsLabel,
+  stringifyAsValue
+};
+//# sourceMappingURL=resolveValueLabel.js.map

package/dist/node_modules/@base-ui/react/esm/utils/resolveValueLabel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveValueLabel.js","sources":["../../../../../../node_modules/@base-ui/react/esm/utils/resolveValueLabel.js"],"sourcesContent":["'use client';\n\nimport { serializeValue } from \"./serializeValue.js\";\nexport function isGroupedItems(items) {\n  return items != null && items.length > 0 && typeof items[0] === 'object' && items[0] != null && 'items' in items[0];\n}\nexport function stringifyAsLabel(item, itemToStringLabel) {\n  if (itemToStringLabel && item != null) {\n    return itemToStringLabel(item) ?? '';\n  }\n  if (item && typeof item === 'object') {\n    if ('label' in item && item.label != null) {\n      return String(item.label);\n    }\n    if ('value' in item) {\n      return String(item.value);\n    }\n  }\n  return serializeValue(item);\n}\nexport function stringifyAsValue(item, itemToStringValue) {\n  if (itemToStringValue && item != null) {\n    return itemToStringValue(item) ?? '';\n  }\n  if (item && typeof item === 'object' && 'value' in item && 'label' in item) {\n    return serializeValue(item.value);\n  }\n  return serializeValue(item);\n}\nexport function resolveSelectedLabel(value, items, itemToStringLabel) {\n  if (itemToStringLabel && value != null) {\n    return itemToStringLabel(value);\n  }\n\n  // Custom object with explicit label takes precedence\n  if (value && typeof value === 'object' && 'label' in value && value.label != null) {\n    return value.label;\n  }\n\n  // Items provided as plain record map\n  if (items && !Array.isArray(items)) {\n    return items[value] ?? stringifyAsLabel(value, itemToStringLabel);\n  }\n\n  // Items provided as array (flat or grouped)\n  if (Array.isArray(items)) {\n    const flatItems = isGroupedItems(items) ? items.flatMap(g => g.items) : items;\n\n    // If no value selected, prefer the null option label when available\n    if (value == null) {\n      const nullItem = flatItems.find(it => it.value == null);\n      if (nullItem && nullItem.label != null) {\n        return nullItem.label;\n      }\n      return stringifyAsLabel(value, itemToStringLabel);\n    }\n\n    // Primitive selected value: map to first matching item's label\n    if (typeof value !== 'object') {\n      const match = flatItems.find(it => it && it.value === value);\n      if (match && match.label != null) {\n        return match.label;\n      }\n      return stringifyAsLabel(value, itemToStringLabel);\n    }\n\n    // Object without explicit label: try matching by its `value` property\n    if ('value' in value) {\n      const match = flatItems.find(it => it && it.value === value.value);\n      if (match && match.label != null) {\n        return match.label;\n      }\n    }\n  }\n  return stringifyAsLabel(value, itemToStringLabel);\n}\nexport function resolveMultipleLabels(values, itemToStringLabel) {\n  if (!Array.isArray(values) || values.length === 0) {\n    return '';\n  }\n  return values.map(v => stringifyAsLabel(v, itemToStringLabel)).join(', ');\n}"],"names":[],"mappings":";;AAGO;AACL;AACF;AACO;AACL;AACE;AAAkC;AAEpC;AACE;AACE;AAAwB;AAE1B;AACE;AAAwB;AAC1B;AAEF;AACF;AACO;AACL;AACE;AAAkC;AAEpC;AACE;AAAgC;AAElC;AACF;AACO;AACL;AACE;AAA8B;AAIhC;AACE;AAAa;AAIf;AACE;AAAgE;AAIlE;AACE;AAGA;AACE;AACA;AACE;AAAgB;AAElB;AAAgD;AAIlD;AACE;AACA;AACE;AAAa;AAEf;AAAgD;AAIlD;AACE;AACA;AACE;AAAa;AACf;AACF;AAEF;AACF;AACO;AACL;AACE;AAAO;AAET;AACF;;;;;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/utils/serializeValue.js

@@ -0,0 +1,17 @@
+function serializeValue(value) {
+  if (value == null) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+export {
+  serializeValue
+};
+//# sourceMappingURL=serializeValue.js.map

package/dist/node_modules/@base-ui/react/esm/utils/serializeValue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializeValue.js","sources":["../../../../../../node_modules/@base-ui/react/esm/utils/serializeValue.js"],"sourcesContent":["export function serializeValue(value) {\n  if (value == null) {\n    return '';\n  }\n  if (typeof value === 'string') {\n    return value;\n  }\n  try {\n    return JSON.stringify(value);\n  } catch {\n    return String(value);\n  }\n}"],"names":[],"mappings":"AAAO,SAAS,eAAe,OAAO;AACpC,MAAI,SAAS,MAAM;AACjB,WAAO;AAAA,EACT;AACA,MAAI,OAAO,UAAU,UAAU;AAC7B,WAAO;AAAA,EACT;AACA,MAAI;AACF,WAAO,KAAK,UAAU,KAAK;AAAA,EAC7B,QAAQ;AACN,WAAO,OAAO,KAAK;AAAA,EACrB;AACF;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/utils/stateAttributesMapping.js

@@ -0,0 +1,27 @@
+let TransitionStatusDataAttributes = /* @__PURE__ */ (function(TransitionStatusDataAttributes2) {
+  TransitionStatusDataAttributes2["startingStyle"] = "data-starting-style";
+  TransitionStatusDataAttributes2["endingStyle"] = "data-ending-style";
+  return TransitionStatusDataAttributes2;
+})({});
+const STARTING_HOOK = {
+  [TransitionStatusDataAttributes.startingStyle]: ""
+};
+const ENDING_HOOK = {
+  [TransitionStatusDataAttributes.endingStyle]: ""
+};
+const transitionStatusMapping = {
+  transitionStatus(value) {
+    if (value === "starting") {
+      return STARTING_HOOK;
+    }
+    if (value === "ending") {
+      return ENDING_HOOK;
+    }
+    return null;
+  }
+};
+export {
+  TransitionStatusDataAttributes,
+  transitionStatusMapping
+};
+//# sourceMappingURL=stateAttributesMapping.js.map

package/dist/node_modules/@base-ui/react/esm/utils/stateAttributesMapping.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stateAttributesMapping.js","sources":["../../../../../../node_modules/@base-ui/react/esm/utils/stateAttributesMapping.js"],"sourcesContent":["export let TransitionStatusDataAttributes = /*#__PURE__*/function (TransitionStatusDataAttributes) {\n  /**\n   * Present when the component is animating in.\n   */\n  TransitionStatusDataAttributes[\"startingStyle\"] = \"data-starting-style\";\n  /**\n   * Present when the component is animating out.\n   */\n  TransitionStatusDataAttributes[\"endingStyle\"] = \"data-ending-style\";\n  return TransitionStatusDataAttributes;\n}({});\nconst STARTING_HOOK = {\n  [TransitionStatusDataAttributes.startingStyle]: ''\n};\nconst ENDING_HOOK = {\n  [TransitionStatusDataAttributes.endingStyle]: ''\n};\nexport const transitionStatusMapping = {\n  transitionStatus(value) {\n    if (value === 'starting') {\n      return STARTING_HOOK;\n    }\n    if (value === 'ending') {\n      return ENDING_HOOK;\n    }\n    return null;\n  }\n};"],"names":["TransitionStatusDataAttributes"],"mappings":"AAAU,IAAC,iCAA8C,0BAAUA,iCAAgC;AAIjG,EAAAA,gCAA+B,eAAe,IAAI;AAIlD,EAAAA,gCAA+B,aAAa,IAAI;AAChD,SAAOA;AACT,GAAE,CAAA,CAAE;AACJ,MAAM,gBAAgB;AAAA,EACpB,CAAC,+BAA+B,aAAa,GAAG;AAClD;AACA,MAAM,cAAc;AAAA,EAClB,CAAC,+BAA+B,WAAW,GAAG;AAChD;AACY,MAAC,0BAA0B;AAAA,EACrC,iBAAiB,OAAO;AACtB,QAAI,UAAU,YAAY;AACxB,aAAO;AAAA,IACT;AACA,QAAI,UAAU,UAAU;AACtB,aAAO;AAAA,IACT;AACA,WAAO;AAAA,EACT;AACF;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/utils/styles.js

@@ -0,0 +1,14 @@
+import { jsx } from "react/jsx-runtime";
+const DISABLE_SCROLLBAR_CLASS_NAME = "base-ui-disable-scrollbar";
+const styleDisableScrollbar = {
+  className: DISABLE_SCROLLBAR_CLASS_NAME,
+  element: /* @__PURE__ */ jsx("style", {
+    href: DISABLE_SCROLLBAR_CLASS_NAME,
+    precedence: "base-ui:low",
+    children: `.${DISABLE_SCROLLBAR_CLASS_NAME}{scrollbar-width:none}.${DISABLE_SCROLLBAR_CLASS_NAME}::-webkit-scrollbar{display:none}`
+  })
+};
+export {
+  styleDisableScrollbar
+};
+//# sourceMappingURL=styles.js.map

package/dist/node_modules/@base-ui/react/esm/utils/styles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles.js","sources":["../../../../../../node_modules/@base-ui/react/esm/utils/styles.js"],"sourcesContent":["import { jsx as _jsx } from \"react/jsx-runtime\";\nconst DISABLE_SCROLLBAR_CLASS_NAME = 'base-ui-disable-scrollbar';\nexport const styleDisableScrollbar = {\n  className: DISABLE_SCROLLBAR_CLASS_NAME,\n  element: /*#__PURE__*/_jsx(\"style\", {\n    href: DISABLE_SCROLLBAR_CLASS_NAME,\n    precedence: \"base-ui:low\",\n    children: `.${DISABLE_SCROLLBAR_CLASS_NAME}{scrollbar-width:none}.${DISABLE_SCROLLBAR_CLASS_NAME}::-webkit-scrollbar{display:none}`\n  })\n};"],"names":["_jsx"],"mappings":";AACA,MAAM,+BAA+B;AACzB,MAAC,wBAAwB;AAAA,EACnC,WAAW;AAAA,EACX,SAAsBA,oBAAK,SAAS;AAAA,IAClC,MAAM;AAAA,IACN,YAAY;AAAA,IACZ,UAAU,IAAI,4BAA4B,0BAA0B,4BAA4B;AAAA,EACpG,CAAG;AACH;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/utils/useAnchorPositioning.js

@@ -0,0 +1,360 @@
+"use client";
+import * as React from "react";
+import { getSide, getSideAxis, getAlignment } from "../../../../@floating-ui/utils/dist/floating-ui.utils.js";
+import { ownerDocument } from "../../../utils/esm/owner.js";
+import { useIsoLayoutEffect } from "../../../utils/esm/useIsoLayoutEffect.js";
+import { useValueAsRef } from "../../../utils/esm/useValueAsRef.js";
+import { useStableCallback } from "../../../utils/esm/useStableCallback.js";
+import { useDirection } from "../direction-provider/DirectionContext.js";
+import { arrow } from "../floating-ui-react/middleware/arrow.js";
+import { hide } from "./hideMiddleware.js";
+import { DEFAULT_SIDES } from "./adaptiveOriginMiddleware.js";
+import { flip, offset, size, shift, limitShift } from "../../../../@floating-ui/react-dom/dist/floating-ui.react-dom.js";
+import { useFloating } from "../floating-ui-react/hooks/useFloating.js";
+import { autoUpdate } from "../../../../@floating-ui/dom/dist/floating-ui.dom.js";
+function getLogicalSide(sideParam, renderedSide, isRtl) {
+  const isLogicalSideParam = sideParam === "inline-start" || sideParam === "inline-end";
+  const logicalRight = isRtl ? "inline-start" : "inline-end";
+  const logicalLeft = isRtl ? "inline-end" : "inline-start";
+  return {
+    top: "top",
+    right: isLogicalSideParam ? logicalRight : "right",
+    bottom: "bottom",
+    left: isLogicalSideParam ? logicalLeft : "left"
+  }[renderedSide];
+}
+function getOffsetData(state, sideParam, isRtl) {
+  const {
+    rects,
+    placement
+  } = state;
+  const data = {
+    side: getLogicalSide(sideParam, getSide(placement), isRtl),
+    align: getAlignment(placement) || "center",
+    anchor: {
+      width: rects.reference.width,
+      height: rects.reference.height
+    },
+    positioner: {
+      width: rects.floating.width,
+      height: rects.floating.height
+    }
+  };
+  return data;
+}
+function useAnchorPositioning(params) {
+  const {
+    // Public parameters
+    anchor,
+    positionMethod = "absolute",
+    side: sideParam = "bottom",
+    sideOffset = 0,
+    align = "center",
+    alignOffset = 0,
+    collisionBoundary,
+    collisionPadding: collisionPaddingParam = 5,
+    sticky = false,
+    arrowPadding = 5,
+    disableAnchorTracking = false,
+    // Private parameters
+    keepMounted = false,
+    floatingRootContext,
+    mounted,
+    collisionAvoidance,
+    shiftCrossAxis = false,
+    nodeId,
+    adaptiveOrigin,
+    lazyFlip = false,
+    externalTree
+  } = params;
+  const [mountSide, setMountSide] = React.useState(null);
+  if (!mounted && mountSide !== null) {
+    setMountSide(null);
+  }
+  const collisionAvoidanceSide = collisionAvoidance.side || "flip";
+  const collisionAvoidanceAlign = collisionAvoidance.align || "flip";
+  const collisionAvoidanceFallbackAxisSide = collisionAvoidance.fallbackAxisSide || "end";
+  const anchorFn = typeof anchor === "function" ? anchor : void 0;
+  const anchorFnCallback = useStableCallback(anchorFn);
+  const anchorDep = anchorFn ? anchorFnCallback : anchor;
+  const anchorValueRef = useValueAsRef(anchor);
+  const direction = useDirection();
+  const isRtl = direction === "rtl";
+  const side = mountSide || {
+    top: "top",
+    right: "right",
+    bottom: "bottom",
+    left: "left",
+    "inline-end": isRtl ? "left" : "right",
+    "inline-start": isRtl ? "right" : "left"
+  }[sideParam];
+  const placement = align === "center" ? side : `${side}-${align}`;
+  let collisionPadding = collisionPaddingParam;
+  const bias = 1;
+  const biasTop = sideParam === "bottom" ? bias : 0;
+  const biasBottom = sideParam === "top" ? bias : 0;
+  const biasLeft = sideParam === "right" ? bias : 0;
+  const biasRight = sideParam === "left" ? bias : 0;
+  if (typeof collisionPadding === "number") {
+    collisionPadding = {
+      top: collisionPadding + biasTop,
+      right: collisionPadding + biasRight,
+      bottom: collisionPadding + biasBottom,
+      left: collisionPadding + biasLeft
+    };
+  } else if (collisionPadding) {
+    collisionPadding = {
+      top: (collisionPadding.top || 0) + biasTop,
+      right: (collisionPadding.right || 0) + biasRight,
+      bottom: (collisionPadding.bottom || 0) + biasBottom,
+      left: (collisionPadding.left || 0) + biasLeft
+    };
+  }
+  const commonCollisionProps = {
+    boundary: collisionBoundary === "clipping-ancestors" ? "clippingAncestors" : collisionBoundary,
+    padding: collisionPadding
+  };
+  const arrowRef = React.useRef(null);
+  const sideOffsetRef = useValueAsRef(sideOffset);
+  const alignOffsetRef = useValueAsRef(alignOffset);
+  const sideOffsetDep = typeof sideOffset !== "function" ? sideOffset : 0;
+  const alignOffsetDep = typeof alignOffset !== "function" ? alignOffset : 0;
+  const middleware = [offset((state) => {
+    const data = getOffsetData(state, sideParam, isRtl);
+    const sideAxis = typeof sideOffsetRef.current === "function" ? sideOffsetRef.current(data) : sideOffsetRef.current;
+    const alignAxis = typeof alignOffsetRef.current === "function" ? alignOffsetRef.current(data) : alignOffsetRef.current;
+    return {
+      mainAxis: sideAxis,
+      crossAxis: alignAxis,
+      alignmentAxis: alignAxis
+    };
+  }, [sideOffsetDep, alignOffsetDep, isRtl, sideParam])];
+  const shiftDisabled = collisionAvoidanceAlign === "none" && collisionAvoidanceSide !== "shift";
+  const crossAxisShiftEnabled = !shiftDisabled && (sticky || shiftCrossAxis || collisionAvoidanceSide === "shift");
+  const flipMiddleware = collisionAvoidanceSide === "none" ? null : flip({
+    ...commonCollisionProps,
+    // Ensure the popup flips if it's been limited by its --available-height and it resizes.
+    // Since the size() padding is smaller than the flip() padding, flip() will take precedence.
+    padding: {
+      top: collisionPadding.top + bias,
+      right: collisionPadding.right + bias,
+      bottom: collisionPadding.bottom + bias,
+      left: collisionPadding.left + bias
+    },
+    mainAxis: !shiftCrossAxis && collisionAvoidanceSide === "flip",
+    crossAxis: collisionAvoidanceAlign === "flip" ? "alignment" : false,
+    fallbackAxisSideDirection: collisionAvoidanceFallbackAxisSide
+  });
+  const shiftMiddleware = shiftDisabled ? null : shift((data) => {
+    const html = ownerDocument(data.elements.floating).documentElement;
+    return {
+      ...commonCollisionProps,
+      // Use the Layout Viewport to avoid shifting around when pinch-zooming
+      // for context menus.
+      rootBoundary: shiftCrossAxis ? {
+        x: 0,
+        y: 0,
+        width: html.clientWidth,
+        height: html.clientHeight
+      } : void 0,
+      mainAxis: collisionAvoidanceAlign !== "none",
+      crossAxis: crossAxisShiftEnabled,
+      limiter: sticky || shiftCrossAxis ? void 0 : limitShift((limitData) => {
+        if (!arrowRef.current) {
+          return {};
+        }
+        const {
+          width,
+          height
+        } = arrowRef.current.getBoundingClientRect();
+        const sideAxis = getSideAxis(getSide(limitData.placement));
+        const arrowSize = sideAxis === "y" ? width : height;
+        const offsetAmount = sideAxis === "y" ? collisionPadding.left + collisionPadding.right : collisionPadding.top + collisionPadding.bottom;
+        return {
+          offset: arrowSize / 2 + offsetAmount / 2
+        };
+      })
+    };
+  }, [commonCollisionProps, sticky, shiftCrossAxis, collisionPadding, collisionAvoidanceAlign]);
+  if (collisionAvoidanceSide === "shift" || collisionAvoidanceAlign === "shift" || align === "center") {
+    middleware.push(shiftMiddleware, flipMiddleware);
+  } else {
+    middleware.push(flipMiddleware, shiftMiddleware);
+  }
+  middleware.push(size({
+    ...commonCollisionProps,
+    apply({
+      elements: {
+        floating
+      },
+      rects: {
+        reference
+      },
+      availableWidth,
+      availableHeight
+    }) {
+      Object.entries({
+        "--available-width": `${availableWidth}px`,
+        "--available-height": `${availableHeight}px`,
+        "--anchor-width": `${reference.width}px`,
+        "--anchor-height": `${reference.height}px`
+      }).forEach(([key, value]) => {
+        floating.style.setProperty(key, value);
+      });
+    }
+  }), arrow(() => ({
+    // `transform-origin` calculations rely on an element existing. If the arrow hasn't been set,
+    // we'll create a fake element.
+    element: arrowRef.current || document.createElement("div"),
+    padding: arrowPadding,
+    offsetParent: "floating"
+  }), [arrowPadding]), {
+    name: "transformOrigin",
+    fn(state) {
+      const {
+        elements: elements2,
+        middlewareData: middlewareData2,
+        placement: renderedPlacement2,
+        rects,
+        y: y2
+      } = state;
+      const currentRenderedSide = getSide(renderedPlacement2);
+      const currentRenderedAxis = getSideAxis(currentRenderedSide);
+      const arrowEl = arrowRef.current;
+      const arrowX = middlewareData2.arrow?.x || 0;
+      const arrowY = middlewareData2.arrow?.y || 0;
+      const arrowWidth = arrowEl?.clientWidth || 0;
+      const arrowHeight = arrowEl?.clientHeight || 0;
+      const transformX = arrowX + arrowWidth / 2;
+      const transformY = arrowY + arrowHeight / 2;
+      const shiftY = Math.abs(middlewareData2.shift?.y || 0);
+      const halfAnchorHeight = rects.reference.height / 2;
+      const sideOffsetValue = typeof sideOffset === "function" ? sideOffset(getOffsetData(state, sideParam, isRtl)) : sideOffset;
+      const isOverlappingAnchor = shiftY > sideOffsetValue;
+      const adjacentTransformOrigin = {
+        top: `${transformX}px calc(100% + ${sideOffsetValue}px)`,
+        bottom: `${transformX}px ${-sideOffsetValue}px`,
+        left: `calc(100% + ${sideOffsetValue}px) ${transformY}px`,
+        right: `${-sideOffsetValue}px ${transformY}px`
+      }[currentRenderedSide];
+      const overlapTransformOrigin = `${transformX}px ${rects.reference.y + halfAnchorHeight - y2}px`;
+      elements2.floating.style.setProperty("--transform-origin", crossAxisShiftEnabled && currentRenderedAxis === "y" && isOverlappingAnchor ? overlapTransformOrigin : adjacentTransformOrigin);
+      return {};
+    }
+  }, hide, adaptiveOrigin);
+  useIsoLayoutEffect(() => {
+    if (!mounted && floatingRootContext) {
+      floatingRootContext.update({
+        referenceElement: null,
+        floatingElement: null,
+        domReferenceElement: null
+      });
+    }
+  }, [mounted, floatingRootContext]);
+  const autoUpdateOptions = React.useMemo(() => ({
+    elementResize: !disableAnchorTracking && typeof ResizeObserver !== "undefined",
+    layoutShift: !disableAnchorTracking && typeof IntersectionObserver !== "undefined"
+  }), [disableAnchorTracking]);
+  const {
+    refs,
+    elements,
+    x,
+    y,
+    middlewareData,
+    update,
+    placement: renderedPlacement,
+    context,
+    isPositioned,
+    floatingStyles: originalFloatingStyles
+  } = useFloating({
+    rootContext: floatingRootContext,
+    placement,
+    middleware,
+    strategy: positionMethod,
+    whileElementsMounted: keepMounted ? void 0 : (...args) => autoUpdate(...args, autoUpdateOptions),
+    nodeId,
+    externalTree
+  });
+  const {
+    sideX,
+    sideY
+  } = middlewareData.adaptiveOrigin || DEFAULT_SIDES;
+  const resolvedPosition = isPositioned ? positionMethod : "fixed";
+  const floatingStyles = React.useMemo(() => adaptiveOrigin ? {
+    position: resolvedPosition,
+    [sideX]: x,
+    [sideY]: y
+  } : {
+    position: resolvedPosition,
+    ...originalFloatingStyles
+  }, [adaptiveOrigin, resolvedPosition, sideX, x, sideY, y, originalFloatingStyles]);
+  const registeredPositionReferenceRef = React.useRef(null);
+  useIsoLayoutEffect(() => {
+    if (!mounted) {
+      return;
+    }
+    const anchorValue = anchorValueRef.current;
+    const resolvedAnchor = typeof anchorValue === "function" ? anchorValue() : anchorValue;
+    const unwrappedElement = (isRef(resolvedAnchor) ? resolvedAnchor.current : resolvedAnchor) || null;
+    const finalAnchor = unwrappedElement || null;
+    if (finalAnchor !== registeredPositionReferenceRef.current) {
+      refs.setPositionReference(finalAnchor);
+      registeredPositionReferenceRef.current = finalAnchor;
+    }
+  }, [mounted, refs, anchorDep, anchorValueRef]);
+  React.useEffect(() => {
+    if (!mounted) {
+      return;
+    }
+    const anchorValue = anchorValueRef.current;
+    if (typeof anchorValue === "function") {
+      return;
+    }
+    if (isRef(anchorValue) && anchorValue.current !== registeredPositionReferenceRef.current) {
+      refs.setPositionReference(anchorValue.current);
+      registeredPositionReferenceRef.current = anchorValue.current;
+    }
+  }, [mounted, refs, anchorDep, anchorValueRef]);
+  React.useEffect(() => {
+    if (keepMounted && mounted && elements.domReference && elements.floating) {
+      return autoUpdate(elements.domReference, elements.floating, update, autoUpdateOptions);
+    }
+    return void 0;
+  }, [keepMounted, mounted, elements, update, autoUpdateOptions]);
+  const renderedSide = getSide(renderedPlacement);
+  const logicalRenderedSide = getLogicalSide(sideParam, renderedSide, isRtl);
+  const renderedAlign = getAlignment(renderedPlacement) || "center";
+  const anchorHidden = Boolean(middlewareData.hide?.referenceHidden);
+  useIsoLayoutEffect(() => {
+    if (lazyFlip && mounted && isPositioned) {
+      setMountSide(renderedSide);
+    }
+  }, [lazyFlip, mounted, isPositioned, renderedSide]);
+  const arrowStyles = React.useMemo(() => ({
+    position: "absolute",
+    top: middlewareData.arrow?.y,
+    left: middlewareData.arrow?.x
+  }), [middlewareData.arrow]);
+  const arrowUncentered = middlewareData.arrow?.centerOffset !== 0;
+  return React.useMemo(() => ({
+    positionerStyles: floatingStyles,
+    arrowStyles,
+    arrowRef,
+    arrowUncentered,
+    side: logicalRenderedSide,
+    align: renderedAlign,
+    physicalSide: renderedSide,
+    anchorHidden,
+    refs,
+    context,
+    isPositioned,
+    update
+  }), [floatingStyles, arrowStyles, arrowRef, arrowUncentered, logicalRenderedSide, renderedAlign, renderedSide, anchorHidden, refs, context, isPositioned, update]);
+}
+function isRef(param) {
+  return param != null && "current" in param;
+}
+export {
+  useAnchorPositioning
+};
+//# sourceMappingURL=useAnchorPositioning.js.map

package/dist/node_modules/@base-ui/react/esm/utils/useAnchorPositioning.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAnchorPositioning.js","sources":["../../../../../../node_modules/@base-ui/react/esm/utils/useAnchorPositioning.js"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nimport { getSide, getAlignment, getSideAxis } from '@floating-ui/utils';\nimport { ownerDocument } from '@base-ui/utils/owner';\nimport { useIsoLayoutEffect } from '@base-ui/utils/useIsoLayoutEffect';\nimport { useValueAsRef } from '@base-ui/utils/useValueAsRef';\nimport { useStableCallback } from '@base-ui/utils/useStableCallback';\nimport { autoUpdate, flip, limitShift, offset, shift, useFloating, size } from \"../floating-ui-react/index.js\";\nimport { useDirection } from \"../direction-provider/DirectionContext.js\";\nimport { arrow } from \"../floating-ui-react/middleware/arrow.js\";\nimport { hide } from \"./hideMiddleware.js\";\nimport { DEFAULT_SIDES } from \"./adaptiveOriginMiddleware.js\";\nfunction getLogicalSide(sideParam, renderedSide, isRtl) {\n  const isLogicalSideParam = sideParam === 'inline-start' || sideParam === 'inline-end';\n  const logicalRight = isRtl ? 'inline-start' : 'inline-end';\n  const logicalLeft = isRtl ? 'inline-end' : 'inline-start';\n  return {\n    top: 'top',\n    right: isLogicalSideParam ? logicalRight : 'right',\n    bottom: 'bottom',\n    left: isLogicalSideParam ? logicalLeft : 'left'\n  }[renderedSide];\n}\nfunction getOffsetData(state, sideParam, isRtl) {\n  const {\n    rects,\n    placement\n  } = state;\n  const data = {\n    side: getLogicalSide(sideParam, getSide(placement), isRtl),\n    align: getAlignment(placement) || 'center',\n    anchor: {\n      width: rects.reference.width,\n      height: rects.reference.height\n    },\n    positioner: {\n      width: rects.floating.width,\n      height: rects.floating.height\n    }\n  };\n  return data;\n}\n/**\n * Provides standardized anchor positioning behavior for floating elements. Wraps Floating UI's\n * `useFloating` hook.\n */\nexport function useAnchorPositioning(params) {\n  const {\n    // Public parameters\n    anchor,\n    positionMethod = 'absolute',\n    side: sideParam = 'bottom',\n    sideOffset = 0,\n    align = 'center',\n    alignOffset = 0,\n    collisionBoundary,\n    collisionPadding: collisionPaddingParam = 5,\n    sticky = false,\n    arrowPadding = 5,\n    disableAnchorTracking = false,\n    // Private parameters\n    keepMounted = false,\n    floatingRootContext,\n    mounted,\n    collisionAvoidance,\n    shiftCrossAxis = false,\n    nodeId,\n    adaptiveOrigin,\n    lazyFlip = false,\n    externalTree\n  } = params;\n  const [mountSide, setMountSide] = React.useState(null);\n  if (!mounted && mountSide !== null) {\n    setMountSide(null);\n  }\n  const collisionAvoidanceSide = collisionAvoidance.side || 'flip';\n  const collisionAvoidanceAlign = collisionAvoidance.align || 'flip';\n  const collisionAvoidanceFallbackAxisSide = collisionAvoidance.fallbackAxisSide || 'end';\n  const anchorFn = typeof anchor === 'function' ? anchor : undefined;\n  const anchorFnCallback = useStableCallback(anchorFn);\n  const anchorDep = anchorFn ? anchorFnCallback : anchor;\n  const anchorValueRef = useValueAsRef(anchor);\n  const direction = useDirection();\n  const isRtl = direction === 'rtl';\n  const side = mountSide || {\n    top: 'top',\n    right: 'right',\n    bottom: 'bottom',\n    left: 'left',\n    'inline-end': isRtl ? 'left' : 'right',\n    'inline-start': isRtl ? 'right' : 'left'\n  }[sideParam];\n  const placement = align === 'center' ? side : `${side}-${align}`;\n  let collisionPadding = collisionPaddingParam;\n\n  // Create a bias to the preferred side.\n  // On iOS, when the mobile software keyboard opens, the input is exactly centered\n  // in the viewport, but this can cause it to flip to the top undesirably.\n  const bias = 1;\n  const biasTop = sideParam === 'bottom' ? bias : 0;\n  const biasBottom = sideParam === 'top' ? bias : 0;\n  const biasLeft = sideParam === 'right' ? bias : 0;\n  const biasRight = sideParam === 'left' ? bias : 0;\n  if (typeof collisionPadding === 'number') {\n    collisionPadding = {\n      top: collisionPadding + biasTop,\n      right: collisionPadding + biasRight,\n      bottom: collisionPadding + biasBottom,\n      left: collisionPadding + biasLeft\n    };\n  } else if (collisionPadding) {\n    collisionPadding = {\n      top: (collisionPadding.top || 0) + biasTop,\n      right: (collisionPadding.right || 0) + biasRight,\n      bottom: (collisionPadding.bottom || 0) + biasBottom,\n      left: (collisionPadding.left || 0) + biasLeft\n    };\n  }\n  const commonCollisionProps = {\n    boundary: collisionBoundary === 'clipping-ancestors' ? 'clippingAncestors' : collisionBoundary,\n    padding: collisionPadding\n  };\n\n  // Using a ref assumes that the arrow element is always present in the DOM for the lifetime of the\n  // popup. If this assumption ends up being false, we can switch to state to manage the arrow's\n  // presence.\n  const arrowRef = React.useRef(null);\n\n  // Keep these reactive if they're not functions\n  const sideOffsetRef = useValueAsRef(sideOffset);\n  const alignOffsetRef = useValueAsRef(alignOffset);\n  const sideOffsetDep = typeof sideOffset !== 'function' ? sideOffset : 0;\n  const alignOffsetDep = typeof alignOffset !== 'function' ? alignOffset : 0;\n  const middleware = [offset(state => {\n    const data = getOffsetData(state, sideParam, isRtl);\n    const sideAxis = typeof sideOffsetRef.current === 'function' ? sideOffsetRef.current(data) : sideOffsetRef.current;\n    const alignAxis = typeof alignOffsetRef.current === 'function' ? alignOffsetRef.current(data) : alignOffsetRef.current;\n    return {\n      mainAxis: sideAxis,\n      crossAxis: alignAxis,\n      alignmentAxis: alignAxis\n    };\n  }, [sideOffsetDep, alignOffsetDep, isRtl, sideParam])];\n  const shiftDisabled = collisionAvoidanceAlign === 'none' && collisionAvoidanceSide !== 'shift';\n  const crossAxisShiftEnabled = !shiftDisabled && (sticky || shiftCrossAxis || collisionAvoidanceSide === 'shift');\n  const flipMiddleware = collisionAvoidanceSide === 'none' ? null : flip({\n    ...commonCollisionProps,\n    // Ensure the popup flips if it's been limited by its --available-height and it resizes.\n    // Since the size() padding is smaller than the flip() padding, flip() will take precedence.\n    padding: {\n      top: collisionPadding.top + bias,\n      right: collisionPadding.right + bias,\n      bottom: collisionPadding.bottom + bias,\n      left: collisionPadding.left + bias\n    },\n    mainAxis: !shiftCrossAxis && collisionAvoidanceSide === 'flip',\n    crossAxis: collisionAvoidanceAlign === 'flip' ? 'alignment' : false,\n    fallbackAxisSideDirection: collisionAvoidanceFallbackAxisSide\n  });\n  const shiftMiddleware = shiftDisabled ? null : shift(data => {\n    const html = ownerDocument(data.elements.floating).documentElement;\n    return {\n      ...commonCollisionProps,\n      // Use the Layout Viewport to avoid shifting around when pinch-zooming\n      // for context menus.\n      rootBoundary: shiftCrossAxis ? {\n        x: 0,\n        y: 0,\n        width: html.clientWidth,\n        height: html.clientHeight\n      } : undefined,\n      mainAxis: collisionAvoidanceAlign !== 'none',\n      crossAxis: crossAxisShiftEnabled,\n      limiter: sticky || shiftCrossAxis ? undefined : limitShift(limitData => {\n        if (!arrowRef.current) {\n          return {};\n        }\n        const {\n          width,\n          height\n        } = arrowRef.current.getBoundingClientRect();\n        const sideAxis = getSideAxis(getSide(limitData.placement));\n        const arrowSize = sideAxis === 'y' ? width : height;\n        const offsetAmount = sideAxis === 'y' ? collisionPadding.left + collisionPadding.right : collisionPadding.top + collisionPadding.bottom;\n        return {\n          offset: arrowSize / 2 + offsetAmount / 2\n        };\n      })\n    };\n  }, [commonCollisionProps, sticky, shiftCrossAxis, collisionPadding, collisionAvoidanceAlign]);\n\n  // https://floating-ui.com/docs/flip#combining-with-shift\n  if (collisionAvoidanceSide === 'shift' || collisionAvoidanceAlign === 'shift' || align === 'center') {\n    middleware.push(shiftMiddleware, flipMiddleware);\n  } else {\n    middleware.push(flipMiddleware, shiftMiddleware);\n  }\n  middleware.push(size({\n    ...commonCollisionProps,\n    apply({\n      elements: {\n        floating\n      },\n      rects: {\n        reference\n      },\n      availableWidth,\n      availableHeight\n    }) {\n      Object.entries({\n        '--available-width': `${availableWidth}px`,\n        '--available-height': `${availableHeight}px`,\n        '--anchor-width': `${reference.width}px`,\n        '--anchor-height': `${reference.height}px`\n      }).forEach(([key, value]) => {\n        floating.style.setProperty(key, value);\n      });\n    }\n  }), arrow(() => ({\n    // `transform-origin` calculations rely on an element existing. If the arrow hasn't been set,\n    // we'll create a fake element.\n    element: arrowRef.current || document.createElement('div'),\n    padding: arrowPadding,\n    offsetParent: 'floating'\n  }), [arrowPadding]), {\n    name: 'transformOrigin',\n    fn(state) {\n      const {\n        elements,\n        middlewareData,\n        placement: renderedPlacement,\n        rects,\n        y\n      } = state;\n      const currentRenderedSide = getSide(renderedPlacement);\n      const currentRenderedAxis = getSideAxis(currentRenderedSide);\n      const arrowEl = arrowRef.current;\n      const arrowX = middlewareData.arrow?.x || 0;\n      const arrowY = middlewareData.arrow?.y || 0;\n      const arrowWidth = arrowEl?.clientWidth || 0;\n      const arrowHeight = arrowEl?.clientHeight || 0;\n      const transformX = arrowX + arrowWidth / 2;\n      const transformY = arrowY + arrowHeight / 2;\n      const shiftY = Math.abs(middlewareData.shift?.y || 0);\n      const halfAnchorHeight = rects.reference.height / 2;\n      const sideOffsetValue = typeof sideOffset === 'function' ? sideOffset(getOffsetData(state, sideParam, isRtl)) : sideOffset;\n      const isOverlappingAnchor = shiftY > sideOffsetValue;\n      const adjacentTransformOrigin = {\n        top: `${transformX}px calc(100% + ${sideOffsetValue}px)`,\n        bottom: `${transformX}px ${-sideOffsetValue}px`,\n        left: `calc(100% + ${sideOffsetValue}px) ${transformY}px`,\n        right: `${-sideOffsetValue}px ${transformY}px`\n      }[currentRenderedSide];\n      const overlapTransformOrigin = `${transformX}px ${rects.reference.y + halfAnchorHeight - y}px`;\n      elements.floating.style.setProperty('--transform-origin', crossAxisShiftEnabled && currentRenderedAxis === 'y' && isOverlappingAnchor ? overlapTransformOrigin : adjacentTransformOrigin);\n      return {};\n    }\n  }, hide, adaptiveOrigin);\n  useIsoLayoutEffect(() => {\n    // Ensure positioning doesn't run initially for `keepMounted` elements that\n    // aren't initially open.\n    if (!mounted && floatingRootContext) {\n      floatingRootContext.update({\n        referenceElement: null,\n        floatingElement: null,\n        domReferenceElement: null\n      });\n    }\n  }, [mounted, floatingRootContext]);\n  const autoUpdateOptions = React.useMemo(() => ({\n    elementResize: !disableAnchorTracking && typeof ResizeObserver !== 'undefined',\n    layoutShift: !disableAnchorTracking && typeof IntersectionObserver !== 'undefined'\n  }), [disableAnchorTracking]);\n  const {\n    refs,\n    elements,\n    x,\n    y,\n    middlewareData,\n    update,\n    placement: renderedPlacement,\n    context,\n    isPositioned,\n    floatingStyles: originalFloatingStyles\n  } = useFloating({\n    rootContext: floatingRootContext,\n    placement,\n    middleware,\n    strategy: positionMethod,\n    whileElementsMounted: keepMounted ? undefined : (...args) => autoUpdate(...args, autoUpdateOptions),\n    nodeId,\n    externalTree\n  });\n  const {\n    sideX,\n    sideY\n  } = middlewareData.adaptiveOrigin || DEFAULT_SIDES;\n\n  // Default to `fixed` when not positioned to prevent `autoFocus` scroll jumps.\n  // This ensures the popup is inside the viewport initially before it gets positioned.\n  const resolvedPosition = isPositioned ? positionMethod : 'fixed';\n  const floatingStyles = React.useMemo(() => adaptiveOrigin ? {\n    position: resolvedPosition,\n    [sideX]: x,\n    [sideY]: y\n  } : {\n    position: resolvedPosition,\n    ...originalFloatingStyles\n  }, [adaptiveOrigin, resolvedPosition, sideX, x, sideY, y, originalFloatingStyles]);\n  const registeredPositionReferenceRef = React.useRef(null);\n  useIsoLayoutEffect(() => {\n    if (!mounted) {\n      return;\n    }\n    const anchorValue = anchorValueRef.current;\n    const resolvedAnchor = typeof anchorValue === 'function' ? anchorValue() : anchorValue;\n    const unwrappedElement = (isRef(resolvedAnchor) ? resolvedAnchor.current : resolvedAnchor) || null;\n    const finalAnchor = unwrappedElement || null;\n    if (finalAnchor !== registeredPositionReferenceRef.current) {\n      refs.setPositionReference(finalAnchor);\n      registeredPositionReferenceRef.current = finalAnchor;\n    }\n  }, [mounted, refs, anchorDep, anchorValueRef]);\n  React.useEffect(() => {\n    if (!mounted) {\n      return;\n    }\n    const anchorValue = anchorValueRef.current;\n\n    // Refs from parent components are set after useLayoutEffect runs and are available in useEffect.\n    // Therefore, if the anchor is a ref, we need to update the position reference in useEffect.\n    if (typeof anchorValue === 'function') {\n      return;\n    }\n    if (isRef(anchorValue) && anchorValue.current !== registeredPositionReferenceRef.current) {\n      refs.setPositionReference(anchorValue.current);\n      registeredPositionReferenceRef.current = anchorValue.current;\n    }\n  }, [mounted, refs, anchorDep, anchorValueRef]);\n  React.useEffect(() => {\n    if (keepMounted && mounted && elements.domReference && elements.floating) {\n      return autoUpdate(elements.domReference, elements.floating, update, autoUpdateOptions);\n    }\n    return undefined;\n  }, [keepMounted, mounted, elements, update, autoUpdateOptions]);\n  const renderedSide = getSide(renderedPlacement);\n  const logicalRenderedSide = getLogicalSide(sideParam, renderedSide, isRtl);\n  const renderedAlign = getAlignment(renderedPlacement) || 'center';\n  const anchorHidden = Boolean(middlewareData.hide?.referenceHidden);\n\n  /**\n   * Locks the flip (makes it \"sticky\") so it doesn't prefer a given placement\n   * and flips back lazily, not eagerly. Ideal for filtered lists that change\n   * the size of the popup dynamically to avoid unwanted flipping when typing.\n   */\n  useIsoLayoutEffect(() => {\n    if (lazyFlip && mounted && isPositioned) {\n      setMountSide(renderedSide);\n    }\n  }, [lazyFlip, mounted, isPositioned, renderedSide]);\n  const arrowStyles = React.useMemo(() => ({\n    position: 'absolute',\n    top: middlewareData.arrow?.y,\n    left: middlewareData.arrow?.x\n  }), [middlewareData.arrow]);\n  const arrowUncentered = middlewareData.arrow?.centerOffset !== 0;\n  return React.useMemo(() => ({\n    positionerStyles: floatingStyles,\n    arrowStyles,\n    arrowRef,\n    arrowUncentered,\n    side: logicalRenderedSide,\n    align: renderedAlign,\n    physicalSide: renderedSide,\n    anchorHidden,\n    refs,\n    context,\n    isPositioned,\n    update\n  }), [floatingStyles, arrowStyles, arrowRef, arrowUncentered, logicalRenderedSide, renderedAlign, renderedSide, anchorHidden, refs, context, isPositioned, update]);\n}\nfunction isRef(param) {\n  return param != null && 'current' in param;\n}"],"names":[],"mappings":";;;;;;;;;;;;;;AAaA;AACE;AACA;AACA;AACA;AAAO;AACA;AACsC;AACnC;AACiC;AAE7C;AACA;AACE;AAAM;AACJ;AACA;AAEF;AAAa;AAC8C;AACvB;AAC1B;AACiB;AACC;AAC9B;AACgB;AACY;AACC;AAC7B;AAEE;AACF;AAKO;AACL;AAAM;AAAA;AAEJ;AACiB;AACC;AACL;AACL;AACM;AACd;AAC0C;AACjC;AACM;AACS;AAAA;AAEV;AACd;AACA;AACA;AACiB;AACjB;AACA;AACW;AACX;AAEF;AACA;AACE;AAAiB;AAEnB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAA0B;AACnB;AACE;AACC;AACF;AACyB;AACG;AAEpC;AACA;AAKA;AACA;AACA;AACA;AACA;AACA;AACE;AAAmB;AACO;AACE;AACC;AACF;AAC/B;AAEI;AAAmB;AACkB;AACI;AACE;AACJ;AAC3C;AAEE;AAA6B;AACkD;AACpE;AAMX;AAGA;AACA;AACA;AACA;AACA;AACE;AACA;AACA;AACA;AAAO;AACK;AACC;AACI;AACrB;AAEE;AACA;AACA;AAAuE;AAClE;AAAA;AAAA;AAGM;AACqB;AACI;AACE;AACJ;AACpC;AAC4D;AACM;AACnC;AAE7B;AACE;AACA;AAAO;AACF;AAAA;AAAA;AAG4B;AAC1B;AACA;AACS;AACC;AACX;AACkC;AAC3B;AAET;AACE;AAAO;AAET;AAAM;AACJ;AACA;AAEF;AACA;AACA;AACA;AAAO;AACkC;AACjD;AACO;AACP;AAIE;AACE;AAA+C;AAE/C;AAA+C;AAEjD;AAAqB;AAChB;AACG;AACM;AACR;AACR;AACa;AACL;AACR;AACM;AACA;AAEA;AAAe;AACyB;AACE;AACJ;AACE;AAEtC;AAAqC;AACtC;AACH;AACe;AAAA;AAAA;AAG0C;AAChD;AACK;AACK;AACb;AAEJ;AAAM;AACJ;AACA;AACW;AACX;AACA;AAEF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAgC;AACqB;AACR;AACU;AACX;AAE5C;AACA;AACA;AAAO;AACT;AAEF;AAGE;AACE;AAA2B;AACP;AACD;AACI;AACtB;AACH;AAEF;AAA+C;AACsB;AACI;AAEzE;AAAM;AACJ;AACA;AACA;AACA;AACA;AACA;AACW;AACX;AACA;AACgB;AACF;AACD;AACb;AACA;AACU;AACwF;AAClG;AACA;AAEF;AAAM;AACJ;AACA;AAKF;AACA;AAA4D;AAChD;AACD;AACA;AACP;AACQ;AACP;AAEL;AACA;AACE;AACE;AAAA;AAEF;AACA;AACA;AACA;AACA;AACE;AACA;AAAyC;AAC3C;AAEF;AACE;AACE;AAAA;AAEF;AAIA;AACE;AAAA;AAEF;AACE;AACA;AAAqD;AACvD;AAEF;AACE;AACE;AAAqF;AAEvF;AAAO;AAET;AACA;AACA;AACA;AAOA;AACE;AACE;AAAyB;AAC3B;AAEF;AAAyC;AAC7B;AACiB;AACC;AAE9B;AACA;AAA4B;AACR;AAClB;AACA;AACA;AACM;AACC;AACO;AACd;AACA;AACA;AACA;AACA;AAEJ;AACA;AACE;AACF;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/utils/useAnimationsFinished.js

@@ -0,0 +1,50 @@
+"use client";
+import * as ReactDOM from "react-dom";
+import { useAnimationFrame } from "../../../utils/esm/useAnimationFrame.js";
+import { useStableCallback } from "../../../utils/esm/useStableCallback.js";
+import { resolveRef } from "./resolveRef.js";
+function useAnimationsFinished(elementOrRef, waitForNextTick = false, treatAbortedAsFinished = true) {
+  const frame = useAnimationFrame();
+  return useStableCallback((fnToExecute, signal = null) => {
+    frame.cancel();
+    const element = resolveRef(elementOrRef);
+    if (element == null) {
+      return;
+    }
+    if (typeof element.getAnimations !== "function" || globalThis.BASE_UI_ANIMATIONS_DISABLED) {
+      fnToExecute();
+    } else {
+      frame.request(() => {
+        function exec() {
+          if (!element) {
+            return;
+          }
+          Promise.all(element.getAnimations().map((anim) => anim.finished)).then(() => {
+            if (signal != null && signal.aborted) {
+              return;
+            }
+            ReactDOM.flushSync(fnToExecute);
+          }).catch(() => {
+            if (treatAbortedAsFinished) {
+              if (signal != null && signal.aborted) {
+                return;
+              }
+              ReactDOM.flushSync(fnToExecute);
+            } else if (element.getAnimations().length > 0 && element.getAnimations().some((anim) => anim.pending || anim.playState !== "finished")) {
+              exec();
+            }
+          });
+        }
+        if (waitForNextTick) {
+          frame.request(exec);
+        } else {
+          exec();
+        }
+      });
+    }
+  });
+}
+export {
+  useAnimationsFinished
+};
+//# sourceMappingURL=useAnimationsFinished.js.map

package/dist/node_modules/@base-ui/react/esm/utils/useAnimationsFinished.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAnimationsFinished.js","sources":["../../../../../../node_modules/@base-ui/react/esm/utils/useAnimationsFinished.js"],"sourcesContent":["'use client';\n\nimport * as ReactDOM from 'react-dom';\nimport { useAnimationFrame } from '@base-ui/utils/useAnimationFrame';\nimport { useStableCallback } from '@base-ui/utils/useStableCallback';\nimport { resolveRef } from \"./resolveRef.js\";\n\n/**\n * Executes a function once all animations have finished on the provided element.\n * @param elementOrRef - The element to watch for animations.\n * @param waitForNextTick - Whether to wait for the next tick before checking for animations.\n * @param treatAbortedAsFinished - Whether to treat aborted animations as finished. If `false`, and there are aborted animations,\n *   the function will check again if any new animations have started and wait for them to finish.\n * @returns A function that takes a callback to execute once all animations have finished, and an optional AbortSignal to abort the callback\n */\nexport function useAnimationsFinished(elementOrRef, waitForNextTick = false, treatAbortedAsFinished = true) {\n  const frame = useAnimationFrame();\n  return useStableCallback((fnToExecute,\n  /**\n   * An optional [AbortSignal](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) that\n   * can be used to abort `fnToExecute` before all the animations have finished.\n   * @default null\n   */\n  signal = null) => {\n    frame.cancel();\n    const element = resolveRef(elementOrRef);\n    if (element == null) {\n      return;\n    }\n    if (typeof element.getAnimations !== 'function' || globalThis.BASE_UI_ANIMATIONS_DISABLED) {\n      fnToExecute();\n    } else {\n      frame.request(() => {\n        function exec() {\n          if (!element) {\n            return;\n          }\n          Promise.all(element.getAnimations().map(anim => anim.finished)).then(() => {\n            if (signal != null && signal.aborted) {\n              return;\n            }\n\n            // Synchronously flush the unmounting of the component so that the browser doesn't\n            // paint: https://github.com/mui/base-ui/issues/979\n            ReactDOM.flushSync(fnToExecute);\n          }).catch(() => {\n            if (treatAbortedAsFinished) {\n              if (signal != null && signal.aborted) {\n                return;\n              }\n              ReactDOM.flushSync(fnToExecute);\n            } else if (element.getAnimations().length > 0 && element.getAnimations().some(anim => anim.pending || anim.playState !== 'finished')) {\n              // Sometimes animations can be aborted because a property they depend on changes while the animation plays.\n              // In such cases, we need to re-check if any new animations have started.\n              exec();\n            }\n          });\n        }\n\n        // `open: true` animations need to wait for the next tick to be detected\n        if (waitForNextTick) {\n          frame.request(exec);\n        } else {\n          exec();\n        }\n      });\n    }\n  });\n}"],"names":[],"mappings":";;;;;AAeO;AACL;AACA;AAOE;AACA;AACA;AACE;AAAA;AAEF;AACE;AAAW;AAEX;AACE;AACE;AACE;AAAA;AAEF;AACE;AACE;AAAA;AAKF;AAA8B;AAE9B;AACE;AACE;AAAA;AAEF;AAA8B;AAI9B;AAAI;AACN;AACD;AAIH;AACE;AAAkB;AAElB;AAAI;AACN;AACD;AACH;AAEJ;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/utils/useBaseUiId.js

@@ -0,0 +1,9 @@
+"use client";
+import { useId } from "../../../utils/esm/useId.js";
+function useBaseUiId(idOverride) {
+  return useId(idOverride, "base-ui");
+}
+export {
+  useBaseUiId
+};
+//# sourceMappingURL=useBaseUiId.js.map

package/dist/node_modules/@base-ui/react/esm/utils/useBaseUiId.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBaseUiId.js","sources":["../../../../../../node_modules/@base-ui/react/esm/utils/useBaseUiId.js"],"sourcesContent":["'use client';\n\nimport { useId } from '@base-ui/utils/useId';\n\n/**\n * Wraps `useId` and prefixes generated `id`s with `base-ui-`\n * @param {string | undefined} idOverride overrides the generated id when provided\n * @returns {string | undefined}\n */\nexport function useBaseUiId(idOverride) {\n  return useId(idOverride, 'base-ui');\n}"],"names":[],"mappings":";;AASO;AACL;AACF;;;;","x_google_ignoreList":[0]}