first commit

frontend/node_modules/rc-picker/es/PickerPanel/TimePanel/TimePanelBody/TimeColumn.d.ts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+export type Unit<ValueType = number | string> = {
+    label: React.ReactText;
+    value: ValueType;
+    disabled?: boolean;
+};
+export interface TimeUnitColumnProps {
+    units: Unit[];
+    value: number | string;
+    optionalValue?: number | string;
+    type: 'hour' | 'minute' | 'second' | 'millisecond' | 'meridiem';
+    onChange: (value: number | string) => void;
+    onHover: (value: number | string) => void;
+    onDblClick?: VoidFunction;
+    changeOnScroll?: boolean;
+}
+export default function TimeColumn<DateType extends object>(props: TimeUnitColumnProps): React.JSX.Element;

frontend/node_modules/rc-picker/es/PickerPanel/TimePanel/TimePanelBody/TimeColumn.js

@@ -0,0 +1,138 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import classNames from 'classnames';
+import useLayoutEffect from "rc-util/es/hooks/useLayoutEffect";
+import * as React from 'react';
+import { usePanelContext } from "../../context";
+import useScrollTo from "./useScrollTo";
+var SCROLL_DELAY = 300;
+// Not use JSON.stringify to avoid dead loop
+function flattenUnits(units) {
+  return units.map(function (_ref) {
+    var value = _ref.value,
+      label = _ref.label,
+      disabled = _ref.disabled;
+    return [value, label, disabled].join(',');
+  }).join(';');
+}
+export default function TimeColumn(props) {
+  var units = props.units,
+    value = props.value,
+    optionalValue = props.optionalValue,
+    type = props.type,
+    onChange = props.onChange,
+    onHover = props.onHover,
+    onDblClick = props.onDblClick,
+    changeOnScroll = props.changeOnScroll;
+  var _usePanelContext = usePanelContext(),
+    prefixCls = _usePanelContext.prefixCls,
+    cellRender = _usePanelContext.cellRender,
+    now = _usePanelContext.now,
+    locale = _usePanelContext.locale;
+  var panelPrefixCls = "".concat(prefixCls, "-time-panel");
+  var cellPrefixCls = "".concat(prefixCls, "-time-panel-cell");
+
+  // ========================== Refs ==========================
+  var ulRef = React.useRef(null);
+
+  // ========================= Scroll =========================
+  var checkDelayRef = React.useRef();
+  var clearDelayCheck = function clearDelayCheck() {
+    clearTimeout(checkDelayRef.current);
+  };
+
+  // ========================== Sync ==========================
+  var _useScrollTo = useScrollTo(ulRef, value !== null && value !== void 0 ? value : optionalValue),
+    _useScrollTo2 = _slicedToArray(_useScrollTo, 3),
+    syncScroll = _useScrollTo2[0],
+    stopScroll = _useScrollTo2[1],
+    isScrolling = _useScrollTo2[2];
+
+  // Effect sync value scroll
+  useLayoutEffect(function () {
+    syncScroll();
+    clearDelayCheck();
+    return function () {
+      stopScroll();
+      clearDelayCheck();
+    };
+  }, [value, optionalValue, flattenUnits(units)]);
+
+  // ========================= Change =========================
+  // Scroll event if sync onScroll
+  var onInternalScroll = function onInternalScroll(event) {
+    clearDelayCheck();
+    var target = event.target;
+    if (!isScrolling() && changeOnScroll) {
+      checkDelayRef.current = setTimeout(function () {
+        var ul = ulRef.current;
+        var firstLiTop = ul.querySelector("li").offsetTop;
+        var liList = Array.from(ul.querySelectorAll("li"));
+        var liTopList = liList.map(function (li) {
+          return li.offsetTop - firstLiTop;
+        });
+        var liDistList = liTopList.map(function (top, index) {
+          if (units[index].disabled) {
+            return Number.MAX_SAFE_INTEGER;
+          }
+          return Math.abs(top - target.scrollTop);
+        });
+
+        // Find min distance index
+        var minDist = Math.min.apply(Math, _toConsumableArray(liDistList));
+        var minDistIndex = liDistList.findIndex(function (dist) {
+          return dist === minDist;
+        });
+        var targetUnit = units[minDistIndex];
+        if (targetUnit && !targetUnit.disabled) {
+          onChange(targetUnit.value);
+        }
+      }, SCROLL_DELAY);
+    }
+  };
+
+  // ========================= Render =========================
+  var columnPrefixCls = "".concat(panelPrefixCls, "-column");
+  return /*#__PURE__*/React.createElement("ul", {
+    className: columnPrefixCls,
+    ref: ulRef,
+    "data-type": type,
+    onScroll: onInternalScroll
+  }, units.map(function (_ref2) {
+    var label = _ref2.label,
+      unitValue = _ref2.value,
+      disabled = _ref2.disabled;
+    var inner = /*#__PURE__*/React.createElement("div", {
+      className: "".concat(cellPrefixCls, "-inner")
+    }, label);
+    return /*#__PURE__*/React.createElement("li", {
+      key: unitValue,
+      className: classNames(cellPrefixCls, _defineProperty(_defineProperty({}, "".concat(cellPrefixCls, "-selected"), value === unitValue), "".concat(cellPrefixCls, "-disabled"), disabled)),
+      onClick: function onClick() {
+        if (!disabled) {
+          onChange(unitValue);
+        }
+      },
+      onDoubleClick: function onDoubleClick() {
+        if (!disabled && onDblClick) {
+          onDblClick();
+        }
+      },
+      onMouseEnter: function onMouseEnter() {
+        onHover(unitValue);
+      },
+      onMouseLeave: function onMouseLeave() {
+        onHover(null);
+      },
+      "data-value": unitValue
+    }, cellRender ? cellRender(unitValue, {
+      prefixCls: prefixCls,
+      originNode: inner,
+      today: now,
+      type: 'time',
+      subType: type,
+      locale: locale
+    }) : inner);
+  }));
+}

frontend/node_modules/rc-picker/es/PickerPanel/TimePanel/TimePanelBody/index.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import type { SharedPanelProps, SharedTimeProps } from '../../../interface';
+export type TimePanelBodyProps<DateType extends object = any> = SharedPanelProps<DateType>;
+export default function TimePanelBody<DateType extends object = any>(props: SharedTimeProps<DateType>): React.JSX.Element;

frontend/node_modules/rc-picker/es/PickerPanel/TimePanel/TimePanelBody/index.js

@@ -0,0 +1,278 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import * as React from 'react';
+import useTimeInfo from "../../../hooks/useTimeInfo";
+import { formatValue } from "../../../utils/dateUtil";
+import { PickerHackContext, usePanelContext } from "../../context";
+import TimeColumn from "./TimeColumn";
+function isAM(hour) {
+  return hour < 12;
+}
+export default function TimePanelBody(props) {
+  var showHour = props.showHour,
+    showMinute = props.showMinute,
+    showSecond = props.showSecond,
+    showMillisecond = props.showMillisecond,
+    showMeridiem = props.use12Hours,
+    changeOnScroll = props.changeOnScroll;
+  var _usePanelContext = usePanelContext(),
+    prefixCls = _usePanelContext.prefixCls,
+    values = _usePanelContext.values,
+    generateConfig = _usePanelContext.generateConfig,
+    locale = _usePanelContext.locale,
+    onSelect = _usePanelContext.onSelect,
+    _usePanelContext$onHo = _usePanelContext.onHover,
+    onHover = _usePanelContext$onHo === void 0 ? function () {} : _usePanelContext$onHo,
+    pickerValue = _usePanelContext.pickerValue;
+  var value = (values === null || values === void 0 ? void 0 : values[0]) || null;
+  var _React$useContext = React.useContext(PickerHackContext),
+    onCellDblClick = _React$useContext.onCellDblClick;
+
+  // ========================== Info ==========================
+  var _useTimeInfo = useTimeInfo(generateConfig, props, value),
+    _useTimeInfo2 = _slicedToArray(_useTimeInfo, 5),
+    getValidTime = _useTimeInfo2[0],
+    rowHourUnits = _useTimeInfo2[1],
+    getMinuteUnits = _useTimeInfo2[2],
+    getSecondUnits = _useTimeInfo2[3],
+    getMillisecondUnits = _useTimeInfo2[4];
+
+  // ========================= Value ==========================
+  // PickerValue will tell which one to align on the top
+  var getUnitValue = function getUnitValue(func) {
+    var valueUnitVal = value && generateConfig[func](value);
+    var pickerUnitValue = pickerValue && generateConfig[func](pickerValue);
+    return [valueUnitVal, pickerUnitValue];
+  };
+  var _getUnitValue = getUnitValue('getHour'),
+    _getUnitValue2 = _slicedToArray(_getUnitValue, 2),
+    hour = _getUnitValue2[0],
+    pickerHour = _getUnitValue2[1];
+  var _getUnitValue3 = getUnitValue('getMinute'),
+    _getUnitValue4 = _slicedToArray(_getUnitValue3, 2),
+    minute = _getUnitValue4[0],
+    pickerMinute = _getUnitValue4[1];
+  var _getUnitValue5 = getUnitValue('getSecond'),
+    _getUnitValue6 = _slicedToArray(_getUnitValue5, 2),
+    second = _getUnitValue6[0],
+    pickerSecond = _getUnitValue6[1];
+  var _getUnitValue7 = getUnitValue('getMillisecond'),
+    _getUnitValue8 = _slicedToArray(_getUnitValue7, 2),
+    millisecond = _getUnitValue8[0],
+    pickerMillisecond = _getUnitValue8[1];
+  var meridiem = hour === null ? null : isAM(hour) ? 'am' : 'pm';
+
+  // ========================= Column =========================
+  // Hours
+  var hourUnits = React.useMemo(function () {
+    if (!showMeridiem) {
+      return rowHourUnits;
+    }
+    return isAM(hour) ? rowHourUnits.filter(function (h) {
+      return isAM(h.value);
+    }) : rowHourUnits.filter(function (h) {
+      return !isAM(h.value);
+    });
+  }, [hour, rowHourUnits, showMeridiem]);
+
+  // >>> Pick Fallback
+  var getEnabled = function getEnabled(units, val) {
+    var _enabledUnits$;
+    var enabledUnits = units.filter(function (unit) {
+      return !unit.disabled;
+    });
+    return val !== null && val !== void 0 ? val : // Fallback to enabled value
+    enabledUnits === null || enabledUnits === void 0 || (_enabledUnits$ = enabledUnits[0]) === null || _enabledUnits$ === void 0 ? void 0 : _enabledUnits$.value;
+  };
+
+  // >>> Minutes
+  var validHour = getEnabled(rowHourUnits, hour);
+  var minuteUnits = React.useMemo(function () {
+    return getMinuteUnits(validHour);
+  }, [getMinuteUnits, validHour]);
+
+  // >>> Seconds
+  var validMinute = getEnabled(minuteUnits, minute);
+  var secondUnits = React.useMemo(function () {
+    return getSecondUnits(validHour, validMinute);
+  }, [getSecondUnits, validHour, validMinute]);
+
+  // >>> Milliseconds
+  var validSecond = getEnabled(secondUnits, second);
+  var millisecondUnits = React.useMemo(function () {
+    return getMillisecondUnits(validHour, validMinute, validSecond);
+  }, [getMillisecondUnits, validHour, validMinute, validSecond]);
+  var validMillisecond = getEnabled(millisecondUnits, millisecond);
+
+  // Meridiem
+  var meridiemUnits = React.useMemo(function () {
+    if (!showMeridiem) {
+      return [];
+    }
+    var base = generateConfig.getNow();
+    var amDate = generateConfig.setHour(base, 6);
+    var pmDate = generateConfig.setHour(base, 18);
+    var formatMeridiem = function formatMeridiem(date, defaultLabel) {
+      var cellMeridiemFormat = locale.cellMeridiemFormat;
+      return cellMeridiemFormat ? formatValue(date, {
+        generateConfig: generateConfig,
+        locale: locale,
+        format: cellMeridiemFormat
+      }) : defaultLabel;
+    };
+    return [{
+      label: formatMeridiem(amDate, 'AM'),
+      value: 'am',
+      disabled: rowHourUnits.every(function (h) {
+        return h.disabled || !isAM(h.value);
+      })
+    }, {
+      label: formatMeridiem(pmDate, 'PM'),
+      value: 'pm',
+      disabled: rowHourUnits.every(function (h) {
+        return h.disabled || isAM(h.value);
+      })
+    }];
+  }, [rowHourUnits, showMeridiem, generateConfig, locale]);
+
+  // ========================= Change =========================
+  /**
+   * Check if time is validate or will match to validate one
+   */
+  var triggerChange = function triggerChange(nextDate) {
+    var validateDate = getValidTime(nextDate);
+    onSelect(validateDate);
+  };
+
+  // ========================= Column =========================
+  // Create a template date for the trigger change event
+  var triggerDateTmpl = React.useMemo(function () {
+    var tmpl = value || pickerValue || generateConfig.getNow();
+    var isNotNull = function isNotNull(num) {
+      return num !== null && num !== undefined;
+    };
+    if (isNotNull(hour)) {
+      tmpl = generateConfig.setHour(tmpl, hour);
+      tmpl = generateConfig.setMinute(tmpl, minute);
+      tmpl = generateConfig.setSecond(tmpl, second);
+      tmpl = generateConfig.setMillisecond(tmpl, millisecond);
+    } else if (isNotNull(pickerHour)) {
+      tmpl = generateConfig.setHour(tmpl, pickerHour);
+      tmpl = generateConfig.setMinute(tmpl, pickerMinute);
+      tmpl = generateConfig.setSecond(tmpl, pickerSecond);
+      tmpl = generateConfig.setMillisecond(tmpl, pickerMillisecond);
+    } else if (isNotNull(validHour)) {
+      tmpl = generateConfig.setHour(tmpl, validHour);
+      tmpl = generateConfig.setMinute(tmpl, validMinute);
+      tmpl = generateConfig.setSecond(tmpl, validSecond);
+      tmpl = generateConfig.setMillisecond(tmpl, validMillisecond);
+    }
+    return tmpl;
+  }, [value, pickerValue, hour, minute, second, millisecond, validHour, validMinute, validSecond, validMillisecond, pickerHour, pickerMinute, pickerSecond, pickerMillisecond, generateConfig]);
+
+  // ===================== Columns Change =====================
+  var fillColumnValue = function fillColumnValue(val, func) {
+    if (val === null) {
+      return null;
+    }
+    return generateConfig[func](triggerDateTmpl, val);
+  };
+  var getNextHourTime = function getNextHourTime(val) {
+    return fillColumnValue(val, 'setHour');
+  };
+  var getNextMinuteTime = function getNextMinuteTime(val) {
+    return fillColumnValue(val, 'setMinute');
+  };
+  var getNextSecondTime = function getNextSecondTime(val) {
+    return fillColumnValue(val, 'setSecond');
+  };
+  var getNextMillisecondTime = function getNextMillisecondTime(val) {
+    return fillColumnValue(val, 'setMillisecond');
+  };
+  var getMeridiemTime = function getMeridiemTime(val) {
+    if (val === null) {
+      return null;
+    }
+    if (val === 'am' && !isAM(hour)) {
+      return generateConfig.setHour(triggerDateTmpl, hour - 12);
+    } else if (val === 'pm' && isAM(hour)) {
+      return generateConfig.setHour(triggerDateTmpl, hour + 12);
+    }
+    return triggerDateTmpl;
+  };
+  var onHourChange = function onHourChange(val) {
+    triggerChange(getNextHourTime(val));
+  };
+  var onMinuteChange = function onMinuteChange(val) {
+    triggerChange(getNextMinuteTime(val));
+  };
+  var onSecondChange = function onSecondChange(val) {
+    triggerChange(getNextSecondTime(val));
+  };
+  var onMillisecondChange = function onMillisecondChange(val) {
+    triggerChange(getNextMillisecondTime(val));
+  };
+  var onMeridiemChange = function onMeridiemChange(val) {
+    triggerChange(getMeridiemTime(val));
+  };
+
+  // ====================== Column Hover ======================
+  var onHourHover = function onHourHover(val) {
+    onHover(getNextHourTime(val));
+  };
+  var onMinuteHover = function onMinuteHover(val) {
+    onHover(getNextMinuteTime(val));
+  };
+  var onSecondHover = function onSecondHover(val) {
+    onHover(getNextSecondTime(val));
+  };
+  var onMillisecondHover = function onMillisecondHover(val) {
+    onHover(getNextMillisecondTime(val));
+  };
+  var onMeridiemHover = function onMeridiemHover(val) {
+    onHover(getMeridiemTime(val));
+  };
+
+  // ========================= Render =========================
+  var sharedColumnProps = {
+    onDblClick: onCellDblClick,
+    changeOnScroll: changeOnScroll
+  };
+  return /*#__PURE__*/React.createElement("div", {
+    className: "".concat(prefixCls, "-content")
+  }, showHour && /*#__PURE__*/React.createElement(TimeColumn, _extends({
+    units: hourUnits,
+    value: hour,
+    optionalValue: pickerHour,
+    type: "hour",
+    onChange: onHourChange,
+    onHover: onHourHover
+  }, sharedColumnProps)), showMinute && /*#__PURE__*/React.createElement(TimeColumn, _extends({
+    units: minuteUnits,
+    value: minute,
+    optionalValue: pickerMinute,
+    type: "minute",
+    onChange: onMinuteChange,
+    onHover: onMinuteHover
+  }, sharedColumnProps)), showSecond && /*#__PURE__*/React.createElement(TimeColumn, _extends({
+    units: secondUnits,
+    value: second,
+    optionalValue: pickerSecond,
+    type: "second",
+    onChange: onSecondChange,
+    onHover: onSecondHover
+  }, sharedColumnProps)), showMillisecond && /*#__PURE__*/React.createElement(TimeColumn, _extends({
+    units: millisecondUnits,
+    value: millisecond,
+    optionalValue: pickerMillisecond,
+    type: "millisecond",
+    onChange: onMillisecondChange,
+    onHover: onMillisecondHover
+  }, sharedColumnProps)), showMeridiem && /*#__PURE__*/React.createElement(TimeColumn, _extends({
+    units: meridiemUnits,
+    value: meridiem,
+    type: "meridiem",
+    onChange: onMeridiemChange,
+    onHover: onMeridiemHover
+  }, sharedColumnProps)));
+}

frontend/node_modules/rc-picker/es/PickerPanel/TimePanel/TimePanelBody/useScrollTo.d.ts

@@ -0,0 +1,2 @@
+import * as React from 'react';
+export default function useScrollTo(ulRef: React.RefObject<HTMLUListElement>, value: number | string): [syncScroll: VoidFunction, clearScroll: VoidFunction, isScrolling: () => boolean];

frontend/node_modules/rc-picker/es/PickerPanel/TimePanel/TimePanelBody/useScrollTo.js

@@ -0,0 +1,72 @@
+import { useEvent } from 'rc-util';
+import raf from "rc-util/es/raf";
+import isVisible from "rc-util/es/Dom/isVisible";
+import * as React from 'react';
+var SPEED_PTG = 1 / 3;
+export default function useScrollTo(ulRef, value) {
+  // ========================= Scroll =========================
+  var scrollingRef = React.useRef(false);
+  var scrollRafRef = React.useRef(null);
+  var scrollDistRef = React.useRef(null);
+  var isScrolling = function isScrolling() {
+    return scrollingRef.current;
+  };
+  var stopScroll = function stopScroll() {
+    raf.cancel(scrollRafRef.current);
+    scrollingRef.current = false;
+  };
+  var scrollRafTimesRef = React.useRef();
+  var startScroll = function startScroll() {
+    var ul = ulRef.current;
+    scrollDistRef.current = null;
+    scrollRafTimesRef.current = 0;
+    if (ul) {
+      var targetLi = ul.querySelector("[data-value=\"".concat(value, "\"]"));
+      var firstLi = ul.querySelector("li");
+      var doScroll = function doScroll() {
+        stopScroll();
+        scrollingRef.current = true;
+        scrollRafTimesRef.current += 1;
+        var currentTop = ul.scrollTop;
+        var firstLiTop = firstLi.offsetTop;
+        var targetLiTop = targetLi.offsetTop;
+        var targetTop = targetLiTop - firstLiTop;
+
+        // Wait for element exist. 5 frames is enough
+        if (targetLiTop === 0 && targetLi !== firstLi || !isVisible(ul)) {
+          if (scrollRafTimesRef.current <= 5) {
+            scrollRafRef.current = raf(doScroll);
+          }
+          return;
+        }
+        var nextTop = currentTop + (targetTop - currentTop) * SPEED_PTG;
+        var dist = Math.abs(targetTop - nextTop);
+
+        // Break if dist get larger, which means user is scrolling
+        if (scrollDistRef.current !== null && scrollDistRef.current < dist) {
+          stopScroll();
+          return;
+        }
+        scrollDistRef.current = dist;
+
+        // Stop when dist is less than 1
+        if (dist <= 1) {
+          ul.scrollTop = targetTop;
+          stopScroll();
+          return;
+        }
+
+        // IE not support `scrollTo`
+        ul.scrollTop = nextTop;
+        scrollRafRef.current = raf(doScroll);
+      };
+      if (targetLi && firstLi) {
+        doScroll();
+      }
+    }
+  };
+
+  // ======================== Trigger =========================
+  var syncScroll = useEvent(startScroll);
+  return [syncScroll, stopScroll, isScrolling];
+}

frontend/node_modules/rc-picker/es/PickerPanel/TimePanel/TimePanelBody/util.d.ts

@@ -0,0 +1,3 @@
+import type { GenerateConfig } from '../../../generate';
+import type { Unit } from './TimeColumn';
+export declare function findValidateTime<DateType>(date: DateType, getHourUnits: () => Unit<number>[], getMinuteUnits: (hour: number) => Unit<number>[], getSecondUnits: (hour: number, minute: number) => Unit<number>[], getMillisecondUnits: (hour: number, minute: number, second: number) => Unit<number>[], generateConfig: GenerateConfig<DateType>): DateType;

frontend/node_modules/rc-picker/es/PickerPanel/TimePanel/TimePanelBody/util.js

@@ -0,0 +1,38 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+export function findValidateTime(date, getHourUnits, getMinuteUnits, getSecondUnits, getMillisecondUnits, generateConfig) {
+  var nextDate = date;
+  function alignValidate(getUnitValue, setUnitValue, units) {
+    var nextValue = generateConfig[getUnitValue](nextDate);
+    var nextUnit = units.find(function (unit) {
+      return unit.value === nextValue;
+    });
+    if (!nextUnit || nextUnit.disabled) {
+      // Find most closest unit
+      var validateUnits = units.filter(function (unit) {
+        return !unit.disabled;
+      });
+      var reverseEnabledUnits = _toConsumableArray(validateUnits).reverse();
+      var validateUnit = reverseEnabledUnits.find(function (unit) {
+        return unit.value <= nextValue;
+      }) || validateUnits[0];
+      if (validateUnit) {
+        nextValue = validateUnit.value;
+        nextDate = generateConfig[setUnitValue](nextDate, nextValue);
+      }
+    }
+    return nextValue;
+  }
+
+  // Find validate hour
+  var nextHour = alignValidate('getHour', 'setHour', getHourUnits());
+
+  // Find validate minute
+  var nextMinute = alignValidate('getMinute', 'setMinute', getMinuteUnits(nextHour));
+
+  // Find validate second
+  var nextSecond = alignValidate('getSecond', 'setSecond', getSecondUnits(nextHour, nextMinute));
+
+  // Find validate millisecond
+  alignValidate('getMillisecond', 'setMillisecond', getMillisecondUnits(nextHour, nextMinute, nextSecond));
+  return nextDate;
+}