@wix/site-ui 1.30.0 → 1.31.0

package/dist/6107.js

@@ -0,0 +1,10 @@
+import { esm_formatErrorMessage } from "./8272.js";
+import * as __rspack_external_react from "react";
+const ToolbarRootContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) ToolbarRootContext.displayName = "ToolbarRootContext";
+function useToolbarRootContext(optional) {
+    const context = __rspack_external_react.useContext(ToolbarRootContext);
+    if (void 0 === context && !optional) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: ToolbarRootContext is missing. Toolbar parts must be placed within <Toolbar.Root>.' : esm_formatErrorMessage(69));
+    return context;
+}
+export { ToolbarRootContext, useToolbarRootContext };

package/dist/6247.js

@@ -0,0 +1,20 @@
+import { useIsoLayoutEffect } from "./6499.js";
+import { ownerDocument } from "./9829.js";
+import { useScrollLock } from "./3485.js";
+import * as __rspack_external_react from "react";
+const VIEWPORT_WIDTH_TOLERANCE_PX = 20;
+function useAnchoredPopupScrollLock(enabled, touchOpen, positionerElement, referenceElement) {
+    const [touchOpenShouldLockScroll, setTouchOpenShouldLockScroll] = __rspack_external_react.useState(false);
+    useIsoLayoutEffect(()=>{
+        if (!enabled || !touchOpen || null == positionerElement) return void setTouchOpenShouldLockScroll(false);
+        const viewportWidth = ownerDocument(positionerElement).documentElement.clientWidth;
+        const popupWidth = positionerElement.offsetWidth;
+        setTouchOpenShouldLockScroll(viewportWidth > 0 && popupWidth > 0 && popupWidth >= viewportWidth - VIEWPORT_WIDTH_TOLERANCE_PX);
+    }, [
+        enabled,
+        touchOpen,
+        positionerElement
+    ]);
+    useScrollLock(enabled && (!touchOpen || touchOpenShouldLockScroll), referenceElement);
+}
+export { useAnchoredPopupScrollLock };

package/dist/6270.js

@@ -0,0 +1,487 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { EMPTY_OBJECT, mergeProps, useRenderElement, esm_formatErrorMessage } from "./8272.js";
+import { useButton } from "./9189.js";
+import { createChangeEventDetails } from "./4768.js";
+import { closePress, imperativeAction } from "./2418.js";
+import { useBaseUiId } from "./6046.js";
+import { CLICK_TRIGGER_IDENTIFIER, triggerOpenStateMapping, FloatingPortal_FloatingPortal, popupStateMapping, popupStateMapping_CommonPopupDataAttributes } from "./4388.js";
+import { transitionStatusMapping } from "./880.js";
+import { useTriggerDataForwarding, usePopupInteractionProps, usePopupRootSync, setOpenTriggerState, usePopupStore, useImplicitActiveTrigger, useOnFirstRender, useOpenStateTransitions, FOCUSABLE_POPUP_PROPS } from "./8106.js";
+import { useClick } from "./5864.js";
+import { InternalBackdrop_InternalBackdrop, useOpenMethodTriggerProps, useScrollLock } from "./3485.js";
+import { useDismiss, PopupTriggerMap, createSelector, ReactStore } from "./5992.js";
+import { getTarget, contains } from "./4549.js";
+import { createPopupFloatingRootContext, popupStoreSelectors, createInitialPopupStoreState } from "./6535.js";
+import { inertValue } from "./167.js";
+import * as __rspack_external_react from "react";
+const IsDrawerContext = /*#__PURE__*/ __rspack_external_react.createContext(false);
+if ("production" !== process.env.NODE_ENV) IsDrawerContext.displayName = "IsDrawerContext";
+const DialogRootContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) DialogRootContext.displayName = "DialogRootContext";
+function useDialogRootContext(optional) {
+    const dialogRootContext = __rspack_external_react.useContext(DialogRootContext);
+    if (false === optional && void 0 === dialogRootContext) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: DialogRootContext is missing. Dialog parts must be placed within <Dialog.Root>.' : esm_formatErrorMessage(27));
+    return dialogRootContext;
+}
+const DialogClose_DialogClose = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, disabled = false, nativeButton = true, ...elementProps } = componentProps;
+    const { store } = useDialogRootContext();
+    const open = store.useState('open');
+    const { getButtonProps, buttonRef } = useButton({
+        disabled,
+        native: nativeButton
+    });
+    const state = {
+        disabled
+    };
+    function handleClick(event) {
+        if (open) store.setOpen(false, createChangeEventDetails(closePress, event.nativeEvent));
+    }
+    return useRenderElement('button', componentProps, {
+        state,
+        ref: [
+            forwardedRef,
+            buttonRef
+        ],
+        props: [
+            {
+                onClick: handleClick
+            },
+            elementProps,
+            getButtonProps
+        ]
+    });
+});
+if ("production" !== process.env.NODE_ENV) DialogClose_DialogClose.displayName = "DialogClose";
+const DialogDescription_DialogDescription = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, id: idProp, ...elementProps } = componentProps;
+    const { store } = useDialogRootContext();
+    const id = useBaseUiId(idProp);
+    store.useSyncedValueWithCleanup("descriptionElementId", id);
+    return useRenderElement('p', componentProps, {
+        ref: forwardedRef,
+        props: [
+            {
+                id
+            },
+            elementProps
+        ]
+    });
+});
+if ("production" !== process.env.NODE_ENV) DialogDescription_DialogDescription.displayName = "DialogDescription";
+const DialogPortalContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) DialogPortalContext.displayName = "DialogPortalContext";
+function useDialogPortalContext() {
+    const value = __rspack_external_react.useContext(DialogPortalContext);
+    if (void 0 === value) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: <Dialog.Portal> is missing.' : esm_formatErrorMessage(26));
+    return value;
+}
+const DialogTitle_DialogTitle = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, id: idProp, ...elementProps } = componentProps;
+    const { store } = useDialogRootContext();
+    const id = useBaseUiId(idProp);
+    store.useSyncedValueWithCleanup('titleElementId', id);
+    return useRenderElement('h2', componentProps, {
+        ref: forwardedRef,
+        props: [
+            {
+                id
+            },
+            elementProps
+        ]
+    });
+});
+if ("production" !== process.env.NODE_ENV) DialogTitle_DialogTitle.displayName = "DialogTitle";
+let DialogViewportDataAttributes_DialogViewportDataAttributes = function(DialogViewportDataAttributes) {
+    DialogViewportDataAttributes[DialogViewportDataAttributes["open"] = popupStateMapping_CommonPopupDataAttributes.open] = "open";
+    DialogViewportDataAttributes[DialogViewportDataAttributes["closed"] = popupStateMapping_CommonPopupDataAttributes.closed] = "closed";
+    DialogViewportDataAttributes[DialogViewportDataAttributes["startingStyle"] = popupStateMapping_CommonPopupDataAttributes.startingStyle] = "startingStyle";
+    DialogViewportDataAttributes[DialogViewportDataAttributes["endingStyle"] = popupStateMapping_CommonPopupDataAttributes.endingStyle] = "endingStyle";
+    DialogViewportDataAttributes["nested"] = "data-nested";
+    DialogViewportDataAttributes["nestedDialogOpen"] = "data-nested-dialog-open";
+    return DialogViewportDataAttributes;
+}({});
+const stateAttributesMapping = {
+    ...popupStateMapping,
+    ...transitionStatusMapping,
+    nested (value) {
+        return value ? {
+            [DialogViewportDataAttributes_DialogViewportDataAttributes.nested]: ''
+        } : null;
+    },
+    nestedDialogOpen (value) {
+        return value ? {
+            [DialogViewportDataAttributes_DialogViewportDataAttributes.nestedDialogOpen]: ''
+        } : null;
+    }
+};
+const DialogViewport_DialogViewport = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, children, ...elementProps } = componentProps;
+    const keepMounted = useDialogPortalContext();
+    const { store } = useDialogRootContext();
+    const open = store.useState('open');
+    const nested = store.useState('nested');
+    const transitionStatus = store.useState('transitionStatus');
+    const nestedOpenDialogCount = store.useState('nestedOpenDialogCount');
+    const mounted = store.useState('mounted');
+    const setViewportElement = store.useStateSetter('viewportElement');
+    const nestedDialogOpen = nestedOpenDialogCount > 0;
+    const state = {
+        open,
+        nested,
+        transitionStatus,
+        nestedDialogOpen
+    };
+    const shouldRender = keepMounted || mounted;
+    return useRenderElement('div', componentProps, {
+        enabled: shouldRender,
+        state,
+        ref: [
+            forwardedRef,
+            setViewportElement
+        ],
+        stateAttributesMapping: stateAttributesMapping,
+        props: [
+            {
+                role: 'presentation',
+                hidden: !mounted,
+                style: {
+                    pointerEvents: open ? void 0 : 'none'
+                },
+                children
+            },
+            elementProps
+        ]
+    });
+});
+if ("production" !== process.env.NODE_ENV) DialogViewport_DialogViewport.displayName = "DialogViewport";
+const DialogTrigger_DialogTrigger = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, disabled = false, nativeButton = true, id: idProp, payload, handle, ...elementProps } = componentProps;
+    const dialogRootContext = useDialogRootContext(true);
+    const store = handle?.store ?? dialogRootContext?.store;
+    if (!store) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: <Dialog.Trigger> must be used within <Dialog.Root> or provided with a handle.' : esm_formatErrorMessage(79));
+    const thisTriggerId = useBaseUiId(idProp);
+    const floatingContext = store.useState('floatingRootContext');
+    const isOpenedByThisTrigger = store.useState('isOpenedByTrigger', thisTriggerId);
+    const popupId = store.useState('triggerPopupId', thisTriggerId);
+    const triggerElementRef = __rspack_external_react.useRef(null);
+    const { registerTrigger, isMountedByThisTrigger } = useTriggerDataForwarding(thisTriggerId, triggerElementRef, store, {
+        payload
+    });
+    const { getButtonProps, buttonRef } = useButton({
+        disabled,
+        native: nativeButton
+    });
+    const click = useClick(floatingContext, {
+        enabled: null != floatingContext
+    });
+    const interactionTypeProps = useOpenMethodTriggerProps(()=>store.select('open'), (interactionType)=>{
+        store.set('openMethod', interactionType);
+    });
+    const state = {
+        disabled,
+        open: isOpenedByThisTrigger
+    };
+    const rootTriggerProps = store.useState('triggerProps', isMountedByThisTrigger);
+    return useRenderElement('button', componentProps, {
+        state,
+        ref: [
+            buttonRef,
+            forwardedRef,
+            registerTrigger,
+            triggerElementRef
+        ],
+        props: [
+            click.reference,
+            rootTriggerProps,
+            interactionTypeProps,
+            {
+                [CLICK_TRIGGER_IDENTIFIER]: '',
+                id: thisTriggerId,
+                'aria-haspopup': 'dialog',
+                'aria-expanded': isOpenedByThisTrigger,
+                'aria-controls': popupId
+            },
+            elementProps,
+            getButtonProps
+        ],
+        stateAttributesMapping: triggerOpenStateMapping
+    });
+});
+if ("production" !== process.env.NODE_ENV) DialogTrigger_DialogTrigger.displayName = "DialogTrigger";
+function useDialogRoot(params) {
+    const { store, parentContext, actionsRef, isDrawer } = params;
+    const open = store.useState('open');
+    usePopupRootSync(store, open);
+    useImplicitActiveTrigger(store);
+    const { forceUnmount } = useOpenStateTransitions(open, store);
+    const handleImperativeClose = __rspack_external_react.useCallback(()=>{
+        store.setOpen(false, createChangeEventDetails(imperativeAction));
+    }, [
+        store
+    ]);
+    __rspack_external_react.useImperativeHandle(actionsRef, ()=>({
+            unmount: forceUnmount,
+            close: handleImperativeClose
+        }), [
+        forceUnmount,
+        handleImperativeClose
+    ]);
+    return {
+        parentContext,
+        isDrawer
+    };
+}
+function DialogInteractions({ store, dialogRoot }) {
+    const { parentContext, isDrawer } = dialogRoot;
+    const open = store.useState('open');
+    const disablePointerDismissal = store.useState('disablePointerDismissal');
+    const modal = store.useState('modal');
+    const popupElement = store.useState('popupElement');
+    const floatingRootContext = store.useState('floatingRootContext');
+    const [ownNestedOpenDialogs, setOwnNestedOpenDialogs] = __rspack_external_react.useState(0);
+    const [ownNestedOpenDrawers, setOwnNestedOpenDrawers] = __rspack_external_react.useState(0);
+    const isTopmost = 0 === ownNestedOpenDialogs;
+    const dismiss = useDismiss(floatingRootContext, {
+        outsidePressEvent () {
+            if (store.context.internalBackdropRef.current || store.context.backdropRef.current) return 'intentional';
+            return {
+                mouse: 'trap-focus' === modal ? 'sloppy' : 'intentional',
+                touch: 'sloppy'
+            };
+        },
+        outsidePress (event) {
+            if (!store.context.outsidePressEnabledRef.current) return false;
+            if ('button' in event && 0 !== event.button) return false;
+            if ('touches' in event && 1 !== event.touches.length) return false;
+            const target = getTarget(event);
+            if (isTopmost && !disablePointerDismissal) {
+                const eventTarget = target;
+                if (modal) return store.context.internalBackdropRef.current || store.context.backdropRef.current ? store.context.internalBackdropRef.current === eventTarget || store.context.backdropRef.current === eventTarget || contains(eventTarget, popupElement) && !eventTarget?.hasAttribute('data-base-ui-portal') : true;
+                return true;
+            }
+            return false;
+        },
+        escapeKey: isTopmost
+    });
+    useScrollLock(open && true === modal, popupElement);
+    store.useContextCallback('onNestedDialogOpen', (dialogCount, drawerCount)=>{
+        setOwnNestedOpenDialogs(dialogCount);
+        setOwnNestedOpenDrawers(drawerCount);
+    });
+    store.useContextCallback('onNestedDialogClose', ()=>{
+        setOwnNestedOpenDialogs(0);
+        setOwnNestedOpenDrawers(0);
+    });
+    __rspack_external_react.useEffect(()=>{
+        if (parentContext?.onNestedDialogOpen && open) parentContext.onNestedDialogOpen(ownNestedOpenDialogs + 1, ownNestedOpenDrawers + (isDrawer ? 1 : 0));
+        if (parentContext?.onNestedDialogClose && !open) parentContext.onNestedDialogClose();
+        return ()=>{
+            if (parentContext?.onNestedDialogClose && open) parentContext.onNestedDialogClose();
+        };
+    }, [
+        isDrawer,
+        open,
+        ownNestedOpenDialogs,
+        ownNestedOpenDrawers,
+        parentContext
+    ]);
+    const activeTriggerProps = dismiss.reference ?? EMPTY_OBJECT;
+    const inactiveTriggerProps = dismiss.trigger ?? EMPTY_OBJECT;
+    const popupProps = __rspack_external_react.useMemo(()=>mergeProps(FOCUSABLE_POPUP_PROPS, dismiss.floating), [
+        dismiss.floating
+    ]);
+    usePopupInteractionProps(store, {
+        activeTriggerProps,
+        inactiveTriggerProps,
+        popupProps,
+        nestedOpenDialogCount: ownNestedOpenDialogs,
+        nestedOpenDrawerCount: ownNestedOpenDrawers
+    });
+    return null;
+}
+const selectors = {
+    ...popupStoreSelectors,
+    modal: createSelector((state)=>state.modal),
+    nested: createSelector((state)=>state.nested),
+    nestedOpenDialogCount: createSelector((state)=>state.nestedOpenDialogCount),
+    nestedOpenDrawerCount: createSelector((state)=>state.nestedOpenDrawerCount),
+    disablePointerDismissal: createSelector((state)=>state.disablePointerDismissal),
+    openMethod: createSelector((state)=>state.openMethod),
+    descriptionElementId: createSelector((state)=>state.descriptionElementId),
+    titleElementId: createSelector((state)=>state.titleElementId),
+    viewportElement: createSelector((state)=>state.viewportElement),
+    role: createSelector((state)=>state.role)
+};
+class DialogStore extends ReactStore {
+    constructor(initialState, floatingId, nested = false){
+        const triggerElements = new PopupTriggerMap();
+        const state = createInitialState(initialState);
+        state.floatingRootContext = createPopupFloatingRootContext(triggerElements, floatingId, nested);
+        super(state, {
+            popupRef: /*#__PURE__*/ __rspack_external_react.createRef(),
+            backdropRef: /*#__PURE__*/ __rspack_external_react.createRef(),
+            internalBackdropRef: /*#__PURE__*/ __rspack_external_react.createRef(),
+            outsidePressEnabledRef: {
+                current: true
+            },
+            triggerElements,
+            onOpenChange: void 0,
+            onOpenChangeComplete: void 0
+        }, selectors);
+    }
+    setOpen = (nextOpen, eventDetails)=>{
+        eventDetails.preventUnmountOnClose = ()=>{
+            this.set('preventUnmountingOnClose', true);
+        };
+        if (!nextOpen && null == eventDetails.trigger && null != this.state.activeTriggerId) eventDetails.trigger = this.state.activeTriggerElement ?? void 0;
+        this.context.onOpenChange?.(nextOpen, eventDetails);
+        if (eventDetails.isCanceled) return;
+        this.state.floatingRootContext.dispatchOpenChange(nextOpen, eventDetails);
+        const updatedState = {
+            open: nextOpen
+        };
+        setOpenTriggerState(updatedState, nextOpen, eventDetails.trigger);
+        this.update(updatedState);
+    };
+    static useStore(externalStore, initialState) {
+        const store = usePopupStore(externalStore, (floatingId, nested)=>new DialogStore(initialState, floatingId, nested), true).store;
+        return store;
+    }
+}
+function createInitialState(initialState = {}) {
+    return {
+        ...createInitialPopupStoreState(),
+        modal: true,
+        disablePointerDismissal: false,
+        popupElement: null,
+        viewportElement: null,
+        descriptionElementId: void 0,
+        titleElementId: void 0,
+        openMethod: null,
+        nested: false,
+        nestedOpenDialogCount: 0,
+        nestedOpenDrawerCount: 0,
+        role: 'dialog',
+        ...initialState
+    };
+}
+function useRenderDialogRoot(props, mode = 'dialog') {
+    const { children, open: openProp, defaultOpen = false, onOpenChange, onOpenChangeComplete, disablePointerDismissal: disablePointerDismissalProp = false, modal: modalProp = true, actionsRef, handle, triggerId: triggerIdProp, defaultTriggerId: defaultTriggerIdProp = null } = props;
+    const isDrawer = 'drawer' === mode;
+    const isAlertDialog = 'alert-dialog' === mode;
+    const modal = isAlertDialog ? true : modalProp;
+    const disablePointerDismissal = isAlertDialog || disablePointerDismissalProp;
+    const role = isAlertDialog ? 'alertdialog' : 'dialog';
+    const parentDialogRootContext = useDialogRootContext(true);
+    const nested = Boolean(parentDialogRootContext);
+    const rootState = {
+        modal,
+        disablePointerDismissal,
+        nested,
+        role
+    };
+    const store = DialogStore.useStore(handle?.store, {
+        open: defaultOpen,
+        openProp,
+        activeTriggerId: defaultTriggerIdProp,
+        triggerIdProp,
+        ...rootState
+    });
+    useOnFirstRender(()=>{
+        const nextState = void 0 === openProp && false === store.state.open && true === defaultOpen ? {
+            open: true,
+            activeTriggerId: defaultTriggerIdProp
+        } : null;
+        if (isAlertDialog) store.update(nextState ? {
+            ...rootState,
+            ...nextState
+        } : rootState);
+        else if (nextState) store.update(nextState);
+    });
+    store.useControlledProp('openProp', openProp);
+    store.useControlledProp('triggerIdProp', triggerIdProp);
+    store.useSyncedValues(rootState);
+    store.useContextCallback('onOpenChange', onOpenChange);
+    store.useContextCallback('onOpenChangeComplete', onOpenChangeComplete);
+    const open = store.useState('open');
+    const mounted = store.useState('mounted');
+    const payload = store.useState('payload');
+    const dialogRoot = useDialogRoot({
+        store,
+        actionsRef,
+        parentContext: parentDialogRootContext?.store.context,
+        isDrawer
+    });
+    const shouldRenderInteractions = open || mounted;
+    const contextValue = __rspack_external_react.useMemo(()=>({
+            store
+        }), [
+        store
+    ]);
+    return /*#__PURE__*/ jsx(IsDrawerContext.Provider, {
+        value: false,
+        children: /*#__PURE__*/ jsxs(DialogRootContext.Provider, {
+            value: contextValue,
+            children: [
+                shouldRenderInteractions && /*#__PURE__*/ jsx(DialogInteractions, {
+                    store: store,
+                    dialogRoot: dialogRoot
+                }),
+                'function' == typeof children ? children({
+                    payload
+                }) : children
+            ]
+        })
+    });
+}
+const DialogPortal_DialogPortal = /*#__PURE__*/ __rspack_external_react.forwardRef(function(props, forwardedRef) {
+    const { keepMounted = false, ...portalProps } = props;
+    const { store } = useDialogRootContext();
+    const mounted = store.useState('mounted');
+    const modal = store.useState('modal');
+    const open = store.useState('open');
+    const shouldRender = mounted || keepMounted;
+    if (!shouldRender) return null;
+    return /*#__PURE__*/ jsx(DialogPortalContext.Provider, {
+        value: keepMounted,
+        children: /*#__PURE__*/ jsxs(FloatingPortal_FloatingPortal, {
+            ref: forwardedRef,
+            ...portalProps,
+            children: [
+                mounted && true === modal && /*#__PURE__*/ jsx(InternalBackdrop_InternalBackdrop, {
+                    ref: store.context.internalBackdropRef,
+                    inert: inertValue(!open)
+                }),
+                props.children
+            ]
+        })
+    });
+});
+if ("production" !== process.env.NODE_ENV) DialogPortal_DialogPortal.displayName = "DialogPortal";
+class DialogHandle {
+    constructor(store){
+        this.store = store ?? new DialogStore();
+    }
+    open(triggerId) {
+        const triggerElement = triggerId ? this.store.context.triggerElements.getById(triggerId) : void 0;
+        if ('production' !== process.env.NODE_ENV) {
+            if (triggerId && !triggerElement) console.warn(`Base UI: DialogHandle.open: No trigger found with id "${triggerId}". The dialog will open, but the trigger will not be associated with the dialog.`);
+        }
+        this.store.setOpen(true, createChangeEventDetails(imperativeAction, void 0, triggerElement));
+    }
+    openWithPayload(payload) {
+        this.store.set('payload', payload);
+        this.store.setOpen(true, createChangeEventDetails(imperativeAction, void 0, void 0));
+    }
+    close() {
+        this.store.setOpen(false, createChangeEventDetails(imperativeAction, void 0, void 0));
+    }
+    get isOpen() {
+        return this.store.select('open');
+    }
+}
+function createDialogHandle() {
+    return new DialogHandle();
+}
+export { DialogClose_DialogClose, DialogDescription_DialogDescription, DialogHandle, DialogPortal_DialogPortal, DialogStore, DialogTitle_DialogTitle, DialogTrigger_DialogTrigger, DialogViewport_DialogViewport, IsDrawerContext, createDialogHandle, useDialogPortalContext, useDialogRootContext, useRenderDialogRoot };

package/dist/6329.js

@@ -0,0 +1,32 @@
+import { jsx } from "react/jsx-runtime";
+import { clamp } from "./3296.js";
+const DISABLE_SCROLLBAR_CLASS_NAME = 'base-ui-disable-scrollbar';
+const styleDisableScrollbar = {
+    className: DISABLE_SCROLLBAR_CLASS_NAME,
+    getElement (nonce) {
+        return /*#__PURE__*/ jsx("style", {
+            nonce: nonce,
+            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}`
+        });
+    }
+};
+if ("production" !== process.env.NODE_ENV) styleDisableScrollbar.getElement.displayName = "styleDisableScrollbar.getElement";
+const SCROLL_EDGE_TOLERANCE_PX = 1;
+function getMaxScrollOffset(scrollSize, clientSize) {
+    return Math.max(0, scrollSize - clientSize);
+}
+function normalizeScrollOffset(value, max) {
+    if (max <= 0) return 0;
+    const clamped = clamp(value, 0, max);
+    const startDistance = clamped;
+    const endDistance = max - clamped;
+    const withinStartTolerance = startDistance <= SCROLL_EDGE_TOLERANCE_PX;
+    const withinEndTolerance = endDistance <= SCROLL_EDGE_TOLERANCE_PX;
+    if (withinStartTolerance && withinEndTolerance) return startDistance <= endDistance ? 0 : max;
+    if (withinStartTolerance) return 0;
+    if (withinEndTolerance) return max;
+    return clamped;
+}
+export { getMaxScrollOffset, normalizeScrollOffset, styleDisableScrollbar };

package/dist/6330.js

@@ -0,0 +1,30 @@
+import { isAndroid, isJSDOM } from "./8971.js";
+function stopEvent(event) {
+    event.preventDefault();
+    event.stopPropagation();
+}
+function isReactEvent(event) {
+    return 'nativeEvent' in event;
+}
+function isVirtualClick(event) {
+    if ('' === event.pointerType && event.isTrusted) return true;
+    if (isAndroid && event.pointerType) return 'click' === event.type && 1 === event.buttons;
+    return 0 === event.detail && !event.pointerType;
+}
+function isVirtualPointerEvent(event) {
+    if (isJSDOM) return false;
+    return !isAndroid && 0 === event.width && 0 === event.height || isAndroid && 1 === event.width && 1 === event.height && 0 === event.pressure && 0 === event.detail && 'mouse' === event.pointerType || event.width < 1 && event.height < 1 && 0 === event.pressure && 0 === event.detail && 'touch' === event.pointerType;
+}
+function isMouseLikePointerType(pointerType, strict) {
+    const values = [
+        'mouse',
+        'pen'
+    ];
+    if (!strict) values.push('', void 0);
+    return values.includes(pointerType);
+}
+function isClickLikeEvent(event) {
+    const type = event.type;
+    return 'click' === type || 'mousedown' === type || 'keydown' === type || 'keyup' === type;
+}
+export { isClickLikeEvent, isMouseLikePointerType, isReactEvent, isVirtualClick, isVirtualPointerEvent, stopEvent };

package/dist/6499.js

@@ -0,0 +1,7 @@
+import * as __rspack_external_react from "react";
+const SafeReact = {
+    ...__rspack_external_react
+};
+const noop = ()=>{};
+const useIsoLayoutEffect = "u" > typeof document ? __rspack_external_react.useLayoutEffect : noop;
+export { SafeReact, useIsoLayoutEffect };

package/dist/6535.js

@@ -0,0 +1,71 @@
+import { getEmptyRootContext } from "./4922.js";
+import { EMPTY_OBJECT } from "./8272.js";
+import { createSelector, FloatingRootStore } from "./5992.js";
+function createInitialPopupStoreState() {
+    return {
+        open: false,
+        openProp: void 0,
+        mounted: false,
+        transitionStatus: void 0,
+        floatingRootContext: getEmptyRootContext(),
+        floatingId: void 0,
+        triggerCount: 0,
+        preventUnmountingOnClose: false,
+        payload: void 0,
+        activeTriggerId: null,
+        activeTriggerElement: null,
+        triggerIdProp: void 0,
+        popupElement: null,
+        positionerElement: null,
+        activeTriggerProps: EMPTY_OBJECT,
+        inactiveTriggerProps: EMPTY_OBJECT,
+        popupProps: EMPTY_OBJECT
+    };
+}
+function createPopupFloatingRootContext(triggerElements, floatingId, nested = false) {
+    return new FloatingRootStore({
+        open: false,
+        transitionStatus: void 0,
+        floatingElement: null,
+        referenceElement: null,
+        triggerElements,
+        floatingId,
+        syncOnly: true,
+        nested,
+        onOpenChange: void 0
+    });
+}
+const activeTriggerIdSelector = createSelector((state)=>state.triggerIdProp ?? state.activeTriggerId);
+const openSelector = createSelector((state)=>state.openProp ?? state.open);
+const popupIdSelector = createSelector((state)=>{
+    const popupId = state.popupElement?.id ?? state.floatingId;
+    return popupId || void 0;
+});
+function triggerOwnsOpenPopup(state, triggerId) {
+    return void 0 !== triggerId && openSelector(state) && activeTriggerIdSelector(state) === triggerId;
+}
+function triggerOwnsOpenPopupOrIsOnlyTrigger(state, triggerId) {
+    if (triggerOwnsOpenPopup(state, triggerId)) return true;
+    return void 0 !== triggerId && openSelector(state) && null == activeTriggerIdSelector(state) && 1 === state.triggerCount;
+}
+const popupStoreSelectors = {
+    open: openSelector,
+    mounted: createSelector((state)=>state.mounted),
+    transitionStatus: createSelector((state)=>state.transitionStatus),
+    floatingRootContext: createSelector((state)=>state.floatingRootContext),
+    triggerCount: createSelector((state)=>state.triggerCount),
+    preventUnmountingOnClose: createSelector((state)=>state.preventUnmountingOnClose),
+    payload: createSelector((state)=>state.payload),
+    activeTriggerId: activeTriggerIdSelector,
+    activeTriggerElement: createSelector((state)=>state.mounted ? state.activeTriggerElement : null),
+    popupId: popupIdSelector,
+    isTriggerActive: createSelector((state, triggerId)=>void 0 !== triggerId && activeTriggerIdSelector(state) === triggerId),
+    isOpenedByTrigger: createSelector((state, triggerId)=>triggerOwnsOpenPopup(state, triggerId)),
+    isMountedByTrigger: createSelector((state, triggerId)=>void 0 !== triggerId && activeTriggerIdSelector(state) === triggerId && state.mounted),
+    triggerProps: createSelector((state, isActive)=>isActive ? state.activeTriggerProps : state.inactiveTriggerProps),
+    triggerPopupId: createSelector((state, triggerId)=>triggerOwnsOpenPopupOrIsOnlyTrigger(state, triggerId) ? popupIdSelector(state) : void 0),
+    popupProps: createSelector((state)=>state.popupProps),
+    popupElement: createSelector((state)=>state.popupElement),
+    positionerElement: createSelector((state)=>state.positionerElement)
+};
+export { createInitialPopupStoreState, createPopupFloatingRootContext, popupStoreSelectors };