@povio/ui 3.4.0-rc.2 → 3.4.0-rc.22

package/dist/confirmation.context-BJ8gTx7U.d.ts

@@ -0,0 +1,23 @@
+import { n as ActionModalProps } from "./ActionModal-DLeVinly.js";
+import { PropsWithChildren } from "react";
+//#region src/config/confirmation.context.d.ts
+declare namespace Confirmation {
+  type ContextState = Pick<ActionModalProps, "heading" | "description" | "buttonSize" | "textAlign" | "primaryAction" | "secondaryAction" | "modalClassName"> & {
+    isOpen: boolean;
+  };
+  type ConfirmationInput = Pick<ContextState, "heading" | "description" | "buttonSize" | "textAlign" | "modalClassName"> & {
+    cancelLabel?: NonNullable<ContextState["secondaryAction"]>["label"];
+    confirmLabel?: NonNullable<ContextState["primaryAction"]>["label"];
+    cancelVariant?: NonNullable<ContextState["secondaryAction"]>["variant"];
+    cancelColor?: NonNullable<ContextState["secondaryAction"]>["color"];
+    confirmVariant?: NonNullable<ContextState["primaryAction"]>["variant"];
+    confirmColor?: NonNullable<ContextState["primaryAction"]>["color"];
+  };
+  interface Options {
+    confirm: (input: ConfirmationInput) => Promise<boolean>;
+  }
+  const Provider: ({ children }: PropsWithChildren) => import("react/jsx-runtime").JSX.Element;
+  const useConfirmation: () => Options;
+}
+//#endregion
+export { Confirmation as t };

package/dist/confirmation.context-C1-ZF9CW.js

@@ -0,0 +1,80 @@
+import "./i18n-C2TBJvnh.js";
+import { ActionModal } from "./components/action-modal.js";
+import { createContext, use, useCallback, useMemo, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useTranslation } from "react-i18next";
+//#region src/config/confirmation.context.tsx
+let Confirmation;
+(function(_Confirmation) {
+	const DEFAULT_STATE = {
+		heading: "",
+		description: "",
+		isOpen: false,
+		primaryAction: {
+			label: "",
+			onPress: () => {}
+		},
+		secondaryAction: {
+			label: "",
+			onPress: () => {}
+		}
+	};
+	const Context = createContext(null);
+	_Confirmation.Provider = ({ children }) => {
+		const [state, setState] = useState(DEFAULT_STATE);
+		const { t } = useTranslation("ui");
+		const onCancel = () => setState(DEFAULT_STATE);
+		const confirm = useCallback(async ({ heading, description, buttonSize, textAlign, modalClassName, cancelLabel = t(($) => $.ui.confirmation.cancel), confirmLabel = t(($_0) => $_0.ui.confirmation.confirm), confirmVariant, confirmColor, cancelVariant, cancelColor }) => {
+			return new Promise((resolve) => {
+				setState({
+					heading,
+					description,
+					buttonSize,
+					textAlign,
+					modalClassName,
+					primaryAction: {
+						label: confirmLabel,
+						onPress() {
+							setState({
+								...state,
+								isOpen: false,
+								heading: "",
+								description: ""
+							});
+							resolve(true);
+						},
+						variant: confirmVariant,
+						color: confirmColor
+					},
+					secondaryAction: {
+						label: cancelLabel,
+						onPress() {
+							onCancel();
+							resolve(false);
+						},
+						variant: cancelVariant,
+						color: cancelColor
+					},
+					isOpen: !state.isOpen
+				});
+			});
+		}, [state, t]);
+		const value = useMemo(() => ({ confirm }), [confirm]);
+		return /* @__PURE__ */ jsxs(Context.Provider, {
+			value,
+			children: [/* @__PURE__ */ jsx(ActionModal, {
+				...state,
+				onClose: state.secondaryAction?.onPress ?? onCancel,
+				primaryAction: state.primaryAction,
+				secondaryAction: state.secondaryAction
+			}), children]
+		});
+	};
+	_Confirmation.useConfirmation = () => {
+		const context = use(Context);
+		if (!context) throw new Error("Confirmation.useConfirmation must be used within a Confirmation.Provider");
+		return context;
+	};
+})(Confirmation || (Confirmation = {}));
+//#endregion
+export { Confirmation as t };

package/dist/context-CLFkoJMP.js

@@ -0,0 +1,93 @@
+import { Y as $b5e257d569688ac6$export$535bd6ca7f90a273 } from "./useHover-DwfnacVy.js";
+import $HgANd$react, { useContext, useEffect, useState } from "react";
+//#region ../../node_modules/.bun/@react-aria+i18n@3.12.15+67f6792bdf102c28/node_modules/@react-aria/i18n/dist/utils.mjs
+const $148a7a147e38ea7f$var$RTL_SCRIPTS = /* @__PURE__ */ new Set([
+	"Arab",
+	"Syrc",
+	"Samr",
+	"Mand",
+	"Thaa",
+	"Mend",
+	"Nkoo",
+	"Adlm",
+	"Rohg",
+	"Hebr"
+]);
+const $148a7a147e38ea7f$var$RTL_LANGS = /* @__PURE__ */ new Set([
+	"ae",
+	"ar",
+	"arc",
+	"bcc",
+	"bqi",
+	"ckb",
+	"dv",
+	"fa",
+	"glk",
+	"he",
+	"ku",
+	"mzn",
+	"nqo",
+	"pnb",
+	"ps",
+	"sd",
+	"ug",
+	"ur",
+	"yi"
+]);
+function $148a7a147e38ea7f$export$702d680b21cbd764(localeString) {
+	if (Intl.Locale) {
+		let locale = new Intl.Locale(localeString).maximize();
+		let textInfo = typeof locale.getTextInfo === "function" ? locale.getTextInfo() : locale.textInfo;
+		if (textInfo) return textInfo.direction === "rtl";
+		if (locale.script) return $148a7a147e38ea7f$var$RTL_SCRIPTS.has(locale.script);
+	}
+	let lang = localeString.split("-")[0];
+	return $148a7a147e38ea7f$var$RTL_LANGS.has(lang);
+}
+//#endregion
+//#region ../../node_modules/.bun/@react-aria+i18n@3.12.15+67f6792bdf102c28/node_modules/@react-aria/i18n/dist/useDefaultLocale.mjs
+const $1e5a04cdaf7d1af8$var$localeSymbol = Symbol.for("react-aria.i18n.locale");
+function $1e5a04cdaf7d1af8$export$f09106e7c6677ec5() {
+	let locale = typeof window !== "undefined" && window[$1e5a04cdaf7d1af8$var$localeSymbol] || typeof navigator !== "undefined" && (navigator.language || navigator.userLanguage) || "en-US";
+	try {
+		Intl.DateTimeFormat.supportedLocalesOf([locale]);
+	} catch {
+		locale = "en-US";
+	}
+	return {
+		locale,
+		direction: $148a7a147e38ea7f$export$702d680b21cbd764(locale) ? "rtl" : "ltr"
+	};
+}
+let $1e5a04cdaf7d1af8$var$currentLocale = $1e5a04cdaf7d1af8$export$f09106e7c6677ec5();
+let $1e5a04cdaf7d1af8$var$listeners = /* @__PURE__ */ new Set();
+function $1e5a04cdaf7d1af8$var$updateLocale() {
+	$1e5a04cdaf7d1af8$var$currentLocale = $1e5a04cdaf7d1af8$export$f09106e7c6677ec5();
+	for (let listener of $1e5a04cdaf7d1af8$var$listeners) listener($1e5a04cdaf7d1af8$var$currentLocale);
+}
+function $1e5a04cdaf7d1af8$export$188ec29ebc2bdc3a() {
+	let isSSR = $b5e257d569688ac6$export$535bd6ca7f90a273();
+	let [defaultLocale, setDefaultLocale] = useState($1e5a04cdaf7d1af8$var$currentLocale);
+	useEffect(() => {
+		if ($1e5a04cdaf7d1af8$var$listeners.size === 0) window.addEventListener("languagechange", $1e5a04cdaf7d1af8$var$updateLocale);
+		$1e5a04cdaf7d1af8$var$listeners.add(setDefaultLocale);
+		return () => {
+			$1e5a04cdaf7d1af8$var$listeners.delete(setDefaultLocale);
+			if ($1e5a04cdaf7d1af8$var$listeners.size === 0) window.removeEventListener("languagechange", $1e5a04cdaf7d1af8$var$updateLocale);
+		};
+	}, []);
+	if (isSSR) return {
+		locale: typeof window !== "undefined" && window[$1e5a04cdaf7d1af8$var$localeSymbol] || "en-US",
+		direction: "ltr"
+	};
+	return defaultLocale;
+}
+//#endregion
+//#region ../../node_modules/.bun/@react-aria+i18n@3.12.15+67f6792bdf102c28/node_modules/@react-aria/i18n/dist/context.mjs
+const $18f2051aff69b9bf$var$I18nContext = /*#__PURE__*/ $HgANd$react.createContext(null);
+function $18f2051aff69b9bf$export$43bb16f9c6d9e3f7() {
+	let defaultLocale = $1e5a04cdaf7d1af8$export$188ec29ebc2bdc3a();
+	return useContext($18f2051aff69b9bf$var$I18nContext) || defaultLocale;
+}
+//#endregion
+export { $18f2051aff69b9bf$export$43bb16f9c6d9e3f7 as t };

package/dist/createLucideIcon-CskCrR9z.js

@@ -0,0 +1,125 @@
+import { createContext, createElement, forwardRef, useContext } from "react";
+//#region ../../node_modules/.bun/lucide-react@1.28.0+83d5fd7b249dbeef/node_modules/lucide-react/dist/esm/shared/src/utils/mergeClasses.mjs
+/**
+* @license lucide-react v1.28.0 - ISC
+*
+* This source code is licensed under the ISC license.
+* See the LICENSE file in the root directory of this source tree.
+*/
+const mergeClasses = (...classes) => classes.filter((className, index, array) => {
+	return Boolean(className) && className.trim() !== "" && array.indexOf(className) === index;
+}).join(" ").trim();
+//#endregion
+//#region ../../node_modules/.bun/lucide-react@1.28.0+83d5fd7b249dbeef/node_modules/lucide-react/dist/esm/shared/src/utils/toKebabCase.mjs
+/**
+* @license lucide-react v1.28.0 - ISC
+*
+* This source code is licensed under the ISC license.
+* See the LICENSE file in the root directory of this source tree.
+*/
+const toKebabCase = (string) => string.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+//#endregion
+//#region ../../node_modules/.bun/lucide-react@1.28.0+83d5fd7b249dbeef/node_modules/lucide-react/dist/esm/shared/src/utils/toCamelCase.mjs
+/**
+* @license lucide-react v1.28.0 - ISC
+*
+* This source code is licensed under the ISC license.
+* See the LICENSE file in the root directory of this source tree.
+*/
+const toCamelCase = (string) => string.replace(/^([A-Z])|[\s-_]+(\w)/g, (match, p1, p2) => p2 ? p2.toUpperCase() : p1.toLowerCase());
+//#endregion
+//#region ../../node_modules/.bun/lucide-react@1.28.0+83d5fd7b249dbeef/node_modules/lucide-react/dist/esm/shared/src/utils/toPascalCase.mjs
+/**
+* @license lucide-react v1.28.0 - ISC
+*
+* This source code is licensed under the ISC license.
+* See the LICENSE file in the root directory of this source tree.
+*/
+const toPascalCase = (string) => {
+	const camelCase = toCamelCase(string);
+	return camelCase.charAt(0).toUpperCase() + camelCase.slice(1);
+};
+//#endregion
+//#region ../../node_modules/.bun/lucide-react@1.28.0+83d5fd7b249dbeef/node_modules/lucide-react/dist/esm/defaultAttributes.mjs
+/**
+* @license lucide-react v1.28.0 - ISC
+*
+* This source code is licensed under the ISC license.
+* See the LICENSE file in the root directory of this source tree.
+*/
+var defaultAttributes = {
+	xmlns: "http://www.w3.org/2000/svg",
+	width: 24,
+	height: 24,
+	viewBox: "0 0 24 24",
+	fill: "none",
+	stroke: "currentColor",
+	strokeWidth: 2,
+	strokeLinecap: "round",
+	strokeLinejoin: "round"
+};
+//#endregion
+//#region ../../node_modules/.bun/lucide-react@1.28.0+83d5fd7b249dbeef/node_modules/lucide-react/dist/esm/shared/src/utils/hasA11yProp.mjs
+/**
+* @license lucide-react v1.28.0 - ISC
+*
+* This source code is licensed under the ISC license.
+* See the LICENSE file in the root directory of this source tree.
+*/
+const hasA11yProp = (props) => {
+	for (const prop in props) if (prop.startsWith("aria-") || prop === "role" || prop === "title") return true;
+	return false;
+};
+//#endregion
+//#region ../../node_modules/.bun/lucide-react@1.28.0+83d5fd7b249dbeef/node_modules/lucide-react/dist/esm/context.mjs
+/**
+* @license lucide-react v1.28.0 - ISC
+*
+* This source code is licensed under the ISC license.
+* See the LICENSE file in the root directory of this source tree.
+*/
+const LucideContext = createContext({});
+const useLucideContext = () => useContext(LucideContext);
+//#endregion
+//#region ../../node_modules/.bun/lucide-react@1.28.0+83d5fd7b249dbeef/node_modules/lucide-react/dist/esm/Icon.mjs
+/**
+* @license lucide-react v1.28.0 - ISC
+*
+* This source code is licensed under the ISC license.
+* See the LICENSE file in the root directory of this source tree.
+*/
+const Icon = forwardRef(({ color, size, strokeWidth, absoluteStrokeWidth, className = "", children, iconNode, ...rest }, ref) => {
+	const { size: contextSize = 24, strokeWidth: contextStrokeWidth = 2, absoluteStrokeWidth: contextAbsoluteStrokeWidth = false, color: contextColor = "currentColor", className: contextClass = "" } = useLucideContext() ?? {};
+	const calculatedStrokeWidth = absoluteStrokeWidth ?? contextAbsoluteStrokeWidth ? Number(strokeWidth ?? contextStrokeWidth) * 24 / Number(size ?? contextSize) : strokeWidth ?? contextStrokeWidth;
+	return createElement("svg", {
+		ref,
+		...defaultAttributes,
+		width: size ?? contextSize ?? defaultAttributes.width,
+		height: size ?? contextSize ?? defaultAttributes.height,
+		stroke: color ?? contextColor,
+		strokeWidth: calculatedStrokeWidth,
+		className: mergeClasses("lucide", contextClass, className),
+		...!children && !hasA11yProp(rest) && { "aria-hidden": "true" },
+		...rest
+	}, [...iconNode.map(([tag, attrs]) => createElement(tag, attrs)), ...Array.isArray(children) ? children : [children]]);
+});
+//#endregion
+//#region ../../node_modules/.bun/lucide-react@1.28.0+83d5fd7b249dbeef/node_modules/lucide-react/dist/esm/createLucideIcon.mjs
+/**
+* @license lucide-react v1.28.0 - ISC
+*
+* This source code is licensed under the ISC license.
+* See the LICENSE file in the root directory of this source tree.
+*/
+const createLucideIcon = (iconName, iconNode) => {
+	const Component = forwardRef(({ className, ...props }, ref) => createElement(Icon, {
+		ref,
+		iconNode,
+		className: mergeClasses(`lucide-${toKebabCase(toPascalCase(iconName))}`, `lucide-${iconName}`, className),
+		...props
+	}));
+	Component.displayName = toPascalCase(iconName);
+	return Component;
+};
+//#endregion
+export { createLucideIcon as t };

package/dist/date-picker-BpSowet-.d.ts

@@ -0,0 +1,9 @@
+import { r as DatePickerProps } from "./DatePicker-DclmenVd.js";
+import { t as ControlProps } from "./form.types-ZNGbcqJS.js";
+import { t as FireBlurOnChangeProps } from "./fieldAdapter-C4sDFC8f.js";
+import { FieldValues } from "react-hook-form";
+//#region src/entries/rhf/date-picker.d.ts
+type ControlledDatePickerProps<T extends FieldValues> = ControlProps<DatePickerProps & FireBlurOnChangeProps, T>;
+declare const DatePicker: <T extends FieldValues>(props: ControlledDatePickerProps<T>) => import("react").ReactNode;
+//#endregion
+export { DatePicker as n, ControlledDatePickerProps as t };

package/dist/date-range-picker-aO65H4wV.d.ts

@@ -0,0 +1,9 @@
+import { r as DateRangePickerProps } from "./DateRangePicker-DjkIlnMl.js";
+import { t as ControlProps } from "./form.types-ZNGbcqJS.js";
+import { t as FireBlurOnChangeProps } from "./fieldAdapter-C4sDFC8f.js";
+import { FieldValues } from "react-hook-form";
+//#region src/entries/rhf/date-range-picker.d.ts
+type ControlledDateRangePickerProps<T extends FieldValues> = ControlProps<DateRangePickerProps & FireBlurOnChangeProps, T>;
+declare const DateRangePicker: <T extends FieldValues>(props: ControlledDateRangePickerProps<T>) => import("react").ReactNode;
+//#endregion
+export { DateRangePicker as n, ControlledDateRangePickerProps as t };

package/dist/date-time-picker-DWo2GFg7.d.ts

@@ -0,0 +1,9 @@
+import { r as DateTimePickerProps } from "./DateTimePicker-aDvcYnVk.js";
+import { t as ControlProps } from "./form.types-ZNGbcqJS.js";
+import { t as FireBlurOnChangeProps } from "./fieldAdapter-C4sDFC8f.js";
+import { FieldValues } from "react-hook-form";
+//#region src/entries/rhf/date-time-picker.d.ts
+type ControlledDateTimePickerProps<T extends FieldValues> = ControlProps<DateTimePickerProps & FireBlurOnChangeProps, T>;
+declare const DateTimePicker: <T extends FieldValues>(props: ControlledDateTimePickerProps<T>) => import("react").ReactNode;
+//#endregion
+export { DateTimePicker as n, ControlledDateTimePickerProps as t };

package/dist/date-time.utils-0F9qduim.js

@@ -0,0 +1,190 @@
+import { t as IntlUtils } from "./intl.utils-zwAFoZ0U.js";
+import { CalendarDate, CalendarDateTime, DateFormatter, fromDate, getLocalTimeZone, parseAbsolute, toZoned } from "@internationalized/date";
+//#region src/utils/date-time.utils.ts
+let DateTimeUtils;
+(function(_DateTimeUtils) {
+	const DATE_SAMPLE_DATE_UTC = new Date(Date.UTC(2e3, 10, 22));
+	const TIME_SAMPLE_DATE_UTC = new Date(Date.UTC(2e3, 10, 22, 6, 45));
+	const timeFormatters = /* @__PURE__ */ new Map();
+	const getDayMonthFormat = (shouldForceLeadingZeros = false) => shouldForceLeadingZeros ? "2-digit" : "numeric";
+	const getTimeHourFormat = (shouldForceLeadingZeros = false) => shouldForceLeadingZeros ? "2-digit" : "numeric";
+	const getDatePlaceholderFormatter = (locale, options) => IntlUtils.getDateTimeFormatter(locale, {
+		day: getDayMonthFormat(options?.shouldForceLeadingZeros),
+		month: getDayMonthFormat(options?.shouldForceLeadingZeros),
+		year: "numeric"
+	});
+	const getTimePlaceholderFormatter = (locale) => IntlUtils.getDateTimeFormatter(locale, {
+		hour: "2-digit",
+		minute: "2-digit"
+	});
+	const getResolvedLocale = (locale) => {
+		if (locale) return locale;
+		return IntlUtils.getDateTimeFormatter().resolvedOptions().locale;
+	};
+	const getDateFormatter = (locale, options) => IntlUtils.getDateTimeFormatter(getResolvedLocale(locale), {
+		day: getDayMonthFormat(options?.shouldForceLeadingZeros),
+		month: getDayMonthFormat(options?.shouldForceLeadingZeros),
+		year: "numeric",
+		timeZone: "UTC"
+	});
+	const getTimeFormatter = (locale, options) => {
+		const resolvedLocale = getResolvedLocale(locale);
+		const key = `${resolvedLocale}|${options?.shouldForceLeadingZeros ?? false}`;
+		const cachedFormatter = timeFormatters.get(key);
+		if (cachedFormatter) return cachedFormatter;
+		const formatter = new DateFormatter(resolvedLocale, {
+			hour: getTimeHourFormat(options?.shouldForceLeadingZeros),
+			minute: "2-digit",
+			timeZone: "UTC"
+		});
+		timeFormatters.set(key, formatter);
+		return formatter;
+	};
+	const getDateTimeFormatter = (locale, options) => IntlUtils.getDateTimeFormatter(getResolvedLocale(locale), {
+		day: getDayMonthFormat(options?.shouldForceLeadingZeros),
+		month: getDayMonthFormat(options?.shouldForceLeadingZeros),
+		year: "numeric",
+		hour: getTimeHourFormat(options?.shouldForceLeadingZeros),
+		minute: "2-digit",
+		timeZone: "UTC"
+	});
+	const repeatLocalizedFieldLabel = (type, length, locale) => {
+		const placeholderChar = IntlUtils.getDisplayNamesFormatter(getResolvedLocale(locale), { type: "dateTimeField" }).of(type)?.trim().charAt(0).toLocaleLowerCase(getResolvedLocale(locale));
+		if (!placeholderChar) return null;
+		return placeholderChar.repeat(length);
+	};
+	const mapTypeToPlaceholder = (type, locale) => {
+		switch (type) {
+			case "day": return repeatLocalizedFieldLabel(type, 2, locale);
+			case "month": return repeatLocalizedFieldLabel(type, 2, locale);
+			case "year": return repeatLocalizedFieldLabel(type, 4, locale);
+			case "hour": return "hh";
+			case "minute": return "mm";
+			default: return null;
+		}
+	};
+	const formatPlaceholder = (formatter, sampleDate) => {
+		return formatter.formatToParts(sampleDate).map((part) => mapTypeToPlaceholder(part.type, formatter.resolvedOptions().locale) ?? part.value).join("");
+	};
+	const removeDateSeparatorSpacing = (value) => value.replace(/([./-])\s+(?=[\p{Letter}\p{Number}])/gu, "$1");
+	const formatLocalizedDateParts = (formatter, date) => {
+		return removeDateSeparatorSpacing(formatter.format(date));
+	};
+	const formatLocalizedDatePartList = (formatter, date, isPlaceholder) => {
+		const locale = formatter.resolvedOptions().locale;
+		return formatter.formatToParts(date).map((part) => {
+			const value = part.type === "literal" ? part.value.replace(/([./-])\s+/gu, "$1") : part.value.replace(/\s+/gu, "");
+			return {
+				type: part.type,
+				value,
+				placeholder: mapTypeToPlaceholder(part.type, locale) ?? value,
+				isPlaceholder
+			};
+		});
+	};
+	function getDatePlaceholder(locale, options) {
+		return removeDateSeparatorSpacing(formatPlaceholder(getDatePlaceholderFormatter(locale, options), DATE_SAMPLE_DATE_UTC));
+	}
+	_DateTimeUtils.getDatePlaceholder = getDatePlaceholder;
+	function getTimePlaceholder(locale) {
+		return formatPlaceholder(getTimePlaceholderFormatter(locale), TIME_SAMPLE_DATE_UTC);
+	}
+	_DateTimeUtils.getTimePlaceholder = getTimePlaceholder;
+	function getDateTimePlaceholder(locale, options) {
+		return `${getDatePlaceholder(locale, options)}, ${getTimePlaceholder(locale)}`;
+	}
+	_DateTimeUtils.getDateTimePlaceholder = getDateTimePlaceholder;
+	function getDateRangePlaceholder(locale, options) {
+		const datePlaceholder = getDatePlaceholder(locale, options);
+		return `${datePlaceholder} – ${datePlaceholder}`;
+	}
+	_DateTimeUtils.getDateRangePlaceholder = getDateRangePlaceholder;
+	function formatCalendarDateLocalized(calendarDate, locale, options) {
+		return formatLocalizedDateParts(getDateFormatter(locale, options), calendarDate.toDate("UTC"));
+	}
+	_DateTimeUtils.formatCalendarDateLocalized = formatCalendarDateLocalized;
+	function formatCalendarDatePartsLocalized(calendarDate, locale, options) {
+		return formatLocalizedDatePartList(getDateFormatter(locale, options), calendarDate?.toDate("UTC") ?? DATE_SAMPLE_DATE_UTC, !calendarDate);
+	}
+	_DateTimeUtils.formatCalendarDatePartsLocalized = formatCalendarDatePartsLocalized;
+	function formatCalendarDateTimePartsLocalized(calendarDateTime, locale, options) {
+		const normalizedValue = calendarDateTime ? new CalendarDateTime(calendarDateTime.year, calendarDateTime.month, calendarDateTime.day, calendarDateTime.hour, calendarDateTime.minute) : null;
+		return formatLocalizedDatePartList(getDateTimeFormatter(locale, options), normalizedValue?.toDate("UTC") ?? TIME_SAMPLE_DATE_UTC, !calendarDateTime);
+	}
+	_DateTimeUtils.formatCalendarDateTimePartsLocalized = formatCalendarDateTimePartsLocalized;
+	function formatTimeLocalized(timeValue, locale, options) {
+		const dateTime = new CalendarDateTime(2e3, 11, 22, timeValue.hour, timeValue.minute);
+		return getTimeFormatter(locale, options).format(dateTime.toDate("UTC"));
+	}
+	_DateTimeUtils.formatTimeLocalized = formatTimeLocalized;
+	function formatTimePartsLocalized(timeValue, locale, options) {
+		const normalizedValue = new CalendarDateTime(2e3, 11, 22, timeValue?.hour ?? 6, timeValue?.minute ?? 45);
+		return formatLocalizedDatePartList(getTimeFormatter(locale, options), normalizedValue.toDate("UTC"), !timeValue);
+	}
+	_DateTimeUtils.formatTimePartsLocalized = formatTimePartsLocalized;
+	function formatCalendarDateTimeLocalized(calendarDateTime, locale, options) {
+		const normalizedValue = new CalendarDateTime(calendarDateTime.year, calendarDateTime.month, calendarDateTime.day, calendarDateTime.hour, calendarDateTime.minute);
+		return formatLocalizedDateParts(getDateTimeFormatter(locale, options), normalizedValue.toDate("UTC"));
+	}
+	_DateTimeUtils.formatCalendarDateTimeLocalized = formatCalendarDateTimeLocalized;
+	function resolveTimeZone(timeZone) {
+		if (timeZone) return timeZone;
+		return getLocalTimeZone();
+	}
+	function fromISOtoZonedDateTime(isoString, timeZone) {
+		const resolvedTimeZone = resolveTimeZone(timeZone);
+		return parseAbsolute(isoString, resolvedTimeZone);
+	}
+	_DateTimeUtils.fromISOtoZonedDateTime = fromISOtoZonedDateTime;
+	function fromDateValueToISO(dateValue, timeZone) {
+		const resolvedTimeZone = resolveTimeZone(timeZone);
+		return dateValue.toDate(resolvedTimeZone).toISOString();
+	}
+	_DateTimeUtils.fromDateValueToISO = fromDateValueToISO;
+	function fromDateValueFieldsToUTCISO(dateValue) {
+		const dateTimeFields = dateValue;
+		return new CalendarDateTime(dateValue.year, dateValue.month, dateValue.day, dateTimeFields.hour ?? 0, dateTimeFields.minute ?? 0, dateTimeFields.second ?? 0, dateTimeFields.millisecond ?? 0).toDate("UTC").toISOString();
+	}
+	_DateTimeUtils.fromDateValueFieldsToUTCISO = fromDateValueFieldsToUTCISO;
+	function getCurrentWallClockCalendarDateTime() {
+		const date = /* @__PURE__ */ new Date();
+		return new CalendarDateTime(date.getFullYear(), date.getMonth() + 1, date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());
+	}
+	_DateTimeUtils.getCurrentWallClockCalendarDateTime = getCurrentWallClockCalendarDateTime;
+	function fromDateValueToOffsetISO(dateValue, timeZone) {
+		const resolvedTimeZone = resolveTimeZone(timeZone);
+		return toZoned(dateValue, resolvedTimeZone).toString().replace(/\[[^\]]+\]$/u, "");
+	}
+	_DateTimeUtils.fromDateValueToOffsetISO = fromDateValueToOffsetISO;
+	function fromLocalToZonedDateTime(date, timeZone) {
+		const resolvedTimeZone = resolveTimeZone(timeZone);
+		return fromDate(date, resolvedTimeZone);
+	}
+	_DateTimeUtils.fromLocalToZonedDateTime = fromLocalToZonedDateTime;
+	function fromDateValueToLocal(dateValue, timeZone) {
+		const resolvedTimeZone = resolveTimeZone(timeZone);
+		return dateValue.toDate(resolvedTimeZone);
+	}
+	_DateTimeUtils.fromDateValueToLocal = fromDateValueToLocal;
+	function fromCalendarDateToUTCISO(calendarDate, options = {}) {
+		if (options.endOfDay) return new CalendarDateTime(calendarDate.year, calendarDate.month, calendarDate.day, 23, 59, 59, 999).toDate("UTC").toISOString();
+		return calendarDate.toDate("UTC").toISOString();
+	}
+	_DateTimeUtils.fromCalendarDateToUTCISO = fromCalendarDateToUTCISO;
+	function fromUTCISOToCalendarDate(isoString) {
+		const date = new Date(isoString);
+		return new CalendarDate(date.getUTCFullYear(), date.getUTCMonth() + 1, date.getUTCDate());
+	}
+	_DateTimeUtils.fromUTCISOToCalendarDate = fromUTCISOToCalendarDate;
+	function fromCalendarDateTimeToUTCISO(calendarDateTime) {
+		return calendarDateTime.toDate("UTC").toISOString();
+	}
+	_DateTimeUtils.fromCalendarDateTimeToUTCISO = fromCalendarDateTimeToUTCISO;
+	function fromUTCISOToCalendarDateTime(isoString, timeZone = "UTC") {
+		const zonedDateTime = parseAbsolute(isoString, timeZone);
+		return new CalendarDateTime(zonedDateTime.year, zonedDateTime.month, zonedDateTime.day, zonedDateTime.hour, zonedDateTime.minute, zonedDateTime.second, zonedDateTime.millisecond);
+	}
+	_DateTimeUtils.fromUTCISOToCalendarDateTime = fromUTCISOToCalendarDateTime;
+})(DateTimeUtils || (DateTimeUtils = {}));
+//#endregion
+export { DateTimeUtils as t };

package/dist/date-time.utils-Cu9TVj46.d.ts

@@ -0,0 +1,45 @@
+import { CalendarDate, CalendarDateTime, DateValue, ZonedDateTime } from "@internationalized/date";
+//#region src/utils/date-time.utils.d.ts
+declare namespace DateTimeUtils {
+  interface LocalizedDateFormatOptions {
+    shouldForceLeadingZeros?: boolean;
+  }
+  export interface LocalizedDatePart {
+    type: Intl.DateTimeFormatPartTypes;
+    value: string;
+    placeholder: string;
+    isPlaceholder: boolean;
+  }
+  export function getDatePlaceholder(locale?: string, options?: LocalizedDateFormatOptions): string;
+  export function getTimePlaceholder(locale?: string): string;
+  export function getDateTimePlaceholder(locale?: string, options?: LocalizedDateFormatOptions): string;
+  export function getDateRangePlaceholder(locale?: string, options?: LocalizedDateFormatOptions): string;
+  export function formatCalendarDateLocalized(calendarDate: CalendarDate, locale?: string, options?: LocalizedDateFormatOptions): string;
+  export function formatCalendarDatePartsLocalized(calendarDate?: CalendarDate | null, locale?: string, options?: LocalizedDateFormatOptions): LocalizedDatePart[];
+  export function formatCalendarDateTimePartsLocalized(calendarDateTime?: Pick<CalendarDateTime, "day" | "month" | "year" | "hour" | "minute"> | null, locale?: string, options?: LocalizedDateFormatOptions): LocalizedDatePart[];
+  export function formatTimeLocalized(timeValue: {
+    hour: number;
+    minute: number;
+  }, locale?: string, options?: LocalizedDateFormatOptions): string;
+  export function formatTimePartsLocalized(timeValue?: {
+    hour: number;
+    minute: number;
+  } | null, locale?: string, options?: LocalizedDateFormatOptions): LocalizedDatePart[];
+  export function formatCalendarDateTimeLocalized(calendarDateTime: Pick<CalendarDateTime, "day" | "month" | "year" | "hour" | "minute">, locale?: string, options?: LocalizedDateFormatOptions): string;
+  export function fromISOtoZonedDateTime(isoString: string, timeZone?: string): ZonedDateTime;
+  export function fromDateValueToISO(dateValue: DateValue, timeZone?: string): string;
+  export function fromDateValueFieldsToUTCISO(dateValue: DateValue): string;
+  export function getCurrentWallClockCalendarDateTime(): CalendarDateTime;
+  export function fromDateValueToOffsetISO(dateValue: DateValue, timeZone?: string): string;
+  export function fromLocalToZonedDateTime(date: Date, timeZone?: string): ZonedDateTime;
+  export function fromDateValueToLocal(dateValue: DateValue, timeZone?: string): Date;
+  export function fromCalendarDateToUTCISO(calendarDate: CalendarDate, options?: {
+    endOfDay?: boolean;
+  }): string;
+  export function fromUTCISOToCalendarDate(isoString: string): CalendarDate;
+  export function fromCalendarDateTimeToUTCISO(calendarDateTime: CalendarDateTime): string;
+  export function fromUTCISOToCalendarDateTime(isoString: string, timeZone?: string): CalendarDateTime;
+  export {};
+}
+//#endregion
+export { DateTimeUtils as t };

package/dist/date.transforms-DLg-eFcE.js

@@ -0,0 +1,15 @@
+import { parseDate, parseDateTime, parseTime } from "@internationalized/date";
+//#region src/rhf/date.transforms.ts
+const toCalendarDate$1 = (value) => typeof value === "string" ? parseDate(value.slice(0, 10)) : value;
+const toCalendarDateTime$1 = (value) => typeof value === "string" ? parseDateTime(value.replace(/(?:Z|[+-]\d{2}:?\d{2})$/, "")) : value;
+const toTime$1 = (value) => typeof value === "string" ? parseTime(value.slice(11, 23)) : value;
+const toCalendarDateRange = (value) => {
+	if (!value || typeof value !== "object" || !("start" in value) || !("end" in value)) return value;
+	const range = value;
+	return {
+		start: toCalendarDate$1(range.start),
+		end: toCalendarDate$1(range.end)
+	};
+};
+//#endregion
+export { toTime$1 as i, toCalendarDateRange as n, toCalendarDateTime$1 as r, toCalendarDate$1 as t };

package/dist/date.utils-B8_QF9y6.js

@@ -0,0 +1,42 @@
+//#region src/utils/date.utils.ts
+let DateUtils;
+(function(_DateUtils) {
+	const DATE_FORMAT = "dd/MM/yyyy";
+	const DATETIME_FORMAT = "dd/MM/yyyy HH:mm:ss";
+	function formatDate(date, format = DATE_FORMAT) {
+		if (Number.isNaN(date.getTime())) return "Invalid DateTime";
+		const monthShort = new Intl.DateTimeFormat(void 0, { month: "short" }).format(date);
+		const parts = {
+			yyyy: String(date.getFullYear()).padStart(4, "0"),
+			MMM: monthShort,
+			MM: String(date.getMonth() + 1).padStart(2, "0"),
+			M: String(date.getMonth() + 1),
+			dd: String(date.getDate()).padStart(2, "0"),
+			d: String(date.getDate()),
+			HH: String(date.getHours()).padStart(2, "0"),
+			mm: String(date.getMinutes()).padStart(2, "0"),
+			ss: String(date.getSeconds()).padStart(2, "0")
+		};
+		return format.replace(/yyyy|MMM|MM|dd|HH|mm|ss|M|d/gu, (token) => parts[token]);
+	}
+	_DateUtils.formatDate = formatDate;
+	function formatRelativeTime(date, options) {
+		const dateObject = typeof date === "string" ? new Date(date) : date;
+		if (Number.isNaN(dateObject.getTime())) return formatDate(dateObject, DATETIME_FORMAT);
+		const differenceSeconds = (dateObject.getTime() - Date.now()) / 1e3;
+		const units = [
+			["year", 31536e3],
+			["month", 2592e3],
+			["day", 86400],
+			["hour", 3600],
+			["minute", 60],
+			["second", 1]
+		];
+		const [unit, secondsPerUnit] = units.find(([, seconds]) => Math.abs(differenceSeconds) >= seconds) ?? units.at(-1);
+		const value = Math.round(differenceSeconds / secondsPerUnit);
+		return new Intl.RelativeTimeFormat(void 0, options).format(value, unit);
+	}
+	_DateUtils.formatRelativeTime = formatRelativeTime;
+})(DateUtils || (DateUtils = {}));
+//#endregion
+export { DateUtils as t };

package/dist/date.utils-BoQnMRlF.d.ts

@@ -0,0 +1,7 @@
+//#region src/utils/date.utils.d.ts
+declare namespace DateUtils {
+  function formatDate(date: Date, format?: string): string;
+  function formatRelativeTime(date: Date | string, options?: Intl.RelativeTimeFormatOptions): string;
+}
+//#endregion
+export { DateUtils as t };