dune-react 0.0.1 → 0.0.2

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/navigation-menu/viewport/NavigationMenuViewport.js

@@ -0,0 +1,109 @@
+import * as React from "react";
+import { useIsoLayoutEffect } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useIsoLayoutEffect.js";
+import { useId } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useId.js";
+import { inertValue } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/inertValue.js";
+import { useRenderElement } from "../../utils/useRenderElement.js";
+import { useNavigationMenuRootContext } from "../root/NavigationMenuRootContext.js";
+import { FocusGuard } from "../../utils/FocusGuard.js";
+import { getEmptyRootContext } from "../../floating-ui-react/utils/getEmptyRootContext.js";
+import { useNavigationMenuPositionerContext } from "../positioner/NavigationMenuPositionerContext.js";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { contains } from "../../floating-ui-react/utils/element.js";
+import { isOutsideEvent, getNextTabbable, getPreviousTabbable } from "../../floating-ui-react/utils/tabbable.js";
+const EMPTY_ROOT_CONTEXT = getEmptyRootContext();
+function Guards({
+  children
+}) {
+  const {
+    beforeInsideRef,
+    beforeOutsideRef,
+    afterInsideRef,
+    afterOutsideRef,
+    positionerElement,
+    viewportElement,
+    floatingRootContext
+  } = useNavigationMenuRootContext();
+  const hasPositioner = Boolean(useNavigationMenuPositionerContext(true));
+  const referenceElement = positionerElement || viewportElement;
+  if (!floatingRootContext && !hasPositioner) {
+    return children;
+  }
+  return /* @__PURE__ */ jsxs(React.Fragment, {
+    children: [/* @__PURE__ */ jsx(FocusGuard, {
+      ref: beforeInsideRef,
+      onFocus: (event) => {
+        var _a, _b;
+        if (referenceElement && isOutsideEvent(event, referenceElement)) {
+          (_a = getNextTabbable(referenceElement)) == null ? void 0 : _a.focus();
+        } else {
+          (_b = beforeOutsideRef.current) == null ? void 0 : _b.focus();
+        }
+      }
+    }), children, /* @__PURE__ */ jsx(FocusGuard, {
+      ref: afterInsideRef,
+      onFocus: (event) => {
+        var _a, _b;
+        if (referenceElement && isOutsideEvent(event, referenceElement)) {
+          (_a = getPreviousTabbable(referenceElement)) == null ? void 0 : _a.focus();
+        } else {
+          (_b = afterOutsideRef.current) == null ? void 0 : _b.focus();
+        }
+      }
+    })]
+  });
+}
+const NavigationMenuViewport = /* @__PURE__ */ React.forwardRef(function NavigationMenuViewport2(componentProps, forwardedRef) {
+  const {
+    className,
+    render,
+    children,
+    id: idProp,
+    ...elementProps
+  } = componentProps;
+  const id = useId(idProp);
+  const {
+    setViewportElement,
+    setViewportTargetElement,
+    floatingRootContext,
+    prevTriggerElementRef,
+    viewportInert,
+    setViewportInert
+  } = useNavigationMenuRootContext();
+  const positioning = useNavigationMenuPositionerContext(true);
+  const hasPositioner = Boolean(positioning);
+  const domReference = (floatingRootContext || EMPTY_ROOT_CONTEXT).useState("domReferenceElement");
+  useIsoLayoutEffect(() => {
+    if (domReference) {
+      prevTriggerElementRef.current = domReference;
+    }
+  }, [domReference, prevTriggerElementRef]);
+  const element = useRenderElement("div", componentProps, {
+    ref: [forwardedRef, setViewportElement],
+    props: [{
+      id,
+      onBlur(event) {
+        const relatedTarget = event.relatedTarget;
+        const currentTarget = event.currentTarget;
+        if (relatedTarget && !contains(currentTarget, relatedTarget) && relatedTarget !== domReference) {
+          setViewportInert(true);
+        }
+      },
+      ...!hasPositioner && viewportInert && {
+        inert: inertValue(true)
+      },
+      children: hasPositioner ? children : /* @__PURE__ */ jsx(Guards, {
+        children: /* @__PURE__ */ jsx("div", {
+          ref: setViewportTargetElement,
+          children
+        })
+      })
+    }, elementProps]
+  });
+  return hasPositioner ? /* @__PURE__ */ jsx(Guards, {
+    children: element
+  }) : element;
+});
+if (process.env.NODE_ENV !== "production") NavigationMenuViewport.displayName = "NavigationMenuViewport";
+export {
+  NavigationMenuViewport
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/popover/description/PopoverDescription.js

@@ -0,0 +1,33 @@
+import * as React from "react";
+import { useIsoLayoutEffect } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useIsoLayoutEffect.js";
+import { usePopoverRootContext } from "../root/PopoverRootContext.js";
+import { useBaseUiId } from "../../utils/useBaseUiId.js";
+import { useRenderElement } from "../../utils/useRenderElement.js";
+const PopoverDescription = /* @__PURE__ */ React.forwardRef(function PopoverDescription2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    ...elementProps
+  } = componentProps;
+  const {
+    store
+  } = usePopoverRootContext();
+  const id = useBaseUiId(elementProps.id);
+  useIsoLayoutEffect(() => {
+    store.set("descriptionElementId", id);
+    return () => {
+      store.set("descriptionElementId", void 0);
+    };
+  }, [store, id]);
+  const element = useRenderElement("p", componentProps, {
+    ref: forwardedRef,
+    props: [{
+      id
+    }, elementProps]
+  });
+  return element;
+});
+if (process.env.NODE_ENV !== "production") PopoverDescription.displayName = "PopoverDescription";
+export {
+  PopoverDescription
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/popover/popup/PopoverPopup.js

@@ -0,0 +1,119 @@
+import * as React from "react";
+import { isHTMLElement } from "../../../../../../../@floating-ui_utils@0.2.11/node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.js";
+import { usePopoverRootContext } from "../root/PopoverRootContext.js";
+import { usePopoverPositionerContext } from "../positioner/PopoverPositionerContext.js";
+import { popupStateMapping } from "../../utils/popupStateMapping.js";
+import { transitionStatusMapping } from "../../utils/stateAttributesMapping.js";
+import { useOpenChangeComplete } from "../../utils/useOpenChangeComplete.js";
+import { useRenderElement } from "../../utils/useRenderElement.js";
+import { COMPOSITE_KEYS } from "../../composite/composite.js";
+import { useToolbarRootContext } from "../../toolbar/root/ToolbarRootContext.js";
+import { getDisabledMountTransitionStyles } from "../../utils/getDisabledMountTransitionStyles.js";
+import { useClosePartCount, ClosePartProvider } from "../../utils/closePart.js";
+import { jsx } from "react/jsx-runtime";
+import { useHoverFloatingInteraction } from "../../floating-ui-react/hooks/useHoverFloatingInteraction.js";
+import { FloatingFocusManager } from "../../floating-ui-react/components/FloatingFocusManager.js";
+import { triggerHover } from "../../utils/reason-parts.js";
+const stateAttributesMapping = {
+  ...popupStateMapping,
+  ...transitionStatusMapping
+};
+const PopoverPopup = /* @__PURE__ */ React.forwardRef(function PopoverPopup2(componentProps, forwardedRef) {
+  const {
+    className,
+    render,
+    initialFocus,
+    finalFocus,
+    ...elementProps
+  } = componentProps;
+  const {
+    store
+  } = usePopoverRootContext();
+  const positioner = usePopoverPositionerContext();
+  const insideToolbar = useToolbarRootContext() != null;
+  const {
+    context: closePartContext,
+    hasClosePart
+  } = useClosePartCount();
+  const open = store.useState("open");
+  const openMethod = store.useState("openMethod");
+  const instantType = store.useState("instantType");
+  const transitionStatus = store.useState("transitionStatus");
+  const popupProps = store.useState("popupProps");
+  const titleId = store.useState("titleElementId");
+  const descriptionId = store.useState("descriptionElementId");
+  const modal = store.useState("modal");
+  const mounted = store.useState("mounted");
+  const openReason = store.useState("openChangeReason");
+  const activeTriggerElement = store.useState("activeTriggerElement");
+  const floatingContext = store.useState("floatingRootContext");
+  useOpenChangeComplete({
+    open,
+    ref: store.context.popupRef,
+    onComplete() {
+      var _a, _b;
+      if (open) {
+        (_b = (_a = store.context).onOpenChangeComplete) == null ? void 0 : _b.call(_a, true);
+      }
+    }
+  });
+  const disabled = store.useState("disabled");
+  const openOnHover = store.useState("openOnHover");
+  const closeDelay = store.useState("closeDelay");
+  useHoverFloatingInteraction(floatingContext, {
+    enabled: openOnHover && !disabled,
+    closeDelay
+  });
+  function defaultInitialFocus(interactionType) {
+    if (interactionType === "touch") {
+      return store.context.popupRef.current;
+    }
+    return true;
+  }
+  const resolvedInitialFocus = initialFocus === void 0 ? defaultInitialFocus : initialFocus;
+  const state = {
+    open,
+    side: positioner.side,
+    align: positioner.align,
+    instant: instantType,
+    transitionStatus
+  };
+  const focusManagerModal = modal !== false && hasClosePart;
+  const setPopupElement = React.useCallback((element2) => {
+    store.set("popupElement", element2);
+  }, [store]);
+  const element = useRenderElement("div", componentProps, {
+    state,
+    ref: [forwardedRef, store.context.popupRef, setPopupElement],
+    props: [popupProps, {
+      "aria-labelledby": titleId,
+      "aria-describedby": descriptionId,
+      onKeyDown(event) {
+        if (insideToolbar && COMPOSITE_KEYS.has(event.key)) {
+          event.stopPropagation();
+        }
+      }
+    }, getDisabledMountTransitionStyles(transitionStatus), elementProps],
+    stateAttributesMapping
+  });
+  return /* @__PURE__ */ jsx(FloatingFocusManager, {
+    context: floatingContext,
+    openInteractionType: openMethod,
+    modal: focusManagerModal,
+    disabled: !mounted || openReason === triggerHover,
+    initialFocus: resolvedInitialFocus,
+    returnFocus: finalFocus,
+    restoreFocus: "popup",
+    previousFocusableElement: isHTMLElement(activeTriggerElement) ? activeTriggerElement : void 0,
+    nextFocusableElement: store.context.triggerFocusTargetRef,
+    beforeContentFocusGuardRef: store.context.beforeContentFocusGuardRef,
+    children: /* @__PURE__ */ jsx(ClosePartProvider, {
+      value: closePartContext,
+      children: element
+    })
+  });
+});
+if (process.env.NODE_ENV !== "production") PopoverPopup.displayName = "PopoverPopup";
+export {
+  PopoverPopup
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/popover/portal/PopoverPortal.js

@@ -0,0 +1,30 @@
+import * as React from "react";
+import { usePopoverRootContext } from "../root/PopoverRootContext.js";
+import { PopoverPortalContext } from "./PopoverPortalContext.js";
+import { jsx } from "react/jsx-runtime";
+import { FloatingPortal } from "../../floating-ui-react/components/FloatingPortal.js";
+const PopoverPortal = /* @__PURE__ */ React.forwardRef(function PopoverPortal2(props, forwardedRef) {
+  const {
+    keepMounted = false,
+    ...portalProps
+  } = props;
+  const {
+    store
+  } = usePopoverRootContext();
+  const mounted = store.useState("mounted");
+  const shouldRender = mounted || keepMounted;
+  if (!shouldRender) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(PopoverPortalContext.Provider, {
+    value: keepMounted,
+    children: /* @__PURE__ */ jsx(FloatingPortal, {
+      ref: forwardedRef,
+      ...portalProps
+    })
+  });
+});
+if (process.env.NODE_ENV !== "production") PopoverPortal.displayName = "PopoverPortal";
+export {
+  PopoverPortal
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/popover/portal/PopoverPortalContext.js

@@ -0,0 +1,15 @@
+import formatErrorMessage from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/formatErrorMessage.js";
+import * as React from "react";
+const PopoverPortalContext = /* @__PURE__ */ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") PopoverPortalContext.displayName = "PopoverPortalContext";
+function usePopoverPortalContext() {
+  const value = React.useContext(PopoverPortalContext);
+  if (value === void 0) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: <Popover.Portal> is missing." : formatErrorMessage(45));
+  }
+  return value;
+}
+export {
+  PopoverPortalContext,
+  usePopoverPortalContext
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/popover/positioner/PopoverPositioner.js

@@ -0,0 +1,140 @@
+import * as React from "react";
+import { inertValue } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/inertValue.js";
+import { useIsoLayoutEffect } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useIsoLayoutEffect.js";
+import { usePopoverRootContext } from "../root/PopoverRootContext.js";
+import { PopoverPositionerContext } from "./PopoverPositionerContext.js";
+import { useAnchorPositioning } from "../../utils/useAnchorPositioning.js";
+import { popupStateMapping } from "../../utils/popupStateMapping.js";
+import { usePopoverPortalContext } from "../portal/PopoverPortalContext.js";
+import { InternalBackdrop } from "../../utils/InternalBackdrop.js";
+import { useRenderElement } from "../../utils/useRenderElement.js";
+import { POPUP_COLLISION_AVOIDANCE } from "../../utils/constants.js";
+import { useAnimationsFinished } from "../../utils/useAnimationsFinished.js";
+import { adaptiveOrigin } from "../../utils/adaptiveOriginMiddleware.js";
+import { getDisabledMountTransitionStyles } from "../../utils/getDisabledMountTransitionStyles.js";
+import { jsxs, jsx } from "react/jsx-runtime";
+import { useFloatingNodeId, FloatingNode } from "../../floating-ui-react/components/FloatingTree.js";
+import { triggerHover } from "../../utils/reason-parts.js";
+const PopoverPositioner = /* @__PURE__ */ React.forwardRef(function PopoverPositioner2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    anchor,
+    positionMethod = "absolute",
+    side = "bottom",
+    align = "center",
+    sideOffset = 0,
+    alignOffset = 0,
+    collisionBoundary = "clipping-ancestors",
+    collisionPadding = 5,
+    arrowPadding = 5,
+    sticky = false,
+    disableAnchorTracking = false,
+    collisionAvoidance = POPUP_COLLISION_AVOIDANCE,
+    ...elementProps
+  } = componentProps;
+  const {
+    store
+  } = usePopoverRootContext();
+  const keepMounted = usePopoverPortalContext();
+  const nodeId = useFloatingNodeId();
+  const floatingRootContext = store.useState("floatingRootContext");
+  const mounted = store.useState("mounted");
+  const open = store.useState("open");
+  const openReason = store.useState("openChangeReason");
+  const triggerElement = store.useState("activeTriggerElement");
+  const modal = store.useState("modal");
+  const positionerElement = store.useState("positionerElement");
+  const instantType = store.useState("instantType");
+  const transitionStatus = store.useState("transitionStatus");
+  const hasViewport = store.useState("hasViewport");
+  const prevTriggerElementRef = React.useRef(null);
+  const runOnceAnimationsFinish = useAnimationsFinished(positionerElement, false, false);
+  const positioning = useAnchorPositioning({
+    anchor,
+    floatingRootContext,
+    positionMethod,
+    mounted,
+    side,
+    sideOffset,
+    align,
+    alignOffset,
+    arrowPadding,
+    collisionBoundary,
+    collisionPadding,
+    sticky,
+    disableAnchorTracking,
+    keepMounted,
+    nodeId,
+    collisionAvoidance,
+    adaptiveOrigin: hasViewport ? adaptiveOrigin : void 0
+  });
+  const defaultProps = React.useMemo(() => {
+    const hiddenStyles = {};
+    if (!open) {
+      hiddenStyles.pointerEvents = "none";
+    }
+    return {
+      role: "presentation",
+      hidden: !mounted,
+      style: {
+        ...positioning.positionerStyles,
+        ...hiddenStyles
+      }
+    };
+  }, [open, mounted, positioning.positionerStyles]);
+  const positioner = React.useMemo(() => ({
+    props: defaultProps,
+    ...positioning
+  }), [defaultProps, positioning]);
+  const domReference = floatingRootContext.useState("domReferenceElement");
+  useIsoLayoutEffect(() => {
+    const currentTriggerElement = domReference;
+    const prevTriggerElement = prevTriggerElementRef.current;
+    if (currentTriggerElement) {
+      prevTriggerElementRef.current = currentTriggerElement;
+    }
+    if (prevTriggerElement && currentTriggerElement && currentTriggerElement !== prevTriggerElement) {
+      store.set("instantType", void 0);
+      const ac = new AbortController();
+      runOnceAnimationsFinish(() => {
+        store.set("instantType", "trigger-change");
+      }, ac.signal);
+      return () => {
+        ac.abort();
+      };
+    }
+    return void 0;
+  }, [domReference, runOnceAnimationsFinish, store]);
+  const state = {
+    open,
+    side: positioner.side,
+    align: positioner.align,
+    anchorHidden: positioner.anchorHidden,
+    instant: instantType
+  };
+  const setPositionerElement = React.useCallback((element2) => {
+    store.set("positionerElement", element2);
+  }, [store]);
+  const element = useRenderElement("div", componentProps, {
+    state,
+    props: [positioner.props, getDisabledMountTransitionStyles(transitionStatus), elementProps],
+    ref: [forwardedRef, setPositionerElement],
+    stateAttributesMapping: popupStateMapping
+  });
+  return /* @__PURE__ */ jsxs(PopoverPositionerContext.Provider, {
+    value: positioner,
+    children: [mounted && modal === true && openReason !== triggerHover && /* @__PURE__ */ jsx(InternalBackdrop, {
+      ref: store.context.internalBackdropRef,
+      inert: inertValue(!open),
+      cutout: triggerElement
+    }), /* @__PURE__ */ jsx(FloatingNode, {
+      id: nodeId,
+      children: element
+    })]
+  });
+});
+if (process.env.NODE_ENV !== "production") PopoverPositioner.displayName = "PopoverPositioner";
+export {
+  PopoverPositioner
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/popover/positioner/PopoverPositionerContext.js

@@ -0,0 +1,15 @@
+import formatErrorMessage from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/formatErrorMessage.js";
+import * as React from "react";
+const PopoverPositionerContext = /* @__PURE__ */ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") PopoverPositionerContext.displayName = "PopoverPositionerContext";
+function usePopoverPositionerContext() {
+  const context = React.useContext(PopoverPositionerContext);
+  if (!context) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: PopoverPositionerContext is missing. PopoverPositioner parts must be placed within <Popover.Positioner>." : formatErrorMessage(46));
+  }
+  return context;
+}
+export {
+  PopoverPositionerContext,
+  usePopoverPositionerContext
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/popover/root/PopoverRoot.js

@@ -0,0 +1,146 @@
+import * as React from "react";
+import { useScrollLock } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useScrollLock.js";
+import { useOnFirstRender } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useOnFirstRender.js";
+import { usePopoverRootContext, PopoverRootContext } from "./PopoverRootContext.js";
+import { PopoverStore } from "../store/PopoverStore.js";
+import { createChangeEventDetails } from "../../utils/createBaseUIEventDetails.js";
+import { useOpenInteractionType } from "../../utils/useOpenInteractionType.js";
+import { jsx } from "react/jsx-runtime";
+import { FloatingTree, useFloatingParentNodeId } from "../../floating-ui-react/components/FloatingTree.js";
+import { useSyncedFloatingRootContext } from "../../floating-ui-react/hooks/useSyncedFloatingRootContext.js";
+import { useDismiss } from "../../floating-ui-react/hooks/useDismiss.js";
+import { useRole } from "../../floating-ui-react/hooks/useRole.js";
+import { useInteractions } from "../../floating-ui-react/hooks/useInteractions.js";
+import { useImplicitActiveTrigger, useOpenStateTransitions } from "../../utils/popups/popupStoreUtils.js";
+import { triggerHover, imperativeAction } from "../../utils/reason-parts.js";
+function PopoverRootComponent({
+  props
+}) {
+  const {
+    children,
+    open: openProp,
+    defaultOpen = false,
+    onOpenChange,
+    onOpenChangeComplete,
+    modal = false,
+    handle,
+    triggerId: triggerIdProp,
+    defaultTriggerId: defaultTriggerIdProp = null
+  } = props;
+  const store = PopoverStore.useStore(handle == null ? void 0 : handle.store, {
+    modal,
+    open: defaultOpen,
+    openProp,
+    activeTriggerId: defaultTriggerIdProp,
+    triggerIdProp
+  });
+  useOnFirstRender(() => {
+    if (openProp === void 0 && store.state.open === false && defaultOpen === true) {
+      store.update({
+        open: true,
+        activeTriggerId: defaultTriggerIdProp
+      });
+    }
+  });
+  store.useControlledProp("openProp", openProp);
+  store.useControlledProp("triggerIdProp", triggerIdProp);
+  const open = store.useState("open");
+  const positionerElement = store.useState("positionerElement");
+  const payload = store.useState("payload");
+  const openReason = store.useState("openChangeReason");
+  store.useContextCallback("onOpenChange", onOpenChange);
+  store.useContextCallback("onOpenChangeComplete", onOpenChangeComplete);
+  const {
+    openMethod,
+    triggerProps: interactionTypeTriggerProps
+  } = useOpenInteractionType(open);
+  useImplicitActiveTrigger(store);
+  const {
+    forceUnmount
+  } = useOpenStateTransitions(open, store, () => {
+    store.update({
+      stickIfOpen: true,
+      openChangeReason: null
+    });
+  });
+  useScrollLock(open && modal === true && openReason !== triggerHover && openMethod !== "touch", positionerElement);
+  React.useEffect(() => {
+    if (!open) {
+      store.context.stickIfOpenTimeout.clear();
+    }
+  }, [store, open]);
+  const createPopoverEventDetails = React.useCallback((reason) => {
+    const details = createChangeEventDetails(reason);
+    details.preventUnmountOnClose = () => {
+      store.set("preventUnmountingOnClose", true);
+    };
+    return details;
+  }, [store]);
+  const handleImperativeClose = React.useCallback(() => {
+    store.setOpen(false, createPopoverEventDetails(imperativeAction));
+  }, [store, createPopoverEventDetails]);
+  React.useImperativeHandle(props.actionsRef, () => ({
+    unmount: forceUnmount,
+    close: handleImperativeClose
+  }), [forceUnmount, handleImperativeClose]);
+  const floatingRootContext = useSyncedFloatingRootContext({
+    popupStore: store,
+    onOpenChange: store.setOpen
+  });
+  const dismiss = useDismiss(floatingRootContext, {
+    outsidePressEvent: {
+      // Ensure `aria-hidden` on outside elements is removed immediately
+      // on outside press when trapping focus.
+      mouse: modal === "trap-focus" ? "sloppy" : "intentional",
+      touch: "sloppy"
+    }
+  });
+  const role = useRole(floatingRootContext);
+  const {
+    getReferenceProps,
+    getFloatingProps,
+    getTriggerProps
+  } = useInteractions([dismiss, role]);
+  const activeTriggerProps = React.useMemo(() => {
+    return getReferenceProps(interactionTypeTriggerProps);
+  }, [getReferenceProps, interactionTypeTriggerProps]);
+  const inactiveTriggerProps = React.useMemo(() => {
+    return getTriggerProps(interactionTypeTriggerProps);
+  }, [getTriggerProps, interactionTypeTriggerProps]);
+  const popupProps = React.useMemo(() => {
+    return getFloatingProps();
+  }, [getFloatingProps]);
+  store.useSyncedValues({
+    modal,
+    openMethod,
+    activeTriggerProps,
+    inactiveTriggerProps,
+    popupProps,
+    floatingRootContext,
+    nested: useFloatingParentNodeId() != null
+  });
+  const popoverContext = React.useMemo(() => ({
+    store
+  }), [store]);
+  return /* @__PURE__ */ jsx(PopoverRootContext.Provider, {
+    value: popoverContext,
+    children: typeof children === "function" ? children({
+      payload
+    }) : children
+  });
+}
+function PopoverRoot(props) {
+  if (usePopoverRootContext(true)) {
+    return /* @__PURE__ */ jsx(PopoverRootComponent, {
+      props
+    });
+  }
+  return /* @__PURE__ */ jsx(FloatingTree, {
+    children: /* @__PURE__ */ jsx(PopoverRootComponent, {
+      props
+    })
+  });
+}
+export {
+  PopoverRoot
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/popover/root/PopoverRootContext.js

@@ -0,0 +1,15 @@
+import formatErrorMessage from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/formatErrorMessage.js";
+import * as React from "react";
+const PopoverRootContext = /* @__PURE__ */ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") PopoverRootContext.displayName = "PopoverRootContext";
+function usePopoverRootContext(optional) {
+  const context = React.useContext(PopoverRootContext);
+  if (context === void 0 && !optional) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: PopoverRootContext is missing. Popover parts must be placed within <Popover.Root>." : formatErrorMessage(47));
+  }
+  return context;
+}
+export {
+  PopoverRootContext,
+  usePopoverRootContext
+};