@base-ui/react 1.4.1 → 1.5.0

package/utils/popups/popupStoreUtils.js

@@ -5,15 +5,51 @@ var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWild
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.FOCUSABLE_POPUP_PROPS = void 0;
+exports.setOpenTriggerState = setOpenTriggerState;
 exports.useImplicitActiveTrigger = useImplicitActiveTrigger;
 exports.useOpenStateTransitions = useOpenStateTransitions;
+exports.usePopupInteractionProps = usePopupInteractionProps;
+exports.usePopupRootSync = usePopupRootSync;
+exports.usePopupStore = usePopupStore;
 exports.useTriggerDataForwarding = useTriggerDataForwarding;
 exports.useTriggerRegistration = useTriggerRegistration;
 var React = _interopRequireWildcard(require("react"));
+var _empty = require("@base-ui/utils/empty");
+var _useId = require("@base-ui/utils/useId");
 var _useStableCallback = require("@base-ui/utils/useStableCallback");
 var _useIsoLayoutEffect = require("@base-ui/utils/useIsoLayoutEffect");
+var _constants = require("../../floating-ui-react/utils/constants");
+var _FloatingTree = require("../../floating-ui-react/components/FloatingTree");
+var _useSyncedFloatingRootContext = require("../../floating-ui-react/hooks/useSyncedFloatingRootContext");
 var _useTransitionStatus = require("../../internals/useTransitionStatus");
 var _useOpenChangeComplete = require("../../internals/useOpenChangeComplete");
+const FOCUSABLE_POPUP_PROPS = exports.FOCUSABLE_POPUP_PROPS = {
+  tabIndex: -1,
+  [_constants.FOCUSABLE_ATTRIBUTE]: ''
+};
+function usePopupStore(externalStore, createStore, treatPopupAsFloatingElement = false) {
+  const floatingId = (0, _useId.useId)();
+  const nested = (0, _FloatingTree.useFloatingParentNodeId)() != null;
+  const internalStoreRef = React.useRef(null);
+  if (externalStore === undefined && internalStoreRef.current === null) {
+    internalStoreRef.current = createStore(floatingId, nested);
+  }
+  const store = externalStore ?? internalStoreRef.current;
+  (0, _useSyncedFloatingRootContext.useSyncedFloatingRootContext)({
+    popupStore: store,
+    treatPopupAsFloatingElement,
+    floatingRootContext: store.state.floatingRootContext,
+    floatingId,
+    nested,
+    onOpenChange: store.setOpen
+  });
+  return {
+    store,
+    internalStore: internalStoreRef.current
+  };
+}
+
 /**
  * Returns a callback ref that registers/unregisters the trigger element in the store.
  *
@@ -27,12 +63,14 @@ function useTriggerRegistration(id, store) {
     if (id === undefined) {
       return;
     }
+    let shouldSyncTriggerCount = false;
     if (registeredElementIdRef.current !== null) {
       const registeredId = registeredElementIdRef.current;
       const registeredElement = registeredElementRef.current;
       const currentElement = store.context.triggerElements.getById(registeredId);
       if (registeredElement && currentElement === registeredElement) {
         store.context.triggerElements.delete(registeredId);
+        shouldSyncTriggerCount = true;
       }
       registeredElementIdRef.current = null;
       registeredElementRef.current = null;
@@ -41,15 +79,32 @@ function useTriggerRegistration(id, store) {
       registeredElementIdRef.current = id;
       registeredElementRef.current = element;
       store.context.triggerElements.add(id, element);
+      shouldSyncTriggerCount = true;
+    }
+    if (shouldSyncTriggerCount) {
+      const triggerCount = store.context.triggerElements.size;
+      if (store.select('open') && store.state.triggerCount !== triggerCount) {
+        store.set('triggerCount', triggerCount);
+      }
     }
   }, [store, id]);
 }
+function setOpenTriggerState(state, open, trigger) {
+  const triggerId = trigger?.id ?? null;
+
+  // If a popup is closing, the `trigger` may be undefined.
+  // We want to keep the previous value so that exit animations are played and focus is returned correctly.
+  if (triggerId || open) {
+    state.activeTriggerId = triggerId;
+    state.activeTriggerElement = trigger ?? null;
+  }
+}
 
 /**
  * Sets up trigger data forwarding to the store.
  *
  * @param triggerId Id of the trigger.
- * @param triggerElement The trigger DOM element.
+ * @param triggerElementRef Ref for the trigger DOM element.
  * @param store The Store instance managing the popup state.
  * @param stateUpdates An object with state updates to apply when the trigger is active.
  */
@@ -58,22 +113,22 @@ function useTriggerDataForwarding(triggerId, triggerElementRef, store, stateUpda
   const baseRegisterTrigger = useTriggerRegistration(triggerId, store);
   const registerTrigger = (0, _useStableCallback.useStableCallback)(element => {
     baseRegisterTrigger(element);
-    if (!element || !store.select('open')) {
+    if (!element) {
       return;
     }
+    const open = store.select('open');
     const activeTriggerId = store.select('activeTriggerId');
     if (activeTriggerId === triggerId) {
       store.update({
         activeTriggerElement: element,
-        ...stateUpdates
+        ...(open ? stateUpdates : null)
       });
       return;
     }
-    if (activeTriggerId == null) {
-      // This runs when popup is open, but no active trigger is set.
-      // It can happen when using controlled mode and the trigger is mounted after opening or if `triggerId` prop is not set explicitly.
-      // In such cases the first trigger to run this code becomes the active trigger (store.select('activeTriggerId') should not return null after that).
-      // This is mostly for compatibility with contained triggers where no explicit `triggerId` was required in controlled mode.
+    if (activeTriggerId == null && open) {
+      // If a popup is already open, a detached trigger can mount before any active trigger
+      // has been established. Claim the first registered trigger so trigger-owned focus
+      // management and ARIA relationships work.
       store.update({
         activeTriggerId: triggerId,
         activeTriggerElement: element,
@@ -97,32 +152,44 @@ function useTriggerDataForwarding(triggerId, triggerElementRef, store, stateUpda
 }
 /**
  * Ensures that when there's only one trigger element registered, it is set as the active trigger.
- * This allows controlled popups to work correctly without an explicit triggerId, maintaining compatibility
- * with the contained triggers.
+ * This keeps triggerCount reactive while open and allows controlled popups to work correctly without
+ * an explicit triggerId, maintaining compatibility with contained triggers.
  *
  * This should be called on the Root part.
  *
- * @param open Whether the popup is open.
  * @param store The Store instance managing the popup state.
  */
 function useImplicitActiveTrigger(store) {
   const open = store.useState('open');
+  const reactiveTriggerCount = store.useState('triggerCount');
   (0, _useIsoLayoutEffect.useIsoLayoutEffect)(() => {
-    if (open && !store.select('activeTriggerId') && store.context.triggerElements.size === 1) {
+    if (!open) {
+      if (store.state.triggerCount !== 0) {
+        store.set('triggerCount', 0);
+      }
+      return;
+    }
+    const triggerCount = store.context.triggerElements.size;
+    const stateUpdates = {};
+    if (store.state.triggerCount !== triggerCount) {
+      stateUpdates.triggerCount = triggerCount;
+    }
+    if (!store.select('activeTriggerId') && triggerCount === 1) {
       const iteratorResult = store.context.triggerElements.entries().next();
       if (!iteratorResult.done) {
         const [implicitTriggerId, implicitTriggerElement] = iteratorResult.value;
-        store.update({
-          activeTriggerId: implicitTriggerId,
-          activeTriggerElement: implicitTriggerElement
-        });
+        stateUpdates.activeTriggerId = implicitTriggerId;
+        stateUpdates.activeTriggerElement = implicitTriggerElement;
       }
     }
-  }, [open, store]);
+    if (stateUpdates.triggerCount !== undefined || stateUpdates.activeTriggerId !== undefined) {
+      store.update(stateUpdates);
+    }
+  }, [open, store, reactiveTriggerCount]);
 }
 
 /**
- * Mangages the mounted state of the popup.
+ * Manages the mounted state of the popup.
  * Sets up the transition status listeners and handles unmounting when needed.
  * Updates the `mounted` and `transitionStatus` states in the store.
  *
@@ -147,14 +214,15 @@ function useOpenStateTransitions(open, store, onUnmount) {
     store.update({
       activeTriggerId: null,
       activeTriggerElement: null,
-      mounted: false
+      mounted: false,
+      preventUnmountingOnClose: false
     });
     onUnmount?.();
     store.context.onOpenChangeComplete?.(false);
   });
   const preventUnmountingOnClose = store.useState('preventUnmountingOnClose');
   (0, _useOpenChangeComplete.useOpenChangeComplete)({
-    enabled: !preventUnmountingOnClose,
+    enabled: mounted && !open && !preventUnmountingOnClose,
     open,
     ref: store.context.popupRef,
     onComplete() {
@@ -167,4 +235,26 @@ function useOpenStateTransitions(open, store, onUnmount) {
     forceUnmount,
     transitionStatus
   };
+}
+function usePopupInteractionProps(store, statePart) {
+  store.useSyncedValues(statePart);
+  (0, _useIsoLayoutEffect.useIsoLayoutEffect)(() => () => {
+    store.update({
+      activeTriggerProps: _empty.EMPTY_OBJECT,
+      inactiveTriggerProps: _empty.EMPTY_OBJECT,
+      popupProps: _empty.EMPTY_OBJECT
+    });
+  }, [store]);
+}
+function usePopupRootSync(store, open) {
+  (0, _useIsoLayoutEffect.useIsoLayoutEffect)(() => {
+    if (!open && store.state.openMethod !== null) {
+      store.set('openMethod', null);
+    }
+  }, [open, store]);
+  (0, _useIsoLayoutEffect.useIsoLayoutEffect)(() => () => {
+    if (store.state.openMethod !== null) {
+      store.set('openMethod', null);
+    }
+  }, [store]);
 }

package/utils/popups/popupTriggerMap.js

@@ -33,6 +33,8 @@ class PopupTriggerMap {
     this.idMap.set(id, element);
     if (process.env.NODE_ENV !== 'production') {
       if (this.elementsSet.size !== this.idMap.size) {
+        // TODO: fix mui/no-guarded-throw
+        // eslint-disable-next-line mui/no-guarded-throw
         throw new Error('Base UI: A trigger element cannot be registered under multiple IDs in PopupTriggerMap.');
       }
     }

package/utils/popups/store.d.ts

@@ -1,4 +1,5 @@
 import { FloatingRootContext } from "../../floating-ui-react/index.js";
+import { FloatingRootStore } from "../../floating-ui-react/components/FloatingRootStore.js";
 import { TransitionStatus } from "../../internals/useTransitionStatus.js";
 import { PopupTriggerMap } from "./popupTriggerMap.js";
 import { HTMLProps } from "../../internals/types.js";
@@ -24,9 +25,14 @@ export type PopupStoreState<Payload> = {
    */
   transitionStatus: TransitionStatus;
   floatingRootContext: FloatingRootContext;
+  floatingId: string | undefined;
+  /**
+   * Number of trigger elements currently registered for this popup.
+   */
+  triggerCount: number;
   /**
    * Whether to prevent unmounting the popup when closed.
-   * Useful for interactling with JS animation libraries that control unmounting themselves.
+   * Useful for interacting with JS animation libraries that control unmounting themselves.
    */
   preventUnmountingOnClose: boolean;
   /**
@@ -67,6 +73,7 @@ export type PopupStoreState<Payload> = {
   popupProps: HTMLProps;
 };
 export declare function createInitialPopupStoreState<Payload>(): PopupStoreState<Payload>;
+export declare function createPopupFloatingRootContext(triggerElements: PopupTriggerMap, floatingId?: string | undefined, nested?: boolean): FloatingRootStore;
 export type PopupStoreContext<ChangeEventDetails> = {
   /**
    * Map of registered trigger elements.
@@ -90,11 +97,13 @@ export declare const popupStoreSelectors: {
   open: (state: S) => boolean;
   mounted: (state: S) => boolean;
   transitionStatus: (state: S) => TransitionStatus;
-  floatingRootContext: (state: S) => import("../../floating-ui-react/components/FloatingRootStore.js").FloatingRootStore;
+  floatingRootContext: (state: S) => FloatingRootStore;
+  triggerCount: (state: S) => number;
   preventUnmountingOnClose: (state: S) => boolean;
   payload: (state: S) => unknown;
   activeTriggerId: (state: S) => string | null;
   activeTriggerElement: (state: S) => Element | null;
+  popupId: (state: S) => string | undefined;
   /**
    * Whether the trigger with the given ID was used to open the popup.
    */
@@ -108,6 +117,10 @@ export declare const popupStoreSelectors: {
    */
   isMountedByTrigger: (state: S, triggerId: string | undefined) => boolean;
   triggerProps: (state: S, isActive: boolean) => HTMLProps;
+  /**
+   * Popup id for the trigger that currently owns the open popup.
+   */
+  triggerPopupId: (state: S, triggerId: string | undefined) => string | undefined;
   popupProps: (state: S) => HTMLProps;
   popupElement: (state: S) => HTMLElement | null;
   positionerElement: (state: S) => HTMLElement | null;

package/utils/popups/store.js

@@ -4,9 +4,11 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createInitialPopupStoreState = createInitialPopupStoreState;
+exports.createPopupFloatingRootContext = createPopupFloatingRootContext;
 exports.popupStoreSelectors = void 0;
 var _store = require("@base-ui/utils/store");
 var _empty = require("@base-ui/utils/empty");
+var _FloatingRootStore = require("../../floating-ui-react/components/FloatingRootStore");
 var _getEmptyRootContext = require("../../floating-ui-react/utils/getEmptyRootContext");
 /**
  * State common to all popup stores.
@@ -19,6 +21,8 @@ function createInitialPopupStoreState() {
     mounted: false,
     transitionStatus: undefined,
     floatingRootContext: (0, _getEmptyRootContext.getEmptyRootContext)(),
+    floatingId: undefined,
+    triggerCount: 0,
     preventUnmountingOnClose: false,
     payload: undefined,
     activeTriggerId: null,
@@ -31,16 +35,45 @@ function createInitialPopupStoreState() {
     popupProps: _empty.EMPTY_OBJECT
   };
 }
+function createPopupFloatingRootContext(triggerElements, floatingId, nested = false) {
+  return new _FloatingRootStore.FloatingRootStore({
+    open: false,
+    transitionStatus: undefined,
+    floatingElement: null,
+    referenceElement: null,
+    triggerElements,
+    floatingId,
+    syncOnly: true,
+    nested,
+    onOpenChange: undefined
+  });
+}
 const activeTriggerIdSelector = (0, _store.createSelector)(state => state.triggerIdProp ?? state.activeTriggerId);
+const openSelector = (0, _store.createSelector)(state => state.openProp ?? state.open);
+const popupIdSelector = (0, _store.createSelector)(state => {
+  const popupId = state.popupElement?.id ?? state.floatingId;
+  return popupId || undefined;
+});
+function triggerOwnsOpenPopup(state, triggerId) {
+  return triggerId !== undefined && openSelector(state) && activeTriggerIdSelector(state) === triggerId;
+}
+function triggerOwnsOpenPopupOrIsOnlyTrigger(state, triggerId) {
+  if (triggerOwnsOpenPopup(state, triggerId)) {
+    return true;
+  }
+  return triggerId !== undefined && openSelector(state) && activeTriggerIdSelector(state) == null && state.triggerCount === 1;
+}
 const popupStoreSelectors = exports.popupStoreSelectors = {
-  open: (0, _store.createSelector)(state => state.openProp ?? state.open),
+  open: openSelector,
   mounted: (0, _store.createSelector)(state => state.mounted),
   transitionStatus: (0, _store.createSelector)(state => state.transitionStatus),
   floatingRootContext: (0, _store.createSelector)(state => state.floatingRootContext),
+  triggerCount: (0, _store.createSelector)(state => state.triggerCount),
   preventUnmountingOnClose: (0, _store.createSelector)(state => state.preventUnmountingOnClose),
   payload: (0, _store.createSelector)(state => state.payload),
   activeTriggerId: activeTriggerIdSelector,
   activeTriggerElement: (0, _store.createSelector)(state => state.mounted ? state.activeTriggerElement : null),
+  popupId: popupIdSelector,
   /**
    * Whether the trigger with the given ID was used to open the popup.
    */
@@ -48,12 +81,16 @@ const popupStoreSelectors = exports.popupStoreSelectors = {
   /**
    * Whether the popup is open and was activated by a trigger with the given ID.
    */
-  isOpenedByTrigger: (0, _store.createSelector)((state, triggerId) => triggerId !== undefined && activeTriggerIdSelector(state) === triggerId && state.open),
+  isOpenedByTrigger: (0, _store.createSelector)((state, triggerId) => triggerOwnsOpenPopup(state, triggerId)),
   /**
    * Whether the popup is mounted and was activated by a trigger with the given ID.
    */
   isMountedByTrigger: (0, _store.createSelector)((state, triggerId) => triggerId !== undefined && activeTriggerIdSelector(state) === triggerId && state.mounted),
   triggerProps: (0, _store.createSelector)((state, isActive) => isActive ? state.activeTriggerProps : state.inactiveTriggerProps),
+  /**
+   * Popup id for the trigger that currently owns the open popup.
+   */
+  triggerPopupId: (0, _store.createSelector)((state, triggerId) => triggerOwnsOpenPopupOrIsOnlyTrigger(state, triggerId) ? popupIdSelector(state) : undefined),
   popupProps: (0, _store.createSelector)(state => state.popupProps),
   popupElement: (0, _store.createSelector)(state => state.popupElement),
   positionerElement: (0, _store.createSelector)(state => state.positionerElement)

package/utils/popups/useTriggerFocusGuards.js

@@ -8,7 +8,6 @@ Object.defineProperty(exports, "__esModule", {
 exports.useTriggerFocusGuards = useTriggerFocusGuards;
 var React = _interopRequireWildcard(require("react"));
 var ReactDOM = _interopRequireWildcard(require("react-dom"));
-var _useStableCallback = require("@base-ui/utils/useStableCallback");
 var _utils = require("../../floating-ui-react/utils");
 var _createBaseUIEventDetails = require("../../internals/createBaseUIEventDetails");
 var _reasons = require("../../internals/reasons");
@@ -26,14 +25,14 @@ var _reasons = require("../../internals/reasons");
  */
 function useTriggerFocusGuards(store, triggerElementRef) {
   const preFocusGuardRef = React.useRef(null);
-  const handlePreFocusGuardFocus = (0, _useStableCallback.useStableCallback)(event => {
+  function handlePreFocusGuardFocus(event) {
     ReactDOM.flushSync(() => {
       store.setOpen(false, (0, _createBaseUIEventDetails.createChangeEventDetails)(_reasons.REASONS.focusOut, event.nativeEvent, event.currentTarget));
     });
     const previousTabbable = (0, _utils.getTabbableBeforeElement)(preFocusGuardRef.current);
     previousTabbable?.focus();
-  });
-  const handleFocusTargetFocus = (0, _useStableCallback.useStableCallback)(event => {
+  }
+  function handleFocusTargetFocus(event) {
     const positionerElement = store.select('positionerElement');
     if (positionerElement && (0, _utils.isOutsideEvent)(event, positionerElement)) {
       store.context.beforeContentFocusGuardRef.current?.focus();
@@ -51,7 +50,7 @@ function useTriggerFocusGuards(store, triggerElementRef) {
       }
       nextTabbable?.focus();
     }
-  });
+  }
   return {
     preFocusGuardRef,
     handlePreFocusGuardFocus,

package/utils/useAnchorPositioning.d.ts

@@ -220,6 +220,11 @@ export interface UseAnchorPositioningParameters extends UseAnchorPositioningShar
   shiftCrossAxis?: boolean | undefined;
   lazyFlip?: boolean | undefined;
   externalTree?: FloatingTreeStore | undefined;
+  /**
+   * Optional middleware that can replace the measured reference rect before offsets and collision
+   * middleware run. Used by Preview Card to position against a specific inline line box.
+   */
+  inline?: Middleware | undefined;
 }
 export interface UseAnchorPositioningReturnValue {
   positionerStyles: React.CSSProperties;

package/utils/useAnchorPositioning.js

@@ -65,6 +65,7 @@ function useAnchorPositioning(params) {
     sticky = false,
     arrowPadding = 5,
     disableAnchorTracking = false,
+    inline: inlineMiddleware,
     // Private parameters
     keepMounted = false,
     floatingRootContext,
@@ -139,7 +140,11 @@ function useAnchorPositioning(params) {
   const alignOffsetRef = (0, _useValueAsRef.useValueAsRef)(alignOffset);
   const sideOffsetDep = typeof sideOffset !== 'function' ? sideOffset : 0;
   const alignOffsetDep = typeof alignOffset !== 'function' ? alignOffset : 0;
-  const middleware = [(0, _floatingUiReact.offset)(state => {
+  const middleware = [];
+  if (inlineMiddleware) {
+    middleware.push(inlineMiddleware);
+  }
+  middleware.push((0, _floatingUiReact.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;
@@ -148,7 +153,7 @@ function useAnchorPositioning(params) {
       crossAxis: alignAxis,
       alignmentAxis: alignAxis
     };
-  }, [sideOffsetDep, alignOffsetDep, isRtl, sideParam])];
+  }, [sideOffsetDep, alignOffsetDep, isRtl, sideParam]));
   const shiftDisabled = collisionAvoidanceAlign === 'none' && collisionAvoidanceSide !== 'shift';
   const crossAxisShiftEnabled = !shiftDisabled && (sticky || shiftCrossAxis || collisionAvoidanceSide === 'shift');
   const flipMiddleware = collisionAvoidanceSide === 'none' ? null : (0, _floatingUiReact.flip)({
@@ -233,10 +238,10 @@ function useAnchorPositioning(params) {
       floatingStyle.setProperty('--anchor-width', `${anchorWidth}px`);
       floatingStyle.setProperty('--anchor-height', `${anchorHeight}px`);
     }
-  }), (0, _arrow.arrow)(() => ({
+  }), (0, _arrow.arrow)(state => ({
     // `transform-origin` calculations rely on an element existing. If the arrow hasn't been set,
     // we'll create a fake element.
-    element: arrowRef.current || (0, _owner.ownerDocument)(arrowRef.current).createElement('div'),
+    element: arrowRef.current || (0, _owner.ownerDocument)(state.elements.floating).createElement('div'),
     padding: arrowPadding,
     offsetParent: 'floating'
   }), [arrowPadding]), {
@@ -373,11 +378,9 @@ function useAnchorPositioning(params) {
   const renderedAlign = (0, _utils.getAlignment)(renderedPlacement) || 'center';
   const anchorHidden = Boolean(middlewareData.hide?.referenceHidden);
 
-  /**
-   * Locks the flip (makes it "sticky") so it doesn't prefer a given placement
-   * and flips back lazily, not eagerly. Ideal for filtered lists that change
-   * the size of the popup dynamically to avoid unwanted flipping when typing.
-   */
+  // Locks the flip (makes it "sticky") so it doesn't prefer a given placement
+  // and flips back lazily, not eagerly. Ideal for filtered lists that change
+  // the size of the popup dynamically to avoid unwanted flipping when typing.
   (0, _useIsoLayoutEffect.useIsoLayoutEffect)(() => {
     if (lazyFlip && mounted && isPositioned) {
       setMountSide(renderedSide);

package/utils/useOpenInteractionType.d.ts

@@ -1,5 +1,9 @@
 import * as React from 'react';
 import { InteractionType } from '@base-ui/utils/useEnhancedClickHandler';
+export declare function useOpenMethodTriggerProps(open: boolean | (() => boolean), setOpenMethod: (interactionType: InteractionType | null) => void): {
+  onClick: (event: React.MouseEvent | React.PointerEvent) => void;
+  onPointerDown: (event: React.PointerEvent) => void;
+};
 /**
  * Determines the interaction type (keyboard, mouse, touch, etc.) that opened the component.
  *

package/utils/useOpenInteractionType.js

@@ -6,20 +6,16 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useOpenInteractionType = useOpenInteractionType;
+exports.useOpenMethodTriggerProps = useOpenMethodTriggerProps;
 var React = _interopRequireWildcard(require("react"));
 var _useStableCallback = require("@base-ui/utils/useStableCallback");
 var _useEnhancedClickHandler = require("@base-ui/utils/useEnhancedClickHandler");
 var _detectBrowser = require("@base-ui/utils/detectBrowser");
 var _useValueChanged = require("../internals/useValueChanged");
-/**
- * Determines the interaction type (keyboard, mouse, touch, etc.) that opened the component.
- *
- * @param open The open state of the component.
- */
-function useOpenInteractionType(open) {
-  const [openMethod, setOpenMethod] = React.useState(null);
+function useOpenMethodTriggerProps(open, setOpenMethod) {
   const handleTriggerClick = (0, _useStableCallback.useStableCallback)((_, interactionType) => {
-    if (!open) {
+    const isOpen = typeof open === 'function' ? open() : open;
+    if (!isOpen) {
       setOpenMethod(interactionType || (
       // On iOS Safari, the hitslop around touch targets means tapping outside an element's
       // bounds does not fire `pointerdown` but does fire `mousedown`. The `interactionType`
@@ -27,20 +23,31 @@ function useOpenInteractionType(open) {
       _detectBrowser.isIOS ? 'touch' : ''));
     }
   });
+  const {
+    onClick,
+    onPointerDown
+  } = (0, _useEnhancedClickHandler.useEnhancedClickHandler)(handleTriggerClick);
+  return React.useMemo(() => ({
+    onClick,
+    onPointerDown
+  }), [onClick, onPointerDown]);
+}
+
+/**
+ * Determines the interaction type (keyboard, mouse, touch, etc.) that opened the component.
+ *
+ * @param open The open state of the component.
+ */
+function useOpenInteractionType(open) {
+  const [openMethod, setOpenMethod] = React.useState(null);
+  const triggerProps = useOpenMethodTriggerProps(open, setOpenMethod);
   (0, _useValueChanged.useValueChanged)(open, previousOpen => {
     if (previousOpen && !open) {
       setOpenMethod(null);
     }
   });
-  const {
-    onClick,
-    onPointerDown
-  } = (0, _useEnhancedClickHandler.useEnhancedClickHandler)(handleTriggerClick);
   return React.useMemo(() => ({
     openMethod,
-    triggerProps: {
-      onClick,
-      onPointerDown
-    }
-  }), [openMethod, onClick, onPointerDown]);
+    triggerProps
+  }), [openMethod, triggerProps]);
 }

package/checkbox-group/index.parts.d.ts

@@ -1 +0,0 @@
-export { CheckboxGroup } from "./CheckboxGroup.js";

package/checkbox-group/index.parts.js

@@ -1,12 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "CheckboxGroup", {
-  enumerable: true,
-  get: function () {
-    return _CheckboxGroup.CheckboxGroup;
-  }
-});
-var _CheckboxGroup = require("./CheckboxGroup");

package/esm/checkbox-group/index.parts.d.ts

@@ -1 +0,0 @@
-export { CheckboxGroup } from "./CheckboxGroup.js";

package/esm/checkbox-group/index.parts.js

@@ -1 +0,0 @@
-export { CheckboxGroup } from "./CheckboxGroup.js";

package/esm/floating-ui-react/hooks/useInteractions.d.ts

@@ -1,20 +0,0 @@
-import * as React from 'react';
-import type { ElementProps } from "../types.js";
-import { ACTIVE_KEY, SELECTED_KEY } from "../utils/constants.js";
-export type ExtendedUserProps = {
-  [ACTIVE_KEY]?: boolean | undefined;
-  [SELECTED_KEY]?: boolean | undefined;
-};
-export interface UseInteractionsReturn {
-  getReferenceProps: (userProps?: React.HTMLProps<Element>) => Record<string, unknown>;
-  getFloatingProps: (userProps?: React.HTMLProps<HTMLElement>) => Record<string, unknown>;
-  getItemProps: (userProps?: Omit<React.HTMLProps<HTMLElement>, 'selected' | 'active'> & ExtendedUserProps) => Record<string, unknown>;
-  getTriggerProps: (userProps?: React.HTMLProps<Element>) => Record<string, unknown>;
-}
-/**
- * Merges an array of interaction hooks' props into prop getters, allowing
- * event handler functions to be composed together without overwriting one
- * another.
- * @see https://floating-ui.com/docs/useInteractions
- */
-export declare function useInteractions(propsList?: Array<ElementProps | void>): UseInteractionsReturn;