@monimesl/dot-renderer-react 0.1.0-alpha.10

package/dist/vendor/@base-ui/react/radio/indicator/RadioIndicator.js

@@ -0,0 +1,46 @@
+"use client";
+import { useRenderElement } from "../../internals/useRenderElement.js";
+import { useTransitionStatus } from "../../internals/useTransitionStatus.js";
+import { useOpenChangeComplete } from "../../internals/useOpenChangeComplete.js";
+import { stateAttributesMapping } from "../utils/stateAttributesMapping.js";
+import { useRadioRootContext } from "../root/RadioRootContext.js";
+import * as React from "react";
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/radio/indicator/RadioIndicator.mjs
+/**
+* Indicates whether the radio button is selected.
+* Renders a `<span>` element.
+*
+* Documentation: [Base UI Radio](https://base-ui.com/react/components/radio)
+*/
+const RadioIndicator = /*#__PURE__*/ React.forwardRef(function RadioIndicator(componentProps, forwardedRef) {
+	const { render, className, style, keepMounted = false, ...elementProps } = componentProps;
+	const rootState = useRadioRootContext();
+	const rendered = rootState.checked;
+	const { mounted, transitionStatus, setMounted } = useTransitionStatus(rendered);
+	const state = {
+		...rootState,
+		transitionStatus
+	};
+	const indicatorRef = React.useRef(null);
+	const shouldRender = keepMounted || mounted;
+	const element = useRenderElement("span", componentProps, {
+		ref: [forwardedRef, indicatorRef],
+		state,
+		props: elementProps,
+		stateAttributesMapping
+	});
+	useOpenChangeComplete({
+		batch: true,
+		enabled: !rendered,
+		open: rendered,
+		ref: indicatorRef,
+		onComplete() {
+			if (!rendered) setMounted(false);
+		}
+	});
+	if (!shouldRender) return null;
+	return element;
+});
+if (process.env.NODE_ENV !== "production") RadioIndicator.displayName = "RadioIndicator";
+//#endregion
+export { RadioIndicator };

package/dist/vendor/@base-ui/react/radio/root/RadioRoot.js

@@ -0,0 +1,179 @@
+"use client";
+import { useMergedRefs } from "../../../utils/useMergedRefs.js";
+import { EMPTY_OBJECT, NOOP } from "../../../utils/empty.js";
+import { useRenderElement } from "../../internals/useRenderElement.js";
+import { useIsoLayoutEffect } from "../../../utils/useIsoLayoutEffect.js";
+import { dispatchClickWithModifiers } from "../../utils/dispatchClickWithModifiers.js";
+import { useButton } from "../../internals/use-button/useButton.js";
+import { none } from "../../internals/reason-parts.js";
+import { createChangeEventDetails } from "../../internals/createBaseUIEventDetails.js";
+import { useBaseUiId } from "../../internals/useBaseUiId.js";
+import { visuallyHidden, visuallyHiddenInput } from "../../../utils/visuallyHidden.js";
+import { ACTIVE_COMPOSITE_ITEM } from "../../internals/composite/constants.js";
+import { useFieldRootContext } from "../../internals/field-root-context/FieldRootContext.js";
+import { useFieldItemContext } from "../../field/item/FieldItemContext.js";
+import { useLabelableContext } from "../../internals/labelable-provider/LabelableContext.js";
+import { useAriaLabelledBy } from "../../internals/labelable-provider/useAriaLabelledBy.js";
+import { useLabelableId } from "../../internals/labelable-provider/useLabelableId.js";
+import { stateAttributesMapping } from "../utils/stateAttributesMapping.js";
+import { CompositeItem } from "../../internals/composite/item/CompositeItem.js";
+import { useRadioGroupContext } from "../../radio-group/RadioGroupContext.js";
+import { serializeValue } from "../../internals/serializeValue.js";
+import { RadioRootContext } from "./RadioRootContext.js";
+import * as React from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/radio/root/RadioRoot.mjs
+/**
+* Represents the radio button itself.
+* Renders a `<span>` element and a hidden `<input>` beside.
+*
+* Documentation: [Base UI Radio](https://base-ui.com/react/components/radio)
+*/
+const RadioRoot = /*#__PURE__*/ React.forwardRef(function RadioRoot(componentProps, forwardedRef) {
+	const { render, className, disabled: disabledProp = false, readOnly: readOnlyProp = false, required: requiredProp = false, "aria-labelledby": ariaLabelledByProp, value, inputRef: inputRefProp, nativeButton = false, id: idProp, style, ...elementProps } = componentProps;
+	const groupContext = useRadioGroupContext();
+	const { disabled: disabledGroup, readOnly: readOnlyGroup, required: requiredGroup, form: formGroup, checkedValue, touched = false, validation, name, setCheckedValue = NOOP, setTouched = NOOP, registerInputRef = NOOP } = groupContext ?? {};
+	const { setTouched: setFieldTouched, setFilled, state: fieldState, disabled: fieldDisabled } = useFieldRootContext();
+	const fieldItemContext = useFieldItemContext();
+	const { labelId, getDescriptionProps } = useLabelableContext();
+	const disabled = fieldDisabled || fieldItemContext.disabled || disabledGroup || disabledProp;
+	const readOnly = readOnlyGroup || readOnlyProp;
+	const required = requiredGroup || requiredProp;
+	const form = formGroup;
+	const checked = groupContext ? checkedValue === value : value === "";
+	const radioRef = React.useRef(null);
+	const inputRef = React.useRef(null);
+	const registerFieldInput = validation?.registerInput;
+	const registerInput = React.useCallback((element) => registerFieldInput?.(element, {
+		controlRef: radioRef,
+		value: void 0
+	}), [registerFieldInput]);
+	const mergedInputRef = useMergedRefs(inputRefProp, inputRef, registerInputRef, registerInput);
+	useIsoLayoutEffect(() => {
+		if (inputRef.current?.checked) setFilled(true);
+	}, [setFilled]);
+	useIsoLayoutEffect(() => {
+		if (!inputRef.current) return;
+		if (disabled && checked) {
+			registerInputRef(null);
+			return;
+		}
+		registerInputRef(inputRef.current);
+	}, [
+		checked,
+		disabled,
+		registerInputRef
+	]);
+	const id = useBaseUiId();
+	const inputId = useLabelableId({ id: idProp });
+	const hiddenInputId = nativeButton ? void 0 : inputId;
+	const rootProps = {
+		role: "radio",
+		"aria-checked": checked,
+		"aria-labelledby": useAriaLabelledBy(ariaLabelledByProp, labelId, inputRef, !nativeButton, hiddenInputId),
+		[ACTIVE_COMPOSITE_ITEM]: checked ? "" : void 0,
+		id: nativeButton ? inputId : id,
+		onKeyDown(event) {
+			if (event.key === "Enter") event.preventDefault();
+		},
+		onClick(event) {
+			if (event.defaultPrevented || disabled || readOnly) return;
+			event.preventDefault();
+			const input = inputRef.current;
+			if (!input) return;
+			dispatchClickWithModifiers(input, event);
+		},
+		onFocus(event) {
+			if (event.defaultPrevented || disabled || readOnly || !touched) return;
+			inputRef.current?.click();
+			setTouched(false);
+		}
+	};
+	const { getButtonProps, buttonRef } = useButton({
+		disabled,
+		native: nativeButton,
+		composite: false
+	});
+	const inputProps = {
+		type: "radio",
+		ref: mergedInputRef,
+		form,
+		id: hiddenInputId,
+		name,
+		tabIndex: -1,
+		style: name ? visuallyHiddenInput : visuallyHidden,
+		"aria-hidden": true,
+		...value !== void 0 ? { value: serializeValue(value) } : EMPTY_OBJECT,
+		disabled,
+		checked,
+		required,
+		readOnly,
+		onChange(event) {
+			if (event.nativeEvent.defaultPrevented) return;
+			if (disabled || readOnly || value === void 0) return;
+			const details = createChangeEventDetails(none, event.nativeEvent);
+			setCheckedValue(value, details);
+			if (details.isCanceled) return;
+			setFieldTouched(true);
+		},
+		onClick(event) {
+			event.stopPropagation();
+		},
+		onFocus() {
+			radioRef.current?.focus();
+		}
+	};
+	const state = React.useMemo(() => ({
+		...fieldState,
+		required,
+		disabled,
+		readOnly,
+		checked
+	}), [
+		fieldState,
+		disabled,
+		readOnly,
+		checked,
+		required
+	]);
+	const contextValue = state;
+	const isRadioGroup = groupContext !== void 0;
+	const refs = [
+		forwardedRef,
+		radioRef,
+		buttonRef
+	];
+	const props = [
+		rootProps,
+		elementProps,
+		getButtonProps,
+		getDescriptionProps,
+		validation ? (validationProps) => validation.getValidationProps(disabled, validationProps) : EMPTY_OBJECT
+	];
+	const element = useRenderElement("span", componentProps, {
+		enabled: !isRadioGroup,
+		state,
+		ref: refs,
+		props,
+		stateAttributesMapping
+	});
+	return /*#__PURE__*/ jsxs(RadioRootContext.Provider, {
+		value: contextValue,
+		children: [isRadioGroup ? /*#__PURE__*/ jsx(CompositeItem, {
+			tag: "span",
+			render,
+			className,
+			style,
+			state,
+			refs,
+			props,
+			stateAttributesMapping
+		}) : element, /*#__PURE__*/ jsx("input", {
+			...inputProps,
+			suppressHydrationWarning: true
+		})]
+	});
+});
+if (process.env.NODE_ENV !== "production") RadioRoot.displayName = "RadioRoot";
+//#endregion
+export { RadioRoot };

package/dist/vendor/@base-ui/react/radio/root/RadioRootContext.js

@@ -0,0 +1,13 @@
+"use client";
+import formatErrorMessage from "../../../utils/formatErrorMessage.js";
+import * as React from "react";
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/radio/root/RadioRootContext.mjs
+const RadioRootContext = /*#__PURE__*/ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") RadioRootContext.displayName = "RadioRootContext";
+function useRadioRootContext() {
+	const value = React.useContext(RadioRootContext);
+	if (value === void 0) throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: RadioRootContext is missing. Radio parts must be placed within <Radio.Root>." : formatErrorMessage(52));
+	return value;
+}
+//#endregion
+export { RadioRootContext, useRadioRootContext };

package/dist/vendor/@base-ui/react/radio/root/RadioRootDataAttributes.js

@@ -0,0 +1,11 @@
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/radio/root/RadioRootDataAttributes.mjs
+/**
+* Present when the radio is checked.
+*/
+const checked = "data-checked";
+/**
+* Present when the radio is not checked.
+*/
+const unchecked = "data-unchecked";
+//#endregion
+export { checked, unchecked };

package/dist/vendor/@base-ui/react/radio/utils/stateAttributesMapping.js

@@ -0,0 +1,14 @@
+import { transitionStatusMapping } from "../../internals/stateAttributesMapping.js";
+import { fieldValidityMapping } from "../../internals/field-constants/constants.js";
+import { checked, unchecked } from "../root/RadioRootDataAttributes.js";
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/radio/utils/stateAttributesMapping.mjs
+const stateAttributesMapping = {
+	checked(value) {
+		if (value) return { [checked]: "" };
+		return { [unchecked]: "" };
+	},
+	...transitionStatusMapping,
+	...fieldValidityMapping
+};
+//#endregion
+export { stateAttributesMapping };

package/dist/vendor/@base-ui/react/radio-group/RadioGroup.js

@@ -0,0 +1,170 @@
+"use client";
+import { useStableCallback } from "../../utils/useStableCallback.js";
+import { useBaseUiId } from "../internals/useBaseUiId.js";
+import { contains } from "../../utils/shadowDom.js";
+import { SHIFT } from "../internals/composite/composite.js";
+import { useValueChanged } from "../internals/useValueChanged.js";
+import { useControlled } from "../../utils/useControlled.js";
+import { CompositeRoot } from "../internals/composite/root/CompositeRoot.js";
+import { fieldValidityMapping } from "../internals/field-constants/constants.js";
+import { useFieldRootContext } from "../internals/field-root-context/FieldRootContext.js";
+import { useRegisterFieldControl } from "../internals/field-register-control/useRegisterFieldControl.js";
+import { useFormContext } from "../internals/form-context/FormContext.js";
+import { useLabelableContext } from "../internals/labelable-provider/LabelableContext.js";
+import { RadioGroupContext } from "./RadioGroupContext.js";
+import { isEligibleInput } from "../field/root/useFieldValidation.js";
+import { useFieldsetRootContext } from "../fieldset/root/FieldsetRootContext.js";
+import * as React from "react";
+import { jsx } from "react/jsx-runtime";
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/radio-group/RadioGroup.mjs
+const MODIFIER_KEYS = [SHIFT];
+/**
+* Provides a shared state to a series of radio buttons.
+* Renders a `<div>` element.
+*
+* Documentation: [Base UI Radio Group](https://base-ui.com/react/components/radio)
+*/
+const RadioGroup = /*#__PURE__*/ React.forwardRef(function RadioGroup(componentProps, forwardedRef) {
+	const { render, className, disabled: disabledProp, readOnly, required, onValueChange: onValueChangeProp, value: externalValue, defaultValue, form, name: nameProp, inputRef: inputRefProp, id: idProp, style, ...elementProps } = componentProps;
+	const { setTouched: setFieldTouched, setFocused, validationMode, name: fieldName, disabled: fieldDisabled, state: fieldState, validation, setDirty, setFilled, validityData } = useFieldRootContext();
+	const { labelId } = useLabelableContext();
+	const { clearErrors, elementRef } = useFormContext();
+	const fieldsetContext = useFieldsetRootContext(true);
+	const disabled = fieldDisabled || disabledProp;
+	const name = fieldName ?? nameProp;
+	const id = useBaseUiId(idProp);
+	const [checkedValue, setCheckedValueUnwrapped] = useControlled({
+		controlled: externalValue,
+		default: defaultValue,
+		name: "RadioGroup",
+		state: "value"
+	});
+	const [touched, setTouched] = React.useState(false);
+	const setCheckedValue = useStableCallback((value, eventDetails) => {
+		onValueChangeProp?.(value, eventDetails);
+		if (eventDetails.isCanceled) return;
+		setCheckedValueUnwrapped(value);
+	});
+	const getInputControl = validation.getInputControl;
+	const controlRef = React.useMemo(() => ({ get current() {
+		return getInputControl();
+	} }), [getInputControl]);
+	const groupInputRef = React.useRef(null);
+	const firstEnabledInputRef = React.useRef(null);
+	function setInputRef(hiddenInput) {
+		let cleanup = void 0;
+		if (inputRefProp) {
+			if (typeof inputRefProp === "function") cleanup = inputRefProp(hiddenInput);
+			else inputRefProp.current = hiddenInput;
+		}
+		groupInputRef.current = hiddenInput;
+		return cleanup;
+	}
+	const registerInputRef = useStableCallback((input) => {
+		if (!input || input.disabled) return;
+		if (!firstEnabledInputRef.current) firstEnabledInputRef.current = input;
+		const currentInput = groupInputRef.current;
+		const cleanup = input.checked || currentInput == null || currentInput.disabled ? setInputRef(input) : void 0;
+		return () => {
+			if (firstEnabledInputRef.current === input) firstEnabledInputRef.current = null;
+			if (groupInputRef.current === input) {
+				if (cleanup) {
+					cleanup();
+					groupInputRef.current = null;
+				} else setInputRef(null);
+			} else cleanup?.();
+		};
+	});
+	const getFormValue = useStableCallback(() => {
+		const formElement = elementRef.current;
+		if (!formElement) return checkedValue ?? null;
+		for (const input of validation.registeredInputs.keys()) if (input.checked && isEligibleInput(input, formElement)) return checkedValue ?? null;
+		return null;
+	});
+	useRegisterFieldControl(controlRef, id, checkedValue ?? null, getFormValue, !disabled, nameProp);
+	useValueChanged(checkedValue, () => {
+		clearErrors(name);
+		setDirty(checkedValue !== validityData.initialValue);
+		setFilled(checkedValue != null);
+		validation.change(checkedValue);
+		const fallbackInput = firstEnabledInputRef.current;
+		if (checkedValue == null && fallbackInput && !fallbackInput.disabled) setInputRef(fallbackInput);
+	});
+	const ariaLabelledby = labelId ?? fieldsetContext?.legendId;
+	const state = {
+		...fieldState,
+		disabled: disabled ?? false,
+		required: required ?? false,
+		readOnly: readOnly ?? false
+	};
+	const contextValue = React.useMemo(() => ({
+		checkedValue,
+		disabled,
+		form,
+		validation,
+		name,
+		readOnly,
+		registerInputRef,
+		required,
+		setCheckedValue,
+		setTouched,
+		touched
+	}), [
+		checkedValue,
+		disabled,
+		form,
+		validation,
+		name,
+		readOnly,
+		registerInputRef,
+		required,
+		setCheckedValue,
+		setTouched,
+		touched
+	]);
+	const defaultProps = {
+		id: idProp,
+		role: "radiogroup",
+		"aria-required": required || void 0,
+		"aria-disabled": disabled || void 0,
+		"aria-readonly": readOnly || void 0,
+		"aria-labelledby": ariaLabelledby,
+		onFocus() {
+			setFocused(true);
+		},
+		onBlur(event) {
+			if (!contains(event.currentTarget, event.relatedTarget)) {
+				setFieldTouched(true);
+				setFocused(false);
+				if (validationMode === "onBlur") validation.commit(checkedValue);
+			}
+		},
+		onKeyDownCapture(event) {
+			if (event.key.startsWith("Arrow")) {
+				setTouched(true);
+				setFocused(true);
+			}
+		}
+	};
+	return /*#__PURE__*/ jsx(RadioGroupContext.Provider, {
+		value: contextValue,
+		children: /*#__PURE__*/ jsx(CompositeRoot, {
+			render,
+			className,
+			style,
+			state,
+			props: [
+				defaultProps,
+				elementProps,
+				(props) => validation.getValidationProps(disabled ?? false, props)
+			],
+			refs: [forwardedRef],
+			stateAttributesMapping: fieldValidityMapping,
+			enableHomeAndEndKeys: false,
+			modifierKeys: MODIFIER_KEYS
+		})
+	});
+});
+if (process.env.NODE_ENV !== "production") RadioGroup.displayName = "RadioGroup";
+//#endregion
+export { RadioGroup };

package/dist/vendor/@base-ui/react/radio-group/RadioGroupContext.js

@@ -0,0 +1,10 @@
+"use client";
+import * as React from "react";
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/radio-group/RadioGroupContext.mjs
+const RadioGroupContext = /*#__PURE__*/ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") RadioGroupContext.displayName = "RadioGroupContext";
+function useRadioGroupContext() {
+	return React.useContext(RadioGroupContext);
+}
+//#endregion
+export { RadioGroupContext, useRadioGroupContext };

package/dist/vendor/@base-ui/react/switch/root/SwitchRoot.js

@@ -0,0 +1,170 @@
+"use client";
+import { useMergedRefs } from "../../../utils/useMergedRefs.js";
+import { EMPTY_OBJECT } from "../../../utils/empty.js";
+import { useRenderElement } from "../../internals/useRenderElement.js";
+import { useIsoLayoutEffect } from "../../../utils/useIsoLayoutEffect.js";
+import { dispatchClickWithModifiers } from "../../utils/dispatchClickWithModifiers.js";
+import { useButton } from "../../internals/use-button/useButton.js";
+import { none } from "../../internals/reason-parts.js";
+import { createChangeEventDetails } from "../../internals/createBaseUIEventDetails.js";
+import { useBaseUiId } from "../../internals/useBaseUiId.js";
+import { visuallyHidden, visuallyHiddenInput } from "../../../utils/visuallyHidden.js";
+import { useValueChanged } from "../../internals/useValueChanged.js";
+import { useControlled } from "../../../utils/useControlled.js";
+import { useFieldRootContext } from "../../internals/field-root-context/FieldRootContext.js";
+import { useRegisterFieldControl } from "../../internals/field-register-control/useRegisterFieldControl.js";
+import { useFormContext } from "../../internals/form-context/FormContext.js";
+import { useLabelableContext } from "../../internals/labelable-provider/LabelableContext.js";
+import { useAriaLabelledBy } from "../../internals/labelable-provider/useAriaLabelledBy.js";
+import { useLabelableId } from "../../internals/labelable-provider/useLabelableId.js";
+import { SwitchRootContext } from "./SwitchRootContext.js";
+import { stateAttributesMapping } from "../stateAttributesMapping.js";
+import * as React from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/switch/root/SwitchRoot.mjs
+/**
+* Represents the switch itself.
+* Renders a `<span>` element and a hidden `<input>` beside.
+*
+* Documentation: [Base UI Switch](https://base-ui.com/react/components/switch)
+*/
+const SwitchRoot = /*#__PURE__*/ React.forwardRef(function SwitchRoot(componentProps, forwardedRef) {
+	const { checked: checkedProp, className, defaultChecked, "aria-labelledby": ariaLabelledByProp, form, id: idProp, inputRef: externalInputRef, name: nameProp, nativeButton = false, onCheckedChange, readOnly = false, required = false, disabled: disabledProp = false, render, uncheckedValue, value, style, ...elementProps } = componentProps;
+	const { clearErrors } = useFormContext();
+	const { state: fieldState, setTouched, setDirty, validityData, setFilled, setFocused, validationMode, disabled: fieldDisabled, name: fieldName, validation } = useFieldRootContext();
+	const { labelId } = useLabelableContext();
+	const disabled = fieldDisabled || disabledProp;
+	const name = fieldName ?? nameProp;
+	const inputRef = React.useRef(null);
+	const handleInputRef = useMergedRefs(inputRef, externalInputRef, validation.inputRef);
+	const switchRef = React.useRef(null);
+	const id = useBaseUiId();
+	const controlId = useLabelableId({ id: idProp });
+	const hiddenInputId = nativeButton ? void 0 : controlId;
+	const [checked, setCheckedState] = useControlled({
+		controlled: checkedProp,
+		default: Boolean(defaultChecked),
+		name: "Switch",
+		state: "checked"
+	});
+	useRegisterFieldControl(switchRef, id, checked, void 0, !disabled, nameProp);
+	useIsoLayoutEffect(() => {
+		setFilled(checked);
+	}, [checked, setFilled]);
+	useValueChanged(checked, () => {
+		clearErrors(name);
+		setDirty(checked !== validityData.initialValue);
+		validation.change(checked);
+	});
+	const { getButtonProps, buttonRef } = useButton({
+		disabled,
+		native: nativeButton
+	});
+	const ariaLabelledBy = useAriaLabelledBy(ariaLabelledByProp, labelId, inputRef, !nativeButton, hiddenInputId);
+	const rootProps = {
+		id: nativeButton ? controlId : id,
+		role: "switch",
+		"aria-checked": checked,
+		"aria-readonly": readOnly || void 0,
+		"aria-required": required || void 0,
+		"aria-labelledby": ariaLabelledBy,
+		onFocus() {
+			if (!disabled) setFocused(true);
+		},
+		onBlur() {
+			const element = inputRef.current;
+			if (!element || disabled) return;
+			setTouched(true);
+			setFocused(false);
+			if (validationMode === "onBlur") validation.commit(element.checked);
+		},
+		onClick(event) {
+			if (readOnly || disabled) return;
+			event.preventDefault();
+			const input = inputRef.current;
+			if (!input) return;
+			dispatchClickWithModifiers(input, event);
+		}
+	};
+	const inputProps = {
+		...validation.getValidationProps(disabled),
+		checked,
+		disabled,
+		form,
+		id: hiddenInputId,
+		name,
+		required,
+		style: name ? visuallyHiddenInput : visuallyHidden,
+		tabIndex: -1,
+		type: "checkbox",
+		"aria-hidden": true,
+		ref: handleInputRef,
+		onChange(event) {
+			if (event.nativeEvent.defaultPrevented) return;
+			if (readOnly) {
+				event.preventDefault();
+				return;
+			}
+			const nextChecked = event.currentTarget.checked;
+			const eventDetails = createChangeEventDetails(none, event.nativeEvent);
+			onCheckedChange?.(nextChecked, eventDetails);
+			if (eventDetails.isCanceled) return;
+			setCheckedState(nextChecked);
+		},
+		onClick(event) {
+			event.stopPropagation();
+		},
+		onFocus() {
+			switchRef.current?.focus();
+		},
+		...value !== void 0 ? { value } : EMPTY_OBJECT
+	};
+	const state = React.useMemo(() => ({
+		...fieldState,
+		checked,
+		disabled,
+		readOnly,
+		required
+	}), [
+		fieldState,
+		checked,
+		disabled,
+		readOnly,
+		required
+	]);
+	const element = useRenderElement("span", componentProps, {
+		state,
+		ref: [
+			forwardedRef,
+			switchRef,
+			buttonRef
+		],
+		props: [
+			rootProps,
+			elementProps,
+			getButtonProps,
+			(props) => validation.getValidationProps(disabled, props)
+		],
+		stateAttributesMapping
+	});
+	return /*#__PURE__*/ jsxs(SwitchRootContext.Provider, {
+		value: state,
+		children: [
+			element,
+			!checked && name && uncheckedValue !== void 0 && /*#__PURE__*/ jsx("input", {
+				type: "hidden",
+				form,
+				name,
+				value: uncheckedValue,
+				disabled
+			}),
+			/*#__PURE__*/ jsx("input", {
+				...inputProps,
+				suppressHydrationWarning: true
+			})
+		]
+	});
+});
+if (process.env.NODE_ENV !== "production") SwitchRoot.displayName = "SwitchRoot";
+//#endregion
+export { SwitchRoot };

package/dist/vendor/@base-ui/react/switch/root/SwitchRootContext.js

@@ -0,0 +1,13 @@
+"use client";
+import formatErrorMessage from "../../../utils/formatErrorMessage.js";
+import * as React from "react";
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/switch/root/SwitchRootContext.mjs
+const SwitchRootContext = /*#__PURE__*/ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") SwitchRootContext.displayName = "SwitchRootContext";
+function useSwitchRootContext() {
+	const context = React.useContext(SwitchRootContext);
+	if (context === void 0) throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: SwitchRootContext is missing. Switch parts must be placed within <Switch.Root>." : formatErrorMessage(63));
+	return context;
+}
+//#endregion
+export { SwitchRootContext, useSwitchRootContext };

package/dist/vendor/@base-ui/react/switch/root/SwitchRootDataAttributes.js

@@ -0,0 +1,11 @@
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/switch/root/SwitchRootDataAttributes.mjs
+/**
+* Present when the switch is checked.
+*/
+const checked = "data-checked";
+/**
+* Present when the switch is not checked.
+*/
+const unchecked = "data-unchecked";
+//#endregion
+export { checked, unchecked };

package/dist/vendor/@base-ui/react/switch/stateAttributesMapping.js

@@ -0,0 +1,12 @@
+import { fieldValidityMapping } from "../internals/field-constants/constants.js";
+import { checked, unchecked } from "./root/SwitchRootDataAttributes.js";
+//#region ../../../node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/switch/stateAttributesMapping.mjs
+const stateAttributesMapping = {
+	...fieldValidityMapping,
+	checked(value) {
+		if (value) return { [checked]: "" };
+		return { [unchecked]: "" };
+	}
+};
+//#endregion
+export { stateAttributesMapping };