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

package/lib/cjs/node_modules/rc-virtual-list/es/List.js

@@ -0,0 +1,550 @@
+/** @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.
+ */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+
+var React = require('react');
+
+var index = require('../../classnames/index.js');
+
+var Filler = require('./Filler.js');
+
+var ScrollBar = require('./ScrollBar.js');
+
+var useChildren = require('./hooks/useChildren.js');
+
+var useHeights = require('./hooks/useHeights.js');
+
+var useScrollTo = require('./hooks/useScrollTo.js');
+
+var useDiffItem = require('./hooks/useDiffItem.js');
+
+var useFrameWheel = require('./hooks/useFrameWheel.js');
+
+var useMobileTouchMove = require('./hooks/useMobileTouchMove.js');
+
+var useOriginScroll = require('./hooks/useOriginScroll.js');
+
+var useLayoutEffect = require('../../rc-util/es/hooks/useLayoutEffect.js');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function get() {
+            return e[k];
+          }
+        });
+      }
+    });
+  }
+
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+var _excluded = ["prefixCls", "className", "height", "itemHeight", "fullHeight", "style", "data", "children", "itemKey", "virtual", "component", "onScroll", "onVisibleChange"];
+
+function _extends() {
+  _extends = Object.assign || 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(object, enumerableOnly) {
+  var keys = Object.keys(object);
+
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function (sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+
+  return keys;
+}
+
+function _objectSpread(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = null != arguments[i] ? arguments[i] : {};
+    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
+      _defineProperty(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+
+  return target;
+}
+
+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 _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 _objectWithoutProperties(source, excluded) {
+  if (source == null) return {};
+
+  var target = _objectWithoutPropertiesLoose(source, excluded);
+
+  var key, i;
+
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+
+    for (i = 0; i < sourceSymbolKeys.length; i++) {
+      key = sourceSymbolKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+      target[key] = source[key];
+    }
+  }
+
+  return target;
+}
+
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+
+  return target;
+}
+
+var EMPTY_DATA = [];
+var ScrollStyle = {
+  overflowY: 'auto',
+  overflowAnchor: 'none'
+};
+
+function RawList(props, ref) {
+  var _props$prefixCls = props.prefixCls,
+      prefixCls = _props$prefixCls === void 0 ? 'rc-virtual-list' : _props$prefixCls,
+      className = props.className,
+      height = props.height,
+      itemHeight = props.itemHeight,
+      _props$fullHeight = props.fullHeight,
+      fullHeight = _props$fullHeight === void 0 ? true : _props$fullHeight,
+      style = props.style,
+      data = props.data,
+      children = props.children,
+      itemKey = props.itemKey,
+      virtual = props.virtual,
+      _props$component = props.component,
+      Component = _props$component === void 0 ? 'div' : _props$component,
+      onScroll = props.onScroll,
+      onVisibleChange = props.onVisibleChange,
+      restProps = _objectWithoutProperties(props, _excluded); // ================================= MISC =================================
+
+
+  var useVirtual = !!(virtual !== false && height && itemHeight);
+  var inVirtual = useVirtual && data && itemHeight * data.length > height;
+
+  var _useState = React.useState(0),
+      _useState2 = _slicedToArray(_useState, 2),
+      scrollTop = _useState2[0],
+      setScrollTop = _useState2[1];
+
+  var _useState3 = React.useState(false),
+      _useState4 = _slicedToArray(_useState3, 2),
+      scrollMoving = _useState4[0],
+      setScrollMoving = _useState4[1];
+
+  var mergedClassName = index["default"](prefixCls, className);
+  var mergedData = data || EMPTY_DATA;
+  var componentRef = React.useRef();
+  var fillerInnerRef = React.useRef();
+  var scrollBarRef = React.useRef(); // Hack on scrollbar to enable flash call
+  // =============================== Item Key ===============================
+
+  var getKey = React__namespace.useCallback(function (item) {
+    if (typeof itemKey === 'function') {
+      return itemKey(item);
+    }
+
+    return item === null || item === void 0 ? void 0 : item[itemKey];
+  }, [itemKey]);
+  var sharedConfig = {
+    getKey: getKey
+  }; // ================================ Scroll ================================
+
+  function syncScrollTop(newTop) {
+    setScrollTop(function (origin) {
+      var value;
+
+      if (typeof newTop === 'function') {
+        value = newTop(origin);
+      } else {
+        value = newTop;
+      }
+
+      var alignedTop = keepInRange(value);
+      componentRef.current.scrollTop = alignedTop;
+      return alignedTop;
+    });
+  } // ================================ Legacy ================================
+  // Put ref here since the range is generate by follow
+
+
+  var rangeRef = React.useRef({
+    start: 0,
+    end: mergedData.length
+  });
+  var diffItemRef = React.useRef();
+
+  var _useDiffItem = useDiffItem["default"](mergedData, getKey),
+      _useDiffItem2 = _slicedToArray(_useDiffItem, 1),
+      diffItem = _useDiffItem2[0];
+
+  diffItemRef.current = diffItem; // ================================ Height ================================
+
+  var _useHeights = useHeights["default"](getKey, null, null),
+      _useHeights2 = _slicedToArray(_useHeights, 4),
+      setInstanceRef = _useHeights2[0],
+      collectHeight = _useHeights2[1],
+      heights = _useHeights2[2],
+      heightUpdatedMark = _useHeights2[3]; // ========================== Visible Calculation =========================
+
+
+  var _React$useMemo = React__namespace.useMemo(function () {
+    if (!useVirtual) {
+      return {
+        scrollHeight: undefined,
+        start: 0,
+        end: mergedData.length - 1,
+        offset: undefined
+      };
+    } // Always use virtual scroll bar in avoid shaking
+    // Always use virtual scroll bar in avoid shaking
+
+
+    if (!inVirtual) {
+      var _fillerInnerRef$curre;
+
+      return {
+        scrollHeight: ((_fillerInnerRef$curre = fillerInnerRef.current) === null || _fillerInnerRef$curre === void 0 ? void 0 : _fillerInnerRef$curre.offsetHeight) || 0,
+        start: 0,
+        end: mergedData.length - 1,
+        offset: undefined
+      };
+    }
+
+    var itemTop = 0;
+    var startIndex;
+    var startOffset;
+    var endIndex;
+    var dataLen = mergedData.length;
+
+    for (var i = 0; i < dataLen; i += 1) {
+      var item = mergedData[i];
+      var key = getKey(item);
+      var cacheHeight = heights.get(key);
+      var currentItemBottom = itemTop + (cacheHeight === undefined ? itemHeight : cacheHeight); // Check item top in the range
+      // Check item top in the range
+
+      if (currentItemBottom >= scrollTop && startIndex === undefined) {
+        startIndex = i;
+        startOffset = itemTop;
+      } // Check item bottom in the range. We will render additional one item for motion usage
+      // Check item bottom in the range. We will render additional one item for motion usage
+
+
+      if (currentItemBottom > scrollTop + height && endIndex === undefined) {
+        endIndex = i;
+      }
+
+      itemTop = currentItemBottom;
+    } // Fallback to normal if not match. This code should never reach
+
+    /* istanbul ignore next */
+    // Fallback to normal if not match. This code should never reach
+
+    /* istanbul ignore next */
+
+
+    if (startIndex === undefined) {
+      startIndex = 0;
+      startOffset = 0;
+    }
+
+    if (endIndex === undefined) {
+      endIndex = mergedData.length - 1;
+    } // Give cache to improve scroll experience
+    // Give cache to improve scroll experience
+
+
+    endIndex = Math.min(endIndex + 1, mergedData.length);
+    return {
+      scrollHeight: itemTop,
+      start: startIndex,
+      end: endIndex,
+      offset: startOffset
+    };
+  }, [inVirtual, useVirtual, scrollTop, mergedData, heightUpdatedMark, height]),
+      scrollHeight = _React$useMemo.scrollHeight,
+      start = _React$useMemo.start,
+      end = _React$useMemo.end,
+      offset = _React$useMemo.offset;
+
+  rangeRef.current.start = start;
+  rangeRef.current.end = end; // =============================== In Range ===============================
+
+  var maxScrollHeight = scrollHeight - height;
+  var maxScrollHeightRef = React.useRef(maxScrollHeight);
+  maxScrollHeightRef.current = maxScrollHeight;
+
+  function keepInRange(newScrollTop) {
+    var newTop = newScrollTop;
+
+    if (!Number.isNaN(maxScrollHeightRef.current)) {
+      newTop = Math.min(newTop, maxScrollHeightRef.current);
+    }
+
+    newTop = Math.max(newTop, 0);
+    return newTop;
+  }
+
+  var isScrollAtTop = scrollTop <= 0;
+  var isScrollAtBottom = scrollTop >= maxScrollHeight;
+  var originScroll = useOriginScroll["default"](isScrollAtTop, isScrollAtBottom); // ================================ Scroll ================================
+
+  function onScrollBar(newScrollTop) {
+    var newTop = newScrollTop;
+    syncScrollTop(newTop);
+  } // When data size reduce. It may trigger native scroll event back to fit scroll position
+
+
+  function onFallbackScroll(e) {
+    var newScrollTop = e.currentTarget.scrollTop;
+
+    if (newScrollTop !== scrollTop) {
+      syncScrollTop(newScrollTop);
+    } // Trigger origin onScroll
+
+
+    onScroll === null || onScroll === void 0 ? void 0 : onScroll(e);
+  } // Since this added in global,should use ref to keep update
+
+
+  var _useFrameWheel = useFrameWheel["default"](useVirtual, isScrollAtTop, isScrollAtBottom, function (offsetY) {
+    syncScrollTop(function (top) {
+      var newTop = top + offsetY;
+      return newTop;
+    });
+  }),
+      _useFrameWheel2 = _slicedToArray(_useFrameWheel, 2),
+      onRawWheel = _useFrameWheel2[0],
+      onFireFoxScroll = _useFrameWheel2[1]; // Mobile touch move
+
+
+  useMobileTouchMove["default"](useVirtual, componentRef, function (deltaY, smoothOffset) {
+    if (originScroll(deltaY, smoothOffset)) {
+      return false;
+    }
+
+    onRawWheel({
+      preventDefault: function preventDefault() {},
+      deltaY: deltaY
+    });
+    return true;
+  });
+  useLayoutEffect["default"](function () {
+    // Firefox only
+    function onMozMousePixelScroll(e) {
+      if (useVirtual) {
+        e.preventDefault();
+      }
+    }
+
+    componentRef.current.addEventListener('wheel', onRawWheel);
+    componentRef.current.addEventListener('DOMMouseScroll', onFireFoxScroll);
+    componentRef.current.addEventListener('MozMousePixelScroll', onMozMousePixelScroll);
+    return function () {
+      if (componentRef.current) {
+        componentRef.current.removeEventListener('wheel', onRawWheel);
+        componentRef.current.removeEventListener('DOMMouseScroll', onFireFoxScroll);
+        componentRef.current.removeEventListener('MozMousePixelScroll', onMozMousePixelScroll);
+      }
+    };
+  }, [useVirtual]); // ================================= Ref ==================================
+
+  var scrollTo = useScrollTo["default"](componentRef, mergedData, heights, itemHeight, getKey, collectHeight, syncScrollTop, function () {
+    var _scrollBarRef$current;
+
+    (_scrollBarRef$current = scrollBarRef.current) === null || _scrollBarRef$current === void 0 ? void 0 : _scrollBarRef$current.delayHidden();
+  });
+  React__namespace.useImperativeHandle(ref, function () {
+    return {
+      scrollTo: scrollTo
+    };
+  }); // ================================ Effect ================================
+
+  /** We need told outside that some list not rendered */
+
+  useLayoutEffect["default"](function () {
+    if (onVisibleChange) {
+      var renderList = mergedData.slice(start, end + 1);
+      onVisibleChange(renderList, mergedData);
+    }
+  }, [start, end, mergedData]); // ================================ Render ================================
+
+  var listChildren = useChildren["default"](mergedData, start, end, setInstanceRef, children, sharedConfig);
+  var componentStyle = null;
+
+  if (height) {
+    componentStyle = _objectSpread(_defineProperty({}, fullHeight ? 'height' : 'maxHeight', height), ScrollStyle);
+
+    if (useVirtual) {
+      componentStyle.overflowY = 'hidden';
+
+      if (scrollMoving) {
+        componentStyle.pointerEvents = 'none';
+      }
+    }
+  }
+
+  return /*#__PURE__*/React__namespace.createElement("div", _extends({
+    style: _objectSpread(_objectSpread({}, style), {}, {
+      position: 'relative'
+    }),
+    className: mergedClassName
+  }, restProps), /*#__PURE__*/React__namespace.createElement(Component, {
+    className: "".concat(prefixCls, "-holder"),
+    style: componentStyle,
+    ref: componentRef,
+    onScroll: onFallbackScroll
+  }, /*#__PURE__*/React__namespace.createElement(Filler["default"], {
+    prefixCls: prefixCls,
+    height: scrollHeight,
+    offset: offset,
+    onInnerResize: collectHeight,
+    ref: fillerInnerRef
+  }, listChildren)), useVirtual && /*#__PURE__*/React__namespace.createElement(ScrollBar["default"], {
+    ref: scrollBarRef,
+    prefixCls: prefixCls,
+    scrollTop: scrollTop,
+    height: height,
+    scrollHeight: scrollHeight,
+    count: mergedData.length,
+    onScroll: onScrollBar,
+    onStartMove: function onStartMove() {
+      setScrollMoving(true);
+    },
+    onStopMove: function onStopMove() {
+      setScrollMoving(false);
+    }
+  }));
+}
+
+var List = /*#__PURE__*/React__namespace.forwardRef(RawList);
+List.displayName = 'List';
+exports.RawList = RawList;
+exports["default"] = List;