solid-baseui 0.1.0-alpha.0

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

@@ -0,0 +1,566 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.js";
+import { getStateAttributesProps } from "../internals/getStateAttributesProps.js";
+import { N as triggerPress, w as none } from "../internals/reasons.js";
+import { n as resolveClass, t as resolveStyle } from "../resolveStyle-XCSFDHAL.js";
+import { n as createCollapsibleTransitionStatus, t as createCollapsiblePanel } from "../createCollapsiblePanel-DTyVJz0G.js";
+import { createChangeEventDetails } from "../internals/createBaseUIEventDetails.js";
+import { transitionStatusMapping } from "../internals/stateAttributesMapping.js";
+import { composeEventHandlers } from "../internals/composeEventHandlers.js";
+import { Dynamic, memo, mergeProps, ssrElement } from "@solidjs/web";
+import { Show, createContext, createEffect, createMemo, createSignal, createUniqueId, flush, omit, onCleanup, untrack, useContext } from "solid-js";
+//#region src/accordion/root/AccordionRootContext.ts
+var MISSING_CONTEXT$1 = Symbol("AccordionRootContext");
+var AccordionRootContext = createContext(MISSING_CONTEXT$1);
+function useAccordionRootContext() {
+	const context = useContext(AccordionRootContext);
+	if (context === MISSING_CONTEXT$1) throw new Error("Base UI: AccordionRootContext is missing. Accordion parts must be placed within <Accordion.Root>.");
+	return context;
+}
+//#endregion
+//#region src/accordion/root/stateAttributesMapping.ts
+var accordionRootStateAttributesMapping = { value: () => null };
+//#endregion
+//#region src/accordion/root/AccordionRoot.tsx
+var EMPTY_VALUE = [];
+function AccordionRoot(props) {
+	const internalProps = props;
+	const allProps = props;
+	const controlled = untrack(() => internalProps.value !== void 0);
+	const [uncontrolledValue, setUncontrolledValue] = createSignal(() => untrack(() => internalProps.defaultValue ?? []));
+	let uncontrolledValueSnapshot = untrack(uncontrolledValue);
+	const [rootElement, setRootElement] = createSignal();
+	const [itemVersion, setItemVersion] = createSignal(0);
+	const items = /* @__PURE__ */ new Map();
+	let nextItemOrder = 0;
+	let disposed = false;
+	let itemChangeQueued = false;
+	const others = omit(allProps, "as", "class", "defaultValue", "disabled", "hiddenUntilFound", "keepMounted", "loopFocus", "multiple", "onValueChange", "orientation", "ref", "style", "value");
+	const value = createMemo(() => controlled ? internalProps.value ?? EMPTY_VALUE : uncontrolledValue());
+	const disabled = createMemo(() => internalProps.disabled ?? false);
+	const hiddenUntilFound = createMemo(() => internalProps.hiddenUntilFound ?? false);
+	const keepMounted = createMemo(() => internalProps.keepMounted ?? false);
+	const multiple = createMemo(() => internalProps.multiple ?? false);
+	const orientation = createMemo(() => internalProps.orientation ?? "vertical");
+	const state = createMemo(() => ({
+		value: value(),
+		disabled: disabled(),
+		orientation: orientation()
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => resolveStyle(props.style, state()));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), accordionRootStateAttributesMapping));
+	function notifyItemChange() {
+		if (itemChangeQueued) return;
+		itemChangeQueued = true;
+		queueMicrotask(() => {
+			itemChangeQueued = false;
+			if (!disposed) setItemVersion((version) => version + 1);
+		});
+	}
+	function registerItem(registration) {
+		registration.order = nextItemOrder;
+		nextItemOrder += 1;
+		items.set(registration.token, registration);
+		notifyItemChange();
+		return () => {
+			items.delete(registration.token);
+			notifyItemChange();
+		};
+	}
+	function getOrderedItems() {
+		return Array.from(items.values()).sort(compareRegistrations);
+	}
+	function getItemIndex(registration) {
+		itemVersion();
+		return getOrderedItems().indexOf(registration);
+	}
+	function handleValueChange(itemValue, nextOpen, details, beforeCommit) {
+		const currentValue = controlled ? internalProps.value ?? EMPTY_VALUE : uncontrolledValueSnapshot;
+		let nextValue;
+		if (!multiple()) nextValue = currentValue[0] === itemValue ? [] : [itemValue];
+		else if (nextOpen) {
+			nextValue = currentValue.slice();
+			nextValue.push(itemValue);
+		} else nextValue = currentValue.filter((valueItem) => valueItem !== itemValue);
+		internalProps.onValueChange?.(nextValue, details);
+		if (details.isCanceled) return false;
+		beforeCommit?.();
+		if (!controlled) {
+			uncontrolledValueSnapshot = nextValue;
+			setUncontrolledValue(() => nextValue);
+		}
+		flush();
+		return true;
+	}
+	const context = {
+		disabled,
+		getItemIndex,
+		handleValueChange,
+		hiddenUntilFound,
+		keepMounted,
+		notifyItemChange,
+		registerItem,
+		state,
+		value
+	};
+	createEffect(() => ({
+		hiddenUntilFound: internalProps.hiddenUntilFound,
+		keepMounted: internalProps.keepMounted
+	}), (current) => {
+		if (current.hiddenUntilFound && current.keepMounted === false && false);
+	});
+	createEffect(rootElement, (element) => {
+		const Observer = element?.ownerDocument.defaultView?.MutationObserver;
+		if (!element || !Observer) return;
+		const observer = new Observer(notifyItemChange);
+		observer.observe(element, {
+			childList: true,
+			subtree: true
+		});
+		return () => observer.disconnect();
+	});
+	onCleanup(() => {
+		disposed = true;
+	});
+	return AccordionRootContext({
+		value: context,
+		get children() {
+			return Dynamic(mergeProps({
+				get component() {
+					return props.as ?? "div";
+				},
+				ref: [((element) => setRootElement(element)), internalProps.ref],
+				get ["class"]() {
+					return classValue();
+				},
+				get style() {
+					return styleValue();
+				}
+			}, stateAttributes, others));
+		}
+	});
+}
+function compareRegistrations(first, second) {
+	const firstElement = first.element();
+	const secondElement = second.element();
+	if (firstElement && secondElement && firstElement !== secondElement) {
+		const position = firstElement.compareDocumentPosition(secondElement);
+		if ((position & Node.DOCUMENT_POSITION_DISCONNECTED) === 0) {
+			if (position & Node.DOCUMENT_POSITION_FOLLOWING) return -1;
+			if (position & Node.DOCUMENT_POSITION_PRECEDING) return 1;
+		}
+	}
+	return first.order - second.order;
+}
+//#endregion
+//#region src/accordion/item/AccordionItemContext.ts
+var MISSING_CONTEXT = Symbol("AccordionItemContext");
+var AccordionItemContext = createContext(MISSING_CONTEXT);
+function useAccordionItemContext() {
+	const context = useContext(AccordionItemContext);
+	if (context === MISSING_CONTEXT) throw new Error("Base UI: AccordionItemContext is missing. Accordion parts must be placed within <Accordion.Item>.");
+	return context;
+}
+//#endregion
+//#region src/accordion/item/AccordionItemDataAttributes.ts
+var AccordionItemDataAttributes = /* @__PURE__ */ function(AccordionItemDataAttributes) {
+	AccordionItemDataAttributes["index"] = "data-index";
+	AccordionItemDataAttributes["disabled"] = "data-disabled";
+	AccordionItemDataAttributes["open"] = "data-open";
+	return AccordionItemDataAttributes;
+}({});
+//#endregion
+//#region src/accordion/item/stateAttributesMapping.ts
+var OPEN_HOOK = { "data-open": "" };
+var CLOSED_HOOK = { "data-closed": "" };
+var accordionStateAttributesMapping = {
+	open(value) {
+		return value ? OPEN_HOOK : CLOSED_HOOK;
+	},
+	index(value) {
+		return { [AccordionItemDataAttributes.index]: String(value) };
+	},
+	...transitionStatusMapping,
+	value: () => null
+};
+//#endregion
+//#region src/accordion/item/AccordionItem.tsx
+/** Groups an accordion header with its corresponding panel. */
+function AccordionItem(props) {
+	const root = useAccordionRootContext();
+	const internalProps = props;
+	const allProps = props;
+	const fallbackValue = `base-ui-${createUniqueId()}`;
+	const defaultPanelId = `base-ui-${createUniqueId()}`;
+	const defaultTriggerId = `base-ui-${createUniqueId()}`;
+	const token = Symbol("AccordionItem");
+	const [element, setElement] = createSignal();
+	const [registeredPanelId, setPanelIdState] = createSignal();
+	const [registeredTriggerId, setTriggerIdState] = createSignal();
+	const value = createMemo(() => internalProps.value === void 0 ? fallbackValue : internalProps.value);
+	const disabled = createMemo(() => (internalProps.disabled ?? false) || root.disabled());
+	const open = createMemo(() => root.value().indexOf(value()) !== -1);
+	const transition = createCollapsibleTransitionStatus(() => open());
+	const registration = {
+		token,
+		order: 0,
+		element
+	};
+	const unregister = root.registerItem(registration);
+	const panelId = createMemo(() => {
+		const registered = registeredPanelId();
+		return registered === null ? void 0 : registered ?? defaultPanelId;
+	});
+	const triggerId = createMemo(() => {
+		const registered = registeredTriggerId();
+		return registered === null ? void 0 : registered ?? defaultTriggerId;
+	});
+	const others = omit(allProps, "as", "class", "disabled", "onOpenChange", "ref", "style", "value");
+	const state = createMemo(() => ({
+		...root.state(),
+		hidden: !open() && !transition.mounted(),
+		index: root.getItemIndex(registration),
+		disabled: disabled(),
+		open: open()
+	}));
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => resolveStyle(props.style, state()));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), accordionStateAttributesMapping));
+	function requestOpenChange(nextOpen, event, reason, beforeCommit) {
+		const details = createChangeEventDetails(reason, event);
+		internalProps.onOpenChange?.(nextOpen, details);
+		if (details.isCanceled) return false;
+		return root.handleValueChange(value(), nextOpen, details, beforeCommit);
+	}
+	const context = {
+		defaultPanelId,
+		defaultTriggerId,
+		disabled,
+		mounted: transition.mounted,
+		open,
+		panelId,
+		requestOpenChange,
+		setMounted: transition.setMounted,
+		setPanelIdState,
+		setTriggerIdState,
+		state,
+		transitionStatus: transition.transitionStatus,
+		triggerId
+	};
+	createEffect(() => ({
+		element: element(),
+		value: value()
+	}), () => root.notifyItemChange());
+	onCleanup(() => {
+		unregister();
+		setElement(void 0);
+	});
+	return AccordionItemContext({
+		value: context,
+		get children() {
+			return Dynamic(mergeProps({
+				get component() {
+					return props.as ?? "div";
+				},
+				ref: [((current) => setElement(current)), internalProps.ref],
+				get ["class"]() {
+					return classValue();
+				},
+				get style() {
+					return styleValue();
+				}
+			}, stateAttributes, others));
+		}
+	});
+}
+//#endregion
+//#region src/accordion/header/AccordionHeader.tsx
+/** A heading that labels the corresponding panel. */
+function AccordionHeader(props) {
+	const context = useAccordionItemContext();
+	const internalProps = props;
+	const others = omit(props, "as", "class", "ref", "style");
+	const state = context.state;
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => resolveStyle(props.style, state()));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), accordionStateAttributesMapping));
+	return Dynamic(mergeProps({
+		get component() {
+			return props.as ?? "h3";
+		},
+		ref: [internalProps.ref],
+		get ["class"]() {
+			return classValue();
+		},
+		get style() {
+			return styleValue();
+		}
+	}, stateAttributes, others));
+}
+//#endregion
+//#region src/accordion/trigger/AccordionTriggerDataAttributes.ts
+var AccordionTriggerDataAttributes = /* @__PURE__ */ function(AccordionTriggerDataAttributes) {
+	AccordionTriggerDataAttributes["panelOpen"] = "data-panel-open";
+	AccordionTriggerDataAttributes["disabled"] = "data-disabled";
+	return AccordionTriggerDataAttributes;
+}({});
+//#endregion
+//#region src/accordion/trigger/AccordionTrigger.tsx
+var triggerStateAttributesMapping = { open(value) {
+	return value ? { [AccordionTriggerDataAttributes.panelOpen]: "" } : null;
+} };
+/** A button that opens and closes the corresponding panel. */
+function AccordionTrigger(props) {
+	const context = useAccordionItemContext();
+	const internalProps = props;
+	const allProps = props;
+	const registeredId = createMemo(() => internalProps.id || void 0);
+	const id = createMemo(() => registeredId() ?? context.defaultTriggerId);
+	const disabled = createMemo(() => (internalProps.disabled ?? false) || context.disabled());
+	const nativeButton = createMemo(() => internalProps.nativeButton ?? true);
+	const others = omit(allProps, "as", "class", "disabled", "id", "nativeButton", "onClick", "onKeyDown", "onKeyUp", "onMouseDown", "onMouseUp", "onPointerDown", "ref", "style");
+	const state = context.state;
+	const classValue = createMemo(() => resolveClass(props.class, state()));
+	const styleValue = createMemo(() => resolveStyle(props.style, state()));
+	const stateAttributes = createMemo(() => getStateAttributesProps(state(), triggerStateAttributesMapping));
+	const ariaDisabled = createMemo(() => nativeButton() ? disabled() ? "true" : "false" : disabled() ? "true" : void 0);
+	const onClick = composeEventHandlers(() => untrack(() => disabled() ? preventInteraction : void 0), () => internalProps.onClick, () => (event) => {
+		context.requestOpenChange(!context.open(), event, triggerPress);
+	});
+	const onMouseDown = composeEventHandlers(() => untrack(() => disabled() ? stopInteraction : void 0), () => internalProps.onMouseDown);
+	const onMouseUp = composeEventHandlers(() => internalProps.onMouseUp);
+	const onPointerDown = composeEventHandlers(() => untrack(() => disabled() ? preventInteraction : void 0), () => internalProps.onPointerDown);
+	const onKeyDown = composeEventHandlers(() => untrack(() => disabled() ? preventDisabledKeyDown : void 0), () => internalProps.onKeyDown, () => untrack(() => nativeButton() ? void 0 : handleNonNativeKeyDown));
+	const onKeyUp = composeEventHandlers(() => untrack(() => disabled() ? stopInteraction : void 0), () => internalProps.onKeyUp, () => untrack(() => nativeButton() ? void 0 : handleNonNativeKeyUp));
+	createEffect(() => registeredId(), (currentId) => {
+		context.setTriggerIdState((existingId) => currentId ?? (existingId === null ? void 0 : existingId));
+		return () => {
+			context.setTriggerIdState((existingId) => existingId === currentId ? null : existingId);
+		};
+	});
+	return Dynamic(mergeProps({
+		get component() {
+			return props.as ?? "button";
+		},
+		ref: [internalProps.ref],
+		get id() {
+			return id();
+		},
+		get ["class"]() {
+			return classValue();
+		},
+		get style() {
+			return styleValue();
+		},
+		get type() {
+			return nativeButton() ? "button" : void 0;
+		},
+		get role() {
+			return nativeButton() ? void 0 : "button";
+		},
+		tabIndex: 0,
+		get ["aria-controls"]() {
+			return memo(() => {
+				return !!context.open();
+			})() ? context.panelId() : void 0;
+		},
+		get ["aria-disabled"]() {
+			return ariaDisabled();
+		},
+		get ["aria-expanded"]() {
+			return context.open() ? "true" : "false";
+		},
+		onClick,
+		onKeyDown,
+		onKeyUp,
+		onMouseDown,
+		onMouseUp,
+		onPointerDown
+	}, stateAttributes, others));
+}
+function preventInteraction(event) {
+	event.preventDefault();
+	event.preventBaseUIHandler();
+}
+function stopInteraction(event) {
+	event.preventBaseUIHandler();
+}
+function preventDisabledKeyDown(event) {
+	if (event.key !== "Tab") event.preventDefault();
+	event.preventBaseUIHandler();
+}
+function handleNonNativeKeyDown(event) {
+	if (event.target !== event.currentTarget) return;
+	const isLink = event.currentTarget.tagName === "A" && Boolean(event.currentTarget.href);
+	if (isLink || event.key !== "Enter" && event.key !== " ") {
+		if (isLink && event.key === " ") event.preventDefault();
+		return;
+	}
+	if (event.defaultPrevented) return;
+	event.preventDefault();
+	if (event.key === "Enter") {
+		event.preventBaseUIHandler();
+		dispatchClick(event.currentTarget, event);
+	}
+}
+function handleNonNativeKeyUp(event) {
+	if (event.target === event.currentTarget && !event.defaultPrevented && event.key === " ") {
+		event.preventBaseUIHandler();
+		dispatchClick(event.currentTarget, event);
+	}
+}
+function dispatchClick(target, sourceEvent) {
+	const ownerWindow = target.ownerDocument.defaultView;
+	if (!ownerWindow) return;
+	const ClickEvent = ownerWindow.PointerEvent ?? ownerWindow.MouseEvent;
+	target.dispatchEvent(new ClickEvent("click", {
+		bubbles: true,
+		cancelable: true,
+		composed: true,
+		detail: 0,
+		shiftKey: sourceEvent.shiftKey,
+		ctrlKey: sourceEvent.ctrlKey,
+		altKey: sourceEvent.altKey,
+		metaKey: sourceEvent.metaKey
+	}));
+}
+//#endregion
+//#region src/accordion/panel/AccordionPanelCssVars.ts
+var AccordionPanelCssVars = /* @__PURE__ */ function(AccordionPanelCssVars) {
+	AccordionPanelCssVars["accordionPanelHeight"] = "--accordion-panel-height";
+	AccordionPanelCssVars["accordionPanelWidth"] = "--accordion-panel-width";
+	return AccordionPanelCssVars;
+}({});
+//#endregion
+//#region src/accordion/panel/AccordionPanel.tsx
+/** A collapsible panel containing the accordion item contents. */
+function AccordionPanel(props) {
+	const root = useAccordionRootContext();
+	const item = useAccordionItemContext();
+	const internalProps = props;
+	const allProps = props;
+	const [panelElement, setPanelElement] = createSignal();
+	const hiddenUntilFound = createMemo(() => internalProps.hiddenUntilFound ?? root.hiddenUntilFound());
+	const keepMounted = createMemo(() => internalProps.keepMounted ?? root.keepMounted());
+	const registeredId = createMemo(() => internalProps.id || void 0);
+	const id = createMemo(() => internalProps.id ?? item.defaultPanelId);
+	const others = omit(allProps, "as", "class", "hiddenUntilFound", "id", "keepMounted", "ref", "style");
+	const controller = createCollapsiblePanel({
+		element: panelElement,
+		hiddenUntilFound,
+		keepMounted,
+		mounted: item.mounted,
+		open: item.open,
+		requestBeforeMatchOpen: (event, beforeCommit) => item.requestOpenChange(true, event, none, beforeCommit),
+		setMounted: item.setMounted,
+		transitionStatus: item.transitionStatus
+	});
+	const state = createMemo(() => ({
+		...item.state(),
+		transitionStatus: controller.panelTransitionStatus()
+	}));
+	const classValue = createMemo(() => controller.shouldRender() ? resolveClass(props.class, state()) : void 0);
+	const styleValue = createMemo(() => resolvePanelStyle(controller.dimensions(), controller.shouldRender() ? resolveStyle(props.style, state()) : void 0, controller.shouldPreventOpenAnimation()));
+	const stateAttributes = createMemo(() => {
+		const attributes = getStateAttributesProps(state(), accordionStateAttributesMapping);
+		if (controller.shouldPersistHiddenTransitionStyles()) attributes["data-starting-style"] = "";
+		return attributes;
+	});
+	const hiddenValue = createMemo(() => controller.hidden() ? hiddenUntilFound() ? "until-found" : true : void 0);
+	createEffect(() => registeredId(), (currentId) => {
+		item.setPanelIdState((existingId) => currentId ?? (existingId === null ? void 0 : existingId));
+		return () => {
+			item.setPanelIdState((existingId) => existingId === currentId ? null : existingId);
+		};
+	});
+	createEffect(() => ({
+		hiddenUntilFound: hiddenUntilFound(),
+		keepMounted: internalProps.keepMounted
+	}), (current) => {
+		if (current.hiddenUntilFound && current.keepMounted === false && false);
+	});
+	onCleanup(() => setPanelElement(void 0));
+	return Show({
+		get when() {
+			return controller.shouldRender();
+		},
+		get children() {
+			return Show({
+				get when() {
+					return props.as;
+				},
+				get fallback() {
+					return ssrElement("div", () => {
+						return mergeProps({
+							get id() {
+								return id();
+							},
+							get ["class"]() {
+								return classValue();
+							},
+							get style() {
+								return styleValue();
+							},
+							get hidden() {
+								return hiddenValue();
+							},
+							role: "region",
+							get ["aria-labelledby"]() {
+								return item.triggerId();
+							}
+						}, stateAttributes, others);
+					}, void 0, true);
+				},
+				children: (component) => Dynamic(mergeProps({
+					get component() {
+						return component();
+					},
+					ref: [internalProps.ref, ((element) => setPanelElement(element))],
+					get id() {
+						return id();
+					},
+					get ["class"]() {
+						return classValue();
+					},
+					get style() {
+						return styleValue();
+					},
+					get hidden() {
+						return hiddenValue();
+					},
+					role: "region",
+					get ["aria-labelledby"]() {
+						return item.triggerId();
+					}
+				}, stateAttributes, others))
+			});
+		}
+	});
+}
+function resolvePanelStyle(dimensions, externalStyle, preventOpenAnimation) {
+	const height = dimensions.height === void 0 ? "auto" : `${dimensions.height}px`;
+	const width = dimensions.width === void 0 ? "auto" : `${dimensions.width}px`;
+	if (typeof externalStyle === "string") return [
+		`${AccordionPanelCssVars.accordionPanelHeight}:${height}`,
+		`${AccordionPanelCssVars.accordionPanelWidth}:${width}`,
+		externalStyle,
+		preventOpenAnimation ? "animation-name:none" : ""
+	].filter(Boolean).join(";");
+	return {
+		[AccordionPanelCssVars.accordionPanelHeight]: height,
+		[AccordionPanelCssVars.accordionPanelWidth]: width,
+		...externalStyle,
+		...preventOpenAnimation ? { "animation-name": "none" } : {}
+	};
+}
+//#endregion
+//#region src/accordion/index.parts.ts
+var index_parts_exports = /* @__PURE__ */ __exportAll({
+	Header: () => AccordionHeader,
+	Item: () => AccordionItem,
+	Panel: () => AccordionPanel,
+	Root: () => AccordionRoot,
+	Trigger: () => AccordionTrigger
+});
+//#endregion
+export { index_parts_exports as Accordion };

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

@@ -0,0 +1,36 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.js";
+import { a as DialogTitle, c as DialogDescription, i as DialogTrigger, l as DialogClose, m as renderDialogRoot, o as DialogPortal, r as DialogViewport, t as DialogHandle } from "../DialogHandle-ATZlm9RC.js";
+import { n as DialogBackdrop, t as DialogPopup } from "../DialogPopup-BebI-w5P.js";
+//#region src/alert-dialog/root/AlertDialogRoot.tsx
+/** Groups all parts of the alert dialog without rendering an element. */
+function AlertDialogRoot(props) {
+	return renderDialogRoot("alert-dialog", props);
+}
+//#endregion
+//#region src/alert-dialog/trigger/AlertDialogTrigger.tsx
+/** A button that opens the alert dialog. */
+var AlertDialogTrigger = DialogTrigger;
+//#endregion
+//#region src/alert-dialog/handle.ts
+/** Imperatively controls an Alert Dialog and connects detached triggers to its Root. */
+var AlertDialogHandle = class extends DialogHandle {};
+function createAlertDialogHandle() {
+	return new AlertDialogHandle();
+}
+//#endregion
+//#region src/alert-dialog/index.parts.ts
+var index_parts_exports = /* @__PURE__ */ __exportAll({
+	Backdrop: () => DialogBackdrop,
+	Close: () => DialogClose,
+	Description: () => DialogDescription,
+	Handle: () => AlertDialogHandle,
+	Popup: () => DialogPopup,
+	Portal: () => DialogPortal,
+	Root: () => AlertDialogRoot,
+	Title: () => DialogTitle,
+	Trigger: () => AlertDialogTrigger,
+	Viewport: () => DialogViewport,
+	createHandle: () => createAlertDialogHandle
+});
+//#endregion
+export { index_parts_exports as AlertDialog };