@mezzanine-ui/react 0.9.0 → 0.10.0

package/Calendar/CalendarControls.js

@@ -10,11 +10,11 @@ import cx from 'clsx';
  */
 function CalendarControls(props) {
     const { children, className, disableOnNext, disableOnPrev, onNext, onPrev, ...restElementProps } = props;
-    return (jsxs("div", Object.assign({}, restElementProps, { className: cx(calendarClasses.controls, className) }, { children: [onPrev && (jsx("button", Object.assign({ type: "button", "aria-disabled": disableOnPrev, disabled: disableOnPrev, onClick: onPrev, className: cx(calendarClasses.button, calendarClasses.controlsIconButton, calendarClasses.controlsPrev, {
+    return (jsxs("div", { ...restElementProps, className: cx(calendarClasses.controls, className), children: [onPrev && (jsx("button", { type: "button", "aria-disabled": disableOnPrev, disabled: disableOnPrev, onClick: onPrev, className: cx(calendarClasses.button, calendarClasses.controlsIconButton, calendarClasses.controlsPrev, {
                     [calendarClasses.buttonDisabled]: disableOnPrev,
-                }) }, { children: jsx(Icon, { icon: ChevronLeftIcon }, void 0) }), void 0)), children, onNext && (jsx("button", Object.assign({ type: "button", "aria-disabled": disableOnNext, disabled: disableOnNext, onClick: onNext, className: cx(calendarClasses.button, calendarClasses.controlsIconButton, calendarClasses.controlsNext, {
+                }), children: jsx(Icon, { icon: ChevronLeftIcon }) })), children, onNext && (jsx("button", { type: "button", "aria-disabled": disableOnNext, disabled: disableOnNext, onClick: onNext, className: cx(calendarClasses.button, calendarClasses.controlsIconButton, calendarClasses.controlsNext, {
                     [calendarClasses.buttonDisabled]: disableOnNext,
-                }) }, { children: jsx(Icon, { icon: ChevronRightIcon }, void 0) }), void 0))] }), void 0));
+                }), children: jsx(Icon, { icon: ChevronRightIcon }) }))] }));
 }
 
 export { CalendarControls as default };

package/Calendar/CalendarDayOfWeek.js

@@ -12,7 +12,7 @@ function CalendarDayOfWeek(props) {
     const { getWeekDayNames, displayWeekDayLocale: displayWeekDayLocaleFromConfig, } = useCalendarContext();
     const { displayWeekDayLocale = displayWeekDayLocaleFromConfig, className, ...restRowProps } = props;
     const weekDayNames = getWeekDayNames(displayWeekDayLocale);
-    return (jsx("div", Object.assign({ className: cx(calendarClasses.row, className) }, restRowProps, { children: weekDayNames.map((name) => (jsx(CalendarCell, { children: name }, `CALENDAR_DAY_OF_WEEK/${name}`))) }), void 0));
+    return (jsx("div", { className: cx(calendarClasses.row, className), ...restRowProps, children: weekDayNames.map((name) => (jsx(CalendarCell, { children: name }, `CALENDAR_DAY_OF_WEEK/${name}`))) }));
 }
 
 export { CalendarDayOfWeek as default };

package/Calendar/CalendarDays.js

@@ -15,8 +15,7 @@ function CalendarDays(props) {
     const { displayWeekDayLocale: displayWeekDayLocaleFromConfig, getCalendarGrid, getDate, getMonth, getNow, isDateIncluded, isSameDate, setDate, setMonth, } = useCalendarContext();
     const { className, displayWeekDayLocale = displayWeekDayLocaleFromConfig, isDateDisabled, isDateInRange, onClick: onClickProp, onDateHover, referenceDate, value, ...rest } = props;
     const daysGrid = useMemo(() => getCalendarGrid(referenceDate), [getCalendarGrid, referenceDate]);
-    return (jsxs("div", Object.assign({}, rest, { className: cx(calendarClasses.board, className) }, { children: [jsx(CalendarDayOfWeek, { displayWeekDayLocale: displayWeekDayLocale }, void 0),
-            daysGrid.map((week, index) => (jsx("div", Object.assign({ className: calendarClasses.row }, { children: week.map((dateNum) => {
+    return (jsxs("div", { ...rest, className: cx(calendarClasses.board, className), children: [jsx(CalendarDayOfWeek, { displayWeekDayLocale: displayWeekDayLocale }), daysGrid.map((week, index) => (jsx("div", { className: calendarClasses.row, children: week.map((dateNum) => {
                     const isPrevMonth = index === 0 && dateNum > 7;
                     const isNextMonth = index > 3 && dateNum <= 14;
                     const thisMonth = getMonth(referenceDate);
@@ -37,12 +36,12 @@ function CalendarDays(props) {
                     const onClick = onClickProp
                         ? () => { onClickProp(date); }
                         : undefined;
-                    return (jsx(CalendarCell, Object.assign({ today: isSameDate(date, getNow()), active: active, disabled: isPrevMonth || isNextMonth }, { children: jsx("button", Object.assign({ type: "button", "aria-disabled": disabled, disabled: disabled, onMouseEnter: onMouseEnter, className: cx(calendarClasses.button, {
+                    return (jsx(CalendarCell, { today: isSameDate(date, getNow()), active: active, disabled: isPrevMonth || isNextMonth, children: jsx("button", { type: "button", "aria-disabled": disabled, disabled: disabled, onMouseEnter: onMouseEnter, className: cx(calendarClasses.button, {
                                 [calendarClasses.buttonInRange]: inRange,
                                 [calendarClasses.buttonActive]: active,
                                 [calendarClasses.buttonDisabled]: disabled,
-                            }), onClick: onClick }, { children: dateNum }), void 0) }), `${getMonth(date)}/${getDate(date)}`));
-                }) }), `CALENDAR_DAYS/WEEK_OF/${index}`)))] }), void 0));
+                            }), onClick: onClick, children: dateNum }) }, `${getMonth(date)}/${getDate(date)}`));
+                }) }, `CALENDAR_DAYS/WEEK_OF/${index}`)))] }));
 }
 
 export { CalendarDays as default };

package/Calendar/CalendarMonths.js

@@ -12,19 +12,19 @@ function CalendarMonths(props) {
     const { displayMonthLocale: displayMonthLocaleFromConfig, getMonthShortNames, isMonthIncluded, setMonth, } = useCalendarContext();
     const { className, displayMonthLocale = displayMonthLocaleFromConfig, isMonthDisabled, isMonthInRange, onClick: onClickProp, onMonthHover, referenceDate, value, ...rest } = props;
     const monthNames = getMonthShortNames(displayMonthLocale);
-    return (jsx("div", Object.assign({ className: cx(calendarClasses.board, className) }, rest, { children: jsx("div", Object.assign({ className: calendarClasses.twelveGrid }, { children: calendarMonths.map((month) => {
+    return (jsx("div", { className: cx(calendarClasses.board, className), ...rest, children: jsx("div", { className: calendarClasses.twelveGrid, children: calendarMonths.map((month) => {
                 const monthDateType = setMonth(referenceDate, month);
                 const active = value && isMonthIncluded(monthDateType, value);
                 const disabled = isMonthDisabled && isMonthDisabled(monthDateType);
                 const inRange = isMonthInRange && isMonthInRange(monthDateType);
                 const onClick = onClickProp ? () => { onClickProp(monthDateType); } : undefined;
                 const onMouseEnter = onMonthHover ? () => { onMonthHover(monthDateType); } : undefined;
-                return (jsx("button", Object.assign({ type: "button", "aria-disabled": disabled, disabled: disabled, className: cx(calendarClasses.button, {
+                return (jsx("button", { type: "button", "aria-disabled": disabled, disabled: disabled, className: cx(calendarClasses.button, {
                         [calendarClasses.buttonActive]: active,
                         [calendarClasses.buttonInRange]: inRange,
                         [calendarClasses.buttonDisabled]: disabled,
-                    }), onClick: onClick, onMouseEnter: onMouseEnter }, { children: monthNames[month] }), month));
-            }) }), void 0) }), void 0));
+                    }), onClick: onClick, onMouseEnter: onMouseEnter, children: monthNames[month] }, month));
+            }) }) }));
 }
 
 export { CalendarMonths as default };

package/Calendar/CalendarWeeks.js

@@ -15,8 +15,7 @@ function CalendarWeeks(props) {
     const { displayWeekDayLocale: displayWeekDayLocaleFromConfig, getCalendarGrid, getDate, getMonth, getNow, isInMonth, isSameDate, isWeekIncluded, setDate, setMonth, } = useCalendarContext();
     const { className, displayWeekDayLocale = displayWeekDayLocaleFromConfig, isWeekDisabled, isWeekInRange, onClick: onClickProp, onWeekHover, referenceDate, value, ...rest } = props;
     const daysGrid = useMemo(() => getCalendarGrid(referenceDate), [getCalendarGrid, referenceDate]);
-    return (jsxs("div", Object.assign({}, rest, { className: cx(calendarClasses.board, className) }, { children: [jsx(CalendarDayOfWeek, { displayWeekDayLocale: displayWeekDayLocale }, void 0),
-            daysGrid.map((week, index) => {
+    return (jsxs("div", { ...rest, className: cx(calendarClasses.board, className), children: [jsx(CalendarDayOfWeek, { displayWeekDayLocale: displayWeekDayLocale }), daysGrid.map((week, index) => {
                 const dates = [];
                 const weekStartInPrevMonth = index === 0 && week[0] > 7;
                 const weekStartInNextMonth = index > 3 && week[0] <= 14;
@@ -43,12 +42,12 @@ function CalendarWeeks(props) {
                 const onClick = onClickProp ? () => {
                     onClickProp(dates[0]);
                 } : undefined;
-                return (jsx("button", Object.assign({ type: "button", className: cx(calendarClasses.button, calendarClasses.row, {
+                return (jsx("button", { type: "button", className: cx(calendarClasses.button, calendarClasses.row, {
                         [calendarClasses.buttonActive]: active,
                         [calendarClasses.buttonInRange]: inRange,
                         [calendarClasses.buttonDisabled]: disabled,
-                    }), disabled: disabled, "aria-disabled": disabled, onClick: onClick, onMouseEnter: onMouseEnter }, { children: week.map((dateNum, dateIndex) => (jsx(CalendarCell, Object.assign({ today: isSameDate(dates[dateIndex], getNow()), disabled: disabled || !isInMonth(dates[dateIndex], getMonth(referenceDate)), active: active }, { children: dateNum }), `${getMonth(dates[dateIndex])}/${getDate(dates[dateIndex])}`))) }), `CALENDAR_WEEKS/WEEK_OF/${index}`));
-            })] }), void 0));
+                    }), disabled: disabled, "aria-disabled": disabled, onClick: onClick, onMouseEnter: onMouseEnter, children: week.map((dateNum, dateIndex) => (jsx(CalendarCell, { today: isSameDate(dates[dateIndex], getNow()), disabled: disabled || !isInMonth(dates[dateIndex], getMonth(referenceDate)), active: active, children: dateNum }, `${getMonth(dates[dateIndex])}/${getDate(dates[dateIndex])}`))) }, `CALENDAR_WEEKS/WEEK_OF/${index}`));
+            })] }));
 }
 
 export { CalendarWeeks as default };

package/Calendar/CalendarYears.js

@@ -13,7 +13,7 @@ function CalendarYears(props) {
     const { getNow, getYear, isYearIncluded, setYear, } = useCalendarContext();
     const { className, isYearDisabled, isYearInRange, onClick: onClickProp, onYearHover, referenceDate, value, ...rest } = props;
     const [start] = useMemo(() => getCalendarYearRange(getYear(referenceDate)), [getYear, referenceDate]);
-    return (jsx("div", Object.assign({ className: cx(calendarClasses.board, className) }, rest, { children: jsx("div", Object.assign({ className: calendarClasses.twelveGrid }, { children: calendarYearsBase.map((base) => {
+    return (jsx("div", { className: cx(calendarClasses.board, className), ...rest, children: jsx("div", { className: calendarClasses.twelveGrid, children: calendarYearsBase.map((base) => {
                 const thisYear = base + start;
                 const yearDateType = setYear(getNow(), thisYear);
                 const disabled = isYearDisabled && isYearDisabled(yearDateType);
@@ -22,13 +22,13 @@ function CalendarYears(props) {
                 const inRange = isYearInRange && isYearInRange(yearDateType);
                 const onClick = onClickProp ? () => { onClickProp(yearDateType); } : undefined;
                 const onMouseEnter = onYearHover ? () => { onYearHover(yearDateType); } : undefined;
-                return (jsx("button", Object.assign({ type: "button", "aria-disabled": disabled, disabled: disabled, className: cx(calendarClasses.button, {
+                return (jsx("button", { type: "button", "aria-disabled": disabled, disabled: disabled, className: cx(calendarClasses.button, {
                         [calendarClasses.buttonActive]: active,
                         [calendarClasses.buttonInRange]: inRange,
                         [calendarClasses.buttonDisabled]: disabled,
                         [calendarClasses.buttonInactive]: inactive,
-                    }), onClick: onClick, onMouseEnter: onMouseEnter }, { children: thisYear }), base + start));
-            }) }), void 0) }), void 0));
+                    }), onClick: onClick, onMouseEnter: onMouseEnter, children: thisYear }, base + start));
+            }) }) }));
 }
 
 export { CalendarYears as default };

package/Calendar/useCalendarControls.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="moment" />
 /// <reference types="react" />
 import { DateType, CalendarMode } from '@mezzanine-ui/core/calendar';
 export declare function useCalendarControls(referenceDateProp: DateType, mode?: CalendarMode): {
@@ -8,6 +7,6 @@ export declare function useCalendarControls(referenceDateProp: DateType, mode?:
     onPrev: () => void;
     onYearControlClick: () => void;
     popModeStack: () => void;
-    referenceDate: import("moment").Moment;
-    updateReferenceDate: import("react").Dispatch<import("react").SetStateAction<import("moment").Moment>>;
+    referenceDate: string;
+    updateReferenceDate: import("react").Dispatch<import("react").SetStateAction<string>>;
 };

package/Card/Card.js

@@ -10,11 +10,11 @@ import cx from 'clsx';
 const Card = forwardRef(function Card(props, ref) {
     const { actions, className, contentProps, cover, description, descriptionProps, metaProps, subtitle, subtitleProps, title, titleProps, ...rest } = props;
     const { variant = 'h3', } = titleProps || {};
-    const titleTypography = (title ? (jsx(Typography, Object.assign({ variant: variant }, titleProps, { children: title }), void 0)) : null);
-    const subtitleTypography = (subtitle ? (jsx(Typography, Object.assign({}, subtitleProps, { children: subtitle }), void 0)) : null);
-    const contentHeader = (titleTypography || subtitleTypography ? (jsxs("div", Object.assign({ className: cardClasses.metaContentsHeader }, { children: [titleTypography, subtitleTypography] }), void 0)) : null);
-    const descriptionTypography = (description ? (jsx(Typography, Object.assign({}, descriptionProps, { children: description }), void 0)) : null);
-    return (jsxs("div", Object.assign({ ref: ref, className: cx(cardClasses.host, className) }, rest, { children: [cover, jsxs("div", Object.assign({ className: cardClasses.meta }, metaProps, { children: [jsxs("div", Object.assign({ className: cardClasses.metaContents }, contentProps, { children: [contentHeader, descriptionTypography] }), void 0), actions] }), void 0)] }), void 0));
+    const titleTypography = (title ? (jsx(Typography, { variant: variant, ...titleProps, children: title })) : null);
+    const subtitleTypography = (subtitle ? (jsx(Typography, { ...subtitleProps, children: subtitle })) : null);
+    const contentHeader = (titleTypography || subtitleTypography ? (jsxs("div", { className: cardClasses.metaContentsHeader, children: [titleTypography, subtitleTypography] })) : null);
+    const descriptionTypography = (description ? (jsx(Typography, { ...descriptionProps, children: description })) : null);
+    return (jsxs("div", { ref: ref, className: cx(cardClasses.host, className), ...rest, children: [cover, jsxs("div", { className: cardClasses.meta, ...metaProps, children: [jsxs("div", { className: cardClasses.metaContents, ...contentProps, children: [contentHeader, descriptionTypography] }), actions] })] }));
 });
 var Card$1 = Card;
 

package/Card/CardActions.js

@@ -9,8 +9,7 @@ import cx from 'clsx';
  */
 const CardActions = forwardRef(function CardActions(props, ref) {
     const { cancelText, cancelButtonProps, className, confirmText, confirmButtonProps, hideCancelButton, hideConfirmButton, loading, onCancel, onConfirm, otherActions, ...rest } = props;
-    return (jsxs("div", Object.assign({ ref: ref, className: cx(cardActionsClasses.host, className) }, rest, { children: [otherActions || (jsx("div", {}, void 0)),
-            jsx(ConfirmActions, { cancelText: cancelText, confirmText: confirmText, cancelButtonProps: cancelButtonProps, confirmButtonProps: confirmButtonProps, hideCancelButton: hideCancelButton || !cancelText, hideConfirmButton: hideConfirmButton || !confirmText, loading: loading }, void 0)] }), void 0));
+    return (jsxs("div", { ref: ref, className: cx(cardActionsClasses.host, className), ...rest, children: [otherActions || (jsx("div", {})), jsx(ConfirmActions, { cancelText: cancelText, confirmText: confirmText, cancelButtonProps: cancelButtonProps, confirmButtonProps: confirmButtonProps, hideCancelButton: hideCancelButton || !cancelText, hideConfirmButton: hideConfirmButton || !confirmText, loading: loading })] }));
 });
 var CardActions$1 = CardActions;
 

package/Checkbox/CheckAll.js

@@ -19,7 +19,7 @@ const CheckAll = forwardRef(function CheckAll(props, ref) {
         allChecked = enabledOptions.length === value.length;
         indeterminate = enabledOptions.length > value.length && value.length > 0;
     }
-    return (jsxs("div", Object.assign({}, rest, { ref: ref, className: cx(checkboxClasses.all, className) }, { children: [jsx("div", { children: jsx(Checkbox, Object.assign({ checked: allChecked, disabled: disabled, indeterminate: indeterminate, inputProps: {
+    return (jsxs("div", { ...rest, ref: ref, className: cx(checkboxClasses.all, className), children: [jsx("div", { children: jsx(Checkbox, { checked: allChecked, disabled: disabled, indeterminate: indeterminate, inputProps: {
                         name,
                     }, onChange: (event) => {
                         if (onChange) {
@@ -30,7 +30,7 @@ const CheckAll = forwardRef(function CheckAll(props, ref) {
                                 onChange(enabledOptions.map((option) => option.value), event);
                             }
                         }
-                    }, size: size }, { children: label }), void 0) }, void 0), children] }), void 0));
+                    }, size: size, children: label }) }), children] }));
 });
 var CheckAll$1 = CheckAll;
 

package/Checkbox/Checkbox.js

@@ -24,10 +24,10 @@ const Checkbox = forwardRef(function Checkbox(props, ref) {
         value,
     });
     const indeterminate = !checked && indeterminateProp;
-    return (jsx(InputCheck, Object.assign({}, rest, { ref: ref, control: (jsx("span", Object.assign({ className: cx(checkboxClasses.host, {
+    return (jsx(InputCheck, { ...rest, ref: ref, control: (jsx("span", { className: cx(checkboxClasses.host, {
                 [checkboxClasses.checked]: checked,
                 [checkboxClasses.indeterminate]: indeterminate,
-            }) }, { children: jsx("input", Object.assign({}, restInputProps, { "aria-checked": indeterminate ? 'mixed' : checked, "aria-disabled": disabled, checked: checked, disabled: disabled, id: inputId, onChange: onChange, name: name, type: "checkbox", value: value }), void 0) }), void 0)), disabled: disabled, error: error, htmlFor: inputId, size: size }, { children: children }), void 0));
+            }), children: jsx("input", { ...restInputProps, "aria-checked": indeterminate ? 'mixed' : checked, "aria-disabled": disabled, checked: checked, disabled: disabled, id: inputId, onChange: onChange, name: name, type: "checkbox", value: value }) })), disabled: disabled, error: error, htmlFor: inputId, size: size, children: children }));
 });
 var Checkbox$1 = Checkbox;
 

package/Checkbox/CheckboxGroup.js

@@ -5,7 +5,7 @@ import { CheckboxGroupContext } from './CheckboxGroupContext.js';
 import Checkbox from './Checkbox.js';
 import InputCheckGroup from '../_internal/InputCheck/InputCheckGroup.js';
 
-const renderOption = ({ label: children, ...option }) => (createElement(Checkbox, Object.assign({}, option, { key: option.value }), children));
+const renderOption = ({ label: children, ...option }) => (createElement(Checkbox, { ...option, key: option.value }, children));
 /**
  * The react component for `mezzanine` checkbox group.
  */
@@ -30,7 +30,7 @@ const CheckboxGroup = forwardRef(function CheckboxGroup(props, ref) {
         value,
     };
     const children = childrenProp || options.map(renderOption);
-    return (jsx(CheckboxGroupContext.Provider, Object.assign({ value: context }, { children: jsx(InputCheckGroup, Object.assign({}, rest, { ref: ref }, { children: children }), void 0) }), void 0));
+    return (jsx(CheckboxGroupContext.Provider, { value: context, children: jsx(InputCheckGroup, { ...rest, ref: ref, children: children }) }));
 });
 var CheckboxGroup$1 = CheckboxGroup;
 

package/ConfirmActions/ConfirmActions.js

@@ -9,8 +9,7 @@ import ButtonGroup from '../Button/ButtonGroup.js';
 const ConfirmActions = forwardRef(function ConfirmActions(props, ref) {
     const { cancelButtonProps, cancelText, confirmButtonProps, confirmText, hideCancelButton, hideConfirmButton, loading, onCancel, onConfirm, ...rest } = props;
     const { disabled: cancelButtonDisabled = loading, } = cancelButtonProps || {};
-    return (jsxs(ButtonGroup, Object.assign({}, rest, { ref: ref }, { children: [!hideCancelButton && (jsx(Button, Object.assign({ variant: "outlined" }, cancelButtonProps, { disabled: cancelButtonDisabled, onClick: onCancel }, { children: cancelText }), void 0)),
-            !hideConfirmButton && (jsx(Button, Object.assign({ variant: "contained" }, confirmButtonProps, { loading: loading, onClick: onConfirm }, { children: confirmText }), void 0))] }), void 0));
+    return (jsxs(ButtonGroup, { ...rest, ref: ref, children: [!hideCancelButton && (jsx(Button, { variant: "outlined", ...cancelButtonProps, disabled: cancelButtonDisabled, onClick: onCancel, children: cancelText })), !hideConfirmButton && (jsx(Button, { variant: "contained", ...confirmButtonProps, loading: loading, onClick: onConfirm, children: confirmText }))] }));
 });
 var ConfirmActions$1 = ConfirmActions;
 

package/DatePicker/DatePicker.js

@@ -127,9 +127,8 @@ const DatePicker = forwardRef(function DatePicker(props, ref) {
         }
         onCalendarToggle(!open);
     };
-    const suffixActionIcon = (jsx(Icon, { icon: CalendarIcon, onClick: onIconClick }, void 0));
-    return (jsxs(Fragment, { children: [jsx(PickerTrigger, Object.assign({}, restTriggerProps, { ref: triggerComposedRef, className: className, clearable: clearable, disabled: disabled, error: error, fullWidth: fullWidth, inputProps: resolvedInputProps, inputRef: inputRef, onChange: onInputChange, onClear: onClear, placeholder: placeholder, prefix: prefix, readOnly: readOnly, required: required, size: size, suffixActionIcon: suffixActionIcon, value: inputValue }), void 0),
-            jsx(DatePickerCalendar, { ref: calendarRef, anchor: anchorRef, calendarProps: calendarProps, disableOnNext: disableOnNext, disableOnPrev: disableOnPrev, displayMonthLocale: displayMonthLocale, fadeProps: fadeProps, isDateDisabled: isDateDisabled, isMonthDisabled: isMonthDisabled, isYearDisabled: isYearDisabled, mode: mode, onChange: onCalendarChange, open: open, popperProps: popperProps, referenceDate: referenceDate, value: internalValue }, void 0)] }, void 0));
+    const suffixActionIcon = (jsx(Icon, { icon: CalendarIcon, onClick: onIconClick }));
+    return (jsxs(Fragment, { children: [jsx(PickerTrigger, { ...restTriggerProps, ref: triggerComposedRef, className: className, clearable: clearable, disabled: disabled, error: error, fullWidth: fullWidth, inputProps: resolvedInputProps, inputRef: inputRef, onChange: onInputChange, onClear: onClear, placeholder: placeholder, prefix: prefix, readOnly: readOnly, required: required, size: size, suffixActionIcon: suffixActionIcon, value: inputValue }), jsx(DatePickerCalendar, { ref: calendarRef, anchor: anchorRef, calendarProps: calendarProps, disableOnNext: disableOnNext, disableOnPrev: disableOnPrev, displayMonthLocale: displayMonthLocale, fadeProps: fadeProps, isDateDisabled: isDateDisabled, isMonthDisabled: isMonthDisabled, isYearDisabled: isYearDisabled, mode: mode, onChange: onCalendarChange, open: open, popperProps: popperProps, referenceDate: referenceDate, value: internalValue })] }));
 });
 var DatePicker$1 = DatePicker;
 

package/DatePicker/DatePickerCalendar.js

@@ -55,7 +55,7 @@ const DatePickerCalendar = forwardRef(function DatePickerCalendar(props, ref) {
         setYear,
         getYear,
     ]);
-    return (jsx(InputTriggerPopper, Object.assign({}, popperProps, { ref: ref, anchor: anchor, open: open, fadeProps: fadeProps }, { children: jsx(Calendar, Object.assign({}, restCalendarProps, { ref: calendarRef, className: calendarClassName, disableOnNext: disableOnNext, disableOnPrev: disableOnPrev, displayMonthLocale: displayMonthLocale, isDateDisabled: isDateDisabled, isMonthDisabled: isMonthDisabled, isYearDisabled: isYearDisabled, mode: currentMode, onChange: onChange, onMonthControlClick: onMonthControlClick, onNext: onNext, onPrev: onPrev, onYearControlClick: onYearControlClick, referenceDate: referenceDate, value: value }), void 0) }), void 0));
+    return (jsx(InputTriggerPopper, { ...popperProps, ref: ref, anchor: anchor, open: open, fadeProps: fadeProps, children: jsx(Calendar, { ...restCalendarProps, ref: calendarRef, className: calendarClassName, disableOnNext: disableOnNext, disableOnPrev: disableOnPrev, displayMonthLocale: displayMonthLocale, isDateDisabled: isDateDisabled, isMonthDisabled: isMonthDisabled, isYearDisabled: isYearDisabled, mode: currentMode, onChange: onChange, onMonthControlClick: onMonthControlClick, onNext: onNext, onPrev: onPrev, onYearControlClick: onYearControlClick, referenceDate: referenceDate, value: value }) }));
 });
 var DatePickerCalendar$1 = DatePickerCalendar;
 

package/DateRangePicker/DateRangePicker.js

@@ -181,9 +181,8 @@ const DateRangePicker = forwardRef(function DateRangePicker(props, ref) {
         }
         onCalendarToggle(!open);
     };
-    const suffixActionIcon = (jsx(Icon, { icon: CalendarIcon, onClick: onIconClick }, void 0));
-    return (jsxs(Fragment, { children: [jsx(RangePickerTrigger, { ref: triggerComposedRef, className: className, clearable: clearable, disabled: disabled, error: error, fullWidth: fullWidth, inputFromPlaceholder: inputFromPlaceholder, inputFromProps: resolvedInputFromProps, inputFromRef: inputFromRef, inputFromValue: inputFromValue, inputToPlaceholder: inputToPlaceholder, inputToProps: resolvedInputToProps, inputToRef: inputToRef, inputToValue: inputToValue, onClear: onClear, onInputFromChange: onInputFromChange, onInputToChange: onInputToChange, prefix: prefix, readOnly: readOnly, required: required, size: size, suffixActionIcon: suffixActionIcon }, void 0),
-            jsx(DateRangePickerCalendar, { ref: calendarRef, open: open, anchor: anchorRef, calendarProps: calendarProps, displayMonthLocale: displayMonthLocale, fadeProps: fadeProps, isDateDisabled: isDateDisabled, isDateInRange: getIsInRangeHandler('date'), isMonthDisabled: isMonthDisabled, isMonthInRange: getIsInRangeHandler('month'), isWeekInRange: getIsInRangeHandler('week'), isYearDisabled: isYearDisabled, isYearInRange: getIsInRangeHandler('year'), mode: mode, onChange: onCalendarChangeWithCloseControl, onDateHover: onCalendarHover, onWeekHover: onCalendarHover, onMonthHover: onCalendarHover, onYearHover: onCalendarHover, popperProps: popperProps, referenceDate: referenceDate, value: calendarValue }, void 0)] }, void 0));
+    const suffixActionIcon = (jsx(Icon, { icon: CalendarIcon, onClick: onIconClick }));
+    return (jsxs(Fragment, { children: [jsx(RangePickerTrigger, { ref: triggerComposedRef, className: className, clearable: clearable, disabled: disabled, error: error, fullWidth: fullWidth, inputFromPlaceholder: inputFromPlaceholder, inputFromProps: resolvedInputFromProps, inputFromRef: inputFromRef, inputFromValue: inputFromValue, inputToPlaceholder: inputToPlaceholder, inputToProps: resolvedInputToProps, inputToRef: inputToRef, inputToValue: inputToValue, onClear: onClear, onInputFromChange: onInputFromChange, onInputToChange: onInputToChange, prefix: prefix, readOnly: readOnly, required: required, size: size, suffixActionIcon: suffixActionIcon }), jsx(DateRangePickerCalendar, { ref: calendarRef, open: open, anchor: anchorRef, calendarProps: calendarProps, displayMonthLocale: displayMonthLocale, fadeProps: fadeProps, isDateDisabled: isDateDisabled, isDateInRange: getIsInRangeHandler('date'), isMonthDisabled: isMonthDisabled, isMonthInRange: getIsInRangeHandler('month'), isWeekInRange: getIsInRangeHandler('week'), isYearDisabled: isYearDisabled, isYearInRange: getIsInRangeHandler('year'), mode: mode, onChange: onCalendarChangeWithCloseControl, onDateHover: onCalendarHover, onWeekHover: onCalendarHover, onMonthHover: onCalendarHover, onYearHover: onCalendarHover, popperProps: popperProps, referenceDate: referenceDate, value: calendarValue })] }));
 });
 var DateRangePicker$1 = DateRangePicker;
 

package/DateRangePicker/DateRangePickerCalendar.js

@@ -87,12 +87,11 @@ const DateRangePickerCalendar = forwardRef(function DateRangePickerCalendar(prop
     }, [onYearControlClickFromHook]);
     const isSettingFirstCalendar = currentMode !== mode && controlPanelOnLeft;
     const isSettingSecondCalendar = currentMode !== mode && !controlPanelOnLeft;
-    return (jsx(InputTriggerPopper, Object.assign({}, popperProps, { ref: ref, anchor: anchor, open: open, fadeProps: fadeProps }, { children: jsxs("div", Object.assign({ className: dateRangePickerClasses.calendarGroup }, { children: [jsx(Calendar, Object.assign({}, restCalendarProps, { className: cx(dateRangePickerClasses.calendar, {
+    return (jsx(InputTriggerPopper, { ...popperProps, ref: ref, anchor: anchor, open: open, fadeProps: fadeProps, children: jsxs("div", { className: dateRangePickerClasses.calendarGroup, children: [jsx(Calendar, { ...restCalendarProps, className: cx(dateRangePickerClasses.calendar, {
                         [dateRangePickerClasses.calendarInactive]: isSettingSecondCalendar,
-                    }, className), displayMonthLocale: displayMonthLocale, isDateDisabled: isDateDisabled, isDateInRange: isDateInRange, isMonthDisabled: isMonthDisabled, isMonthInRange: isMonthInRange, isWeekInRange: isWeekInRange, isYearDisabled: isYearDisabled, isYearInRange: isYearInRange, mode: controlPanelOnLeft ? currentMode : mode, onChange: onChangeFactory(0), onDateHover: currentMode === mode ? onDateHover : undefined, onMonthHover: currentMode === mode ? onMonthHover : undefined, onWeekHover: currentMode === mode ? onWeekHover : undefined, onYearHover: currentMode === mode ? onYearHover : undefined, onMonthControlClick: onMonthControlClickFactory(0), onNext: isSettingFirstCalendar ? onFirstNext : undefined, onPrev: onFirstPrev, onYearControlClick: onYearControlClickFactory(0), ref: firstCalendarRef, referenceDate: referenceDates[0], value: isSettingFirstCalendar ? referenceDates[0] : value }), void 0),
-                jsx(Calendar, Object.assign({}, restCalendarProps, { className: cx(dateRangePickerClasses.calendar, {
+                    }, className), displayMonthLocale: displayMonthLocale, isDateDisabled: isDateDisabled, isDateInRange: isDateInRange, isMonthDisabled: isMonthDisabled, isMonthInRange: isMonthInRange, isWeekInRange: isWeekInRange, isYearDisabled: isYearDisabled, isYearInRange: isYearInRange, mode: controlPanelOnLeft ? currentMode : mode, onChange: onChangeFactory(0), onDateHover: currentMode === mode ? onDateHover : undefined, onMonthHover: currentMode === mode ? onMonthHover : undefined, onWeekHover: currentMode === mode ? onWeekHover : undefined, onYearHover: currentMode === mode ? onYearHover : undefined, onMonthControlClick: onMonthControlClickFactory(0), onNext: isSettingFirstCalendar ? onFirstNext : undefined, onPrev: onFirstPrev, onYearControlClick: onYearControlClickFactory(0), ref: firstCalendarRef, referenceDate: referenceDates[0], value: isSettingFirstCalendar ? referenceDates[0] : value }), jsx(Calendar, { ...restCalendarProps, className: cx(dateRangePickerClasses.calendar, {
                         [dateRangePickerClasses.calendarInactive]: isSettingFirstCalendar,
-                    }, className), displayMonthLocale: displayMonthLocale, isDateDisabled: isDateDisabled, isDateInRange: isDateInRange, isMonthDisabled: isMonthDisabled, isMonthInRange: isMonthInRange, isWeekInRange: isWeekInRange, isYearDisabled: isYearDisabled, isYearInRange: isYearInRange, mode: !controlPanelOnLeft ? currentMode : mode, onChange: onChangeFactory(1), onDateHover: currentMode === mode ? onDateHover : undefined, onMonthHover: currentMode === mode ? onMonthHover : undefined, onWeekHover: currentMode === mode ? onWeekHover : undefined, onYearHover: currentMode === mode ? onYearHover : undefined, onMonthControlClick: onMonthControlClickFactory(1), onNext: onSecondNext, onPrev: isSettingSecondCalendar ? onSecondPrev : undefined, onYearControlClick: onYearControlClickFactory(1), ref: secondCalendarRef, referenceDate: referenceDates[1], value: isSettingSecondCalendar ? referenceDates[1] : value }), void 0)] }), void 0) }), void 0));
+                    }, className), displayMonthLocale: displayMonthLocale, isDateDisabled: isDateDisabled, isDateInRange: isDateInRange, isMonthDisabled: isMonthDisabled, isMonthInRange: isMonthInRange, isWeekInRange: isWeekInRange, isYearDisabled: isYearDisabled, isYearInRange: isYearInRange, mode: !controlPanelOnLeft ? currentMode : mode, onChange: onChangeFactory(1), onDateHover: currentMode === mode ? onDateHover : undefined, onMonthHover: currentMode === mode ? onMonthHover : undefined, onWeekHover: currentMode === mode ? onWeekHover : undefined, onYearHover: currentMode === mode ? onYearHover : undefined, onMonthControlClick: onMonthControlClickFactory(1), onNext: onSecondNext, onPrev: isSettingSecondCalendar ? onSecondPrev : undefined, onYearControlClick: onYearControlClickFactory(1), ref: secondCalendarRef, referenceDate: referenceDates[1], value: isSettingSecondCalendar ? referenceDates[1] : value })] }) }));
 });
 var DateRangePickerCalendar$1 = DateRangePickerCalendar;
 

package/DateRangePicker/useDateRangeCalendarControls.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="moment" />
 import { DateType, CalendarMode } from '@mezzanine-ui/core/calendar';
 export declare function useDateRangeCalendarControls(referenceDate: DateType, mode: CalendarMode): {
     currentMode: CalendarMode;
@@ -9,7 +8,7 @@ export declare function useDateRangeCalendarControls(referenceDate: DateType, mo
     onSecondPrev: () => void;
     onYearControlClick: () => void;
     popModeStack: () => void;
-    referenceDates: import("moment").Moment[];
+    referenceDates: string[];
     updateFirstReferenceDate: (date: DateType) => void;
     updateSecondReferenceDate: (date: DateType) => void;
 };

package/DateRangePicker/useDateRangePickerValue.d.ts

@@ -1,23 +1,22 @@
-/// <reference types="moment" />
-/// <reference types="react" />
 import { RangePickerPickingValue, RangePickerValue } from '@mezzanine-ui/core/picker';
+import { ChangeEventHandler, KeyboardEventHandler } from 'react';
 import { UseRangePickerValueProps } from '../Picker/useRangePickerValue';
 export interface UseDateRangePickerValueProps extends Omit<UseRangePickerValueProps, 'onChange'> {
     onChange?: (value?: RangePickerValue) => void;
 }
 export declare function useDateRangePickerValue({ format, formats, inputFromRef, inputToRef, onChange: onChangeProp, value: valueProp, }: UseDateRangePickerValueProps): {
-    calendarValue: import("moment").Moment[] | undefined;
+    calendarValue: string[] | undefined;
     inputFromValue: string;
     inputToValue: string;
-    onCalendarChange: (val?: import("moment").Moment | undefined) => void;
-    onCalendarHover: import("react").Dispatch<import("react").SetStateAction<import("moment").Moment | undefined>> | undefined;
-    onChange: (target?: undefined[] | [import("moment").Moment, import("moment").Moment] | [import("moment").Moment] | [undefined, import("moment").Moment] | [import("moment").Moment, undefined] | undefined) => undefined[] | [import("moment").Moment, import("moment").Moment] | [import("moment").Moment] | [undefined, import("moment").Moment] | [import("moment").Moment, undefined] | undefined;
+    onCalendarChange: (val?: string | undefined) => void;
+    onCalendarHover: import("react").Dispatch<import("react").SetStateAction<string | undefined>> | undefined;
+    onChange: (target?: RangePickerPickingValue<string> | undefined) => RangePickerPickingValue<string> | undefined;
     onClear: () => void;
-    onFromBlur: (event: import("react").FocusEvent<HTMLInputElement, Element>) => void;
-    onFromKeyDown: (event: import("react").KeyboardEvent<HTMLInputElement>) => void;
-    onInputFromChange: (event: import("react").ChangeEvent<HTMLInputElement>) => void;
-    onInputToChange: (event: import("react").ChangeEvent<HTMLInputElement>) => void;
-    onToBlur: (event: import("react").FocusEvent<HTMLInputElement, Element>) => void;
-    onToKeyDown: (event: import("react").KeyboardEvent<HTMLInputElement>) => void;
-    value: RangePickerPickingValue;
+    onFromBlur: import("react").FocusEventHandler<HTMLInputElement>;
+    onFromKeyDown: KeyboardEventHandler<HTMLInputElement>;
+    onInputFromChange: ChangeEventHandler<HTMLInputElement>;
+    onInputToChange: ChangeEventHandler<HTMLInputElement>;
+    onToBlur: import("react").FocusEventHandler<HTMLInputElement>;
+    onToKeyDown: KeyboardEventHandler<HTMLInputElement>;
+    value: RangePickerPickingValue<string>;
 };

package/DateTimePicker/DateTimePicker.js

@@ -114,9 +114,8 @@ const DateTimePicker = forwardRef(function DateTimePicker(props, ref) {
         }
         onPanelToggle(!open);
     };
-    const suffixActionIcon = (jsx(Icon, { icon: ClockIcon, onClick: onIconClick }, void 0));
-    return (jsxs(Fragment, { children: [jsx(PickerTrigger, { ref: triggerComposedRef, className: className, clearable: clearable, disabled: disabled, error: error, fullWidth: fullWidth, inputProps: resolvedInputProps, inputRef: inputRef, onChange: onInputChange, onClear: onClear, placeholder: placeholder, prefix: prefix, readOnly: readOnly, required: required, size: sizeProp, suffixActionIcon: suffixActionIcon, value: inputValue }, void 0),
-            jsx(DateTimePickerPanel, { ref: panelRef, anchor: anchorRef, calendarProps: calendarProps, confirmText: confirmText, disableOnNext: disableOnNext, disableOnPrev: disableOnPrev, displayMonthLocale: displayMonthLocale, fadeProps: fadeProps, hideHour: hideHour, hideMinute: hideMinute, hideSecond: hideSecond, hourPrefix: hourPrefix, hourStep: hourStep, isDateDisabled: isDateDisabled, isMonthDisabled: isMonthDisabled, isYearDisabled: isYearDisabled, minutePrefix: minutePrefix, minuteStep: minuteStep, onChange: onChange, onConfirm: onConfirm, open: open, popperProps: popperProps, referenceDate: referenceDate, secondPrefix: secondPrefix, secondStep: secondStep, value: internalValue }, void 0)] }, void 0));
+    const suffixActionIcon = (jsx(Icon, { icon: ClockIcon, onClick: onIconClick }));
+    return (jsxs(Fragment, { children: [jsx(PickerTrigger, { ref: triggerComposedRef, className: className, clearable: clearable, disabled: disabled, error: error, fullWidth: fullWidth, inputProps: resolvedInputProps, inputRef: inputRef, onChange: onInputChange, onClear: onClear, placeholder: placeholder, prefix: prefix, readOnly: readOnly, required: required, size: sizeProp, suffixActionIcon: suffixActionIcon, value: inputValue }), jsx(DateTimePickerPanel, { ref: panelRef, anchor: anchorRef, calendarProps: calendarProps, confirmText: confirmText, disableOnNext: disableOnNext, disableOnPrev: disableOnPrev, displayMonthLocale: displayMonthLocale, fadeProps: fadeProps, hideHour: hideHour, hideMinute: hideMinute, hideSecond: hideSecond, hourPrefix: hourPrefix, hourStep: hourStep, isDateDisabled: isDateDisabled, isMonthDisabled: isMonthDisabled, isYearDisabled: isYearDisabled, minutePrefix: minutePrefix, minuteStep: minuteStep, onChange: onChange, onConfirm: onConfirm, open: open, popperProps: popperProps, referenceDate: referenceDate, secondPrefix: secondPrefix, secondStep: secondStep, value: internalValue })] }));
 });
 var DateTimePicker$1 = DateTimePicker;
 

package/DateTimePicker/DateTimePickerPanel.js

@@ -43,9 +43,7 @@ const DateTimePickerPanel = forwardRef(function TimePickerPanel(props, ref) {
             onChangeProp(result);
         }
     };
-    return (jsx(InputTriggerPopper, Object.assign({}, popperProps, { ref: ref, anchor: anchor, open: open, fadeProps: fadeProps }, { children: jsxs("div", Object.assign({}, restHostProps, { className: cx(dateTimePickerClasses.panel, className) }, { children: [jsxs("div", Object.assign({ className: dateTimePickerClasses.panelSelectors }, { children: [jsx(Calendar, Object.assign({}, calendarProps, { disableOnNext: disableOnNext, disableOnPrev: disableOnPrev, displayMonthLocale: displayMonthLocale, isDateDisabled: isDateDisabled, isMonthDisabled: isMonthDisabled, isYearDisabled: isYearDisabled, mode: currentMode, onChange: onCalendarChange, onMonthControlClick: onMonthControlClick, onNext: onNext, onPrev: onPrev, onYearControlClick: onYearControlClick, referenceDate: referenceDate, value: value, className: dateTimePickerClasses.panelCalendar }), void 0),
-                        jsx(TimePanel, { hideHour: hideHour, hourStep: hourStep, hideMinute: hideMinute, minuteStep: minuteStep, hideSecond: hideSecond, secondStep: secondStep, hourPrefix: hourPrefix, minutePrefix: minutePrefix, secondPrefix: secondPrefix, onChange: onTimePanelChange, value: value, withoutAction: true }, void 0)] }), void 0),
-                jsx(TimePanelAction, { onConfirm: onConfirm, confirmText: confirmText }, void 0)] }), void 0) }), void 0));
+    return (jsx(InputTriggerPopper, { ...popperProps, ref: ref, anchor: anchor, open: open, fadeProps: fadeProps, children: jsxs("div", { ...restHostProps, className: cx(dateTimePickerClasses.panel, className), children: [jsxs("div", { className: dateTimePickerClasses.panelSelectors, children: [jsx(Calendar, { ...calendarProps, disableOnNext: disableOnNext, disableOnPrev: disableOnPrev, displayMonthLocale: displayMonthLocale, isDateDisabled: isDateDisabled, isMonthDisabled: isMonthDisabled, isYearDisabled: isYearDisabled, mode: currentMode, onChange: onCalendarChange, onMonthControlClick: onMonthControlClick, onNext: onNext, onPrev: onPrev, onYearControlClick: onYearControlClick, referenceDate: referenceDate, value: value, className: dateTimePickerClasses.panelCalendar }), jsx(TimePanel, { hideHour: hideHour, hourStep: hourStep, hideMinute: hideMinute, minuteStep: minuteStep, hideSecond: hideSecond, secondStep: secondStep, hourPrefix: hourPrefix, minutePrefix: minutePrefix, secondPrefix: secondPrefix, onChange: onTimePanelChange, value: value, withoutAction: true })] }), jsx(TimePanelAction, { onConfirm: onConfirm, confirmText: confirmText })] }) }));
 });
 var DateTimePickerPanel$1 = DateTimePickerPanel;
 

package/Drawer/Drawer.js

@@ -12,7 +12,7 @@ const Drawer = forwardRef((props, ref) => {
         right: 'left',
         bottom: 'up',
     }), []);
-    return (jsx(SlideFadeOverlay, Object.assign({ className: drawerClasses.overlay, container: container, direction: slideFadeDirection[placement], disableCloseOnBackdropClick: disableCloseOnBackdropClick, disableCloseOnEscapeKeyDown: disableCloseOnEscapeKeyDown, disablePortal: disablePortal, hideBackdrop: hideBackdrop, invisibleBackdrop: invisibleBackdrop, onBackdropClick: onBackdropClick, onClose: onClose, open: open, ref: ref }, { children: jsx("div", Object.assign({}, rest, { className: cx(drawerClasses.host, drawerClasses[placement], className) }, { children: children }), void 0) }), void 0));
+    return (jsx(SlideFadeOverlay, { className: drawerClasses.overlay, container: container, direction: slideFadeDirection[placement], disableCloseOnBackdropClick: disableCloseOnBackdropClick, disableCloseOnEscapeKeyDown: disableCloseOnEscapeKeyDown, disablePortal: disablePortal, hideBackdrop: hideBackdrop, invisibleBackdrop: invisibleBackdrop, onBackdropClick: onBackdropClick, onClose: onClose, open: open, ref: ref, children: jsx("div", { ...rest, className: cx(drawerClasses.host, drawerClasses[placement], className), children: children }) }));
 });
 var Drawer$1 = Drawer;
 

package/Dropdown/Dropdown.js

@@ -47,14 +47,14 @@ const Dropdown = forwardRef(function Dropdown(props, ref) {
         open,
         popperRef,
     ]);
-    return (jsxs(Fragment, { children: [children(anchor), jsx(Popper, Object.assign({}, popperProps, { ref: composedRef }, rest, { anchor: anchor, options: {
+    return (jsxs(Fragment, { children: [children(anchor), jsx(Popper, { ...popperProps, ref: composedRef, ...rest, anchor: anchor, options: {
                     placement: 'top-start',
                     ...popperProps === null || popperProps === void 0 ? void 0 : popperProps.options,
                     modifiers: [
                         ...(popperOptions.modifiers || []),
                         ...modifiers,
                     ],
-                } }, { children: menu }), void 0)] }, void 0));
+                }, children: menu })] }));
 });
 var Dropdown$1 = Dropdown;
 

package/Empty/Empty.js

@@ -6,11 +6,10 @@ import Icon from '../Icon/Icon.js';
 import cx from 'clsx';
 
 const Empty = forwardRef(function Empty(props, ref) {
-    const { children, className, fullHeight, image = jsx(Icon, { className: emptyClasses.icon, icon: FolderOpenIcon }, void 0), title, ...rest } = props;
-    return (jsxs("div", Object.assign({ ref: ref }, rest, { className: cx(emptyClasses.host, {
+    const { children, className, fullHeight, image = jsx(Icon, { className: emptyClasses.icon, icon: FolderOpenIcon }), title, ...rest } = props;
+    return (jsxs("div", { ref: ref, ...rest, className: cx(emptyClasses.host, {
             [emptyClasses.fullHeight]: fullHeight,
-        }, className) }, { children: [image, title && jsx("div", Object.assign({ className: emptyClasses.title }, { children: title }), void 0),
-            children && jsx("div", Object.assign({ className: emptyClasses.description }, { children: children }), void 0)] }), void 0));
+        }, className), children: [image, title && jsx("div", { className: emptyClasses.title, children: title }), children && jsx("div", { className: emptyClasses.description, children: children })] }));
 });
 var Empty$1 = Empty;
 

package/Form/FormField.js

@@ -15,10 +15,10 @@ const FormField = forwardRef(function FormField(props, ref) {
         required,
         severity,
     };
-    return (jsx("div", Object.assign({}, rest, { ref: ref, className: cx(formFieldClasses.host, severity && formFieldClasses.severity(severity), {
+    return (jsx("div", { ...rest, ref: ref, className: cx(formFieldClasses.host, severity && formFieldClasses.severity(severity), {
             [formFieldClasses.disabled]: disabled,
             [formFieldClasses.fullWidth]: fullWidth,
-        }, className) }, { children: jsx(FormControlContext.Provider, Object.assign({ value: formControl }, { children: children }), void 0) }), void 0));
+        }, className), children: jsx(FormControlContext.Provider, { value: formControl, children: children }) }));
 });
 var FormField$1 = FormField;
 

package/Form/FormLabel.js

@@ -10,8 +10,7 @@ import cx from 'clsx';
 const FormLabel = forwardRef(function FormLabel(props, ref) {
     const { children, className, htmlFor, remark, remarkIcon, ...rest } = props;
     const { required } = useContext(FormControlContext) || {};
-    return (jsxs("label", Object.assign({}, rest, { ref: ref, className: cx(formFieldClasses.label, className), htmlFor: htmlFor }, { children: [jsxs("span", { children: [children, required && jsx("span", Object.assign({ className: formFieldClasses.asterisk }, { children: "*" }), void 0)] }, void 0),
-            (remark || remarkIcon) && (jsxs("span", Object.assign({ className: formFieldClasses.remark }, { children: [jsx("span", { children: remark }, void 0), remarkIcon] }), void 0))] }), void 0));
+    return (jsxs("label", { ...rest, ref: ref, className: cx(formFieldClasses.label, className), htmlFor: htmlFor, children: [jsxs("span", { children: [children, required && jsx("span", { className: formFieldClasses.asterisk, children: "*" })] }), (remark || remarkIcon) && (jsxs("span", { className: formFieldClasses.remark, children: [jsx("span", { children: remark }), remarkIcon] }))] }));
 });
 var FormLabel$1 = FormLabel;
 

package/Form/FormMessage.d.ts

@@ -4,5 +4,5 @@ export declare type FormMessageProps = NativeElementPropsWithoutKeyAndRef<'span'
 /**
  * The react component for `mezzanine` form message.
  */
-declare const FormMessage: import("react").ForwardRefExoticComponent<Pick<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "defaultChecked" | "defaultValue" | "suppressContentEditableWarning" | "suppressHydrationWarning" | "accessKey" | "className" | "contentEditable" | "contextMenu" | "dir" | "draggable" | "hidden" | "id" | "lang" | "placeholder" | "slot" | "spellCheck" | "style" | "tabIndex" | "title" | "translate" | "radioGroup" | "role" | "about" | "datatype" | "inlist" | "prefix" | "property" | "resource" | "typeof" | "vocab" | "autoCapitalize" | "autoCorrect" | "autoSave" | "color" | "itemProp" | "itemScope" | "itemType" | "itemID" | "itemRef" | "results" | "security" | "unselectable" | "inputMode" | "is" | "aria-activedescendant" | "aria-atomic" | "aria-autocomplete" | "aria-busy" | "aria-checked" | "aria-colcount" | "aria-colindex" | "aria-colspan" | "aria-controls" | "aria-current" | "aria-describedby" | "aria-details" | "aria-disabled" | "aria-dropeffect" | "aria-errormessage" | "aria-expanded" | "aria-flowto" | "aria-grabbed" | "aria-haspopup" | "aria-hidden" | "aria-invalid" | "aria-keyshortcuts" | "aria-label" | "aria-labelledby" | "aria-level" | "aria-live" | "aria-modal" | "aria-multiline" | "aria-multiselectable" | "aria-orientation" | "aria-owns" | "aria-placeholder" | "aria-posinset" | "aria-pressed" | "aria-readonly" | "aria-relevant" | "aria-required" | "aria-roledescription" | "aria-rowcount" | "aria-rowindex" | "aria-rowspan" | "aria-selected" | "aria-setsize" | "aria-sort" | "aria-valuemax" | "aria-valuemin" | "aria-valuenow" | "aria-valuetext" | "children" | "dangerouslySetInnerHTML" | "onCopy" | "onCopyCapture" | "onCut" | "onCutCapture" | "onPaste" | "onPasteCapture" | "onCompositionEnd" | "onCompositionEndCapture" | "onCompositionStart" | "onCompositionStartCapture" | "onCompositionUpdate" | "onCompositionUpdateCapture" | "onFocus" | "onFocusCapture" | "onBlur" | "onBlurCapture" | "onChange" | "onChangeCapture" | "onBeforeInput" | "onBeforeInputCapture" | "onInput" | "onInputCapture" | "onReset" | "onResetCapture" | "onSubmit" | "onSubmitCapture" | "onInvalid" | "onInvalidCapture" | "onLoad" | "onLoadCapture" | "onError" | "onErrorCapture" | "onKeyDown" | "onKeyDownCapture" | "onKeyPress" | "onKeyPressCapture" | "onKeyUp" | "onKeyUpCapture" | "onAbort" | "onAbortCapture" | "onCanPlay" | "onCanPlayCapture" | "onCanPlayThrough" | "onCanPlayThroughCapture" | "onDurationChange" | "onDurationChangeCapture" | "onEmptied" | "onEmptiedCapture" | "onEncrypted" | "onEncryptedCapture" | "onEnded" | "onEndedCapture" | "onLoadedData" | "onLoadedDataCapture" | "onLoadedMetadata" | "onLoadedMetadataCapture" | "onLoadStart" | "onLoadStartCapture" | "onPause" | "onPauseCapture" | "onPlay" | "onPlayCapture" | "onPlaying" | "onPlayingCapture" | "onProgress" | "onProgressCapture" | "onRateChange" | "onRateChangeCapture" | "onSeeked" | "onSeekedCapture" | "onSeeking" | "onSeekingCapture" | "onStalled" | "onStalledCapture" | "onSuspend" | "onSuspendCapture" | "onTimeUpdate" | "onTimeUpdateCapture" | "onVolumeChange" | "onVolumeChangeCapture" | "onWaiting" | "onWaitingCapture" | "onAuxClick" | "onAuxClickCapture" | "onClick" | "onClickCapture" | "onContextMenu" | "onContextMenuCapture" | "onDoubleClick" | "onDoubleClickCapture" | "onDrag" | "onDragCapture" | "onDragEnd" | "onDragEndCapture" | "onDragEnter" | "onDragEnterCapture" | "onDragExit" | "onDragExitCapture" | "onDragLeave" | "onDragLeaveCapture" | "onDragOver" | "onDragOverCapture" | "onDragStart" | "onDragStartCapture" | "onDrop" | "onDropCapture" | "onMouseDown" | "onMouseDownCapture" | "onMouseEnter" | "onMouseLeave" | "onMouseMove" | "onMouseMoveCapture" | "onMouseOut" | "onMouseOutCapture" | "onMouseOver" | "onMouseOverCapture" | "onMouseUp" | "onMouseUpCapture" | "onSelect" | "onSelectCapture" | "onTouchCancel" | "onTouchCancelCapture" | "onTouchEnd" | "onTouchEndCapture" | "onTouchMove" | "onTouchMoveCapture" | "onTouchStart" | "onTouchStartCapture" | "onPointerDown" | "onPointerDownCapture" | "onPointerMove" | "onPointerMoveCapture" | "onPointerUp" | "onPointerUpCapture" | "onPointerCancel" | "onPointerCancelCapture" | "onPointerEnter" | "onPointerEnterCapture" | "onPointerLeave" | "onPointerLeaveCapture" | "onPointerOver" | "onPointerOverCapture" | "onPointerOut" | "onPointerOutCapture" | "onGotPointerCapture" | "onGotPointerCaptureCapture" | "onLostPointerCapture" | "onLostPointerCaptureCapture" | "onScroll" | "onScrollCapture" | "onWheel" | "onWheelCapture" | "onAnimationStart" | "onAnimationStartCapture" | "onAnimationEnd" | "onAnimationEndCapture" | "onAnimationIteration" | "onAnimationIterationCapture" | "onTransitionEnd" | "onTransitionEndCapture"> & import("react").RefAttributes<HTMLSpanElement>>;
+declare const FormMessage: import("react").ForwardRefExoticComponent<FormMessageProps & import("react").RefAttributes<HTMLSpanElement>>;
 export default FormMessage;

package/Form/FormMessage.js

@@ -12,7 +12,7 @@ const FormMessage = forwardRef(function FormMessage(props, ref) {
     const { children, className, ...rest } = props;
     const { severity } = useContext(FormControlContext) || {};
     const icon = severity ? formMessageIcons[severity] : null;
-    return (jsxs("span", Object.assign({}, rest, { ref: ref, className: cx(formFieldClasses.message, className) }, { children: [icon && (jsx(Icon, { className: formFieldClasses.severityIcon, icon: icon }, void 0)), children] }), void 0));
+    return (jsxs("span", { ...rest, ref: ref, className: cx(formFieldClasses.message, className), children: [icon && (jsx(Icon, { className: formFieldClasses.severityIcon, icon: icon })), children] }));
 });
 var FormMessage$1 = FormMessage;
 

package/Form/useAutoCompleteValueControl.d.ts

@@ -1,23 +1,42 @@
 import { Dispatch, MouseEvent, SetStateAction } from 'react';
 import { SelectValue } from '../Select/typings';
-export interface UseAutoCompleteValueControl {
-    defaultValue?: string;
+export interface UseAutoCompleteBaseValueControl {
     disabledOptionsFilter: boolean;
-    onChange?(newOption: string): any;
+    onChange?(newOptions: SelectValue[] | SelectValue | null): any;
     onClear?(e: MouseEvent<Element>): void;
     onClose?(): void;
-    options: string[];
-    value?: string;
+    onSearch?(input: string): any;
+    options: SelectValue[];
 }
-export interface AutoCompleteValueControl {
+export declare type UseAutoCompleteMultipleValueControl = UseAutoCompleteBaseValueControl & {
+    defaultValue?: SelectValue[];
+    mode: 'multiple';
+    onChange?(newOptions: SelectValue[]): any;
+    value?: SelectValue[];
+};
+export declare type UseAutoCompleteSingleValueControl = UseAutoCompleteBaseValueControl & {
+    defaultValue?: SelectValue;
+    mode: 'single';
+    onChange?(newOption: SelectValue | null): any;
+    value?: SelectValue | null;
+};
+export declare type UseAutoCompleteValueControl = UseAutoCompleteMultipleValueControl | UseAutoCompleteSingleValueControl;
+export interface AutoCompleteBaseValueControl {
     focused: boolean;
-    onChange: (v: SelectValue | null) => SelectValue[];
     onClear(e: MouseEvent<Element>): void;
     onFocus: (f: boolean) => void;
-    options: string[];
+    options: SelectValue[];
     searchText: string;
+    selectedOptions: SelectValue[];
     setSearchText: Dispatch<SetStateAction<string>>;
-    setValue: (text: string) => void;
-    value: SelectValue | null;
+    unselectedOptions: SelectValue[];
 }
-export declare function useAutoCompleteValueControl(props: UseAutoCompleteValueControl): AutoCompleteValueControl;
+export declare type AutoCompleteMultipleValueControl = AutoCompleteBaseValueControl & {
+    onChange: (v: SelectValue | null) => SelectValue[];
+    value: SelectValue[];
+};
+export declare type AutoCompleteSingleValueControl = AutoCompleteBaseValueControl & {
+    onChange: (v: SelectValue | null) => SelectValue | null;
+    value: SelectValue | null;
+};
+export declare const useAutoCompleteValueControl: (props: UseAutoCompleteValueControl) => AutoCompleteMultipleValueControl | AutoCompleteSingleValueControl;