solid-baseui 0.1.0-alpha.0

package/dist/lib/server/createClickInteraction-BYsMgvup.js

@@ -0,0 +1,68 @@
+import "./internals/reasons.js";
+import { createChangeEventDetails } from "./internals/createBaseUIEventDetails.js";
+import { f as isTypeableElement } from "./dom-Crg_2R-j.js";
+import { onCleanup } from "solid-js";
+//#region src/internals/overlay/createClickInteraction.ts
+function clickLike(event) {
+	return Boolean(event && [
+		"click",
+		"mousedown",
+		"keydown",
+		"keyup"
+	].includes(event.type));
+}
+function createClickInteraction(options) {
+	let pointerType = "";
+	let openTimer;
+	let mouseDownFrame = 0;
+	onCleanup(() => {
+		clearTimeout(openTimer);
+		if (typeof cancelAnimationFrame === "function") cancelAnimationFrame(mouseDownFrame);
+	});
+	const enabled = () => options.enabled?.() ?? true;
+	const eventType = () => options.event?.() ?? "click";
+	const open = () => options.context.track().open;
+	const changeOpen = (event, trigger) => {
+		if (!enabled() || event.button !== 0) return;
+		const inactiveTrigger = options.context.track().domReferenceElement !== trigger;
+		const openEvent = options.context.context.data.openEvent;
+		const wasClickOpen = clickLike(openEvent);
+		let nextOpen = true;
+		if (open() && !inactiveTrigger) {
+			if ((options.stickIfOpen?.() ?? true) && openEvent && !wasClickOpen) nextOpen = true;
+			else nextOpen = !(options.toggle?.() ?? true);
+		}
+		options.context.setOpen(nextOpen, createChangeEventDetails(options.reason?.() ?? "trigger-press", event, trigger));
+	};
+	const scheduleChange = (event, trigger) => {
+		const delay = pointerType === "touch" && event.detail !== 0 && !open() ? options.touchOpenDelay?.() ?? 0 : 0;
+		clearTimeout(openTimer);
+		if (delay > 0) openTimer = setTimeout(() => changeOpen(event, trigger), delay);
+		else changeOpen(event, trigger);
+	};
+	return {
+		onPointerDown(event) {
+			pointerType = event.pointerType;
+		},
+		onMouseDown(event) {
+			const mouseInput = pointerType === "mouse" || pointerType === "pen" || pointerType === "";
+			if (!enabled() || event.button !== 0 || options.ignoreMouse?.() && mouseInput && event.detail !== 0 || eventType() === "click") return;
+			const trigger = event.currentTarget;
+			if (isTypeableElement(trigger)) scheduleChange(event, trigger);
+			else {
+				cancelAnimationFrame(mouseDownFrame);
+				mouseDownFrame = requestAnimationFrame(() => scheduleChange(event, trigger));
+			}
+		},
+		onClick(event) {
+			if ("pointerType" in event && event.pointerType) pointerType = event.pointerType;
+			const mouseInput = pointerType === "mouse" || pointerType === "pen" || pointerType === "";
+			if (!enabled() || event.button !== 0 || options.ignoreMouse?.() && mouseInput && event.detail !== 0 || eventType() === "mousedown-only") return;
+			if (eventType() === "mousedown" && event.detail !== 0) return;
+			scheduleChange(event, event.currentTarget);
+			pointerType = "";
+		}
+	};
+}
+//#endregion
+export { createClickInteraction as t };

package/dist/lib/server/createCollapsiblePanel-DTyVJz0G.js

@@ -0,0 +1,297 @@
+import { t as runOnceAnimationsFinish } from "./runOnceAnimationsFinish-DCHzXWZU.js";
+import { createEffect, createMemo, createSignal, onCleanup, untrack } from "solid-js";
+//#region src/collapsible/root/createCollapsibleTransitionStatus.ts
+/** Adds an idle phase and a frame boundary before Collapsible exit styles apply. */
+function createCollapsibleTransitionStatus(open) {
+	const initiallyOpen = untrack(open);
+	const [mounted, setMounted] = createSignal(initiallyOpen);
+	const [transitionStatus, setTransitionStatus] = createSignal(initiallyOpen ? "idle" : void 0);
+	createEffect(() => ({
+		mounted: mounted(),
+		open: open(),
+		status: transitionStatus()
+	}), (current) => {
+		if (current.open) {
+			if (!current.mounted) {
+				setMounted(true);
+				setTransitionStatus("starting");
+				return;
+			}
+			if (current.status === "ending") {
+				setTransitionStatus("starting");
+				return;
+			}
+			if (current.status === "starting") {
+				let secondFrame;
+				const firstFrame = requestFrame$1(() => {
+					secondFrame = requestFrame$1(() => setTransitionStatus("idle"));
+				});
+				return () => {
+					cancelFrame$1(firstFrame);
+					if (secondFrame) cancelFrame$1(secondFrame);
+				};
+			}
+			return;
+		}
+		if (current.mounted && current.status !== "ending") {
+			let secondFrame;
+			const firstFrame = requestFrame$1(() => {
+				secondFrame = requestFrame$1(() => setTransitionStatus("ending"));
+			});
+			return () => {
+				cancelFrame$1(firstFrame);
+				if (secondFrame) cancelFrame$1(secondFrame);
+			};
+		}
+		if (!current.mounted && current.status !== void 0) setTransitionStatus(void 0);
+	});
+	return {
+		mounted,
+		setMounted,
+		transitionStatus
+	};
+}
+function requestFrame$1(callback) {
+	if (typeof requestAnimationFrame === "function") return {
+		kind: "animation",
+		id: requestAnimationFrame(callback)
+	};
+	return {
+		kind: "timeout",
+		id: setTimeout(() => callback(performance.now()), 16)
+	};
+}
+function cancelFrame$1(frame) {
+	if (frame.kind === "animation") cancelAnimationFrame(frame.id);
+	else clearTimeout(frame.id);
+}
+//#endregion
+//#region src/collapsible/panel/createCollapsiblePanel.ts
+var EMPTY_DIMENSIONS = {
+	height: void 0,
+	width: void 0
+};
+function createCollapsiblePanel(parameters) {
+	const [dimensions, setDimensionsSignal] = createSignal(EMPTY_DIMENSIONS);
+	const [forcePanelIdle, setForcePanelIdle] = createSignal(false);
+	let animationType = null;
+	let lastMeasuredDimensions = EMPTY_DIMENSIONS;
+	let shouldSkipNextOpen = false;
+	let shouldPreventMountAnimation = untrack(parameters.open);
+	let restorePendingTemporaryStyle;
+	const hidden = createMemo(() => !parameters.open() && !parameters.mounted());
+	const panelTransitionStatus = createMemo(() => forcePanelIdle() ? "idle" : parameters.transitionStatus());
+	const shouldPreventOpenAnimation = createMemo(() => parameters.open() && shouldPreventMountAnimation);
+	const shouldRender = createMemo(() => parameters.keepMounted() || parameters.hiddenUntilFound() || parameters.mounted() || parameters.open());
+	const renderedDimensions = createMemo(() => {
+		const current = dimensions();
+		if (!parameters.open() && parameters.mounted() && animationType === "css-animation" && current.height === void 0 && current.width === void 0) return lastMeasuredDimensions;
+		return current;
+	});
+	const shouldPersistHiddenTransitionStyles = createMemo(() => parameters.hiddenUntilFound() && hidden() && animationType !== "css-animation");
+	function setDimensions(nextDimensions, shouldCacheMeasurement = true) {
+		if (shouldCacheMeasurement) lastMeasuredDimensions = nextDimensions;
+		setDimensionsSignal(nextDimensions);
+	}
+	function restoreTemporaryStyle() {
+		restorePendingTemporaryStyle?.();
+		restorePendingTemporaryStyle = void 0;
+	}
+	function setPendingTemporaryStyleRestore(restore) {
+		restoreTemporaryStyle();
+		restorePendingTemporaryStyle = () => {
+			restorePendingTemporaryStyle = void 0;
+			restore();
+		};
+	}
+	createEffect(() => ({
+		forceIdle: forcePanelIdle(),
+		transitionStatus: parameters.transitionStatus()
+	}), (current) => {
+		if (current.forceIdle && current.transitionStatus !== "starting") setForcePanelIdle(false);
+	});
+	createEffect(() => ({
+		element: parameters.element(),
+		mounted: parameters.mounted(),
+		open: parameters.open(),
+		preventOpenAnimation: shouldPreventOpenAnimation(),
+		transitionStatus: parameters.transitionStatus()
+	}), (current) => {
+		const panel = current.element;
+		if (!panel || !panel.isConnected) {
+			if (!current.open && current.mounted && current.transitionStatus === "ending") parameters.setMounted(false);
+			return;
+		}
+		if (!current.open && restorePendingTemporaryStyle) restoreTemporaryStyle();
+		animationType = getAnimationType(panel, current.preventOpenAnimation);
+		if (current.open && current.transitionStatus === "idle" && shouldPreventMountAnimation && animationType === "css-animation") {
+			lastMeasuredDimensions = getDimensions(panel);
+			return;
+		}
+		if (current.open && current.transitionStatus === "starting") {
+			const skipNextOpen = shouldSkipNextOpen;
+			shouldSkipNextOpen = false;
+			if (animationType === "none") {
+				setDimensions(getDimensions(panel));
+				setForcePanelIdle(true);
+				return;
+			}
+			if (animationType === "css-transition") {
+				const restoreLayoutStyles = resetLayoutStyles(panel);
+				setDimensions(getDimensions(panel));
+				if (!skipNextOpen) return restoreLayoutStyles;
+				setPendingTemporaryStyleRestore(setTemporaryStyle(panel, "transition-duration", "0s"));
+				setForcePanelIdle(true);
+				return restoreLayoutStyles;
+			}
+			setDimensions(getDimensions(panel));
+			const restoreAnimationName = setTemporaryStyle(panel, "animation-name", "none");
+			if (!skipNextOpen) {
+				restoreAnimationName();
+				return;
+			}
+			const restoreAnimationDuration = setTemporaryStyle(panel, "animation-duration", "0s");
+			restoreAnimationName();
+			setPendingTemporaryStyleRestore(restoreAnimationDuration);
+			setForcePanelIdle(true);
+			return;
+		}
+		if (!current.open && current.mounted && (current.transitionStatus === "idle" || current.transitionStatus === "starting")) {
+			shouldPreventMountAnimation = false;
+			if (animationType === "none") {
+				setDimensions(EMPTY_DIMENSIONS, false);
+				parameters.setMounted(false);
+				return;
+			}
+			setDimensions(getDimensions(panel));
+			return;
+		}
+		if (current.transitionStatus !== "ending") return;
+		if (animationType === "none") {
+			parameters.setMounted(false);
+			return;
+		}
+		const nextDimensions = getDimensions(panel);
+		if ((nextDimensions.height ?? 0) <= 0 && (nextDimensions.width ?? 0) <= 0) {
+			parameters.setMounted(false);
+			return;
+		}
+		setDimensions(nextDimensions);
+		if (animationType === "css-animation") setTemporaryStyle(panel, "animation-name", "none")();
+	});
+	createEffect(() => ({
+		element: parameters.element(),
+		mounted: parameters.mounted(),
+		open: parameters.open(),
+		transitionStatus: panelTransitionStatus()
+	}), (current) => {
+		if (!current.open || !current.mounted || current.transitionStatus !== "idle" || !current.element || !current.element.isConnected) return;
+		const abortController = new AbortController();
+		runOnceAnimationsFinish(current.element, () => {
+			if (untrack(parameters.open)) setDimensions(EMPTY_DIMENSIONS, false);
+		}, abortController.signal);
+		return () => abortController.abort();
+	});
+	createEffect(() => ({
+		element: parameters.element(),
+		mounted: parameters.mounted(),
+		open: parameters.open(),
+		transitionStatus: panelTransitionStatus()
+	}), (current) => {
+		if (current.open || !current.mounted || current.transitionStatus !== "ending" || !current.element || !current.element.isConnected) return;
+		const abortController = new AbortController();
+		const frame = requestFrame(() => {
+			runOnceAnimationsFinish(current.element, () => {
+				if (!untrack(parameters.open)) {
+					parameters.setMounted(false);
+					setDimensions(EMPTY_DIMENSIONS, false);
+				}
+			}, abortController.signal);
+		});
+		return () => {
+			cancelFrame(frame);
+			abortController.abort();
+		};
+	});
+	createEffect(() => parameters.element(), (panel) => {
+		if (!panel) return;
+		const handleBeforeMatch = (event) => {
+			parameters.requestBeforeMatchOpen(event, () => {
+				shouldSkipNextOpen = true;
+			});
+		};
+		panel.addEventListener("beforematch", handleBeforeMatch);
+		return () => panel.removeEventListener("beforematch", handleBeforeMatch);
+	});
+	onCleanup(restoreTemporaryStyle);
+	return {
+		dimensions: renderedDimensions,
+		hidden,
+		panelTransitionStatus,
+		shouldPersistHiddenTransitionStyles,
+		shouldPreventOpenAnimation,
+		shouldRender
+	};
+}
+function getDimensions(element) {
+	return {
+		height: element.scrollHeight,
+		width: element.scrollWidth
+	};
+}
+function getAnimationType(element, hasSuppressedMountAnimation) {
+	const styles = element.ownerDocument.defaultView?.getComputedStyle(element);
+	if (!styles) return "none";
+	const hasAnimation = (styles.animationName.split(",").map((name) => name.trim()).some((name) => name !== "" && name !== "none") || hasSuppressedMountAnimation) && hasNonZeroDuration(styles.animationDuration);
+	const hasTransition = hasNonZeroDuration(styles.transitionDuration);
+	if (hasAnimation && hasTransition) return "css-transition";
+	if (hasTransition) return "css-transition";
+	if (hasAnimation) return "css-animation";
+	return "none";
+}
+function hasNonZeroDuration(value) {
+	return value.split(",").map((part) => part.trim()).some((part) => part !== "" && Number.parseFloat(part) > 0);
+}
+function setTemporaryStyle(element, property, value) {
+	const previousValue = element.style.getPropertyValue(property);
+	const previousPriority = element.style.getPropertyPriority(property);
+	element.style.setProperty(property, value);
+	return () => {
+		if (previousValue === "") element.style.removeProperty(property);
+		else element.style.setProperty(property, previousValue, previousPriority);
+	};
+}
+function resetLayoutStyles(element) {
+	const originalLayoutStyles = {
+		"justify-content": element.style.justifyContent,
+		"align-items": element.style.alignItems,
+		"align-content": element.style.alignContent,
+		"justify-items": element.style.justifyItems
+	};
+	for (const property of Object.keys(originalLayoutStyles)) element.style.setProperty(property, "initial", "important");
+	const restore = () => {
+		for (const [property, value] of Object.entries(originalLayoutStyles)) if (value === "") element.style.removeProperty(property);
+		else element.style.setProperty(property, value);
+	};
+	const frame = requestFrame(restore);
+	return () => {
+		cancelFrame(frame);
+		restore();
+	};
+}
+function requestFrame(callback) {
+	if (typeof requestAnimationFrame === "function") return {
+		kind: "animation",
+		id: requestAnimationFrame(callback)
+	};
+	return {
+		kind: "timeout",
+		id: setTimeout(() => callback(performance.now()), 16)
+	};
+}
+function cancelFrame(frame) {
+	if (frame.kind === "animation") cancelAnimationFrame(frame.id);
+	else clearTimeout(frame.id);
+}
+//#endregion
+export { createCollapsibleTransitionStatus as n, createCollapsiblePanel as t };

package/dist/lib/server/createFocusInteraction-EIS0QOel.js

@@ -0,0 +1,77 @@
+import { j as triggerFocus } from "./internals/reasons.js";
+import { createChangeEventDetails } from "./internals/createBaseUIEventDetails.js";
+import { n as contains, p as ownerDocument, t as activeElement } from "./dom-Crg_2R-j.js";
+import { onCleanup } from "solid-js";
+//#region src/internals/overlay/createFocusInteraction.ts
+function matchesFocusVisible(element) {
+	try {
+		return element.matches(":focus-visible");
+	} catch {
+		return true;
+	}
+}
+function createFocusInteraction(options) {
+	let openTimer;
+	let closeTimer;
+	let blockFocus = false;
+	let blockedReference = null;
+	const unsubscribe = options.context.context.events.on("openchange", (details) => {
+		if (!details.open && (details.reason === "escape-key" || details.reason === "trigger-press")) {
+			blockFocus = true;
+			blockedReference = options.context.state.domReferenceElement;
+		}
+		clearTimeout(openTimer);
+	});
+	onCleanup(() => {
+		unsubscribe();
+		clearTimeout(openTimer);
+		clearTimeout(closeTimer);
+	});
+	const enabled = () => options.enabled?.() ?? true;
+	return {
+		onFocus(event) {
+			if (!enabled()) return;
+			const trigger = event.currentTarget;
+			if (blockFocus && blockedReference !== trigger) {
+				blockFocus = false;
+				blockedReference = null;
+			}
+			if (blockFocus && blockedReference === trigger) return;
+			if ((options.visibleOnly?.() ?? true) && !matchesFocusVisible(trigger)) return;
+			clearTimeout(closeTimer);
+			const delay = options.context.state.open ? 0 : options.delay?.() ?? 0;
+			clearTimeout(openTimer);
+			openTimer = setTimeout(() => {
+				options.context.setOpen(true, createChangeEventDetails(triggerFocus, event, trigger));
+			}, delay);
+		},
+		onBlur(event) {
+			clearTimeout(openTimer);
+			clearTimeout(closeTimer);
+			if (blockedReference === event.currentTarget) {
+				blockFocus = false;
+				blockedReference = null;
+			}
+			closeTimer = setTimeout(() => {
+				const documentNode = ownerDocument(event.currentTarget);
+				const active = activeElement(documentNode);
+				const floating = options.context.state.floatingElement;
+				if (contains(floating, active)) return;
+				const nextTrigger = Array.from(options.context.context.triggerElements.elements()).find((trigger) => contains(trigger, active));
+				if (nextTrigger && !nextTrigger.hasAttribute("data-trigger-disabled")) {
+					blockFocus = false;
+					blockedReference = null;
+					options.context.setOpen(true, createChangeEventDetails(triggerFocus, event, nextTrigger));
+					return;
+				}
+				options.context.setOpen(false, createChangeEventDetails(triggerFocus, event));
+			});
+		},
+		onPointerLeave() {
+			blockFocus = false;
+			blockedReference = null;
+		}
+	};
+}
+//#endregion
+export { createFocusInteraction as t };

package/dist/lib/server/createPopupAutoResize-DO50jjNX.js

@@ -0,0 +1,111 @@
+import { t as runOnceAnimationsFinish } from "./runOnceAnimationsFinish-DCHzXWZU.js";
+import { c as isHTMLElement, m as ownerWindow } from "./dom-Crg_2R-j.js";
+import { createEffect, untrack } from "solid-js";
+//#region src/internals/overlay/createPopupAutoResize.ts
+function getCssDimensions(element) {
+	const styles = ownerWindow(element).getComputedStyle(element);
+	let width = parseFloat(styles.width) || 0;
+	let height = parseFloat(styles.height) || 0;
+	if (isHTMLElement(element)) {
+		if (Math.round(width) !== element.offsetWidth || Math.round(height) !== element.offsetHeight) {
+			width = element.offsetWidth;
+			height = element.offsetHeight;
+		}
+	}
+	return {
+		width,
+		height
+	};
+}
+function overrideStyle(element, property, value) {
+	const previous = element.style.getPropertyValue(property);
+	element.style.setProperty(property, value);
+	return () => element.style.setProperty(property, previous);
+}
+function setPopupSize(element, size) {
+	element.style.setProperty("--popup-width", size === "auto" ? "auto" : `${size.width}px`);
+	element.style.setProperty("--popup-height", size === "auto" ? "auto" : `${size.height}px`);
+}
+function setPositionerSize(element, size) {
+	element.style.setProperty("--positioner-width", size === "max-content" ? "max-content" : `${size.width}px`);
+	element.style.setProperty("--positioner-height", size === "max-content" ? "max-content" : `${size.height}px`);
+}
+function createPopupAutoResize(options) {
+	let committed = null;
+	let initial = true;
+	let frame = 0;
+	createEffect(() => ({
+		popup: options.popup(),
+		positioner: options.positioner(),
+		mounted: options.mounted(),
+		content: options.content(),
+		side: options.side(),
+		direction: options.direction?.() ?? "ltr"
+	}), (state) => {
+		if (!state.mounted) {
+			initial = true;
+			committed = null;
+			return;
+		}
+		if (!state.popup || !state.positioner) return;
+		const restorers = [];
+		const physicalLeft = state.side === "left" || state.side === (state.direction === "rtl" ? "inline-end" : "inline-start");
+		if (state.side === "top") {
+			restorers.push(overrideStyle(state.popup, "position", "absolute"));
+			restorers.push(overrideStyle(state.popup, "bottom", "0"));
+		}
+		if (physicalLeft) {
+			if (state.side !== "top") restorers.push(overrideStyle(state.popup, "position", "absolute"));
+			restorers.push(overrideStyle(state.popup, "right", "0"));
+		}
+		setPopupSize(state.popup, "auto");
+		const restorePosition = overrideStyle(state.popup, "position", "static");
+		const restoreTransform = overrideStyle(state.popup, "transform", "none");
+		const restoreScale = overrideStyle(state.popup, "scale", "1");
+		const restoreAvailableWidth = overrideStyle(state.positioner, "--available-width", "max-content");
+		const restoreAvailableHeight = overrideStyle(state.positioner, "--available-height", "max-content");
+		const restoreMeasurements = () => {
+			restorePosition();
+			restoreTransform();
+			restoreScale();
+			restoreAvailableWidth();
+			restoreAvailableHeight();
+		};
+		untrack(() => options.onMeasureLayout)?.();
+		setPositionerSize(state.positioner, "max-content");
+		const dimensions = getCssDimensions(state.popup);
+		if (initial || !committed) {
+			committed = dimensions;
+			setPositionerSize(state.positioner, dimensions);
+			restoreMeasurements();
+			untrack(() => options.onMeasureLayoutComplete)?.(null, dimensions);
+			initial = false;
+			return () => restorers.forEach((restore) => restore());
+		}
+		const previous = committed;
+		committed = dimensions;
+		setPopupSize(state.popup, previous);
+		restoreMeasurements();
+		untrack(() => options.onMeasureLayoutComplete)?.(previous, dimensions);
+		setPositionerSize(state.positioner, dimensions);
+		const abortController = new AbortController();
+		frame = requestAnimationFrame(() => {
+			setPopupSize(state.popup, dimensions);
+			runOnceAnimationsFinish(state.popup, () => setPopupSize(state.popup, "auto"), abortController.signal, { waitForStartingStyleRemoved: true });
+		});
+		return () => {
+			abortController.abort();
+			cancelAnimationFrame(frame);
+			restorers.forEach((restore) => restore());
+		};
+	});
+}
+function calculateActivationDirection(from, to) {
+	const fromRect = from.getBoundingClientRect();
+	const toRect = to.getBoundingClientRect();
+	const horizontal = toRect.left + toRect.width / 2 - (fromRect.left + fromRect.width / 2);
+	const vertical = toRect.top + toRect.height / 2 - (fromRect.top + fromRect.height / 2);
+	return `${horizontal > 5 ? "right" : horizontal < -5 ? "left" : ""} ${vertical > 5 ? "down" : vertical < -5 ? "up" : ""}`;
+}
+//#endregion
+export { createPopupAutoResize as n, calculateActivationDirection as t };

package/dist/lib/server/createTransitionStatus-BTlrerSS.js

@@ -0,0 +1,61 @@
+import { createEffect, createSignal, untrack } from "solid-js";
+//#region src/internals/createTransitionStatus.ts
+/** Tracks mount retention and CSS starting/ending states for a visibility accessor. */
+function createTransitionStatus(open) {
+	const [mounted, setMounted] = createSignal(untrack(open), { ownedWrite: true });
+	const [transitionStatus, setTransitionStatus] = createSignal(void 0, { ownedWrite: true });
+	createEffect(() => ({
+		open: open(),
+		mounted: mounted(),
+		transitionStatus: transitionStatus()
+	}), (state) => {
+		if (state.open && !state.mounted) {
+			setMounted(true);
+			setTransitionStatus("starting");
+			return;
+		}
+		if (!state.open && state.mounted && state.transitionStatus !== "ending") {
+			setTransitionStatus("ending");
+			return;
+		}
+		if (!state.open && !state.mounted && state.transitionStatus === "ending") {
+			setTransitionStatus(void 0);
+			return;
+		}
+		if (state.open && state.transitionStatus === "starting") {
+			let secondFrame;
+			const firstFrame = requestFrame(() => {
+				secondFrame = requestFrame(() => setTransitionStatus(void 0));
+			});
+			return () => {
+				cancelFrame(firstFrame);
+				if (secondFrame) cancelFrame(secondFrame);
+			};
+		}
+		if (state.open && state.transitionStatus === "ending") {
+			const frame = requestFrame(() => setTransitionStatus(void 0));
+			return () => cancelFrame(frame);
+		}
+	});
+	return {
+		mounted,
+		setMounted,
+		transitionStatus
+	};
+}
+function requestFrame(callback) {
+	if (typeof requestAnimationFrame === "function") return {
+		kind: "animation",
+		id: requestAnimationFrame(callback)
+	};
+	return {
+		kind: "timeout",
+		id: setTimeout(() => callback(performance.now()), 16)
+	};
+}
+function cancelFrame(frame) {
+	if (frame.kind === "animation") cancelAnimationFrame(frame.id);
+	else clearTimeout(frame.id);
+}
+//#endregion
+export { createTransitionStatus as t };

package/dist/lib/server/csp-provider/index.js

@@ -0,0 +1,15 @@
+import { t as CSPContext } from "../CSPContext-DOxR0PO7.js";
+//#region src/csp-provider/CSPProvider.tsx
+function CSPProvider(props) {
+	return CSPContext({
+		value: {
+			nonce: () => props.nonce,
+			disableStyleElements: () => props.disableStyleElements ?? false
+		},
+		get children() {
+			return props.children;
+		}
+	});
+}
+//#endregion
+export { CSPProvider };

package/dist/lib/server/dialog/index.js

@@ -0,0 +1,19 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.js";
+import { a as DialogTitle, c as DialogDescription, i as DialogTrigger, l as DialogClose, n as createDialogHandle, o as DialogPortal, p as DialogRoot, r as DialogViewport, t as DialogHandle } from "../DialogHandle-ATZlm9RC.js";
+import { n as DialogBackdrop, t as DialogPopup } from "../DialogPopup-BebI-w5P.js";
+//#region src/dialog/index.parts.ts
+var index_parts_exports = /* @__PURE__ */ __exportAll({
+	Backdrop: () => DialogBackdrop,
+	Close: () => DialogClose,
+	Description: () => DialogDescription,
+	Handle: () => DialogHandle,
+	Popup: () => DialogPopup,
+	Portal: () => DialogPortal,
+	Root: () => DialogRoot,
+	Title: () => DialogTitle,
+	Trigger: () => DialogTrigger,
+	Viewport: () => DialogViewport,
+	createHandle: () => createDialogHandle
+});
+//#endregion
+export { index_parts_exports as Dialog };

package/dist/lib/server/direction-provider/index.js

@@ -0,0 +1,13 @@
+import { n as useDirection, t as DirectionContext } from "../DirectionContext-YORWLF08.js";
+//#region src/direction-provider/DirectionProvider.tsx
+function DirectionProvider(props) {
+	const direction = () => props.direction ?? "ltr";
+	return DirectionContext({
+		value: direction,
+		get children() {
+			return props.children;
+		}
+	});
+}
+//#endregion
+export { DirectionProvider, useDirection };