You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1178 lines
40 KiB
1178 lines
40 KiB
"use strict";
|
|
(self["webpackChunk"] = self["webpackChunk"] || []).push([[73358],{
|
|
|
|
/***/ 73358:
|
|
/*!*********************************************************************************!*\
|
|
!*** ./node_modules/antd/node_modules/rc-virtual-list/es/index.js + 18 modules ***!
|
|
\*********************************************************************************/
|
|
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
|
|
|
|
|
|
// EXPORTS
|
|
__webpack_require__.d(__webpack_exports__, {
|
|
"Z": function() { return /* binding */ rc_virtual_list_es; }
|
|
});
|
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js
|
|
var esm_extends = __webpack_require__(87462);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectSpread2.js
|
|
var objectSpread2 = __webpack_require__(1413);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js
|
|
var defineProperty = __webpack_require__(4942);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 1 modules
|
|
var slicedToArray = __webpack_require__(97685);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js
|
|
var objectWithoutProperties = __webpack_require__(45987);
|
|
// EXTERNAL MODULE: ./node_modules/react/index.js
|
|
var react = __webpack_require__(67294);
|
|
// EXTERNAL MODULE: ./node_modules/classnames/index.js
|
|
var classnames = __webpack_require__(94184);
|
|
var classnames_default = /*#__PURE__*/__webpack_require__.n(classnames);
|
|
// EXTERNAL MODULE: ./node_modules/rc-resize-observer/es/index.js + 4 modules
|
|
var es = __webpack_require__(48555);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-virtual-list/es/Filler.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Fill component to provided the scroll content real height.
|
|
*/
|
|
var Filler = /*#__PURE__*/react.forwardRef(function (_ref, ref) {
|
|
var height = _ref.height,
|
|
offset = _ref.offset,
|
|
children = _ref.children,
|
|
prefixCls = _ref.prefixCls,
|
|
onInnerResize = _ref.onInnerResize,
|
|
innerProps = _ref.innerProps;
|
|
var outerStyle = {};
|
|
var innerStyle = {
|
|
display: 'flex',
|
|
flexDirection: 'column'
|
|
};
|
|
if (offset !== undefined) {
|
|
outerStyle = {
|
|
height: height,
|
|
position: 'relative',
|
|
overflow: 'hidden'
|
|
};
|
|
innerStyle = (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, innerStyle), {}, {
|
|
transform: "translateY(".concat(offset, "px)"),
|
|
position: 'absolute',
|
|
left: 0,
|
|
right: 0,
|
|
top: 0
|
|
});
|
|
}
|
|
return /*#__PURE__*/react.createElement("div", {
|
|
style: outerStyle
|
|
}, /*#__PURE__*/react.createElement(es/* default */.Z, {
|
|
onResize: function onResize(_ref2) {
|
|
var offsetHeight = _ref2.offsetHeight;
|
|
if (offsetHeight && onInnerResize) {
|
|
onInnerResize();
|
|
}
|
|
}
|
|
}, /*#__PURE__*/react.createElement("div", (0,esm_extends/* default */.Z)({
|
|
style: innerStyle,
|
|
className: classnames_default()((0,defineProperty/* default */.Z)({}, "".concat(prefixCls, "-holder-inner"), prefixCls)),
|
|
ref: ref
|
|
}, innerProps), children)));
|
|
});
|
|
Filler.displayName = 'Filler';
|
|
/* harmony default export */ var es_Filler = (Filler);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/classCallCheck.js
|
|
var classCallCheck = __webpack_require__(15671);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/createClass.js
|
|
var createClass = __webpack_require__(43144);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/inherits.js
|
|
var inherits = __webpack_require__(60136);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/createSuper.js + 1 modules
|
|
var createSuper = __webpack_require__(51630);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-virtual-list/node_modules/rc-util/es/raf.js
|
|
var raf = function raf(callback) {
|
|
return +setTimeout(callback, 16);
|
|
};
|
|
var caf = function caf(num) {
|
|
return clearTimeout(num);
|
|
};
|
|
if (typeof window !== 'undefined' && 'requestAnimationFrame' in window) {
|
|
raf = function raf(callback) {
|
|
return window.requestAnimationFrame(callback);
|
|
};
|
|
caf = function caf(handle) {
|
|
return window.cancelAnimationFrame(handle);
|
|
};
|
|
}
|
|
var rafUUID = 0;
|
|
var rafIds = new Map();
|
|
function cleanup(id) {
|
|
rafIds.delete(id);
|
|
}
|
|
var wrapperRaf = function wrapperRaf(callback) {
|
|
var times = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
|
|
rafUUID += 1;
|
|
var id = rafUUID;
|
|
function callRef(leftTimes) {
|
|
if (leftTimes === 0) {
|
|
// Clean up
|
|
cleanup(id);
|
|
|
|
// Trigger
|
|
callback();
|
|
} else {
|
|
// Next raf
|
|
var realId = raf(function () {
|
|
callRef(leftTimes - 1);
|
|
});
|
|
|
|
// Bind real raf id
|
|
rafIds.set(id, realId);
|
|
}
|
|
}
|
|
callRef(times);
|
|
return id;
|
|
};
|
|
wrapperRaf.cancel = function (id) {
|
|
var realId = rafIds.get(id);
|
|
cleanup(realId);
|
|
return caf(realId);
|
|
};
|
|
/* harmony default export */ var es_raf = (wrapperRaf);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-virtual-list/es/ScrollBar.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var MIN_SIZE = 20;
|
|
function getPageY(e) {
|
|
return 'touches' in e ? e.touches[0].pageY : e.pageY;
|
|
}
|
|
var ScrollBar = /*#__PURE__*/function (_React$Component) {
|
|
(0,inherits/* default */.Z)(ScrollBar, _React$Component);
|
|
var _super = (0,createSuper/* default */.Z)(ScrollBar);
|
|
function ScrollBar() {
|
|
var _this;
|
|
(0,classCallCheck/* default */.Z)(this, ScrollBar);
|
|
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
_this = _super.call.apply(_super, [this].concat(args));
|
|
_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);
|
|
if (_this.thumbRef.current) {
|
|
_this.thumbRef.current.removeEventListener('touchmove', _this.onMouseMove);
|
|
_this.thumbRef.current.removeEventListener('touchend', _this.onMouseUp);
|
|
}
|
|
es_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;
|
|
es_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 = es_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;
|
|
}
|
|
(0,createClass/* default */.Z)(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() {
|
|
var _this$scrollbarRef$cu, _this$thumbRef$curren;
|
|
this.removeEvents();
|
|
(_this$scrollbarRef$cu = this.scrollbarRef.current) === null || _this$scrollbarRef$cu === void 0 ? void 0 : _this$scrollbarRef$cu.removeEventListener('touchstart', this.onScrollbarTouchStart);
|
|
(_this$thumbRef$curren = this.thumbRef.current) === null || _this$thumbRef$curren === void 0 ? void 0 : _this$thumbRef$curren.removeEventListener('touchstart', this.onMouseDown);
|
|
clearTimeout(this.visibleTimeout);
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value:
|
|
// ====================== Render =======================
|
|
function render() {
|
|
var _this$state2 = this.state,
|
|
dragging = _this$state2.dragging,
|
|
visible = _this$state2.visible;
|
|
var _this$props4 = this.props,
|
|
prefixCls = _this$props4.prefixCls,
|
|
direction = _this$props4.direction;
|
|
var spinHeight = this.getSpinHeight();
|
|
var top = this.getTop();
|
|
var canScroll = this.showScroll();
|
|
var mergedVisible = canScroll && visible;
|
|
var scrollBarDirection = direction === 'rtl' ? {
|
|
left: 0
|
|
} : {
|
|
right: 0
|
|
};
|
|
return /*#__PURE__*/react.createElement("div", {
|
|
ref: this.scrollbarRef,
|
|
className: classnames_default()("".concat(prefixCls, "-scrollbar"), (0,defineProperty/* default */.Z)({}, "".concat(prefixCls, "-scrollbar-show"), canScroll)),
|
|
style: (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({
|
|
width: 8,
|
|
top: 0,
|
|
bottom: 0
|
|
}, scrollBarDirection), {}, {
|
|
position: 'absolute',
|
|
display: mergedVisible ? null : 'none'
|
|
}),
|
|
onMouseDown: this.onContainerMouseDown,
|
|
onMouseMove: this.delayHidden
|
|
}, /*#__PURE__*/react.createElement("div", {
|
|
ref: this.thumbRef,
|
|
className: classnames_default()("".concat(prefixCls, "-scrollbar-thumb"), (0,defineProperty/* default */.Z)({}, "".concat(prefixCls, "-scrollbar-thumb-moving"), dragging)),
|
|
style: {
|
|
width: '100%',
|
|
height: spinHeight,
|
|
top: top,
|
|
left: 0,
|
|
position: 'absolute',
|
|
background: 'rgba(0, 0, 0, 0.5)',
|
|
borderRadius: 99,
|
|
cursor: 'pointer',
|
|
userSelect: 'none'
|
|
},
|
|
onMouseDown: this.onMouseDown
|
|
}));
|
|
}
|
|
}]);
|
|
return ScrollBar;
|
|
}(react.Component);
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-virtual-list/es/Item.js
|
|
|
|
function Item(_ref) {
|
|
var children = _ref.children,
|
|
setRef = _ref.setRef;
|
|
var refFunc = react.useCallback(function (node) {
|
|
setRef(node);
|
|
}, []);
|
|
return /*#__PURE__*/react.cloneElement(children, {
|
|
ref: refFunc
|
|
});
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-virtual-list/es/hooks/useChildren.js
|
|
|
|
|
|
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);
|
|
});
|
|
}
|
|
// EXTERNAL MODULE: ./node_modules/react-dom/index.js
|
|
var react_dom = __webpack_require__(73935);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-virtual-list/node_modules/rc-util/es/Dom/findDOMNode.js
|
|
|
|
|
|
function isDOM(node) {
|
|
// https://developer.mozilla.org/en-US/docs/Web/API/Element
|
|
// Since XULElement is also subclass of Element, we only need HTMLElement and SVGElement
|
|
return node instanceof HTMLElement || node instanceof SVGElement;
|
|
}
|
|
|
|
/**
|
|
* Return if a node is a DOM node. Else will return by `findDOMNode`
|
|
*/
|
|
function findDOMNode(node) {
|
|
if (isDOM(node)) {
|
|
return node;
|
|
}
|
|
if (node instanceof react.Component) {
|
|
return react_dom.findDOMNode(node);
|
|
}
|
|
return null;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-virtual-list/es/utils/CacheMap.js
|
|
|
|
|
|
// Firefox has low performance of map.
|
|
var CacheMap = /*#__PURE__*/function () {
|
|
function CacheMap() {
|
|
(0,classCallCheck/* default */.Z)(this, CacheMap);
|
|
this.maps = void 0;
|
|
this.maps = Object.create(null);
|
|
}
|
|
(0,createClass/* default */.Z)(CacheMap, [{
|
|
key: "set",
|
|
value: function set(key, value) {
|
|
this.maps[key] = value;
|
|
}
|
|
}, {
|
|
key: "get",
|
|
value: function get(key) {
|
|
return this.maps[key];
|
|
}
|
|
}]);
|
|
return CacheMap;
|
|
}();
|
|
/* harmony default export */ var utils_CacheMap = (CacheMap);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-virtual-list/es/hooks/useHeights.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function useHeights(getKey, onItemAdd, onItemRemove) {
|
|
var _React$useState = react.useState(0),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
updatedMark = _React$useState2[0],
|
|
setUpdatedMark = _React$useState2[1];
|
|
var instanceRef = (0,react.useRef)(new Map());
|
|
var heightsRef = (0,react.useRef)(new utils_CacheMap());
|
|
var collectRafRef = (0,react.useRef)();
|
|
function cancelRaf() {
|
|
es_raf.cancel(collectRafRef.current);
|
|
}
|
|
function collectHeight() {
|
|
cancelRaf();
|
|
collectRafRef.current = es_raf(function () {
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
(0,react.useEffect)(function () {
|
|
return cancelRaf;
|
|
}, []);
|
|
return [setInstanceRef, collectHeight, heightsRef.current, updatedMark];
|
|
}
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/typeof.js
|
|
var esm_typeof = __webpack_require__(71002);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-virtual-list/es/hooks/useScrollTo.js
|
|
|
|
/* eslint-disable no-param-reassign */
|
|
|
|
|
|
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
|
|
es_raf.cancel(scrollRef.current);
|
|
if (typeof arg === 'number') {
|
|
syncScrollTop(arg);
|
|
} else if (arg && (0,esm_typeof/* default */.Z)(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 = es_raf(function () {
|
|
if (needCollectHeight) {
|
|
collectHeight();
|
|
}
|
|
syncScroll(times - 1, newTargetAlign);
|
|
}, 2); // Delay 2 to wait for List collect heights
|
|
};
|
|
|
|
syncScroll(3);
|
|
}
|
|
};
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-virtual-list/es/utils/algorithmUtil.js
|
|
/**
|
|
* 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
|
|
*/
|
|
function getIndexByStartLoc(min, max, start, index) {
|
|
var beforeCount = start - min;
|
|
var afterCount = max - start;
|
|
var balanceCount = Math.min(beforeCount, afterCount) * 2;
|
|
// Balance
|
|
if (index <= balanceCount) {
|
|
var stepIndex = Math.floor(index / 2);
|
|
if (index % 2) {
|
|
return start + stepIndex + 1;
|
|
}
|
|
return start - stepIndex;
|
|
}
|
|
// One is out of range
|
|
if (beforeCount > afterCount) {
|
|
return start - (index - afterCount);
|
|
}
|
|
return start + (index - beforeCount);
|
|
}
|
|
/**
|
|
* 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
|
|
};
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-virtual-list/es/hooks/useDiffItem.js
|
|
|
|
|
|
|
|
function useDiffItem(data, getKey, onDiff) {
|
|
var _React$useState = react.useState(data),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
prevData = _React$useState2[0],
|
|
setPrevData = _React$useState2[1];
|
|
var _React$useState3 = react.useState(null),
|
|
_React$useState4 = (0,slicedToArray/* default */.Z)(_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];
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-virtual-list/es/utils/isFirefox.js
|
|
|
|
var isFF = (typeof navigator === "undefined" ? "undefined" : (0,esm_typeof/* default */.Z)(navigator)) === 'object' && /Firefox/i.test(navigator.userAgent);
|
|
/* harmony default export */ var isFirefox = (isFF);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-virtual-list/es/hooks/useOriginScroll.js
|
|
|
|
/* harmony default export */ var useOriginScroll = (function (isScrollAtTop, isScrollAtBottom) {
|
|
// Do lock for a wheel when scrolling
|
|
var lockRef = (0,react.useRef)(false);
|
|
var lockTimeoutRef = (0,react.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 = (0,react.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;
|
|
};
|
|
});
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-virtual-list/es/hooks/useFrameWheel.js
|
|
|
|
|
|
|
|
|
|
function useFrameWheel(inVirtual, isScrollAtTop, isScrollAtBottom, onWheelDelta) {
|
|
var offsetRef = (0,react.useRef)(0);
|
|
var nextFrameRef = (0,react.useRef)(null);
|
|
// Firefox patch
|
|
var wheelValueRef = (0,react.useRef)(null);
|
|
var isMouseScrollRef = (0,react.useRef)(false);
|
|
// Scroll status sync
|
|
var originScroll = useOriginScroll(isScrollAtTop, isScrollAtBottom);
|
|
function onWheel(event) {
|
|
if (!inVirtual) return;
|
|
es_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 (!isFirefox) {
|
|
event.preventDefault();
|
|
}
|
|
nextFrameRef.current = es_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];
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-virtual-list/node_modules/rc-util/es/Dom/canUseDom.js
|
|
function canUseDom() {
|
|
return !!(typeof window !== 'undefined' && window.document && window.document.createElement);
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-virtual-list/node_modules/rc-util/es/hooks/useLayoutEffect.js
|
|
|
|
|
|
|
|
/**
|
|
* Wrap `React.useLayoutEffect` which will not throw warning message in test env
|
|
*/
|
|
var useLayoutEffect = true && canUseDom() ? react.useLayoutEffect : react.useEffect;
|
|
/* harmony default export */ var hooks_useLayoutEffect = (useLayoutEffect);
|
|
var useLayoutUpdateEffect = function useLayoutUpdateEffect(callback, deps) {
|
|
var firstMountRef = React.useRef(true);
|
|
useLayoutEffect(function () {
|
|
if (!firstMountRef.current) {
|
|
return callback();
|
|
}
|
|
}, deps);
|
|
|
|
// We tell react that first mount has passed
|
|
useLayoutEffect(function () {
|
|
firstMountRef.current = false;
|
|
return function () {
|
|
firstMountRef.current = true;
|
|
};
|
|
}, []);
|
|
};
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-virtual-list/es/hooks/useMobileTouchMove.js
|
|
|
|
|
|
var SMOOTH_PTG = 14 / 15;
|
|
function useMobileTouchMove(inVirtual, listRef, callback) {
|
|
var touchedRef = (0,react.useRef)(false);
|
|
var touchYRef = (0,react.useRef)(0);
|
|
var elementRef = (0,react.useRef)(null);
|
|
// Smooth scroll
|
|
var intervalRef = (0,react.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);
|
|
}
|
|
};
|
|
hooks_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]);
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-virtual-list/es/List.js
|
|
|
|
|
|
|
|
|
|
|
|
var _excluded = ["prefixCls", "className", "height", "itemHeight", "fullHeight", "style", "data", "children", "itemKey", "virtual", "direction", "component", "onScroll", "onVisibleChange", "innerProps"];
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var EMPTY_DATA = [];
|
|
var ScrollStyle = {
|
|
overflowY: 'auto',
|
|
overflowAnchor: 'none'
|
|
};
|
|
function RawList(props, ref) {
|
|
var _props$prefixCls = props.prefixCls,
|
|
prefixCls = _props$prefixCls === void 0 ? 'rc-virtual-list' : _props$prefixCls,
|
|
className = props.className,
|
|
height = props.height,
|
|
itemHeight = props.itemHeight,
|
|
_props$fullHeight = props.fullHeight,
|
|
fullHeight = _props$fullHeight === void 0 ? true : _props$fullHeight,
|
|
style = props.style,
|
|
data = props.data,
|
|
children = props.children,
|
|
itemKey = props.itemKey,
|
|
virtual = props.virtual,
|
|
direction = props.direction,
|
|
_props$component = props.component,
|
|
Component = _props$component === void 0 ? 'div' : _props$component,
|
|
onScroll = props.onScroll,
|
|
onVisibleChange = props.onVisibleChange,
|
|
innerProps = props.innerProps,
|
|
restProps = (0,objectWithoutProperties/* default */.Z)(props, _excluded);
|
|
// ================================= MISC =================================
|
|
var useVirtual = !!(virtual !== false && height && itemHeight);
|
|
var inVirtual = useVirtual && data && itemHeight * data.length > height;
|
|
var _useState = (0,react.useState)(0),
|
|
_useState2 = (0,slicedToArray/* default */.Z)(_useState, 2),
|
|
scrollTop = _useState2[0],
|
|
setScrollTop = _useState2[1];
|
|
var _useState3 = (0,react.useState)(false),
|
|
_useState4 = (0,slicedToArray/* default */.Z)(_useState3, 2),
|
|
scrollMoving = _useState4[0],
|
|
setScrollMoving = _useState4[1];
|
|
var mergedClassName = classnames_default()(prefixCls, (0,defineProperty/* default */.Z)({}, "".concat(prefixCls, "-rtl"), direction === 'rtl'), className);
|
|
var mergedData = data || EMPTY_DATA;
|
|
var componentRef = (0,react.useRef)();
|
|
var fillerInnerRef = (0,react.useRef)();
|
|
var scrollBarRef = (0,react.useRef)(); // Hack on scrollbar to enable flash call
|
|
// =============================== Item Key ===============================
|
|
var getKey = react.useCallback(function (item) {
|
|
if (typeof itemKey === 'function') {
|
|
return itemKey(item);
|
|
}
|
|
return item === null || item === void 0 ? void 0 : item[itemKey];
|
|
}, [itemKey]);
|
|
var sharedConfig = {
|
|
getKey: getKey
|
|
};
|
|
// ================================ Scroll ================================
|
|
function syncScrollTop(newTop) {
|
|
setScrollTop(function (origin) {
|
|
var value;
|
|
if (typeof newTop === 'function') {
|
|
value = newTop(origin);
|
|
} else {
|
|
value = newTop;
|
|
}
|
|
var alignedTop = keepInRange(value);
|
|
componentRef.current.scrollTop = alignedTop;
|
|
return alignedTop;
|
|
});
|
|
}
|
|
// ================================ Legacy ================================
|
|
// Put ref here since the range is generate by follow
|
|
var rangeRef = (0,react.useRef)({
|
|
start: 0,
|
|
end: mergedData.length
|
|
});
|
|
var diffItemRef = (0,react.useRef)();
|
|
var _useDiffItem = useDiffItem(mergedData, getKey),
|
|
_useDiffItem2 = (0,slicedToArray/* default */.Z)(_useDiffItem, 1),
|
|
diffItem = _useDiffItem2[0];
|
|
diffItemRef.current = diffItem;
|
|
// ================================ Height ================================
|
|
var _useHeights = useHeights(getKey, null, null),
|
|
_useHeights2 = (0,slicedToArray/* default */.Z)(_useHeights, 4),
|
|
setInstanceRef = _useHeights2[0],
|
|
collectHeight = _useHeights2[1],
|
|
heights = _useHeights2[2],
|
|
heightUpdatedMark = _useHeights2[3];
|
|
// ========================== Visible Calculation =========================
|
|
var _React$useMemo = react.useMemo(function () {
|
|
if (!useVirtual) {
|
|
return {
|
|
scrollHeight: undefined,
|
|
start: 0,
|
|
end: mergedData.length - 1,
|
|
offset: undefined
|
|
};
|
|
}
|
|
// Always use virtual scroll bar in avoid shaking
|
|
if (!inVirtual) {
|
|
var _fillerInnerRef$curre;
|
|
return {
|
|
scrollHeight: ((_fillerInnerRef$curre = fillerInnerRef.current) === null || _fillerInnerRef$curre === void 0 ? void 0 : _fillerInnerRef$curre.offsetHeight) || 0,
|
|
start: 0,
|
|
end: mergedData.length - 1,
|
|
offset: undefined
|
|
};
|
|
}
|
|
var itemTop = 0;
|
|
var startIndex;
|
|
var startOffset;
|
|
var endIndex;
|
|
var dataLen = mergedData.length;
|
|
for (var i = 0; i < dataLen; i += 1) {
|
|
var item = mergedData[i];
|
|
var key = getKey(item);
|
|
var cacheHeight = heights.get(key);
|
|
var currentItemBottom = itemTop + (cacheHeight === undefined ? itemHeight : cacheHeight);
|
|
// Check item top in the range
|
|
if (currentItemBottom >= scrollTop && startIndex === undefined) {
|
|
startIndex = i;
|
|
startOffset = itemTop;
|
|
}
|
|
// Check item bottom in the range. We will render additional one item for motion usage
|
|
if (currentItemBottom > scrollTop + height && endIndex === undefined) {
|
|
endIndex = i;
|
|
}
|
|
itemTop = currentItemBottom;
|
|
}
|
|
// When scrollTop at the end but data cut to small count will reach this
|
|
if (startIndex === undefined) {
|
|
startIndex = 0;
|
|
startOffset = 0;
|
|
endIndex = Math.ceil(height / itemHeight);
|
|
}
|
|
if (endIndex === undefined) {
|
|
endIndex = mergedData.length - 1;
|
|
}
|
|
// Give cache to improve scroll experience
|
|
endIndex = Math.min(endIndex + 1, mergedData.length);
|
|
return {
|
|
scrollHeight: itemTop,
|
|
start: startIndex,
|
|
end: endIndex,
|
|
offset: startOffset
|
|
};
|
|
}, [inVirtual, useVirtual, scrollTop, mergedData, heightUpdatedMark, height]),
|
|
scrollHeight = _React$useMemo.scrollHeight,
|
|
start = _React$useMemo.start,
|
|
end = _React$useMemo.end,
|
|
offset = _React$useMemo.offset;
|
|
rangeRef.current.start = start;
|
|
rangeRef.current.end = end;
|
|
// =============================== In Range ===============================
|
|
var maxScrollHeight = scrollHeight - height;
|
|
var maxScrollHeightRef = (0,react.useRef)(maxScrollHeight);
|
|
maxScrollHeightRef.current = maxScrollHeight;
|
|
function keepInRange(newScrollTop) {
|
|
var newTop = newScrollTop;
|
|
if (!Number.isNaN(maxScrollHeightRef.current)) {
|
|
newTop = Math.min(newTop, maxScrollHeightRef.current);
|
|
}
|
|
newTop = Math.max(newTop, 0);
|
|
return newTop;
|
|
}
|
|
var isScrollAtTop = scrollTop <= 0;
|
|
var isScrollAtBottom = scrollTop >= maxScrollHeight;
|
|
var originScroll = useOriginScroll(isScrollAtTop, isScrollAtBottom);
|
|
// ================================ Scroll ================================
|
|
function onScrollBar(newScrollTop) {
|
|
var newTop = newScrollTop;
|
|
syncScrollTop(newTop);
|
|
}
|
|
// When data size reduce. It may trigger native scroll event back to fit scroll position
|
|
function onFallbackScroll(e) {
|
|
var newScrollTop = e.currentTarget.scrollTop;
|
|
if (newScrollTop !== scrollTop) {
|
|
syncScrollTop(newScrollTop);
|
|
}
|
|
// Trigger origin onScroll
|
|
onScroll === null || onScroll === void 0 ? void 0 : onScroll(e);
|
|
}
|
|
// Since this added in global,should use ref to keep update
|
|
var _useFrameWheel = useFrameWheel(useVirtual, isScrollAtTop, isScrollAtBottom, function (offsetY) {
|
|
syncScrollTop(function (top) {
|
|
var newTop = top + offsetY;
|
|
return newTop;
|
|
});
|
|
}),
|
|
_useFrameWheel2 = (0,slicedToArray/* default */.Z)(_useFrameWheel, 2),
|
|
onRawWheel = _useFrameWheel2[0],
|
|
onFireFoxScroll = _useFrameWheel2[1];
|
|
// Mobile touch move
|
|
useMobileTouchMove(useVirtual, componentRef, function (deltaY, smoothOffset) {
|
|
if (originScroll(deltaY, smoothOffset)) {
|
|
return false;
|
|
}
|
|
onRawWheel({
|
|
preventDefault: function preventDefault() {},
|
|
deltaY: deltaY
|
|
});
|
|
return true;
|
|
});
|
|
hooks_useLayoutEffect(function () {
|
|
// Firefox only
|
|
function onMozMousePixelScroll(e) {
|
|
if (useVirtual) {
|
|
e.preventDefault();
|
|
}
|
|
}
|
|
componentRef.current.addEventListener('wheel', onRawWheel);
|
|
componentRef.current.addEventListener('DOMMouseScroll', onFireFoxScroll);
|
|
componentRef.current.addEventListener('MozMousePixelScroll', onMozMousePixelScroll);
|
|
return function () {
|
|
if (componentRef.current) {
|
|
componentRef.current.removeEventListener('wheel', onRawWheel);
|
|
componentRef.current.removeEventListener('DOMMouseScroll', onFireFoxScroll);
|
|
componentRef.current.removeEventListener('MozMousePixelScroll', onMozMousePixelScroll);
|
|
}
|
|
};
|
|
}, [useVirtual]);
|
|
// ================================= Ref ==================================
|
|
var scrollTo = useScrollTo(componentRef, mergedData, heights, itemHeight, getKey, collectHeight, syncScrollTop, function () {
|
|
var _scrollBarRef$current;
|
|
(_scrollBarRef$current = scrollBarRef.current) === null || _scrollBarRef$current === void 0 ? void 0 : _scrollBarRef$current.delayHidden();
|
|
});
|
|
react.useImperativeHandle(ref, function () {
|
|
return {
|
|
scrollTo: scrollTo
|
|
};
|
|
});
|
|
// ================================ Effect ================================
|
|
/** We need told outside that some list not rendered */
|
|
hooks_useLayoutEffect(function () {
|
|
if (onVisibleChange) {
|
|
var renderList = mergedData.slice(start, end + 1);
|
|
onVisibleChange(renderList, mergedData);
|
|
}
|
|
}, [start, end, mergedData]);
|
|
// ================================ Render ================================
|
|
var listChildren = useChildren(mergedData, start, end, setInstanceRef, children, sharedConfig);
|
|
var componentStyle = null;
|
|
if (height) {
|
|
componentStyle = (0,objectSpread2/* default */.Z)((0,defineProperty/* default */.Z)({}, fullHeight ? 'height' : 'maxHeight', height), ScrollStyle);
|
|
if (useVirtual) {
|
|
componentStyle.overflowY = 'hidden';
|
|
if (scrollMoving) {
|
|
componentStyle.pointerEvents = 'none';
|
|
}
|
|
}
|
|
}
|
|
return /*#__PURE__*/react.createElement("div", (0,esm_extends/* default */.Z)({
|
|
style: (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, style), {}, {
|
|
position: 'relative'
|
|
}),
|
|
className: mergedClassName
|
|
}, restProps), /*#__PURE__*/react.createElement(Component, {
|
|
className: "".concat(prefixCls, "-holder"),
|
|
style: componentStyle,
|
|
ref: componentRef,
|
|
onScroll: onFallbackScroll
|
|
}, /*#__PURE__*/react.createElement(es_Filler, {
|
|
prefixCls: prefixCls,
|
|
height: scrollHeight,
|
|
offset: offset,
|
|
onInnerResize: collectHeight,
|
|
ref: fillerInnerRef,
|
|
innerProps: innerProps
|
|
}, listChildren)), useVirtual && /*#__PURE__*/react.createElement(ScrollBar, {
|
|
ref: scrollBarRef,
|
|
prefixCls: prefixCls,
|
|
scrollTop: scrollTop,
|
|
height: height,
|
|
scrollHeight: scrollHeight,
|
|
count: mergedData.length,
|
|
direction: direction,
|
|
onScroll: onScrollBar,
|
|
onStartMove: function onStartMove() {
|
|
setScrollMoving(true);
|
|
},
|
|
onStopMove: function onStopMove() {
|
|
setScrollMoving(false);
|
|
}
|
|
}));
|
|
}
|
|
var List = /*#__PURE__*/react.forwardRef(RawList);
|
|
List.displayName = 'List';
|
|
/* harmony default export */ var es_List = (List);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-virtual-list/es/index.js
|
|
|
|
/* harmony default export */ var rc_virtual_list_es = (es_List);
|
|
|
|
/***/ })
|
|
|
|
}]); |