@redis-ui/components 49.1.0 → 50.0.0

package/dist/node_modules/rsuite/esm/internals/InputBase/InputBase.js

@@ -0,0 +1,59 @@
+"use client";
+import { _extends } from "../../../../@babel/runtime/helpers/esm/extends.js";
+import { forwardRef as forwardRef$1 } from "../utils/react/forwardRef.js";
+import { KEY_VALUES } from "../constants/index.js";
+import useStyles from "../hooks/useStyles.js";
+import mergeRefs from "../utils/react/mergeRefs.js";
+import createChainedFunction from "../utils/createChainedFunction.js";
+import Box_default from "../Box/index.js";
+import Plaintext_default from "../Plaintext/index.js";
+import { useFormGroup } from "../../FormGroup/useFormGroup.js";
+import { InputGroupContext } from "../../InputGroup/InputGroupContext.js";
+import React, { useContext } from "react";
+//#region ../../node_modules/rsuite/esm/internals/InputBase/InputBase.js
+/**
+* The `InputBase` component serves as the base for both Input and Textarea components.
+* It provides common functionality for both components.
+*/
+var InputBase = forwardRef$1((props, ref) => {
+	const { as, className, classPrefix, disabled, value, defaultValue, inputRef, id, size, plaintext, placeholder, readOnly, inputProps, onPressEnter, onFocus, onBlur, onKeyDown, onChange, ...rest } = props;
+	const inputGroup = useContext(InputGroupContext);
+	const { controlId } = useFormGroup();
+	const handleKeyDown = (event) => {
+		if (event.key === KEY_VALUES.ENTER) onPressEnter?.(event);
+		onKeyDown?.(event);
+	};
+	const handleChange = (event) => {
+		onChange?.(event.target?.value, event);
+	};
+	const { withPrefix, merge } = useStyles(classPrefix || "input");
+	const classes = merge(className, withPrefix({ plaintext }));
+	if (plaintext) return /*#__PURE__*/ React.createElement(Plaintext_default, {
+		ref,
+		localeKey: "unfilled",
+		placeholder
+	}, typeof value === "undefined" ? defaultValue : value);
+	const inputable = !disabled && !readOnly;
+	const eventProps = {};
+	if (inputable) {
+		eventProps.onChange = handleChange;
+		eventProps.onKeyDown = handleKeyDown;
+		eventProps.onFocus = createChainedFunction(onFocus, inputGroup?.onFocus);
+		eventProps.onBlur = createChainedFunction(onBlur, inputGroup?.onBlur);
+	}
+	return /*#__PURE__*/ React.createElement(Box_default, _extends({
+		as,
+		ref: mergeRefs(ref, inputRef),
+		className: classes,
+		id: id || controlId,
+		value,
+		defaultValue,
+		disabled,
+		readOnly,
+		placeholder,
+		"data-size": size
+	}, inputProps, eventProps, rest));
+});
+InputBase.displayName = "InputBase";
+//#endregion
+export { InputBase as default };

package/dist/node_modules/rsuite/esm/internals/InputBase/index.cjs

@@ -0,0 +1,5 @@
+"use client";
+//#region ../../node_modules/rsuite/esm/internals/InputBase/index.js
+var InputBase_default = require("./InputBase.cjs").default;
+//#endregion
+exports.default = InputBase_default;

package/dist/node_modules/rsuite/esm/internals/InputBase/index.js

@@ -0,0 +1,6 @@
+"use client";
+import InputBase from "./InputBase.js";
+//#region ../../node_modules/rsuite/esm/internals/InputBase/index.js
+var InputBase_default = InputBase;
+//#endregion
+export { InputBase_default as default };

package/dist/node_modules/rsuite/esm/internals/Overlay/Modal.cjs

@@ -0,0 +1,167 @@
+"use client";
+const require_runtime = require("../../../../../_virtual/_rolldown/runtime.cjs");
+const require_extends = require("../../../../@babel/runtime/helpers/esm/extends.cjs");
+const require_forwardRef = require("../utils/react/forwardRef.cjs");
+const require_index = require("../../../../classnames/index.cjs");
+const require_index$1 = require("../constants/index.cjs");
+const require_mergeRefs = require("../utils/react/mergeRefs.cjs");
+const require_createChainedFunction = require("../utils/createChainedFunction.cjs");
+const require_useEventCallback = require("../hooks/useEventCallback.cjs");
+const require_on = require("../../../../dom-lib/esm/on.cjs");
+const require_usePortal = require("../hooks/usePortal.cjs");
+const require_contains = require("../../../../dom-lib/esm/contains.cjs");
+const require_useWillUnmount = require("../hooks/useWillUnmount.cjs");
+const require_index$2 = require("../Box/index.cjs");
+const require_Fade = require("../../Animation/Fade.cjs");
+const require_OverlayProvider = require("./OverlayProvider.cjs");
+const require_ModalManager = require("./ModalManager.cjs");
+let react = require("react");
+react = require_runtime.__toESM(react);
+//#region ../../node_modules/rsuite/esm/internals/Overlay/Modal.js
+var import_classnames = /* @__PURE__ */ require_runtime.__toESM(require_index.default);
+var manager;
+function getManager() {
+	if (!manager) manager = new require_ModalManager.default();
+	return manager;
+}
+var useModalManager = () => {
+	const modalManager = getManager();
+	const modal = (0, react.useRef)({
+		dialog: null,
+		backdrop: null
+	});
+	return {
+		get dialog() {
+			return modal.current?.dialog;
+		},
+		add: (containerElement, containerClassName) => modalManager.add(modal.current, containerElement, containerClassName),
+		remove: () => modalManager.remove(modal.current),
+		isTopModal: () => modalManager.isTopModal(modal.current),
+		setDialogRef: (0, react.useCallback)((ref) => {
+			modal.current.dialog = ref;
+		}, []),
+		setBackdropRef: (0, react.useCallback)((ref) => {
+			modal.current.backdrop = ref;
+		}, [])
+	};
+};
+var Modal = require_forwardRef.forwardRef((props, ref) => {
+	const { as, children, transition: Transition, dialogTransitionTimeout, style, className, container, animationProps, containerClassName, keyboard = true, enforceFocus = true, backdrop = true, backdropTransitionTimeout, backdropStyle, backdropClassName, open, autoFocus = true, onEsc, onExit, onExiting, onExited, onEnter, onEntering, onEntered, onClose, onOpen, ...rest } = props;
+	const [exited, setExited] = (0, react.useState)(!open);
+	const { Portal, target: containerElement } = require_usePortal.default({ container });
+	const modal = useModalManager();
+	if (open) {
+		if (exited) setExited(false);
+	} else if (!Transition && !exited) setExited(true);
+	const mountModal = open || Transition && !exited;
+	const lastFocus = (0, react.useRef)(null);
+	const handleDocumentKeyDown = require_useEventCallback.default((event) => {
+		if (keyboard && event.key === require_index$1.KEY_VALUES.ESC && modal.isTopModal()) {
+			onEsc?.(event);
+			onClose?.(event);
+		}
+	});
+	const restoreLastFocus = (0, react.useCallback)(() => {
+		if (lastFocus.current) {
+			lastFocus.current.focus?.();
+			lastFocus.current = null;
+		}
+	}, []);
+	/**
+	* Determines if the currently focused element is inside the dialog,
+	* and if not, returns the focus to the dialog.
+	*
+	*/
+	const handleFocusDialog = require_useEventCallback.default((onBeforeFocusCallback) => {
+		const currentActiveElement = document.activeElement;
+		const dialog = modal.dialog;
+		if (dialog && currentActiveElement && !require_contains.default(dialog, currentActiveElement)) {
+			onBeforeFocusCallback?.();
+			dialog.focus();
+		}
+	});
+	const handleEnforceFocus = require_useEventCallback.default(() => {
+		if (!enforceFocus || !modal.isTopModal()) return;
+		handleFocusDialog();
+	});
+	const documentKeyDownListener = (0, react.useRef)(null);
+	const documentFocusListener = (0, react.useRef)(null);
+	const handleOpen = require_useEventCallback.default(() => {
+		if (containerElement) modal.add(containerElement, containerClassName);
+		if (!documentKeyDownListener.current) documentKeyDownListener.current = require_on.default(document, "keydown", handleDocumentKeyDown);
+		if (!documentFocusListener.current) documentFocusListener.current = require_on.default(document, "focus", handleEnforceFocus, true);
+		if (autoFocus) handleFocusDialog(() => {
+			lastFocus.current = document.activeElement;
+		});
+		onOpen?.();
+	});
+	const handleClose = require_useEventCallback.default(() => {
+		modal.remove();
+		documentKeyDownListener.current?.off();
+		documentKeyDownListener.current = null;
+		documentFocusListener.current?.off();
+		documentFocusListener.current = null;
+		restoreLastFocus();
+	});
+	(0, react.useEffect)(() => {
+		if (!open) return;
+		handleOpen();
+	}, [open, handleOpen]);
+	(0, react.useEffect)(() => {
+		if (!exited) return;
+		handleClose();
+	}, [exited, handleClose]);
+	require_useWillUnmount.default(() => {
+		handleClose();
+	});
+	const handleExited = (0, react.useCallback)(() => {
+		setExited(true);
+	}, []);
+	const overlayContainer = (0, react.useCallback)(() => {
+		return modal.dialog;
+	}, [modal.dialog]);
+	if (!mountModal) return null;
+	const renderBackdrop = () => {
+		if (Transition) return /*#__PURE__*/ react.default.createElement(require_Fade.default, {
+			transitionAppear: true,
+			in: open,
+			timeout: backdropTransitionTimeout
+		}, (fadeProps, ref) => {
+			const { className, ...rest } = fadeProps;
+			return /*#__PURE__*/ react.default.createElement("div", require_extends._extends({
+				"aria-hidden": true,
+				"data-testid": "backdrop"
+			}, rest, {
+				style: backdropStyle,
+				ref: require_mergeRefs.default(modal.setBackdropRef, ref),
+				className: (0, import_classnames.default)(backdropClassName, className)
+			}));
+		});
+		return /*#__PURE__*/ react.default.createElement("div", {
+			"aria-hidden": true,
+			style: backdropStyle,
+			className: backdropClassName
+		});
+	};
+	const dialogElement = Transition ? /*#__PURE__*/ react.default.createElement(Transition, require_extends._extends({}, animationProps, {
+		transitionAppear: true,
+		unmountOnExit: true,
+		in: open,
+		timeout: dialogTransitionTimeout,
+		onExit,
+		onExiting,
+		onExited: require_createChainedFunction.default(handleExited, onExited),
+		onEnter,
+		onEntering,
+		onEntered
+	}), children) : children;
+	return /*#__PURE__*/ react.default.createElement(require_OverlayProvider.OverlayProvider, { overlayContainer }, /*#__PURE__*/ react.default.createElement(Portal, null, backdrop && renderBackdrop(), /*#__PURE__*/ react.default.createElement(require_index$2.default, require_extends._extends({ as }, rest, {
+		ref: require_mergeRefs.default(modal.setDialogRef, ref),
+		style,
+		className,
+		tabIndex: -1
+	}), dialogElement)));
+});
+Modal.displayName = "OverlayModal";
+//#endregion
+exports.default = Modal;

package/dist/node_modules/rsuite/esm/internals/Overlay/Modal.js

@@ -0,0 +1,166 @@
+"use client";
+import { __toESM } from "../../../../../_virtual/_rolldown/runtime.js";
+import { _extends } from "../../../../@babel/runtime/helpers/esm/extends.js";
+import { forwardRef as forwardRef$1 } from "../utils/react/forwardRef.js";
+import { require_classnames } from "../../../../classnames/index.js";
+import { KEY_VALUES } from "../constants/index.js";
+import mergeRefs from "../utils/react/mergeRefs.js";
+import createChainedFunction from "../utils/createChainedFunction.js";
+import useEventCallback from "../hooks/useEventCallback.js";
+import on from "../../../../dom-lib/esm/on.js";
+import usePortal from "../hooks/usePortal.js";
+import contains_default from "../../../../dom-lib/esm/contains.js";
+import useWillUnmount from "../hooks/useWillUnmount.js";
+import Box_default from "../Box/index.js";
+import Fade from "../../Animation/Fade.js";
+import { OverlayProvider } from "./OverlayProvider.js";
+import ModalManager from "./ModalManager.js";
+import React, { useCallback, useEffect, useRef, useState } from "react";
+//#region ../../node_modules/rsuite/esm/internals/Overlay/Modal.js
+var import_classnames = /* @__PURE__ */ __toESM(require_classnames());
+var manager;
+function getManager() {
+	if (!manager) manager = new ModalManager();
+	return manager;
+}
+var useModalManager = () => {
+	const modalManager = getManager();
+	const modal = useRef({
+		dialog: null,
+		backdrop: null
+	});
+	return {
+		get dialog() {
+			return modal.current?.dialog;
+		},
+		add: (containerElement, containerClassName) => modalManager.add(modal.current, containerElement, containerClassName),
+		remove: () => modalManager.remove(modal.current),
+		isTopModal: () => modalManager.isTopModal(modal.current),
+		setDialogRef: useCallback((ref) => {
+			modal.current.dialog = ref;
+		}, []),
+		setBackdropRef: useCallback((ref) => {
+			modal.current.backdrop = ref;
+		}, [])
+	};
+};
+var Modal = forwardRef$1((props, ref) => {
+	const { as, children, transition: Transition, dialogTransitionTimeout, style, className, container, animationProps, containerClassName, keyboard = true, enforceFocus = true, backdrop = true, backdropTransitionTimeout, backdropStyle, backdropClassName, open, autoFocus = true, onEsc, onExit, onExiting, onExited, onEnter, onEntering, onEntered, onClose, onOpen, ...rest } = props;
+	const [exited, setExited] = useState(!open);
+	const { Portal, target: containerElement } = usePortal({ container });
+	const modal = useModalManager();
+	if (open) {
+		if (exited) setExited(false);
+	} else if (!Transition && !exited) setExited(true);
+	const mountModal = open || Transition && !exited;
+	const lastFocus = useRef(null);
+	const handleDocumentKeyDown = useEventCallback((event) => {
+		if (keyboard && event.key === KEY_VALUES.ESC && modal.isTopModal()) {
+			onEsc?.(event);
+			onClose?.(event);
+		}
+	});
+	const restoreLastFocus = useCallback(() => {
+		if (lastFocus.current) {
+			lastFocus.current.focus?.();
+			lastFocus.current = null;
+		}
+	}, []);
+	/**
+	* Determines if the currently focused element is inside the dialog,
+	* and if not, returns the focus to the dialog.
+	*
+	*/
+	const handleFocusDialog = useEventCallback((onBeforeFocusCallback) => {
+		const currentActiveElement = document.activeElement;
+		const dialog = modal.dialog;
+		if (dialog && currentActiveElement && !contains_default(dialog, currentActiveElement)) {
+			onBeforeFocusCallback?.();
+			dialog.focus();
+		}
+	});
+	const handleEnforceFocus = useEventCallback(() => {
+		if (!enforceFocus || !modal.isTopModal()) return;
+		handleFocusDialog();
+	});
+	const documentKeyDownListener = useRef(null);
+	const documentFocusListener = useRef(null);
+	const handleOpen = useEventCallback(() => {
+		if (containerElement) modal.add(containerElement, containerClassName);
+		if (!documentKeyDownListener.current) documentKeyDownListener.current = on(document, "keydown", handleDocumentKeyDown);
+		if (!documentFocusListener.current) documentFocusListener.current = on(document, "focus", handleEnforceFocus, true);
+		if (autoFocus) handleFocusDialog(() => {
+			lastFocus.current = document.activeElement;
+		});
+		onOpen?.();
+	});
+	const handleClose = useEventCallback(() => {
+		modal.remove();
+		documentKeyDownListener.current?.off();
+		documentKeyDownListener.current = null;
+		documentFocusListener.current?.off();
+		documentFocusListener.current = null;
+		restoreLastFocus();
+	});
+	useEffect(() => {
+		if (!open) return;
+		handleOpen();
+	}, [open, handleOpen]);
+	useEffect(() => {
+		if (!exited) return;
+		handleClose();
+	}, [exited, handleClose]);
+	useWillUnmount(() => {
+		handleClose();
+	});
+	const handleExited = useCallback(() => {
+		setExited(true);
+	}, []);
+	const overlayContainer = useCallback(() => {
+		return modal.dialog;
+	}, [modal.dialog]);
+	if (!mountModal) return null;
+	const renderBackdrop = () => {
+		if (Transition) return /*#__PURE__*/ React.createElement(Fade, {
+			transitionAppear: true,
+			in: open,
+			timeout: backdropTransitionTimeout
+		}, (fadeProps, ref) => {
+			const { className, ...rest } = fadeProps;
+			return /*#__PURE__*/ React.createElement("div", _extends({
+				"aria-hidden": true,
+				"data-testid": "backdrop"
+			}, rest, {
+				style: backdropStyle,
+				ref: mergeRefs(modal.setBackdropRef, ref),
+				className: (0, import_classnames.default)(backdropClassName, className)
+			}));
+		});
+		return /*#__PURE__*/ React.createElement("div", {
+			"aria-hidden": true,
+			style: backdropStyle,
+			className: backdropClassName
+		});
+	};
+	const dialogElement = Transition ? /*#__PURE__*/ React.createElement(Transition, _extends({}, animationProps, {
+		transitionAppear: true,
+		unmountOnExit: true,
+		in: open,
+		timeout: dialogTransitionTimeout,
+		onExit,
+		onExiting,
+		onExited: createChainedFunction(handleExited, onExited),
+		onEnter,
+		onEntering,
+		onEntered
+	}), children) : children;
+	return /*#__PURE__*/ React.createElement(OverlayProvider, { overlayContainer }, /*#__PURE__*/ React.createElement(Portal, null, backdrop && renderBackdrop(), /*#__PURE__*/ React.createElement(Box_default, _extends({ as }, rest, {
+		ref: mergeRefs(modal.setDialogRef, ref),
+		style,
+		className,
+		tabIndex: -1
+	}), dialogElement)));
+});
+Modal.displayName = "OverlayModal";
+//#endregion
+export { Modal as default };

package/dist/node_modules/rsuite/esm/internals/Overlay/ModalManager.cjs

@@ -0,0 +1,76 @@
+"use client";
+const require_addStyle = require("../../../../dom-lib/esm/addStyle.cjs");
+const require_getStyle = require("../../../../dom-lib/esm/getStyle.cjs");
+const require_addClass = require("../../../../dom-lib/esm/addClass.cjs");
+const require_removeClass = require("../../../../dom-lib/esm/removeClass.cjs");
+const require_getScrollbarSize = require("../../../../dom-lib/esm/getScrollbarSize.cjs");
+const require_isOverflowing = require("../../../../dom-lib/esm/isOverflowing.cjs");
+//#region ../../node_modules/rsuite/esm/internals/Overlay/ModalManager.js
+function findIndexOf(arr, cb) {
+	let index = -1;
+	arr.some((d, i) => {
+		if (cb(d, i)) {
+			index = i;
+			return true;
+		}
+		return false;
+	});
+	return index;
+}
+function findContainer(data, modal) {
+	return findIndexOf(data, (d) => d.modals.indexOf(modal) !== -1);
+}
+var ModalManager = class {
+	modals = [];
+	containers = [];
+	data = [];
+	add(modal, container, className) {
+		let modalIndex = this.modals.indexOf(modal);
+		const containerIndex = this.containers.indexOf(container);
+		if (modalIndex !== -1) return modalIndex;
+		modalIndex = this.modals.length;
+		this.modals.push(modal);
+		if (containerIndex !== -1) {
+			this.data[containerIndex].modals.push(modal);
+			return modalIndex;
+		}
+		const containerState = {
+			modals: [modal],
+			classes: className ? className.split(/\s+/) : [],
+			style: {
+				overflow: container.style.overflow,
+				paddingRight: container.style.paddingRight
+			},
+			overflowing: require_isOverflowing.default(container)
+		};
+		if (containerState.overflowing) {
+			const paddingRight = parseInt(require_getStyle.default(container, "paddingRight") || 0, 10);
+			const barSize = require_getScrollbarSize.default();
+			require_addStyle.default(container, { paddingRight: (barSize ? paddingRight + barSize : paddingRight) + "px" });
+		}
+		containerState.classes.forEach(require_addClass.default.bind(null, container));
+		this.containers.push(container);
+		this.data.push(containerState);
+		return modalIndex;
+	}
+	remove(modal) {
+		const modalIndex = this.modals.indexOf(modal);
+		if (modalIndex === -1) return;
+		const containerIndex = findContainer(this.data, modal);
+		const containerState = this.data[containerIndex];
+		const container = this.containers[containerIndex];
+		containerState.modals.splice(containerState.modals.indexOf(modal), 1);
+		this.modals.splice(modalIndex, 1);
+		if (containerState.modals.length === 0) {
+			Object.keys(containerState.style).forEach((key) => container.style[key] = containerState.style[key]);
+			containerState.classes.forEach(require_removeClass.default.bind(null, container));
+			this.containers.splice(containerIndex, 1);
+			this.data.splice(containerIndex, 1);
+		}
+	}
+	isTopModal(modal) {
+		return !!this.modals.length && this.modals[this.modals.length - 1] === modal;
+	}
+};
+//#endregion
+exports.default = ModalManager;

package/dist/node_modules/rsuite/esm/internals/Overlay/ModalManager.js

@@ -0,0 +1,76 @@
+"use client";
+import addStyle from "../../../../dom-lib/esm/addStyle.js";
+import getStyle from "../../../../dom-lib/esm/getStyle.js";
+import addClass from "../../../../dom-lib/esm/addClass.js";
+import removeClass from "../../../../dom-lib/esm/removeClass.js";
+import getScrollbarSize from "../../../../dom-lib/esm/getScrollbarSize.js";
+import isOverflowing from "../../../../dom-lib/esm/isOverflowing.js";
+//#region ../../node_modules/rsuite/esm/internals/Overlay/ModalManager.js
+function findIndexOf(arr, cb) {
+	let index = -1;
+	arr.some((d, i) => {
+		if (cb(d, i)) {
+			index = i;
+			return true;
+		}
+		return false;
+	});
+	return index;
+}
+function findContainer(data, modal) {
+	return findIndexOf(data, (d) => d.modals.indexOf(modal) !== -1);
+}
+var ModalManager = class {
+	modals = [];
+	containers = [];
+	data = [];
+	add(modal, container, className) {
+		let modalIndex = this.modals.indexOf(modal);
+		const containerIndex = this.containers.indexOf(container);
+		if (modalIndex !== -1) return modalIndex;
+		modalIndex = this.modals.length;
+		this.modals.push(modal);
+		if (containerIndex !== -1) {
+			this.data[containerIndex].modals.push(modal);
+			return modalIndex;
+		}
+		const containerState = {
+			modals: [modal],
+			classes: className ? className.split(/\s+/) : [],
+			style: {
+				overflow: container.style.overflow,
+				paddingRight: container.style.paddingRight
+			},
+			overflowing: isOverflowing(container)
+		};
+		if (containerState.overflowing) {
+			const paddingRight = parseInt(getStyle(container, "paddingRight") || 0, 10);
+			const barSize = getScrollbarSize();
+			addStyle(container, { paddingRight: (barSize ? paddingRight + barSize : paddingRight) + "px" });
+		}
+		containerState.classes.forEach(addClass.bind(null, container));
+		this.containers.push(container);
+		this.data.push(containerState);
+		return modalIndex;
+	}
+	remove(modal) {
+		const modalIndex = this.modals.indexOf(modal);
+		if (modalIndex === -1) return;
+		const containerIndex = findContainer(this.data, modal);
+		const containerState = this.data[containerIndex];
+		const container = this.containers[containerIndex];
+		containerState.modals.splice(containerState.modals.indexOf(modal), 1);
+		this.modals.splice(modalIndex, 1);
+		if (containerState.modals.length === 0) {
+			Object.keys(containerState.style).forEach((key) => container.style[key] = containerState.style[key]);
+			containerState.classes.forEach(removeClass.bind(null, container));
+			this.containers.splice(containerIndex, 1);
+			this.data.splice(containerIndex, 1);
+		}
+	}
+	isTopModal(modal) {
+		return !!this.modals.length && this.modals[this.modals.length - 1] === modal;
+	}
+};
+//#endregion
+export { ModalManager as default };

package/dist/node_modules/rsuite/esm/internals/Overlay/Overlay.cjs

@@ -0,0 +1,81 @@
+"use client";
+const require_runtime = require("../../../../../_virtual/_rolldown/runtime.cjs");
+const require_extends = require("../../../../@babel/runtime/helpers/esm/extends.cjs");
+const require_css = require("../utils/style-sheet/css.cjs");
+const require_index = require("../../../../classnames/index.cjs");
+const require_mergeRefs = require("../utils/react/mergeRefs.cjs");
+const require_useRootClose = require("../hooks/useRootClose.cjs");
+const require_Fade = require("../../Animation/Fade.cjs");
+const require_Position = require("./Position.cjs");
+const require_OverlayProvider = require("./OverlayProvider.cjs");
+let react = require("react");
+react = require_runtime.__toESM(react);
+//#region ../../node_modules/rsuite/esm/internals/Overlay/Overlay.js
+var import_classnames = /* @__PURE__ */ require_runtime.__toESM(require_index.default);
+/**
+* Overlay is a powerful component that helps you create floating components.
+* @private
+*/
+var Overlay = /*#__PURE__*/ react.default.forwardRef((props, ref) => {
+	const { overlayContainer } = require_OverlayProvider.useOverlay();
+	const { container = overlayContainer, containerPadding, placement, rootClose, children, childrenProps, transition: Transition = require_Fade.default, open, preventOverflow, triggerTarget, onClose, onExited, onExit, onExiting, onEnter, onEntering, onEntered, followCursor, cursorPosition } = props;
+	const [exited, setExited] = (0, react.useState)(!open);
+	const overlayTarget = (0, react.useRef)(null);
+	if (open) {
+		if (exited) setExited(false);
+	} else if (!Transition && !exited) setExited(true);
+	const mountOverlay = open || Transition && !exited;
+	const handleExited = (0, react.useCallback)((args) => {
+		setExited(true);
+		onExited?.(args);
+	}, [onExited]);
+	require_useRootClose.default(onClose, {
+		triggerTarget,
+		overlayTarget,
+		disabled: !rootClose || !mountOverlay
+	});
+	if (!mountOverlay) return null;
+	const positionProps = {
+		container,
+		containerPadding,
+		triggerTarget,
+		placement,
+		preventOverflow,
+		followCursor,
+		cursorPosition
+	};
+	const renderChildWithPosition = (transitionProps, transitionRef) => {
+		const { className } = transitionProps || {};
+		return /*#__PURE__*/ react.default.createElement(require_Position.default, require_extends._extends({}, positionProps, transitionProps, { ref: require_mergeRefs.default(ref, transitionRef) }), (positionChildProps, childRef) => {
+			const { left, top } = positionChildProps;
+			if (typeof children === "function") return children({
+				className,
+				...positionChildProps,
+				...childrenProps
+			}, require_mergeRefs.default(childRef, overlayTarget));
+			const childElement = children;
+			const childStyles = require_css.mergeStyles(require_Position.getPositionStyle(left, top), childElement.props.style);
+			return /*#__PURE__*/ react.default.cloneElement(childElement, {
+				...childrenProps,
+				...childElement.props,
+				className: (0, import_classnames.default)(childElement.props.className, className),
+				style: childStyles,
+				ref: require_mergeRefs.default(childRef, overlayTarget)
+			});
+		});
+	};
+	if (Transition) return /*#__PURE__*/ react.default.createElement(Transition, {
+		in: open,
+		transitionAppear: true,
+		onExit,
+		onExiting,
+		onExited: handleExited,
+		onEnter,
+		onEntering,
+		onEntered
+	}, renderChildWithPosition);
+	return renderChildWithPosition();
+});
+Overlay.displayName = "Overlay";
+//#endregion
+exports.default = Overlay;