solid-baseui 0.1.0-alpha.0

package/dist/lib/server/PopupStore-DEs3FAEe.js

@@ -0,0 +1,645 @@
+import { N as triggerPress, T as outsidePress, l as escapeKey, w as none } from "./internals/reasons.js";
+import { createChangeEventDetails } from "./internals/createBaseUIEventDetails.js";
+import { t as runOnceAnimationsFinish } from "./runOnceAnimationsFinish-DCHzXWZU.js";
+import { a as isElement, c as isHTMLElement, m as ownerWindow, n as contains, p as ownerDocument, r as getEventTarget, s as isEventTargetWithin, u as isShadowRoot } from "./dom-Crg_2R-j.js";
+import { l as createEventEmitter, o as getNodeChildren } from "./FloatingTree-z1JPD1dR.js";
+import { t as createTransitionStatus } from "./createTransitionStatus-BTlrerSS.js";
+import { _ as ReactiveStore } from "./popupStateMapping-nKoUwoke.js";
+import { createEffect, untrack } from "solid-js";
+//#region src/internals/overlay/createDismiss.ts
+function normalizeBubbles(value) {
+	return {
+		escapeKey: typeof value === "boolean" ? value : value?.escapeKey ?? false,
+		outsidePress: typeof value === "boolean" ? value : value?.outsidePress ?? true
+	};
+}
+function isScrollbarPress(event, target) {
+	if (!isHTMLElement(target)) return false;
+	const styles = ownerWindow(target).getComputedStyle(target);
+	const root = target.matches("html,body");
+	const canScrollX = (root || /auto|scroll/.test(styles.overflowX)) && target.clientWidth > 0 && target.scrollWidth > target.clientWidth;
+	return (root || /auto|scroll/.test(styles.overflowY)) && target.clientHeight > 0 && target.scrollHeight > target.clientHeight && (styles.direction === "rtl" ? event.offsetX <= target.offsetWidth - target.clientWidth : event.offsetX > target.clientWidth) || canScrollX && event.offsetY > target.clientHeight;
+}
+function createDismiss(options) {
+	let composing = false;
+	let compositionTimer;
+	let pointerType = "";
+	let pressStartedInside = false;
+	let pressStartPrevented = false;
+	let suppressNextOutsideClick = false;
+	let suppressionTimer;
+	let touchTimer;
+	let touchState = null;
+	const handledEscapeEvents = /* @__PURE__ */ new WeakSet();
+	const enabled = () => options.enabled?.() ?? true;
+	const open = () => options.context.track().open;
+	const bubbles = () => normalizeBubbles(options.bubbles?.());
+	const outsidePress$1 = () => options.outsidePress?.() ?? true;
+	const outsidePressEnabled = () => outsidePress$1() !== false;
+	const pressMode = () => {
+		const configured = options.outsidePressEvent?.() ?? "sloppy";
+		if (typeof configured === "string") return configured;
+		return pointerType === "touch" ? configured.touch : configured.mouse;
+	};
+	const tree = () => options.tree?.();
+	const nodeId = () => options.context.context.nodeId;
+	const descendants = (onlyOpenChildren = true) => tree() ? getNodeChildren(tree().nodes, nodeId(), onlyOpenChildren) : [];
+	const hasBlockingChild = (key) => descendants().some((node) => node.context?.state.open && node.context.context.data[key] !== true);
+	const eventInsideOwnElements = (event) => isEventTargetWithin(event, options.context.state.floatingElement) || isEventTargetWithin(event, options.context.state.domReferenceElement) || (options.insideElements?.() ?? []).some((element) => isEventTargetWithin(event, element));
+	const eventInsideTree = (event) => eventInsideOwnElements(event) || descendants(false).some((node) => {
+		if (isEventTargetWithin(event, node.context?.state.floatingElement)) return true;
+		if (node.context?.context.triggerElements.hasMatchingElement((trigger) => isEventTargetWithin(event, trigger))) return true;
+		const getInsideElements = node.context?.context.data.insideElements;
+		return typeof getInsideElements === "function" && getInsideElements().some((element) => isEventTargetWithin(event, element));
+	});
+	const onKeyDown = (event) => {
+		if (event.baseUIHandlerPrevented) return;
+		if (handledEscapeEvents.has(event)) return;
+		if (!open() || !enabled() || !(options.escapeKey?.() ?? true) || event.key !== "Escape") return;
+		if (composing || event.isComposing || event.keyCode === 229) return;
+		if (!bubbles().escapeKey && hasBlockingChild("__escapeKeyBubbles")) return;
+		handledEscapeEvents.add(event);
+		const details = createChangeEventDetails(escapeKey, event);
+		options.context.setOpen(false, details);
+		if (!details.isCanceled) event.preventDefault();
+		if (!bubbles().escapeKey && !details.isPropagationAllowed) event.stopPropagation();
+	};
+	const onReferencePress = (event) => {
+		if (options.referencePress?.() && open() && enabled()) options.context.setOpen(false, createChangeEventDetails(triggerPress, event));
+	};
+	createEffect(() => ({
+		open: open(),
+		enabled: enabled(),
+		floating: options.context.track().floatingElement,
+		escapeKey: options.escapeKey?.() ?? true,
+		outsidePressEnabled: outsidePressEnabled(),
+		escapeBubbles: bubbles().escapeKey,
+		outsideBubbles: bubbles().outsidePress
+	}), (state) => {
+		if (!state.open || !state.enabled) return;
+		options.context.context.data.__escapeKeyBubbles = state.escapeBubbles;
+		options.context.context.data.__outsidePressBubbles = state.outsideBubbles;
+		const documentNode = ownerDocument(state.floating);
+		const onCompositionStart = () => {
+			clearTimeout(compositionTimer);
+			composing = true;
+		};
+		const onCompositionEnd = () => {
+			clearTimeout(compositionTimer);
+			compositionTimer = setTimeout(() => {
+				composing = false;
+			}, typeof CSS !== "undefined" && CSS.supports?.("-webkit-backdrop-filter:none") ? 5 : 0);
+		};
+		const resetPressStart = () => {
+			pressStartedInside = false;
+			pressStartPrevented = false;
+		};
+		const suppressImmediateClick = () => {
+			suppressNextOutsideClick = true;
+			clearTimeout(suppressionTimer);
+			suppressionTimer = setTimeout(() => {
+				suppressNextOutsideClick = false;
+			});
+		};
+		const guardAllows = (event) => {
+			const guard = outsidePress$1();
+			return typeof guard !== "function" || guard(event);
+		};
+		const closeOutside = (event) => {
+			if (pressMode() === "intentional" && event.type !== "click" || pressMode() === "sloppy" && event.type === "click") {
+				if (event.type !== "click" && !eventInsideOwnElements(event)) {
+					clearTimeout(suppressionTimer);
+					suppressNextOutsideClick = false;
+				}
+				return;
+			}
+			const target = getEventTarget(event);
+			const triggers = options.context.context.triggerElements;
+			if (isElement(target) && (triggers.hasElement(target) || triggers.hasMatchingElement((trigger) => contains(trigger, target)))) return;
+			if (!("touches" in event) && isScrollbarPress(event, target)) return;
+			if (eventInsideTree(event)) return;
+			if (pressMode() === "intentional" && suppressNextOutsideClick) {
+				clearTimeout(suppressionTimer);
+				suppressNextOutsideClick = false;
+				return;
+			}
+			if (!guardAllows(event) || hasBlockingChild("__outsidePressBubbles")) return;
+			const targetElement = isElement(target) ? target : null;
+			const root = targetElement?.getRootNode();
+			const markerRoot = isShadowRoot(root) ? root : documentNode;
+			const markers = Array.from(markerRoot.querySelectorAll("[data-base-ui-inert]"));
+			if (targetElement && markers.length && !targetElement.matches("html,body") && !contains(targetElement, state.floating) && markers.every((marker) => !contains(targetElement.getRootNode() === marker.getRootNode() ? targetElement : null, marker))) {
+				let top = targetElement;
+				while (top.parentElement && !top.parentElement.matches("html,body")) top = top.parentElement;
+				if (markers.every((marker) => !contains(top, marker))) return;
+			}
+			options.context.setOpen(false, createChangeEventDetails(outsidePress, event));
+		};
+		const runAtTarget = (event, listener) => {
+			getEventTarget(event)?.addEventListener(event.type, () => listener(event), { once: true });
+		};
+		const onPressCapture = (event) => {
+			if (event.type === "pointerdown") pointerType = event.pointerType;
+			if (event.type === "mousedown" && touchState && !touchState.dismissOnMouseDown) return;
+			if (event.type !== "click" && eventInsideTree(event) && event.button === 0) {
+				pressStartedInside = true;
+				pressStartPrevented = false;
+				runAtTarget(event, (targetEvent) => {
+					pressStartPrevented = targetEvent.defaultPrevented;
+				});
+				return;
+			}
+			runAtTarget(event, (targetEvent) => {
+				if (targetEvent.type === "pointerdown" && pressMode() === "sloppy" && targetEvent.pointerType !== "touch") closeOutside(targetEvent);
+				else if (targetEvent.type !== "pointerdown") closeOutside(targetEvent);
+			});
+		};
+		const onPressEndCapture = (event) => {
+			if (!pressStartedInside) return;
+			const prevented = pressStartPrevented;
+			resetPressStart();
+			if (pressMode() !== "intentional") return;
+			if (event.type === "pointercancel") {
+				if (prevented) suppressImmediateClick();
+				return;
+			}
+			if (eventInsideTree(event)) return;
+			if (prevented) {
+				suppressImmediateClick();
+				return;
+			}
+			if (!guardAllows(event)) return;
+			suppressNextOutsideClick = true;
+		};
+		const onTouchStart = (event) => {
+			pointerType = "touch";
+			if (pressMode() !== "sloppy" || eventInsideOwnElements(event)) return;
+			const touch = event.touches[0];
+			if (!touch) return;
+			touchState = {
+				startX: touch.clientX,
+				startY: touch.clientY,
+				dismissOnTouchEnd: false,
+				dismissOnMouseDown: true
+			};
+			clearTimeout(touchTimer);
+			touchTimer = setTimeout(() => {
+				if (touchState) {
+					touchState.dismissOnTouchEnd = false;
+					touchState.dismissOnMouseDown = false;
+				}
+			}, 1e3);
+		};
+		const onTouchMove = (event) => {
+			if (pressMode() !== "sloppy" || !touchState || eventInsideOwnElements(event)) return;
+			const touch = event.touches[0];
+			if (!touch) return;
+			const distance = Math.hypot(touch.clientX - touchState.startX, touch.clientY - touchState.startY);
+			if (distance > 5) touchState.dismissOnTouchEnd = true;
+			if (distance > 10) {
+				closeOutside(event);
+				clearTimeout(touchTimer);
+				touchState = null;
+			}
+		};
+		const onTouchEnd = (event) => {
+			if (pressMode() === "sloppy" && touchState && !eventInsideOwnElements(event)) {
+				if (touchState.dismissOnTouchEnd) closeOutside(event);
+				clearTimeout(touchTimer);
+				touchState = null;
+			}
+		};
+		if (state.escapeKey) {
+			documentNode.addEventListener("keydown", onKeyDown);
+			documentNode.addEventListener("compositionstart", onCompositionStart);
+			documentNode.addEventListener("compositionend", onCompositionEnd);
+		}
+		if (state.outsidePressEnabled) {
+			documentNode.addEventListener("click", onPressCapture, true);
+			documentNode.addEventListener("pointerdown", onPressCapture, true);
+			documentNode.addEventListener("pointerup", onPressEndCapture, true);
+			documentNode.addEventListener("pointercancel", onPressEndCapture, true);
+			documentNode.addEventListener("mousedown", onPressCapture, true);
+			documentNode.addEventListener("mouseup", onPressEndCapture, true);
+			documentNode.addEventListener("touchstart", onTouchStart, true);
+			documentNode.addEventListener("touchmove", onTouchMove, true);
+			documentNode.addEventListener("touchend", onTouchEnd, true);
+		}
+		return () => {
+			documentNode.removeEventListener("keydown", onKeyDown);
+			documentNode.removeEventListener("compositionstart", onCompositionStart);
+			documentNode.removeEventListener("compositionend", onCompositionEnd);
+			documentNode.removeEventListener("click", onPressCapture, true);
+			documentNode.removeEventListener("pointerdown", onPressCapture, true);
+			documentNode.removeEventListener("pointerup", onPressEndCapture, true);
+			documentNode.removeEventListener("pointercancel", onPressEndCapture, true);
+			documentNode.removeEventListener("mousedown", onPressCapture, true);
+			documentNode.removeEventListener("mouseup", onPressEndCapture, true);
+			documentNode.removeEventListener("touchstart", onTouchStart, true);
+			documentNode.removeEventListener("touchmove", onTouchMove, true);
+			documentNode.removeEventListener("touchend", onTouchEnd, true);
+			clearTimeout(compositionTimer);
+			clearTimeout(suppressionTimer);
+			clearTimeout(touchTimer);
+			resetPressStart();
+			suppressNextOutsideClick = false;
+			touchState = null;
+		};
+	});
+	return {
+		onReferencePress,
+		onKeyDown
+	};
+}
+//#endregion
+//#region src/internals/overlay/createPopupPresence.ts
+function createPopupPresence(store, element, options = {}) {
+	const transition = createTransitionStatus(() => store.open());
+	store.update({
+		mounted: untrack(transition.mounted),
+		transitionStatus: untrack(transition.transitionStatus)
+	});
+	const forceUnmount = () => {
+		transition.setMounted(false);
+		store.update({
+			activeTriggerId: null,
+			activeTriggerElement: null,
+			mounted: false,
+			preventUnmountingOnClose: false
+		});
+		options.onUnmount?.();
+		untrack(store.context.onOpenChangeComplete)?.(false);
+	};
+	createEffect(() => ({
+		mounted: transition.mounted(),
+		transitionStatus: transition.transitionStatus()
+	}), (state) => store.update(state));
+	createEffect(() => ({
+		open: store.open(),
+		mounted: transition.mounted(),
+		preventUnmounting: store.track().preventUnmountingOnClose,
+		element: element()
+	}), (state) => {
+		if (state.open || !state.mounted || state.preventUnmounting) return;
+		if (!state.element) {
+			let active = true;
+			queueMicrotask(() => {
+				if (active) forceUnmount();
+			});
+			return () => {
+				active = false;
+			};
+		}
+		const abortController = new AbortController();
+		runOnceAnimationsFinish(state.element, () => {
+			forceUnmount();
+		}, abortController.signal);
+		return () => abortController.abort();
+	});
+	createEffect(() => ({
+		open: store.open(),
+		mounted: transition.mounted(),
+		element: element()
+	}), (state) => {
+		if (!state.open || !state.mounted || !state.element) return;
+		const abortController = new AbortController();
+		runOnceAnimationsFinish(state.element, () => {
+			untrack(store.context.onOpenChangeComplete)?.(true);
+		}, abortController.signal, { waitForStartingStyleRemoved: true });
+		return () => abortController.abort();
+	});
+	return {
+		mounted: transition.mounted,
+		transitionStatus: transition.transitionStatus,
+		forceUnmount
+	};
+}
+//#endregion
+//#region src/internals/overlay/PopupTriggerMap.ts
+var PopupTriggerMap = class {
+	idMap = /* @__PURE__ */ new Map();
+	add(id, element) {
+		this.idMap.set(id, element);
+	}
+	delete(id) {
+		this.idMap.delete(id);
+	}
+	getById(id) {
+		return this.idMap.get(id);
+	}
+	hasElement(element) {
+		for (const registered of this.idMap.values()) if (registered === element) return true;
+		return false;
+	}
+	hasMatchingElement(predicate) {
+		for (const element of this.idMap.values()) if (predicate(element)) return true;
+		return false;
+	}
+	entries() {
+		return this.idMap.entries();
+	}
+	elements() {
+		return this.idMap.values();
+	}
+	get size() {
+		return this.idMap.size;
+	}
+};
+//#endregion
+//#region src/internals/overlay/FloatingRootStore.ts
+function isClickLikeEvent(event) {
+	return [
+		"click",
+		"mousedown",
+		"keydown",
+		"keyup"
+	].includes(event.type);
+}
+var FloatingRootStore = class extends ReactiveStore {
+	constructor(options) {
+		const triggerElements = options.triggerElements ?? new PopupTriggerMap();
+		super({
+			open: false,
+			transitionStatus: void 0,
+			domReferenceElement: null,
+			referenceElement: null,
+			positionReference: null,
+			floatingElement: null,
+			floatingId: options.floatingId
+		}, {
+			data: {},
+			events: createEventEmitter(),
+			nested: options.nested ?? false,
+			nodeId: options.nodeId,
+			triggerElements,
+			onOpenChange: options.onOpenChange
+		});
+	}
+	referenceElement() {
+		const state = this.track();
+		return state.positionReference ?? state.referenceElement;
+	}
+	syncOpenEvent(open, event) {
+		if (!open || !this.state.open || event && isClickLikeEvent(event)) this.context.data.openEvent = open ? event : void 0;
+	}
+	dispatchOpenChange(open, details) {
+		this.syncOpenEvent(open, details.event);
+		this.context.events.emit("openchange", {
+			open,
+			reason: details.reason,
+			nativeEvent: details.event,
+			nested: this.context.nested,
+			triggerElement: details.trigger
+		});
+	}
+	setOpen(open, details) {
+		this.context.onOpenChange(open, details);
+	}
+};
+//#endregion
+//#region src/internals/overlay/PopupStore.ts
+var EMPTY_PROPS = Object.freeze({});
+var undefinedAccessor = () => void 0;
+var PopupStore = class extends ReactiveStore {
+	resolvedActiveTriggerId = null;
+	closeOnActiveTriggerUnmount = false;
+	triggerState = /* @__PURE__ */ new Map();
+	constructor(options = {}) {
+		const triggerElements = new PopupTriggerMap();
+		let setOpen;
+		const floatingRoot = new FloatingRootStore({
+			floatingId: options.floatingId,
+			nested: options.nested,
+			nodeId: options.nodeId,
+			triggerElements,
+			onOpenChange: (open, details) => setOpen(open, details)
+		});
+		super({
+			open: false,
+			mounted: false,
+			transitionStatus: void 0,
+			triggerCount: 0,
+			preventUnmountingOnClose: false,
+			payload: void 0,
+			activeTriggerId: null,
+			activeTriggerElement: null,
+			popupElement: null,
+			popupId: void 0,
+			positionerElement: null,
+			activeTriggerProps: EMPTY_PROPS,
+			inactiveTriggerProps: EMPTY_PROPS,
+			popupProps: EMPTY_PROPS,
+			instantType: void 0,
+			adaptiveOriginMiddleware: void 0,
+			closeDelay: 0
+		}, {
+			triggerElements,
+			floatingRoot,
+			floatingId: options.floatingId,
+			controlledOpen: options.controlledOpen ?? undefinedAccessor,
+			controlledTriggerId: options.controlledTriggerId ?? undefinedAccessor,
+			onOpenChange: options.onOpenChange ?? undefinedAccessor,
+			onOpenChangeComplete: options.onOpenChangeComplete ?? undefinedAccessor
+		});
+		setOpen = (open, details) => this.setOpen(open, details);
+		createEffect(() => ({
+			open: this.open(),
+			transitionStatus: this.track().transitionStatus,
+			referenceElement: this.track().activeTriggerElement,
+			floatingElement: this.track().positionerElement ?? this.track().popupElement,
+			floatingId: this.context.floatingId
+		}), (state) => {
+			this.context.floatingRoot.update({
+				open: state.open,
+				transitionStatus: state.transitionStatus,
+				domReferenceElement: state.referenceElement,
+				referenceElement: state.referenceElement,
+				positionReference: this.context.floatingRoot.state.positionReference === this.context.floatingRoot.state.referenceElement ? state.referenceElement : this.context.floatingRoot.state.positionReference,
+				floatingElement: state.floatingElement,
+				floatingId: state.floatingId
+			});
+		});
+	}
+	open() {
+		return this.context.controlledOpen() ?? this.track().open;
+	}
+	activeTriggerId() {
+		return this.context.controlledTriggerId() ?? this.track().activeTriggerId;
+	}
+	activeTriggerElement() {
+		return this.track().mounted ? this.track().activeTriggerElement : null;
+	}
+	popupId() {
+		const state = this.track();
+		return (state.popupId ?? state.popupElement?.id ?? this.context.floatingId) || void 0;
+	}
+	isTriggerActive(triggerId) {
+		return triggerId !== void 0 && this.activeTriggerId() === triggerId;
+	}
+	isOpenedByTrigger(triggerId) {
+		return this.open() && this.isTriggerActive(triggerId);
+	}
+	isMountedByTrigger(triggerId) {
+		return this.track().mounted && this.isTriggerActive(triggerId);
+	}
+	triggerPopupId(triggerId) {
+		if (this.isOpenedByTrigger(triggerId)) return this.popupId();
+		return this.open() && this.activeTriggerId() == null && this.track().triggerCount === 1 ? this.popupId() : void 0;
+	}
+	configureTriggerUnmount(options) {
+		this.closeOnActiveTriggerUnmount = options.closeOnActiveTriggerUnmount ?? false;
+	}
+	setOpen(open, details) {
+		let preventUnmountingOnClose = false;
+		details.preventUnmountOnClose = () => {
+			preventUnmountingOnClose = true;
+		};
+		this.context.onOpenChange()?.(open, details);
+		if (details.isCanceled) return false;
+		if (!this.shouldCommitOpenChange(open, details)) return false;
+		this.context.floatingRoot.dispatchOpenChange(open, details);
+		const nextState = { open };
+		if (open) nextState.preventUnmountingOnClose = false;
+		else if (preventUnmountingOnClose) nextState.preventUnmountingOnClose = true;
+		const triggerId = details.trigger?.id || null;
+		if (triggerId || open) {
+			nextState.activeTriggerId = triggerId;
+			nextState.activeTriggerElement = details.trigger ?? null;
+		}
+		if (open && details.reason === "trigger-focus") nextState.instantType = "focus";
+		else if (!open && (details.reason === "trigger-press" || details.reason === "escape-key")) nextState.instantType = "dismiss";
+		else if (details.reason === "trigger-hover") nextState.instantType = void 0;
+		this.update(nextState);
+		this.reconcileTriggers();
+		return true;
+	}
+	shouldCommitOpenChange(_open, _details) {
+		return true;
+	}
+	registerTrigger(id, element, triggerState) {
+		this.context.triggerElements.add(id, element);
+		this.triggerState.set(id, triggerState ?? {});
+		this.forwardTriggerData(id, element, triggerState);
+		this.reconcileTriggers();
+		return () => {
+			if (this.context.triggerElements.getById(id) === element) {
+				this.context.triggerElements.delete(id);
+				this.triggerState.delete(id);
+				this.reconcileTriggers();
+			}
+		};
+	}
+	forwardTriggerData(id, element, triggerState = {}) {
+		this.triggerState.set(id, triggerState);
+		const activeId = this.activeTriggerId();
+		if (activeId === id) {
+			this.update({
+				activeTriggerElement: element,
+				...this.open() ? triggerState : void 0
+			});
+			this.resolvedActiveTriggerId = id;
+			return;
+		}
+		if (activeId == null && this.open()) {
+			this.update({
+				activeTriggerId: id,
+				activeTriggerElement: element,
+				...triggerState
+			});
+			this.resolvedActiveTriggerId = id;
+		}
+	}
+	reconcileTriggers() {
+		if (!this.open()) {
+			this.resolvedActiveTriggerId = null;
+			if (this.state.triggerCount !== 0) this.set("triggerCount", 0);
+			return;
+		}
+		const triggerCount = this.context.triggerElements.size;
+		const changes = {};
+		if (this.state.triggerCount !== triggerCount) changes.triggerCount = triggerCount;
+		const activeId = this.activeTriggerId();
+		let lostActiveId = null;
+		if (activeId) {
+			const activeElement = this.context.triggerElements.getById(activeId);
+			if (activeElement) {
+				this.resolvedActiveTriggerId = activeId;
+				Object.assign(changes, this.triggerState.get(activeId));
+				if (activeElement !== this.state.activeTriggerElement) changes.activeTriggerElement = activeElement;
+			} else {
+				for (const [registeredId, registeredElement] of this.context.triggerElements.entries()) if (registeredElement === this.state.activeTriggerElement) {
+					changes.activeTriggerId = registeredId;
+					changes.activeTriggerElement = registeredElement;
+					this.resolvedActiveTriggerId = registeredId;
+					break;
+				}
+				if (changes.activeTriggerId === void 0) {
+					if (this.resolvedActiveTriggerId === activeId) lostActiveId = activeId;
+					else this.resolvedActiveTriggerId = null;
+				}
+			}
+		} else this.resolvedActiveTriggerId = null;
+		if (!lostActiveId && !activeId && triggerCount === 1) {
+			const first = this.context.triggerElements.entries().next();
+			if (!first.done) {
+				changes.activeTriggerId = first.value[0];
+				changes.activeTriggerElement = first.value[1];
+				Object.assign(changes, this.triggerState.get(first.value[0]));
+				this.resolvedActiveTriggerId = first.value[0];
+			}
+		}
+		this.update(changes);
+		if (lostActiveId && this.closeOnActiveTriggerUnmount) queueMicrotask(() => {
+			if (this.open() && this.activeTriggerId() === lostActiveId && !this.context.triggerElements.getById(lostActiveId)) {
+				const details = createChangeEventDetails(none);
+				if (this.setOpen(false, details)) this.update({
+					activeTriggerId: null,
+					activeTriggerElement: null
+				});
+			}
+		});
+	}
+	setPopupElement(element) {
+		this.update({
+			popupElement: element,
+			popupId: element?.id || void 0
+		});
+	}
+	setPopupId(id) {
+		this.set("popupId", id || void 0);
+	}
+	setPositionerElement(element) {
+		this.set("positionerElement", element);
+	}
+	setInteractionProps(props) {
+		this.update(props);
+	}
+	clearInteractionProps() {
+		this.update({
+			activeTriggerProps: EMPTY_PROPS,
+			inactiveTriggerProps: EMPTY_PROPS,
+			popupProps: EMPTY_PROPS
+		});
+	}
+};
+function createTriggerRegistration(store, id, element, triggerState = () => ({})) {
+	createEffect(() => ({
+		store: store(),
+		id: id(),
+		element: element()
+	}), (current) => {
+		if (!current.store || !current.id || !current.element) return;
+		const unregister = untrack(() => current.store.registerTrigger(current.id, current.element, triggerState()));
+		return () => untrack(unregister);
+	});
+	createEffect(() => ({
+		store: store(),
+		id: id(),
+		element: element(),
+		state: triggerState()
+	}), (current) => {
+		if (current.store && current.id && current.element) untrack(() => current.store.forwardTriggerData(current.id, current.element, current.state));
+	});
+}
+//#endregion
+export { createPopupPresence as a, PopupTriggerMap as i, createTriggerRegistration as n, createDismiss as o, FloatingRootStore as r, PopupStore as t };