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

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

@@ -0,0 +1,150 @@
+/** @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 { useRef, useEffect } from 'react';
+import findDOMNode from '../../../rc-util/es/Dom/findDOMNode.js';
+import wrapperRaf from '../../../rc-util/es/raf.js';
+import CacheMap from '../utils/CacheMap.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;
+}
+/**
+ * To get exact height to avoid scrolling deviation
+ */
+
+
+function getOuterHeight(el) {
+  var height = el.offsetHeight;
+  var computedStyle = window.getComputedStyle(el);
+  height += parseInt(computedStyle.marginTop, 10);
+  height += parseInt(computedStyle.marginBottom, 10);
+  return height;
+}
+
+function useHeights(getKey, onItemAdd, onItemRemove) {
+  var _React$useState = React.useState(0),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      updatedMark = _React$useState2[0],
+      setUpdatedMark = _React$useState2[1];
+
+  var instanceRef = useRef(new Map());
+  var heightsRef = useRef(new CacheMap());
+  var collectRafRef = useRef();
+
+  function cancelRaf() {
+    wrapperRaf.cancel(collectRafRef.current);
+  }
+
+  function collectHeight() {
+    cancelRaf();
+    collectRafRef.current = wrapperRaf(function () {
+      instanceRef.current.forEach(function (element, key) {
+        if (element && element.offsetParent) {
+          var htmlElement = findDOMNode(element);
+          var outerHeight = getOuterHeight(htmlElement);
+
+          if (heightsRef.current.get(key) !== outerHeight) {
+            heightsRef.current.set(key, outerHeight);
+          }
+        }
+      }); // Always trigger update mark to tell parent that should re-calculate heights when resized
+
+      setUpdatedMark(function (c) {
+        return c + 1;
+      });
+    });
+  }
+
+  function setInstanceRef(item, instance) {
+    var key = getKey(item);
+    var origin = instanceRef.current.get(key);
+
+    if (instance) {
+      instanceRef.current.set(key, instance);
+      collectHeight();
+    } else {
+      instanceRef.current["delete"](key);
+    } // Instance changed
+
+
+    if (!origin !== !instance) {
+      if (instance) {
+        onItemAdd === null || onItemAdd === void 0 ? void 0 : onItemAdd(item);
+      } else {
+        onItemRemove === null || onItemRemove === void 0 ? void 0 : onItemRemove(item);
+      }
+    }
+  }
+
+  useEffect(function () {
+    return cancelRaf;
+  }, []);
+  return [setInstanceRef, collectHeight, heightsRef.current, updatedMark];
+}
+
+export { useHeights as default };

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

@@ -0,0 +1,85 @@
+/** @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 useLayoutEffect from '../../../rc-util/es/hooks/useLayoutEffect.js';
+var SMOOTH_PTG = 14 / 15;
+
+function useMobileTouchMove(inVirtual, listRef, callback) {
+  var touchedRef = useRef(false);
+  var touchYRef = useRef(0);
+  var elementRef = useRef(null); // Smooth scroll
+
+  var intervalRef = useRef(null);
+  /* eslint-disable prefer-const */
+
+  var cleanUpEvents;
+
+  var onTouchMove = function onTouchMove(e) {
+    if (touchedRef.current) {
+      var currentY = Math.ceil(e.touches[0].pageY);
+      var offsetY = touchYRef.current - currentY;
+      touchYRef.current = currentY;
+
+      if (callback(offsetY)) {
+        e.preventDefault();
+      } // Smooth interval
+
+
+      clearInterval(intervalRef.current);
+      intervalRef.current = setInterval(function () {
+        offsetY *= SMOOTH_PTG;
+
+        if (!callback(offsetY, true) || Math.abs(offsetY) <= 0.1) {
+          clearInterval(intervalRef.current);
+        }
+      }, 16);
+    }
+  };
+
+  var onTouchEnd = function onTouchEnd() {
+    touchedRef.current = false;
+    cleanUpEvents();
+  };
+
+  var onTouchStart = function onTouchStart(e) {
+    cleanUpEvents();
+
+    if (e.touches.length === 1 && !touchedRef.current) {
+      touchedRef.current = true;
+      touchYRef.current = Math.ceil(e.touches[0].pageY);
+      elementRef.current = e.target;
+      elementRef.current.addEventListener('touchmove', onTouchMove);
+      elementRef.current.addEventListener('touchend', onTouchEnd);
+    }
+  };
+
+  cleanUpEvents = function cleanUpEvents() {
+    if (elementRef.current) {
+      elementRef.current.removeEventListener('touchmove', onTouchMove);
+      elementRef.current.removeEventListener('touchend', onTouchEnd);
+    }
+  };
+
+  useLayoutEffect(function () {
+    if (inVirtual) {
+      listRef.current.addEventListener('touchstart', onTouchStart);
+    }
+
+    return function () {
+      var _listRef$current;
+
+      (_listRef$current = listRef.current) === null || _listRef$current === void 0 ? void 0 : _listRef$current.removeEventListener('touchstart', onTouchStart);
+      cleanUpEvents();
+      clearInterval(intervalRef.current);
+    };
+  }, [inVirtual]);
+}
+
+export { useMobileTouchMove as default };

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

@@ -0,0 +1,50 @@
+/** @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';
+
+var useOriginScroll = function useOriginScroll(isScrollAtTop, isScrollAtBottom) {
+  // Do lock for a wheel when scrolling
+  var lockRef = useRef(false);
+  var lockTimeoutRef = useRef(null);
+
+  function lockScroll() {
+    clearTimeout(lockTimeoutRef.current);
+    lockRef.current = true;
+    lockTimeoutRef.current = setTimeout(function () {
+      lockRef.current = false;
+    }, 50);
+  } // Pass to ref since global add is in closure
+
+
+  var scrollPingRef = useRef({
+    top: isScrollAtTop,
+    bottom: isScrollAtBottom
+  });
+  scrollPingRef.current.top = isScrollAtTop;
+  scrollPingRef.current.bottom = isScrollAtBottom;
+  return function (deltaY) {
+    var smoothOffset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    var originScroll = // Pass origin wheel when on the top
+    deltaY < 0 && scrollPingRef.current.top || // Pass origin wheel when on the bottom
+    deltaY > 0 && scrollPingRef.current.bottom;
+
+    if (smoothOffset && originScroll) {
+      // No need lock anymore when it's smooth offset from touchMove interval
+      clearTimeout(lockTimeoutRef.current);
+      lockRef.current = false;
+    } else if (!originScroll || lockRef.current) {
+      lockScroll();
+    }
+
+    return !lockRef.current && originScroll;
+  };
+};
+
+export { useOriginScroll as default };

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

@@ -0,0 +1,123 @@
+/** @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 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 useScrollTo(containerRef, data, heights, itemHeight, getKey, collectHeight, syncScrollTop, triggerFlash) {
+  var scrollRef = React.useRef();
+  return function (arg) {
+    // When not argument provided, we think dev may want to show the scrollbar
+    if (arg === null || arg === undefined) {
+      triggerFlash();
+      return;
+    } // Normal scroll logic
+
+
+    wrapperRaf.cancel(scrollRef.current);
+
+    if (typeof arg === 'number') {
+      syncScrollTop(arg);
+    } else if (arg && _typeof(arg) === 'object') {
+      var index;
+      var align = arg.align;
+
+      if ('index' in arg) {
+        index = arg.index;
+      } else {
+        index = data.findIndex(function (item) {
+          return getKey(item) === arg.key;
+        });
+      }
+
+      var _arg$offset = arg.offset,
+          offset = _arg$offset === void 0 ? 0 : _arg$offset; // We will retry 3 times in case dynamic height shaking
+
+      var syncScroll = function syncScroll(times, targetAlign) {
+        if (times < 0 || !containerRef.current) return;
+        var height = containerRef.current.clientHeight;
+        var needCollectHeight = false;
+        var newTargetAlign = targetAlign; // Go to next frame if height not exist
+
+        if (height) {
+          var mergedAlign = targetAlign || align; // Get top & bottom
+
+          var stackTop = 0;
+          var itemTop = 0;
+          var itemBottom = 0;
+          var maxLen = Math.min(data.length, index);
+
+          for (var i = 0; i <= maxLen; i += 1) {
+            var key = getKey(data[i]);
+            itemTop = stackTop;
+            var cacheHeight = heights.get(key);
+            itemBottom = itemTop + (cacheHeight === undefined ? itemHeight : cacheHeight);
+            stackTop = itemBottom;
+
+            if (i === index && cacheHeight === undefined) {
+              needCollectHeight = true;
+            }
+          } // Scroll to
+
+
+          var targetTop = null;
+
+          switch (mergedAlign) {
+            case 'top':
+              targetTop = itemTop - offset;
+              break;
+
+            case 'bottom':
+              targetTop = itemBottom - height + offset;
+              break;
+
+            default:
+              {
+                var scrollTop = containerRef.current.scrollTop;
+                var scrollBottom = scrollTop + height;
+
+                if (itemTop < scrollTop) {
+                  newTargetAlign = 'top';
+                } else if (itemBottom > scrollBottom) {
+                  newTargetAlign = 'bottom';
+                }
+              }
+          }
+
+          if (targetTop !== null && targetTop !== containerRef.current.scrollTop) {
+            syncScrollTop(targetTop);
+          }
+        } // We will retry since element may not sync height as it described
+
+
+        scrollRef.current = wrapperRaf(function () {
+          if (needCollectHeight) {
+            collectHeight();
+          }
+
+          syncScroll(times - 1, newTargetAlign);
+        });
+      };
+
+      syncScroll(3);
+    }
+  };
+}
+
+export { useScrollTo as default };

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

@@ -0,0 +1,11 @@
+/** @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 List from './List.js';
+export { default } from './List.js';

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

@@ -0,0 +1,59 @@
+/** @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.
+ */
+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;
+} // Firefox has low performance of map.
+
+
+var CacheMap = /*#__PURE__*/function () {
+  function CacheMap() {
+    _classCallCheck(this, CacheMap);
+
+    this.maps = void 0;
+    this.maps = Object.create(null);
+  }
+
+  _createClass(CacheMap, [{
+    key: "set",
+    value: function set(key, value) {
+      this.maps[key] = value;
+    }
+  }, {
+    key: "get",
+    value: function get(key) {
+      return this.maps[key];
+    }
+  }]);
+
+  return CacheMap;
+}();
+
+export { CacheMap as default };

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

@@ -0,0 +1,80 @@
+/** @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.
+ */
+
+/**
+ * Get index with specific start index one by one. e.g.
+ * min: 3, max: 9, start: 6
+ *
+ * Return index is:
+ * [0]: 6
+ * [1]: 7
+ * [2]: 5
+ * [3]: 8
+ * [4]: 4
+ * [5]: 9
+ * [6]: 3
+ */
+
+/**
+ * We assume that 2 list has only 1 item diff and others keeping the order.
+ * So we can use dichotomy algorithm to find changed one.
+ */
+function findListDiffIndex(originList, targetList, getKey) {
+  var originLen = originList.length;
+  var targetLen = targetList.length;
+  var shortList;
+  var longList;
+
+  if (originLen === 0 && targetLen === 0) {
+    return null;
+  }
+
+  if (originLen < targetLen) {
+    shortList = originList;
+    longList = targetList;
+  } else {
+    shortList = targetList;
+    longList = originList;
+  }
+
+  var notExistKey = {
+    __EMPTY_ITEM__: true
+  };
+
+  function getItemKey(item) {
+    if (item !== undefined) {
+      return getKey(item);
+    }
+
+    return notExistKey;
+  } // Loop to find diff one
+
+
+  var diffIndex = null;
+  var multiple = Math.abs(originLen - targetLen) !== 1;
+
+  for (var i = 0; i < longList.length; i += 1) {
+    var shortKey = getItemKey(shortList[i]);
+    var longKey = getItemKey(longList[i]);
+
+    if (shortKey !== longKey) {
+      diffIndex = i;
+      multiple = multiple || shortKey !== getItemKey(longList[i + 1]);
+      break;
+    }
+  }
+
+  return diffIndex === null ? null : {
+    index: diffIndex,
+    multiple: multiple
+  };
+}
+
+export { findListDiffIndex };

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

@@ -0,0 +1,21 @@
+/** @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.
+ */
+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);
+}
+
+var isFF = (typeof navigator === "undefined" ? "undefined" : _typeof(navigator)) === 'object' && /Firefox/i.test(navigator.userAgent);
+export { isFF as default };