acud 0.0.60

package/es/virtual-list/ScrollBar.js

@@ -0,0 +1,257 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
+import * as React from 'react';
+import classNames from 'classnames';
+import raf from "rc-util/es/raf";
+var MIN_SIZE = 20;
+
+function getPageY(e) {
+  return 'touches' in e ? e.touches[0].pageY : e.pageY;
+}
+
+var ScrollBar = /*#__PURE__*/function (_React$Component) {
+  _inherits(ScrollBar, _React$Component);
+
+  var _super = _createSuper(ScrollBar);
+
+  function ScrollBar() {
+    var _this;
+
+    _classCallCheck(this, ScrollBar);
+
+    _this = _super.apply(this, arguments);
+    _this.moveRaf = null;
+    _this.scrollbarRef = /*#__PURE__*/React.createRef();
+    _this.thumbRef = /*#__PURE__*/React.createRef();
+    _this.visibleTimeout = null;
+    _this.state = {
+      dragging: false,
+      pageY: null,
+      startTop: null,
+      visible: false
+    };
+
+    _this.delayHidden = function () {
+      clearTimeout(_this.visibleTimeout);
+
+      _this.setState({
+        visible: true
+      });
+
+      _this.visibleTimeout = setTimeout(function () {
+        _this.setState({
+          visible: false
+        });
+      }, 2000);
+    };
+
+    _this.onScrollbarTouchStart = function (e) {
+      e.preventDefault();
+    };
+
+    _this.onContainerMouseDown = function (e) {
+      e.stopPropagation();
+      e.preventDefault();
+    }; // ======================= Clean =======================
+
+
+    _this.patchEvents = function () {
+      window.addEventListener('mousemove', _this.onMouseMove);
+      window.addEventListener('mouseup', _this.onMouseUp);
+
+      _this.thumbRef.current.addEventListener('touchmove', _this.onMouseMove);
+
+      _this.thumbRef.current.addEventListener('touchend', _this.onMouseUp);
+    };
+
+    _this.removeEvents = function () {
+      window.removeEventListener('mousemove', _this.onMouseMove);
+      window.removeEventListener('mouseup', _this.onMouseUp);
+
+      _this.scrollbarRef.current.removeEventListener('touchstart', _this.onScrollbarTouchStart);
+
+      _this.thumbRef.current.removeEventListener('touchstart', _this.onMouseDown);
+
+      _this.thumbRef.current.removeEventListener('touchmove', _this.onMouseMove);
+
+      _this.thumbRef.current.removeEventListener('touchend', _this.onMouseUp);
+
+      raf.cancel(_this.moveRaf);
+    }; // ======================= Thumb =======================
+
+
+    _this.onMouseDown = function (e) {
+      var onStartMove = _this.props.onStartMove;
+
+      _this.setState({
+        dragging: true,
+        pageY: getPageY(e),
+        startTop: _this.getTop()
+      });
+
+      onStartMove();
+
+      _this.patchEvents();
+
+      e.stopPropagation();
+      e.preventDefault();
+    };
+
+    _this.onMouseMove = function (e) {
+      var _this$state = _this.state,
+          dragging = _this$state.dragging,
+          pageY = _this$state.pageY,
+          startTop = _this$state.startTop;
+      var onScroll = _this.props.onScroll;
+      raf.cancel(_this.moveRaf);
+
+      if (dragging) {
+        var offsetY = getPageY(e) - pageY;
+        var newTop = startTop + offsetY;
+
+        var enableScrollRange = _this.getEnableScrollRange();
+
+        var enableHeightRange = _this.getEnableHeightRange();
+
+        var ptg = enableHeightRange ? newTop / enableHeightRange : 0;
+        var newScrollTop = Math.ceil(ptg * enableScrollRange);
+        _this.moveRaf = raf(function () {
+          onScroll(newScrollTop);
+        });
+      }
+    };
+
+    _this.onMouseUp = function () {
+      var onStopMove = _this.props.onStopMove;
+
+      _this.setState({
+        dragging: false
+      });
+
+      onStopMove();
+
+      _this.removeEvents();
+    }; // ===================== Calculate =====================
+
+
+    _this.getSpinHeight = function () {
+      var _this$props = _this.props,
+          height = _this$props.height,
+          count = _this$props.count;
+      var baseHeight = height / count * 10;
+      baseHeight = Math.max(baseHeight, MIN_SIZE);
+      baseHeight = Math.min(baseHeight, height / 2);
+      return Math.floor(baseHeight);
+    };
+
+    _this.getEnableScrollRange = function () {
+      var _this$props2 = _this.props,
+          scrollHeight = _this$props2.scrollHeight,
+          height = _this$props2.height;
+      return scrollHeight - height || 0;
+    };
+
+    _this.getEnableHeightRange = function () {
+      var height = _this.props.height;
+
+      var spinHeight = _this.getSpinHeight();
+
+      return height - spinHeight || 0;
+    };
+
+    _this.getTop = function () {
+      var scrollTop = _this.props.scrollTop;
+
+      var enableScrollRange = _this.getEnableScrollRange();
+
+      var enableHeightRange = _this.getEnableHeightRange();
+
+      if (scrollTop === 0 || enableScrollRange === 0) {
+        return 0;
+      }
+
+      var ptg = scrollTop / enableScrollRange;
+      return ptg * enableHeightRange;
+    }; // Not show scrollbar when height is large than scrollHeight
+
+
+    _this.showScroll = function () {
+      var _this$props3 = _this.props,
+          height = _this$props3.height,
+          scrollHeight = _this$props3.scrollHeight;
+      return scrollHeight > height;
+    };
+
+    return _this;
+  }
+
+  _createClass(ScrollBar, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this.scrollbarRef.current.addEventListener('touchstart', this.onScrollbarTouchStart);
+      this.thumbRef.current.addEventListener('touchstart', this.onMouseDown);
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps) {
+      if (prevProps.scrollTop !== this.props.scrollTop) {
+        this.delayHidden();
+      }
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      this.removeEvents();
+      clearTimeout(this.visibleTimeout);
+    } // ====================== Render =======================
+
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$state2 = this.state,
+          dragging = _this$state2.dragging,
+          visible = _this$state2.visible;
+      var prefixCls = this.props.prefixCls;
+      var spinHeight = this.getSpinHeight();
+      var top = this.getTop();
+      var canScroll = this.showScroll();
+      var mergedVisible = canScroll && visible;
+      return /*#__PURE__*/React.createElement("div", {
+        ref: this.scrollbarRef,
+        className: classNames("".concat(prefixCls, "-scrollbar"), _defineProperty({}, "".concat(prefixCls, "-scrollbar-show"), canScroll)),
+        style: {
+          width: 6,
+          top: 0,
+          bottom: 0,
+          right: 0,
+          position: 'absolute',
+          display: mergedVisible ? null : 'none'
+        },
+        onMouseDown: this.onContainerMouseDown,
+        onMouseMove: this.delayHidden
+      }, /*#__PURE__*/React.createElement("div", {
+        ref: this.thumbRef,
+        className: classNames("".concat(prefixCls, "-scrollbar-thumb"), _defineProperty({}, "".concat(prefixCls, "-scrollbar-thumb-moving"), dragging)),
+        style: {
+          width: '100%',
+          height: spinHeight,
+          top: top,
+          left: 0,
+          position: 'absolute',
+          background: '#D4D6D9',
+          borderRadius: 99,
+          cursor: 'pointer',
+          userSelect: 'none'
+        },
+        onMouseDown: this.onMouseDown
+      }));
+    }
+  }]);
+
+  return ScrollBar;
+}(React.Component);
+
+export { ScrollBar as default };

package/es/virtual-list/hooks/useChildren.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import type { SharedConfig, RenderFunc } from '../interface';
+export default function useChildren<T>(list: T[], startIndex: number, endIndex: number, setNodeRef: (item: T, element: HTMLElement) => void, renderFunc: RenderFunc<T>, { getKey }: SharedConfig<T>): JSX.Element[];

package/es/virtual-list/hooks/useChildren.js

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import { Item } from '../Item';
+export default function useChildren(list, startIndex, endIndex, setNodeRef, renderFunc, _ref) {
+  var getKey = _ref.getKey;
+  return list.slice(startIndex, endIndex + 1).map(function (item, index) {
+    var eleIndex = startIndex + index;
+    var node = renderFunc(item, eleIndex, {// style: status === 'MEASURE_START' ? { visibility: 'hidden' } : {},
+    });
+    var key = getKey(item);
+    return /*#__PURE__*/React.createElement(Item, {
+      key: key,
+      setRef: function setRef(ele) {
+        return setNodeRef(item, ele);
+      }
+    }, node);
+  });
+}

package/es/virtual-list/hooks/useDiffItem.d.ts

@@ -0,0 +1,2 @@
+import type { GetKey } from '../interface';
+export default function useDiffItem<T>(data: T[], getKey: GetKey<T>, onDiff?: (diffIndex: number) => void): [T];

package/es/virtual-list/hooks/useDiffItem.js

@@ -0,0 +1,26 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import * as React from 'react';
+import { findListDiffIndex } from '../utils/algorithmUtil';
+export default function useDiffItem(data, getKey, onDiff) {
+  var _React$useState = React.useState(data),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      prevData = _React$useState2[0],
+      setPrevData = _React$useState2[1];
+
+  var _React$useState3 = React.useState(null),
+      _React$useState4 = _slicedToArray(_React$useState3, 2),
+      diffItem = _React$useState4[0],
+      setDiffItem = _React$useState4[1];
+
+  React.useEffect(function () {
+    var diff = findListDiffIndex(prevData || [], data || [], getKey);
+
+    if ((diff === null || diff === void 0 ? void 0 : diff.index) !== undefined) {
+      onDiff === null || onDiff === void 0 ? void 0 : onDiff(diff.index);
+      setDiffItem(data[diff.index]);
+    }
+
+    setPrevData(data);
+  }, [data]);
+  return [diffItem];
+}

package/es/virtual-list/hooks/useFrameWheel.d.ts

@@ -0,0 +1,6 @@
+interface FireFoxDOMMouseScrollEvent {
+    detail: number;
+    preventDefault: Function;
+}
+export default function useFrameWheel(inVirtual: boolean, isScrollAtTop: boolean, isScrollAtBottom: boolean, onWheelDelta: (offset: number) => void): [(e: WheelEvent) => void, (e: FireFoxDOMMouseScrollEvent) => void];
+export {};

package/es/virtual-list/hooks/useFrameWheel.js

@@ -0,0 +1,43 @@
+import { useRef } from 'react';
+import raf from "rc-util/es/raf";
+import isFF from '../utils/isFirefox';
+import useOriginScroll from './useOriginScroll';
+export default function useFrameWheel(inVirtual, isScrollAtTop, isScrollAtBottom, onWheelDelta) {
+  var offsetRef = useRef(0);
+  var nextFrameRef = useRef(null); // Firefox patch
+
+  var wheelValueRef = useRef(null);
+  var isMouseScrollRef = useRef(false); // Scroll status sync
+
+  var originScroll = useOriginScroll(isScrollAtTop, isScrollAtBottom);
+
+  function onWheel(event) {
+    if (!inVirtual) return;
+    raf.cancel(nextFrameRef.current);
+    var deltaY = event.deltaY;
+    offsetRef.current += deltaY;
+    wheelValueRef.current = deltaY; // Do nothing when scroll at the edge, Skip check when is in scroll
+
+    if (originScroll(deltaY)) return; // Proxy of scroll events
+
+    if (!isFF) {
+      event.preventDefault();
+    }
+
+    nextFrameRef.current = raf(function () {
+      // Patch a multiple for Firefox to fix wheel number too small
+      // ref: https://github.com/ant-design/ant-design/issues/26372#issuecomment-679460266
+      var patchMultiple = isMouseScrollRef.current ? 10 : 1;
+      onWheelDelta(offsetRef.current * patchMultiple);
+      offsetRef.current = 0;
+    });
+  } // A patch for firefox
+
+
+  function onFireFoxScroll(event) {
+    if (!inVirtual) return;
+    isMouseScrollRef.current = event.detail === wheelValueRef.current;
+  }
+
+  return [onWheel, onFireFoxScroll];
+}

package/es/virtual-list/hooks/useHeights.d.ts

@@ -0,0 +1,3 @@
+import type { GetKey } from '../interface';
+import CacheMap from '../utils/CacheMap';
+export default function useHeights<T>(getKey: GetKey<T>, onItemAdd?: (item: T) => void, onItemRemove?: (item: T) => void): [(item: T, instance: HTMLElement) => void, () => void, CacheMap, number];

package/es/virtual-list/hooks/useHeights.js

@@ -0,0 +1,61 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import * as React from 'react';
+import { useRef } from 'react';
+import findDOMNode from "rc-util/es/Dom/findDOMNode";
+import CacheMap from '../utils/CacheMap';
+export default 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 heightUpdateIdRef = useRef(0);
+
+  function collectHeight() {
+    heightUpdateIdRef.current += 1;
+    var currentId = heightUpdateIdRef.current;
+    Promise.resolve().then(function () {
+      // Only collect when it's latest call
+      if (currentId !== heightUpdateIdRef.current) return;
+      instanceRef.current.forEach(function (element, key) {
+        if (element && element.offsetParent) {
+          var htmlElement = findDOMNode(element);
+          var offsetHeight = htmlElement.offsetHeight;
+
+          if (heightsRef.current.get(key) !== offsetHeight) {
+            heightsRef.current.set(key, htmlElement.offsetHeight);
+          }
+        }
+      }); // 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);
+      }
+    }
+  }
+
+  return [setInstanceRef, collectHeight, heightsRef.current, updatedMark];
+}

package/es/virtual-list/hooks/useMobileTouchMove.d.ts

@@ -0,0 +1,2 @@
+import * as React from 'react';
+export default function useMobileTouchMove(inVirtual: boolean, listRef: React.RefObject<HTMLDivElement>, callback: (offsetY: number, smoothOffset?: boolean) => boolean): void;

package/es/virtual-list/hooks/useMobileTouchMove.js

@@ -0,0 +1,71 @@
+import { useRef } from 'react';
+import useLayoutEffect from "rc-util/es/hooks/useLayoutEffect";
+var SMOOTH_PTG = 14 / 15;
+export default 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 () {
+      listRef.current.removeEventListener('touchstart', onTouchStart);
+      cleanUpEvents();
+      clearInterval(intervalRef.current);
+    };
+  }, [inVirtual]);
+}

package/es/virtual-list/hooks/useOriginScroll.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (isScrollAtTop: boolean, isScrollAtBottom: boolean) => (deltaY: number, smoothOffset?: boolean) => boolean;
+export default _default;

package/es/virtual-list/hooks/useOriginScroll.js

@@ -0,0 +1,38 @@
+import { useRef } from 'react';
+export default (function (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;
+  };
+});

package/es/virtual-list/hooks/useScrollTo.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+import type { ScrollTo } from '../List';
+import type { GetKey } from '../interface';
+import type CacheMap from '../utils/CacheMap';
+export default function useScrollTo<T>(containerRef: React.RefObject<HTMLDivElement>, data: T[], heights: CacheMap, itemHeight: number, getKey: GetKey<T>, collectHeight: () => void, syncScrollTop: (newTop: number) => void, triggerFlash: () => void): ScrollTo;

package/es/virtual-list/hooks/useScrollTo.js

@@ -0,0 +1,104 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+
+/* eslint-disable no-param-reassign */
+import * as React from 'react';
+import raf from "rc-util/es/raf";
+export default 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
+
+
+    raf.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 = raf(function () {
+          if (needCollectHeight) {
+            collectHeight();
+          }
+
+          syncScroll(times - 1, newTargetAlign);
+        });
+      };
+
+      syncScroll(3);
+    }
+  };
+}

package/es/virtual-list/index.d.ts

@@ -0,0 +1,3 @@
+import List, { ListRef, ListProps } from './List';
+export { ListRef, ListProps };
+export default List;

package/es/virtual-list/index.js

@@ -0,0 +1,2 @@
+import List from './List';
+export default List;

package/es/virtual-list/interface.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+export declare type RenderFunc<T> = (item: T, index: number, props: {
+    style?: React.CSSProperties;
+}) => React.ReactNode;
+export interface SharedConfig<T> {
+    getKey: (item: T) => React.Key;
+}
+export declare type GetKey<T> = (item: T) => React.Key;

package/es/virtual-list/interface.js

@@ -0,0 +1 @@
+export {};