rsuite 5.71.0 → 5.72.0

package/esm/DateRangePicker/hooks/useCalendarHandlers.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="react" />
+interface CalendarHandlerProps {
+    index: number;
+    calendarDateRange: Date[];
+    onChangeCalendarMonth?: (index: number, nextPageDate: Date) => void;
+    onChangeCalendarTime?: (index: number, nextPageDate: Date) => void;
+    onSelect?: (index: number, date: Date, event: React.SyntheticEvent) => void;
+}
+export declare function useCalendarHandlers({ index, calendarDateRange, onChangeCalendarMonth, onChangeCalendarTime, onSelect }: CalendarHandlerProps): {
+    calendarDate: Date;
+    onSelect: (...args: any[]) => any;
+    onChangeMonth: (...args: any[]) => any;
+    onChangeTime: (...args: any[]) => any;
+    onMoveForward: (...args: any[]) => any;
+    onMoveBackward: (...args: any[]) => any;
+};
+export default useCalendarHandlers;

package/esm/DateRangePicker/hooks/useCalendarHandlers.js

@@ -0,0 +1,38 @@
+'use client';
+import { useMemo } from 'react';
+import { useEventCallback } from "../../internals/hooks/index.js";
+import { addMonths } from "../../internals/utils/date/index.js";
+export function useCalendarHandlers(_ref) {
+  var index = _ref.index,
+    calendarDateRange = _ref.calendarDateRange,
+    onChangeCalendarMonth = _ref.onChangeCalendarMonth,
+    onChangeCalendarTime = _ref.onChangeCalendarTime,
+    onSelect = _ref.onSelect;
+  var calendarDate = useMemo(function () {
+    return calendarDateRange[index];
+  }, [calendarDateRange, index]);
+  var handleSelect = useEventCallback(function (date, event) {
+    onSelect === null || onSelect === void 0 ? void 0 : onSelect(index, date, event);
+  });
+  var handleChangeMonth = useEventCallback(function (nextPageDate) {
+    onChangeCalendarMonth === null || onChangeCalendarMonth === void 0 ? void 0 : onChangeCalendarMonth(index, nextPageDate);
+  });
+  var handleChangeTime = useEventCallback(function (nextPageDate) {
+    onChangeCalendarTime === null || onChangeCalendarTime === void 0 ? void 0 : onChangeCalendarTime(index, nextPageDate);
+  });
+  var handleMoveForward = useEventCallback(function () {
+    onChangeCalendarMonth === null || onChangeCalendarMonth === void 0 ? void 0 : onChangeCalendarMonth(index, addMonths(calendarDate, 1));
+  });
+  var handleMoveBackward = useEventCallback(function () {
+    onChangeCalendarMonth === null || onChangeCalendarMonth === void 0 ? void 0 : onChangeCalendarMonth(index, addMonths(calendarDate, -1));
+  });
+  return {
+    calendarDate: calendarDate,
+    onSelect: handleSelect,
+    onChangeMonth: handleChangeMonth,
+    onChangeTime: handleChangeTime,
+    onMoveForward: handleMoveForward,
+    onMoveBackward: handleMoveBackward
+  };
+}
+export default useCalendarHandlers;

package/esm/DateRangePicker/hooks/useDateDisabled.d.ts

@@ -12,5 +12,5 @@ interface DateDisabledOptions {
 /**
  * Returns a function that determines whether a date is disabled and is compatible with the deprecated `disabledDate` prop.
  */
-declare function useDateDisabled(props: UseDateDisabledProps): ((date: Date, options: DateDisabledOptions) => boolean) | undefined;
+export declare function useDateDisabled(props: UseDateDisabledProps): ((date: Date, options: DateDisabledOptions) => boolean) | undefined;
 export default useDateDisabled;

package/esm/DateRangePicker/hooks/useDateDisabled.js

@@ -3,7 +3,7 @@ import { useCallback } from 'react';
 /**
  * Returns a function that determines whether a date is disabled and is compatible with the deprecated `disabledDate` prop.
  */
-function useDateDisabled(props) {
+export function useDateDisabled(props) {
   var shouldDisableDate = props.shouldDisableDate,
     DEPRECATED_disabledDate = props.DEPRECATED_disabledDate;
   var isDateDisabled = useCallback(function (date, options) {

package/esm/DateRangePicker/hooks/useDateRangePicker.d.ts

@@ -0,0 +1,2 @@
+import { DateRangePickerContextValue } from '../DateRangePickerProvider';
+export declare const useDateRangePicker: () => DateRangePickerContextValue;

package/esm/DateRangePicker/hooks/useDateRangePicker.js

@@ -0,0 +1,6 @@
+'use client';
+import { useContext } from 'react';
+import { DateRangePickerContext } from "../DateRangePickerProvider.js";
+export var useDateRangePicker = function useDateRangePicker() {
+  return useContext(DateRangePickerContext) || {};
+};

package/esm/DateRangePicker/utils.js

@@ -1,5 +1,5 @@
 'use client';
-import { addMonths, isSameDay, shouldRenderTime, isSameSecond, startOfMonth, endOfMonth, startOfISOWeek, endOfISOWeek, startOfWeek, endOfWeek, differenceInCalendarMonths, copyTime } from "../internals/utils/date/index.js";
+import { addMonths, isSameDay, shouldRenderTime, isSameSecond, startOfMonth, endOfMonth, startOfISOWeek, endOfISOWeek, startOfWeek, startOfToday, endOfWeek, differenceInCalendarMonths, copyTime } from "../internals/utils/date/index.js";
 export function getSafeCalendarDate(_ref) {
   var _value;
   var value = _ref.value,
@@ -27,7 +27,7 @@ export function getSafeCalendarDate(_ref) {
   } else if (value[0]) {
     return [value[0], addMonths(value[0], gap)];
   }
-  var todayDate = new Date();
+  var todayDate = startOfToday();
   return [todayDate, addMonths(todayDate, gap)];
 }
 export var isSameRange = function isSameRange(source, dest, format) {

package/esm/InlineEdit/renderChildren.d.ts

@@ -6,7 +6,7 @@ export interface ChildrenProps {
     plaintext?: boolean;
     value: any;
     onChange: (value: any, event: React.SyntheticEvent) => void;
-    onBlur?: (event: React.SyntheticEvent) => void;
+    onBlur?: (event?: React.FocusEvent) => void;
 }
 export declare function defaultRenderInput(props: ChildrenProps, ref: React.Ref<any>): React.JSX.Element;
 export declare function renderChildren(children: ((props: ChildrenProps, ref: React.Ref<any>) => React.ReactElement) | React.ReactElement, props: ChildrenProps, ref: React.Ref<any>): React.ReactElement<any, string | React.JSXElementConstructor<any>>;

package/esm/InlineEdit/renderChildren.js

@@ -4,12 +4,13 @@ import _extends from "@babel/runtime/helpers/esm/extends";
 var _excluded = ["onBlur"];
 import React from 'react';
 import Input from "../Input/index.js";
+import { createChainedFunction } from "../internals/utils/index.js";
 export function defaultRenderInput(props, ref) {
   return /*#__PURE__*/React.createElement(Input, _extends({
     ref: ref
   }, props));
 }
-var pickers = ['DatePicker', 'DateRangePicker', 'InputPicker', 'TagPicker', 'Cascader', 'MultiCascader', 'SelectPicker', 'CheckPicker', 'CheckTreePicker', 'TreePicker'];
+var pickers = ['DatePicker', 'DateRangePicker', 'TimePicker', 'TimeRangePicker', 'InputPicker', 'TagPicker', 'Cascader', 'MultiCascader', 'SelectPicker', 'CheckPicker', 'CheckTreePicker', 'TreePicker'];
 function getDisplayName(Component) {
   var _Component$type;
   if (typeof (Component === null || Component === void 0 ? void 0 : Component.type) === 'string') {
@@ -24,10 +25,18 @@ export function renderChildren(children, props, ref) {
   if (pickers.includes(getDisplayName(children))) {
     var onBlur = props.onBlur,
       rest = _objectWithoutPropertiesLoose(props, _excluded);
-
-    // if the children is a picker, we should pass the onBlur to the onClose
+    var _children$props = children.props,
+      onExit = _children$props.onExit,
+      onClean = _children$props.onClean;
     return /*#__PURE__*/React.cloneElement(children, _extends({}, rest, {
-      onClose: onBlur,
+      // Pass onBlur to the child component to automatically save or cancel after the focus event is processed.
+      // Special handling in the Picker component, call onBlur when onExit and onClean
+      onExit: createChainedFunction(function () {
+        return onBlur === null || onBlur === void 0 ? void 0 : onBlur();
+      }, onExit),
+      onClean: createChainedFunction(function () {
+        return onBlur === null || onBlur === void 0 ? void 0 : onBlur();
+      }, onClean),
       ref: ref
     }));
   }

package/esm/InlineEdit/useFocusEvent.d.ts

@@ -3,8 +3,8 @@ import { PickerHandle } from '../internals/Picker/types';
 interface FocusEventProps {
     isEditing: boolean;
     stateOnBlur?: 'save' | 'cancel';
-    onSave?: (event?: React.FocusEvent) => void;
-    onCancel?: (event?: React.FocusEvent) => void;
+    onSave?: (event?: React.FocusEvent | null) => void;
+    onCancel?: (event?: React.FocusEvent | null) => void;
 }
 declare const useFocusEvent: ({ isEditing, stateOnBlur, onSave, onCancel }: FocusEventProps) => {
     target: import("react").RefObject<HTMLInputElement | PickerHandle>;

package/esm/InlineEdit/useFocusEvent.js

@@ -15,12 +15,17 @@ var useFocusEvent = function useFocusEvent(_ref) {
   var focus = function focus() {
     if (isPicker) {
       setTimeout(function () {
-        var _ref$current2, _ref$current2$target, _ref$current2$target$;
-        (_ref$current2 = ref.current) === null || _ref$current2 === void 0 ? void 0 : (_ref$current2$target = _ref$current2.target) === null || _ref$current2$target === void 0 ? void 0 : (_ref$current2$target$ = _ref$current2$target.focus) === null || _ref$current2$target$ === void 0 ? void 0 : _ref$current2$target$.call(_ref$current2$target);
+        var _picker$target, _picker$target$focus, _picker$open;
+        var picker = ref.current;
+        // Auto focus the search input
+        picker === null || picker === void 0 ? void 0 : (_picker$target = picker.target) === null || _picker$target === void 0 ? void 0 : (_picker$target$focus = _picker$target.focus) === null || _picker$target$focus === void 0 ? void 0 : _picker$target$focus.call(_picker$target);
+
+        // Open the picker
+        picker === null || picker === void 0 ? void 0 : (_picker$open = picker.open) === null || _picker$open === void 0 ? void 0 : _picker$open.call(picker);
       }, 100);
     } else {
-      var _ref$current3, _ref$current3$focus;
-      (_ref$current3 = ref.current) === null || _ref$current3 === void 0 ? void 0 : (_ref$current3$focus = _ref$current3.focus) === null || _ref$current3$focus === void 0 ? void 0 : _ref$current3$focus.call(_ref$current3);
+      var _ref$current2, _ref$current2$focus;
+      (_ref$current2 = ref.current) === null || _ref$current2 === void 0 ? void 0 : (_ref$current2$focus = _ref$current2.focus) === null || _ref$current2$focus === void 0 ? void 0 : _ref$current2$focus.call(_ref$current2);
     }
   };
   var handleBlur = useEventCallback(function (event) {

package/esm/TimePicker/TimePicker.d.ts

@@ -0,0 +1,81 @@
+import React from 'react';
+import { RangeType } from '../DatePicker';
+import type { FormControlBaseProps, PickerBaseProps } from '../internals/types';
+import type { PickerComponent } from '../internals/Picker/types';
+import type { DatePickerLocale } from '../locales';
+export interface TimePickerProps extends PickerBaseProps<DatePickerLocale>, FormControlBaseProps<Date | null> {
+    /**
+     * Custom caret component
+     */
+    caretAs?: React.ElementType | null;
+    /**
+     * Calendar panel default presentation date and time
+     */
+    calendarDefaultDate?: Date;
+    /**
+     * Whether disabled the component
+     */
+    disabled?: boolean;
+    /**
+     * Rendered as an input, the date can be entered via the keyboard
+     */
+    editable?: boolean;
+    /**
+     * Format date string
+     */
+    format?: string;
+    /**
+     * A label displayed at the beginning of toggle button
+     */
+    label?: React.ReactNode;
+    /**
+     * Whether to display a loading state indicator
+     */
+    loading?: boolean;
+    /**
+     * Whether plaintext the component
+     */
+    plaintext?: boolean;
+    /**
+     * Whether read only the component
+     */
+    readOnly?: boolean;
+    /**
+     * Meridiem format for 12-hour time
+     */
+    showMeridiem?: boolean;
+    /**
+     * Hide specific hour options
+     */
+    hideHours?: (hour: number, date: Date) => boolean;
+    /**
+     * Hide specific minute options
+     */
+    hideMinutes?: (minute: number, date: Date) => boolean;
+    /**
+     * Hide specific second options
+     */
+    hideSeconds?: (second: number, date: Date) => boolean;
+    /**
+     * Called when the option is selected
+     */
+    onSelect?: (date: Date, event?: React.SyntheticEvent) => void;
+    /**
+     * Called after clicking the OK button
+     */
+    onOk?: (date: Date, event: React.SyntheticEvent) => void;
+    /**
+     * Called after clicking the shortcut button
+     */
+    onShortcutClick?: (range: RangeType<Date>, event: React.MouseEvent) => void;
+    /**
+     * Called when clean
+     */
+    onClean?: (event: React.MouseEvent) => void;
+    /**
+     * Custom rendering of the selected date.
+     */
+    renderValue?: (value: Date, format: string) => string;
+}
+declare const TimePicker: PickerComponent<TimePickerProps>;
+export default TimePicker;

package/esm/TimePicker/TimePicker.js

@@ -0,0 +1,24 @@
+'use client';
+import _extends from "@babel/runtime/helpers/esm/extends";
+import React, { useMemo } from 'react';
+import DatePicker from "../DatePicker/index.js";
+import { useCustom } from "../internals/hooks/index.js";
+var TimePicker = /*#__PURE__*/React.forwardRef(function (props, ref) {
+  var _useCustom = useCustom('Calendar'),
+    locale = _useCustom.locale;
+  var defaultRanges = useMemo(function () {
+    return [{
+      label: locale.now,
+      value: function value() {
+        return new Date();
+      }
+    }];
+  }, [locale]);
+  return /*#__PURE__*/React.createElement(DatePicker, _extends({
+    ref: ref,
+    format: locale.shortTimeFormat,
+    ranges: defaultRanges
+  }, props));
+});
+TimePicker.displayName = 'TimePicker';
+export default TimePicker;

package/esm/TimePicker/index.d.ts

@@ -0,0 +1,3 @@
+import TimePicker from './TimePicker';
+export type { TimePickerProps } from './TimePicker';
+export default TimePicker;

package/esm/TimePicker/index.js

@@ -0,0 +1,3 @@
+'use client';
+import TimePicker from "./TimePicker.js";
+export default TimePicker;

package/esm/TimeRangePicker/TimeRangePicker.d.ts

@@ -0,0 +1,77 @@
+import React from 'react';
+import { RangeType, DateRange } from '../DateRangePicker';
+import type { FormControlBaseProps, PickerBaseProps } from '../internals/types';
+import type { PickerComponent } from '../internals/Picker/types';
+import type { DatePickerLocale } from '../locales';
+export interface TimeRangePickerProps extends PickerBaseProps<DatePickerLocale>, FormControlBaseProps<DateRange | null> {
+    /**
+     * Custom caret component
+     */
+    caretAs?: React.ElementType | null;
+    /** Predefined date ranges */
+    ranges?: RangeType[];
+    /**
+     * Format of the date displayed in the input box
+     */
+    format?: string;
+    /**
+     * Rendered as an input, the date can be entered via the keyboard.
+     * @default true
+     */
+    editable?: boolean;
+    /**
+     * A label displayed at the beginning of toggle button
+     */
+    label?: React.ReactNode;
+    /**
+     * Whether to display a loading state indicator
+     */
+    loading?: boolean;
+    /**
+     * Meridiem format for 12-hour time
+     */
+    showMeridiem?: boolean;
+    /**
+     * Whether to display the formatted date range at the header of the calendar
+     */
+    showHeader?: boolean;
+    /**
+     * The character that separates two dates
+     * @default ' ~ '
+     */
+    character?: string;
+    /**
+     * Hide specific hour options
+     */
+    hideHours?: (hour: number, date: Date) => boolean;
+    /**
+     * Hide specific minute options
+     */
+    hideMinutes?: (minute: number, date: Date) => boolean;
+    /**
+     * Hide specific second options
+     */
+    hideSeconds?: (second: number, date: Date) => boolean;
+    /**
+     * Called after clicking the OK button
+     */
+    onOk?: (date: DateRange, event: React.SyntheticEvent) => void;
+    /**
+     * Called after clicking the shortcut button
+     */
+    onShortcutClick?: (range: RangeType, event: React.MouseEvent) => void;
+    /**
+     * Called when the value is cleared
+     */
+    onClean?: (event: React.MouseEvent) => void;
+    /**
+     * Custom rendering of the selected date range.
+     */
+    renderValue?: (value: DateRange, format: string) => string;
+    /**
+     * Custom render for calendar title
+     */
+    renderTitle?: (date: Date) => React.ReactNode;
+}
+declare const TimeRangePicker: PickerComponent<TimeRangePickerProps>;
+export default TimeRangePicker;

package/esm/TimeRangePicker/TimeRangePicker.js

@@ -0,0 +1,18 @@
+'use client';
+import _extends from "@babel/runtime/helpers/esm/extends";
+import React from 'react';
+import { useCustom } from "../internals/hooks/index.js";
+import DateRangePicker from "../DateRangePicker/index.js";
+var defaultRanges = [];
+var TimeRangePicker = /*#__PURE__*/React.forwardRef(function (props, ref) {
+  var _useCustom = useCustom('Calendar'),
+    locale = _useCustom.locale;
+  return /*#__PURE__*/React.createElement(DateRangePicker, _extends({
+    ref: ref,
+    showHeader: false,
+    format: locale.shortTimeFormat,
+    ranges: defaultRanges
+  }, props));
+});
+TimeRangePicker.displayName = 'TimeRangePicker';
+export default TimeRangePicker;

package/esm/TimeRangePicker/index.d.ts

@@ -0,0 +1,3 @@
+import TimeRangePicker from './TimeRangePicker';
+export type { TimeRangePickerProps } from './TimeRangePicker';
+export default TimeRangePicker;

package/esm/TimeRangePicker/index.js

@@ -0,0 +1,3 @@
+'use client';
+import TimeRangePicker from "./TimeRangePicker.js";
+export default TimeRangePicker;

package/esm/index.d.ts

@@ -105,10 +105,14 @@ export { default as DateInput } from './DateInput';
 export type { DateInputProps } from './DateInput';
 export { default as DatePicker } from './DatePicker';
 export type { DatePickerProps } from './DatePicker';
+export { default as TimePicker } from './TimePicker';
+export type { TimePickerProps } from './TimePicker';
 export { default as DateRangeInput } from './DateRangeInput';
 export type { DateRangeInputProps } from './DateRangeInput';
 export { default as DateRangePicker } from './DateRangePicker';
 export type { DateRangePickerProps } from './DateRangePicker';
+export { default as TimeRangePicker } from './TimeRangePicker';
+export type { TimeRangePickerProps } from './TimeRangePicker';
 export { default as AutoComplete } from './AutoComplete';
 export type { AutoCompleteProps } from './AutoComplete';
 export { default as Uploader } from './Uploader';

package/esm/index.js

@@ -69,8 +69,10 @@ export { default as Cascader } from "./Cascader/index.js";
 export { default as MultiCascader } from "./MultiCascader/index.js";
 export { default as DateInput } from "./DateInput/index.js";
 export { default as DatePicker } from "./DatePicker/index.js";
+export { default as TimePicker } from "./TimePicker/index.js";
 export { default as DateRangeInput } from "./DateRangeInput/index.js";
 export { default as DateRangePicker } from "./DateRangePicker/index.js";
+export { default as TimeRangePicker } from "./TimeRangePicker/index.js";
 export { default as AutoComplete } from "./AutoComplete/index.js";
 export { default as Uploader } from "./Uploader/index.js";
 export { default as Slider } from "./Slider/index.js";

package/esm/internals/Picker/Listbox.js

@@ -69,7 +69,8 @@ var Listbox = /*#__PURE__*/React.forwardRef(function (props, ref) {
   var _useClassNames = useClassNames(classPrefix),
     withClassPrefix = _useClassNames.withClassPrefix,
     prefix = _useClassNames.prefix,
-    merge = _useClassNames.merge;
+    merge = _useClassNames.merge,
+    rootPrefix = _useClassNames.rootPrefix;
   var groupable = typeof groupBy !== 'undefined';
   var classes = merge(className, withClassPrefix('items', {
     grouped: groupable
@@ -230,7 +231,8 @@ var Listbox = /*#__PURE__*/React.forwardRef(function (props, ref) {
       height: height || maxHeight,
       itemCount: rowCount,
       itemData: filteredItems,
-      itemSize: getRowHeight.bind(_this, filteredItems)
+      itemSize: getRowHeight.bind(_this, filteredItems),
+      className: rootPrefix('virt-list')
     }, listProps), renderItem);
   }) : filteredItems.map(function (item, index) {
     return renderItem({

package/esm/internals/hooks/useCustom.js

@@ -2,7 +2,7 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import { useContext, useCallback } from 'react';
 import { format, parse, isValid } from "../utils/date/index.js";
-import defaultLocale from "../../locales/default.js";
+import defaultLocale from "../../locales/en_GB.js";
 import { CustomContext } from "../../CustomProvider/CustomProvider.js";
 var mergeObject = function mergeObject(list) {
   return list.reduce(function (a, b) {

package/esm/internals/utils/date/extractTimeFormat.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Extracts the time format from a given date format.
+ */
+export declare function extractTimeFormat(format: string): string | null;

package/esm/internals/utils/date/extractTimeFormat.js

@@ -0,0 +1,8 @@
+'use client';
+/**
+ * Extracts the time format from a given date format.
+ */
+export function extractTimeFormat(format) {
+  var match = format.match(/([hH]{1,2}[:.]mm(?:[:.]ss)?(?: ?aa)?|(?:aa )?[hH]{1,2}[:.]mm(?:[:.]ss)?)/);
+  return match ? match[0] : null;
+}

package/esm/internals/utils/date/formatCheck.d.ts

@@ -26,3 +26,7 @@ export declare const shouldRenderDate: (format: string) => boolean;
  * @returns Whether only the time should be rendered.
  */
 export declare const shouldOnlyRenderTime: (format: string) => boolean;
+/**
+ * Check if only the month should be rendered based on the format.
+ */
+export declare const shouldOnlyRenderMonth: (format: string) => boolean;

package/esm/internals/utils/date/formatCheck.js

@@ -37,4 +37,11 @@ export var shouldRenderDate = function shouldRenderDate(format) {
  */
 export var shouldOnlyRenderTime = function shouldOnlyRenderTime(format) {
   return /([Hhms])/.test(format) && !/([YyMDd])/.test(format);
+};
+
+/**
+ * Check if only the month should be rendered based on the format.
+ */
+export var shouldOnlyRenderMonth = function shouldOnlyRenderMonth(format) {
+  return shouldRenderMonth(format) && !shouldRenderDate(format);
 };

package/esm/internals/utils/date/index.d.ts

@@ -43,13 +43,15 @@ export { default as set } from 'date-fns/set';
 export { default as differenceInCalendarMonths } from 'date-fns/differenceInCalendarMonths';
 export { default as isLastDayOfMonth } from 'date-fns/isLastDayOfMonth';
 export { default as lastDayOfMonth } from 'date-fns/lastDayOfMonth';
+export { default as startOfToday } from 'date-fns/startOfToday';
 export { getWeekStartDates } from './getWeekStartDates';
 export { getWeekKeys } from './getWeekKeys';
-export { getReversedTimeMeridian } from './getReversedTimeMeridian';
 export { reverseDateRangeOmitTime } from './reverseDateRangeOmitTime';
 export { omitHideDisabledProps } from './omitHideDisabledProps';
 export { copyTime } from './copyTime';
 export { disableTime } from './disableTime';
-export { shouldRenderTime, shouldRenderMonth, shouldRenderDate, shouldOnlyRenderTime } from './formatCheck';
+export { useDateMode, DateMode } from './useDateMode';
+export { extractTimeFormat } from './extractTimeFormat';
+export * from './formatCheck';
 export type { TimeProp, CalendarOnlyPropsType } from './types';
 export { calendarOnlyProps } from './types';

package/esm/internals/utils/date/index.js

@@ -45,16 +45,18 @@ export { default as set } from 'date-fns/set';
 export { default as differenceInCalendarMonths } from 'date-fns/differenceInCalendarMonths';
 export { default as isLastDayOfMonth } from 'date-fns/isLastDayOfMonth';
 export { default as lastDayOfMonth } from 'date-fns/lastDayOfMonth';
+export { default as startOfToday } from 'date-fns/startOfToday';
 
 // Export custom functions
 export { getWeekStartDates } from "./getWeekStartDates.js";
 export { getWeekKeys } from "./getWeekKeys.js";
-export { getReversedTimeMeridian } from "./getReversedTimeMeridian.js";
 export { reverseDateRangeOmitTime } from "./reverseDateRangeOmitTime.js";
 export { omitHideDisabledProps } from "./omitHideDisabledProps.js";
 export { copyTime } from "./copyTime.js";
 export { disableTime } from "./disableTime.js";
-export { shouldRenderTime, shouldRenderMonth, shouldRenderDate, shouldOnlyRenderTime } from "./formatCheck.js";
+export { useDateMode, DateMode } from "./useDateMode.js";
+export { extractTimeFormat } from "./extractTimeFormat.js";
+export * from "./formatCheck.js";
 
 // Export types
 

package/esm/internals/utils/date/useDateMode.d.ts

@@ -0,0 +1,16 @@
+export declare enum DateMode {
+    Date = "date",
+    Month = "month",
+    Time = "time",
+    DateTime = "datetime"
+}
+/**
+ * Custom hook to determine the date mode and check format parts.
+ *
+ * @param format - The format string.
+ * @returns An object containing the resolved DateMode and a `has` method to check format parts.
+ */
+export declare const useDateMode: (format: string) => {
+    mode: DateMode;
+    has: (part: 'year' | 'month' | 'day' | 'time') => boolean;
+};

package/esm/internals/utils/date/useDateMode.js

@@ -0,0 +1,54 @@
+'use client';
+import { useMemo, useCallback } from 'react';
+import { shouldRenderDate, shouldRenderTime, shouldOnlyRenderMonth, shouldOnlyRenderTime } from "./formatCheck.js";
+export var DateMode = /*#__PURE__*/function (DateMode) {
+  DateMode["Date"] = "date";
+  DateMode["Month"] = "month";
+  DateMode["Time"] = "time";
+  DateMode["DateTime"] = "datetime";
+  return DateMode;
+}({});
+
+/**
+ * Custom hook to determine the date mode and check format parts.
+ *
+ * @param format - The format string.
+ * @returns An object containing the resolved DateMode and a `has` method to check format parts.
+ */
+export var useDateMode = function useDateMode(format) {
+  var mode = useMemo(function () {
+    if (shouldRenderDate(format) && shouldRenderTime(format)) {
+      return DateMode.DateTime;
+    }
+    if (shouldOnlyRenderMonth(format)) {
+      return DateMode.Month;
+    }
+    if (shouldOnlyRenderTime(format)) {
+      return DateMode.Time;
+    }
+    if (shouldRenderDate(format)) {
+      return DateMode.Date;
+    }
+    return DateMode.Date; // Default fallback
+  }, [format]);
+
+  // Use useCallback to memoize the has method
+  var has = useCallback(function (part) {
+    switch (part) {
+      case 'year':
+        return /[Yy]/.test(format);
+      case 'month':
+        return /[ML]/.test(format);
+      case 'day':
+        return /[Dd]/.test(format);
+      case 'time':
+        return /([Hhms])/.test(format);
+      default:
+        return false;
+    }
+  }, [format]);
+  return {
+    mode: mode,
+    has: has
+  };
+};

package/esm/internals/utils/index.d.ts

@@ -13,7 +13,6 @@ export { placementPolyfill } from './placementPolyfill';
 export { mergeRefs } from './mergeRefs';
 export { shallowEqual, shallowEqualArray } from './shallowEqual';
 export { composeFunctions } from './composeFunctions';
-export { scrollTopAnimation } from './scrollTopAnimation';
 export { render } from './render';
 export { safeSetSelection } from './safeSetSelection';
 export { getStringLength } from './getStringLength';

package/esm/internals/utils/index.js

@@ -14,7 +14,6 @@ export { placementPolyfill } from "./placementPolyfill.js";
 export { mergeRefs } from "./mergeRefs.js";
 export { shallowEqual, shallowEqualArray } from "./shallowEqual.js";
 export { composeFunctions } from "./composeFunctions.js";
-export { scrollTopAnimation } from "./scrollTopAnimation.js";
 export { render } from "./render.js";
 export { safeSetSelection } from "./safeSetSelection.js";
 export { getStringLength } from "./getStringLength.js";