@rc-component/picker 1.0.0

package/es/PickerInput/Popup/PopupPanel.js

@@ -0,0 +1,84 @@
+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 _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+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 * as React from 'react';
+import PickerPanel from "../../PickerPanel";
+import { PickerHackContext } from "../../PickerPanel/context";
+import PickerContext from "../context";
+import { offsetPanelDate } from "../hooks/useRangePickerValue";
+export default function PopupPanel(props) {
+  var picker = props.picker,
+    multiplePanel = props.multiplePanel,
+    pickerValue = props.pickerValue,
+    onPickerValueChange = props.onPickerValueChange,
+    needConfirm = props.needConfirm,
+    onSubmit = props.onSubmit,
+    range = props.range,
+    hoverValue = props.hoverValue;
+  var _React$useContext = React.useContext(PickerContext),
+    prefixCls = _React$useContext.prefixCls,
+    generateConfig = _React$useContext.generateConfig;
+
+  // ======================== Offset ========================
+  var internalOffsetDate = React.useCallback(function (date, offset) {
+    return offsetPanelDate(generateConfig, picker, date, offset);
+  }, [generateConfig, picker]);
+  var nextPickerValue = React.useMemo(function () {
+    return internalOffsetDate(pickerValue, 1);
+  }, [pickerValue, internalOffsetDate]);
+
+  // Outside
+  var onSecondPickerValueChange = function onSecondPickerValueChange(nextDate) {
+    onPickerValueChange(internalOffsetDate(nextDate, -1));
+  };
+
+  // ======================= Context ========================
+  var sharedContext = {
+    onCellDblClick: function onCellDblClick() {
+      if (needConfirm) {
+        onSubmit();
+      }
+    }
+  };
+  var hideHeader = picker === 'time';
+
+  // ======================== Props =========================
+  var pickerProps = _objectSpread(_objectSpread({}, props), {}, {
+    hoverValue: null,
+    hoverRangeValue: null,
+    hideHeader: hideHeader
+  });
+  if (range) {
+    pickerProps.hoverRangeValue = hoverValue;
+  } else {
+    pickerProps.hoverValue = hoverValue;
+  }
+
+  // ======================== Render ========================
+  // Multiple
+  if (multiplePanel) {
+    return /*#__PURE__*/React.createElement("div", {
+      className: "".concat(prefixCls, "-panels")
+    }, /*#__PURE__*/React.createElement(PickerHackContext.Provider, {
+      value: _objectSpread(_objectSpread({}, sharedContext), {}, {
+        hideNext: true
+      })
+    }, /*#__PURE__*/React.createElement(PickerPanel, pickerProps)), /*#__PURE__*/React.createElement(PickerHackContext.Provider, {
+      value: _objectSpread(_objectSpread({}, sharedContext), {}, {
+        hidePrev: true
+      })
+    }, /*#__PURE__*/React.createElement(PickerPanel, _extends({}, pickerProps, {
+      pickerValue: nextPickerValue,
+      onPickerValueChange: onSecondPickerValueChange
+    }))));
+  }
+
+  // Single
+  return /*#__PURE__*/React.createElement(PickerHackContext.Provider, {
+    value: _objectSpread({}, sharedContext)
+  }, /*#__PURE__*/React.createElement(PickerPanel, pickerProps));
+}

package/es/PickerInput/Popup/PresetPanel.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import type { ValueDate } from '../../interface';
+export interface PresetPanelProps<ValueType = any> {
+    prefixCls: string;
+    presets: ValueDate<ValueType>[];
+    onClick: (value: ValueType) => void;
+    onHover: (value: ValueType) => void;
+}
+export default function PresetPanel<DateType extends object = any>(props: PresetPanelProps<DateType>): React.JSX.Element;

package/es/PickerInput/Popup/PresetPanel.js

@@ -0,0 +1,31 @@
+import * as React from 'react';
+function executeValue(value) {
+  return typeof value === 'function' ? value() : value;
+}
+export default function PresetPanel(props) {
+  var prefixCls = props.prefixCls,
+    presets = props.presets,
+    _onClick = props.onClick,
+    onHover = props.onHover;
+  if (!presets.length) {
+    return null;
+  }
+  return /*#__PURE__*/React.createElement("div", {
+    className: "".concat(prefixCls, "-presets")
+  }, /*#__PURE__*/React.createElement("ul", null, presets.map(function (_ref, index) {
+    var label = _ref.label,
+      value = _ref.value;
+    return /*#__PURE__*/React.createElement("li", {
+      key: index,
+      onClick: function onClick() {
+        _onClick(executeValue(value));
+      },
+      onMouseEnter: function onMouseEnter() {
+        onHover(executeValue(value));
+      },
+      onMouseLeave: function onMouseLeave() {
+        onHover(null);
+      }
+    }, label);
+  })));
+}

package/es/PickerInput/Popup/index.d.ts

@@ -0,0 +1,20 @@
+import * as React from 'react';
+import type { RangeTimeProps, SharedPickerProps, SharedTimeProps, ValueDate } from '../../interface';
+import { type FooterProps } from './Footer';
+import { type PopupPanelProps } from './PopupPanel';
+export type PopupShowTimeConfig<DateType extends object = any> = Omit<RangeTimeProps<DateType>, 'defaultValue' | 'defaultOpenValue' | 'disabledTime'> & Pick<SharedTimeProps<DateType>, 'disabledTime'>;
+export interface PopupProps<DateType extends object = any, PresetValue = DateType> extends Pick<React.InputHTMLAttributes<HTMLDivElement>, 'onFocus' | 'onBlur'>, FooterProps<DateType>, PopupPanelProps<DateType> {
+    panelRender?: SharedPickerProps['panelRender'];
+    presets: ValueDate<DateType>[];
+    onPresetHover: (presetValue: PresetValue) => void;
+    onPresetSubmit: (presetValue: PresetValue) => void;
+    activeInfo?: [activeInputLeft: number, activeInputRight: number, selectorWidth: number];
+    direction?: 'ltr' | 'rtl';
+    /** TimePicker or showTime only */
+    defaultOpenValue: DateType;
+    needConfirm: boolean;
+    isInvalid: (date: DateType | DateType[]) => boolean;
+    onOk: VoidFunction;
+    onPanelMouseDown?: React.MouseEventHandler<HTMLDivElement>;
+}
+export default function Popup<DateType extends object = any>(props: PopupProps<DateType>): React.JSX.Element;

package/es/PickerInput/Popup/index.js

@@ -0,0 +1,198 @@
+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 _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 _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+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 classNames from 'classnames';
+import ResizeObserver from '@rc-component/resize-observer';
+import * as React from 'react';
+import { toArray } from "../../utils/miscUtil";
+import PickerContext from "../context";
+import Footer from "./Footer";
+import PopupPanel from "./PopupPanel";
+import PresetPanel from "./PresetPanel";
+export default function Popup(props) {
+  var panelRender = props.panelRender,
+    internalMode = props.internalMode,
+    picker = props.picker,
+    showNow = props.showNow,
+    range = props.range,
+    multiple = props.multiple,
+    _props$activeInfo = props.activeInfo,
+    activeInfo = _props$activeInfo === void 0 ? [0, 0, 0] : _props$activeInfo,
+    presets = props.presets,
+    onPresetHover = props.onPresetHover,
+    onPresetSubmit = props.onPresetSubmit,
+    onFocus = props.onFocus,
+    onBlur = props.onBlur,
+    onPanelMouseDown = props.onPanelMouseDown,
+    direction = props.direction,
+    value = props.value,
+    onSelect = props.onSelect,
+    isInvalid = props.isInvalid,
+    defaultOpenValue = props.defaultOpenValue,
+    onOk = props.onOk,
+    onSubmit = props.onSubmit;
+  var _React$useContext = React.useContext(PickerContext),
+    prefixCls = _React$useContext.prefixCls;
+  var panelPrefixCls = "".concat(prefixCls, "-panel");
+  var rtl = direction === 'rtl';
+
+  // ========================= Refs =========================
+  var arrowRef = React.useRef(null);
+  var wrapperRef = React.useRef(null);
+
+  // ======================== Offset ========================
+  var _React$useState = React.useState(0),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    containerWidth = _React$useState2[0],
+    setContainerWidth = _React$useState2[1];
+  var _React$useState3 = React.useState(0),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    containerOffset = _React$useState4[0],
+    setContainerOffset = _React$useState4[1];
+  var _React$useState5 = React.useState(0),
+    _React$useState6 = _slicedToArray(_React$useState5, 2),
+    arrowOffset = _React$useState6[0],
+    setArrowOffset = _React$useState6[1];
+  var onResize = function onResize(info) {
+    if (info.width) {
+      setContainerWidth(info.width);
+    }
+  };
+  var _activeInfo = _slicedToArray(activeInfo, 3),
+    activeInputLeft = _activeInfo[0],
+    activeInputRight = _activeInfo[1],
+    selectorWidth = _activeInfo[2];
+  var _React$useState7 = React.useState(0),
+    _React$useState8 = _slicedToArray(_React$useState7, 2),
+    retryTimes = _React$useState8[0],
+    setRetryTimes = _React$useState8[1];
+  React.useEffect(function () {
+    setRetryTimes(10);
+  }, [activeInputLeft]);
+  React.useEffect(function () {
+    // `activeOffset` is always align with the active input element
+    // So we need only check container contains the `activeOffset`
+    if (range && wrapperRef.current) {
+      var _arrowRef$current;
+      // Offset in case container has border radius
+      var arrowWidth = ((_arrowRef$current = arrowRef.current) === null || _arrowRef$current === void 0 ? void 0 : _arrowRef$current.offsetWidth) || 0;
+
+      // Arrow Offset
+      var wrapperRect = wrapperRef.current.getBoundingClientRect();
+      if (!wrapperRect.height || wrapperRect.right < 0) {
+        setRetryTimes(function (times) {
+          return Math.max(0, times - 1);
+        });
+        return;
+      }
+      var nextArrowOffset = (rtl ? activeInputRight - arrowWidth : activeInputLeft) - wrapperRect.left;
+      setArrowOffset(nextArrowOffset);
+
+      // Container Offset
+      if (containerWidth && containerWidth < selectorWidth) {
+        var offset = rtl ? wrapperRect.right - (activeInputRight - arrowWidth + containerWidth) : activeInputLeft + arrowWidth - wrapperRect.left - containerWidth;
+        var safeOffset = Math.max(0, offset);
+        setContainerOffset(safeOffset);
+      } else {
+        setContainerOffset(0);
+      }
+    }
+  }, [retryTimes, rtl, containerWidth, activeInputLeft, activeInputRight, selectorWidth, range]);
+
+  // ======================== Custom ========================
+  function filterEmpty(list) {
+    return list.filter(function (item) {
+      return item;
+    });
+  }
+  var valueList = React.useMemo(function () {
+    return filterEmpty(toArray(value));
+  }, [value]);
+  var isTimePickerEmptyValue = picker === 'time' && !valueList.length;
+  var footerSubmitValue = React.useMemo(function () {
+    if (isTimePickerEmptyValue) {
+      return filterEmpty([defaultOpenValue]);
+    }
+    return valueList;
+  }, [isTimePickerEmptyValue, valueList, defaultOpenValue]);
+  var popupPanelValue = isTimePickerEmptyValue ? defaultOpenValue : valueList;
+  var disableSubmit = React.useMemo(function () {
+    // Empty is invalid
+    if (!footerSubmitValue.length) {
+      return true;
+    }
+    return footerSubmitValue.some(function (val) {
+      return isInvalid(val);
+    });
+  }, [footerSubmitValue, isInvalid]);
+  var onFooterSubmit = function onFooterSubmit() {
+    // For TimePicker, we will additional trigger the value update
+    if (isTimePickerEmptyValue) {
+      onSelect(defaultOpenValue);
+    }
+    onOk();
+    onSubmit();
+  };
+  var mergedNodes = /*#__PURE__*/React.createElement("div", {
+    className: "".concat(prefixCls, "-panel-layout")
+  }, /*#__PURE__*/React.createElement(PresetPanel, {
+    prefixCls: prefixCls,
+    presets: presets,
+    onClick: onPresetSubmit,
+    onHover: onPresetHover
+  }), /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement(PopupPanel, _extends({}, props, {
+    value: popupPanelValue
+  })), /*#__PURE__*/React.createElement(Footer, _extends({}, props, {
+    showNow: multiple ? false : showNow,
+    invalid: disableSubmit,
+    onSubmit: onFooterSubmit
+  }))));
+  if (panelRender) {
+    mergedNodes = panelRender(mergedNodes);
+  }
+
+  // ======================== Render ========================
+  var containerPrefixCls = "".concat(panelPrefixCls, "-container");
+  var marginLeft = 'marginLeft';
+  var marginRight = 'marginRight';
+
+  // Container
+  var renderNode = /*#__PURE__*/React.createElement("div", {
+    onMouseDown: onPanelMouseDown,
+    tabIndex: -1,
+    className: classNames(containerPrefixCls, // Used for Today Button style, safe to remove if no need
+    "".concat(prefixCls, "-").concat(internalMode, "-panel-container")),
+    style: _defineProperty(_defineProperty({}, rtl ? marginRight : marginLeft, containerOffset), rtl ? marginLeft : marginRight, 'auto')
+    // Still wish not to lose focus on mouse down
+    // onMouseDown={(e) => {
+    //   // e.preventDefault();
+    // }}
+    ,
+    onFocus: onFocus,
+    onBlur: onBlur
+  }, mergedNodes);
+  if (range) {
+    renderNode = /*#__PURE__*/React.createElement("div", {
+      onMouseDown: onPanelMouseDown,
+      ref: wrapperRef,
+      className: classNames("".concat(prefixCls, "-range-wrapper"), "".concat(prefixCls, "-").concat(picker, "-range-wrapper"))
+    }, /*#__PURE__*/React.createElement("div", {
+      ref: arrowRef,
+      className: "".concat(prefixCls, "-range-arrow"),
+      style: {
+        left: arrowOffset
+      }
+    }), /*#__PURE__*/React.createElement(ResizeObserver, {
+      onResize: onResize
+    }, renderNode));
+  }
+  return renderNode;
+}

package/es/PickerInput/RangePicker.d.ts

@@ -0,0 +1,54 @@
+import * as React from 'react';
+import type { BaseInfo, PanelMode, RangePickerRef, RangeTimeProps, SharedPickerProps, ValueDate } from '../interface';
+import { type SelectorIdType } from './Selector/RangeSelector';
+export type RangeValueType<DateType> = [
+    start: DateType | null | undefined,
+    end: DateType | null | undefined
+];
+/** Used for change event, it should always be not undefined */
+export type NoUndefinedRangeValueType<DateType> = [start: DateType | null, end: DateType | null];
+export interface BaseRangePickerProps<DateType extends object> extends Omit<SharedPickerProps<DateType>, 'showTime' | 'id'> {
+    id?: SelectorIdType;
+    separator?: React.ReactNode;
+    value?: RangeValueType<DateType> | null;
+    defaultValue?: RangeValueType<DateType>;
+    onChange?: (dates: NoUndefinedRangeValueType<DateType> | null, dateStrings: [string, string]) => void;
+    onCalendarChange?: (dates: NoUndefinedRangeValueType<DateType>, dateStrings: [string, string], info: BaseInfo) => void;
+    onOk?: (values: NoUndefinedRangeValueType<DateType>) => void;
+    placeholder?: [string, string];
+    /**
+     * Config the popup panel date.
+     * Every time active the input to open popup will reset with `defaultPickerValue`.
+     *
+     * Note: `defaultPickerValue` priority is higher than `value` for the first open.
+     */
+    defaultPickerValue?: [DateType, DateType] | DateType | null;
+    /**
+     * Config each start & end field popup panel date.
+     * When config `pickerValue`, you must also provide `onPickerValueChange` to handle changes.
+     */
+    pickerValue?: [DateType, DateType] | DateType | null;
+    /**
+     * Each popup panel `pickerValue` includes `mode` change will trigger the callback.
+     * @param date The changed picker value
+     * @param info.source `panel` from the panel click. `reset` from popup open or field typing
+     * @param info.mode Next `mode` panel
+     */
+    onPickerValueChange?: (date: [DateType, DateType], info: BaseInfo & {
+        source: 'reset' | 'panel';
+        mode: [PanelMode, PanelMode];
+    }) => void;
+    presets?: ValueDate<Exclude<RangeValueType<DateType>, null>>[];
+    /** @deprecated Please use `presets` instead */
+    ranges?: Record<string, Exclude<RangeValueType<DateType>, null> | (() => Exclude<RangeValueType<DateType>, null>)>;
+    disabled?: boolean | [boolean, boolean];
+    allowEmpty?: boolean | [boolean, boolean];
+    showTime?: boolean | RangeTimeProps<DateType>;
+    mode?: [startMode: PanelMode, endMode: PanelMode];
+    /** Trigger on each `mode` or `pickerValue` changed. */
+    onPanelChange?: (values: NoUndefinedRangeValueType<DateType>, modes: [startMode: PanelMode, endMode: PanelMode]) => void;
+}
+export interface RangePickerProps<DateType extends object> extends BaseRangePickerProps<DateType>, Omit<RangeTimeProps<DateType>, 'format' | 'defaultValue' | 'defaultOpenValue'> {
+}
+declare const RefRangePicker: <DateType extends object = any>(props: RangePickerProps<DateType> & React.RefAttributes<RangePickerRef>) => React.ReactElement;
+export default RefRangePicker;