@mezzanine-ui/react 0.13.9 → 0.13.11

package/Calendar/Calendar.d.ts

@@ -1,69 +1,69 @@
-/// <reference types="react" />
-import { CalendarMode, DateType } from '@mezzanine-ui/core/calendar';
-import { NativeElementPropsWithoutKeyAndRef } from '../utils/jsx-types';
-import { CalendarControlsProps } from './CalendarControls';
-import { CalendarDaysProps } from './CalendarDays';
-import { CalendarMonthsProps } from './CalendarMonths';
-import { CalendarWeeksProps } from './CalendarWeeks';
-import { CalendarYearsProps } from './CalendarYears';
-export interface CalendarProps extends Omit<NativeElementPropsWithoutKeyAndRef<'div'>, 'onChange' | 'children'>, Pick<CalendarDaysProps, 'isDateDisabled' | 'isDateInRange' | 'onDateHover' | 'displayWeekDayLocale'>, Pick<CalendarMonthsProps, 'isMonthDisabled' | 'isMonthInRange' | 'onMonthHover' | 'displayMonthLocale'>, Pick<CalendarWeeksProps, 'isWeekDisabled' | 'isWeekInRange' | 'onWeekHover'>, Pick<CalendarYearsProps, 'isYearDisabled' | 'isYearInRange' | 'onYearHover'>, Pick<CalendarControlsProps, 'disableOnNext' | 'disableOnPrev'> {
-    /**
-     * Other props you may provide to `CalendarDays`
-     */
-    calendarDaysProps?: Omit<CalendarDaysProps, 'onClick' | 'referenceDate' | 'value' | 'displayWeekDayLocale' | 'isDateDisabled' | 'isDateInRange' | 'onDateHover' | 'updateReferenceDate'>;
-    /**
-     * Other props you may provide to `CalendarMonths`
-     */
-    calendarMonthsProps?: Omit<CalendarMonthsProps, 'onClick' | 'referenceDate' | 'value' | 'isMonthDisabled' | 'isMonthInRange' | 'onMonthHover' | 'displayMonthLocale'>;
-    /**
-     * Other props you may provide to `CalendarWeeks`
-     */
-    calendarWeeksProps?: Omit<CalendarWeeksProps, 'onClick' | 'referenceDate' | 'value' | 'displayWeekDayLocale' | 'isWeekDisabled' | 'isWeekInRange' | 'onWeekHover'>;
-    /**
-     * Other props you may provide to `CalendarYears`
-     */
-    calendarYearsProps?: Omit<CalendarYearsProps, 'onClick' | 'referenceDate' | 'value' | 'isYearDisabled' | 'isYearInRange' | 'onYearHover'>;
-    /**
-     * Use this prop to switch calendars.
-     * @default 'day'
-     */
-    mode?: CalendarMode;
-    /**
-     * Click handler for every cell on calendars.
-     */
-    onChange?: (target: DateType) => void;
-    /**
-     * Click handler for control button of month.
-     */
-    onMonthControlClick?: VoidFunction;
-    /**
-     * Click handler for control button of next.
-     */
-    onNext?: (currentMode: CalendarMode) => void;
-    /**
-     * Click handler for control button of prev.
-     */
-    onPrev?: (currentMode: CalendarMode) => void;
-    /**
-     * Click handler for control button of year.
-     */
-    onYearControlClick?: VoidFunction;
-    /**
-     * The refernce date for getting the calendar.
-     * **The type of `referenceDate` should be the same as your declared `DateType`.**
-     */
-    referenceDate: DateType;
-    /**
-     * The displaying cells will be marked as active
-     * if the single value of it matches any date object in the array. <br />
-     * **The type of `value` should be the same as your declared `DateType`.**
-     */
-    value?: DateType | DateType[];
-}
-/**
- * The react component for `mezzanine` calendar. <br />
- * Notice that any component related to calendar should be used along with `CalendarContext`. <br />
- * You may use the handlers provided by `useCalendarControls` hook or your own customizd methods.
- */
-declare const Calendar: import("react").ForwardRefExoticComponent<CalendarProps & import("react").RefAttributes<HTMLDivElement>>;
-export default Calendar;
+/// <reference types="react" />
+import { CalendarMode, DateType } from '@mezzanine-ui/core/calendar';
+import { NativeElementPropsWithoutKeyAndRef } from '../utils/jsx-types';
+import { CalendarControlsProps } from './CalendarControls';
+import { CalendarDaysProps } from './CalendarDays';
+import { CalendarMonthsProps } from './CalendarMonths';
+import { CalendarWeeksProps } from './CalendarWeeks';
+import { CalendarYearsProps } from './CalendarYears';
+export interface CalendarProps extends Omit<NativeElementPropsWithoutKeyAndRef<'div'>, 'onChange' | 'children'>, Pick<CalendarDaysProps, 'isDateDisabled' | 'isDateInRange' | 'onDateHover' | 'displayWeekDayLocale'>, Pick<CalendarMonthsProps, 'isMonthDisabled' | 'isMonthInRange' | 'onMonthHover' | 'displayMonthLocale'>, Pick<CalendarWeeksProps, 'isWeekDisabled' | 'isWeekInRange' | 'onWeekHover'>, Pick<CalendarYearsProps, 'isYearDisabled' | 'isYearInRange' | 'onYearHover'>, Pick<CalendarControlsProps, 'disableOnNext' | 'disableOnPrev'> {
+    /**
+     * Other props you may provide to `CalendarDays`
+     */
+    calendarDaysProps?: Omit<CalendarDaysProps, 'onClick' | 'referenceDate' | 'value' | 'displayWeekDayLocale' | 'isDateDisabled' | 'isDateInRange' | 'onDateHover' | 'updateReferenceDate'>;
+    /**
+     * Other props you may provide to `CalendarMonths`
+     */
+    calendarMonthsProps?: Omit<CalendarMonthsProps, 'onClick' | 'referenceDate' | 'value' | 'isMonthDisabled' | 'isMonthInRange' | 'onMonthHover' | 'displayMonthLocale'>;
+    /**
+     * Other props you may provide to `CalendarWeeks`
+     */
+    calendarWeeksProps?: Omit<CalendarWeeksProps, 'onClick' | 'referenceDate' | 'value' | 'displayWeekDayLocale' | 'isWeekDisabled' | 'isWeekInRange' | 'onWeekHover'>;
+    /**
+     * Other props you may provide to `CalendarYears`
+     */
+    calendarYearsProps?: Omit<CalendarYearsProps, 'onClick' | 'referenceDate' | 'value' | 'isYearDisabled' | 'isYearInRange' | 'onYearHover'>;
+    /**
+     * Use this prop to switch calendars.
+     * @default 'day'
+     */
+    mode?: CalendarMode;
+    /**
+     * Click handler for every cell on calendars.
+     */
+    onChange?: (target: DateType) => void;
+    /**
+     * Click handler for control button of month.
+     */
+    onMonthControlClick?: VoidFunction;
+    /**
+     * Click handler for control button of next.
+     */
+    onNext?: (currentMode: CalendarMode) => void;
+    /**
+     * Click handler for control button of prev.
+     */
+    onPrev?: (currentMode: CalendarMode) => void;
+    /**
+     * Click handler for control button of year.
+     */
+    onYearControlClick?: VoidFunction;
+    /**
+     * The refernce date for getting the calendar.
+     * **The type of `referenceDate` should be the same as your declared `DateType`.**
+     */
+    referenceDate: DateType;
+    /**
+     * The displaying cells will be marked as active
+     * if the single value of it matches any date object in the array. <br />
+     * **The type of `value` should be the same as your declared `DateType`.**
+     */
+    value?: DateType | DateType[];
+}
+/**
+ * The react component for `mezzanine` calendar. <br />
+ * Notice that any component related to calendar should be used along with `CalendarContext`. <br />
+ * You may use the handlers provided by `useCalendarControls` hook or your own customizd methods.
+ */
+declare const Calendar: import("react").ForwardRefExoticComponent<CalendarProps & import("react").RefAttributes<HTMLDivElement>>;
+export default Calendar;

package/Calendar/Calendar.js

@@ -10,44 +10,44 @@ import CalendarWeeks from './CalendarWeeks.js';
 import CalendarYears from './CalendarYears.js';
 import cx from 'clsx';
 
-/**
- * The react component for `mezzanine` calendar. <br />
- * Notice that any component related to calendar should be used along with `CalendarContext`. <br />
- * You may use the handlers provided by `useCalendarControls` hook or your own customizd methods.
- */
-const Calendar = forwardRef(function Calendar(props, ref) {
-    const { displayMonthLocale: displayMonthLocaleFromConfig, getMonth, getMonthShortName, getYear, } = useCalendarContext();
-    const { calendarDaysProps, calendarMonthsProps, calendarWeeksProps, calendarYearsProps, className, disableOnNext, disableOnPrev, displayMonthLocale = displayMonthLocaleFromConfig, displayWeekDayLocale, isDateDisabled, isDateInRange, isMonthDisabled, isMonthInRange, isWeekDisabled, isWeekInRange, isYearDisabled, isYearInRange, mode = 'day', onChange, onDateHover, onMonthControlClick, onMonthHover, onNext, onPrev, onWeekHover, onYearControlClick, onYearHover, referenceDate, value: valueProp, ...restCalendarProps } = props;
-    const value = valueProp ? castArray(valueProp) : undefined;
-    /** Compute which calendar to use */
-    let displayCalendar;
-    if (mode === 'day') {
-        displayCalendar = (jsx(CalendarDays, { ...calendarDaysProps, isDateDisabled: isDateDisabled, isDateInRange: isDateInRange, onClick: onChange, onDateHover: onDateHover, referenceDate: referenceDate, displayWeekDayLocale: displayWeekDayLocale, value: value }));
-    }
-    else if (mode === 'week') {
-        displayCalendar = (jsx(CalendarWeeks, { ...calendarWeeksProps, isWeekDisabled: isWeekDisabled, isWeekInRange: isWeekInRange, onClick: onChange, onWeekHover: onWeekHover, referenceDate: referenceDate, displayWeekDayLocale: displayWeekDayLocale, value: value }));
-    }
-    else if (mode === 'month') {
-        displayCalendar = (jsx(CalendarMonths, { ...calendarMonthsProps, isMonthDisabled: isMonthDisabled, isMonthInRange: isMonthInRange, onClick: onChange, onMonthHover: onMonthHover, referenceDate: referenceDate, value: value }));
-    }
-    else if (mode === 'year') {
-        displayCalendar = (jsx(CalendarYears, { ...calendarYearsProps, isYearDisabled: isYearDisabled, isYearInRange: isYearInRange, onClick: onChange, onYearHover: onYearHover, referenceDate: referenceDate, value: value }));
-    }
-    /** Compute controls outcome */
-    const [start, end] = getYearRange(getYear(referenceDate), calendarYearModuler);
-    const displayYearRange = `${start} - ${end}`;
-    let controls;
-    if (mode === 'day' || mode === 'week') {
-        controls = (jsxs(Fragment, { children: [jsx("button", { type: "button", className: cx(calendarClasses.button, calendarClasses.controlsButton), onClick: onMonthControlClick, children: getMonthShortName(getMonth(referenceDate), displayMonthLocale) }), jsx("button", { type: "button", className: cx(calendarClasses.button, calendarClasses.controlsButton), onClick: onYearControlClick, children: getYear(referenceDate) })] }));
-    }
-    else if (mode === 'month') {
-        controls = (jsx("button", { type: "button", className: cx(calendarClasses.button, calendarClasses.controlsButton), onClick: onYearControlClick, children: getYear(referenceDate) }));
-    }
-    else if (mode === 'year') {
-        controls = (jsx("button", { type: "button", className: cx(calendarClasses.button, calendarClasses.controlsButton, calendarClasses.buttonDisabled), disabled: true, "aria-disabled": true, children: displayYearRange }));
-    }
-    return (jsxs("div", { ...restCalendarProps, ref: ref, className: cx(calendarClasses.host, className), children: [jsx(CalendarControls, { disableOnNext: disableOnNext, disableOnPrev: disableOnPrev, onNext: onNext ? () => { onNext(mode); } : undefined, onPrev: onPrev ? () => { onPrev(mode); } : undefined, children: controls }), displayCalendar] }));
-});
+/**
+ * The react component for `mezzanine` calendar. <br />
+ * Notice that any component related to calendar should be used along with `CalendarContext`. <br />
+ * You may use the handlers provided by `useCalendarControls` hook or your own customizd methods.
+ */
+const Calendar = forwardRef(function Calendar(props, ref) {
+    const { displayMonthLocale: displayMonthLocaleFromConfig, getMonth, getMonthShortName, getYear, } = useCalendarContext();
+    const { calendarDaysProps, calendarMonthsProps, calendarWeeksProps, calendarYearsProps, className, disableOnNext, disableOnPrev, displayMonthLocale = displayMonthLocaleFromConfig, displayWeekDayLocale, isDateDisabled, isDateInRange, isMonthDisabled, isMonthInRange, isWeekDisabled, isWeekInRange, isYearDisabled, isYearInRange, mode = 'day', onChange, onDateHover, onMonthControlClick, onMonthHover, onNext, onPrev, onWeekHover, onYearControlClick, onYearHover, referenceDate, value: valueProp, ...restCalendarProps } = props;
+    const value = valueProp ? castArray(valueProp) : undefined;
+    /** Compute which calendar to use */
+    let displayCalendar;
+    if (mode === 'day') {
+        displayCalendar = (jsx(CalendarDays, { ...calendarDaysProps, isDateDisabled: isDateDisabled, isDateInRange: isDateInRange, onClick: onChange, onDateHover: onDateHover, referenceDate: referenceDate, displayWeekDayLocale: displayWeekDayLocale, value: value }));
+    }
+    else if (mode === 'week') {
+        displayCalendar = (jsx(CalendarWeeks, { ...calendarWeeksProps, isWeekDisabled: isWeekDisabled, isWeekInRange: isWeekInRange, onClick: onChange, onWeekHover: onWeekHover, referenceDate: referenceDate, displayWeekDayLocale: displayWeekDayLocale, value: value }));
+    }
+    else if (mode === 'month') {
+        displayCalendar = (jsx(CalendarMonths, { ...calendarMonthsProps, isMonthDisabled: isMonthDisabled, isMonthInRange: isMonthInRange, onClick: onChange, onMonthHover: onMonthHover, referenceDate: referenceDate, value: value }));
+    }
+    else if (mode === 'year') {
+        displayCalendar = (jsx(CalendarYears, { ...calendarYearsProps, isYearDisabled: isYearDisabled, isYearInRange: isYearInRange, onClick: onChange, onYearHover: onYearHover, referenceDate: referenceDate, value: value }));
+    }
+    /** Compute controls outcome */
+    const [start, end] = getYearRange(getYear(referenceDate), calendarYearModuler);
+    const displayYearRange = `${start} - ${end}`;
+    let controls;
+    if (mode === 'day' || mode === 'week') {
+        controls = (jsxs(Fragment, { children: [jsx("button", { type: "button", className: cx(calendarClasses.button, calendarClasses.controlsButton), onClick: onMonthControlClick, children: getMonthShortName(getMonth(referenceDate), displayMonthLocale) }), jsx("button", { type: "button", className: cx(calendarClasses.button, calendarClasses.controlsButton), onClick: onYearControlClick, children: getYear(referenceDate) })] }));
+    }
+    else if (mode === 'month') {
+        controls = (jsx("button", { type: "button", className: cx(calendarClasses.button, calendarClasses.controlsButton), onClick: onYearControlClick, children: getYear(referenceDate) }));
+    }
+    else if (mode === 'year') {
+        controls = (jsx("button", { type: "button", className: cx(calendarClasses.button, calendarClasses.controlsButton, calendarClasses.buttonDisabled), disabled: true, "aria-disabled": true, children: displayYearRange }));
+    }
+    return (jsxs("div", { ...restCalendarProps, ref: ref, className: cx(calendarClasses.host, className), children: [jsx(CalendarControls, { disableOnNext: disableOnNext, disableOnPrev: disableOnPrev, onNext: onNext ? () => { onNext(mode); } : undefined, onPrev: onPrev ? () => { onPrev(mode); } : undefined, children: controls }), displayCalendar] }));
+});
 var Calendar$1 = Calendar;
 
 export { Calendar$1 as default };

package/Calendar/CalendarCell.d.ts

@@ -1,21 +1,22 @@
-import { NativeElementPropsWithoutKeyAndRef } from '../utils/jsx-types';
-export interface CalendarCellProps extends NativeElementPropsWithoutKeyAndRef<'div'> {
-    /**
-     * Apply active styles if true.
-     */
-    active?: boolean;
-    /**
-     * Apply disabled styles if true.
-     */
-    disabled?: boolean;
-    /**
-     * Apply today styles if true.
-     */
-    today?: boolean;
-}
-/**
- * The react component for `mezzanine` calendar cell.
- * You may use it to compose your own calendar.
- */
-declare function CalendarCell(props: CalendarCellProps): import("react/jsx-runtime").JSX.Element;
-export default CalendarCell;
+/// <reference types="react" />
+import { NativeElementPropsWithoutKeyAndRef } from '../utils/jsx-types';
+export interface CalendarCellProps extends NativeElementPropsWithoutKeyAndRef<'div'> {
+    /**
+     * Apply active styles if true.
+     */
+    active?: boolean;
+    /**
+     * Apply disabled styles if true.
+     */
+    disabled?: boolean;
+    /**
+     * Apply today styles if true.
+     */
+    today?: boolean;
+}
+/**
+ * The react component for `mezzanine` calendar cell.
+ * You may use it to compose your own calendar.
+ */
+declare function CalendarCell(props: CalendarCellProps): JSX.Element;
+export default CalendarCell;

package/Calendar/CalendarCell.js

@@ -2,17 +2,17 @@ import { jsx } from 'react/jsx-runtime';
 import { calendarClasses } from '@mezzanine-ui/core/calendar';
 import cx from 'clsx';
 
-/**
- * The react component for `mezzanine` calendar cell.
- * You may use it to compose your own calendar.
- */
-function CalendarCell(props) {
-    const { active, children, className, disabled, onClick, today, ...restCalendarCellProps } = props;
-    return (jsx("div", { className: cx(calendarClasses.cell, {
-            [calendarClasses.cellActive]: active,
-            [calendarClasses.cellDisabled]: disabled,
-            [calendarClasses.cellToday]: today,
-        }, className), ...restCalendarCellProps, children: jsx("span", { className: calendarClasses.cellInner, children: children }) }));
+/**
+ * The react component for `mezzanine` calendar cell.
+ * You may use it to compose your own calendar.
+ */
+function CalendarCell(props) {
+    const { active, children, className, disabled, onClick, today, ...restCalendarCellProps } = props;
+    return (jsx("div", { className: cx(calendarClasses.cell, {
+            [calendarClasses.cellActive]: active,
+            [calendarClasses.cellDisabled]: disabled,
+            [calendarClasses.cellToday]: today,
+        }, className), ...restCalendarCellProps, children: jsx("span", { className: calendarClasses.cellInner, children: children }) }));
 }
 
 export { CalendarCell as default };

package/Calendar/CalendarContext.d.ts

@@ -1,22 +1,22 @@
-import { ReactNode } from 'react';
-import { CalendarMethods } from '@mezzanine-ui/core/calendar';
-export interface CalendarConfigs extends CalendarMethods {
-    defaultDateFormat: string;
-    defaultTimeFormat: string;
-    displayMonthLocale: string;
-    displayWeekDayLocale: string;
-    valueLocale: string;
-}
-export type CalendarConfigProviderProps = {
-    children?: ReactNode;
-    defaultDateFormat?: string;
-    defaultTimeFormat?: string;
-    displayMonthLocale?: string;
-    displayWeekDayLocale?: string;
-    methods: CalendarMethods;
-    valueLocale?: string;
-};
-export declare const CalendarContext: import("react").Context<CalendarConfigs | undefined>;
-export declare function useCalendarContext(): CalendarConfigs;
-declare function CalendarConfigProvider(props: CalendarConfigProviderProps): import("react/jsx-runtime").JSX.Element;
-export default CalendarConfigProvider;
+import { ReactNode } from 'react';
+import { CalendarMethods } from '@mezzanine-ui/core/calendar';
+export interface CalendarConfigs extends CalendarMethods {
+    defaultDateFormat: string;
+    defaultTimeFormat: string;
+    displayMonthLocale: string;
+    displayWeekDayLocale: string;
+    valueLocale: string;
+}
+export type CalendarConfigProviderProps = {
+    children?: ReactNode;
+    defaultDateFormat?: string;
+    defaultTimeFormat?: string;
+    displayMonthLocale?: string;
+    displayWeekDayLocale?: string;
+    methods: CalendarMethods;
+    valueLocale?: string;
+};
+export declare const CalendarContext: import("react").Context<CalendarConfigs | undefined>;
+export declare function useCalendarContext(): CalendarConfigs;
+declare function CalendarConfigProvider(props: CalendarConfigProviderProps): JSX.Element;
+export default CalendarConfigProvider;

package/Calendar/CalendarContext.js

@@ -1,34 +1,34 @@
 import { jsx } from 'react/jsx-runtime';
 import { createContext, useContext, useMemo } from 'react';
 
-const CalendarContext = createContext(undefined);
-function useCalendarContext() {
-    const configs = useContext(CalendarContext);
-    if (!configs) {
-        throw new Error('Cannot find values in your context. '
-            + 'Make sure you use `CalendarConfigProvider` in your app '
-            + 'and pass in one of the following as methods: `CalendarMethodsMoment`.');
-    }
-    return configs;
-}
-function CalendarConfigProvider(props) {
-    const { children, defaultDateFormat = 'YYYY-MM-DD', defaultTimeFormat = 'HH:mm:ss', displayMonthLocale = 'en-us', displayWeekDayLocale = 'en-us', methods, valueLocale = 'en-us', } = props;
-    const context = useMemo(() => ({
-        ...methods,
-        defaultDateFormat,
-        defaultTimeFormat,
-        displayMonthLocale,
-        displayWeekDayLocale,
-        valueLocale,
-    }), [
-        methods,
-        defaultDateFormat,
-        defaultTimeFormat,
-        displayMonthLocale,
-        displayWeekDayLocale,
-        valueLocale,
-    ]);
-    return (jsx(CalendarContext.Provider, { value: context, children: children }));
+const CalendarContext = createContext(undefined);
+function useCalendarContext() {
+    const configs = useContext(CalendarContext);
+    if (!configs) {
+        throw new Error('Cannot find values in your context. '
+            + 'Make sure you use `CalendarConfigProvider` in your app '
+            + 'and pass in one of the following as methods: `CalendarMethodsMoment`.');
+    }
+    return configs;
+}
+function CalendarConfigProvider(props) {
+    const { children, defaultDateFormat = 'YYYY-MM-DD', defaultTimeFormat = 'HH:mm:ss', displayMonthLocale = 'en-us', displayWeekDayLocale = 'en-us', methods, valueLocale = 'en-us', } = props;
+    const context = useMemo(() => ({
+        ...methods,
+        defaultDateFormat,
+        defaultTimeFormat,
+        displayMonthLocale,
+        displayWeekDayLocale,
+        valueLocale,
+    }), [
+        methods,
+        defaultDateFormat,
+        defaultTimeFormat,
+        displayMonthLocale,
+        displayWeekDayLocale,
+        valueLocale,
+    ]);
+    return (jsx(CalendarContext.Provider, { value: context, children: children }));
 }
 
 export { CalendarContext, CalendarConfigProvider as default, useCalendarContext };

package/Calendar/CalendarControls.d.ts

@@ -1,25 +1,26 @@
-import { NativeElementPropsWithoutKeyAndRef } from '../utils/jsx-types';
-export interface CalendarControlsProps extends Omit<NativeElementPropsWithoutKeyAndRef<'div'>, 'onClick'> {
-    /**
-     * Disable the next controller if true.
-     */
-    disableOnNext?: boolean;
-    /**
-     * Disable the prev controller if true.
-     */
-    disableOnPrev?: boolean;
-    /**
-     * Click handler for next controller.
-     */
-    onNext?: VoidFunction;
-    /**
-     * Click handler for prev controller.
-     */
-    onPrev?: VoidFunction;
-}
-/**
- * The react component for `mezzanine` calendar controls.
- * You may use it to compose your own calendar.
- */
-declare function CalendarControls(props: CalendarControlsProps): import("react/jsx-runtime").JSX.Element;
-export default CalendarControls;
+/// <reference types="react" />
+import { NativeElementPropsWithoutKeyAndRef } from '../utils/jsx-types';
+export interface CalendarControlsProps extends Omit<NativeElementPropsWithoutKeyAndRef<'div'>, 'onClick'> {
+    /**
+     * Disable the next controller if true.
+     */
+    disableOnNext?: boolean;
+    /**
+     * Disable the prev controller if true.
+     */
+    disableOnPrev?: boolean;
+    /**
+     * Click handler for next controller.
+     */
+    onNext?: VoidFunction;
+    /**
+     * Click handler for prev controller.
+     */
+    onPrev?: VoidFunction;
+}
+/**
+ * The react component for `mezzanine` calendar controls.
+ * You may use it to compose your own calendar.
+ */
+declare function CalendarControls(props: CalendarControlsProps): JSX.Element;
+export default CalendarControls;

package/Calendar/CalendarControls.js

@@ -4,17 +4,17 @@ import { ChevronLeftIcon, ChevronRightIcon } from '@mezzanine-ui/icons';
 import Icon from '../Icon/Icon.js';
 import cx from 'clsx';
 
-/**
- * The react component for `mezzanine` calendar controls.
- * You may use it to compose your own calendar.
- */
-function CalendarControls(props) {
-    const { children, className, disableOnNext, disableOnPrev, onNext, onPrev, ...restElementProps } = props;
-    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 }) })), 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 }) }))] }));
+/**
+ * The react component for `mezzanine` calendar controls.
+ * You may use it to compose your own calendar.
+ */
+function CalendarControls(props) {
+    const { children, className, disableOnNext, disableOnPrev, onNext, onPrev, ...restElementProps } = props;
+    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 }) })), 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 }) }))] }));
 }
 
 export { CalendarControls as default };

package/Calendar/CalendarDayOfWeek.d.ts

@@ -1,14 +1,15 @@
-import { NativeElementPropsWithoutKeyAndRef } from '../utils/jsx-types';
-export interface CalendarDayOfWeekProps extends Omit<NativeElementPropsWithoutKeyAndRef<'div'>, 'onClick' | 'children'> {
-    /**
-     * The locale you want to use when rendering the name of week day.
-     * If none provided, it will use the `displayWeekDayLocale` from calendar context.
-     */
-    displayWeekDayLocale?: string;
-}
-/**
- * The react component for `mezzanine` calendar day of week.
- * You may use it to compose your own calendar.
- */
-declare function CalendarDayOfWeek(props: CalendarDayOfWeekProps): import("react/jsx-runtime").JSX.Element;
-export default CalendarDayOfWeek;
+/// <reference types="react" />
+import { NativeElementPropsWithoutKeyAndRef } from '../utils/jsx-types';
+export interface CalendarDayOfWeekProps extends Omit<NativeElementPropsWithoutKeyAndRef<'div'>, 'onClick' | 'children'> {
+    /**
+     * The locale you want to use when rendering the name of week day.
+     * If none provided, it will use the `displayWeekDayLocale` from calendar context.
+     */
+    displayWeekDayLocale?: string;
+}
+/**
+ * The react component for `mezzanine` calendar day of week.
+ * You may use it to compose your own calendar.
+ */
+declare function CalendarDayOfWeek(props: CalendarDayOfWeekProps): JSX.Element;
+export default CalendarDayOfWeek;

package/Calendar/CalendarDayOfWeek.js

@@ -4,15 +4,15 @@ import CalendarCell from './CalendarCell.js';
 import { useCalendarContext } from './CalendarContext.js';
 import cx from 'clsx';
 
-/**
- * The react component for `mezzanine` calendar day of week.
- * You may use it to compose your own calendar.
- */
-function CalendarDayOfWeek(props) {
-    const { getWeekDayNames, displayWeekDayLocale: displayWeekDayLocaleFromConfig, } = useCalendarContext();
-    const { displayWeekDayLocale = displayWeekDayLocaleFromConfig, className, ...restRowProps } = props;
-    const weekDayNames = getWeekDayNames(displayWeekDayLocale);
-    return (jsx("div", { className: cx(calendarClasses.row, className), ...restRowProps, children: weekDayNames.map((name) => (jsx(CalendarCell, { children: name }, `CALENDAR_DAY_OF_WEEK/${name}`))) }));
+/**
+ * The react component for `mezzanine` calendar day of week.
+ * You may use it to compose your own calendar.
+ */
+function CalendarDayOfWeek(props) {
+    const { getWeekDayNames, displayWeekDayLocale: displayWeekDayLocaleFromConfig, } = useCalendarContext();
+    const { displayWeekDayLocale = displayWeekDayLocaleFromConfig, className, ...restRowProps } = props;
+    const weekDayNames = getWeekDayNames(displayWeekDayLocale);
+    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.d.ts

@@ -1,37 +1,38 @@
-import { DateType } from '@mezzanine-ui/core/calendar';
-import { NativeElementPropsWithoutKeyAndRef } from '../utils/jsx-types';
-import { CalendarDayOfWeekProps } from './CalendarDayOfWeek';
-export interface CalendarDaysProps extends Pick<CalendarDayOfWeekProps, 'displayWeekDayLocale'>, Omit<NativeElementPropsWithoutKeyAndRef<'div'>, 'onClick' | 'children'> {
-    /**
-     * Provide if you have a custom disabling logic. The method takes the date object as its parameter.
-     */
-    isDateDisabled?: (date: DateType) => boolean;
-    /**
-     * Provide if you have a custom logic for checking if the date is in range.
-     * The method takes the date object as its parameter.
-     */
-    isDateInRange?: (date: DateType) => boolean;
-    /**
-     * Click handler for date button.
-     */
-    onClick?: (date: DateType) => void;
-    /**
-     * Mouse enter handler for date button.
-     */
-    onDateHover?: (date: DateType) => void;
-    /**
-     * The refernce date for getting the month of the calendar.
-     */
-    referenceDate: DateType;
-    /**
-     * If provided, each date that matches the same dates in this array will be marked as active.
-     */
-    value?: DateType[];
-}
-/**
- * The react component for `mezzanine` calendar days. <br />
- * This component displays a monthly calendar whose month is the same as `referenceDate`.
- * You may use it to compose your own calendar.
- */
-declare function CalendarDays(props: CalendarDaysProps): import("react/jsx-runtime").JSX.Element;
-export default CalendarDays;
+/// <reference types="react" />
+import { DateType } from '@mezzanine-ui/core/calendar';
+import { NativeElementPropsWithoutKeyAndRef } from '../utils/jsx-types';
+import { CalendarDayOfWeekProps } from './CalendarDayOfWeek';
+export interface CalendarDaysProps extends Pick<CalendarDayOfWeekProps, 'displayWeekDayLocale'>, Omit<NativeElementPropsWithoutKeyAndRef<'div'>, 'onClick' | 'children'> {
+    /**
+     * Provide if you have a custom disabling logic. The method takes the date object as its parameter.
+     */
+    isDateDisabled?: (date: DateType) => boolean;
+    /**
+     * Provide if you have a custom logic for checking if the date is in range.
+     * The method takes the date object as its parameter.
+     */
+    isDateInRange?: (date: DateType) => boolean;
+    /**
+     * Click handler for date button.
+     */
+    onClick?: (date: DateType) => void;
+    /**
+     * Mouse enter handler for date button.
+     */
+    onDateHover?: (date: DateType) => void;
+    /**
+     * The refernce date for getting the month of the calendar.
+     */
+    referenceDate: DateType;
+    /**
+     * If provided, each date that matches the same dates in this array will be marked as active.
+     */
+    value?: DateType[];
+}
+/**
+ * The react component for `mezzanine` calendar days. <br />
+ * This component displays a monthly calendar whose month is the same as `referenceDate`.
+ * You may use it to compose your own calendar.
+ */
+declare function CalendarDays(props: CalendarDaysProps): JSX.Element;
+export default CalendarDays;