@rc-component/picker 1.0.0

package/es/PickerInput/hooks/useDisabledBoundary.js

@@ -0,0 +1,20 @@
+import { useEvent } from '@rc-component/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;
+}

package/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];

package/es/PickerInput/hooks/useFieldFormat.js

@@ -0,0 +1,18 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+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]);
+}

package/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];

package/es/PickerInput/hooks/useFieldsInvalidate.js

@@ -0,0 +1,55 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+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];
+}

package/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 {};

package/es/PickerInput/hooks/useFilledProps.js

@@ -0,0 +1,155 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import { warning } from '@rc-component/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];
+}

package/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;

package/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;
+}

package/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;

package/es/PickerInput/hooks/useInvalidate.js

@@ -0,0 +1,61 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { useEvent } from '@rc-component/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;
+}

package/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;

package/es/PickerInput/hooks/useLockEffect.js

@@ -0,0 +1,25 @@
+import { useLayoutUpdateEffect } from "@rc-component/util/es/hooks/useLayoutEffect";
+import raf from "@rc-component/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]);
+}

package/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];

package/es/PickerInput/hooks/useOpen.js

@@ -0,0 +1,33 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+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];
+}

package/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 {};

package/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;
+}

package/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>[];

package/es/PickerInput/hooks/usePresets.js

@@ -0,0 +1,28 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import * as React from 'react';
+import warning from "@rc-component/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]);
+}

package/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
+];

package/es/PickerInput/hooks/useRangeActive.js

@@ -0,0 +1,74 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+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];
+}

package/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>;