@povio/ui 3.4.0-rc.4 → 3.4.0-rc.40

package/dist/TextInput-Dxq5XKdp.d.ts

@@ -0,0 +1,27 @@
+import { s as InputProps } from "./types-ZbFfCz06.js";
+import { n as FieldValues } from "./form.binding-QO3Py45C.js";
+import { t as ControlProps } from "./form.types-CefwT7Po.js";
+import { n as FormFieldProps } from "./FormField-Iy2O8A4g.js";
+import { n as InputVariantProps } from "./input.cva-CfgCOIQW.js";
+import { t as InputContentProps } from "./InputContent-jcMfOzpN.js";
+import { Ref } from "react";
+import { AriaTextFieldProps } from "@react-aria/textfield";
+//#region src/components/inputs/Input/TextInput/TextInput.d.ts
+type AllowedHTMLInputTypeAttribute = "email" | "hidden" | "tel" | "text" | "url";
+interface TextInputBaseProps extends FormFieldProps, InputVariantProps, Omit<InputContentProps, "ref" | "value" | "onChange" | "onBlur">, Omit<InputProps, "value" | "defaultValue" | "onChange" | "disabled" | "required" | "type" | "size" | "className" | keyof AriaTextFieldProps>, Omit<AriaTextFieldProps<HTMLInputElement>, "label"> {
+  ref?: Ref<HTMLInputElement>;
+  inputClassName?: string;
+  type?: AllowedHTMLInputTypeAttribute;
+  todayIcon?: boolean;
+  isDirty?: boolean;
+  autoFocusOnMount?: boolean;
+}
+interface TextInputProps extends TextInputBaseProps {
+  renderStaticInput?: boolean;
+}
+type ControlledTextInputProps<TFieldValues extends Record<string, unknown>> = ControlProps<TextInputProps, TFieldValues>;
+/** @internal Exported for production render benchmarks. */
+declare const TextInputComponent: <TFieldValues extends FieldValues>({ renderStaticInput, ...props }: ControlledTextInputProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+declare const TextInput: typeof TextInputComponent;
+//#endregion
+export { TextInputProps as i, TextInput as n, TextInputComponent as r, ControlledTextInputProps as t };

package/dist/TimePicker-B_atBC0F.d.ts

@@ -0,0 +1,32 @@
+import { d as AriaTimeFieldProps, v as TimeValue } from "./types-BT18i837.js";
+import { n as FieldValues } from "./form.binding-QO3Py45C.js";
+import { t as ControlProps } from "./form.types-CefwT7Po.js";
+import { n as FormFieldProps } from "./FormField-Iy2O8A4g.js";
+import { n as InputVariantProps } from "./input.cva-CfgCOIQW.js";
+import { FocusEvent, Ref } from "react";
+//#region src/components/inputs/DateTime/TimePicker/TimePicker.d.ts
+interface TimePickerBaseProps extends FormFieldProps, InputVariantProps, Omit<AriaTimeFieldProps<TimeValue>, "label" | "onBlur"> {
+  ref?: Ref<HTMLDivElement>;
+  disableDropdown?: boolean;
+  date?: string | null;
+  isClearable?: boolean;
+  isClearableIfDisabled?: boolean;
+  isDirty?: boolean;
+  disableManualEntry?: boolean;
+  placeholder?: string;
+  inputClassName?: string;
+  onBlur?: (e: FocusEvent<HTMLInputElement>) => void;
+  shouldForceLeadingZeros?: boolean;
+}
+interface TimePickerProps extends Omit<TimePickerBaseProps, "value" | "onChange"> {
+  value?: string | null;
+  onChange?: (value: string | null) => void;
+  fullIso?: boolean;
+  timeZone?: string;
+  renderStaticInput?: boolean;
+}
+type ControlledTimePickerProps<TFieldValues extends FieldValues> = ControlProps<TimePickerProps, TFieldValues>;
+declare const TimePickerComponent: <TFieldValues extends FieldValues>({ renderStaticInput, ...props }: ControlledTimePickerProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+declare const TimePicker: typeof TimePickerComponent;
+//#endregion
+export { TimePicker as n, TimePickerProps as r, ControlledTimePickerProps as t };

package/dist/TimePicker-D1ptdYlJ.js

@@ -0,0 +1,375 @@
+import { t as UIConfig } from "./uiConfig.context-BG4jfp9p.js";
+import { t as clsx } from "./clsx-CnD0nOiA.js";
+import { f as $5dc95899b306f630$export$c9058316764c140e } from "./utils-D-KKbY-n.js";
+import { a as getStaticTimeSegments, c as useFirefoxDateSegmentSelectionGuard, g as useTimeFieldState, i as getStaticDateTimeFocusTarget, l as DateSegmentItem, o as DateTimeDialogFooter, s as DateTimeDialog, y as $16f0b7bb276bc17e$export$4c842f6a241dc825 } from "./staticDateTimeSegments-Cefwvojy.js";
+import { n as $d2b4bc8c273e7be6$export$353f5b6fc5456de1 } from "./Button-D09S1dNt.js";
+import { t as $18f2051aff69b9bf$export$43bb16f9c6d9e3f7 } from "./context-74MZZLC0.js";
+import { t as UIOverrides } from "./uiOverrides.context-Bfm2n-n8.js";
+import { t as Typography } from "./Typography-AcUd9df8.js";
+import { InlineIconButton } from "./components/inline-icon-button.js";
+import { t as FieldController } from "./form.binding-DyZ4fH8l.js";
+import { r as FormFieldLabel, t as FormField } from "./FormField-Cl-t5Wi1.js";
+import { n as InputClear, t as TooltipWrapper } from "./TooltipWrapper-CoRIizbz.js";
+import { a as inputSizeDefinition, t as inputBaseDefinition } from "./input.cva-KYGD4Bdz.js";
+import { n as InputFrame, t as useStaticInputHandoff } from "./useStaticInputHandoff-9V4kd391.js";
+import { n as TimePickerForm, t as normalizeDatePickerValue } from "./datePickerValue.utils-DtR1CyuD.js";
+import { t as DateTimeUtils } from "./date-time.utils-0F9qduim.js";
+import { memo, useEffect, useRef, useState } from "react";
+import { getLocalTimeZone, now, toTime } from "@internationalized/date";
+import { useFocusVisible, useFocusWithin, useHover } from "@react-aria/interactions";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/components/inputs/DateTime/shared/TimeField.tsx
+const TimeField = ({ ref, fieldProps, state, isDisabled, hidePlaceholder }) => {
+	return /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsx("div", {
+		...fieldProps,
+		ref,
+		className: "flex",
+		children: state.segments.map((segment, i) => /* @__PURE__ */ jsx(DateSegmentItem, {
+			segment,
+			state,
+			isDisabled,
+			timePickerOnly: true,
+			hidePlaceholder
+		}, i))
+	}) });
+};
+//#endregion
+//#region src/components/inputs/DateTime/shared/TimePickerInput.tsx
+const TimePickerInput = ({ ref, as, fieldProps, state, isDisabled, isDirty, isRequired, isInvalid, disableDropdown, variant, size, isClearable, isClearableIfDisabled, headerProps, disableManualEntry, placeholder, className, onPress, onClear, ...props }) => {
+	const uiConfig = UIConfig.useConfig();
+	const inputBaseCva = UIOverrides.useCva("input.baseCva", inputBaseDefinition);
+	const inputSizeCva = UIOverrides.useCva("input.sizeCva", inputSizeDefinition);
+	const { hoverProps, isHovered } = useHover({ isDisabled });
+	const [isFocused, setIsFocused] = useState(false);
+	const { focusWithinProps } = useFocusWithin({ onFocusWithinChange: setIsFocused });
+	const { isFocusVisible } = useFocusVisible();
+	const containerRef = useRef(null);
+	useFirefoxDateSegmentSelectionGuard(containerRef);
+	const hidePlaceholder = as === "floating" && !state.value && !isFocused;
+	const canClear = state.segments.some((segment) => segment.type !== "literal" && segment.isPlaceholder === false);
+	return /* @__PURE__ */ jsxs("div", {
+		ref: $5dc95899b306f630$export$c9058316764c140e(ref, containerRef),
+		className: clsx(inputBaseCva({
+			variant,
+			as,
+			...props
+		}), "group/date-picker-content relative min-w-input-width-min-width", "flex items-center justify-between gap-input-gap-input-text-to-elements", className),
+		"data-rac": "",
+		"data-datetime-input": "",
+		"data-hovered": isHovered || void 0,
+		"data-disabled": isDisabled || void 0,
+		"data-is-disabled": isDisabled || void 0,
+		"data-invalid": isInvalid || void 0,
+		"data-is-empty": state.value === null || void 0,
+		"data-focus-within": isFocused || void 0,
+		"data-focus-visible": isFocused && isFocusVisible || void 0,
+		"data-has-selection": state.value !== null || void 0,
+		"data-is-dirty": isDirty || void 0,
+		"data-is-required": isRequired || void 0,
+		"data-is-filled": state.value !== null || void 0,
+		...fieldProps,
+		...focusWithinProps,
+		...hoverProps,
+		children: [/* @__PURE__ */ jsxs("div", {
+			className: clsx(inputSizeCva({
+				size,
+				as
+			}), "flex w-full items-center gap-input-gap-input-text-to-elements pr-0!"),
+			children: [
+				disableManualEntry && /* @__PURE__ */ jsx($d2b4bc8c273e7be6$export$353f5b6fc5456de1, {
+					onPress,
+					className: "absolute inset-0 z-base"
+				}),
+				as && ["filter", "floating"].includes(as) && headerProps && /* @__PURE__ */ jsx(FormFieldLabel, {
+					as,
+					...headerProps
+				}),
+				/* @__PURE__ */ jsx("div", { children: disableManualEntry && placeholder && !state.value ? /* @__PURE__ */ jsx(Typography, {
+					size: "label-1",
+					className: "text-text-default-3",
+					children: placeholder
+				}) : /* @__PURE__ */ jsx(TimeField, {
+					fieldProps,
+					state,
+					isDisabled,
+					hidePlaceholder
+				}) })
+			]
+		}), /* @__PURE__ */ jsxs("div", {
+			className: clsx(inputSizeCva({
+				size,
+				as
+			}), "flex items-center gap-input-gap-trailing-elements py-0! pl-0!"),
+			children: [isClearable && /* @__PURE__ */ jsx(InputClear, {
+				onClear: () => {
+					if (onClear) onClear();
+					else state.setValue(null);
+				},
+				show: canClear && (!isDisabled || isClearableIfDisabled === true)
+			}), (!disableDropdown || disableManualEntry) && /* @__PURE__ */ jsx(InlineIconButton, {
+				label: "",
+				color: "secondary",
+				onPress,
+				icon: uiConfig.dateInput.timeIcon,
+				isDisabled,
+				className: "border-0!",
+				"data-static-press-action": ""
+			})]
+		})]
+	});
+};
+//#endregion
+//#region src/components/inputs/DateTime/TimePicker/TimePicker.tsx
+const TimePickerBase = (props) => {
+	const ui = UIConfig.useConfig();
+	const { ref, label, tooltipText, helperText, isRequired, rightContent, isDisabled, isDirty, headerClassName, errorClassName, isHeaderHidden, error, onChange, onBlur, value, disableDropdown, placeholder, className, inputClassName, variant: variantProp, as: asProp, size: sizeProp, hideLabel: hideLabelProp, isClearable: isClearableProp, isClearableIfDisabled, disableManualEntry: disableManualEntryProp, shouldForceLeadingZeros: shouldForceLeadingZerosProp, ...rest } = props;
+	const variant = variantProp ?? ui.input.variant;
+	const as = asProp ?? ui.input.as;
+	const size = sizeProp ?? ui.input.size;
+	const hideLabel = hideLabelProp ?? ui.input.hideLabel;
+	const isClearable = isClearableProp ?? ui.input.isClearable;
+	const disableManualEntry = disableManualEntryProp ?? ui.dateInput.disableManualEntry;
+	const shouldForceLeadingZeros = shouldForceLeadingZerosProp ?? ui.dateInput.shouldForceLeadingZeros;
+	const formFieldProps = {
+		error,
+		label,
+		tooltipText,
+		helperText,
+		isRequired,
+		rightContent,
+		isHeaderHidden: isHeaderHidden || as === "inline" || as === "filter" || as === "floating",
+		hideLabel,
+		isDisabled,
+		headerClassName,
+		errorClassName
+	};
+	const [isOpen, setIsOpen] = useState(false);
+	const initialDateEmitRef = useRef(true);
+	const { locale } = $18f2051aff69b9bf$export$43bb16f9c6d9e3f7();
+	const normalizedValue = value ?? null;
+	const dialogState = useTimeFieldState({
+		...rest,
+		defaultValue: normalizedValue ?? rest.defaultValue ?? null,
+		locale,
+		shouldForceLeadingZeros
+	});
+	const handleBlur = (val) => {
+		onBlur?.({ target: { value: val } });
+	};
+	const state = useTimeFieldState({
+		...rest,
+		isDisabled,
+		value: normalizedValue,
+		onChange: (val) => {
+			onChange?.(normalizeDatePickerValue(val));
+		},
+		locale,
+		shouldForceLeadingZeros
+	});
+	useEffect(() => {
+		if (initialDateEmitRef.current) {
+			initialDateEmitRef.current = false;
+			return;
+		}
+		if (state.timeValue) onChange?.(state.timeValue);
+	}, [rest.date]);
+	const timeFieldRef = useRef(null);
+	const { labelProps, fieldProps } = $16f0b7bb276bc17e$export$4c842f6a241dc825({
+		...rest,
+		label,
+		isReadOnly: disableManualEntry,
+		shouldForceLeadingZeros
+	}, state, timeFieldRef);
+	const headerProps = {
+		label,
+		tooltipText,
+		helperText,
+		isRequired,
+		rightContent,
+		isHeaderHidden: hideLabel || isHeaderHidden,
+		isDisabled,
+		className: headerClassName,
+		labelProps
+	};
+	const onApply = () => {
+		const newValue = dialogState.value;
+		state.setValue(newValue);
+		setIsOpen(false);
+	};
+	const onOpenChange = (open) => {
+		setIsOpen(open);
+		if (!isOpen) dialogState.setValue(state.value);
+	};
+	const onOpen = () => {
+		dialogState.setValue(state.value);
+		setIsOpen(true);
+	};
+	const onInputClear = () => {
+		onChange?.(null);
+	};
+	return /* @__PURE__ */ jsx(TooltipWrapper, {
+		as,
+		error,
+		triggerTabIndex: as === "inline" ? -1 : void 0,
+		children: /* @__PURE__ */ jsxs(FormField, {
+			...formFieldProps,
+			as,
+			labelProps,
+			className: clsx("group relative inline-flex w-full flex-col text-left", className),
+			tabIndex: as === "inline" ? -1 : void 0,
+			children: [/* @__PURE__ */ jsx(TimePickerInput, {
+				ref: $5dc95899b306f630$export$c9058316764c140e(ref, timeFieldRef),
+				as,
+				fieldProps: {
+					...fieldProps,
+					onBlur: (event) => {
+						fieldProps.onBlur?.(event);
+						handleBlur(state.value);
+					}
+				},
+				state,
+				onPress: onOpen,
+				isDisabled,
+				isDirty,
+				isRequired,
+				isInvalid: !!error,
+				disableDropdown,
+				variant,
+				size,
+				isClearable,
+				isClearableIfDisabled,
+				headerProps,
+				disableManualEntry,
+				placeholder,
+				className: inputClassName,
+				onClear: onInputClear
+			}), (!disableDropdown || disableManualEntry) && /* @__PURE__ */ jsx(DateTimeDialog, {
+				footer: /* @__PURE__ */ jsx(DateTimeDialogFooter, {
+					isDisabled,
+					onApply,
+					isValid: !dialogState.isInvalid && !!dialogState.value
+				}),
+				label,
+				triggerRef: timeFieldRef,
+				isOpen,
+				onOpenChange,
+				children: /* @__PURE__ */ jsx(TimePickerForm, { state: dialogState })
+			})]
+		})
+	});
+};
+const TimePickerInner = ({ renderStaticInput, isFormControlDisabled, ...props }) => {
+	const ui = UIConfig.useConfig();
+	const timeZone = props.timeZone ?? ui.dateInput.timeZone;
+	let effectiveTimeZone = getLocalTimeZone();
+	if (timeZone !== "clientLocal") effectiveTimeZone = timeZone;
+	const { locale } = $18f2051aff69b9bf$export$43bb16f9c6d9e3f7();
+	const [renderInput, setRenderInput] = useState(!(renderStaticInput ?? ui.renderStaticInput));
+	const inputRef = useRef(null);
+	const { renderRealInput, replayStaticInputPress } = useStaticInputHandoff({
+		inputRef,
+		renderInput,
+		setRenderInput,
+		getFocusTarget: (input, staticTarget) => getStaticDateTimeFocusTarget(input, staticTarget),
+		getPressTarget: (input) => input.querySelector("[data-static-press-action]")
+	});
+	const normalizedValue = props.value ?? null;
+	const formatTimeValue = (timeValue) => {
+		if (timeValue === null) return null;
+		let parsedDate;
+		if (props.date) parsedDate = new Date(props.date);
+		let dateValue = now(effectiveTimeZone);
+		if (parsedDate) dateValue = DateTimeUtils.fromLocalToZonedDateTime(parsedDate, effectiveTimeZone);
+		const dateTimeValue = dateValue.set(timeValue);
+		return DateTimeUtils.fromDateValueToISO(dateTimeValue, effectiveTimeZone);
+	};
+	const parseTimeValue = (isoString) => {
+		if (isoString == null) return null;
+		const zonedDateTime = DateTimeUtils.fromISOtoZonedDateTime(isoString, effectiveTimeZone);
+		return toTime(zonedDateTime);
+	};
+	if (!renderInput) {
+		const timeValue = normalizedValue ? parseTimeValue(normalizedValue) : null;
+		const as = props.as ?? ui.input.as;
+		const isDisabled = isFormControlDisabled || !!props.isDisabled;
+		const disableManualEntry = props.disableManualEntry ?? ui.dateInput.disableManualEntry;
+		const shouldForceLeadingZeros = props.shouldForceLeadingZeros ?? ui.dateInput.shouldForceLeadingZeros;
+		const showDropdown = !props.disableDropdown || disableManualEntry;
+		const staticSegments = getStaticTimeSegments({
+			value: timeValue,
+			locale,
+			shouldForceLeadingZeros,
+			isDisabled,
+			hidePlaceholder: as === "floating" && !timeValue,
+			disableManualEntry,
+			placeholder: props.placeholder
+		});
+		return /* @__PURE__ */ jsx(InputFrame, {
+			...props,
+			onClear: () => props.onChange?.(null),
+			isDisabled,
+			className: clsx("group relative inline-flex w-full flex-col text-left", props.className),
+			inputClassName: clsx("min-w-input-width-min-width", props.inputClassName),
+			contentClassName: "pr-0!",
+			contentGroup: "date-picker",
+			labelPlacement: "content-row",
+			dataAttributes: {
+				dataIsEmpty: timeValue == null,
+				dataIsFilled: timeValue != null,
+				dataIsDirty: props.isDirty,
+				dataIsRequired: props.isRequired,
+				dataIsDisabled: isDisabled,
+				dataDisabled: isDisabled,
+				dataInvalid: !!props.error,
+				dataHasSelection: timeValue != null
+			},
+			onStaticInteract: renderRealInput,
+			onStaticPress: replayStaticInputPress,
+			staticPressTarget: "action",
+			showClear: timeValue != null,
+			wrapContentAndTrailing: true,
+			trailingClassName: "py-0! pl-0!",
+			action: showDropdown ? {
+				icon: ui.dateInput.timeIcon,
+				onClick: () => {},
+				altText: ""
+			} : void 0,
+			children: staticSegments
+		});
+	}
+	return /* @__PURE__ */ jsx(TimePickerBase, {
+		...props,
+		ref: $5dc95899b306f630$export$c9058316764c140e(props.ref, inputRef),
+		value: parseTimeValue(normalizedValue),
+		onChange: (value) => props.onChange?.(formatTimeValue(value))
+	});
+};
+const TimePickerComponent = ({ renderStaticInput, ...props }) => {
+	if ("field" in props && props.field) {
+		const { field, ref, ...innerProps } = props;
+		const controlWithOptions = field.form;
+		return /* @__PURE__ */ jsx(FieldController, {
+			control: field.form,
+			name: field.name,
+			render: ({ field, fieldState: { error, isDirty } }) => /* @__PURE__ */ jsx(TimePickerInner, {
+				...innerProps,
+				ref: $5dc95899b306f630$export$c9058316764c140e(ref, field.ref),
+				value: field.value ?? null,
+				onChange: (value) => field.onChange(value ?? null),
+				onBlur: field.onBlur,
+				isDirty,
+				isDisabled: field.disabled || props.isDisabled,
+				isFormControlDisabled: !!controlWithOptions._options?.disabled,
+				error: props.error ?? error?.message,
+				renderStaticInput
+			})
+		});
+	}
+	return /* @__PURE__ */ jsx(TimePickerInner, {
+		...props,
+		renderStaticInput
+	});
+};
+const TimePicker = memo(TimePickerComponent);
+//#endregion
+export { TimePicker as t };

package/dist/Toast-DL8_g0WV.d.ts

@@ -0,0 +1,16 @@
+import { t as ToastVariantProps } from "./toast.cva-C1ZPw_oP.js";
+import { FC, ReactNode, SVGProps } from "react";
+//#region src/components/status/Toast/Toast.d.ts
+interface ToastAction {
+  text: string;
+  onPress: () => void;
+}
+interface ToastProps extends ToastVariantProps {
+  text: ReactNode;
+  isLoading?: boolean;
+  icon?: FC<SVGProps<SVGSVGElement>>;
+  actions?: ToastAction[];
+}
+declare const Toast: ({ text, isLoading, actions, icon: Icon, ...props }: ToastProps) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+export { ToastAction as n, ToastProps as r, Toast as t };

package/dist/ToastContainer-9OS5SK5K.d.ts

@@ -0,0 +1,5 @@
+//#region src/components/status/Toast/ToastContainer.d.ts
+declare const ToastContainer: () => import("react/jsx-runtime").JSX.Element | null;
+declare const ToastProvider: typeof ToastContainer;
+//#endregion
+export { ToastProvider as n, ToastContainer as t };

package/dist/ToastContainer-C45QhP2Q.js

@@ -0,0 +1,55 @@
+import { t as UIConfig } from "./uiConfig.context-BG4jfp9p.js";
+import { t as UIOverrides } from "./uiOverrides.context-Bfm2n-n8.js";
+import { c as toastWrapper, o as toastContainerDefinition, t as Lt } from "./dist-gJbayyxp.js";
+import { i as subscribeToToastActivation, n as isToastRendererActive, r as isToastRendererInactive } from "./toastActivation.store-BELtcr76.js";
+import { useSyncExternalStore } from "react";
+import { c } from "react/compiler-runtime";
+import { jsx } from "react/jsx-runtime";
+//#region src/components/status/Toast/ToastRenderer.tsx
+const ToastRenderer = () => {
+	const $ = c(6);
+	const uiConfig = UIConfig.useConfig();
+	const containerCva = UIOverrides.useCva("toast.containerCva", toastContainerDefinition);
+	let t0;
+	if ($[0] !== containerCva || $[1] !== uiConfig.toast.position) {
+		t0 = (params) => containerCva({
+			position: params?.position ?? uiConfig.toast.position,
+			className: params?.defaultClassName
+		});
+		$[0] = containerCva;
+		$[1] = uiConfig.toast.position;
+		$[2] = t0;
+	} else t0 = $[2];
+	let t1;
+	if ($[3] !== t0 || $[4] !== uiConfig.toast.position) {
+		t1 = /* @__PURE__ */ jsx(Lt, {
+			position: uiConfig.toast.position,
+			className: t0,
+			toastClassName: toastWrapper,
+			autoClose: 2500,
+			icon: false,
+			closeButton: false,
+			hideProgressBar: true
+		});
+		$[3] = t0;
+		$[4] = uiConfig.toast.position;
+		$[5] = t1;
+	} else t1 = $[5];
+	return t1;
+};
+//#endregion
+//#region src/components/status/Toast/ToastContainer.tsx
+const ToastContainer = () => {
+	const $ = c(2);
+	const isActive = useSyncExternalStore(subscribeToToastActivation, isToastRendererActive, isToastRendererInactive);
+	let t0;
+	if ($[0] !== isActive) {
+		t0 = isActive ? /* @__PURE__ */ jsx(ToastRenderer, {}) : null;
+		$[0] = isActive;
+		$[1] = t0;
+	} else t0 = $[1];
+	return t0;
+};
+const ToastProvider = ToastContainer;
+//#endregion
+export { ToastProvider as n, ToastContainer as t };

package/dist/Toggle-CaBvb0l0.d.ts

@@ -0,0 +1,19 @@
+import { m as SwitchProps } from "./types-ZbFfCz06.js";
+import { n as FieldValues } from "./form.binding-QO3Py45C.js";
+import { t as FormFieldErrorProps } from "./FormFieldError-BT4uxbKY.js";
+import { t as ControlProps } from "./form.types-CefwT7Po.js";
+import { t as ToggleVariantProps } from "./toggle.cva-2CGLc8aa.js";
+import { Ref } from "react";
+//#region src/components/inputs/Toggle/Toggle.d.ts
+interface ToggleBaseProps extends FormFieldErrorProps, ToggleVariantProps, Omit<SwitchProps, "className"> {
+  ref?: Ref<HTMLLabelElement>;
+  children?: string;
+  isDirty?: boolean;
+  isRequired?: boolean;
+}
+type ToggleProps = ToggleBaseProps;
+type ControlledToggleProps<TFieldValues extends FieldValues> = ControlProps<ToggleProps, TFieldValues, "isSelected">;
+declare const ToggleComponent: <TFieldValues extends FieldValues>(props: ControlledToggleProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+declare const Toggle: typeof ToggleComponent;
+//#endregion
+export { Toggle as n, ToggleProps as r, ControlledToggleProps as t };