@sprawlify/primitives 0.0.1

package/dist/machines/bottom-sheet/index.cjs

@@ -0,0 +1,676 @@
+const require_create_anatomy = require('../../create-anatomy-CDsIFUXg.cjs');
+const require_dom_query = require('../../dom-query-CWZdWUGp.cjs');
+const require_defineProperty = require('../../defineProperty-BoUOT9Ie.cjs');
+const require_aria_hidden = require('../../aria-hidden-DtLU6hSU.cjs');
+const require_utils = require('../../utils-_6frwjgJ.cjs');
+const require_core = require('../../core-CQFbMdTl.cjs');
+require('../../interact-outside-C8-oFBpB.cjs');
+const require_dismissable = require('../../dismissable-CTfKZ4OG.cjs');
+const require_focus_trap = require('../../focus-trap-D4i52S9A.cjs');
+const require_create_props = require('../../create-props-YKy7JIKj.cjs');
+const require_remove_scroll = require('../../remove-scroll-Uvzg1L9r.cjs');
+
+//#region src/machines/bottom-sheet/bottom-sheet.anatomy.ts
+const anatomy = require_create_anatomy.createAnatomy("bottom-sheet").parts("content", "title", "trigger", "backdrop", "grabber", "grabberIndicator", "closeTrigger");
+const parts = anatomy.build();
+
+//#endregion
+//#region src/machines/bottom-sheet/bottom-sheet.dom.ts
+const getContentId = (ctx) => ctx.ids?.content ?? `bottom-sheet:${ctx.id}:content`;
+const getTitleId = (ctx) => ctx.ids?.title ?? `bottom-sheet:${ctx.id}:title`;
+const getTriggerId = (ctx) => ctx.ids?.trigger ?? `bottom-sheet:${ctx.id}:trigger`;
+const getBackdropId = (ctx) => ctx.ids?.backdrop ?? `bottom-sheet:${ctx.id}:backdrop`;
+const getGrabberId = (ctx) => ctx.ids?.grabber ?? `bottom-sheet:${ctx.id}:grabber`;
+const getGrabberIndicatorId = (ctx) => ctx.ids?.grabberIndicator ?? `bottom-sheet:${ctx.id}:grabber-indicator`;
+const getCloseTriggerId = (ctx) => ctx.ids?.closeTrigger ?? `bottom-sheet:${ctx.id}:close-trigger`;
+const getContentEl = (ctx) => ctx.getById(getContentId(ctx));
+const getTriggerEl = (ctx) => ctx.getById(getTriggerId(ctx));
+const getCloseTriggerEl = (ctx) => ctx.getById(getCloseTriggerId(ctx));
+
+//#endregion
+//#region src/machines/bottom-sheet/bottom-sheet.connect.ts
+function connect(service, normalize) {
+	const { state, send, context, scope, prop } = service;
+	const open = state.hasTag("open");
+	const dragOffset = context.get("dragOffset");
+	const dragging = dragOffset !== null;
+	const activeSnapPoint = context.get("activeSnapPoint");
+	const resolvedActiveSnapPoint = context.get("resolvedActiveSnapPoint");
+	const translate = dragOffset ?? resolvedActiveSnapPoint?.offset;
+	function onPointerDown(event) {
+		if (!require_dom_query.isLeftClick(event)) return;
+		const target = require_dom_query.getEventTarget(event);
+		if (target?.hasAttribute("data-no-drag") || target?.closest("[data-no-drag]")) return;
+		if (state.matches("closing")) return;
+		send({
+			type: "POINTER_DOWN",
+			point: require_dom_query.getEventPoint(event)
+		});
+	}
+	return {
+		open,
+		dragging,
+		setOpen(nextOpen) {
+			if (state.hasTag("open") === nextOpen) return;
+			send({ type: nextOpen ? "OPEN" : "CLOSE" });
+		},
+		snapPoints: prop("snapPoints"),
+		activeSnapPoint,
+		setActiveSnapPoint(snapPoint) {
+			if (context.get("activeSnapPoint") === snapPoint) return;
+			send({
+				type: "ACTIVE_SNAP_POINT.SET",
+				snapPoint
+			});
+		},
+		getOpenPercentage() {
+			if (!open) return 0;
+			const contentHeight = context.get("contentHeight");
+			if (!contentHeight) return 0;
+			const currentOffset = translate ?? 0;
+			return Math.max(0, Math.min(1, 1 - currentOffset / contentHeight));
+		},
+		getActiveSnapIndex() {
+			return prop("snapPoints").indexOf(activeSnapPoint);
+		},
+		getContentHeight() {
+			return context.get("contentHeight");
+		},
+		getContentProps(props$1 = { draggable: true }) {
+			return normalize.element({
+				...parts.content.attrs,
+				dir: prop("dir"),
+				id: getContentId(scope),
+				tabIndex: -1,
+				role: "dialog",
+				"aria-modal": prop("modal"),
+				"aria-labelledby": getTitleId(scope),
+				hidden: !open,
+				"data-state": open ? "open" : "closed",
+				style: {
+					transform: "translate3d(0, var(--bottom-sheet-translate, 0), 0)",
+					transitionDuration: dragging ? "0s" : void 0,
+					"--bottom-sheet-translate": require_utils.toPx(translate),
+					willChange: "transform"
+				},
+				onPointerDown(event) {
+					if (!props$1.draggable) return;
+					onPointerDown(event);
+				}
+			});
+		},
+		getTitleProps() {
+			return normalize.element({
+				...parts.title.attrs,
+				id: getTitleId(scope),
+				dir: prop("dir")
+			});
+		},
+		getTriggerProps() {
+			return normalize.button({
+				...parts.trigger.attrs,
+				id: getTriggerId(scope),
+				type: "button",
+				onClick() {
+					send({ type: open ? "CLOSE" : "OPEN" });
+				}
+			});
+		},
+		getBackdropProps() {
+			return normalize.element({
+				...parts.backdrop.attrs,
+				id: getBackdropId(scope),
+				hidden: !open,
+				"data-state": open ? "open" : "closed",
+				style: { willChange: "opacity" }
+			});
+		},
+		getGrabberProps() {
+			return normalize.element({
+				...parts.grabber.attrs,
+				id: getGrabberId(scope),
+				onPointerDown(event) {
+					onPointerDown(event);
+				},
+				style: { touchAction: "none" }
+			});
+		},
+		getGrabberIndicatorProps() {
+			return normalize.element({
+				...parts.grabberIndicator.attrs,
+				id: getGrabberIndicatorId(scope)
+			});
+		},
+		getCloseTriggerProps() {
+			return normalize.button({
+				...parts.closeTrigger.attrs,
+				id: getCloseTriggerId(scope),
+				onClick() {
+					send({ type: "CLOSE" });
+				}
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/machines/bottom-sheet/utils/find-closest-snap-point.ts
+function findClosestSnapPoint(offset, snapPoints) {
+	return snapPoints.reduce((acc, curr) => {
+		const closestDiff = Math.abs(offset - acc.offset);
+		return Math.abs(offset - curr.offset) < closestDiff ? curr : acc;
+	});
+}
+
+//#endregion
+//#region src/machines/bottom-sheet/utils/get-scroll-info.ts
+function isScrollContainer(element) {
+	const overflow = getComputedStyle(element).overflowY;
+	return overflow === "auto" || overflow === "scroll";
+}
+function getScrollInfo(target, container) {
+	let element = target;
+	let availableScroll = 0;
+	let availableScrollTop = 0;
+	while (element) {
+		const { clientHeight, scrollTop, scrollHeight } = element;
+		const scrolled = scrollHeight - scrollTop - clientHeight;
+		if ((scrollTop !== 0 || scrolled !== 0) && isScrollContainer(element)) {
+			availableScroll += scrolled;
+			availableScrollTop += scrollTop;
+		}
+		if (element === container || element === document.documentElement) break;
+		element = element.parentNode;
+	}
+	return {
+		availableScroll,
+		availableScrollTop
+	};
+}
+
+//#endregion
+//#region src/machines/bottom-sheet/utils/drag-manager.ts
+const DRAG_START_THRESHOLD = .3;
+var DragManager = class {
+	constructor() {
+		require_defineProperty._defineProperty(this, "pointerStart", null);
+		require_defineProperty._defineProperty(this, "dragOffset", null);
+		require_defineProperty._defineProperty(this, "lastPoint", null);
+		require_defineProperty._defineProperty(this, "lastTimestamp", null);
+		require_defineProperty._defineProperty(this, "velocity", null);
+	}
+	setPointerStart(point) {
+		this.pointerStart = point;
+	}
+	clearPointerStart() {
+		this.pointerStart = null;
+	}
+	getPointerStart() {
+		return this.pointerStart;
+	}
+	setDragOffset(point, resolvedActiveSnapPointOffset) {
+		if (!this.pointerStart) return;
+		const currentTimestamp = (/* @__PURE__ */ new Date()).getTime();
+		if (this.lastPoint) {
+			const dy = point.y - this.lastPoint.y;
+			if (this.lastTimestamp) {
+				const dt = currentTimestamp - this.lastTimestamp;
+				if (dt > 0) {
+					const calculatedVelocity = dy / dt * 1e3;
+					this.velocity = Number.isFinite(calculatedVelocity) ? calculatedVelocity : 0;
+				}
+			}
+		}
+		this.lastPoint = point;
+		this.lastTimestamp = currentTimestamp;
+		let delta = this.pointerStart.y - point.y - resolvedActiveSnapPointOffset;
+		if (delta > 0) delta = 0;
+		this.dragOffset = -delta;
+	}
+	getDragOffset() {
+		return this.dragOffset;
+	}
+	clearDragOffset() {
+		this.dragOffset = null;
+	}
+	getVelocity() {
+		return this.velocity;
+	}
+	clearVelocityTracking() {
+		this.lastPoint = null;
+		this.lastTimestamp = null;
+		this.velocity = null;
+	}
+	clear() {
+		this.clearPointerStart();
+		this.clearDragOffset();
+		this.clearVelocityTracking();
+	}
+	shouldStartDragging(point, target, container, preventDragOnScroll) {
+		if (!this.pointerStart || !container) return false;
+		if (preventDragOnScroll) {
+			const delta = this.pointerStart.y - point.y;
+			if (Math.abs(delta) < DRAG_START_THRESHOLD) return false;
+			const { availableScroll, availableScrollTop } = getScrollInfo(target, container);
+			if (delta > 0 && Math.abs(availableScroll) > 1 || delta < 0 && Math.abs(availableScrollTop) > 0) return false;
+		}
+		return true;
+	}
+	findClosestSnapPoint(snapPoints) {
+		if (this.dragOffset === null) return snapPoints[0]?.value ?? 1;
+		return findClosestSnapPoint(this.dragOffset, snapPoints).value;
+	}
+	shouldDismiss(contentHeight, snapPoints, swipeVelocityThreshold, closeThreshold) {
+		if (this.dragOffset === null || this.velocity === null || contentHeight === null) return false;
+		const visibleHeight = contentHeight - this.dragOffset;
+		const smallestSnapPoint = snapPoints.reduce((acc, curr) => curr.offset > acc.offset ? curr : acc);
+		const isFastSwipe = this.velocity > 0 && this.velocity >= swipeVelocityThreshold;
+		const closeThresholdInPixels = contentHeight * (1 - closeThreshold);
+		const isBelowSmallestSnapPoint = visibleHeight < contentHeight - smallestSnapPoint.offset;
+		return isFastSwipe || visibleHeight < closeThresholdInPixels && isBelowSmallestSnapPoint || visibleHeight === 0;
+	}
+};
+
+//#endregion
+//#region src/machines/bottom-sheet/utils/resolve-snap-point.ts
+function resolveSnapPoint(snapPoint, containerHeight) {
+	if (typeof snapPoint === "number") return {
+		value: snapPoint,
+		offset: containerHeight - snapPoint * containerHeight
+	};
+	if (typeof snapPoint === "string") return {
+		value: snapPoint,
+		offset: containerHeight - parseFloat(snapPoint)
+	};
+	throw new Error(`Invalid snap point: ${snapPoint}`);
+}
+
+//#endregion
+//#region src/machines/bottom-sheet/bottom-sheet.machine.ts
+const machine = require_core.createMachine({
+	props({ props: props$1, scope }) {
+		const initialFocusEl = props$1.role === "alertdialog" ? () => getCloseTriggerEl(scope) : void 0;
+		const modal = typeof props$1.modal === "boolean" ? props$1.modal : true;
+		return {
+			modal,
+			trapFocus: modal,
+			preventScroll: modal,
+			closeOnInteractOutside: true,
+			closeOnEscape: true,
+			restoreFocus: true,
+			initialFocusEl,
+			snapPoints: [1],
+			defaultActiveSnapPoint: 1,
+			swipeVelocityThreshold: 700,
+			closeThreshold: .25,
+			preventDragOnScroll: true,
+			...props$1
+		};
+	},
+	context({ bindable, prop }) {
+		return {
+			dragOffset: bindable(() => ({ defaultValue: null })),
+			activeSnapPoint: bindable(() => ({
+				defaultValue: prop("defaultActiveSnapPoint"),
+				value: prop("activeSnapPoint"),
+				onChange(value) {
+					return prop("onActiveSnapPointChange")?.({ snapPoint: value });
+				}
+			})),
+			resolvedActiveSnapPoint: bindable(() => ({ defaultValue: null })),
+			contentHeight: bindable(() => ({ defaultValue: null }))
+		};
+	},
+	refs() {
+		return { dragManager: new DragManager() };
+	},
+	computed: { resolvedSnapPoints({ context, prop }) {
+		const contentHeight = context.get("contentHeight");
+		if (contentHeight === null) return [];
+		return prop("snapPoints").map((snapPoint) => resolveSnapPoint(snapPoint, contentHeight));
+	} },
+	watch({ track, context, prop, action }) {
+		track([() => context.get("activeSnapPoint"), () => context.get("contentHeight")], () => {
+			const activeSnapPoint = context.get("activeSnapPoint");
+			const contentHeight = context.get("contentHeight");
+			if (contentHeight === null) return;
+			const resolvedActiveSnapPoint = resolveSnapPoint(activeSnapPoint, contentHeight);
+			context.set("resolvedActiveSnapPoint", resolvedActiveSnapPoint);
+		});
+		track([() => prop("open")], () => {
+			action(["toggleVisibility"]);
+		});
+	},
+	initialState({ prop }) {
+		return prop("open") || prop("defaultOpen") ? "open" : "closed";
+	},
+	on: { "ACTIVE_SNAP_POINT.SET": { actions: ["setActiveSnapPoint"] } },
+	states: {
+		open: {
+			tags: ["open"],
+			effects: [
+				"trackDismissableElement",
+				"preventScroll",
+				"trapFocus",
+				"hideContentBelow",
+				"trackPointerMove",
+				"trackContentHeight"
+			],
+			on: {
+				"CONTROLLED.CLOSE": { target: "closed" },
+				POINTER_DOWN: { actions: ["setPointerStart"] },
+				POINTER_MOVE: [{
+					guard: "isDragging",
+					actions: ["setDragOffset"]
+				}, {
+					guard: "shouldStartDragging",
+					actions: ["setDragOffset"]
+				}],
+				POINTER_UP: [
+					{
+						guard: "shouldCloseOnSwipe",
+						target: "closing"
+					},
+					{
+						guard: "isDragging",
+						actions: [
+							"setClosestSnapPoint",
+							"clearPointerStart",
+							"clearDragOffset"
+						]
+					},
+					{ actions: ["clearPointerStart", "clearDragOffset"] }
+				],
+				CLOSE: [{
+					guard: "isOpenControlled",
+					actions: ["invokeOnClose"]
+				}, {
+					target: "closing",
+					actions: ["invokeOnClose"]
+				}]
+			}
+		},
+		closing: {
+			effects: ["trackExitAnimation"],
+			on: { ANIMATION_END: {
+				target: "closed",
+				actions: [
+					"invokeOnClose",
+					"clearPointerStart",
+					"clearDragOffset",
+					"clearActiveSnapPoint",
+					"clearResolvedActiveSnapPoint",
+					"clearContentHeight",
+					"clearVelocityTracking"
+				]
+			} }
+		},
+		closed: {
+			tags: ["closed"],
+			on: {
+				"CONTROLLED.OPEN": { target: "open" },
+				OPEN: [{
+					guard: "isOpenControlled",
+					actions: ["invokeOnOpen"]
+				}, {
+					target: "open",
+					actions: ["invokeOnOpen"]
+				}]
+			}
+		}
+	},
+	implementations: {
+		guards: {
+			isOpenControlled: ({ prop }) => prop("open") !== void 0,
+			isDragging({ context }) {
+				return context.get("dragOffset") !== null;
+			},
+			shouldStartDragging({ prop, refs, event, scope }) {
+				return refs.get("dragManager").shouldStartDragging(event.point, event.target, getContentEl(scope), prop("preventDragOnScroll"));
+			},
+			shouldCloseOnSwipe({ prop, context, computed, refs }) {
+				return refs.get("dragManager").shouldDismiss(context.get("contentHeight"), computed("resolvedSnapPoints"), prop("swipeVelocityThreshold"), prop("closeThreshold"));
+			}
+		},
+		actions: {
+			invokeOnOpen({ prop }) {
+				prop("onOpenChange")?.({ open: true });
+			},
+			invokeOnClose({ prop }) {
+				prop("onOpenChange")?.({ open: false });
+			},
+			setActiveSnapPoint({ context, event }) {
+				context.set("activeSnapPoint", event.snapPoint);
+			},
+			setPointerStart({ event, refs }) {
+				refs.get("dragManager").setPointerStart(event.point);
+			},
+			setDragOffset({ context, event, refs }) {
+				const dragManager = refs.get("dragManager");
+				dragManager.setDragOffset(event.point, context.get("resolvedActiveSnapPoint")?.offset || 0);
+				context.set("dragOffset", dragManager.getDragOffset());
+			},
+			setClosestSnapPoint({ computed, context, refs }) {
+				const snapPoints = computed("resolvedSnapPoints");
+				const contentHeight = context.get("contentHeight");
+				if (!snapPoints.length || contentHeight === null) return;
+				const closestSnapPoint = refs.get("dragManager").findClosestSnapPoint(snapPoints);
+				context.set("activeSnapPoint", closestSnapPoint);
+				const resolved = resolveSnapPoint(closestSnapPoint, contentHeight);
+				context.set("resolvedActiveSnapPoint", resolved);
+			},
+			clearDragOffset({ context, refs }) {
+				refs.get("dragManager").clearDragOffset();
+				context.set("dragOffset", null);
+			},
+			clearActiveSnapPoint({ context, prop }) {
+				context.set("activeSnapPoint", prop("defaultActiveSnapPoint"));
+			},
+			clearResolvedActiveSnapPoint({ context }) {
+				context.set("resolvedActiveSnapPoint", null);
+			},
+			clearPointerStart({ refs }) {
+				refs.get("dragManager").clearPointerStart();
+			},
+			clearContentHeight({ context }) {
+				context.set("contentHeight", null);
+			},
+			clearVelocityTracking({ refs }) {
+				refs.get("dragManager").clearVelocityTracking();
+			},
+			toggleVisibility({ event, send, prop }) {
+				send({
+					type: prop("open") ? "CONTROLLED.OPEN" : "CONTROLLED.CLOSE",
+					previousEvent: event
+				});
+			}
+		},
+		effects: {
+			trackDismissableElement({ scope, prop, send }) {
+				const getContentEl$1 = () => getContentEl(scope);
+				return require_dismissable.trackDismissableElement(getContentEl$1, {
+					defer: true,
+					exclude: [getTriggerEl(scope)],
+					onInteractOutside(event) {
+						prop("onInteractOutside")?.(event);
+						if (!prop("closeOnInteractOutside")) event.preventDefault();
+					},
+					onFocusOutside: prop("onFocusOutside"),
+					onEscapeKeyDown(event) {
+						prop("onEscapeKeyDown")?.(event);
+						if (!prop("closeOnEscape")) event.preventDefault();
+					},
+					onPointerDownOutside: prop("onPointerDownOutside"),
+					onRequestDismiss: prop("onRequestDismiss"),
+					onDismiss() {
+						send({
+							type: "CLOSE",
+							src: "interact-outside"
+						});
+					}
+				});
+			},
+			preventScroll({ scope, prop }) {
+				if (!prop("preventScroll")) return;
+				return require_remove_scroll.preventBodyScroll(scope.getDoc());
+			},
+			trapFocus({ scope, prop }) {
+				if (!prop("trapFocus")) return;
+				const contentEl = () => getContentEl(scope);
+				return require_focus_trap.trapFocus(contentEl, {
+					preventScroll: true,
+					returnFocusOnDeactivate: !!prop("restoreFocus"),
+					initialFocus: prop("initialFocusEl"),
+					setReturnFocus: (el) => prop("finalFocusEl")?.() || el,
+					getShadowRoot: true
+				});
+			},
+			hideContentBelow({ scope, prop }) {
+				if (!prop("modal")) return;
+				const getElements = () => [getContentEl(scope)];
+				return require_aria_hidden.ariaHidden(getElements, { defer: true });
+			},
+			trackPointerMove({ scope, send, prop }) {
+				let lastY = 0;
+				function onPointerMove(event) {
+					send({
+						type: "POINTER_MOVE",
+						point: require_dom_query.getEventPoint(event),
+						target: require_dom_query.getEventTarget(event)
+					});
+				}
+				function onPointerUp(event) {
+					if (event.pointerType === "touch") return;
+					send({
+						type: "POINTER_UP",
+						point: require_dom_query.getEventPoint(event)
+					});
+				}
+				function onTouchStart(event) {
+					if (!event.touches[0]) return;
+					lastY = event.touches[0].clientY;
+				}
+				function onTouchMove(event) {
+					if (!event.touches[0]) return;
+					const point = require_dom_query.getEventPoint(event);
+					const target = event.target;
+					if (!prop("preventDragOnScroll")) {
+						send({
+							type: "POINTER_MOVE",
+							point,
+							target
+						});
+						return;
+					}
+					const contentEl = getContentEl(scope);
+					if (!contentEl) return;
+					let el = target;
+					while (el && el !== contentEl && el.scrollHeight <= el.clientHeight) el = el.parentElement;
+					if (el && el !== contentEl) {
+						const scrollTop = el.scrollTop;
+						const y = event.touches[0].clientY;
+						if (scrollTop <= 0 && y > lastY) event.preventDefault();
+						lastY = y;
+					}
+					send({
+						type: "POINTER_MOVE",
+						point,
+						target
+					});
+				}
+				function onTouchEnd(event) {
+					if (event.touches.length !== 0) return;
+					send({
+						type: "POINTER_UP",
+						point: require_dom_query.getEventPoint(event)
+					});
+				}
+				const doc = scope.getDoc();
+				const cleanups = [
+					require_dom_query.addDomEvent(doc, "pointermove", onPointerMove),
+					require_dom_query.addDomEvent(doc, "pointerup", onPointerUp),
+					require_dom_query.addDomEvent(doc, "touchstart", onTouchStart, { passive: false }),
+					require_dom_query.addDomEvent(doc, "touchmove", onTouchMove, { passive: false }),
+					require_dom_query.addDomEvent(doc, "touchend", onTouchEnd)
+				];
+				return () => {
+					cleanups.forEach((cleanup) => cleanup());
+				};
+			},
+			trackContentHeight({ context, scope }) {
+				const contentEl = getContentEl(scope);
+				if (!contentEl) return;
+				const updateHeight = () => {
+					const rect = contentEl.getBoundingClientRect();
+					context.set("contentHeight", rect.height);
+				};
+				updateHeight();
+				return require_dom_query.resizeObserverBorderBox.observe(contentEl, updateHeight);
+			},
+			trackExitAnimation({ send, scope }) {
+				let cleanup;
+				const rafCleanup = require_dom_query.raf(() => {
+					const contentEl = getContentEl(scope);
+					if (!contentEl) return;
+					const animationName = getComputedStyle(contentEl).animationName;
+					if (!animationName || animationName === "none") {
+						send({ type: "ANIMATION_END" });
+						return;
+					}
+					const onEnd = (event) => {
+						if (require_dom_query.getEventTarget(event) === contentEl) send({ type: "ANIMATION_END" });
+					};
+					contentEl.addEventListener("animationend", onEnd);
+					cleanup = () => {
+						contentEl.removeEventListener("animationend", onEnd);
+					};
+				});
+				return () => {
+					rafCleanup();
+					cleanup?.();
+				};
+			}
+		}
+	}
+});
+
+//#endregion
+//#region src/machines/bottom-sheet/bottom-sheet.props.ts
+const props = require_create_props.createProps()([
+	"id",
+	"ids",
+	"dir",
+	"modal",
+	"initialFocusEl",
+	"finalFocusEl",
+	"open",
+	"defaultOpen",
+	"getRootNode",
+	"snapPoints",
+	"swipeVelocityThreshold",
+	"closeThreshold",
+	"preventDragOnScroll",
+	"closeOnEscape",
+	"closeOnInteractOutside",
+	"onEscapeKeyDown",
+	"onFocusOutside",
+	"onInteractOutside",
+	"onOpenChange",
+	"onPointerDownOutside",
+	"onRequestDismiss",
+	"preventScroll",
+	"restoreFocus",
+	"role",
+	"trapFocus",
+	"defaultActiveSnapPoint",
+	"activeSnapPoint",
+	"onActiveSnapPointChange"
+]);
+const splitProps = require_utils.createSplitProps(props);
+
+//#endregion
+exports.anatomy = anatomy;
+exports.connect = connect;
+exports.machine = machine;
+exports.props = props;
+exports.splitProps = splitProps;