@kdcloudjs/kdesign 1.6.31 → 1.6.33

package/lib/virtual-list/virtual-list.js

@@ -0,0 +1,626 @@
+"use strict";
+
+var _typeof3 = require("@babel/runtime-corejs3/helpers/typeof");
+
+var _WeakMap = require("@babel/runtime-corejs3/core-js-stable/weak-map");
+
+var _Object$getOwnPropertyDescriptor = require("@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptor");
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.isNumber = isNumber;
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/typeof"));
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/extends"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/slicedToArray"));
+
+var _getOwnPropertySymbols = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/get-own-property-symbols"));
+
+var _slice = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/slice"));
+
+var _keys = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/keys"));
+
+var _entries = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/entries"));
+
+var _findIndex = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/find-index"));
+
+var _map = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/map"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _itemUtil = require("./utils/itemUtil");
+
+var _raf = require("../_utils/raf");
+
+var _hooks = require("../_utils/hooks");
+
+var _algorithmUtil = require("./utils/algorithmUtil");
+
+var _Filler = _interopRequireDefault(require("./Filler"));
+
+var _resizeObserver = _interopRequireDefault(require("../_utils/resizeObserver"));
+
+var _context;
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof _WeakMap !== "function") return null; var cacheBabelInterop = new _WeakMap(); var cacheNodeInterop = new _WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof3(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && _Object$getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? _Object$getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var __rest = void 0 && (void 0).__rest || function (s, e) {
+  var t = {};
+
+  for (var p in s) {
+    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  }
+
+  if (s != null && typeof _getOwnPropertySymbols.default === "function") for (var i = 0, p = (0, _getOwnPropertySymbols.default)(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+}; // Reference: https://github.com/arco-design/arco-design/blob/main/components/_class/VirtualList/index.tsx
+
+
+function isNumber(obj) {
+  return Object.prototype.toString.call(obj) === '[object Number]' && obj === obj; // eslint-disable-line
+}
+
+var DEFAULT_VIRTUAL_ITEM_HEIGHT = 32;
+var KEY_VIRTUAL_ITEM_HEIGHT = "__virtual_item_height_".concat((0, _slice.default)(_context = Math.random().toFixed(5)).call(_context, 2));
+
+var useComputeVirtualItemHeight = function useComputeVirtualItemHeight(refItemHeightMap) {
+  var forceUpdate = (0, _hooks.useForceUpdate)();
+  var heightMap = refItemHeightMap.current;
+  (0, _react.useEffect)(function () {
+    if ((0, _keys.default)(heightMap).length && !heightMap[KEY_VIRTUAL_ITEM_HEIGHT]) {
+      heightMap[KEY_VIRTUAL_ITEM_HEIGHT] = (0, _entries.default)(heightMap).reduce(function (sum, _ref, currentIndex, array) {
+        var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
+            currentHeight = _ref2[1];
+
+        var nextSum = sum + currentHeight;
+        return currentIndex === array.length - 1 ? Math.round(nextSum / array.length) : nextSum;
+      }, 0);
+      forceUpdate();
+    }
+  }, [(0, _keys.default)(heightMap).length]);
+};
+
+var useCacheChildrenNodes = function useCacheChildrenNodes(children) {
+  var refCacheMap = (0, _react.useRef)({});
+  var refPrevChildren = (0, _react.useRef)(children);
+  (0, _react.useEffect)(function () {
+    refPrevChildren.current = children;
+  }, [children]);
+
+  if (children !== refPrevChildren.current) {
+    refCacheMap.current = {};
+  }
+
+  return function (item, index, props) {
+    // eslint-disable-next-line no-prototype-builtins
+    if (!refCacheMap.current.hasOwnProperty(index)) {
+      refCacheMap.current[index] = children(item, index, props);
+    }
+
+    return refCacheMap.current[index];
+  };
+};
+
+var VirtualList = /*#__PURE__*/_react.default.forwardRef(function (props, ref) {
+  var style = props.style,
+      className = props.className,
+      children = props.children,
+      _props$data = props.data,
+      data = _props$data === void 0 ? [] : _props$data,
+      itemKey = props.itemKey,
+      _props$threshold = props.threshold,
+      threshold = _props$threshold === void 0 ? 100 : _props$threshold,
+      _props$wrapper = props.wrapper,
+      WrapperTagName = _props$wrapper === void 0 ? 'div' : _props$wrapper,
+      _props$height = props.height,
+      propHeight = _props$height === void 0 ? 300 : _props$height,
+      _props$isStaticItemHe = props.isStaticItemHeight,
+      isStaticItemHeight = _props$isStaticItemHe === void 0 ? true : _props$isStaticItemHe,
+      propItemHeight = props.itemHeight,
+      measureLongestItem = props.measureLongestItem,
+      scrollOptions = props.scrollOptions,
+      onScroll = props.onScroll,
+      _props$needFiller = props.needFiller,
+      needFiller = _props$needFiller === void 0 ? true : _props$needFiller,
+      outerStyle = props.outerStyle,
+      restProps = __rest(props, ["style", "className", "children", "data", "itemKey", "threshold", "wrapper", "height", "isStaticItemHeight", "itemHeight", "measureLongestItem", "scrollOptions", "onScroll", "needFiller", "outerStyle"]);
+
+  var styleListMaxHeight = style && style.maxHeight || propHeight;
+  var refItemHeightMap = (0, _react.useRef)({});
+
+  var _useState = (0, _react.useState)(200),
+      _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+      stateHeight = _useState2[0],
+      setStateHeight = _useState2[1];
+
+  var renderChild = useCacheChildrenNodes(children);
+  useComputeVirtualItemHeight(refItemHeightMap);
+  var itemCount = data.length;
+  var itemHeight = propItemHeight || refItemHeightMap.current[KEY_VIRTUAL_ITEM_HEIGHT] || DEFAULT_VIRTUAL_ITEM_HEIGHT;
+  var viewportHeight = isNumber(styleListMaxHeight) ? styleListMaxHeight : stateHeight;
+  var itemCountVisible = Math.ceil(viewportHeight / itemHeight);
+  var itemTotalHeight = itemHeight * itemCount;
+  var isVirtual = threshold !== null && itemCount >= threshold && itemTotalHeight > viewportHeight;
+  var refList = (0, _react.useRef)(null);
+  var refRafId = (0, _react.useRef)(null);
+  var refLockScroll = (0, _react.useRef)(false);
+  var refIsVirtual = (0, _react.useRef)(isVirtual);
+  var scrollListPadding = (0, _react.useMemo)(function () {
+    if (refList.current) {
+      var getPadding = function getPadding(property) {
+        return +window.getComputedStyle(refList.current)[property].replace(/\D/g, '');
+      };
+
+      return {
+        top: getPadding('paddingTop'),
+        bottom: getPadding('paddingBottom')
+      };
+    }
+
+    return {
+      top: 0,
+      bottom: 0
+    };
+  }, [refList.current]);
+
+  var _useStateWithPromise = (0, _hooks.useStateWithPromise)({
+    status: 'NONE',
+    startIndex: 0,
+    endIndex: 0,
+    itemIndex: 0,
+    itemOffsetPtg: 0,
+    startItemTop: 0,
+    scrollTop: 0
+  }),
+      _useStateWithPromise2 = (0, _slicedToArray2.default)(_useStateWithPromise, 2),
+      state = _useStateWithPromise2[0],
+      setState = _useStateWithPromise2[1];
+
+  var prevData = (0, _hooks.usePrevious)(data) || [];
+  var isFirstRender = (0, _hooks.useIsFirstRender)();
+
+  var getItemKey = function getItemKey(item, index) {
+    return typeof itemKey === 'function' ? itemKey(item, index) : typeof itemKey === 'string' ? item[itemKey] : item.key || index;
+  };
+
+  var getItemKeyByIndex = function getItemKeyByIndex(index) {
+    var items = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : data;
+
+    if (index === items.length) {
+      return _itemUtil.GHOST_ITEM_KEY;
+    }
+
+    var item = items[index];
+    return item !== undefined ? getItemKey(item, index) : null;
+  };
+
+  var getCachedItemHeight = function getCachedItemHeight(key) {
+    return refItemHeightMap.current[key] || itemHeight;
+  };
+
+  var internalScrollTo = function internalScrollTo(relativeScroll) {
+    var compareItemIndex = relativeScroll.itemIndex,
+        compareItemRelativeTop = relativeScroll.relativeTop;
+    if (!refList.current) return;
+    var _refList$current = refList.current,
+        scrollHeight = _refList$current.scrollHeight,
+        clientHeight = _refList$current.clientHeight;
+    var originScrollTop = state.scrollTop;
+    var maxScrollTop = scrollHeight - clientHeight;
+    var bestSimilarity = Number.MAX_VALUE;
+    var bestScrollTop = null;
+    var bestItemIndex = null;
+    var bestItemOffsetPtg = null;
+    var bestStartIndex = null;
+    var bestEndIndex = null;
+    var missSimilarity = 0;
+
+    for (var i = 0; i < maxScrollTop; i++) {
+      var scrollTop = (0, _algorithmUtil.getIndexByStartLoc)(0, maxScrollTop, originScrollTop, i);
+      var scrollPtg = (0, _itemUtil.getScrollPercentage)({
+        scrollTop: scrollTop,
+        scrollHeight: scrollHeight,
+        clientHeight: clientHeight
+      });
+
+      var _getRangeIndex = (0, _itemUtil.getRangeIndex)(scrollPtg, itemCount, itemCountVisible),
+          itemIndex = _getRangeIndex.itemIndex,
+          itemOffsetPtg = _getRangeIndex.itemOffsetPtg,
+          startIndex = _getRangeIndex.startIndex,
+          endIndex = _getRangeIndex.endIndex;
+
+      if (startIndex <= compareItemIndex && compareItemIndex <= endIndex) {
+        var locatedItemRelativeTop = (0, _itemUtil.getItemRelativeTop)({
+          itemHeight: getCachedItemHeight(getItemKeyByIndex(itemIndex)),
+          itemOffsetPtg: itemOffsetPtg,
+          clientHeight: clientHeight,
+          scrollPtg: scrollPtg
+        });
+        var compareItemTop = (0, _itemUtil.getCompareItemRelativeTop)({
+          locatedItemRelativeTop: locatedItemRelativeTop,
+          locatedItemIndex: itemIndex,
+          compareItemIndex: compareItemIndex,
+          startIndex: startIndex,
+          endIndex: endIndex,
+          itemHeight: itemHeight,
+          getItemKey: getItemKeyByIndex,
+          itemElementHeights: refItemHeightMap.current
+        });
+        var similarity = Math.abs(compareItemTop - compareItemRelativeTop);
+
+        if (similarity < bestSimilarity) {
+          bestSimilarity = similarity;
+          bestScrollTop = scrollTop;
+          bestItemIndex = itemIndex;
+          bestItemOffsetPtg = itemOffsetPtg;
+          bestStartIndex = startIndex;
+          bestEndIndex = endIndex;
+          missSimilarity = 0;
+        } else {
+          missSimilarity += 1;
+        }
+      }
+
+      if (missSimilarity > 10) {
+        break;
+      }
+    }
+
+    if (bestScrollTop !== null) {
+      refLockScroll.current = true;
+      refList.current.scrollTop = bestScrollTop;
+      setState((0, _extends2.default)((0, _extends2.default)({}, state), {
+        status: 'MEASURE_START',
+        scrollTop: bestScrollTop,
+        itemIndex: bestItemIndex,
+        itemOffsetPtg: bestItemOffsetPtg,
+        startIndex: bestStartIndex,
+        endIndex: bestEndIndex
+      }));
+    }
+
+    refRafId.current = (0, _raf.raf)(function () {
+      refLockScroll.current = false;
+    });
+  };
+
+  var rawListScrollHandler = function rawListScrollHandler(event) {
+    if (!refList.current) return;
+    var _refList$current2 = refList.current,
+        rawScrollTop = _refList$current2.scrollTop,
+        clientHeight = _refList$current2.clientHeight,
+        scrollHeight = _refList$current2.scrollHeight;
+    var scrollTop = (0, _itemUtil.getValidScrollTop)(rawScrollTop, scrollHeight - clientHeight);
+    var scrollPtg = (0, _itemUtil.getScrollPercentage)({
+      scrollTop: scrollTop,
+      clientHeight: clientHeight,
+      scrollHeight: scrollHeight
+    });
+
+    var _getLocationItem = (0, _itemUtil.getLocationItem)(scrollPtg, itemCount),
+        index = _getLocationItem.index,
+        offsetPtg = _getLocationItem.offsetPtg;
+
+    setState((0, _extends2.default)((0, _extends2.default)({}, state), {
+      scrollTop: scrollTop,
+      itemIndex: index,
+      itemOffsetPtg: offsetPtg
+    }));
+    event && onScroll && onScroll(event);
+  };
+
+  var virtualListScrollHandler = function virtualListScrollHandler(event) {
+    var isInit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    var scrollHeight = itemTotalHeight;
+    if (!refList.current) return;
+    var _refList$current3 = refList.current,
+        rawScrollTop = _refList$current3.scrollTop,
+        clientHeight = _refList$current3.clientHeight;
+    var scrollTop = (0, _itemUtil.getValidScrollTop)(rawScrollTop, scrollHeight - clientHeight);
+
+    if (!isInit && (scrollTop === state.scrollTop || refLockScroll.current)) {
+      return;
+    }
+
+    var scrollPtg = (0, _itemUtil.getScrollPercentage)({
+      scrollTop: scrollTop,
+      clientHeight: clientHeight,
+      scrollHeight: scrollHeight
+    });
+
+    var _getRangeIndex2 = (0, _itemUtil.getRangeIndex)(scrollPtg, itemCount, itemCountVisible),
+        itemIndex = _getRangeIndex2.itemIndex,
+        itemOffsetPtg = _getRangeIndex2.itemOffsetPtg,
+        startIndex = _getRangeIndex2.startIndex,
+        endIndex = _getRangeIndex2.endIndex;
+
+    setState((0, _extends2.default)((0, _extends2.default)({}, state), {
+      scrollTop: scrollTop,
+      itemIndex: itemIndex,
+      itemOffsetPtg: itemOffsetPtg,
+      startIndex: startIndex,
+      endIndex: endIndex,
+      status: 'MEASURE_START'
+    }));
+    event && onScroll && onScroll(event);
+  };
+
+  (0, _react.useEffect)(function () {
+    return function () {
+      refRafId.current && (0, _raf.caf)(refRafId.current);
+    };
+  }, []);
+  (0, _react.useEffect)(function () {
+    if (refList.current) {
+      if (isFirstRender) {
+        refList.current.scrollTop = 0;
+      }
+
+      virtualListScrollHandler(null, true);
+    }
+  }, [itemCountVisible]);
+  (0, _react.useEffect)(function () {
+    var changedItemIndex = null;
+    var switchTo = refIsVirtual.current !== isVirtual ? isVirtual ? 'virtual' : 'raw' : '';
+    refIsVirtual.current = isVirtual;
+
+    if (viewportHeight && prevData.length !== data.length) {
+      var diff = (0, _algorithmUtil.findListDiffIndex)(prevData, data, getItemKey);
+      changedItemIndex = diff ? diff.index : null;
+    }
+
+    if ((switchTo || isVirtual && changedItemIndex) && refList.current) {
+      var clientHeight = refList.current.clientHeight;
+      var locatedItemRelativeTop = (0, _itemUtil.getItemRelativeTop)({
+        itemHeight: getCachedItemHeight(getItemKeyByIndex(state.itemIndex, prevData)),
+        itemOffsetPtg: state.itemOffsetPtg,
+        scrollPtg: (0, _itemUtil.getScrollPercentage)({
+          scrollTop: state.scrollTop,
+          scrollHeight: prevData.length * itemHeight,
+          clientHeight: clientHeight
+        }),
+        clientHeight: clientHeight
+      });
+
+      if (switchTo === 'raw') {
+        var rawTop = locatedItemRelativeTop;
+
+        for (var index = 0; index < state.itemIndex; index++) {
+          rawTop -= getCachedItemHeight(getItemKeyByIndex(index));
+        }
+
+        refList.current.scrollTop = -rawTop;
+        refLockScroll.current = true;
+        refRafId.current = (0, _raf.raf)(function () {
+          refLockScroll.current = false;
+        });
+      } else {
+        internalScrollTo({
+          itemIndex: state.itemIndex,
+          relativeTop: locatedItemRelativeTop
+        });
+      }
+    }
+  }, [data, isVirtual]);
+  (0, _react.useLayoutEffect)(function () {
+    if (state.status === 'MEASURE_START' && refList.current) {
+      var _refList$current4 = refList.current,
+          scrollTop = _refList$current4.scrollTop,
+          scrollHeight = _refList$current4.scrollHeight,
+          clientHeight = _refList$current4.clientHeight;
+      var scrollPtg = (0, _itemUtil.getScrollPercentage)({
+        scrollTop: scrollTop,
+        scrollHeight: scrollHeight,
+        clientHeight: clientHeight
+      });
+      var startItemTop = (0, _itemUtil.getItemAbsoluteTop)({
+        scrollPtg: scrollPtg,
+        clientHeight: clientHeight,
+        scrollTop: scrollTop - (scrollListPadding.top + scrollListPadding.bottom) * scrollPtg,
+        itemHeight: getCachedItemHeight(getItemKeyByIndex(state.itemIndex)),
+        itemOffsetPtg: state.itemOffsetPtg
+      });
+
+      for (var index = state.itemIndex - 1; index >= state.startIndex; index--) {
+        startItemTop -= getCachedItemHeight(getItemKeyByIndex(index));
+      }
+
+      setState((0, _extends2.default)((0, _extends2.default)({}, state), {
+        startItemTop: startItemTop,
+        status: 'MEASURE_DONE'
+      }));
+    }
+  }, [state]);
+  (0, _react.useImperativeHandle)(ref, function () {
+    return {
+      dom: refList.current,
+      scrollTo: function scrollTo(arg) {
+        refRafId.current && (0, _raf.caf)(refRafId.current);
+        refRafId.current = (0, _raf.raf)(function () {
+          var _a;
+
+          if (typeof arg === 'number') {
+            refList.current.scrollTop = arg;
+            return;
+          }
+
+          var index = 'index' in arg ? arg.index : 'key' in arg ? (0, _findIndex.default)(data).call(data, function (item, index) {
+            return getItemKey(item, index) === arg.key;
+          }) : 0;
+          var item = data[index];
+
+          if (!item) {
+            return;
+          }
+
+          var align = (0, _typeof2.default)(arg) === 'object' && ((_a = arg.options) === null || _a === void 0 ? void 0 : _a.block) ? arg.options.block : (scrollOptions === null || scrollOptions === void 0 ? void 0 : scrollOptions.block) || 'nearest';
+          var _refList$current5 = refList.current,
+              clientHeight = _refList$current5.clientHeight,
+              scrollTop = _refList$current5.scrollTop;
+
+          if (isVirtual && !isStaticItemHeight) {
+            if (align === 'nearest') {
+              var itemIndex = state.itemIndex,
+                  itemOffsetPtg = state.itemOffsetPtg;
+
+              if (Math.abs(itemIndex - index) < itemCountVisible) {
+                var itemTop = (0, _itemUtil.getItemRelativeTop)({
+                  itemHeight: getCachedItemHeight(getItemKeyByIndex(itemIndex)),
+                  itemOffsetPtg: itemOffsetPtg,
+                  clientHeight: clientHeight,
+                  scrollPtg: (0, _itemUtil.getScrollPercentage)(refList.current)
+                });
+
+                if (index < itemIndex) {
+                  for (var i = index; i < itemIndex; i++) {
+                    itemTop -= getCachedItemHeight(getItemKeyByIndex(i));
+                  }
+                } else {
+                  for (var _i = itemIndex; _i < index; _i++) {
+                    itemTop += getCachedItemHeight(getItemKeyByIndex(_i));
+                  }
+                }
+
+                if (itemTop < 0 || itemTop > clientHeight) {
+                  align = itemTop < 0 ? 'start' : 'end';
+                } else {
+                  return;
+                }
+              } else {
+                align = index < itemIndex ? 'start' : 'end';
+              }
+            }
+
+            setState((0, _extends2.default)((0, _extends2.default)({}, state), {
+              startIndex: Math.max(0, index - itemCountVisible),
+              endIndex: Math.min(itemCount - 1, index + itemCountVisible)
+            })).then(function () {
+              var itemHeight = getCachedItemHeight(getItemKey(item, index));
+              internalScrollTo({
+                itemIndex: index,
+                relativeTop: align === 'start' ? 0 : (clientHeight - itemHeight) / (align === 'center' ? 2 : 1)
+              });
+            });
+          } else {
+            var indexItemHeight = getCachedItemHeight(getItemKeyByIndex(index));
+            var _itemTop = 0;
+
+            for (var _i2 = 0; _i2 < index; _i2++) {
+              _itemTop += getCachedItemHeight(getItemKeyByIndex(_i2));
+            }
+
+            var itemBottom = _itemTop + indexItemHeight;
+            var itemMiddle = _itemTop + indexItemHeight / 2;
+
+            if (itemMiddle > scrollTop && itemMiddle < clientHeight + scrollTop) {
+              return;
+            }
+
+            if (align === 'nearest') {
+              if (_itemTop < scrollTop) {
+                align = 'start';
+              } else if (itemBottom > scrollTop + clientHeight) {
+                align = 'end';
+              }
+            }
+
+            var _viewportHeight = clientHeight - indexItemHeight;
+
+            refList.current.scrollTop = _itemTop - (align === 'start' ? 0 : _viewportHeight / (align === 'center' ? 2 : 1));
+          }
+        });
+      }
+    };
+  }, [data, itemHeight, state]);
+
+  var renderChildren = function renderChildren(list, startIndex) {
+    return (0, _map.default)(list).call(list, function (item, index) {
+      var originIndex = startIndex + index;
+      var node = renderChild(item, originIndex, {
+        style: {}
+      });
+      var key = getItemKey(item, originIndex);
+      return /*#__PURE__*/_react.default.cloneElement(node, {
+        key: key,
+        ref: function ref(ele) {
+          var heightMap = refItemHeightMap.current;
+
+          if (ele && state.status === 'MEASURE_START' && (!isStaticItemHeight || heightMap[key] === undefined)) {
+            if (isStaticItemHeight) {
+              if (!heightMap[KEY_VIRTUAL_ITEM_HEIGHT]) {
+                heightMap[KEY_VIRTUAL_ITEM_HEIGHT] = (0, _itemUtil.getNodeHeight)(ele, true);
+              }
+
+              heightMap[key] = heightMap[KEY_VIRTUAL_ITEM_HEIGHT];
+            } else {
+              heightMap[key] = (0, _itemUtil.getNodeHeight)(ele, true);
+            }
+          }
+        }
+      });
+    });
+  };
+
+  var refLongestItemIndex = (0, _react.useRef)(null);
+  (0, _react.useEffect)(function () {
+    refLongestItemIndex.current = null;
+  }, [data]);
+
+  var renderLongestItem = function renderLongestItem() {
+    if (measureLongestItem) {
+      var index = refLongestItemIndex.current === null ? (0, _itemUtil.getLongestItemIndex)(data) : refLongestItemIndex.current;
+      var item = data[index];
+      refLongestItemIndex.current = index;
+      return item ? /*#__PURE__*/_react.default.createElement("div", {
+        style: {
+          height: 1,
+          overflow: 'hidden',
+          opacity: 0
+        }
+      }, renderChild(item, index, {
+        style: {}
+      })) : null;
+    }
+
+    return null;
+  };
+
+  return /*#__PURE__*/_react.default.createElement(_resizeObserver.default, {
+    onResize: function onResize() {
+      if (refList.current && !isNumber(styleListMaxHeight)) {
+        var clientHeight = refList.current.clientHeight;
+        setStateHeight(clientHeight);
+      }
+    }
+  }, /*#__PURE__*/_react.default.createElement(WrapperTagName, (0, _extends2.default)({
+    ref: refList,
+    style: (0, _extends2.default)((0, _extends2.default)({
+      overflowY: 'auto',
+      overflowAnchor: 'none'
+    }, style), {
+      maxHeight: styleListMaxHeight
+    }),
+    className: className,
+    onScroll: isVirtual ? virtualListScrollHandler : rawListScrollHandler
+  }, restProps), isVirtual ? /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/_react.default.createElement(_Filler.default, {
+    height: itemTotalHeight,
+    offset: state.status === 'MEASURE_DONE' ? state.startItemTop : 0,
+    outerStyle: outerStyle
+  }, renderChildren((0, _slice.default)(data).call(data, state.startIndex, state.endIndex + 1), state.startIndex)), renderLongestItem()) : needFiller ? /*#__PURE__*/_react.default.createElement(_Filler.default, {
+    height: viewportHeight
+  }, renderChildren(data, 0)) : renderChildren(data, 0)));
+});
+
+VirtualList.displayName = 'VirtualList';
+var _default = VirtualList;
+exports.default = _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kdcloudjs/kdesign",
-  "version": "1.6.31",
+  "version": "1.6.33",
   "description": "KDesign 金蝶前端react 组件库",
   "title": "kdesign",
   "keywords": [