@hi-ui/table 4.0.12 → 4.1.0-beta.0

package/lib/esm/node_modules/rc-virtual-list/es/ScrollBar.js

@@ -0,0 +1,399 @@
+/** @LICENSE
+ * @hi-ui/table
+ * https://github.com/XiaoMi/hiui/tree/master/packages/ui/table#readme
+ *
+ * Copyright (c) HiUI <mi-hiui@xiaomi.com>.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import * as React from 'react';
+import classNames from '../../classnames/index.js';
+import wrapperRaf from '../../rc-util/es/raf.js';
+
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+    return typeof obj;
+  } : function (obj) {
+    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+  }, _typeof(obj);
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true
+    }
+  });
+  Object.defineProperty(subClass, "prototype", {
+    writable: false
+  });
+  if (superClass) _setPrototypeOf(subClass, superClass);
+}
+
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+
+  return _setPrototypeOf(o, p);
+}
+
+function _createSuper(Derived) {
+  var hasNativeReflectConstruct = _isNativeReflectConstruct();
+
+  return function _createSuperInternal() {
+    var Super = _getPrototypeOf(Derived),
+        result;
+
+    if (hasNativeReflectConstruct) {
+      var NewTarget = _getPrototypeOf(this).constructor;
+
+      result = Reflect.construct(Super, arguments, NewTarget);
+    } else {
+      result = Super.apply(this, arguments);
+    }
+
+    return _possibleConstructorReturn(this, result);
+  };
+}
+
+function _possibleConstructorReturn(self, call) {
+  if (call && (_typeof(call) === "object" || typeof call === "function")) {
+    return call;
+  } else if (call !== void 0) {
+    throw new TypeError("Derived constructors may only return object or undefined");
+  }
+
+  return _assertThisInitialized(self);
+}
+
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+
+  return self;
+}
+
+function _isNativeReflectConstruct() {
+  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+  if (Reflect.construct.sham) return false;
+  if (typeof Proxy === "function") return true;
+
+  try {
+    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}
+
+var MIN_SIZE = 20;
+
+function getPageY(e) {
+  return 'touches' in e ? e.touches[0].pageY : e.pageY;
+}
+
+var ScrollBar = /*#__PURE__*/function (_React$Component) {
+  _inherits(ScrollBar, _React$Component);
+
+  var _super = _createSuper(ScrollBar);
+
+  function ScrollBar() {
+    var _this;
+
+    _classCallCheck(this, ScrollBar);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _super.call.apply(_super, [this].concat(args));
+    _this.moveRaf = null;
+    _this.scrollbarRef = /*#__PURE__*/React.createRef();
+    _this.thumbRef = /*#__PURE__*/React.createRef();
+    _this.visibleTimeout = null;
+    _this.state = {
+      dragging: false,
+      pageY: null,
+      startTop: null,
+      visible: false
+    };
+
+    _this.delayHidden = function () {
+      clearTimeout(_this.visibleTimeout);
+
+      _this.setState({
+        visible: true
+      });
+
+      _this.visibleTimeout = setTimeout(function () {
+        _this.setState({
+          visible: false
+        });
+      }, 2000);
+    };
+
+    _this.onScrollbarTouchStart = function (e) {
+      e.preventDefault();
+    };
+
+    _this.onContainerMouseDown = function (e) {
+      e.stopPropagation();
+      e.preventDefault();
+    };
+
+    _this.patchEvents = function () {
+      window.addEventListener('mousemove', _this.onMouseMove);
+      window.addEventListener('mouseup', _this.onMouseUp);
+
+      _this.thumbRef.current.addEventListener('touchmove', _this.onMouseMove);
+
+      _this.thumbRef.current.addEventListener('touchend', _this.onMouseUp);
+    };
+
+    _this.removeEvents = function () {
+      var _this$scrollbarRef$cu;
+
+      window.removeEventListener('mousemove', _this.onMouseMove);
+      window.removeEventListener('mouseup', _this.onMouseUp);
+      (_this$scrollbarRef$cu = _this.scrollbarRef.current) === null || _this$scrollbarRef$cu === void 0 ? void 0 : _this$scrollbarRef$cu.removeEventListener('touchstart', _this.onScrollbarTouchStart);
+
+      if (_this.thumbRef.current) {
+        _this.thumbRef.current.removeEventListener('touchstart', _this.onMouseDown);
+
+        _this.thumbRef.current.removeEventListener('touchmove', _this.onMouseMove);
+
+        _this.thumbRef.current.removeEventListener('touchend', _this.onMouseUp);
+      }
+
+      wrapperRaf.cancel(_this.moveRaf);
+    };
+
+    _this.onMouseDown = function (e) {
+      var onStartMove = _this.props.onStartMove;
+
+      _this.setState({
+        dragging: true,
+        pageY: getPageY(e),
+        startTop: _this.getTop()
+      });
+
+      onStartMove();
+
+      _this.patchEvents();
+
+      e.stopPropagation();
+      e.preventDefault();
+    };
+
+    _this.onMouseMove = function (e) {
+      var _this$state = _this.state,
+          dragging = _this$state.dragging,
+          pageY = _this$state.pageY,
+          startTop = _this$state.startTop;
+      var onScroll = _this.props.onScroll;
+      wrapperRaf.cancel(_this.moveRaf);
+
+      if (dragging) {
+        var offsetY = getPageY(e) - pageY;
+        var newTop = startTop + offsetY;
+
+        var enableScrollRange = _this.getEnableScrollRange();
+
+        var enableHeightRange = _this.getEnableHeightRange();
+
+        var ptg = enableHeightRange ? newTop / enableHeightRange : 0;
+        var newScrollTop = Math.ceil(ptg * enableScrollRange);
+        _this.moveRaf = wrapperRaf(function () {
+          onScroll(newScrollTop);
+        });
+      }
+    };
+
+    _this.onMouseUp = function () {
+      var onStopMove = _this.props.onStopMove;
+
+      _this.setState({
+        dragging: false
+      });
+
+      onStopMove();
+
+      _this.removeEvents();
+    };
+
+    _this.getSpinHeight = function () {
+      var _this$props = _this.props,
+          height = _this$props.height,
+          count = _this$props.count;
+      var baseHeight = height / count * 10;
+      baseHeight = Math.max(baseHeight, MIN_SIZE);
+      baseHeight = Math.min(baseHeight, height / 2);
+      return Math.floor(baseHeight);
+    };
+
+    _this.getEnableScrollRange = function () {
+      var _this$props2 = _this.props,
+          scrollHeight = _this$props2.scrollHeight,
+          height = _this$props2.height;
+      return scrollHeight - height || 0;
+    };
+
+    _this.getEnableHeightRange = function () {
+      var height = _this.props.height;
+
+      var spinHeight = _this.getSpinHeight();
+
+      return height - spinHeight || 0;
+    };
+
+    _this.getTop = function () {
+      var scrollTop = _this.props.scrollTop;
+
+      var enableScrollRange = _this.getEnableScrollRange();
+
+      var enableHeightRange = _this.getEnableHeightRange();
+
+      if (scrollTop === 0 || enableScrollRange === 0) {
+        return 0;
+      }
+
+      var ptg = scrollTop / enableScrollRange;
+      return ptg * enableHeightRange;
+    };
+
+    _this.showScroll = function () {
+      var _this$props3 = _this.props,
+          height = _this$props3.height,
+          scrollHeight = _this$props3.scrollHeight;
+      return scrollHeight > height;
+    };
+
+    return _this;
+  }
+
+  _createClass(ScrollBar, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this.scrollbarRef.current.addEventListener('touchstart', this.onScrollbarTouchStart);
+      this.thumbRef.current.addEventListener('touchstart', this.onMouseDown);
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps) {
+      if (prevProps.scrollTop !== this.props.scrollTop) {
+        this.delayHidden();
+      }
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      this.removeEvents();
+      clearTimeout(this.visibleTimeout);
+    }
+  }, {
+    key: "render",
+    value: // ====================== Render =======================
+    function render() {
+      var _this$state2 = this.state,
+          dragging = _this$state2.dragging,
+          visible = _this$state2.visible;
+      var prefixCls = this.props.prefixCls;
+      var spinHeight = this.getSpinHeight();
+      var top = this.getTop();
+      var canScroll = this.showScroll();
+      var mergedVisible = canScroll && visible;
+      return /*#__PURE__*/React.createElement("div", {
+        ref: this.scrollbarRef,
+        className: classNames("".concat(prefixCls, "-scrollbar"), _defineProperty({}, "".concat(prefixCls, "-scrollbar-show"), canScroll)),
+        style: {
+          width: 8,
+          top: 0,
+          bottom: 0,
+          right: 0,
+          position: 'absolute',
+          display: mergedVisible ? null : 'none'
+        },
+        onMouseDown: this.onContainerMouseDown,
+        onMouseMove: this.delayHidden
+      }, /*#__PURE__*/React.createElement("div", {
+        ref: this.thumbRef,
+        className: classNames("".concat(prefixCls, "-scrollbar-thumb"), _defineProperty({}, "".concat(prefixCls, "-scrollbar-thumb-moving"), dragging)),
+        style: {
+          width: '100%',
+          height: spinHeight,
+          top: top,
+          left: 0,
+          position: 'absolute',
+          background: 'rgba(0, 0, 0, 0.5)',
+          borderRadius: 99,
+          cursor: 'pointer',
+          userSelect: 'none'
+        },
+        onMouseDown: this.onMouseDown
+      }));
+    }
+  }]);
+
+  return ScrollBar;
+}(React.Component);
+
+export { ScrollBar as default };

package/lib/esm/node_modules/rc-virtual-list/es/hooks/useChildren.js

@@ -0,0 +1,29 @@
+/** @LICENSE
+ * @hi-ui/table
+ * https://github.com/XiaoMi/hiui/tree/master/packages/ui/table#readme
+ *
+ * Copyright (c) HiUI <mi-hiui@xiaomi.com>.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import * as React from 'react';
+import { Item } from '../Item.js';
+
+function useChildren(list, startIndex, endIndex, setNodeRef, renderFunc, _ref) {
+  var getKey = _ref.getKey;
+  return list.slice(startIndex, endIndex + 1).map(function (item, index) {
+    var eleIndex = startIndex + index;
+    var node = renderFunc(item, eleIndex, {// style: status === 'MEASURE_START' ? { visibility: 'hidden' } : {},
+    });
+    var key = getKey(item);
+    return /*#__PURE__*/React.createElement(Item, {
+      key: key,
+      setRef: function setRef(ele) {
+        return setNodeRef(item, ele);
+      }
+    }, node);
+  });
+}
+
+export { useChildren as default };

package/lib/esm/node_modules/rc-virtual-list/es/hooks/useDiffItem.js

@@ -0,0 +1,98 @@
+/** @LICENSE
+ * @hi-ui/table
+ * https://github.com/XiaoMi/hiui/tree/master/packages/ui/table#readme
+ *
+ * Copyright (c) HiUI <mi-hiui@xiaomi.com>.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import * as React from 'react';
+import { findListDiffIndex } from '../utils/algorithmUtil.js';
+
+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(arr, i) {
+  var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+
+  if (_i == null) return;
+  var _arr = [];
+  var _n = true;
+  var _d = false;
+
+  var _s, _e;
+
+  try {
+    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+      _arr.push(_s.value);
+
+      if (i && _arr.length === i) break;
+    }
+  } catch (err) {
+    _d = true;
+    _e = err;
+  } finally {
+    try {
+      if (!_n && _i["return"] != null) _i["return"]();
+    } finally {
+      if (_d) throw _e;
+    }
+  }
+
+  return _arr;
+}
+
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+
+function useDiffItem(data, getKey, onDiff) {
+  var _React$useState = React.useState(data),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      prevData = _React$useState2[0],
+      setPrevData = _React$useState2[1];
+
+  var _React$useState3 = React.useState(null),
+      _React$useState4 = _slicedToArray(_React$useState3, 2),
+      diffItem = _React$useState4[0],
+      setDiffItem = _React$useState4[1];
+
+  React.useEffect(function () {
+    var diff = findListDiffIndex(prevData || [], data || [], getKey);
+
+    if ((diff === null || diff === void 0 ? void 0 : diff.index) !== undefined) {
+      onDiff === null || onDiff === void 0 ? void 0 : onDiff(diff.index);
+      setDiffItem(data[diff.index]);
+    }
+
+    setPrevData(data);
+  }, [data]);
+  return [diffItem];
+}
+
+export { useDiffItem as default };

package/lib/esm/node_modules/rc-virtual-list/es/hooks/useFrameWheel.js

@@ -0,0 +1,55 @@
+/** @LICENSE
+ * @hi-ui/table
+ * https://github.com/XiaoMi/hiui/tree/master/packages/ui/table#readme
+ *
+ * Copyright (c) HiUI <mi-hiui@xiaomi.com>.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { useRef } from 'react';
+import wrapperRaf from '../../../rc-util/es/raf.js';
+import isFF from '../utils/isFirefox.js';
+import useOriginScroll from './useOriginScroll.js';
+
+function useFrameWheel(inVirtual, isScrollAtTop, isScrollAtBottom, onWheelDelta) {
+  var offsetRef = useRef(0);
+  var nextFrameRef = useRef(null); // Firefox patch
+
+  var wheelValueRef = useRef(null);
+  var isMouseScrollRef = useRef(false); // Scroll status sync
+
+  var originScroll = useOriginScroll(isScrollAtTop, isScrollAtBottom);
+
+  function onWheel(event) {
+    if (!inVirtual) return;
+    wrapperRaf.cancel(nextFrameRef.current);
+    var deltaY = event.deltaY;
+    offsetRef.current += deltaY;
+    wheelValueRef.current = deltaY; // Do nothing when scroll at the edge, Skip check when is in scroll
+
+    if (originScroll(deltaY)) return; // Proxy of scroll events
+
+    if (!isFF) {
+      event.preventDefault();
+    }
+
+    nextFrameRef.current = wrapperRaf(function () {
+      // Patch a multiple for Firefox to fix wheel number too small
+      // ref: https://github.com/ant-design/ant-design/issues/26372#issuecomment-679460266
+      var patchMultiple = isMouseScrollRef.current ? 10 : 1;
+      onWheelDelta(offsetRef.current * patchMultiple);
+      offsetRef.current = 0;
+    });
+  } // A patch for firefox
+
+
+  function onFireFoxScroll(event) {
+    if (!inVirtual) return;
+    isMouseScrollRef.current = event.detail === wheelValueRef.current;
+  }
+
+  return [onWheel, onFireFoxScroll];
+}
+
+export { useFrameWheel as default };