const require_rolldown_runtime = require('../rolldown-runtime.cjs');
const require_shared_getActiveElement = require('../shared/getActiveElement.cjs');
const require_Drawer_utils = require('../Drawer/utils.cjs');
const vue = require_rolldown_runtime.__toESM(require("vue"));

//#region src/Drawer/composables/useDrawerVirtualKeyboard.ts
/** Viewport shrinkage below this is browser chrome moving, not the keyboard. */
const KEYBOARD_RESIZE_THRESHOLD = 60;
/** Gap kept between the focused field and the edges of the visible band. */
const KEYBOARD_VISIBILITY_MARGIN = 16;
const KEYBOARD_REALIGN_INTERVAL = 150;
const KEYBOARD_REALIGN_MAX_PASSES = 4;
/** Frames the alignment waits for its scroll destination to stop moving. */
const KEYBOARD_SETTLE_FRAME_LIMIT = 60;
/** Travel that turns a tap into a scroll/swipe. */
const INPUT_TAP_MOVE_THRESHOLD = 10;
const INPUT_TAP_HIT_SLOP = 16;
const KEYBOARD_INPUT_TYPES = new Set([
	"email",
	"number",
	"password",
	"search",
	"tel",
	"text",
	"url"
]);
const INTERACTIVE_SELECTOR = "button,a[href],select,[role=\"button\"],[tabindex]:not([tabindex=\"-1\"]),input:not([type=\"hidden\"]):not([disabled]),textarea:not([disabled]),[contenteditable]:not([contenteditable=\"false\"])";
/**
* The lift point landed on another interactive element. Distinct from `null` so
* the caller does not fall back to the touchstart target and steal that tap.
*/
const KEYBOARD_TAP_BLOCKED = Symbol("KeyboardTapBlocked");
function isKeyboardInputElement(element) {
	if (element.isContentEditable) return true;
	const win = element.ownerDocument.defaultView ?? window;
	if (element instanceof win.HTMLTextAreaElement || element instanceof win.HTMLInputElement && KEYBOARD_INPUT_TYPES.has(element.type)) return !element.matches(":disabled");
	return false;
}
/** Nodes inside a `contenteditable` are not focusable; the editing host is. */
function getContentEditableHost(element) {
	let host = element;
	while (host.parentElement?.isContentEditable) host = host.parentElement;
	return host;
}
/**
* Normalizes a target to the element the keyboard is attached to: the field
* itself, its `contenteditable` host, or the control a `<label>` points at.
*/
function resolveKeyboardInputTarget(target) {
	if (!(target instanceof HTMLElement)) return null;
	if (isKeyboardInputElement(target)) return target.isContentEditable ? getContentEditableHost(target) : target;
	const control = target.closest("label")?.control;
	return control instanceof HTMLElement && isKeyboardInputElement(control) ? control : null;
}
function resolveKeyboardTouchTarget(target) {
	const focusTarget = resolveKeyboardInputTarget(target);
	return focusTarget ? {
		focusTarget,
		clickTarget: target
	} : null;
}
function getElementAtPoint(root, x, y) {
	const elementFromPoint = root.elementFromPoint;
	return typeof elementFromPoint === "function" ? elementFromPoint.call(root, x, y) : null;
}
/**
* iOS retargets taps while the page reacts to the keyboard, so points around
* the lift point are probed too — but never at the cost of a tap that landed on
* another interactive element.
*/
function resolveKeyboardTouchTargetFromPoint(root, clientX, clientY) {
	const exactTarget = getElementAtPoint(root, clientX, clientY);
	if (exactTarget instanceof HTMLElement) {
		const focusTarget = resolveKeyboardInputTarget(exactTarget);
		if (focusTarget) return {
			focusTarget,
			clickTarget: exactTarget
		};
	}
	if (exactTarget?.closest(INTERACTIVE_SELECTOR) != null || exactTarget?.closest("label") != null) return KEYBOARD_TAP_BLOCKED;
	for (const [offsetX, offsetY] of [
		[0, INPUT_TAP_HIT_SLOP],
		[0, -INPUT_TAP_HIT_SLOP],
		[INPUT_TAP_HIT_SLOP, 0],
		[-INPUT_TAP_HIT_SLOP, 0]
	]) {
		const focusTarget = resolveKeyboardInputTarget(getElementAtPoint(root, clientX + offsetX, clientY + offsetY));
		if (focusTarget) return {
			focusTarget,
			clickTarget: focusTarget
		};
	}
	return null;
}
function dispatchKeyboardClick(target, touch) {
	const win = target.ownerDocument.defaultView ?? window;
	const ClickEvent = win.PointerEvent ?? win.MouseEvent;
	const init = {
		bubbles: true,
		cancelable: true,
		clientX: touch.clientX,
		clientY: touch.clientY,
		detail: 1
	};
	let event;
	try {
		event = new ClickEvent("click", {
			...init,
			view: win
		});
	} catch {
		event = new ClickEvent("click", init);
	}
	target.dispatchEvent(event);
}
/**
* Overrides the painted geometry WebKit samples when an element takes focus.
* The rect is hidden rather than detached so layout is unaffected; the caller
* must restore it before the next paint.
*/
function overrideGeometryDuringFocus(target, translateY) {
	const { opacity, transform, transition } = target.style;
	target.style.transition = "none";
	target.style.opacity = "0";
	target.style.transform = `translateY(${translateY}px)`;
	return () => {
		target.style.opacity = opacity;
		target.style.transform = transform;
		target.style.transition = transition;
	};
}
/**
* iOS Safari scrolls the page toward a focused field even inside a transformed
* sheet, so the field is moved off-screen for the synchronous focus call only.
*/
function focusKeyboardInputWithoutPageScroll(target) {
	const wasFocused = require_shared_getActiveElement.getActiveElement() === target;
	const restore = overrideGeometryDuringFocus(target, -2e3);
	try {
		if (wasFocused) target.blur();
		target.focus({ preventScroll: true });
	} finally {
		restore();
	}
}
function isVerticallyScrollable(element, allowOverflowIntent) {
	const win = element.ownerDocument.defaultView ?? window;
	const { overflowY } = win.getComputedStyle(element);
	if (overflowY !== "auto" && overflowY !== "scroll") return false;
	return allowOverflowIntent ? element.clientHeight > 0 : element.scrollHeight > element.clientHeight;
}
/** The parent in the flat tree: crosses slots and shadow roots. */
function getParentNode(node) {
	if (node instanceof Element && node.assignedSlot) return node.assignedSlot;
	const parent = node.parentNode;
	return parent instanceof ShadowRoot ? parent.host : parent;
}
function findScrollableAncestor(start, root, allowOverflowIntent) {
	let node = start;
	while (node instanceof HTMLElement && node !== root && node.nodeName !== "BODY" && node.nodeName !== "HTML") {
		if (isVerticallyScrollable(node, allowOverflowIntent)) return node;
		node = getParentNode(node);
	}
	return isVerticallyScrollable(root, allowOverflowIntent) ? root : null;
}
/**
* The scroller that can move the field out from under the keyboard. Starts at
* the parent: scrolling the field's own content never moves its box.
*/
function findKeyboardScrollTarget(target, root) {
	const start = getParentNode(target);
	return findScrollableAncestor(start, root, false) ?? findScrollableAncestor(start, root, true);
}
/**
* Keyboard-aware focus and scroll handling for drawers with form fields.
* Ported from Base UI `DrawerVirtualKeyboardProvider`.
*
* Publishes `--drawer-keyboard-inset` — the height the keyboard covers — while
* a field inside the drawer is focused, and keeps that field scrolled into the
* band left visible above the keyboard. Styling stays in CSS.
*/
function useDrawerVirtualKeyboard(options) {
	const { enabled, elementRef, modal = true, nestedDrawerOpen = false } = options;
	let focusedTarget = null;
	let scrollAdjustment = null;
	let alignFrame;
	let realignTimer;
	let programmaticFocus = false;
	let touchStart = null;
	let touchMoved = false;
	function restoreScrollAdjustment() {
		if (!scrollAdjustment) return;
		const { element, paddingBottom, scrollPaddingBottom, overflowAnchor } = scrollAdjustment;
		element.style.paddingBottom = paddingBottom;
		element.style.scrollPaddingBottom = scrollPaddingBottom;
		element.style.overflowAnchor = overflowAnchor;
		scrollAdjustment = null;
	}
	function setScrollSlack(element, slack) {
		const rounded = Math.max(0, Math.ceil(slack));
		if (scrollAdjustment && (!scrollAdjustment.element.isConnected || scrollAdjustment.element !== element)) restoreScrollAdjustment();
		if (rounded === 0) {
			restoreScrollAdjustment();
			return;
		}
		if (!scrollAdjustment) {
			const styles = (element.ownerDocument.defaultView ?? window).getComputedStyle(element);
			scrollAdjustment = {
				element,
				paddingBottom: element.style.paddingBottom,
				scrollPaddingBottom: element.style.scrollPaddingBottom,
				overflowAnchor: element.style.overflowAnchor,
				computedPaddingBottom: Number.parseFloat(styles.paddingBottom) || 0,
				computedScrollPaddingBottom: Number.parseFloat(styles.scrollPaddingBottom) || 0
			};
		}
		element.style.overflowAnchor = "none";
		element.style.paddingBottom = `${rounded + Math.max(scrollAdjustment.computedPaddingBottom, KEYBOARD_VISIBILITY_MARGIN)}px`;
		element.style.scrollPaddingBottom = `${scrollAdjustment.computedScrollPaddingBottom + KEYBOARD_VISIBILITY_MARGIN}px`;
	}
	function animateScroll(element, scrollTop) {
		const win = element.ownerDocument.defaultView ?? window;
		const reducedMotion = win.matchMedia?.("(prefers-reduced-motion: reduce)")?.matches;
		element.scrollTo?.({
			top: scrollTop,
			behavior: reducedMotion ? "auto" : "smooth"
		});
	}
	function cancelPendingAlignment() {
		if (alignFrame !== void 0) {
			cancelAnimationFrame(alignFrame);
			alignFrame = void 0;
		}
		if (realignTimer !== void 0) {
			clearTimeout(realignTimer);
			realignTimer = void 0;
		}
	}
	(0, vue.watchEffect)((onCleanup) => {
		if (!(0, vue.toValue)(enabled) || !elementRef.value) return;
		const root = elementRef.value;
		const doc = root.ownerDocument;
		const win = doc.defaultView ?? window;
		let scrollElement = null;
		let scrollDestination = 0;
		let scrollChecks = 0;
		let scrollObserved = -1;
		let keyboardVisualHeight = -1;
		let smallViewportProbe = null;
		/**
		* The band of the layout viewport still visible with the keyboard up, or
		* `null` when it is closed — or the measurement can't be trusted (no
		* `visualViewport`, or the user is pinch-zoomed).
		*
		* New Chrome on iOS shrinks `svh` for the keyboard, then the layout viewport
		* down to the visual viewport, moving fixed content itself. Remembering the
		* keyboard's visual height keeps it detected once the overlap is gone; a
		* substantial change in visual height clears it.
		*/
		function getKeyboardViewport() {
			const visualViewport = win.visualViewport;
			if (!visualViewport || visualViewport.scale !== 1) return null;
			const layoutHeight = win.innerHeight;
			const visualHeight = visualViewport.height;
			if (layoutHeight - visualHeight > KEYBOARD_RESIZE_THRESHOLD) keyboardVisualHeight = visualHeight;
			else if (Math.abs(visualHeight - keyboardVisualHeight) > KEYBOARD_RESIZE_THRESHOLD) {
				keyboardVisualHeight = -1;
				return null;
			}
			if (!smallViewportProbe) {
				smallViewportProbe = doc.createElement("div");
				smallViewportProbe.style.cssText = "position:fixed;top:0;height:100svh;visibility:hidden";
				doc.body.appendChild(smallViewportProbe);
			}
			const layoutFollowsKeyboard = smallViewportProbe.offsetHeight - visualHeight <= KEYBOARD_RESIZE_THRESHOLD;
			const top = Math.max(0, visualViewport.offsetTop);
			return {
				top,
				bottom: layoutFollowsKeyboard ? layoutHeight : Math.min(layoutHeight, top + visualHeight),
				resizing: layoutFollowsKeyboard && Math.abs(layoutHeight - visualHeight) >= 1
			};
		}
		const baseScrollX = win.scrollX;
		const baseScrollY = win.scrollY;
		let restorePreemptedFocus = null;
		function setKeyboardInset(inset) {
			root.style.setProperty(require_Drawer_utils.DRAWER_CSS_VARS.keyboardInset, `${Math.max(0, Math.ceil(inset))}px`);
		}
		function consumePreemptedFocus() {
			restorePreemptedFocus?.();
			restorePreemptedFocus = null;
		}
		function preemptFocusReveal(target, keyboardViewport) {
			consumePreemptedFocus();
			const rect = target.getBoundingClientRect();
			restorePreemptedFocus = overrideGeometryDuringFocus(target, (keyboardViewport.top + keyboardViewport.bottom - rect.top - rect.bottom) / 2);
		}
		function restoreWindowScroll() {
			if (!(0, vue.toValue)(modal) || (0, vue.toValue)(nestedDrawerOpen) || !focusedTarget || win.scrollX === baseScrollX && win.scrollY === baseScrollY || getKeyboardViewport() == null) return false;
			win.scrollTo({
				left: baseScrollX,
				top: baseScrollY,
				behavior: "instant"
			});
			return true;
		}
		function clearFocusedTarget() {
			focusedTarget = null;
			scrollElement = null;
			keyboardVisualHeight = -1;
			cancelPendingAlignment();
			restoreScrollAdjustment();
			setKeyboardInset(0);
		}
		function captureTarget(target) {
			if ((0, vue.toValue)(nestedDrawerOpen)) return false;
			const resolved = resolveKeyboardInputTarget(target);
			if (!resolved || !root.contains(resolved)) return false;
			if (focusedTarget !== resolved) scrollElement = null;
			focusedTarget = resolved;
			return true;
		}
		function align() {
			consumePreemptedFocus();
			if ((0, vue.toValue)(nestedDrawerOpen) || !focusedTarget || !root.contains(focusedTarget)) {
				setKeyboardInset(0);
				restoreScrollAdjustment();
				return;
			}
			restoreWindowScroll();
			const keyboardViewport = getKeyboardViewport();
			if (!keyboardViewport) {
				setKeyboardInset(0);
				restoreScrollAdjustment();
				return;
			}
			setKeyboardInset(win.innerHeight - keyboardViewport.bottom);
			const scrollTarget = findKeyboardScrollTarget(focusedTarget, root);
			if (!scrollTarget) {
				restoreScrollAdjustment();
				return;
			}
			const scrollRect = scrollTarget.getBoundingClientRect();
			const overlap = Math.max(0, scrollRect.bottom - keyboardViewport.bottom);
			setScrollSlack(scrollTarget, overlap);
			const maxScrollTop = Math.max(0, scrollTarget.scrollHeight - scrollTarget.clientHeight);
			if (maxScrollTop <= 0) return;
			const visibleTop = Math.max(scrollRect.top, keyboardViewport.top) + KEYBOARD_VISIBILITY_MARGIN;
			const visibleBottom = Math.min(scrollRect.bottom, keyboardViewport.bottom) - KEYBOARD_VISIBILITY_MARGIN;
			if (visibleBottom <= visibleTop) return;
			const targetRect = focusedTarget.getBoundingClientRect();
			const nextScrollTop = scrollTarget.scrollTop + (targetRect.top + targetRect.bottom - visibleTop - visibleBottom) / 2;
			const destination = Math.round(Math.min(maxScrollTop, Math.max(0, nextScrollTop)));
			const settled = scrollElement === scrollTarget && !keyboardViewport.resizing && Math.abs(scrollDestination - destination) <= 1;
			if (!settled) {
				const checks = scrollElement === scrollTarget ? scrollChecks + 1 : 1;
				scrollElement = scrollTarget;
				scrollDestination = destination;
				scrollChecks = checks;
				scrollObserved = -1;
				if (checks <= KEYBOARD_SETTLE_FRAME_LIMIT) {
					scheduleAlign();
					return;
				}
			} else if (scrollObserved >= 0) {
				const current = scrollTarget.scrollTop;
				if (Math.abs(current - destination) <= 1) return;
				if (current !== scrollObserved) {
					scrollObserved = current;
					return;
				}
			}
			scrollElement = scrollTarget;
			scrollDestination = destination;
			scrollChecks = 0;
			scrollObserved = scrollTarget.scrollTop;
			animateScroll(scrollTarget, destination);
		}
		function scheduleAlign() {
			if (alignFrame !== void 0) return;
			alignFrame = requestAnimationFrame(() => {
				alignFrame = void 0;
				align();
			});
		}
		function scheduleRealignPasses() {
			if (realignTimer !== void 0) clearTimeout(realignTimer);
			let remaining = KEYBOARD_REALIGN_MAX_PASSES;
			const pass = () => {
				align();
				remaining -= 1;
				realignTimer = remaining > 0 ? setTimeout(pass, KEYBOARD_REALIGN_INTERVAL) : void 0;
			};
			realignTimer = setTimeout(pass, KEYBOARD_REALIGN_INTERVAL);
		}
		function onFocus(event) {
			if (restorePreemptedFocus && focusedTarget && focusedTarget === event.target) focusedTarget.focus({ preventScroll: true });
		}
		function onFocusIn(event) {
			programmaticFocus = false;
			consumePreemptedFocus();
			if (!captureTarget(event.target)) {
				clearFocusedTarget();
				return;
			}
			if (getKeyboardViewport()) scheduleRealignPasses();
			scheduleAlign();
		}
		function onFocusOut(event) {
			if (programmaticFocus) return;
			if (captureTarget(event.relatedTarget)) {
				const keyboardViewport = getKeyboardViewport();
				if (focusedTarget && keyboardViewport) preemptFocusReveal(focusedTarget, keyboardViewport);
				scheduleAlign();
				return;
			}
			clearFocusedTarget();
		}
		function onViewportChange() {
			if (focusedTarget || captureTarget(require_shared_getActiveElement.getActiveElement())) scheduleAlign();
		}
		function onWindowScroll() {
			if (restoreWindowScroll()) scheduleAlign();
		}
		function onPointerDown() {
			cancelPendingAlignment();
			scrollElement = null;
		}
		function resetTouchTracking() {
			touchStart = null;
			touchMoved = false;
		}
		function onTouchStart(event) {
			const touch = event.touches[0];
			touchMoved = false;
			touchStart = touch ? {
				x: touch.clientX,
				y: touch.clientY
			} : null;
		}
		function onTouchMove(event) {
			const touch = event.touches[0];
			if (!touch || !touchStart || touchMoved) return;
			if (Math.abs(touch.clientX - touchStart.x) > INPUT_TAP_MOVE_THRESHOLD || Math.abs(touch.clientY - touchStart.y) > INPUT_TAP_MOVE_THRESHOLD) touchMoved = true;
		}
		function onTouchEnd(event) {
			if ((0, vue.toValue)(nestedDrawerOpen) || !touchStart || touchMoved) {
				resetTouchTracking();
				return;
			}
			const touch = event.changedTouches[0] ?? event.touches[0];
			if (!touch) {
				resetTouchTracking();
				return;
			}
			const pointTarget = resolveKeyboardTouchTargetFromPoint(root.getRootNode(), touch.clientX, touch.clientY);
			if (pointTarget === KEYBOARD_TAP_BLOCKED) {
				resetTouchTracking();
				return;
			}
			const keyboardTarget = pointTarget ?? resolveKeyboardTouchTarget(event.target);
			if (!keyboardTarget || !root.contains(keyboardTarget.focusTarget) || !root.contains(keyboardTarget.clickTarget)) {
				resetTouchTracking();
				return;
			}
			if (win.visualViewport && win.visualViewport.scale !== 1) {
				resetTouchTracking();
				return;
			}
			if (require_shared_getActiveElement.getActiveElement() === keyboardTarget.focusTarget && (!win.visualViewport || getKeyboardViewport() != null)) {
				resetTouchTracking();
				return;
			}
			event.preventDefault();
			programmaticFocus = true;
			try {
				focusKeyboardInputWithoutPageScroll(keyboardTarget.focusTarget);
			} finally {
				programmaticFocus = false;
			}
			dispatchKeyboardClick(keyboardTarget.clickTarget, touch);
			if (keyboardTarget.clickTarget !== keyboardTarget.focusTarget && require_shared_getActiveElement.getActiveElement() === keyboardTarget.focusTarget) keyboardTarget.focusTarget.focus({ preventScroll: true });
			resetTouchTracking();
		}
		doc.addEventListener("focus", onFocus, true);
		doc.addEventListener("focusin", onFocusIn, true);
		doc.addEventListener("focusout", onFocusOut, true);
		doc.addEventListener("pointerdown", onPointerDown, true);
		win.addEventListener("scroll", onWindowScroll);
		win.visualViewport?.addEventListener("resize", onViewportChange);
		win.visualViewport?.addEventListener("scroll", onViewportChange);
		if (win.visualViewport) win.addEventListener("resize", onViewportChange);
		root.addEventListener("touchstart", onTouchStart, { passive: true });
		root.addEventListener("touchmove", onTouchMove, { passive: true });
		root.addEventListener("touchend", onTouchEnd);
		root.addEventListener("touchcancel", resetTouchTracking);
		if (captureTarget(require_shared_getActiveElement.getActiveElement())) scheduleAlign();
		onCleanup(() => {
			doc.removeEventListener("focus", onFocus, true);
			doc.removeEventListener("focusin", onFocusIn, true);
			doc.removeEventListener("focusout", onFocusOut, true);
			doc.removeEventListener("pointerdown", onPointerDown, true);
			win.removeEventListener("scroll", onWindowScroll);
			win.visualViewport?.removeEventListener("resize", onViewportChange);
			win.visualViewport?.removeEventListener("scroll", onViewportChange);
			win.removeEventListener("resize", onViewportChange);
			root.removeEventListener("touchstart", onTouchStart);
			root.removeEventListener("touchmove", onTouchMove);
			root.removeEventListener("touchend", onTouchEnd);
			root.removeEventListener("touchcancel", resetTouchTracking);
			consumePreemptedFocus();
			resetTouchTracking();
			clearFocusedTarget();
			smallViewportProbe?.remove();
			root.style.removeProperty(require_Drawer_utils.DRAWER_CSS_VARS.keyboardInset);
		});
	});
}

//#endregion
Object.defineProperty(exports, 'useDrawerVirtualKeyboard', {
  enumerable: true,
  get: function () {
    return useDrawerVirtualKeyboard;
  }
});
//# sourceMappingURL=useDrawerVirtualKeyboard.cjs.map