ropav 0.1.6 → 0.1.7

package/dist/floating.js

@@ -1,44 +1,354 @@
 import { t as useControllableValue } from "./useControllableValue.js";
+import { i as querySelectorSafe, t as isElement } from "./query.js";
+import { r as normalizeDelay } from "./number.js";
+import { i as isNodeWithinElement, r as isEventWithinTargets } from "./events.js";
 import { computed, onBeforeUnmount, onMounted, shallowRef, toValue, watch } from "vue";
-//#region src/components/floating/useHoverDisclosure.ts
-var DEFAULT_OPEN_DELAY = 0;
-var DEFAULT_CLOSE_DELAY = 0;
-function isElement(value) {
-	return typeof Element !== "undefined" && value instanceof Element;
+//#region src/components/floating/hoverDisclosureInteractionModel.ts
+function createHoverDisclosureInteractionModel() {
+	let state = createInteractionState();
+	return {
+		read: () => state,
+		send(action) {
+			state = reduceHoverDisclosureInteraction(state, action);
+			return state;
+		}
+	};
+}
+function hasActiveHoverDisclosureInteraction(state) {
+	return state.triggerHovered || state.contentHovered || state.triggerFocused || state.contentFocused || state.touchPinned;
 }
-function resolveSelector(selector) {
-	if (typeof document === "undefined") return null;
-	try {
-		return document.querySelector(selector);
-	} catch {
-		return null;
+function reduceHoverDisclosureInteraction(state, action) {
+	switch (action.type) {
+		case "hover": return setPartInteraction(state, action.part, "hover", action.active);
+		case "focus": return setPartInteraction(state, action.part, "focus", action.active);
+		case "pointer-down": return {
+			...state,
+			touchClickPending: false,
+			touchPointerActive: action.touch
+		};
+		case "pointer-up": return {
+			...state,
+			touchClickPending: action.touch && state.touchPointerActive,
+			touchPointerActive: false
+		};
+		case "pointer-cancel": return {
+			...state,
+			touchClickPending: false,
+			touchPointerActive: false
+		};
+		case "consume-touch-click": return {
+			...state,
+			touchClickPending: false
+		};
+		case "set-touch-pinned": return {
+			...state,
+			touchPinned: action.pinned
+		};
+		case "reset": return resetInteraction(state, action.part);
 	}
 }
-function resolveInteractionTarget(target) {
-	if (!target) return null;
-	if (typeof target === "string") return resolveSelector(target);
-	if (isElement(target)) return target;
-	return isElement(target.contextElement) ? target.contextElement : null;
+function createInteractionState() {
+	return {
+		contentFocused: false,
+		contentHovered: false,
+		touchClickPending: false,
+		touchPinned: false,
+		touchPointerActive: false,
+		triggerFocused: false,
+		triggerHovered: false
+	};
 }
-function resolveContentTarget(target) {
-	if (!target) return null;
-	return typeof target === "string" ? resolveSelector(target) : isElement(target) ? target : null;
+function setPartInteraction(state, part, interaction, active) {
+	if (part === "trigger" && interaction === "hover") return {
+		...state,
+		triggerHovered: active
+	};
+	if (part === "trigger") return {
+		...state,
+		triggerFocused: active
+	};
+	if (interaction === "hover") return {
+		...state,
+		contentHovered: active
+	};
+	return {
+		...state,
+		contentFocused: active
+	};
 }
-function readDelay(value, fallback) {
-	if (value == null) return fallback;
-	return Number.isFinite(value) ? Math.max(0, value) : fallback;
+function resetInteraction(state, part) {
+	if (part === "all") return createInteractionState();
+	if (part === "trigger") return {
+		...state,
+		triggerFocused: false,
+		triggerHovered: false
+	};
+	return {
+		...state,
+		contentFocused: false,
+		contentHovered: false
+	};
 }
-function eventElement(event) {
-	return isElement(event.currentTarget) ? event.currentTarget : null;
+//#endregion
+//#region src/components/floating/useHoverDisclosureInteractions.ts
+function useHoverDisclosureInteractions({ commands, interaction, options, state, targets }) {
+	function rememberTarget(part, event) {
+		const currentTarget = isElement(event.currentTarget) ? event.currentTarget : null;
+		if (part === "trigger") {
+			targets.triggerElement = currentTarget ?? targets.resolvedInteractionTarget.value ?? targets.triggerElement;
+			return;
+		}
+		targets.contentElement = currentTarget ?? targets.resolvedContentTarget.value ?? targets.contentElement;
+	}
+	function onTriggerPointerenter(event) {
+		rememberTarget("trigger", event);
+		if (event.pointerType === "touch" || commands.isDisabled.value) return;
+		interaction.send({
+			type: "hover",
+			part: "trigger",
+			active: true
+		});
+		requestOpen("hover", event, "delayed");
+	}
+	function onTriggerPointerleave(event) {
+		rememberTarget("trigger", event);
+		if (event.pointerType === "touch") return;
+		interaction.send({
+			type: "hover",
+			part: "trigger",
+			active: false
+		});
+		requestClose("hover", event, "delayed");
+	}
+	function onContentPointerenter(event) {
+		rememberTarget("content", event);
+		if (event.pointerType === "touch" || commands.isDisabled.value) return;
+		interaction.send({
+			type: "hover",
+			part: "content",
+			active: true
+		});
+		commands.cancelScheduledClose();
+	}
+	function onContentPointerleave(event) {
+		rememberTarget("content", event);
+		if (event.pointerType === "touch") return;
+		interaction.send({
+			type: "hover",
+			part: "content",
+			active: false
+		});
+		requestClose("hover", event, "delayed");
+	}
+	function onTriggerFocusin(event) {
+		rememberTarget("trigger", event);
+		if (commands.isDisabled.value || toValue(options.openOnFocus) === false) return;
+		interaction.send({
+			type: "focus",
+			part: "trigger",
+			active: true
+		});
+		requestOpen("focus", event, "immediate");
+	}
+	function onTriggerFocusout(event) {
+		rememberTarget("trigger", event);
+		if (!focusLeavesCurrentTarget(event)) return;
+		interaction.send({
+			type: "focus",
+			part: "trigger",
+			active: false
+		});
+		requestClose("focus", event, "delayed");
+	}
+	function onContentFocusin(event) {
+		rememberTarget("content", event);
+		if (commands.isDisabled.value) return;
+		interaction.send({
+			type: "focus",
+			part: "content",
+			active: true
+		});
+		commands.cancelScheduledClose();
+	}
+	function onContentFocusout(event) {
+		rememberTarget("content", event);
+		if (!focusLeavesCurrentTarget(event)) return;
+		interaction.send({
+			type: "focus",
+			part: "content",
+			active: false
+		});
+		requestClose("focus", event, "delayed");
+	}
+	function onTriggerPointerdown(event) {
+		rememberTarget("trigger", event);
+		interaction.send({
+			type: "pointer-down",
+			touch: event.pointerType === "touch"
+		});
+	}
+	function onTriggerPointerup(event) {
+		rememberTarget("trigger", event);
+		interaction.send({
+			type: "pointer-up",
+			touch: event.pointerType === "touch"
+		});
+	}
+	function onTriggerPointercancel(event) {
+		rememberTarget("trigger", event);
+		interaction.send({ type: "pointer-cancel" });
+	}
+	function onTriggerClick(event) {
+		rememberTarget("trigger", event);
+		const interactionState = interaction.read();
+		if (!interactionState.touchClickPending) return;
+		interaction.send({ type: "consume-touch-click" });
+		if (getTouchBehavior() !== "toggle" || commands.isDisabled.value) return;
+		event.preventDefault();
+		if (interactionState.touchPinned || commands.isRequestedOpen()) {
+			interaction.send({
+				type: "set-touch-pinned",
+				pinned: false
+			});
+			requestClose("touch", event, "immediate");
+			return;
+		}
+		interaction.send({
+			type: "set-touch-pinned",
+			pinned: true
+		});
+		requestOpen("touch", event, "immediate");
+	}
+	function onContentPointerdown(event) {
+		rememberTarget("content", event);
+	}
+	function onKeydown(event) {
+		if (event.key !== "Escape" || toValue(options.closeOnEscape) === false || !commands.isOpen.value) return;
+		interaction.send({
+			type: "set-touch-pinned",
+			pinned: false
+		});
+		requestClose("escape", event, "immediate");
+	}
+	function onOutsidePointerdown(event) {
+		if (!interaction.read().touchPinned) return;
+		interaction.send({
+			type: "set-touch-pinned",
+			pinned: false
+		});
+		requestClose("outside", event, "immediate");
+	}
+	function onTargetDetached(part) {
+		interaction.send({
+			type: "reset",
+			part
+		});
+		requestClose("hover", void 0, "delayed");
+	}
+	function requestOpen(reason, event, timing) {
+		commands.request({
+			event,
+			open: true,
+			reason,
+			timing
+		});
+	}
+	function requestClose(reason, event, timing) {
+		commands.request({
+			event,
+			open: false,
+			reason,
+			timing
+		});
+	}
+	function getTouchBehavior() {
+		return toValue(options.touchBehavior) ?? "none";
+	}
+	const presentation = createInteractionPresentation(state, {
+		content: {
+			onFocusin: onContentFocusin,
+			onFocusout: onContentFocusout,
+			onKeydown,
+			onPointerdown: onContentPointerdown,
+			onPointerenter: onContentPointerenter,
+			onPointerleave: onContentPointerleave
+		},
+		trigger: {
+			onClick: onTriggerClick,
+			onFocusin: onTriggerFocusin,
+			onFocusout: onTriggerFocusout,
+			onKeydown,
+			onPointercancel: onTriggerPointercancel,
+			onPointerdown: onTriggerPointerdown,
+			onPointerenter: onTriggerPointerenter,
+			onPointerleave: onTriggerPointerleave,
+			onPointerup: onTriggerPointerup
+		}
+	});
+	watch(() => getTouchBehavior(), (behavior) => {
+		if (behavior === "toggle" || !interaction.read().touchPinned) return;
+		interaction.send({
+			type: "set-touch-pinned",
+			pinned: false
+		});
+		requestClose("touch", void 0, "immediate");
+	});
+	return {
+		bindingAdapter: {
+			contentListeners: presentation.contentListeners,
+			isOutsideDismissalActive: () => interaction.read().touchPinned,
+			onDocumentKeydown: onKeydown,
+			onOutsidePointerdown,
+			onTargetDetached,
+			triggerListeners: presentation.triggerListeners
+		},
+		contentProps: presentation.contentProps,
+		triggerProps: presentation.triggerProps
+	};
+}
+function createInteractionPresentation(state, handlers) {
+	const triggerProps = computed(() => ({
+		"data-state": state.value,
+		...handlers.trigger
+	}));
+	const contentProps = computed(() => ({
+		"data-state": state.value,
+		...handlers.content
+	}));
+	const triggerListeners = [
+		["pointerenter", handlers.trigger.onPointerenter],
+		["pointerleave", handlers.trigger.onPointerleave],
+		["pointerdown", handlers.trigger.onPointerdown],
+		["pointerup", handlers.trigger.onPointerup],
+		["pointercancel", handlers.trigger.onPointercancel],
+		["click", handlers.trigger.onClick],
+		["focusin", handlers.trigger.onFocusin],
+		["focusout", handlers.trigger.onFocusout],
+		["keydown", handlers.trigger.onKeydown]
+	];
+	return {
+		contentListeners: [
+			["pointerenter", handlers.content.onPointerenter],
+			["pointerleave", handlers.content.onPointerleave],
+			["pointerdown", handlers.content.onPointerdown],
+			["focusin", handlers.content.onFocusin],
+			["focusout", handlers.content.onFocusout],
+			["keydown", handlers.content.onKeydown]
+		],
+		contentProps,
+		triggerListeners,
+		triggerProps
+	};
 }
 function focusLeavesCurrentTarget(event) {
-	const currentTarget = eventElement(event);
-	const nextTarget = event.relatedTarget;
-	return !(currentTarget && typeof Node !== "undefined" && nextTarget instanceof Node && currentTarget.contains(nextTarget));
+	const currentTarget = isElement(event.currentTarget) ? event.currentTarget : null;
+	return !isNodeWithinElement(event.relatedTarget, currentTarget);
 }
-function useHoverDisclosure(options = {}) {
-	const resolvedInteractionTarget = shallowRef(null);
-	const resolvedContentTarget = shallowRef(null);
+//#endregion
+//#region src/components/floating/useHoverDisclosureOpenState.ts
+var defaultOpenDelay = 0;
+var defaultCloseDelay = 0;
+function useHoverDisclosureOpenState({ interaction, onContentClosed, options }) {
 	const controlledOpen = computed(() => toValue(options.open));
 	const isDisabled = computed(() => Boolean(toValue(options.disabled)));
 	let pendingChangeDetails;
@@ -53,318 +363,200 @@ function useHoverDisclosure(options = {}) {
 	const isOpen = computed(() => !isDisabled.value && openState.value);
 	const state = computed(() => isOpen.value ? "open" : "closed");
 	let requestedOpen = openState.value;
-	let triggerHovered = false;
-	let contentHovered = false;
-	let triggerFocused = false;
-	let contentFocused = false;
-	let touchPinned = false;
-	let touchPointerActive = false;
-	let touchClickPending = false;
-	let triggerElement = null;
-	let contentElement = null;
 	let openTimer;
 	let closeTimer;
-	let documentListenersActive = false;
 	let disposed = false;
-	function getOpenDelay() {
-		return readDelay(toValue(options.openDelay), DEFAULT_OPEN_DELAY);
-	}
-	function getCloseDelay() {
-		return readDelay(toValue(options.closeDelay), DEFAULT_CLOSE_DELAY);
-	}
-	function getTouchBehavior() {
-		return toValue(options.touchBehavior) ?? "none";
-	}
-	function clearOpenTimer() {
-		if (openTimer === void 0) return;
-		clearTimeout(openTimer);
-		openTimer = void 0;
-	}
-	function clearCloseTimer() {
-		if (closeTimer === void 0) return;
-		clearTimeout(closeTimer);
-		closeTimer = void 0;
-	}
-	function clearTimers() {
-		clearOpenTimer();
-		clearCloseTimer();
-	}
-	function hasActiveInteraction() {
-		return triggerHovered || contentHovered || triggerFocused || contentFocused || touchPinned;
-	}
-	function setOpen(nextOpen, reason, event) {
-		if (disposed || nextOpen && isDisabled.value || requestedOpen === nextOpen) return;
-		requestedOpen = nextOpen;
-		pendingChangeDetails = {
-			reason,
-			event
-		};
-		try {
-			controllableOpen.setValue(nextOpen);
-		} finally {
-			pendingChangeDetails = void 0;
+	function request(change) {
+		if (change.open) requestOpen(change);
+		else requestClose(change);
+	}
+	function requestOpen(change) {
+		if (change.timing === "immediate") {
+			clearTimers();
+			setOpen(true, change.reason, change.event);
+			return;
 		}
-	}
-	function openImmediately(reason, event) {
-		clearTimers();
-		setOpen(true, reason, event);
-	}
-	function closeImmediately(reason, event) {
-		clearTimers();
-		setOpen(false, reason, event);
-	}
-	function scheduleOpen(reason, event) {
 		if (disposed || isDisabled.value) return;
 		clearCloseTimer();
 		clearOpenTimer();
 		if (requestedOpen) return;
-		const delay = getOpenDelay();
+		const delay = normalizeDelay(toValue(options.openDelay), defaultOpenDelay);
 		if (delay === 0) {
-			setOpen(true, reason, event);
+			setOpen(true, change.reason, change.event);
 			return;
 		}
 		openTimer = setTimeout(() => {
 			openTimer = void 0;
-			if (!triggerHovered || isDisabled.value) return;
-			setOpen(true, reason, event);
+			if (!interaction.read().triggerHovered || isDisabled.value) return;
+			setOpen(true, change.reason, change.event);
 		}, delay);
 	}
-	function scheduleClose(reason, event) {
+	function requestClose(change) {
+		if (change.timing === "immediate") {
+			clearTimers();
+			setOpen(false, change.reason, change.event);
+			return;
+		}
 		clearOpenTimer();
 		clearCloseTimer();
-		if (disposed || hasActiveInteraction()) return;
+		if (disposed || hasActiveHoverDisclosureInteraction(interaction.read())) return;
 		closeTimer = setTimeout(() => {
 			closeTimer = void 0;
-			if (hasActiveInteraction()) return;
-			setOpen(false, reason, event);
-		}, getCloseDelay());
+			if (hasActiveHoverDisclosureInteraction(interaction.read())) return;
+			setOpen(false, change.reason, change.event);
+		}, normalizeDelay(toValue(options.closeDelay), defaultCloseDelay));
 	}
-	function rememberTrigger(event) {
-		triggerElement = eventElement(event) ?? resolvedInteractionTarget.value ?? triggerElement;
-	}
-	function rememberContent(event) {
-		contentElement = eventElement(event) ?? resolvedContentTarget.value ?? contentElement;
-	}
-	function onTriggerPointerenter(event) {
-		rememberTrigger(event);
-		if (event.pointerType === "touch" || isDisabled.value) return;
-		triggerHovered = true;
-		scheduleOpen("hover", event);
-	}
-	function onTriggerPointerleave(event) {
-		rememberTrigger(event);
-		if (event.pointerType === "touch") return;
-		triggerHovered = false;
-		scheduleClose("hover", event);
-	}
-	function onContentPointerenter(event) {
-		rememberContent(event);
-		if (event.pointerType === "touch" || isDisabled.value) return;
-		contentHovered = true;
-		clearCloseTimer();
-	}
-	function onContentPointerleave(event) {
-		rememberContent(event);
-		if (event.pointerType === "touch") return;
-		contentHovered = false;
-		scheduleClose("hover", event);
-	}
-	function onTriggerFocusin(event) {
-		rememberTrigger(event);
-		if (isDisabled.value || toValue(options.openOnFocus) === false) return;
-		triggerFocused = true;
-		openImmediately("focus", event);
-	}
-	function onTriggerFocusout(event) {
-		rememberTrigger(event);
-		if (!focusLeavesCurrentTarget(event)) return;
-		triggerFocused = false;
-		scheduleClose("focus", event);
-	}
-	function onContentFocusin(event) {
-		rememberContent(event);
-		if (isDisabled.value) return;
-		contentFocused = true;
-		clearCloseTimer();
-	}
-	function onContentFocusout(event) {
-		rememberContent(event);
-		if (!focusLeavesCurrentTarget(event)) return;
-		contentFocused = false;
-		scheduleClose("focus", event);
-	}
-	function onTriggerPointerdown(event) {
-		rememberTrigger(event);
-		touchPointerActive = event.pointerType === "touch";
-		touchClickPending = false;
-	}
-	function onTriggerPointerup(event) {
-		rememberTrigger(event);
-		touchClickPending = event.pointerType === "touch" && touchPointerActive;
-		touchPointerActive = false;
-	}
-	function onTriggerPointercancel(event) {
-		rememberTrigger(event);
-		touchPointerActive = false;
-		touchClickPending = false;
-	}
-	function onTriggerClick(event) {
-		rememberTrigger(event);
-		if (!touchClickPending) return;
-		touchClickPending = false;
-		if (getTouchBehavior() !== "toggle" || isDisabled.value) return;
-		event.preventDefault();
-		if (touchPinned || requestedOpen) {
-			touchPinned = false;
-			closeImmediately("touch", event);
-			return;
+	function setOpen(nextOpen, reason, event) {
+		if (disposed || nextOpen && isDisabled.value || requestedOpen === nextOpen) return;
+		requestedOpen = nextOpen;
+		pendingChangeDetails = {
+			reason,
+			event
+		};
+		try {
+			controllableOpen.setValue(nextOpen);
+		} finally {
+			pendingChangeDetails = void 0;
 		}
-		touchPinned = true;
-		openImmediately("touch", event);
 	}
-	function onContentPointerdown(event) {
-		rememberContent(event);
+	function cancelScheduledClose() {
+		clearCloseTimer();
 	}
-	function onKeydown(event) {
-		if (event.key !== "Escape" || toValue(options.closeOnEscape) === false || !isOpen.value) return;
-		touchPinned = false;
-		closeImmediately("escape", event);
+	function isRequestedOpen() {
+		return requestedOpen;
 	}
 	function open() {
-		openImmediately("programmatic");
+		request({
+			open: true,
+			reason: "programmatic",
+			timing: "immediate"
+		});
 	}
 	function close() {
-		touchPinned = false;
-		closeImmediately("programmatic");
+		interaction.send({
+			type: "set-touch-pinned",
+			pinned: false
+		});
+		request({
+			open: false,
+			reason: "programmatic",
+			timing: "immediate"
+		});
 	}
 	function toggle() {
 		if (requestedOpen || isOpen.value) close();
 		else open();
 	}
-	function isEventInside(event) {
-		const elements = [
-			triggerElement,
-			contentElement,
-			resolvedInteractionTarget.value,
-			resolvedContentTarget.value
-		].filter((element) => element !== null);
-		const path = typeof event.composedPath === "function" ? event.composedPath() : [];
-		if (elements.some((element) => path.includes(element))) return true;
-		const target = event.target;
-		return typeof Node !== "undefined" && target instanceof Node && elements.some((element) => element.contains(target));
+	function clearOpenTimer() {
+		if (openTimer === void 0) return;
+		clearTimeout(openTimer);
+		openTimer = void 0;
 	}
-	function onDocumentPointerdown(event) {
-		if (!touchPinned || isEventInside(event)) return;
-		touchPinned = false;
-		closeImmediately("outside", event);
+	function clearCloseTimer() {
+		if (closeTimer === void 0) return;
+		clearTimeout(closeTimer);
+		closeTimer = void 0;
 	}
-	function setDocumentListeners(active) {
-		if (typeof document === "undefined" || active === documentListenersActive) return;
-		documentListenersActive = active;
-		const method = active ? "addEventListener" : "removeEventListener";
-		document[method]("keydown", onKeydown);
-		document[method]("pointerdown", onDocumentPointerdown, true);
+	function clearTimers() {
+		clearOpenTimer();
+		clearCloseTimer();
 	}
+	watch([openState, controllableOpen.isControlled], ([value]) => {
+		requestedOpen = value;
+		if (value) return;
+		interaction.send({
+			type: "reset",
+			part: "content"
+		});
+		interaction.send({
+			type: "set-touch-pinned",
+			pinned: false
+		});
+		onContentClosed();
+	}, { flush: "sync" });
+	watch(isDisabled, (disabled) => {
+		if (!disabled) return;
+		interaction.send({
+			type: "reset",
+			part: "all"
+		});
+		request({
+			open: false,
+			reason: "disabled",
+			timing: "immediate"
+		});
+	});
+	onBeforeUnmount(() => {
+		disposed = true;
+		clearTimers();
+	});
+	return {
+		cancelScheduledClose,
+		close,
+		isDisabled,
+		isOpen,
+		isRequestedOpen,
+		open,
+		request,
+		state,
+		toggle
+	};
+}
+//#endregion
+//#region src/components/floating/useHoverDisclosureTargetBinding.ts
+function createHoverDisclosureTargetState() {
+	return {
+		contentElement: null,
+		resolvedContentTarget: shallowRef(null),
+		resolvedInteractionTarget: shallowRef(null),
+		triggerElement: null
+	};
+}
+function useHoverDisclosureTargetBinding({ adapter, isOpen, options, targets }) {
+	let documentListenersActive = false;
 	function syncInteractionTarget() {
-		resolvedInteractionTarget.value = resolveInteractionTarget(toValue(options.interactionTarget));
+		targets.resolvedInteractionTarget.value = resolveInteractionTarget(toValue(options.interactionTarget));
 	}
 	function syncContentTarget() {
-		resolvedContentTarget.value = resolveContentTarget(toValue(options.contentTarget));
-	}
-	function bindTriggerTarget(target, cleanup) {
-		triggerElement = target;
-		target.addEventListener("pointerenter", onTriggerPointerenter);
-		target.addEventListener("pointerleave", onTriggerPointerleave);
-		target.addEventListener("pointerdown", onTriggerPointerdown);
-		target.addEventListener("pointerup", onTriggerPointerup);
-		target.addEventListener("pointercancel", onTriggerPointercancel);
-		target.addEventListener("click", onTriggerClick);
-		target.addEventListener("focusin", onTriggerFocusin);
-		target.addEventListener("focusout", onTriggerFocusout);
-		target.addEventListener("keydown", onKeydown);
-		cleanup(() => {
-			target.removeEventListener("pointerenter", onTriggerPointerenter);
-			target.removeEventListener("pointerleave", onTriggerPointerleave);
-			target.removeEventListener("pointerdown", onTriggerPointerdown);
-			target.removeEventListener("pointerup", onTriggerPointerup);
-			target.removeEventListener("pointercancel", onTriggerPointercancel);
-			target.removeEventListener("click", onTriggerClick);
-			target.removeEventListener("focusin", onTriggerFocusin);
-			target.removeEventListener("focusout", onTriggerFocusout);
-			target.removeEventListener("keydown", onKeydown);
-			if (triggerElement === target) triggerElement = null;
-			triggerHovered = false;
-			triggerFocused = false;
-			scheduleClose("hover");
-		});
+		targets.resolvedContentTarget.value = resolveContentTarget(toValue(options.contentTarget));
 	}
-	function bindContentTarget(target, cleanup) {
-		contentElement = target;
-		target.addEventListener("pointerenter", onContentPointerenter);
-		target.addEventListener("pointerleave", onContentPointerleave);
-		target.addEventListener("pointerdown", onContentPointerdown);
-		target.addEventListener("focusin", onContentFocusin);
-		target.addEventListener("focusout", onContentFocusout);
-		target.addEventListener("keydown", onKeydown);
+	function syncTargets() {
+		syncInteractionTarget();
+		syncContentTarget();
+	}
+	function bindTarget(part, target, listeners, cleanup) {
+		setCurrentTarget(part, target);
+		for (const [type, listener] of listeners) target.addEventListener(type, listener);
 		cleanup(() => {
-			target.removeEventListener("pointerenter", onContentPointerenter);
-			target.removeEventListener("pointerleave", onContentPointerleave);
-			target.removeEventListener("pointerdown", onContentPointerdown);
-			target.removeEventListener("focusin", onContentFocusin);
-			target.removeEventListener("focusout", onContentFocusout);
-			target.removeEventListener("keydown", onKeydown);
-			if (contentElement === target) contentElement = null;
-			contentHovered = false;
-			contentFocused = false;
-			scheduleClose("hover");
+			for (const [type, listener] of listeners) target.removeEventListener(type, listener);
+			clearCurrentTarget(part, target);
+			adapter.onTargetDetached(part);
 		});
 	}
-	const triggerProps = computed(() => ({
-		"data-state": state.value,
-		onPointerenter: onTriggerPointerenter,
-		onPointerleave: onTriggerPointerleave,
-		onPointerdown: onTriggerPointerdown,
-		onPointerup: onTriggerPointerup,
-		onPointercancel: onTriggerPointercancel,
-		onClick: onTriggerClick,
-		onFocusin: onTriggerFocusin,
-		onFocusout: onTriggerFocusout,
-		onKeydown
-	}));
-	const contentProps = computed(() => ({
-		"data-state": state.value,
-		onPointerenter: onContentPointerenter,
-		onPointerleave: onContentPointerleave,
-		onPointerdown: onContentPointerdown,
-		onFocusin: onContentFocusin,
-		onFocusout: onContentFocusout,
-		onKeydown
-	}));
-	watch([openState, controllableOpen.isControlled], ([value]) => {
-		requestedOpen = value;
-		if (!value) {
-			contentHovered = false;
-			contentFocused = false;
-			contentElement = null;
-			touchPinned = false;
+	function setCurrentTarget(part, target) {
+		if (part === "trigger") targets.triggerElement = target;
+		else targets.contentElement = target;
+	}
+	function clearCurrentTarget(part, target) {
+		if (part === "trigger" && targets.triggerElement === target) targets.triggerElement = null;
+		if (part === "content" && targets.contentElement === target) targets.contentElement = null;
+	}
+	function onDocumentPointerdown(event) {
+		if (!adapter.isOutsideDismissalActive()) return;
+		if (isEventInsideTargets(event, targets)) return;
+		adapter.onOutsidePointerdown(event);
+	}
+	function setDocumentListeners(active) {
+		if (typeof document === "undefined" || active === documentListenersActive) return;
+		documentListenersActive = active;
+		if (active) {
+			document.addEventListener("keydown", adapter.onDocumentKeydown);
+			document.addEventListener("pointerdown", onDocumentPointerdown, true);
+			return;
 		}
-	}, { flush: "sync" });
-	watch(isDisabled, (disabled) => {
-		if (!disabled) return;
-		triggerHovered = false;
-		contentHovered = false;
-		triggerFocused = false;
-		contentFocused = false;
-		touchPinned = false;
-		touchPointerActive = false;
-		touchClickPending = false;
-		closeImmediately("disabled");
-	});
-	watch(() => getTouchBehavior(), (behavior) => {
-		if (behavior === "toggle" || !touchPinned) return;
-		touchPinned = false;
-		closeImmediately("touch");
-	});
+		document.removeEventListener("keydown", adapter.onDocumentKeydown);
+		document.removeEventListener("pointerdown", onDocumentPointerdown, true);
+	}
 	watch(() => toValue(options.interactionTarget), syncInteractionTarget, {
 		flush: "post",
 		immediate: true
@@ -373,42 +565,79 @@ function useHoverDisclosure(options = {}) {
 		flush: "post",
 		immediate: true
 	});
-	watch(resolvedInteractionTarget, (target, _previous, cleanup) => {
-		if (target) bindTriggerTarget(target, cleanup);
+	watch(targets.resolvedInteractionTarget, (target, _previous, cleanup) => {
+		if (target) bindTarget("trigger", target, adapter.triggerListeners, cleanup);
 	}, {
 		flush: "sync",
 		immediate: true
 	});
-	watch(resolvedContentTarget, (target, _previous, cleanup) => {
-		if (target) bindContentTarget(target, cleanup);
+	watch(targets.resolvedContentTarget, (target, _previous, cleanup) => {
+		if (target) bindTarget("content", target, adapter.contentListeners, cleanup);
 	}, {
 		flush: "sync",
 		immediate: true
 	});
 	watch(isOpen, setDocumentListeners, { flush: "sync" });
-	watch(isOpen, () => {
-		syncInteractionTarget();
-		syncContentTarget();
-	}, { flush: "post" });
+	watch(isOpen, syncTargets, { flush: "post" });
 	onMounted(() => {
-		syncInteractionTarget();
-		syncContentTarget();
+		syncTargets();
 		setDocumentListeners(isOpen.value);
 	});
-	onBeforeUnmount(() => {
-		disposed = true;
-		clearTimers();
-		setDocumentListeners(false);
+	onBeforeUnmount(() => setDocumentListeners(false));
+}
+function resolveInteractionTarget(target) {
+	if (!target) return null;
+	if (typeof target === "string") return querySelectorSafe(target);
+	if (isElement(target)) return target;
+	return isElement(target.contextElement) ? target.contextElement : null;
+}
+function resolveContentTarget(target) {
+	if (!target) return null;
+	if (typeof target === "string") return querySelectorSafe(target);
+	return isElement(target) ? target : null;
+}
+function isEventInsideTargets(event, targets) {
+	return isEventWithinTargets(event, [
+		targets.triggerElement,
+		targets.contentElement,
+		targets.resolvedInteractionTarget.value,
+		targets.resolvedContentTarget.value
+	].filter((element) => element !== null));
+}
+//#endregion
+//#region src/components/floating/useHoverDisclosure.ts
+function useHoverDisclosure(options = {}) {
+	const interaction = createHoverDisclosureInteractionModel();
+	const targets = createHoverDisclosureTargetState();
+	const openState = useHoverDisclosureOpenState({
+		interaction,
+		onContentClosed: () => {
+			targets.contentElement = null;
+		},
+		options
+	});
+	const { bindingAdapter, contentProps, triggerProps } = useHoverDisclosureInteractions({
+		commands: openState,
+		interaction,
+		options,
+		state: openState.state,
+		targets
+	});
+	useHoverDisclosureTargetBinding({
+		adapter: bindingAdapter,
+		isOpen: openState.isOpen,
+		options,
+		targets
 	});
 	return {
-		isOpen,
-		isDisabled,
-		state,
+		isOpen: openState.isOpen,
+		isDisabled: openState.isDisabled,
+		state: openState.state,
 		triggerProps,
 		contentProps,
-		open,
-		close,
-		toggle
+		open: openState.open,
+		close: openState.close,
+		toggle: openState.toggle
 	};
 }
 //#endregion