add all frontend files

node_modules/rc-picker/es/PickerInput/hooks/useCellRender.d.ts

@@ -0,0 +1,2 @@
+import type { CellRender, CellRenderInfo, SharedPickerProps } from '../../interface';
+export default function useCellRender<DateType extends object = any>(cellRender: SharedPickerProps<DateType>['cellRender'], dateRender?: SharedPickerProps<DateType>['dateRender'], monthCellRender?: SharedPickerProps<DateType>['monthCellRender'], range?: CellRenderInfo<DateType>['range']): CellRender<DateType>;

node_modules/rc-picker/es/PickerInput/hooks/useCellRender.js

@@ -0,0 +1,36 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { warning } from 'rc-util';
+import * as React from 'react';
+export default function useCellRender(cellRender, dateRender, monthCellRender, range) {
+  // ========================= Warn =========================
+  if (process.env.NODE_ENV !== 'production') {
+    warning(!dateRender, "'dateRender' is deprecated. Please use 'cellRender' instead.");
+    warning(!monthCellRender, "'monthCellRender' is deprecated. Please use 'cellRender' instead.");
+  }
+
+  // ======================== Render ========================
+  // Merged render
+  var mergedCellRender = React.useMemo(function () {
+    if (cellRender) {
+      return cellRender;
+    }
+    return function (current, info) {
+      var date = current;
+      if (dateRender && info.type === 'date') {
+        return dateRender(date, info.today);
+      }
+      if (monthCellRender && info.type === 'month') {
+        return monthCellRender(date, info.locale);
+      }
+      return info.originNode;
+    };
+  }, [cellRender, monthCellRender, dateRender]);
+
+  // Cell render
+  var onInternalCellRender = React.useCallback(function (date, info) {
+    return mergedCellRender(date, _objectSpread(_objectSpread({}, info), {}, {
+      range: range
+    }));
+  }, [mergedCellRender, range]);
+  return onInternalCellRender;
+}

node_modules/rc-picker/es/PickerInput/hooks/useDelayState.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Will be `true` immediately for next effect.
+ * But will be `false` for a delay of effect.
+ */
+export default function useDelayState<T>(value: T, defaultValue?: T, onChange?: (next: T) => void): [state: T, setState: (nextState: T, immediately?: boolean) => void];

node_modules/rc-picker/es/PickerInput/hooks/useDelayState.js

@@ -0,0 +1,43 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { useEvent, useMergedState } from 'rc-util';
+import raf from "rc-util/es/raf";
+import React from 'react';
+
+/**
+ * Will be `true` immediately for next effect.
+ * But will be `false` for a delay of effect.
+ */
+export default function useDelayState(value, defaultValue, onChange) {
+  var _useMergedState = useMergedState(defaultValue, {
+      value: value
+    }),
+    _useMergedState2 = _slicedToArray(_useMergedState, 2),
+    state = _useMergedState2[0],
+    setState = _useMergedState2[1];
+  var nextValueRef = React.useRef(value);
+
+  // ============================= Update =============================
+  var rafRef = React.useRef();
+  var cancelRaf = function cancelRaf() {
+    raf.cancel(rafRef.current);
+  };
+  var doUpdate = useEvent(function () {
+    setState(nextValueRef.current);
+    if (onChange && state !== nextValueRef.current) {
+      onChange(nextValueRef.current);
+    }
+  });
+  var updateValue = useEvent(function (next, immediately) {
+    cancelRaf();
+    nextValueRef.current = next;
+    if (next || immediately) {
+      doUpdate();
+    } else {
+      rafRef.current = raf(doUpdate);
+    }
+  });
+  React.useEffect(function () {
+    return cancelRaf;
+  }, []);
+  return [state, updateValue];
+}

node_modules/rc-picker/es/PickerInput/hooks/useDisabledBoundary.d.ts

@@ -0,0 +1,7 @@
+import type { GenerateConfig } from '../../generate';
+import type { DisabledDate, InternalMode, Locale } from '../../interface';
+export type IsInvalidBoundary<DateType> = (currentDate: DateType, type: InternalMode, fromDate?: DateType) => boolean;
+/**
+ * Merge `disabledDate` with `minDate` & `maxDate`.
+ */
+export default function useDisabledBoundary<DateType extends object = any>(generateConfig: GenerateConfig<DateType>, locale: Locale, disabledDate?: DisabledDate<DateType>, minDate?: DateType, maxDate?: DateType): DisabledDate<DateType>;

node_modules/rc-picker/es/PickerInput/hooks/useDisabledBoundary.js

@@ -0,0 +1,20 @@
+import { useEvent } from 'rc-util';
+import { isSame } from "../../utils/dateUtil";
+/**
+ * Merge `disabledDate` with `minDate` & `maxDate`.
+ */
+export default function useDisabledBoundary(generateConfig, locale, disabledDate, minDate, maxDate) {
+  var mergedDisabledDate = useEvent(function (date, info) {
+    if (disabledDate && disabledDate(date, info)) {
+      return true;
+    }
+    if (minDate && generateConfig.isAfter(minDate, date) && !isSame(generateConfig, locale, minDate, date, info.type)) {
+      return true;
+    }
+    if (maxDate && generateConfig.isAfter(date, maxDate) && !isSame(generateConfig, locale, maxDate, date, info.type)) {
+      return true;
+    }
+    return false;
+  });
+  return mergedDisabledDate;
+}

node_modules/rc-picker/es/PickerInput/hooks/useFieldFormat.d.ts

@@ -0,0 +1,2 @@
+import type { FormatType, InternalMode, Locale, SharedPickerProps } from '../../interface';
+export declare function useFieldFormat<DateType = any>(picker: InternalMode, locale: Locale, format?: SharedPickerProps['format']): [formatList: FormatType<DateType>[], maskFormat?: string];

node_modules/rc-picker/es/PickerInput/hooks/useFieldFormat.js

@@ -0,0 +1,18 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import * as React from 'react';
+import { getRowFormat, toArray } from "../../utils/miscUtil";
+export function useFieldFormat(picker, locale, format) {
+  return React.useMemo(function () {
+    var rawFormat = getRowFormat(picker, locale, format);
+    var formatList = toArray(rawFormat);
+    var firstFormat = formatList[0];
+    var maskFormat = _typeof(firstFormat) === 'object' && firstFormat.type === 'mask' ? firstFormat.format : null;
+    return [
+    // Format list
+    formatList.map(function (config) {
+      return typeof config === 'string' || typeof config === 'function' ? config : config.format;
+    }),
+    // Mask Format
+    maskFormat];
+  }, [picker, locale, format]);
+}

node_modules/rc-picker/es/PickerInput/hooks/useFieldsInvalidate.d.ts

@@ -0,0 +1,5 @@
+import type useInvalidate from './useInvalidate';
+/**
+ * Used to control each fields invalidate status
+ */
+export default function useFieldsInvalidate<DateType extends object, ValueType extends DateType[]>(calendarValue: ValueType, isInvalidateDate: ReturnType<typeof useInvalidate<DateType>>, allowEmpty?: boolean[]): readonly [[boolean, boolean], (invalid: boolean, index: number) => void];

node_modules/rc-picker/es/PickerInput/hooks/useFieldsInvalidate.js

@@ -0,0 +1,50 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { fillIndex } from "../../utils/miscUtil";
+import * as React from 'react';
+/**
+ * Used to control each fields invalidate status
+ */
+export default function useFieldsInvalidate(calendarValue, isInvalidateDate) {
+  var allowEmpty = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  var _React$useState = React.useState([false, false]),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    fieldsInvalidates = _React$useState2[0],
+    setFieldsInvalidates = _React$useState2[1];
+  var onSelectorInvalid = function onSelectorInvalid(invalid, index) {
+    setFieldsInvalidates(function (ori) {
+      return fillIndex(ori, index, invalid);
+    });
+  };
+
+  /**
+   * For the Selector Input to mark as `aria-disabled`
+   */
+  var submitInvalidates = React.useMemo(function () {
+    return fieldsInvalidates.map(function (invalid, index) {
+      // If typing invalidate
+      if (invalid) {
+        return true;
+      }
+      var current = calendarValue[index];
+
+      // Not check if all empty
+      if (!current) {
+        return false;
+      }
+
+      // Not allow empty
+      if (!allowEmpty[index] && !current) {
+        return true;
+      }
+
+      // Invalidate
+      if (current && isInvalidateDate(current, {
+        activeIndex: index
+      })) {
+        return true;
+      }
+      return false;
+    });
+  }, [calendarValue, fieldsInvalidates, isInvalidateDate, allowEmpty]);
+  return [submitInvalidates, onSelectorInvalid];
+}

node_modules/rc-picker/es/PickerInput/hooks/useFilledProps.d.ts

@@ -0,0 +1,37 @@
+import type { FormatType, InternalMode, PickerMode } from '../../interface';
+import type { RangePickerProps } from '../RangePicker';
+import useInvalidate from './useInvalidate';
+type UseInvalidate<DateType extends object = any> = typeof useInvalidate<DateType>;
+type PickedProps<DateType extends object = any> = Pick<RangePickerProps<DateType>, 'generateConfig' | 'locale' | 'picker' | 'prefixCls' | 'styles' | 'classNames' | 'order' | 'components' | 'inputRender' | 'clearIcon' | 'allowClear' | 'needConfirm' | 'format' | 'inputReadOnly' | 'disabledDate' | 'minDate' | 'maxDate' | 'defaultOpenValue'> & {
+    multiple?: boolean;
+    showTime?: any;
+    value?: any;
+    defaultValue?: any;
+    pickerValue?: any;
+    defaultPickerValue?: any;
+};
+type ExcludeBooleanType<T> = T extends boolean ? never : T;
+type GetGeneric<T> = T extends PickedProps<infer U> ? U : never;
+type ToArrayType<T, DateType> = T extends any[] ? T : DateType[];
+/**
+ * Align the outer props with unique typed and fill undefined props.
+ * This is shared with both RangePicker and Picker. This will do:
+ * - Convert `value` & `defaultValue` to array
+ * - handle the legacy props fill like `clearIcon` + `allowClear` = `clearIcon`
+ */
+export default function useFilledProps<InProps extends PickedProps, DateType extends GetGeneric<InProps>, UpdaterProps extends object>(props: InProps, updater?: () => UpdaterProps): [
+    filledProps: Omit<InProps, keyof UpdaterProps | 'showTime' | 'value' | 'defaultValue'> & UpdaterProps & {
+        picker: PickerMode;
+        showTime?: ExcludeBooleanType<InProps['showTime']>;
+        value?: ToArrayType<InProps['value'], DateType>;
+        defaultValue?: ToArrayType<InProps['value'], DateType>;
+        pickerValue?: ToArrayType<InProps['value'], DateType>;
+        defaultPickerValue?: ToArrayType<InProps['value'], DateType>;
+    },
+    internalPicker: InternalMode,
+    complexPicker: boolean,
+    formatList: FormatType<DateType>[],
+    maskFormat: string,
+    isInvalidateDate: ReturnType<UseInvalidate<DateType>>
+];
+export {};

node_modules/rc-picker/es/PickerInput/hooks/useFilledProps.js

@@ -0,0 +1,145 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { warning } from 'rc-util';
+import * as React from 'react';
+import useLocale from "../../hooks/useLocale";
+import { fillShowTimeConfig, getTimeProps } from "../../hooks/useTimeConfig";
+import { toArray } from "../../utils/miscUtil";
+import { fillClearIcon } from "../Selector/hooks/useClearIcon";
+import useDisabledBoundary from "./useDisabledBoundary";
+import { useFieldFormat } from "./useFieldFormat";
+import useInputReadOnly from "./useInputReadOnly";
+import useInvalidate from "./useInvalidate";
+function useList(value) {
+  var fillMode = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  var values = React.useMemo(function () {
+    var list = value ? toArray(value) : value;
+    if (fillMode && list) {
+      list[1] = list[1] || list[0];
+    }
+    return list;
+  }, [value, fillMode]);
+  return values;
+}
+
+/**
+ * Align the outer props with unique typed and fill undefined props.
+ * This is shared with both RangePicker and Picker. This will do:
+ * - Convert `value` & `defaultValue` to array
+ * - handle the legacy props fill like `clearIcon` + `allowClear` = `clearIcon`
+ */
+export default function useFilledProps(props, updater) {
+  var generateConfig = props.generateConfig,
+    locale = props.locale,
+    _props$picker = props.picker,
+    picker = _props$picker === void 0 ? 'date' : _props$picker,
+    _props$prefixCls = props.prefixCls,
+    prefixCls = _props$prefixCls === void 0 ? 'rc-picker' : _props$prefixCls,
+    _props$styles = props.styles,
+    styles = _props$styles === void 0 ? {} : _props$styles,
+    _props$classNames = props.classNames,
+    classNames = _props$classNames === void 0 ? {} : _props$classNames,
+    _props$order = props.order,
+    order = _props$order === void 0 ? true : _props$order,
+    _props$components = props.components,
+    components = _props$components === void 0 ? {} : _props$components,
+    inputRender = props.inputRender,
+    allowClear = props.allowClear,
+    clearIcon = props.clearIcon,
+    needConfirm = props.needConfirm,
+    multiple = props.multiple,
+    format = props.format,
+    inputReadOnly = props.inputReadOnly,
+    disabledDate = props.disabledDate,
+    minDate = props.minDate,
+    maxDate = props.maxDate,
+    showTime = props.showTime,
+    value = props.value,
+    defaultValue = props.defaultValue,
+    pickerValue = props.pickerValue,
+    defaultPickerValue = props.defaultPickerValue;
+  var values = useList(value);
+  var defaultValues = useList(defaultValue);
+  var pickerValues = useList(pickerValue);
+  var defaultPickerValues = useList(defaultPickerValue);
+
+  // ======================== Picker ========================
+  /** Almost same as `picker`, but add `datetime` for `date` with `showTime` */
+  var internalPicker = picker === 'date' && showTime ? 'datetime' : picker;
+
+  /** The picker is `datetime` or `time` */
+  var multipleInteractivePicker = internalPicker === 'time' || internalPicker === 'datetime';
+  var complexPicker = multipleInteractivePicker || multiple;
+  var mergedNeedConfirm = needConfirm !== null && needConfirm !== void 0 ? needConfirm : multipleInteractivePicker;
+
+  // ========================== Time ==========================
+  // Auto `format` need to check `showTime.showXXX` first.
+  // And then merge the `locale` into `mergedShowTime`.
+  var _getTimeProps = getTimeProps(props),
+    _getTimeProps2 = _slicedToArray(_getTimeProps, 4),
+    timeProps = _getTimeProps2[0],
+    localeTimeProps = _getTimeProps2[1],
+    showTimeFormat = _getTimeProps2[2],
+    propFormat = _getTimeProps2[3];
+
+  // ======================= Locales ========================
+  var mergedLocale = useLocale(locale, localeTimeProps);
+  var mergedShowTime = React.useMemo(function () {
+    return fillShowTimeConfig(internalPicker, showTimeFormat, propFormat, timeProps, mergedLocale);
+  }, [internalPicker, showTimeFormat, propFormat, timeProps, mergedLocale]);
+
+  // ======================= Warning ========================
+  if (process.env.NODE_ENV !== 'production' && picker === 'time') {
+    if (['disabledHours', 'disabledMinutes', 'disabledSeconds'].some(function (key) {
+      return props[key];
+    })) {
+      warning(false, "'disabledHours', 'disabledMinutes', 'disabledSeconds' will be removed in the next major version, please use 'disabledTime' instead.");
+    }
+  }
+
+  // ======================== Props =========================
+  var filledProps = React.useMemo(function () {
+    return _objectSpread(_objectSpread({}, props), {}, {
+      prefixCls: prefixCls,
+      locale: mergedLocale,
+      picker: picker,
+      styles: styles,
+      classNames: classNames,
+      order: order,
+      components: _objectSpread({
+        input: inputRender
+      }, components),
+      clearIcon: fillClearIcon(prefixCls, allowClear, clearIcon),
+      showTime: mergedShowTime,
+      value: values,
+      defaultValue: defaultValues,
+      pickerValue: pickerValues,
+      defaultPickerValue: defaultPickerValues
+    }, updater === null || updater === void 0 ? void 0 : updater());
+  }, [props]);
+
+  // ======================== Format ========================
+  var _useFieldFormat = useFieldFormat(internalPicker, mergedLocale, format),
+    _useFieldFormat2 = _slicedToArray(_useFieldFormat, 2),
+    formatList = _useFieldFormat2[0],
+    maskFormat = _useFieldFormat2[1];
+
+  // ======================= ReadOnly =======================
+  var mergedInputReadOnly = useInputReadOnly(formatList, inputReadOnly, multiple);
+
+  // ======================= Boundary =======================
+  var disabledBoundaryDate = useDisabledBoundary(generateConfig, locale, disabledDate, minDate, maxDate);
+
+  // ====================== Invalidate ======================
+  var isInvalidateDate = useInvalidate(generateConfig, picker, disabledBoundaryDate, mergedShowTime);
+
+  // ======================== Merged ========================
+  var mergedProps = React.useMemo(function () {
+    return _objectSpread(_objectSpread({}, filledProps), {}, {
+      needConfirm: mergedNeedConfirm,
+      inputReadOnly: mergedInputReadOnly,
+      disabledDate: disabledBoundaryDate
+    });
+  }, [filledProps, mergedNeedConfirm, mergedInputReadOnly, disabledBoundaryDate]);
+  return [mergedProps, internalPicker, complexPicker, formatList, maskFormat, isInvalidateDate];
+}

node_modules/rc-picker/es/PickerInput/hooks/useInputReadOnly.d.ts

@@ -0,0 +1,2 @@
+import type { FormatType } from '../../interface';
+export default function useInputReadOnly<DateType = any>(formatList: FormatType<DateType>[], inputReadOnly?: boolean, multiple?: boolean): boolean;

node_modules/rc-picker/es/PickerInput/hooks/useInputReadOnly.js

@@ -0,0 +1,6 @@
+export default function useInputReadOnly(formatList, inputReadOnly, multiple) {
+  if (typeof formatList[0] === 'function' || multiple) {
+    return true;
+  }
+  return inputReadOnly;
+}

node_modules/rc-picker/es/PickerInput/hooks/useInvalidate.d.ts

@@ -0,0 +1,9 @@
+import type { GenerateConfig } from '../../generate';
+import type { PanelMode, RangeTimeProps, SharedPickerProps, SharedTimeProps } from '../../interface';
+/**
+ * Check if provided date is valid for the `disabledDate` & `showTime.disabledTime`.
+ */
+export default function useInvalidate<DateType extends object = any>(generateConfig: GenerateConfig<DateType>, picker: PanelMode, disabledDate?: SharedPickerProps<DateType>['disabledDate'], showTime?: SharedTimeProps<DateType> | RangeTimeProps<DateType>): (date: DateType, info?: {
+    from?: DateType;
+    activeIndex: number;
+}) => boolean;

node_modules/rc-picker/es/PickerInput/hooks/useInvalidate.js

@@ -0,0 +1,56 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { useEvent } from 'rc-util';
+/**
+ * Check if provided date is valid for the `disabledDate` & `showTime.disabledTime`.
+ */
+export default function useInvalidate(generateConfig, picker, disabledDate, showTime) {
+  // Check disabled date
+  var isInvalidate = useEvent(function (date, info) {
+    var outsideInfo = _objectSpread({
+      type: picker
+    }, info);
+    delete outsideInfo.activeIndex;
+    if (
+    // Date object is invalid
+    !generateConfig.isValidate(date) ||
+    // Date is disabled by `disabledDate`
+    disabledDate && disabledDate(date, outsideInfo)) {
+      return true;
+    }
+    if ((picker === 'date' || picker === 'time') && showTime) {
+      var _showTime$disabledTim;
+      var range = info && info.activeIndex === 1 ? 'end' : 'start';
+      var _ref = ((_showTime$disabledTim = showTime.disabledTime) === null || _showTime$disabledTim === void 0 ? void 0 : _showTime$disabledTim.call(showTime, date, range, {
+          from: outsideInfo.from
+        })) || {},
+        disabledHours = _ref.disabledHours,
+        disabledMinutes = _ref.disabledMinutes,
+        disabledSeconds = _ref.disabledSeconds,
+        disabledMilliseconds = _ref.disabledMilliseconds;
+      var legacyDisabledHours = showTime.disabledHours,
+        legacyDisabledMinutes = showTime.disabledMinutes,
+        legacyDisabledSeconds = showTime.disabledSeconds;
+      var mergedDisabledHours = disabledHours || legacyDisabledHours;
+      var mergedDisabledMinutes = disabledMinutes || legacyDisabledMinutes;
+      var mergedDisabledSeconds = disabledSeconds || legacyDisabledSeconds;
+      var hour = generateConfig.getHour(date);
+      var minute = generateConfig.getMinute(date);
+      var second = generateConfig.getSecond(date);
+      var millisecond = generateConfig.getMillisecond(date);
+      if (mergedDisabledHours && mergedDisabledHours().includes(hour)) {
+        return true;
+      }
+      if (mergedDisabledMinutes && mergedDisabledMinutes(hour).includes(minute)) {
+        return true;
+      }
+      if (mergedDisabledSeconds && mergedDisabledSeconds(hour, minute).includes(second)) {
+        return true;
+      }
+      if (disabledMilliseconds && disabledMilliseconds(hour, minute, second).includes(millisecond)) {
+        return true;
+      }
+    }
+    return false;
+  });
+  return isInvalidate;
+}

node_modules/rc-picker/es/PickerInput/hooks/useLockEffect.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Trigger `callback` immediately when `condition` is `true`.
+ * But trigger `callback` in next frame when `condition` is `false`.
+ */
+export default function useLockEffect(condition: boolean, callback: (next: boolean) => void, delayFrames?: number): void;

node_modules/rc-picker/es/PickerInput/hooks/useLockEffect.js

@@ -0,0 +1,25 @@
+import { useLayoutUpdateEffect } from "rc-util/es/hooks/useLayoutEffect";
+import raf from "rc-util/es/raf";
+import * as React from 'react';
+
+/**
+ * Trigger `callback` immediately when `condition` is `true`.
+ * But trigger `callback` in next frame when `condition` is `false`.
+ */
+export default function useLockEffect(condition, callback) {
+  var delayFrames = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+  var callbackRef = React.useRef(callback);
+  callbackRef.current = callback;
+  useLayoutUpdateEffect(function () {
+    if (condition) {
+      callbackRef.current(condition);
+    } else {
+      var id = raf(function () {
+        callbackRef.current(condition);
+      }, delayFrames);
+      return function () {
+        raf.cancel(id);
+      };
+    }
+  }, [condition]);
+}

node_modules/rc-picker/es/PickerInput/hooks/useOpen.d.ts

@@ -0,0 +1,6 @@
+import type { OpenConfig } from '../../interface';
+/**
+ * Control the open state.
+ * Will not close if activeElement is on the popup.
+ */
+export default function useOpen(open?: boolean, defaultOpen?: boolean, disabledList?: boolean[], onOpenChange?: (open: boolean) => void): [open: boolean, setOpen: (open: boolean, config?: OpenConfig) => void];

node_modules/rc-picker/es/PickerInput/hooks/useOpen.js

@@ -0,0 +1,28 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import useDelayState from "./useDelayState";
+
+/**
+ * Control the open state.
+ * Will not close if activeElement is on the popup.
+ */
+export default function useOpen(open, defaultOpen) {
+  var disabledList = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  var onOpenChange = arguments.length > 3 ? arguments[3] : undefined;
+  var mergedOpen = disabledList.every(function (disabled) {
+    return disabled;
+  }) ? false : open;
+
+  // Delay for handle the open state, in case fast shift from `open` -> `close` -> `open`
+  // const [rafOpen, setRafOpen] = useLockState(open, defaultOpen || false, onOpenChange);
+  var _useDelayState = useDelayState(mergedOpen, defaultOpen || false, onOpenChange),
+    _useDelayState2 = _slicedToArray(_useDelayState, 2),
+    rafOpen = _useDelayState2[0],
+    setRafOpen = _useDelayState2[1];
+  function setOpen(next) {
+    var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    if (!config.inherit || rafOpen) {
+      setRafOpen(next, config.force);
+    }
+  }
+  return [rafOpen, setOpen];
+}

node_modules/rc-picker/es/PickerInput/hooks/usePickerRef.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import type { PickerRef } from '../../interface';
+type PickerRefType<OptionType> = Omit<PickerRef, 'focus'> & {
+    focus: (options?: OptionType) => void;
+};
+export default function usePickerRef<OptionType>(ref: React.Ref<PickerRefType<OptionType>>): React.MutableRefObject<PickerRefType<OptionType>>;
+export {};

node_modules/rc-picker/es/PickerInput/hooks/usePickerRef.js

@@ -0,0 +1,19 @@
+import * as React from 'react';
+export default function usePickerRef(ref) {
+  var selectorRef = React.useRef();
+  React.useImperativeHandle(ref, function () {
+    var _selectorRef$current;
+    return {
+      nativeElement: (_selectorRef$current = selectorRef.current) === null || _selectorRef$current === void 0 ? void 0 : _selectorRef$current.nativeElement,
+      focus: function focus(options) {
+        var _selectorRef$current2;
+        (_selectorRef$current2 = selectorRef.current) === null || _selectorRef$current2 === void 0 || _selectorRef$current2.focus(options);
+      },
+      blur: function blur() {
+        var _selectorRef$current3;
+        (_selectorRef$current3 = selectorRef.current) === null || _selectorRef$current3 === void 0 || _selectorRef$current3.blur();
+      }
+    };
+  });
+  return selectorRef;
+}

node_modules/rc-picker/es/PickerInput/hooks/usePresets.d.ts

@@ -0,0 +1,2 @@
+import type { ValueDate } from '../../interface';
+export default function usePresets<DateType = any>(presets?: ValueDate<DateType>[], legacyRanges?: Record<string, DateType | (() => DateType)>): ValueDate<DateType>[];

node_modules/rc-picker/es/PickerInput/hooks/usePresets.js

@@ -0,0 +1,23 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import * as React from 'react';
+import warning from "rc-util/es/warning";
+export default function usePresets(presets, legacyRanges) {
+  return React.useMemo(function () {
+    if (presets) {
+      return presets;
+    }
+    if (legacyRanges) {
+      warning(false, '`ranges` is deprecated. Please use `presets` instead.');
+      return Object.entries(legacyRanges).map(function (_ref) {
+        var _ref2 = _slicedToArray(_ref, 2),
+          label = _ref2[0],
+          value = _ref2[1];
+        return {
+          label: label,
+          value: value
+        };
+      });
+    }
+    return [];
+  }, [presets, legacyRanges]);
+}

node_modules/rc-picker/es/PickerInput/hooks/useRangeActive.d.ts

@@ -0,0 +1,19 @@
+import type { RangeValueType } from '../RangePicker';
+export type OperationType = 'input' | 'panel';
+export type NextActive<DateType> = (nextValue: RangeValueType<DateType>) => number | null;
+/**
+ * When user first focus one input, any submit will trigger focus another one.
+ * When second time focus one input, submit will not trigger focus again.
+ * When click outside to close the panel, trigger event if it can trigger onChange.
+ */
+export default function useRangeActive<DateType>(disabled: boolean[], empty?: boolean[], mergedOpen?: boolean): [
+    focused: boolean,
+    triggerFocus: (focused: boolean) => void,
+    lastOperation: (type?: OperationType) => OperationType,
+    activeIndex: number,
+    setActiveIndex: (index: number) => void,
+    nextActiveIndex: NextActive<DateType>,
+    activeList: number[],
+    updateSubmitIndex: (index: number | null) => void,
+    hasActiveSubmitValue: (index: number) => boolean
+];

node_modules/rc-picker/es/PickerInput/hooks/useRangeActive.js

@@ -0,0 +1,69 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import * as React from 'react';
+import useLockEffect from "./useLockEffect";
+/**
+ * When user first focus one input, any submit will trigger focus another one.
+ * When second time focus one input, submit will not trigger focus again.
+ * When click outside to close the panel, trigger event if it can trigger onChange.
+ */
+export default function useRangeActive(disabled) {
+  var empty = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  var mergedOpen = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var _React$useState = React.useState(0),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    activeIndex = _React$useState2[0],
+    setActiveIndex = _React$useState2[1];
+  var _React$useState3 = React.useState(false),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    focused = _React$useState4[0],
+    setFocused = _React$useState4[1];
+  var activeListRef = React.useRef([]);
+  var submitIndexRef = React.useRef(null);
+  var lastOperationRef = React.useRef(null);
+  var updateSubmitIndex = function updateSubmitIndex(index) {
+    submitIndexRef.current = index;
+  };
+  var hasActiveSubmitValue = function hasActiveSubmitValue(index) {
+    return submitIndexRef.current === index;
+  };
+  var triggerFocus = function triggerFocus(nextFocus) {
+    setFocused(nextFocus);
+  };
+
+  // ============================= Record =============================
+  var lastOperation = function lastOperation(type) {
+    if (type) {
+      lastOperationRef.current = type;
+    }
+    return lastOperationRef.current;
+  };
+
+  // ============================ Strategy ============================
+  // Trigger when input enter or input blur or panel close
+  var nextActiveIndex = function nextActiveIndex(nextValue) {
+    var list = activeListRef.current;
+    var filledActiveSet = new Set(list.filter(function (index) {
+      return nextValue[index] || empty[index];
+    }));
+    var nextIndex = list[list.length - 1] === 0 ? 1 : 0;
+    if (filledActiveSet.size >= 2 || disabled[nextIndex]) {
+      return null;
+    }
+    return nextIndex;
+  };
+
+  // ============================= Effect =============================
+  // Wait in case it's from the click outside to blur
+  useLockEffect(focused || mergedOpen, function () {
+    if (!focused) {
+      activeListRef.current = [];
+      updateSubmitIndex(null);
+    }
+  });
+  React.useEffect(function () {
+    if (focused) {
+      activeListRef.current.push(activeIndex);
+    }
+  }, [focused, activeIndex]);
+  return [focused, triggerFocus, lastOperation, activeIndex, setActiveIndex, nextActiveIndex, activeListRef.current, updateSubmitIndex, hasActiveSubmitValue];
+}

node_modules/rc-picker/es/PickerInput/hooks/useRangeDisabledDate.d.ts

@@ -0,0 +1,8 @@
+import type { GenerateConfig } from '../../generate';
+import type { DisabledDate, Locale } from '../../interface';
+import type { RangeValueType } from '../RangePicker';
+/**
+ * RangePicker need additional logic to handle the `disabled` case. e.g.
+ * [disabled, enabled] should end date not before start date
+ */
+export default function useRangeDisabledDate<DateType extends object = any>(values: RangeValueType<DateType>, disabled: [boolean, boolean], activeIndexList: number[], generateConfig: GenerateConfig<DateType>, locale: Locale, disabledDate?: DisabledDate<DateType>): DisabledDate<DateType>;

node_modules/rc-picker/es/PickerInput/hooks/useRangeDisabledDate.js

@@ -0,0 +1,43 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { isSame } from "../../utils/dateUtil";
+import { getFromDate } from "../../utils/miscUtil";
+
+/**
+ * RangePicker need additional logic to handle the `disabled` case. e.g.
+ * [disabled, enabled] should end date not before start date
+ */
+export default function useRangeDisabledDate(values, disabled, activeIndexList, generateConfig, locale, disabledDate) {
+  var activeIndex = activeIndexList[activeIndexList.length - 1];
+  var rangeDisabledDate = function rangeDisabledDate(date, info) {
+    var _values = _slicedToArray(values, 2),
+      start = _values[0],
+      end = _values[1];
+    var mergedInfo = _objectSpread(_objectSpread({}, info), {}, {
+      from: getFromDate(values, activeIndexList)
+    });
+
+    // ============================ Disabled ============================
+    // Should not select days before the start date
+    if (activeIndex === 1 && disabled[0] && start &&
+    // Same date isOK
+    !isSame(generateConfig, locale, start, date, mergedInfo.type) &&
+    // Before start date
+    generateConfig.isAfter(start, date)) {
+      return true;
+    }
+
+    // Should not select days after the end date
+    if (activeIndex === 0 && disabled[1] && end &&
+    // Same date isOK
+    !isSame(generateConfig, locale, end, date, mergedInfo.type) &&
+    // After end date
+    generateConfig.isAfter(date, end)) {
+      return true;
+    }
+
+    // ============================= Origin =============================
+    return disabledDate === null || disabledDate === void 0 ? void 0 : disabledDate(date, mergedInfo);
+  };
+  return rangeDisabledDate;
+}

node_modules/rc-picker/es/PickerInput/hooks/useRangePickerValue.d.ts

@@ -0,0 +1,5 @@
+import type { GenerateConfig } from '../../generate';
+import type { InternalMode, Locale, PanelMode } from '../../interface';
+import type { RangePickerProps } from '../RangePicker';
+export declare function offsetPanelDate<DateType = any>(generateConfig: GenerateConfig<DateType>, picker: InternalMode, date: DateType, offset: number): DateType;
+export default function useRangePickerValue<DateType extends object, ValueType extends DateType[]>(generateConfig: GenerateConfig<DateType>, locale: Locale, calendarValue: ValueType, modes: PanelMode[], open: boolean, activeIndex: number, pickerMode: InternalMode, multiplePanel: boolean, defaultPickerValue?: ValueType, pickerValue?: ValueType, timeDefaultValue?: ValueType, onPickerValueChange?: RangePickerProps<DateType>['onPickerValueChange'], minDate?: DateType, maxDate?: DateType): [currentIndexPickerValue: DateType, setCurrentIndexPickerValue: (value: DateType) => void];

node_modules/rc-picker/es/PickerInput/hooks/useRangePickerValue.js

@@ -0,0 +1,187 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { useMergedState } from 'rc-util';
+import useLayoutEffect from "rc-util/es/hooks/useLayoutEffect";
+import * as React from 'react';
+import { fillTime, isSame } from "../../utils/dateUtil";
+export function offsetPanelDate(generateConfig, picker, date, offset) {
+  switch (picker) {
+    case 'date':
+    case 'week':
+      return generateConfig.addMonth(date, offset);
+    case 'month':
+    case 'quarter':
+      return generateConfig.addYear(date, offset);
+    case 'year':
+      return generateConfig.addYear(date, offset * 10);
+    case 'decade':
+      return generateConfig.addYear(date, offset * 100);
+    default:
+      return date;
+  }
+}
+var EMPTY_LIST = [];
+export default function useRangePickerValue(generateConfig, locale, calendarValue, modes, open, activeIndex, pickerMode, multiplePanel) {
+  var defaultPickerValue = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : EMPTY_LIST;
+  var pickerValue = arguments.length > 9 && arguments[9] !== undefined ? arguments[9] : EMPTY_LIST;
+  var timeDefaultValue = arguments.length > 10 && arguments[10] !== undefined ? arguments[10] : EMPTY_LIST;
+  var onPickerValueChange = arguments.length > 11 ? arguments[11] : undefined;
+  var minDate = arguments.length > 12 ? arguments[12] : undefined;
+  var maxDate = arguments.length > 13 ? arguments[13] : undefined;
+  var isTimePicker = pickerMode === 'time';
+
+  // ======================== Active ========================
+  // `activeIndex` must be valid to avoid getting empty `pickerValue`
+  var mergedActiveIndex = activeIndex || 0;
+
+  // ===================== Picker Value =====================
+  var getDefaultPickerValue = function getDefaultPickerValue(index) {
+    var now = generateConfig.getNow();
+    if (isTimePicker) {
+      now = fillTime(generateConfig, now);
+    }
+    return defaultPickerValue[index] || calendarValue[index] || now;
+  };
+
+  // Align `pickerValue` with `showTime.defaultValue`
+  var _pickerValue = _slicedToArray(pickerValue, 2),
+    startPickerValue = _pickerValue[0],
+    endPickerValue = _pickerValue[1];
+
+  // PickerValue state
+  var _useMergedState = useMergedState(function () {
+      return getDefaultPickerValue(0);
+    }, {
+      value: startPickerValue
+    }),
+    _useMergedState2 = _slicedToArray(_useMergedState, 2),
+    mergedStartPickerValue = _useMergedState2[0],
+    setStartPickerValue = _useMergedState2[1];
+  var _useMergedState3 = useMergedState(function () {
+      return getDefaultPickerValue(1);
+    }, {
+      value: endPickerValue
+    }),
+    _useMergedState4 = _slicedToArray(_useMergedState3, 2),
+    mergedEndPickerValue = _useMergedState4[0],
+    setEndPickerValue = _useMergedState4[1];
+
+  // Current PickerValue
+  var currentPickerValue = React.useMemo(function () {
+    var current = [mergedStartPickerValue, mergedEndPickerValue][mergedActiveIndex];
+
+    // Merge the `showTime.defaultValue` into `pickerValue`
+    return isTimePicker ? current : fillTime(generateConfig, current, timeDefaultValue[mergedActiveIndex]);
+  }, [isTimePicker, mergedStartPickerValue, mergedEndPickerValue, mergedActiveIndex, generateConfig, timeDefaultValue]);
+  var setCurrentPickerValue = function setCurrentPickerValue(nextPickerValue) {
+    var source = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'panel';
+    var updater = [setStartPickerValue, setEndPickerValue][mergedActiveIndex];
+    updater(nextPickerValue);
+    var clone = [mergedStartPickerValue, mergedEndPickerValue];
+    clone[mergedActiveIndex] = nextPickerValue;
+    if (onPickerValueChange && (!isSame(generateConfig, locale, mergedStartPickerValue, clone[0], pickerMode) || !isSame(generateConfig, locale, mergedEndPickerValue, clone[1], pickerMode))) {
+      onPickerValueChange(clone, {
+        source: source,
+        range: mergedActiveIndex === 1 ? 'end' : 'start',
+        mode: modes
+      });
+    }
+  };
+
+  // ======================== Effect ========================
+  /**
+   * EndDate pickerValue is little different. It should be:
+   * - If date picker (without time), endDate is not same year & month as startDate
+   *   - pickerValue minus one month
+   * - Else pass directly
+   */
+  var getEndDatePickerValue = function getEndDatePickerValue(startDate, endDate) {
+    if (multiplePanel) {
+      // Basic offset
+      var SAME_CHECKER = {
+        date: 'month',
+        week: 'month',
+        month: 'year',
+        quarter: 'year'
+      };
+      var mode = SAME_CHECKER[pickerMode];
+      if (mode && !isSame(generateConfig, locale, startDate, endDate, mode)) {
+        return offsetPanelDate(generateConfig, pickerMode, endDate, -1);
+      }
+
+      // Year offset
+      if (pickerMode === 'year' && startDate) {
+        var srcYear = Math.floor(generateConfig.getYear(startDate) / 10);
+        var tgtYear = Math.floor(generateConfig.getYear(endDate) / 10);
+        if (srcYear !== tgtYear) {
+          return offsetPanelDate(generateConfig, pickerMode, endDate, -1);
+        }
+      }
+    }
+    return endDate;
+  };
+
+  // >>> When switch field, reset the picker value as prev field picker value
+  var prevActiveIndexRef = React.useRef(null);
+  useLayoutEffect(function () {
+    if (open) {
+      if (!defaultPickerValue[mergedActiveIndex]) {
+        var nextPickerValue = isTimePicker ? null : generateConfig.getNow();
+
+        /**
+         * 1. If has prevActiveIndex, use it to avoid panel jump
+         * 2. If current field has value
+         *    - If `activeIndex` is 1 and `calendarValue[0]` is not same panel as `calendarValue[1]`,
+         *      offset `calendarValue[1]` and set it
+         *    - Else use `calendarValue[activeIndex]`
+         * 3. If current field has no value but another field has value, use another field value
+         * 4. Else use now (not any `calendarValue` can ref)
+         */
+
+        if (prevActiveIndexRef.current !== null && prevActiveIndexRef.current !== mergedActiveIndex) {
+          // If from another field, not jump picker value
+          nextPickerValue = [mergedStartPickerValue, mergedEndPickerValue][mergedActiveIndex ^ 1];
+        } else if (calendarValue[mergedActiveIndex]) {
+          // Current field has value
+          nextPickerValue = mergedActiveIndex === 0 ? calendarValue[0] : getEndDatePickerValue(calendarValue[0], calendarValue[1]);
+        } else if (calendarValue[mergedActiveIndex ^ 1]) {
+          // Current field has no value but another field has value
+          nextPickerValue = calendarValue[mergedActiveIndex ^ 1];
+        }
+
+        // Only sync when has value, this will sync in the `min-max` logic
+        if (nextPickerValue) {
+          // nextPickerValue < minDate
+          if (minDate && generateConfig.isAfter(minDate, nextPickerValue)) {
+            nextPickerValue = minDate;
+          }
+
+          // maxDate < nextPickerValue
+          var offsetPickerValue = multiplePanel ? offsetPanelDate(generateConfig, pickerMode, nextPickerValue, 1) : nextPickerValue;
+          if (maxDate && generateConfig.isAfter(offsetPickerValue, maxDate)) {
+            nextPickerValue = multiplePanel ? offsetPanelDate(generateConfig, pickerMode, maxDate, -1) : maxDate;
+          }
+          setCurrentPickerValue(nextPickerValue, 'reset');
+        }
+      }
+    }
+  }, [open, mergedActiveIndex, calendarValue[mergedActiveIndex]]);
+
+  // >>> Reset prevActiveIndex when panel closed
+  React.useEffect(function () {
+    if (open) {
+      prevActiveIndexRef.current = mergedActiveIndex;
+    } else {
+      prevActiveIndexRef.current = null;
+    }
+  }, [open, mergedActiveIndex]);
+
+  // >>> defaultPickerValue: Resync to `defaultPickerValue` for each panel focused
+  useLayoutEffect(function () {
+    if (open && defaultPickerValue) {
+      if (defaultPickerValue[mergedActiveIndex]) {
+        setCurrentPickerValue(defaultPickerValue[mergedActiveIndex], 'reset');
+      }
+    }
+  }, [open, mergedActiveIndex]);
+  return [currentPickerValue, setCurrentPickerValue];
+}

node_modules/rc-picker/es/PickerInput/hooks/useRangeValue.d.ts

@@ -0,0 +1,28 @@
+import type { GenerateConfig } from '../../generate';
+import type { BaseInfo, FormatType, Locale, ReplaceListType } from '../../interface';
+import type { RangePickerProps } from '../RangePicker';
+import type { ReplacedPickerProps } from '../SinglePicker';
+type TriggerCalendarChange<ValueType extends object[]> = (calendarValues: ValueType) => void;
+/**
+ * Control the internal `value` align with prop `value` and provide a temp `calendarValue` for ui.
+ * `calendarValue` will be reset when blur & focus & open.
+ */
+export declare function useInnerValue<ValueType extends DateType[], DateType extends object = any>(generateConfig: GenerateConfig<DateType>, locale: Locale, formatList: FormatType[], 
+/** Used for RangePicker. `true` means [DateType, DateType] or will be DateType[] */
+rangeValue: boolean, 
+/**
+ * Trigger order when trigger calendar value change.
+ * This should only used in SinglePicker with `multiple` mode.
+ * So when `rangeValue` is `true`, order will be ignored.
+ */
+order: boolean, defaultValue?: ValueType, value?: ValueType, onCalendarChange?: (dates: ValueType, dateStrings: ReplaceListType<Required<ValueType>, string>, info: BaseInfo) => void, onOk?: (dates: ValueType) => void): readonly [ValueType, (updater: ValueType | ((origin: ValueType) => ValueType), ignoreDestroy?: boolean) => void, (useControlledValueFirst?: boolean) => ValueType, TriggerCalendarChange<ValueType>, () => void];
+export default function useRangeValue<ValueType extends DateType[], DateType extends object = any>(info: Pick<RangePickerProps<DateType>, 'generateConfig' | 'locale' | 'allowEmpty' | 'order' | 'picker'> & ReplacedPickerProps<DateType>, mergedValue: ValueType, setInnerValue: (nextValue: ValueType) => void, getCalendarValue: () => ValueType, triggerCalendarChange: TriggerCalendarChange<ValueType>, disabled: ReplaceListType<Required<ValueType>, boolean>, formatList: FormatType[], focused: boolean, open: boolean, isInvalidateDate: (date: DateType, info?: {
+    from?: DateType;
+    activeIndex: number;
+}) => boolean): [
+    /** Trigger `onChange` by check `disabledDate` */
+    flushSubmit: (index: number, needTriggerChange: boolean) => void,
+    /** Trigger `onChange` directly without check `disabledDate` */
+    triggerSubmitChange: (value: ValueType) => boolean
+];
+export {};

node_modules/rc-picker/es/PickerInput/hooks/useRangeValue.js

@@ -0,0 +1,289 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import { useEvent, useMergedState } from 'rc-util';
+import * as React from 'react';
+import useSyncState from "../../hooks/useSyncState";
+import { formatValue, isSame, isSameTimestamp } from "../../utils/dateUtil";
+import { fillIndex } from "../../utils/miscUtil";
+import useLockEffect from "./useLockEffect";
+var EMPTY_VALUE = [];
+
+// Submit Logic:
+// * ✅ Value:
+//    * merged value using controlled value, if not, use stateValue
+//    * When merged value change, [1] resync calendar value and submit value
+// * ✅ Calender Value:
+//    * 💻 When user typing is validate, change the calendar value
+//    * 🌅 When user click on the panel, change the calendar value
+// * Submit Value:
+//    * 💻 When user blur the input, flush calendar value to submit value
+//    * 🌅 When user click on the panel is no needConfirm, flush calendar value to submit value
+//    * 🌅 When user click on the panel is needConfirm and click OK, flush calendar value to submit value
+// * Blur logic & close logic:
+//    * ✅ For value, always try flush submit
+//    * ✅ If `needConfirm`, reset as [1]
+//    * Else (`!needConfirm`)
+//      * If has another index field, active another index
+// * ✅ Flush submit:
+//    * If all the start & end field is confirmed or all blur or panel closed
+//    * Update `needSubmit` mark to true
+//    * trigger onChange by `needSubmit` and update stateValue
+
+function useUtil(generateConfig, locale, formatList) {
+  var getDateTexts = function getDateTexts(dates) {
+    return dates.map(function (date) {
+      return formatValue(date, {
+        generateConfig: generateConfig,
+        locale: locale,
+        format: formatList[0]
+      });
+    });
+  };
+  var isSameDates = function isSameDates(source, target) {
+    var maxLen = Math.max(source.length, target.length);
+    var diffIndex = -1;
+    for (var i = 0; i < maxLen; i += 1) {
+      var prev = source[i] || null;
+      var next = target[i] || null;
+      if (prev !== next && !isSameTimestamp(generateConfig, prev, next)) {
+        diffIndex = i;
+        break;
+      }
+    }
+    return [diffIndex < 0, diffIndex !== 0];
+  };
+  return [getDateTexts, isSameDates];
+}
+function orderDates(dates, generateConfig) {
+  return _toConsumableArray(dates).sort(function (a, b) {
+    return generateConfig.isAfter(a, b) ? 1 : -1;
+  });
+}
+
+/**
+ * Used for internal value management.
+ * It should always use `mergedValue` in render logic
+ */
+function useCalendarValue(mergedValue) {
+  var _useSyncState = useSyncState(mergedValue),
+    _useSyncState2 = _slicedToArray(_useSyncState, 2),
+    calendarValue = _useSyncState2[0],
+    setCalendarValue = _useSyncState2[1];
+
+  /** Sync calendarValue & submitValue back with value */
+  var syncWithValue = useEvent(function () {
+    setCalendarValue(mergedValue);
+  });
+  React.useEffect(function () {
+    syncWithValue();
+  }, [mergedValue]);
+  return [calendarValue, setCalendarValue];
+}
+
+/**
+ * Control the internal `value` align with prop `value` and provide a temp `calendarValue` for ui.
+ * `calendarValue` will be reset when blur & focus & open.
+ */
+export function useInnerValue(generateConfig, locale, formatList, /** Used for RangePicker. `true` means [DateType, DateType] or will be DateType[] */
+rangeValue,
+/**
+ * Trigger order when trigger calendar value change.
+ * This should only used in SinglePicker with `multiple` mode.
+ * So when `rangeValue` is `true`, order will be ignored.
+ */
+order, defaultValue, value, onCalendarChange, onOk) {
+  // This is the root value which will sync with controlled or uncontrolled value
+  var _useMergedState = useMergedState(defaultValue, {
+      value: value
+    }),
+    _useMergedState2 = _slicedToArray(_useMergedState, 2),
+    innerValue = _useMergedState2[0],
+    setInnerValue = _useMergedState2[1];
+  var mergedValue = innerValue || EMPTY_VALUE;
+
+  // ========================= Inner Values =========================
+  var _useCalendarValue = useCalendarValue(mergedValue),
+    _useCalendarValue2 = _slicedToArray(_useCalendarValue, 2),
+    calendarValue = _useCalendarValue2[0],
+    setCalendarValue = _useCalendarValue2[1];
+
+  // ============================ Change ============================
+  var _useUtil = useUtil(generateConfig, locale, formatList),
+    _useUtil2 = _slicedToArray(_useUtil, 2),
+    getDateTexts = _useUtil2[0],
+    isSameDates = _useUtil2[1];
+  var triggerCalendarChange = useEvent(function (nextCalendarValues) {
+    var clone = _toConsumableArray(nextCalendarValues);
+    if (rangeValue) {
+      for (var i = 0; i < 2; i += 1) {
+        clone[i] = clone[i] || null;
+      }
+    } else if (order) {
+      clone = orderDates(clone.filter(function (date) {
+        return date;
+      }), generateConfig);
+    }
+
+    // Update merged value
+    var _isSameDates = isSameDates(calendarValue(), clone),
+      _isSameDates2 = _slicedToArray(_isSameDates, 2),
+      isSameMergedDates = _isSameDates2[0],
+      isSameStart = _isSameDates2[1];
+    if (!isSameMergedDates) {
+      setCalendarValue(clone);
+
+      // Trigger calendar change event
+      if (onCalendarChange) {
+        var cellTexts = getDateTexts(clone);
+        onCalendarChange(clone, cellTexts, {
+          range: isSameStart ? 'end' : 'start'
+        });
+      }
+    }
+  });
+  var triggerOk = function triggerOk() {
+    if (onOk) {
+      onOk(calendarValue());
+    }
+  };
+  return [mergedValue, setInnerValue, calendarValue, triggerCalendarChange, triggerOk];
+}
+export default function useRangeValue(info, mergedValue, setInnerValue, getCalendarValue, triggerCalendarChange, disabled, formatList, focused, open, isInvalidateDate) {
+  var generateConfig = info.generateConfig,
+    locale = info.locale,
+    picker = info.picker,
+    onChange = info.onChange,
+    allowEmpty = info.allowEmpty,
+    order = info.order;
+  var orderOnChange = disabled.some(function (d) {
+    return d;
+  }) ? false : order;
+
+  // ============================= Util =============================
+  var _useUtil3 = useUtil(generateConfig, locale, formatList),
+    _useUtil4 = _slicedToArray(_useUtil3, 2),
+    getDateTexts = _useUtil4[0],
+    isSameDates = _useUtil4[1];
+
+  // ============================ Values ============================
+  // Used for trigger `onChange` event.
+  // Record current value which is wait for submit.
+  var _useSyncState3 = useSyncState(mergedValue),
+    _useSyncState4 = _slicedToArray(_useSyncState3, 2),
+    submitValue = _useSyncState4[0],
+    setSubmitValue = _useSyncState4[1];
+
+  /** Sync calendarValue & submitValue back with value */
+  var syncWithValue = useEvent(function () {
+    setSubmitValue(mergedValue);
+  });
+  React.useEffect(function () {
+    syncWithValue();
+  }, [mergedValue]);
+
+  // ============================ Submit ============================
+  var triggerSubmit = useEvent(function (nextValue) {
+    var isNullValue = nextValue === null;
+    var clone = _toConsumableArray(nextValue || submitValue());
+
+    // Fill null value
+    if (isNullValue) {
+      var maxLen = Math.max(disabled.length, clone.length);
+      for (var i = 0; i < maxLen; i += 1) {
+        if (!disabled[i]) {
+          clone[i] = null;
+        }
+      }
+    }
+
+    // Only when exist value to sort
+    if (orderOnChange && clone[0] && clone[1]) {
+      clone = orderDates(clone, generateConfig);
+    }
+
+    // Sync `calendarValue`
+    triggerCalendarChange(clone);
+
+    // ========= Validate check =========
+    var _clone = clone,
+      _clone2 = _slicedToArray(_clone, 2),
+      start = _clone2[0],
+      end = _clone2[1];
+
+    // >>> Empty
+    var startEmpty = !start;
+    var endEmpty = !end;
+    var validateEmptyDateRange = allowEmpty ?
+    // Validate empty start
+    (!startEmpty || allowEmpty[0]) && (
+    // Validate empty end
+    !endEmpty || allowEmpty[1]) : true;
+
+    // >>> Order
+    var validateOrder = !order || startEmpty || endEmpty || isSame(generateConfig, locale, start, end, picker) || generateConfig.isAfter(end, start);
+
+    // >>> Invalid
+    var validateDates =
+    // Validate start
+    (disabled[0] || !start || !isInvalidateDate(start, {
+      activeIndex: 0
+    })) && (
+    // Validate end
+    disabled[1] || !end || !isInvalidateDate(end, {
+      from: start,
+      activeIndex: 1
+    }));
+    // >>> Result
+    var allPassed =
+    // Null value is from clear button
+    isNullValue ||
+    // Normal check
+    validateEmptyDateRange && validateOrder && validateDates;
+    if (allPassed) {
+      // Sync value with submit value
+      setInnerValue(clone);
+      var _isSameDates3 = isSameDates(clone, mergedValue),
+        _isSameDates4 = _slicedToArray(_isSameDates3, 1),
+        isSameMergedDates = _isSameDates4[0];
+
+      // Trigger `onChange` if needed
+      if (onChange && !isSameMergedDates) {
+        onChange(
+        // Return null directly if all date are empty
+        isNullValue && clone.every(function (val) {
+          return !val;
+        }) ? null : clone, getDateTexts(clone));
+      }
+    }
+    return allPassed;
+  });
+
+  // ========================= Flush Submit =========================
+  var flushSubmit = useEvent(function (index, needTriggerChange) {
+    var nextSubmitValue = fillIndex(submitValue(), index, getCalendarValue()[index]);
+    setSubmitValue(nextSubmitValue);
+    if (needTriggerChange) {
+      triggerSubmit();
+    }
+  });
+
+  // ============================ Effect ============================
+  // All finished action trigger after 2 frames
+  var interactiveFinished = !focused && !open;
+  useLockEffect(!interactiveFinished, function () {
+    if (interactiveFinished) {
+      // Always try to trigger submit first
+      triggerSubmit();
+
+      // Trigger calendar change since this is a effect reset
+      // https://github.com/ant-design/ant-design/issues/22351
+      triggerCalendarChange(mergedValue);
+
+      // Sync with value anyway
+      syncWithValue();
+    }
+  }, 2);
+
+  // ============================ Return ============================
+  return [flushSubmit, triggerSubmit];
+}

node_modules/rc-picker/es/PickerInput/hooks/useShowNow.d.ts

@@ -0,0 +1,2 @@
+import type { InternalMode, PanelMode } from '../../interface';
+export default function useShowNow(picker: InternalMode, mode: PanelMode, showNow?: boolean, showToday?: boolean, rangePicker?: boolean): boolean;

node_modules/rc-picker/es/PickerInput/hooks/useShowNow.js

@@ -0,0 +1,14 @@
+export default function useShowNow(picker, mode, showNow, showToday, rangePicker) {
+  if (mode !== 'date' && mode !== 'time') {
+    return false;
+  }
+  if (showNow !== undefined) {
+    return showNow;
+  }
+
+  // Compatible with old version `showToday`
+  if (showToday !== undefined) {
+    return showToday;
+  }
+  return !rangePicker && (picker === 'date' || picker === 'time');
+}