first commit

frontend/node_modules/rc-slider/lib/hooks/useDrag.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import type { Direction, OnStartMove } from '../interface';
+import type { OffsetValues } from './useOffset';
+declare function useDrag(containerRef: React.RefObject<HTMLDivElement>, direction: Direction, rawValues: number[], min: number, max: number, formatValue: (value: number) => number, triggerChange: (values: number[]) => void, finishChange: (draggingDelete: boolean) => void, offsetValues: OffsetValues, editable: boolean, minCount: number): [
+    draggingIndex: number,
+    draggingValue: number,
+    draggingDelete: boolean,
+    returnValues: number[],
+    onStartMove: OnStartMove
+];
+export default useDrag;

frontend/node_modules/rc-slider/lib/hooks/useDrag.js

@@ -0,0 +1,235 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var React = _interopRequireWildcard(require("react"));
+var _useEvent = _interopRequireDefault(require("rc-util/lib/hooks/useEvent"));
+var _useLayoutEffect = _interopRequireDefault(require("rc-util/lib/hooks/useLayoutEffect"));
+var _context = require("../context");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/** Drag to delete offset. It's a user experience number for dragging out */
+var REMOVE_DIST = 130;
+function getPosition(e) {
+  var obj = 'targetTouches' in e ? e.targetTouches[0] : e;
+  return {
+    pageX: obj.pageX,
+    pageY: obj.pageY
+  };
+}
+function useDrag(containerRef, direction, rawValues, min, max, formatValue, triggerChange, finishChange, offsetValues, editable, minCount) {
+  var _React$useState = React.useState(null),
+    _React$useState2 = (0, _slicedToArray2.default)(_React$useState, 2),
+    draggingValue = _React$useState2[0],
+    setDraggingValue = _React$useState2[1];
+  var _React$useState3 = React.useState(-1),
+    _React$useState4 = (0, _slicedToArray2.default)(_React$useState3, 2),
+    draggingIndex = _React$useState4[0],
+    setDraggingIndex = _React$useState4[1];
+  var _React$useState5 = React.useState(false),
+    _React$useState6 = (0, _slicedToArray2.default)(_React$useState5, 2),
+    draggingDelete = _React$useState6[0],
+    setDraggingDelete = _React$useState6[1];
+  var _React$useState7 = React.useState(rawValues),
+    _React$useState8 = (0, _slicedToArray2.default)(_React$useState7, 2),
+    cacheValues = _React$useState8[0],
+    setCacheValues = _React$useState8[1];
+  var _React$useState9 = React.useState(rawValues),
+    _React$useState10 = (0, _slicedToArray2.default)(_React$useState9, 2),
+    originValues = _React$useState10[0],
+    setOriginValues = _React$useState10[1];
+  var mouseMoveEventRef = React.useRef(null);
+  var mouseUpEventRef = React.useRef(null);
+  var touchEventTargetRef = React.useRef(null);
+  var _React$useContext = React.useContext(_context.UnstableContext),
+    onDragStart = _React$useContext.onDragStart,
+    onDragChange = _React$useContext.onDragChange;
+  (0, _useLayoutEffect.default)(function () {
+    if (draggingIndex === -1) {
+      setCacheValues(rawValues);
+    }
+  }, [rawValues, draggingIndex]);
+
+  // Clean up event
+  React.useEffect(function () {
+    return function () {
+      document.removeEventListener('mousemove', mouseMoveEventRef.current);
+      document.removeEventListener('mouseup', mouseUpEventRef.current);
+      if (touchEventTargetRef.current) {
+        touchEventTargetRef.current.removeEventListener('touchmove', mouseMoveEventRef.current);
+        touchEventTargetRef.current.removeEventListener('touchend', mouseUpEventRef.current);
+      }
+    };
+  }, []);
+  var flushValues = function flushValues(nextValues, nextValue, deleteMark) {
+    // Perf: Only update state when value changed
+    if (nextValue !== undefined) {
+      setDraggingValue(nextValue);
+    }
+    setCacheValues(nextValues);
+    var changeValues = nextValues;
+    if (deleteMark) {
+      changeValues = nextValues.filter(function (_, i) {
+        return i !== draggingIndex;
+      });
+    }
+    triggerChange(changeValues);
+    if (onDragChange) {
+      onDragChange({
+        rawValues: nextValues,
+        deleteIndex: deleteMark ? draggingIndex : -1,
+        draggingIndex: draggingIndex,
+        draggingValue: nextValue
+      });
+    }
+  };
+  var updateCacheValue = (0, _useEvent.default)(function (valueIndex, offsetPercent, deleteMark) {
+    if (valueIndex === -1) {
+      // >>>> Dragging on the track
+      var startValue = originValues[0];
+      var endValue = originValues[originValues.length - 1];
+      var maxStartOffset = min - startValue;
+      var maxEndOffset = max - endValue;
+
+      // Get valid offset
+      var offset = offsetPercent * (max - min);
+      offset = Math.max(offset, maxStartOffset);
+      offset = Math.min(offset, maxEndOffset);
+
+      // Use first value to revert back of valid offset (like steps marks)
+      var formatStartValue = formatValue(startValue + offset);
+      offset = formatStartValue - startValue;
+      var cloneCacheValues = originValues.map(function (val) {
+        return val + offset;
+      });
+      flushValues(cloneCacheValues);
+    } else {
+      // >>>> Dragging on the handle
+      var offsetDist = (max - min) * offsetPercent;
+
+      // Always start with the valueIndex origin value
+      var cloneValues = (0, _toConsumableArray2.default)(cacheValues);
+      cloneValues[valueIndex] = originValues[valueIndex];
+      var next = offsetValues(cloneValues, offsetDist, valueIndex, 'dist');
+      flushValues(next.values, next.value, deleteMark);
+    }
+  });
+  var onStartMove = function onStartMove(e, valueIndex, startValues) {
+    e.stopPropagation();
+
+    // 如果是点击 track 触发的，需要传入变化后的初始值，而不能直接用 rawValues
+    var initialValues = startValues || rawValues;
+    var originValue = initialValues[valueIndex];
+    setDraggingIndex(valueIndex);
+    setDraggingValue(originValue);
+    setOriginValues(initialValues);
+    setCacheValues(initialValues);
+    setDraggingDelete(false);
+    var _getPosition = getPosition(e),
+      startX = _getPosition.pageX,
+      startY = _getPosition.pageY;
+
+    // We declare it here since closure can't get outer latest value
+    var deleteMark = false;
+
+    // Internal trigger event
+    if (onDragStart) {
+      onDragStart({
+        rawValues: initialValues,
+        draggingIndex: valueIndex,
+        draggingValue: originValue
+      });
+    }
+
+    // Moving
+    var onMouseMove = function onMouseMove(event) {
+      event.preventDefault();
+      var _getPosition2 = getPosition(event),
+        moveX = _getPosition2.pageX,
+        moveY = _getPosition2.pageY;
+      var offsetX = moveX - startX;
+      var offsetY = moveY - startY;
+      var _containerRef$current = containerRef.current.getBoundingClientRect(),
+        width = _containerRef$current.width,
+        height = _containerRef$current.height;
+      var offSetPercent;
+      var removeDist;
+      switch (direction) {
+        case 'btt':
+          offSetPercent = -offsetY / height;
+          removeDist = offsetX;
+          break;
+        case 'ttb':
+          offSetPercent = offsetY / height;
+          removeDist = offsetX;
+          break;
+        case 'rtl':
+          offSetPercent = -offsetX / width;
+          removeDist = offsetY;
+          break;
+        default:
+          offSetPercent = offsetX / width;
+          removeDist = offsetY;
+      }
+
+      // Check if need mark remove
+      deleteMark = editable ? Math.abs(removeDist) > REMOVE_DIST && minCount < cacheValues.length : false;
+      setDraggingDelete(deleteMark);
+      updateCacheValue(valueIndex, offSetPercent, deleteMark);
+    };
+
+    // End
+    var onMouseUp = function onMouseUp(event) {
+      event.preventDefault();
+      document.removeEventListener('mouseup', onMouseUp);
+      document.removeEventListener('mousemove', onMouseMove);
+      if (touchEventTargetRef.current) {
+        touchEventTargetRef.current.removeEventListener('touchmove', mouseMoveEventRef.current);
+        touchEventTargetRef.current.removeEventListener('touchend', mouseUpEventRef.current);
+      }
+      mouseMoveEventRef.current = null;
+      mouseUpEventRef.current = null;
+      touchEventTargetRef.current = null;
+      finishChange(deleteMark);
+      setDraggingIndex(-1);
+      setDraggingDelete(false);
+    };
+    document.addEventListener('mouseup', onMouseUp);
+    document.addEventListener('mousemove', onMouseMove);
+    e.currentTarget.addEventListener('touchend', onMouseUp);
+    e.currentTarget.addEventListener('touchmove', onMouseMove);
+    mouseMoveEventRef.current = onMouseMove;
+    mouseUpEventRef.current = onMouseUp;
+    touchEventTargetRef.current = e.currentTarget;
+  };
+
+  // Only return cache value when it mapping with rawValues
+  var returnValues = React.useMemo(function () {
+    var sourceValues = (0, _toConsumableArray2.default)(rawValues).sort(function (a, b) {
+      return a - b;
+    });
+    var targetValues = (0, _toConsumableArray2.default)(cacheValues).sort(function (a, b) {
+      return a - b;
+    });
+    var counts = {};
+    targetValues.forEach(function (val) {
+      counts[val] = (counts[val] || 0) + 1;
+    });
+    sourceValues.forEach(function (val) {
+      counts[val] = (counts[val] || 0) - 1;
+    });
+    var maxDiffCount = editable ? 1 : 0;
+    var diffCount = Object.values(counts).reduce(function (prev, next) {
+      return prev + Math.abs(next);
+    }, 0);
+    return diffCount <= maxDiffCount ? cacheValues : rawValues;
+  }, [rawValues, cacheValues, editable]);
+  return [draggingIndex, draggingValue, draggingDelete, returnValues, onStartMove];
+}
+var _default = exports.default = useDrag;

frontend/node_modules/rc-slider/lib/hooks/useOffset.d.ts

@@ -0,0 +1,10 @@
+import type { InternalMarkObj } from '../Marks';
+/** Format value align with step & marks */
+type FormatValue = (value: number) => number;
+type OffsetMode = 'unit' | 'dist';
+export type OffsetValues = (values: number[], offset: number | 'min' | 'max', valueIndex: number, mode?: OffsetMode) => {
+    value: number;
+    values: number[];
+};
+export default function useOffset(min: number, max: number, step: number, markList: InternalMarkObj[], allowCross: boolean, pushable: false | number): [FormatValue, OffsetValues];
+export {};

frontend/node_modules/rc-slider/lib/hooks/useOffset.js

@@ -0,0 +1,228 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useOffset;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var React = _interopRequireWildcard(require("react"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/** Format the value in the range of [min, max] */
+
+/** Format value align with step */
+
+/** Format value align with step & marks */
+
+function useOffset(min, max, step, markList, allowCross, pushable) {
+  var formatRangeValue = React.useCallback(function (val) {
+    return Math.max(min, Math.min(max, val));
+  }, [min, max]);
+  var formatStepValue = React.useCallback(function (val) {
+    if (step !== null) {
+      var stepValue = min + Math.round((formatRangeValue(val) - min) / step) * step;
+
+      // Cut number in case to be like 0.30000000000000004
+      var getDecimal = function getDecimal(num) {
+        return (String(num).split('.')[1] || '').length;
+      };
+      var maxDecimal = Math.max(getDecimal(step), getDecimal(max), getDecimal(min));
+      var fixedValue = Number(stepValue.toFixed(maxDecimal));
+      return min <= fixedValue && fixedValue <= max ? fixedValue : null;
+    }
+    return null;
+  }, [step, min, max, formatRangeValue]);
+  var formatValue = React.useCallback(function (val) {
+    var formatNextValue = formatRangeValue(val);
+
+    // List align values
+    var alignValues = markList.map(function (mark) {
+      return mark.value;
+    });
+    if (step !== null) {
+      alignValues.push(formatStepValue(val));
+    }
+
+    // min & max
+    alignValues.push(min, max);
+
+    // Align with marks
+    var closeValue = alignValues[0];
+    var closeDist = max - min;
+    alignValues.forEach(function (alignValue) {
+      var dist = Math.abs(formatNextValue - alignValue);
+      if (dist <= closeDist) {
+        closeValue = alignValue;
+        closeDist = dist;
+      }
+    });
+    return closeValue;
+  }, [min, max, markList, step, formatRangeValue, formatStepValue]);
+
+  // ========================== Offset ==========================
+  // Single Value
+  var offsetValue = function offsetValue(values, offset, valueIndex) {
+    var mode = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'unit';
+    if (typeof offset === 'number') {
+      var nextValue;
+      var originValue = values[valueIndex];
+
+      // Only used for `dist` mode
+      var targetDistValue = originValue + offset;
+
+      // Compare next step value & mark value which is best match
+      var potentialValues = [];
+      markList.forEach(function (mark) {
+        potentialValues.push(mark.value);
+      });
+
+      // Min & Max
+      potentialValues.push(min, max);
+
+      // In case origin value is align with mark but not with step
+      potentialValues.push(formatStepValue(originValue));
+
+      // Put offset step value also
+      var sign = offset > 0 ? 1 : -1;
+      if (mode === 'unit') {
+        potentialValues.push(formatStepValue(originValue + sign * step));
+      } else {
+        potentialValues.push(formatStepValue(targetDistValue));
+      }
+
+      // Find close one
+      potentialValues = potentialValues.filter(function (val) {
+        return val !== null;
+      })
+      // Remove reverse value
+      .filter(function (val) {
+        return offset < 0 ? val <= originValue : val >= originValue;
+      });
+      if (mode === 'unit') {
+        // `unit` mode can not contain itself
+        potentialValues = potentialValues.filter(function (val) {
+          return val !== originValue;
+        });
+      }
+      var compareValue = mode === 'unit' ? originValue : targetDistValue;
+      nextValue = potentialValues[0];
+      var valueDist = Math.abs(nextValue - compareValue);
+      potentialValues.forEach(function (potentialValue) {
+        var dist = Math.abs(potentialValue - compareValue);
+        if (dist < valueDist) {
+          nextValue = potentialValue;
+          valueDist = dist;
+        }
+      });
+
+      // Out of range will back to range
+      if (nextValue === undefined) {
+        return offset < 0 ? min : max;
+      }
+
+      // `dist` mode
+      if (mode === 'dist') {
+        return nextValue;
+      }
+
+      // `unit` mode may need another round
+      if (Math.abs(offset) > 1) {
+        var cloneValues = (0, _toConsumableArray2.default)(values);
+        cloneValues[valueIndex] = nextValue;
+        return offsetValue(cloneValues, offset - sign, valueIndex, mode);
+      }
+      return nextValue;
+    } else if (offset === 'min') {
+      return min;
+    } else if (offset === 'max') {
+      return max;
+    }
+  };
+
+  /** Same as `offsetValue` but return `changed` mark to tell value changed */
+  var offsetChangedValue = function offsetChangedValue(values, offset, valueIndex) {
+    var mode = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'unit';
+    var originValue = values[valueIndex];
+    var nextValue = offsetValue(values, offset, valueIndex, mode);
+    return {
+      value: nextValue,
+      changed: nextValue !== originValue
+    };
+  };
+  var needPush = function needPush(dist) {
+    return pushable === null && dist === 0 || typeof pushable === 'number' && dist < pushable;
+  };
+
+  // Values
+  var offsetValues = function offsetValues(values, offset, valueIndex) {
+    var mode = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'unit';
+    var nextValues = values.map(formatValue);
+    var originValue = nextValues[valueIndex];
+    var nextValue = offsetValue(nextValues, offset, valueIndex, mode);
+    nextValues[valueIndex] = nextValue;
+    if (allowCross === false) {
+      // >>>>> Allow Cross
+      var pushNum = pushable || 0;
+
+      // ============ AllowCross ===============
+      if (valueIndex > 0 && nextValues[valueIndex - 1] !== originValue) {
+        nextValues[valueIndex] = Math.max(nextValues[valueIndex], nextValues[valueIndex - 1] + pushNum);
+      }
+      if (valueIndex < nextValues.length - 1 && nextValues[valueIndex + 1] !== originValue) {
+        nextValues[valueIndex] = Math.min(nextValues[valueIndex], nextValues[valueIndex + 1] - pushNum);
+      }
+    } else if (typeof pushable === 'number' || pushable === null) {
+      // >>>>> Pushable
+      // =============== Push ==================
+
+      // >>>>>> Basic push
+      // End values
+      for (var i = valueIndex + 1; i < nextValues.length; i += 1) {
+        var changed = true;
+        while (needPush(nextValues[i] - nextValues[i - 1]) && changed) {
+          var _offsetChangedValue = offsetChangedValue(nextValues, 1, i);
+          nextValues[i] = _offsetChangedValue.value;
+          changed = _offsetChangedValue.changed;
+        }
+      }
+
+      // Start values
+      for (var _i = valueIndex; _i > 0; _i -= 1) {
+        var _changed = true;
+        while (needPush(nextValues[_i] - nextValues[_i - 1]) && _changed) {
+          var _offsetChangedValue2 = offsetChangedValue(nextValues, -1, _i - 1);
+          nextValues[_i - 1] = _offsetChangedValue2.value;
+          _changed = _offsetChangedValue2.changed;
+        }
+      }
+
+      // >>>>> Revert back to safe push range
+      // End to Start
+      for (var _i2 = nextValues.length - 1; _i2 > 0; _i2 -= 1) {
+        var _changed2 = true;
+        while (needPush(nextValues[_i2] - nextValues[_i2 - 1]) && _changed2) {
+          var _offsetChangedValue3 = offsetChangedValue(nextValues, -1, _i2 - 1);
+          nextValues[_i2 - 1] = _offsetChangedValue3.value;
+          _changed2 = _offsetChangedValue3.changed;
+        }
+      }
+
+      // Start to End
+      for (var _i3 = 0; _i3 < nextValues.length - 1; _i3 += 1) {
+        var _changed3 = true;
+        while (needPush(nextValues[_i3 + 1] - nextValues[_i3]) && _changed3) {
+          var _offsetChangedValue4 = offsetChangedValue(nextValues, 1, _i3 + 1);
+          nextValues[_i3 + 1] = _offsetChangedValue4.value;
+          _changed3 = _offsetChangedValue4.changed;
+        }
+      }
+    }
+    return {
+      value: nextValues[valueIndex],
+      values: nextValues
+    };
+  };
+  return [formatValue, offsetValues];
+}

frontend/node_modules/rc-slider/lib/hooks/useRange.d.ts

@@ -0,0 +1,8 @@
+import type { SliderProps } from '../Slider';
+export default function useRange(range?: SliderProps['range']): [
+    range: boolean,
+    rangeEditable: boolean,
+    rangeDraggableTrack: boolean,
+    minCount: number,
+    maxCount?: number
+];

frontend/node_modules/rc-slider/lib/hooks/useRange.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useRange;
+var _warning = require("rc-util/lib/warning");
+var _react = require("react");
+function useRange(range) {
+  return (0, _react.useMemo)(function () {
+    if (range === true || !range) {
+      return [!!range, false, false, 0];
+    }
+    var editable = range.editable,
+      draggableTrack = range.draggableTrack,
+      minCount = range.minCount,
+      maxCount = range.maxCount;
+    if (process.env.NODE_ENV !== 'production') {
+      (0, _warning.warning)(!editable || !draggableTrack, '`editable` can not work with `draggableTrack`.');
+    }
+    return [true, editable, !editable && draggableTrack, minCount || 0, maxCount];
+  }, [range]);
+}