ropav 0.1.7 → 0.1.8

package/dist/{floating.js → useHoverDisclosure.js}

@@ -1,52 +1,57 @@
 import { t as useControllableValue } from "./useControllableValue.js";
-import { i as querySelectorSafe, t as isElement } from "./query.js";
+import { t as isElement } from "./query.js";
 import { r as normalizeDelay } from "./number.js";
-import { i as isNodeWithinElement, r as isEventWithinTargets } from "./events.js";
+import { i as isNodeWithinElement, n as isEventWithinElement, r as isEventWithinTargets } from "./events.js";
+import { t as useFloatingTargetLifecycle } from "./useFloatingTargetLifecycle.js";
 import { computed, onBeforeUnmount, onMounted, shallowRef, toValue, watch } from "vue";
-//#region src/components/floating/hoverDisclosureInteractionModel.ts
-function createHoverDisclosureInteractionModel() {
-	let state = createInteractionState();
+//#region src/components/floating/useHoverDisclosure.ts
+var DEFAULT_OPEN_DELAY = 0;
+var DEFAULT_CLOSE_DELAY = 0;
+var TOUCH_CLICK_EXPIRY_DELAY = 500;
+function useHoverDisclosure(options = {}) {
+	return useHoverDisclosureImplementation(options).disclosure;
+}
+function useHoverDisclosureWithExternalDismissal(options) {
+	return useHoverDisclosureImplementation(options, true);
+}
+function useHoverDisclosureImplementation(options, dismissalRouted = false) {
+	const interaction = createInteractionState();
+	const targets = createTargetState();
+	const commands = useHoverDisclosureOpenState(options, interaction, () => {
+		targets.contentElement = null;
+	});
+	const runtime = useHoverDisclosureInteractions({
+		commands,
+		dismissalRouted,
+		interaction,
+		options,
+		state: commands.state,
+		targets
+	});
+	useHoverDisclosureTargetBinding({
+		commands,
+		options,
+		runtime,
+		targets,
+		useDocumentDismissal: !dismissalRouted
+	});
 	return {
-		read: () => state,
-		send(action) {
-			state = reduceHoverDisclosureInteraction(state, action);
-			return state;
+		disclosure: {
+			isOpen: commands.isOpen,
+			isDisabled: commands.isDisabled,
+			state: commands.state,
+			triggerProps: runtime.triggerProps,
+			contentProps: runtime.contentProps,
+			open: commands.open,
+			close: commands.close,
+			toggle: commands.toggle
+		},
+		dismissalHandlers: {
+			escapeKeyDown: runtime.onDocumentKeydown,
+			pointerDownOutside: runtime.onOutsidePointerdown
 		}
 	};
 }
-function hasActiveHoverDisclosureInteraction(state) {
-	return state.triggerHovered || state.contentHovered || state.triggerFocused || state.contentFocused || state.touchPinned;
-}
-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 createInteractionState() {
 	return {
 		contentFocused: false,
@@ -58,40 +63,214 @@ function createInteractionState() {
 		triggerHovered: false
 	};
 }
-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
-	};
+function createTargetState() {
 	return {
-		...state,
-		contentFocused: active
+		contentElement: null,
+		resolvedContentTarget: shallowRef(null),
+		resolvedInteractionTarget: shallowRef(null),
+		triggerElement: null
 	};
 }
+function hasActiveInteraction(state) {
+	return state.triggerHovered || state.contentHovered || state.triggerFocused || state.contentFocused || state.touchPinned;
+}
+function hasPendingTouchInteraction(state) {
+	return state.touchPointerActive || state.touchClickPending;
+}
+function setPartInteraction(state, part, kind, active) {
+	if (part === "trigger" && kind === "hover") {
+		state.triggerHovered = active;
+		return;
+	}
+	if (part === "trigger") {
+		state.triggerFocused = active;
+		return;
+	}
+	if (kind === "hover") {
+		state.contentHovered = active;
+		return;
+	}
+	state.contentFocused = active;
+}
 function resetInteraction(state, part) {
-	if (part === "all") return createInteractionState();
-	if (part === "trigger") return {
-		...state,
-		triggerFocused: false,
-		triggerHovered: false
-	};
+	if (part === "all" || part === "trigger") {
+		state.triggerFocused = false;
+		state.triggerHovered = false;
+	}
+	if (part === "all" || part === "content") {
+		state.contentFocused = false;
+		state.contentHovered = false;
+	}
+	if (part === "all") {
+		state.touchClickPending = false;
+		state.touchPinned = false;
+		state.touchPointerActive = false;
+	}
+}
+function useHoverDisclosureOpenState(options, interaction, onContentClosed) {
+	const controlledOpen = computed(() => toValue(options.open));
+	const isDisabled = computed(() => Boolean(toValue(options.disabled)));
+	let pendingChangeDetails;
+	const controllableOpen = useControllableValue({
+		modelValue: () => controlledOpen.value,
+		defaultValue: () => options.defaultOpen === true && !isDisabled.value,
+		onChange: (nextOpen) => {
+			if (pendingChangeDetails) options.onOpenChange?.(nextOpen, pendingChangeDetails);
+		}
+	});
+	const openState = controllableOpen.value;
+	const isOpen = computed(() => !isDisabled.value && openState.value);
+	const state = computed(() => isOpen.value ? "open" : "closed");
+	let requestedOpen = openState.value;
+	let openTimer;
+	let closeTimer;
+	let disposed = false;
+	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;
+		}
+		if (disposed || isDisabled.value) return;
+		clearCloseTimer();
+		clearOpenTimer();
+		if (requestedOpen) return;
+		const delay = normalizeDelay(toValue(options.openDelay), DEFAULT_OPEN_DELAY);
+		if (delay === 0) {
+			setOpen(true, change.reason, change.event);
+			return;
+		}
+		openTimer = setTimeout(() => {
+			openTimer = void 0;
+			if (!interaction.triggerHovered || isDisabled.value) return;
+			setOpen(true, change.reason, change.event);
+		}, delay);
+	}
+	function requestClose(change) {
+		if (change.timing === "immediate") {
+			clearTimers();
+			setOpen(false, change.reason, change.event);
+			return;
+		}
+		clearOpenTimer();
+		clearCloseTimer();
+		if (disposed || hasActiveInteraction(interaction)) return;
+		closeTimer = setTimeout(() => {
+			closeTimer = void 0;
+			if (hasActiveInteraction(interaction)) return;
+			setOpen(false, change.reason, change.event);
+		}, normalizeDelay(toValue(options.closeDelay), DEFAULT_CLOSE_DELAY));
+	}
+	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 cancelScheduledClose() {
+		clearCloseTimer();
+	}
+	function isRequestedOpen() {
+		return requestedOpen;
+	}
+	function open() {
+		request({
+			open: true,
+			reason: "programmatic",
+			timing: "immediate"
+		});
+	}
+	function close() {
+		interaction.touchPinned = false;
+		request({
+			open: false,
+			reason: "programmatic",
+			timing: "immediate"
+		});
+	}
+	function toggle() {
+		if (requestedOpen || isOpen.value) close();
+		else open();
+	}
+	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();
+	}
+	watch([openState, controllableOpen.isControlled], ([value]) => {
+		requestedOpen = value;
+		if (value) return;
+		resetInteraction(interaction, "content");
+		interaction.touchPinned = false;
+		onContentClosed();
+	}, { flush: "sync" });
+	watch(isDisabled, (disabled) => {
+		if (!disabled) return;
+		resetInteraction(interaction, "all");
+		request({
+			open: false,
+			reason: "disabled",
+			timing: "immediate"
+		});
+	});
+	onBeforeUnmount(() => {
+		disposed = true;
+		clearTimers();
+	});
 	return {
-		...state,
-		contentFocused: false,
-		contentHovered: false
+		cancelScheduledClose,
+		close,
+		isDisabled,
+		isOpen,
+		isRequestedOpen,
+		open,
+		request,
+		state,
+		toggle
 	};
 }
-//#endregion
-//#region src/components/floating/useHoverDisclosureInteractions.ts
-function useHoverDisclosureInteractions({ commands, interaction, options, state, targets }) {
+function useHoverDisclosureInteractions({ commands, dismissalRouted, interaction, options, state, targets }) {
+	let touchClickExpiryTimer;
+	function clearTouchClickExpiryTimer() {
+		if (touchClickExpiryTimer === void 0) return;
+		clearTimeout(touchClickExpiryTimer);
+		touchClickExpiryTimer = void 0;
+	}
+	function clearPendingTouchClick() {
+		clearTouchClickExpiryTimer();
+		interaction.touchClickPending = false;
+	}
+	function scheduleTouchClickExpiry() {
+		clearTouchClickExpiryTimer();
+		touchClickExpiryTimer = setTimeout(() => {
+			touchClickExpiryTimer = void 0;
+			interaction.touchClickPending = false;
+		}, TOUCH_CLICK_EXPIRY_DELAY);
+	}
+	function originatesInContent(event) {
+		const contentTarget = targets.resolvedContentTarget.value;
+		return contentTarget !== null && contentTarget !== targets.resolvedInteractionTarget.value && isEventWithinElement(event, contentTarget);
+	}
 	function rememberTarget(part, event) {
 		const currentTarget = isElement(event.currentTarget) ? event.currentTarget : null;
 		if (part === "trigger") {
@@ -103,146 +282,112 @@ function useHoverDisclosureInteractions({ commands, interaction, options, state,
 	function onTriggerPointerenter(event) {
 		rememberTarget("trigger", event);
 		if (event.pointerType === "touch" || commands.isDisabled.value) return;
-		interaction.send({
-			type: "hover",
-			part: "trigger",
-			active: true
-		});
+		setPartInteraction(interaction, "trigger", "hover", true);
 		requestOpen("hover", event, "delayed");
 	}
 	function onTriggerPointerleave(event) {
 		rememberTarget("trigger", event);
 		if (event.pointerType === "touch") return;
-		interaction.send({
-			type: "hover",
-			part: "trigger",
-			active: false
-		});
+		setPartInteraction(interaction, "trigger", "hover", 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
-		});
+		setPartInteraction(interaction, "content", "hover", true);
 		commands.cancelScheduledClose();
 	}
 	function onContentPointerleave(event) {
 		rememberTarget("content", event);
 		if (event.pointerType === "touch") return;
-		interaction.send({
-			type: "hover",
-			part: "content",
-			active: false
-		});
+		setPartInteraction(interaction, "content", "hover", 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
-		});
+		if (commands.isDisabled.value || toValue(options.openOnFocus) === false || hasPendingTouchInteraction(interaction)) return;
+		setPartInteraction(interaction, "trigger", "focus", true);
 		requestOpen("focus", event, "immediate");
 	}
 	function onTriggerFocusout(event) {
 		rememberTarget("trigger", event);
 		if (!focusLeavesCurrentTarget(event)) return;
-		interaction.send({
-			type: "focus",
-			part: "trigger",
-			active: false
-		});
+		setPartInteraction(interaction, "trigger", "focus", false);
 		requestClose("focus", event, "delayed");
 	}
 	function onContentFocusin(event) {
 		rememberTarget("content", event);
 		if (commands.isDisabled.value) return;
-		interaction.send({
-			type: "focus",
-			part: "content",
-			active: true
-		});
+		setPartInteraction(interaction, "content", "focus", true);
 		commands.cancelScheduledClose();
 	}
 	function onContentFocusout(event) {
 		rememberTarget("content", event);
 		if (!focusLeavesCurrentTarget(event)) return;
-		interaction.send({
-			type: "focus",
-			part: "content",
-			active: false
-		});
+		setPartInteraction(interaction, "content", "focus", false);
 		requestClose("focus", event, "delayed");
 	}
 	function onTriggerPointerdown(event) {
+		if (originatesInContent(event)) return;
 		rememberTarget("trigger", event);
-		interaction.send({
-			type: "pointer-down",
-			touch: event.pointerType === "touch"
-		});
+		clearPendingTouchClick();
+		interaction.touchPointerActive = event.pointerType === "touch";
 	}
 	function onTriggerPointerup(event) {
+		if (originatesInContent(event)) return;
 		rememberTarget("trigger", event);
-		interaction.send({
-			type: "pointer-up",
-			touch: event.pointerType === "touch"
-		});
+		interaction.touchClickPending = event.pointerType === "touch" && interaction.touchPointerActive;
+		interaction.touchPointerActive = false;
+		if (interaction.touchClickPending) scheduleTouchClickExpiry();
 	}
 	function onTriggerPointercancel(event) {
+		if (originatesInContent(event)) return;
 		rememberTarget("trigger", event);
-		interaction.send({ type: "pointer-cancel" });
+		clearTouchClickExpiryTimer();
+		interaction.touchClickPending = false;
+		interaction.touchPointerActive = false;
 	}
 	function onTriggerClick(event) {
+		if (originatesInContent(event)) return;
 		rememberTarget("trigger", event);
-		const interactionState = interaction.read();
-		if (!interactionState.touchClickPending) return;
-		interaction.send({ type: "consume-touch-click" });
+		clearTouchClickExpiryTimer();
+		if (!interaction.touchClickPending) return;
+		interaction.touchClickPending = false;
 		if (getTouchBehavior() !== "toggle" || commands.isDisabled.value) return;
 		event.preventDefault();
-		if (interactionState.touchPinned || commands.isRequestedOpen()) {
-			interaction.send({
-				type: "set-touch-pinned",
-				pinned: false
-			});
+		if (interaction.touchPinned || commands.isRequestedOpen()) {
+			interaction.touchPinned = false;
 			requestClose("touch", event, "immediate");
 			return;
 		}
-		interaction.send({
-			type: "set-touch-pinned",
-			pinned: true
-		});
+		interaction.touchPinned = 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
-		});
+	function requestEscapeClose(event) {
+		if (event.key !== "Escape" || toValue(options.closeOnEscape) === false || !commands.isOpen.value) return false;
+		interaction.touchPinned = false;
 		requestClose("escape", event, "immediate");
+		return true;
+	}
+	function onKeydown(event) {
+		if (dismissalRouted || !requestEscapeClose(event)) return;
+		event.stopPropagation();
+	}
+	function onDocumentKeydown(event) {
+		requestEscapeClose(event);
 	}
 	function onOutsidePointerdown(event) {
-		if (!interaction.read().touchPinned) return;
-		interaction.send({
-			type: "set-touch-pinned",
-			pinned: false
-		});
+		if (!interaction.touchPinned) return;
+		interaction.touchPinned = false;
 		requestClose("outside", event, "immediate");
 	}
 	function onTargetDetached(part) {
-		interaction.send({
-			type: "reset",
-			part
-		});
+		clearPendingTouchClick();
+		if (part === "trigger") interaction.touchPointerActive = false;
+		resetInteraction(interaction, part);
 		requestClose("hover", void 0, "delayed");
 	}
 	function requestOpen(reason, event, timing) {
@@ -286,23 +431,19 @@ function useHoverDisclosureInteractions({ commands, interaction, options, state,
 		}
 	});
 	watch(() => getTouchBehavior(), (behavior) => {
-		if (behavior === "toggle" || !interaction.read().touchPinned) return;
-		interaction.send({
-			type: "set-touch-pinned",
-			pinned: false
-		});
+		if (behavior === "toggle" || !interaction.touchPinned) return;
+		interaction.touchPinned = false;
 		requestClose("touch", void 0, "immediate");
 	});
+	onBeforeUnmount(clearTouchClickExpiryTimer);
 	return {
-		bindingAdapter: {
-			contentListeners: presentation.contentListeners,
-			isOutsideDismissalActive: () => interaction.read().touchPinned,
-			onDocumentKeydown: onKeydown,
-			onOutsidePointerdown,
-			onTargetDetached,
-			triggerListeners: presentation.triggerListeners
-		},
+		contentListeners: presentation.contentListeners,
 		contentProps: presentation.contentProps,
+		isOutsideDismissalActive: () => interaction.touchPinned,
+		onDocumentKeydown,
+		onOutsidePointerdown,
+		onTargetDetached,
+		triggerListeners: presentation.triggerListeners,
 		triggerProps: presentation.triggerProps
 	};
 }
@@ -344,195 +485,8 @@ function focusLeavesCurrentTarget(event) {
 	const currentTarget = isElement(event.currentTarget) ? event.currentTarget : null;
 	return !isNodeWithinElement(event.relatedTarget, currentTarget);
 }
-//#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;
-	const controllableOpen = useControllableValue({
-		modelValue: () => controlledOpen.value,
-		defaultValue: () => options.defaultOpen === true && !isDisabled.value,
-		onChange: (nextOpen) => {
-			if (pendingChangeDetails) options.onOpenChange?.(nextOpen, pendingChangeDetails);
-		}
-	});
-	const openState = controllableOpen.value;
-	const isOpen = computed(() => !isDisabled.value && openState.value);
-	const state = computed(() => isOpen.value ? "open" : "closed");
-	let requestedOpen = openState.value;
-	let openTimer;
-	let closeTimer;
-	let disposed = false;
-	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;
-		}
-		if (disposed || isDisabled.value) return;
-		clearCloseTimer();
-		clearOpenTimer();
-		if (requestedOpen) return;
-		const delay = normalizeDelay(toValue(options.openDelay), defaultOpenDelay);
-		if (delay === 0) {
-			setOpen(true, change.reason, change.event);
-			return;
-		}
-		openTimer = setTimeout(() => {
-			openTimer = void 0;
-			if (!interaction.read().triggerHovered || isDisabled.value) return;
-			setOpen(true, change.reason, change.event);
-		}, delay);
-	}
-	function requestClose(change) {
-		if (change.timing === "immediate") {
-			clearTimers();
-			setOpen(false, change.reason, change.event);
-			return;
-		}
-		clearOpenTimer();
-		clearCloseTimer();
-		if (disposed || hasActiveHoverDisclosureInteraction(interaction.read())) return;
-		closeTimer = setTimeout(() => {
-			closeTimer = void 0;
-			if (hasActiveHoverDisclosureInteraction(interaction.read())) return;
-			setOpen(false, change.reason, change.event);
-		}, normalizeDelay(toValue(options.closeDelay), defaultCloseDelay));
-	}
-	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 cancelScheduledClose() {
-		clearCloseTimer();
-	}
-	function isRequestedOpen() {
-		return requestedOpen;
-	}
-	function open() {
-		request({
-			open: true,
-			reason: "programmatic",
-			timing: "immediate"
-		});
-	}
-	function close() {
-		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 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();
-	}
-	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 }) {
+function useHoverDisclosureTargetBinding({ commands, options, runtime, targets, useDocumentDismissal }) {
 	let documentListenersActive = false;
-	function syncInteractionTarget() {
-		targets.resolvedInteractionTarget.value = resolveInteractionTarget(toValue(options.interactionTarget));
-	}
-	function syncContentTarget() {
-		targets.resolvedContentTarget.value = resolveContentTarget(toValue(options.contentTarget));
-	}
-	function syncTargets() {
-		syncInteractionTarget();
-		syncContentTarget();
-	}
-	function bindTarget(part, target, listeners, cleanup) {
-		setCurrentTarget(part, target);
-		for (const [type, listener] of listeners) target.addEventListener(type, listener);
-		cleanup(() => {
-			for (const [type, listener] of listeners) target.removeEventListener(type, listener);
-			clearCurrentTarget(part, target);
-			adapter.onTargetDetached(part);
-		});
-	}
 	function setCurrentTarget(part, target) {
 		if (part === "trigger") targets.triggerElement = target;
 		else targets.contentElement = target;
@@ -541,60 +495,59 @@ function useHoverDisclosureTargetBinding({ adapter, isOpen, options, targets })
 		if (part === "trigger" && targets.triggerElement === target) targets.triggerElement = null;
 		if (part === "content" && targets.contentElement === target) targets.contentElement = null;
 	}
+	function connectTarget(part, target) {
+		setCurrentTarget(part, target);
+		return () => {
+			clearCurrentTarget(part, target);
+			runtime.onTargetDetached(part);
+		};
+	}
 	function onDocumentPointerdown(event) {
-		if (!adapter.isOutsideDismissalActive()) return;
+		if (!runtime.isOutsideDismissalActive()) return;
 		if (isEventInsideTargets(event, targets)) return;
-		adapter.onOutsidePointerdown(event);
+		runtime.onOutsidePointerdown(event);
 	}
 	function setDocumentListeners(active) {
-		if (typeof document === "undefined" || active === documentListenersActive) return;
+		if (!useDocumentDismissal || typeof document === "undefined" || active === documentListenersActive) return;
 		documentListenersActive = active;
 		if (active) {
-			document.addEventListener("keydown", adapter.onDocumentKeydown);
+			document.addEventListener("keydown", runtime.onDocumentKeydown);
 			document.addEventListener("pointerdown", onDocumentPointerdown, true);
 			return;
 		}
-		document.removeEventListener("keydown", adapter.onDocumentKeydown);
+		document.removeEventListener("keydown", runtime.onDocumentKeydown);
 		document.removeEventListener("pointerdown", onDocumentPointerdown, true);
 	}
-	watch(() => toValue(options.interactionTarget), syncInteractionTarget, {
-		flush: "post",
-		immediate: true
+	const fallbackTarget = shallowRef(null);
+	const interactionTargetLifecycle = useFloatingTargetLifecycle({
+		target: () => toValue(options.interactionTarget),
+		fallback: fallbackTarget,
+		getTargetElement: (reference) => {
+			if (isElement(reference)) return reference;
+			return isElement(reference.contextElement) ? reference.contextElement : null;
+		}
 	});
-	watch(() => toValue(options.contentTarget), syncContentTarget, {
-		flush: "post",
-		immediate: true
+	const contentTargetLifecycle = useFloatingTargetLifecycle({
+		target: () => toValue(options.contentTarget),
+		fallback: fallbackTarget
 	});
-	watch(targets.resolvedInteractionTarget, (target, _previous, cleanup) => {
-		if (target) bindTarget("trigger", target, adapter.triggerListeners, cleanup);
-	}, {
-		flush: "sync",
-		immediate: true
+	targets.resolvedInteractionTarget = interactionTargetLifecycle.targetElement;
+	targets.resolvedContentTarget = contentTargetLifecycle.targetElement;
+	interactionTargetLifecycle.bindTarget({
+		connect: (target) => connectTarget("trigger", target),
+		listeners: runtime.triggerListeners
 	});
-	watch(targets.resolvedContentTarget, (target, _previous, cleanup) => {
-		if (target) bindTarget("content", target, adapter.contentListeners, cleanup);
-	}, {
-		flush: "sync",
-		immediate: true
+	contentTargetLifecycle.bindTarget({
+		connect: (target) => connectTarget("content", target),
+		listeners: runtime.contentListeners
 	});
-	watch(isOpen, setDocumentListeners, { flush: "sync" });
-	watch(isOpen, syncTargets, { flush: "post" });
+	watch(commands.isOpen, setDocumentListeners, { flush: "sync" });
 	onMounted(() => {
-		syncTargets();
-		setDocumentListeners(isOpen.value);
+		setDocumentListeners(commands.isOpen.value);
+	});
+	onBeforeUnmount(() => {
+		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, [
@@ -605,40 +558,4 @@ function isEventInsideTargets(event, targets) {
 	].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: openState.isOpen,
-		isDisabled: openState.isDisabled,
-		state: openState.state,
-		triggerProps,
-		contentProps,
-		open: openState.open,
-		close: openState.close,
-		toggle: openState.toggle
-	};
-}
-//#endregion
-export { useHoverDisclosure as t };
+export { useHoverDisclosureWithExternalDismissal as n, useHoverDisclosure as t };