ropav 0.1.6 → 0.1.8

package/dist/floating.js

@@ -1,415 +0,0 @@
-import { t as useControllableValue } from "./useControllableValue.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;
-}
-function resolveSelector(selector) {
-	if (typeof document === "undefined") return null;
-	try {
-		return document.querySelector(selector);
-	} catch {
-		return null;
-	}
-}
-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 resolveContentTarget(target) {
-	if (!target) return null;
-	return typeof target === "string" ? resolveSelector(target) : isElement(target) ? target : null;
-}
-function readDelay(value, fallback) {
-	if (value == null) return fallback;
-	return Number.isFinite(value) ? Math.max(0, value) : fallback;
-}
-function eventElement(event) {
-	return isElement(event.currentTarget) ? event.currentTarget : null;
-}
-function focusLeavesCurrentTarget(event) {
-	const currentTarget = eventElement(event);
-	const nextTarget = event.relatedTarget;
-	return !(currentTarget && typeof Node !== "undefined" && nextTarget instanceof Node && currentTarget.contains(nextTarget));
-}
-function useHoverDisclosure(options = {}) {
-	const resolvedInteractionTarget = shallowRef(null);
-	const resolvedContentTarget = shallowRef(null);
-	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 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 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();
-		if (delay === 0) {
-			setOpen(true, reason, event);
-			return;
-		}
-		openTimer = setTimeout(() => {
-			openTimer = void 0;
-			if (!triggerHovered || isDisabled.value) return;
-			setOpen(true, reason, event);
-		}, delay);
-	}
-	function scheduleClose(reason, event) {
-		clearOpenTimer();
-		clearCloseTimer();
-		if (disposed || hasActiveInteraction()) return;
-		closeTimer = setTimeout(() => {
-			closeTimer = void 0;
-			if (hasActiveInteraction()) return;
-			setOpen(false, reason, event);
-		}, getCloseDelay());
-	}
-	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;
-		}
-		touchPinned = true;
-		openImmediately("touch", event);
-	}
-	function onContentPointerdown(event) {
-		rememberContent(event);
-	}
-	function onKeydown(event) {
-		if (event.key !== "Escape" || toValue(options.closeOnEscape) === false || !isOpen.value) return;
-		touchPinned = false;
-		closeImmediately("escape", event);
-	}
-	function open() {
-		openImmediately("programmatic");
-	}
-	function close() {
-		touchPinned = false;
-		closeImmediately("programmatic");
-	}
-	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 onDocumentPointerdown(event) {
-		if (!touchPinned || isEventInside(event)) return;
-		touchPinned = false;
-		closeImmediately("outside", event);
-	}
-	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 syncInteractionTarget() {
-		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");
-		});
-	}
-	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);
-		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");
-		});
-	}
-	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;
-		}
-	}, { 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");
-	});
-	watch(() => toValue(options.interactionTarget), syncInteractionTarget, {
-		flush: "post",
-		immediate: true
-	});
-	watch(() => toValue(options.contentTarget), syncContentTarget, {
-		flush: "post",
-		immediate: true
-	});
-	watch(resolvedInteractionTarget, (target, _previous, cleanup) => {
-		if (target) bindTriggerTarget(target, cleanup);
-	}, {
-		flush: "sync",
-		immediate: true
-	});
-	watch(resolvedContentTarget, (target, _previous, cleanup) => {
-		if (target) bindContentTarget(target, cleanup);
-	}, {
-		flush: "sync",
-		immediate: true
-	});
-	watch(isOpen, setDocumentListeners, { flush: "sync" });
-	watch(isOpen, () => {
-		syncInteractionTarget();
-		syncContentTarget();
-	}, { flush: "post" });
-	onMounted(() => {
-		syncInteractionTarget();
-		syncContentTarget();
-		setDocumentListeners(isOpen.value);
-	});
-	onBeforeUnmount(() => {
-		disposed = true;
-		clearTimers();
-		setDocumentListeners(false);
-	});
-	return {
-		isOpen,
-		isDisabled,
-		state,
-		triggerProps,
-		contentProps,
-		open,
-		close,
-		toggle
-	};
-}
-//#endregion
-export { useHoverDisclosure as t };