@para-ui/core 4.0.6 → 4.0.7-alpha2

package/_verture/{index-9784b09c.js → index-b33b6e81.js}

@@ -1,7 +1,7 @@
-import { _ as __rest } from './tslib.es6-55ed4bd2.js';
+import { _ as __rest } from './tslib.es6-fe0d4b4e.js';
 import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
 import { _ as _arrayLikeToArray, a as _unsupportedIterableToArray, b as _slicedToArray, c as _arrayWithHoles, d as _nonIterableRest } from './slicedToArray-8223a2ef.js';
-import { _ as _defineProperty, a as _toPropertyKey } from './defineProperty-1d116156.js';
+import { _ as _defineProperty, t as toPropertyKey } from './defineProperty-6f62bb2a.js';
 import { _ as _typeof$1 } from './typeof-adeedc13.js';
 import * as React$4 from 'react';
 import React__default, { useState as useState$1, useMemo as useMemo$1, useCallback, useRef, useEffect } from 'react';
@@ -245,8 +245,19 @@ var preWarningFns = [];
 var preMessage = function preMessage(fn) {
   preWarningFns.push(fn);
 };
+
+/**
+ * Warning if condition not match.
+ * @param valid Condition
+ * @param message Warning message
+ * @example
+ * ```js
+ * warning(false, 'some error'); // print some error
+ * warning(true, 'some error'); // print nothing
+ * warning(1 === 2, 'some error'); // print some error
+ * ```
+ */
 function warning(valid, message) {
-  // Support uglify
   if (process.env.NODE_ENV !== 'production' && !valid && console !== undefined) {
     var finalMessage = preWarningFns.reduce(function (msg, preMessageFn) {
       return preMessageFn(msg !== null && msg !== void 0 ? msg : '', 'warning');
@@ -256,8 +267,9 @@ function warning(valid, message) {
     }
   }
 }
+
+/** @see Similar to {@link warning} */
 function note(valid, message) {
-  // Support uglify
   if (process.env.NODE_ENV !== 'production' && !valid && console !== undefined) {
     var finalMessage = preWarningFns.reduce(function (msg, preMessageFn) {
       return preMessageFn(msg !== null && msg !== void 0 ? msg : '', 'note');
@@ -276,16 +288,19 @@ function call(method, valid, message) {
     warned[message] = true;
   }
 }
+
+/** @see Same as {@link warning}, but only warn once for the same message */
 function warningOnce(valid, message) {
   call(warning, valid, message);
 }
+
+/** @see Same as {@link warning}, but only warn once for the same message */
 function noteOnce(valid, message) {
   call(note, valid, message);
 }
 warningOnce.preMessage = preMessage;
 warningOnce.resetWarned = resetWarned;
 warningOnce.noteOnce = noteOnce;
-/* eslint-enable */
 
 var classnames = {exports: {}};
 
@@ -302,39 +317,57 @@ var classnames = {exports: {}};
 
 		var hasOwn = {}.hasOwnProperty;
 
-		function classNames() {
-			var classes = [];
+		function classNames () {
+			var classes = '';
 
 			for (var i = 0; i < arguments.length; i++) {
 				var arg = arguments[i];
-				if (!arg) continue;
-
-				var argType = typeof arg;
-
-				if (argType === 'string' || argType === 'number') {
-					classes.push(arg);
-				} else if (Array.isArray(arg)) {
-					if (arg.length) {
-						var inner = classNames.apply(null, arg);
-						if (inner) {
-							classes.push(inner);
-						}
-					}
-				} else if (argType === 'object') {
-					if (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes('[native code]')) {
-						classes.push(arg.toString());
-						continue;
-					}
-
-					for (var key in arg) {
-						if (hasOwn.call(arg, key) && arg[key]) {
-							classes.push(key);
-						}
-					}
+				if (arg) {
+					classes = appendClass(classes, parseValue(arg));
 				}
 			}
 
-			return classes.join(' ');
+			return classes;
+		}
+
+		function parseValue (arg) {
+			if (typeof arg === 'string' || typeof arg === 'number') {
+				return arg;
+			}
+
+			if (typeof arg !== 'object') {
+				return '';
+			}
+
+			if (Array.isArray(arg)) {
+				return classNames.apply(null, arg);
+			}
+
+			if (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes('[native code]')) {
+				return arg.toString();
+			}
+
+			var classes = '';
+
+			for (var key in arg) {
+				if (hasOwn.call(arg, key) && arg[key]) {
+					classes = appendClass(classes, key);
+				}
+			}
+
+			return classes;
+		}
+
+		function appendClass (value, newClass) {
+			if (!newClass) {
+				return value;
+			}
+		
+			if (value) {
+				return value + ' ' + newClass;
+			}
+		
+			return value + newClass;
 		}
 
 		if (module.exports) {
@@ -1212,12 +1245,12 @@ function supportRef(nodeOrComponent) {
   var type = reactIs.exports.isMemo(nodeOrComponent) ? nodeOrComponent.type.type : nodeOrComponent.type;
 
   // Function component node
-  if (typeof type === 'function' && !((_type$prototype = type.prototype) !== null && _type$prototype !== void 0 && _type$prototype.render)) {
+  if (typeof type === 'function' && !((_type$prototype = type.prototype) !== null && _type$prototype !== void 0 && _type$prototype.render) && type.$$typeof !== reactIs.exports.ForwardRef) {
     return false;
   }
 
   // Class component
-  if (typeof nodeOrComponent === 'function' && !((_nodeOrComponent$prot = nodeOrComponent.prototype) !== null && _nodeOrComponent$prot !== void 0 && _nodeOrComponent$prot.render)) {
+  if (typeof nodeOrComponent === 'function' && !((_nodeOrComponent$prot = nodeOrComponent.prototype) !== null && _nodeOrComponent$prot !== void 0 && _nodeOrComponent$prot.render) && nodeOrComponent.$$typeof !== reactIs.exports.ForwardRef) {
     return false;
   }
   return true;
@@ -2480,7 +2513,7 @@ function _defineProperties(target, props) {
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor) descriptor.writable = true;
-    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+    Object.defineProperty(target, toPropertyKey(descriptor.key), descriptor);
   }
 }
 function _createClass(Constructor, protoProps, staticProps) {
@@ -2525,15 +2558,12 @@ function _getPrototypeOf(o) {
 }
 
 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;
-  }
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+  } catch (t) {}
+  return (_isNativeReflectConstruct = function _isNativeReflectConstruct() {
+    return !!t;
+  })();
 }
 
 function _assertThisInitialized(self) {
@@ -3917,7 +3947,7 @@ function injectCSS(css) {
   if (prepend) {
     // If is queue `prepend`, it will prepend first style and then append rest style
     if (isPrependQueue) {
-      var existStyle = findStyles(container).filter(function (node) {
+      var existStyle = (option.styles || findStyles(container)).filter(function (node) {
         // Ignore style which not injected by rc-util with prepend
         if (!['prepend', 'prependQueue'].includes(node.getAttribute(APPEND_ORDER))) {
           return false;
@@ -3943,7 +3973,7 @@ function injectCSS(css) {
 function findExistNode(key) {
   var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   var container = getContainer(option);
-  return findStyles(container).find(function (node) {
+  return (option.styles || findStyles(container)).find(function (node) {
     return node.getAttribute(getMark(option)) === key;
   });
 }
@@ -3971,8 +4001,12 @@ function syncRealContainer(container, option) {
   }
 }
 function updateCSS(css, key) {
-  var option = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  var container = getContainer(option);
+  var originOption = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  var container = getContainer(originOption);
+  var styles = findStyles(container);
+  var option = _objectSpread2(_objectSpread2({}, originOption), {}, {
+    styles: styles
+  });
 
   // Sync real parent
   syncRealContainer(container, option);
@@ -3994,43 +4028,60 @@ function updateCSS(css, key) {
 }
 
 /* eslint-disable no-param-reassign */
+function measureScrollbarSize(ele) {
+  var randomId = "rc-scrollbar-measure-".concat(Math.random().toString(36).substring(7));
+  var measureEle = document.createElement('div');
+  measureEle.id = randomId;
+
+  // Create Style
+  var measureStyle = measureEle.style;
+  measureStyle.position = 'absolute';
+  measureStyle.left = '0';
+  measureStyle.top = '0';
+  measureStyle.width = '100px';
+  measureStyle.height = '100px';
+  measureStyle.overflow = 'scroll';
+
+  // Clone Style if needed
+  var fallbackWidth;
+  var fallbackHeight;
+  if (ele) {
+    var targetStyle = getComputedStyle(ele);
+    measureStyle.scrollbarColor = targetStyle.scrollbarColor;
+    measureStyle.scrollbarWidth = targetStyle.scrollbarWidth;
+
+    // Set Webkit style
+    var webkitScrollbarStyle = getComputedStyle(ele, '::-webkit-scrollbar');
+    var width = parseInt(webkitScrollbarStyle.width, 10);
+    var height = parseInt(webkitScrollbarStyle.height, 10);
+
+    // Try wrap to handle CSP case
+    try {
+      var widthStyle = width ? "width: ".concat(webkitScrollbarStyle.width, ";") : '';
+      var heightStyle = height ? "height: ".concat(webkitScrollbarStyle.height, ";") : '';
+      updateCSS("\n#".concat(randomId, "::-webkit-scrollbar {\n").concat(widthStyle, "\n").concat(heightStyle, "\n}"), randomId);
+    } catch (e) {
+      // Can't wrap, just log error
+      console.error(e);
+
+      // Get from style directly
+      fallbackWidth = width;
+      fallbackHeight = height;
+    }
+  }
+  document.body.appendChild(measureEle);
+
+  // Measure. Get fallback style if provided
+  var scrollWidth = ele && fallbackWidth && !isNaN(fallbackWidth) ? fallbackWidth : measureEle.offsetWidth - measureEle.clientWidth;
+  var scrollHeight = ele && fallbackHeight && !isNaN(fallbackHeight) ? fallbackHeight : measureEle.offsetHeight - measureEle.clientHeight;
 
-var cached;
-function getScrollBarSize(fresh) {
-  if (typeof document === 'undefined') {
-    return 0;
-  }
-  if (fresh || cached === undefined) {
-    var inner = document.createElement('div');
-    inner.style.width = '100%';
-    inner.style.height = '200px';
-    var outer = document.createElement('div');
-    var outerStyle = outer.style;
-    outerStyle.position = 'absolute';
-    outerStyle.top = '0';
-    outerStyle.left = '0';
-    outerStyle.pointerEvents = 'none';
-    outerStyle.visibility = 'hidden';
-    outerStyle.width = '200px';
-    outerStyle.height = '150px';
-    outerStyle.overflow = 'hidden';
-    outer.appendChild(inner);
-    document.body.appendChild(outer);
-    var widthContained = inner.offsetWidth;
-    outer.style.overflow = 'scroll';
-    var widthScroll = inner.offsetWidth;
-    if (widthContained === widthScroll) {
-      widthScroll = outer.clientWidth;
-    }
-    document.body.removeChild(outer);
-    cached = widthContained - widthScroll;
-  }
-  return cached;
-}
-function ensureSize(str) {
-  var match = str.match(/^(.*)px$/);
-  var value = Number(match === null || match === void 0 ? void 0 : match[1]);
-  return Number.isNaN(value) ? getScrollBarSize() : value;
+  // Clean up
+  document.body.removeChild(measureEle);
+  removeCSS(randomId);
+  return {
+    width: scrollWidth,
+    height: scrollHeight
+  };
 }
 function getTargetScrollBarSize(target) {
   if (typeof document === 'undefined' || !target || !(target instanceof Element)) {
@@ -4039,13 +4090,7 @@ function getTargetScrollBarSize(target) {
       height: 0
     };
   }
-  var _getComputedStyle = getComputedStyle(target, '::-webkit-scrollbar'),
-    width = _getComputedStyle.width,
-    height = _getComputedStyle.height;
-  return {
-    width: ensureSize(width),
-    height: ensureSize(height)
-  };
+  return measureScrollbarSize(target);
 }
 
 /**
@@ -5369,7 +5414,9 @@ var _excluded$6 = ["prefixCls", "children", "action", "showAction", "hideAction"
 // Removed Props List
 // Seems this can be auto
 // getDocument?: (element?: HTMLElement) => Document;
+
 // New version will not wrap popup with `rc-trigger-popup-content` when multiple children
+
 function generateTrigger() {
   var PortalComponent = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : Portal;
   var Trigger = /*#__PURE__*/React$4.forwardRef(function (props, ref) {
@@ -5717,9 +5764,9 @@ function generateTrigger() {
       wrapperAction('onPointerEnter', true, mouseEnterDelay, function (event) {
         setMousePosByEvent(event);
       });
-      onPopupMouseEnter = function onPopupMouseEnter() {
+      onPopupMouseEnter = function onPopupMouseEnter(event) {
         // Only trigger re-open when popup is visible
-        if (mergedOpen || inMotion) {
+        if ((mergedOpen || inMotion) && popupEle !== null && popupEle !== void 0 && popupEle.contains(event.target)) {
           triggerOpen(true, mouseEnterDelay);
         }
       };
@@ -6944,16 +6991,15 @@ var Filler = /*#__PURE__*/React$4.forwardRef(function (_ref, ref) {
     flexDirection: 'column'
   };
   if (offsetY !== undefined) {
-    var _objectSpread2$1;
     // Not set `width` since this will break `sticky: right`
     outerStyle = {
       height: height,
       position: 'relative',
       overflow: 'hidden'
     };
-    innerStyle = _objectSpread2(_objectSpread2({}, innerStyle), {}, (_objectSpread2$1 = {
+    innerStyle = _objectSpread2(_objectSpread2({}, innerStyle), {}, _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({
       transform: "translateY(".concat(offsetY, "px)")
-    }, _defineProperty(_objectSpread2$1, rtl ? 'marginRight' : 'marginLeft', -offsetX), _defineProperty(_objectSpread2$1, "position", 'absolute'), _defineProperty(_objectSpread2$1, "left", 0), _defineProperty(_objectSpread2$1, "right", 0), _defineProperty(_objectSpread2$1, "top", 0), _objectSpread2$1));
+    }, rtl ? 'marginRight' : 'marginLeft', -offsetX), "position", 'absolute'), "left", 0), "right", 0), "top", 0));
   }
   return /*#__PURE__*/React$4.createElement("div", {
     style: outerStyle
@@ -6977,7 +7023,6 @@ function getPageXY(e, horizontal) {
   return obj[horizontal ? 'pageX' : 'pageY'];
 }
 var ScrollBar = /*#__PURE__*/React$4.forwardRef(function (props, ref) {
-  var _classNames;
   var prefixCls = props.prefixCls,
     rtl = props.rtl,
     scrollOffset = props.scrollOffset,
@@ -7003,9 +7048,11 @@ var ScrollBar = /*#__PURE__*/React$4.forwardRef(function (props, ref) {
     startTop = _React$useState6[0],
     setStartTop = _React$useState6[1];
   var isLTR = !rtl;
+
   // ========================= Refs =========================
   var scrollbarRef = React$4.useRef();
   var thumbRef = React$4.useRef();
+
   // ======================= Visible ========================
   var _React$useState7 = React$4.useState(false),
     _React$useState8 = _slicedToArray(_React$useState7, 2),
@@ -7019,11 +7066,11 @@ var ScrollBar = /*#__PURE__*/React$4.forwardRef(function (props, ref) {
       setVisible(false);
     }, 3000);
   };
+
   // ======================== Range =========================
   var enableScrollRange = scrollRange - containerSize || 0;
   var enableOffsetRange = containerSize - spinSize || 0;
-  // `scrollWidth` < `clientWidth` means no need to show scrollbar
-  var canScroll = enableScrollRange > 0;
+
   // ========================= Top ==========================
   var top = React$4.useMemo(function () {
     if (scrollOffset === 0 || enableScrollRange === 0) {
@@ -7032,11 +7079,13 @@ var ScrollBar = /*#__PURE__*/React$4.forwardRef(function (props, ref) {
     var ptg = scrollOffset / enableScrollRange;
     return ptg * enableOffsetRange;
   }, [scrollOffset, enableScrollRange, enableOffsetRange]);
+
   // ====================== Container =======================
   var onContainerMouseDown = function onContainerMouseDown(e) {
     e.stopPropagation();
     e.preventDefault();
   };
+
   // ======================== Thumb =========================
   var stateRef = React$4.useRef({
     top: top,
@@ -7058,7 +7107,9 @@ var ScrollBar = /*#__PURE__*/React$4.forwardRef(function (props, ref) {
     e.stopPropagation();
     e.preventDefault();
   };
+
   // ======================== Effect ========================
+
   // React make event as passive, but we need to preventDefault
   // Add event on dom directly instead.
   // ref: https://github.com/facebook/react/issues/9809
@@ -7075,6 +7126,7 @@ var ScrollBar = /*#__PURE__*/React$4.forwardRef(function (props, ref) {
       thumbEle.removeEventListener('touchstart', onThumbMouseDown);
     };
   }, []);
+
   // Pass to effect
   var enableScrollRangeRef = React$4.useRef();
   enableScrollRangeRef.current = enableScrollRange;
@@ -7128,17 +7180,19 @@ var ScrollBar = /*#__PURE__*/React$4.forwardRef(function (props, ref) {
   React$4.useEffect(function () {
     delayHidden();
   }, [scrollOffset]);
+
   // ====================== Imperative ======================
   React$4.useImperativeHandle(ref, function () {
     return {
       delayHidden: delayHidden
     };
   });
+
   // ======================== Render ========================
   var scrollbarPrefixCls = "".concat(prefixCls, "-scrollbar");
   var containerStyle = {
     position: 'absolute',
-    visibility: visible && canScroll ? null : 'hidden'
+    visibility: visible ? null : 'hidden'
   };
   var thumbStyle = {
     position: 'absolute',
@@ -7153,6 +7207,7 @@ var ScrollBar = /*#__PURE__*/React$4.forwardRef(function (props, ref) {
     containerStyle.left = 0;
     containerStyle.right = 0;
     containerStyle.bottom = 0;
+
     // Thumb
     thumbStyle.height = '100%';
     thumbStyle.width = spinSize;
@@ -7171,6 +7226,7 @@ var ScrollBar = /*#__PURE__*/React$4.forwardRef(function (props, ref) {
     } else {
       containerStyle.left = 0;
     }
+
     // Thumb
     thumbStyle.width = '100%';
     thumbStyle.height = spinSize;
@@ -7178,7 +7234,7 @@ var ScrollBar = /*#__PURE__*/React$4.forwardRef(function (props, ref) {
   }
   return /*#__PURE__*/React$4.createElement("div", {
     ref: scrollbarRef,
-    className: classNames(scrollbarPrefixCls, (_classNames = {}, _defineProperty(_classNames, "".concat(scrollbarPrefixCls, "-horizontal"), horizontal), _defineProperty(_classNames, "".concat(scrollbarPrefixCls, "-vertical"), !horizontal), _defineProperty(_classNames, "".concat(scrollbarPrefixCls, "-visible"), visible), _classNames)),
+    className: classNames(scrollbarPrefixCls, _defineProperty(_defineProperty(_defineProperty({}, "".concat(scrollbarPrefixCls, "-horizontal"), horizontal), "".concat(scrollbarPrefixCls, "-vertical"), !horizontal), "".concat(scrollbarPrefixCls, "-visible"), visible)),
     style: _objectSpread2(_objectSpread2({}, containerStyle), style),
     onMouseDown: onContainerMouseDown,
     onMouseMove: delayHidden
@@ -7227,10 +7283,10 @@ function useChildren(list, startIndex, endIndex, scrollWidth, setNodeRef, render
 var CacheMap = /*#__PURE__*/function () {
   function CacheMap() {
     _classCallCheck(this, CacheMap);
-    this.maps = void 0;
+    _defineProperty(this, "maps", void 0);
     // Used for cache key
     // `useMemo` no need to update if `id` not change
-    this.id = 0;
+    _defineProperty(this, "id", 0);
     this.maps = Object.create(null);
   }
   _createClass(CacheMap, [{
@@ -7272,6 +7328,7 @@ function useHeights(getKey, onItemAdd, onItemRemove) {
           }
         }
       });
+
       // Always trigger update mark to tell parent that should re-calculate heights when resized
       setUpdatedMark(function (c) {
         return c + 1;
@@ -7292,12 +7349,13 @@ function useHeights(getKey, onItemAdd, onItemRemove) {
     } else {
       instanceRef.current.delete(key);
     }
+
     // Instance changed
     if (!origin !== !instance) {
       if (instance) {
-        onItemAdd === null || onItemAdd === void 0 ? void 0 : onItemAdd(item);
+        onItemAdd === null || onItemAdd === void 0 || onItemAdd(item);
       } else {
-        onItemRemove === null || onItemRemove === void 0 ? void 0 : onItemRemove(item);
+        onItemRemove === null || onItemRemove === void 0 || onItemRemove(item);
       }
     }
   }
@@ -7314,6 +7372,7 @@ function useScrollTo(containerRef, data, heights, itemHeight, getKey, collectHei
     _React$useState2 = _slicedToArray(_React$useState, 2),
     syncState = _React$useState2[0],
     setSyncState = _React$useState2[1];
+
   // ========================== Sync Scroll ==========================
   useLayoutEffect$3(function () {
     if (syncState && syncState.times < MAX_TIMES) {
@@ -7333,9 +7392,11 @@ function useScrollTo(containerRef, data, heights, itemHeight, getKey, collectHei
       var needCollectHeight = false;
       var newTargetAlign = targetAlign;
       var targetTop = null;
+
       // Go to next frame if height not exist
       if (height) {
         var mergedAlign = targetAlign || originAlign;
+
         // Get top & bottom
         var stackTop = 0;
         var itemTop = 0;
@@ -7348,6 +7409,7 @@ function useScrollTo(containerRef, data, heights, itemHeight, getKey, collectHei
           itemBottom = itemTop + (cacheHeight === undefined ? itemHeight : cacheHeight);
           stackTop = itemBottom;
         }
+
         // Check if need sync height (visible range has item not record height)
         var leftHeight = mergedAlign === 'top' ? offset : height - offset;
         for (var _i = maxLen; _i >= 0; _i -= 1) {
@@ -7362,6 +7424,7 @@ function useScrollTo(containerRef, data, heights, itemHeight, getKey, collectHei
             break;
           }
         }
+
         // Scroll to
         switch (mergedAlign) {
           case 'top':
@@ -7384,11 +7447,13 @@ function useScrollTo(containerRef, data, heights, itemHeight, getKey, collectHei
         if (targetTop !== null) {
           syncScrollTop(targetTop);
         }
+
         // One more time for sync
         if (targetTop !== syncState.lastTop) {
           needCollectHeight = true;
         }
       }
+
       // Trigger next effect
       if (needCollectHeight) {
         setSyncState(_objectSpread2(_objectSpread2({}, syncState), {}, {
@@ -7401,6 +7466,7 @@ function useScrollTo(containerRef, data, heights, itemHeight, getKey, collectHei
       warningOnce(false, 'Seems `scrollTo` with `rc-virtual-list` reach the max limitation. Please fire issue for us. Thanks.');
     }
   }, [syncState, containerRef.current]);
+
   // =========================== Scroll To ===========================
   return function (arg) {
     // When not argument provided, we think dev may want to show the scrollbar
@@ -7408,6 +7474,7 @@ function useScrollTo(containerRef, data, heights, itemHeight, getKey, collectHei
       triggerFlash();
       return;
     }
+
     // Normal scroll logic
     wrapperRaf.cancel(scrollRef.current);
     if (typeof arg === 'number') {
@@ -7447,6 +7514,7 @@ function useScrollTo(containerRef, data, heights, itemHeight, getKey, collectHei
  * [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.
@@ -7475,6 +7543,7 @@ function findListDiffIndex(originList, targetList, getKey) {
     }
     return notExistKey;
   }
+
   // Loop to find diff one
   var diffIndex = null;
   var multiple = Math.abs(originLen - targetLen) !== 1;
@@ -7505,7 +7574,7 @@ function useDiffItem(data, getKey, onDiff) {
   React$4.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);
+      onDiff === null || onDiff === void 0 || onDiff(diff.index);
       setDiffItem(data[diff.index]);
     }
     setPrevData(data);
@@ -7526,6 +7595,7 @@ var useOriginScroll = (function (isScrollAtTop, isScrollAtBottom) {
       lockRef.current = false;
     }, 50);
   }
+
   // Pass to ref since global add is in closure
   var scrollPingRef = useRef({
     top: isScrollAtTop,
@@ -7558,17 +7628,21 @@ function useFrameWheel(inVirtual, isScrollAtTop, isScrollAtBottom, horizontalScr
 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 onWheelY(event, deltaY) {
     wrapperRaf.cancel(nextFrameRef.current);
     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();
@@ -7587,11 +7661,13 @@ onWheelDelta) {
       event.preventDefault();
     }
   }
+
   // Check for which direction does wheel do. `sx` means `shift + wheel`
   var wheelDirectionRef = useRef(null);
   var wheelDirectionCleanRef = useRef(null);
   function onWheel(event) {
     if (!inVirtual) return;
+
     // Wait for 2 frame to clean direction
     wrapperRaf.cancel(wheelDirectionCleanRef.current);
     wheelDirectionCleanRef.current = wrapperRaf(function () {
@@ -7618,6 +7694,7 @@ onWheelDelta) {
       onWheelX(event, mergedDeltaX);
     }
   }
+
   // A patch for firefox
   function onFireFoxScroll(event) {
     if (!inVirtual) return;
@@ -7631,23 +7708,26 @@ 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;
+      var _offsetY = touchYRef.current - currentY;
       touchYRef.current = currentY;
-      if (callback(offsetY)) {
+      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) {
+        _offsetY *= SMOOTH_PTG;
+        if (!callback(_offsetY, true) || Math.abs(_offsetY) <= 0.1) {
           clearInterval(intervalRef.current);
         }
       }, 16);
@@ -7679,7 +7759,7 @@ function useMobileTouchMove(inVirtual, listRef, callback) {
     }
     return function () {
       var _listRef$current;
-      (_listRef$current = listRef.current) === null || _listRef$current === void 0 ? void 0 : _listRef$current.removeEventListener('touchstart', onTouchStart);
+      (_listRef$current = listRef.current) === null || _listRef$current === void 0 || _listRef$current.removeEventListener('touchstart', onTouchStart);
       cleanUpEvents();
       clearInterval(intervalRef.current);
     };
@@ -7690,12 +7770,11 @@ var MIN_SIZE = 20;
 function getSpinSize() {
   var containerSize = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
   var scrollRange = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-  var baseSize = containerSize / scrollRange * 100;
+  var baseSize = containerSize / scrollRange * containerSize;
   if (isNaN(baseSize)) {
     baseSize = 0;
   }
   baseSize = Math.max(baseSize, MIN_SIZE);
-  baseSize = Math.min(baseSize, containerSize / 2);
   return Math.floor(baseSize);
 }
 
@@ -7715,6 +7794,7 @@ function useGetSize(mergedData, getKey, heights, itemHeight) {
     // Get from cache first
     var startIndex = key2Index.get(startKey);
     var endIndex = key2Index.get(endKey);
+
     // Loop to fill the cache
     if (startIndex === undefined || endIndex === undefined) {
       var dataLen = mergedData.length;
@@ -7774,6 +7854,7 @@ function RawList(props, ref) {
     extraRender = props.extraRender,
     styles = props.styles,
     restProps = _objectWithoutProperties(props, _excluded$2);
+
   // ================================= MISC =================================
   var useVirtual = !!(virtual !== false && height && itemHeight);
   var inVirtual = useVirtual && data && (itemHeight * data.length > height || !!scrollWidth);
@@ -7782,7 +7863,9 @@ function RawList(props, ref) {
   var mergedData = data || EMPTY_DATA;
   var componentRef = useRef();
   var fillerInnerRef = useRef();
+
   // =============================== Item Key ===============================
+
   var _useState = useState$1(0),
     _useState2 = _slicedToArray(_useState, 2),
     offsetTop = _useState2[0],
@@ -7801,6 +7884,7 @@ function RawList(props, ref) {
   var onScrollbarStopMove = function onScrollbarStopMove() {
     setScrollMoving(false);
   };
+
   // =============================== Item Key ===============================
   var getKey = React$4.useCallback(function (item) {
     if (typeof itemKey === 'function') {
@@ -7811,6 +7895,7 @@ function RawList(props, ref) {
   var sharedConfig = {
     getKey: getKey
   };
+
   // ================================ Scroll ================================
   function syncScrollTop(newTop) {
     setOffsetTop(function (origin) {
@@ -7825,6 +7910,7 @@ function RawList(props, ref) {
       return alignedTop;
     });
   }
+
   // ================================ Legacy ================================
   // Put ref here since the range is generate by follow
   var rangeRef = useRef({
@@ -7836,6 +7922,7 @@ function RawList(props, ref) {
     _useDiffItem2 = _slicedToArray(_useDiffItem, 1),
     diffItem = _useDiffItem2[0];
   diffItemRef.current = diffItem;
+
   // ================================ Height ================================
   var _useHeights = useHeights(getKey, null, null),
     _useHeights2 = _slicedToArray(_useHeights, 4),
@@ -7843,6 +7930,7 @@ function RawList(props, ref) {
     collectHeight = _useHeights2[1],
     heights = _useHeights2[2],
     heightUpdatedMark = _useHeights2[3];
+
   // ========================== Visible Calculation =========================
   var _React$useMemo = React$4.useMemo(function () {
       if (!useVirtual) {
@@ -7853,6 +7941,7 @@ function RawList(props, ref) {
           offset: undefined
         };
       }
+
       // Always use virtual scroll bar in avoid shaking
       if (!inVirtual) {
         var _fillerInnerRef$curre;
@@ -7869,21 +7958,24 @@ function RawList(props, ref) {
       var endIndex;
       var dataLen = mergedData.length;
       for (var i = 0; i < dataLen; i += 1) {
-        var item = mergedData[i];
-        var key = getKey(item);
+        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
         if (currentItemBottom >= offsetTop && startIndex === undefined) {
           startIndex = i;
           startOffset = itemTop;
         }
+
         // Check item bottom in the range. We will render additional one item for motion usage
         if (currentItemBottom > offsetTop + height && endIndex === undefined) {
           endIndex = i;
         }
         itemTop = currentItemBottom;
       }
+
       // When scrollTop at the end but data cut to small count will reach this
       if (startIndex === undefined) {
         startIndex = 0;
@@ -7893,6 +7985,7 @@ function RawList(props, ref) {
       if (endIndex === undefined) {
         endIndex = mergedData.length - 1;
       }
+
       // Give cache to improve scroll experience
       endIndex = Math.min(endIndex + 1, mergedData.length - 1);
       return {
@@ -7908,6 +8001,7 @@ function RawList(props, ref) {
     fillerOffset = _React$useMemo.offset;
   rangeRef.current.start = start;
   rangeRef.current.end = end;
+
   // ================================= Size =================================
   var _React$useState = React$4.useState({
       width: 0,
@@ -7922,6 +8016,7 @@ function RawList(props, ref) {
       height: sizeInfo.height || sizeInfo.offsetHeight
     });
   };
+
   // Hack on scrollbar to enable flash call
   var verticalScrollBarRef = useRef();
   var horizontalScrollBarRef = useRef();
@@ -7931,6 +8026,7 @@ function RawList(props, ref) {
   var verticalScrollBarSpinSize = React$4.useMemo(function () {
     return getSpinSize(size.height, scrollHeight);
   }, [size.height, scrollHeight]);
+
   // =============================== In Range ===============================
   var maxScrollHeight = scrollHeight - height;
   var maxScrollHeightRef = useRef(maxScrollHeight);
@@ -7946,6 +8042,7 @@ function RawList(props, ref) {
   var isScrollAtTop = offsetTop <= 0;
   var isScrollAtBottom = offsetTop >= maxScrollHeight;
   var originScroll = useOriginScroll(isScrollAtTop, isScrollAtBottom);
+
   // ================================ Scroll ================================
   var getVirtualScrollInfo = function getVirtualScrollInfo() {
     return {
@@ -7957,6 +8054,7 @@ function RawList(props, ref) {
   var triggerScroll = useEvent$2(function () {
     if (onVirtualScroll) {
       var nextInfo = getVirtualScrollInfo();
+
       // Trigger when offset changed
       if (lastVirtualScrollInfoRef.current.x !== nextInfo.x || lastVirtualScrollInfoRef.current.y !== nextInfo.y) {
         onVirtualScroll(nextInfo);
@@ -7975,14 +8073,16 @@ function RawList(props, ref) {
       syncScrollTop(newOffset);
     }
   }
+
   // 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 !== offsetTop) {
       syncScrollTop(newScrollTop);
     }
+
     // Trigger origin onScroll
-    onScroll === null || onScroll === void 0 ? void 0 : onScroll(e);
+    onScroll === null || onScroll === void 0 || onScroll(e);
     triggerScroll();
   }
   var keepInHorizontalRange = function keepInHorizontalRange(nextOffsetLeft) {
@@ -7995,6 +8095,7 @@ function RawList(props, ref) {
   var onWheelDelta = useEvent$2(function (offsetXY, fromHorizontal) {
     if (fromHorizontal) {
       // Horizontal scroll no need sync virtual position
+
       flushSync(function () {
         setOffsetLeft(function (left) {
           var nextOffsetLeft = left + (isRTL ? -offsetXY : offsetXY);
@@ -8009,11 +8110,13 @@ function RawList(props, ref) {
       });
     }
   });
+
   // Since this added in global,should use ref to keep update
   var _useFrameWheel = useFrameWheel(useVirtual, isScrollAtTop, isScrollAtBottom, !!scrollWidth, onWheelDelta),
     _useFrameWheel2 = _slicedToArray(_useFrameWheel, 2),
     onRawWheel = _useFrameWheel2[0],
     onFireFoxScroll = _useFrameWheel2[1];
+
   // Mobile touch move
   useMobileTouchMove(useVirtual, componentRef, function (deltaY, smoothOffset) {
     if (originScroll(deltaY, smoothOffset)) {
@@ -8042,6 +8145,7 @@ function RawList(props, ref) {
       componentEle.removeEventListener('MozMousePixelScroll', onMozMousePixelScroll);
     };
   }, [useVirtual]);
+
   // Sync scroll left
   useLayoutEffect$3(function () {
     if (scrollWidth) {
@@ -8050,11 +8154,12 @@ function RawList(props, ref) {
       });
     }
   }, [size.width, scrollWidth]);
+
   // ================================= Ref ==================================
   var delayHideScrollBar = function delayHideScrollBar() {
     var _verticalScrollBarRef, _horizontalScrollBarR;
-    (_verticalScrollBarRef = verticalScrollBarRef.current) === null || _verticalScrollBarRef === void 0 ? void 0 : _verticalScrollBarRef.delayHidden();
-    (_horizontalScrollBarR = horizontalScrollBarRef.current) === null || _horizontalScrollBarR === void 0 ? void 0 : _horizontalScrollBarR.delayHidden();
+    (_verticalScrollBarRef = verticalScrollBarRef.current) === null || _verticalScrollBarRef === void 0 || _verticalScrollBarRef.delayHidden();
+    (_horizontalScrollBarR = horizontalScrollBarRef.current) === null || _horizontalScrollBarR === void 0 || _horizontalScrollBarR.delayHidden();
   };
   var _scrollTo = useScrollTo(componentRef, mergedData, heights, itemHeight, getKey, function () {
     return collectHeight(true);
@@ -8071,6 +8176,7 @@ function RawList(props, ref) {
           if (config.left !== undefined) {
             setOffsetLeft(keepInHorizontalRange(config.left));
           }
+
           // Scroll Y
           _scrollTo(config.top);
         } else {
@@ -8079,6 +8185,7 @@ function RawList(props, ref) {
       }
     };
   });
+
   // ================================ Effect ================================
   /** We need told outside that some list not rendered */
   useLayoutEffect$3(function () {
@@ -8087,6 +8194,7 @@ function RawList(props, ref) {
       onVisibleChange(renderList, mergedData);
     }
   }, [start, end, mergedData]);
+
   // ================================ Extra =================================
   var getSize = useGetSize(mergedData, getKey, heights, itemHeight);
   var extraContent = extraRender === null || extraRender === void 0 ? void 0 : extraRender({
@@ -8098,6 +8206,7 @@ function RawList(props, ref) {
     rtl: isRTL,
     getSize: getSize
   });
+
   // ================================ Render ================================
   var listChildren = useChildren(mergedData, start, end, scrollWidth, setInstanceRef, children, sharedConfig);
   var componentStyle = null;
@@ -8154,7 +8263,7 @@ function RawList(props, ref) {
     containerSize: size.height,
     style: styles === null || styles === void 0 ? void 0 : styles.verticalScrollBar,
     thumbStyle: styles === null || styles === void 0 ? void 0 : styles.verticalScrollBarThumb
-  }), inVirtual && scrollWidth && /*#__PURE__*/React$4.createElement(ScrollBar, {
+  }), inVirtual && scrollWidth > size.width && /*#__PURE__*/React$4.createElement(ScrollBar, {
     ref: horizontalScrollBarRef,
     prefixCls: prefixCls,
     scrollOffset: offsetLeft,
@@ -9300,7 +9409,7 @@ var interopRequireWildcard = {exports: {}};
 	      __proto__: null
 	    },
 	    a = Object.defineProperty && Object.getOwnPropertyDescriptor;
-	  for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) {
+	  for (var u in e) if ("default" !== u && {}.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];
 	  }