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.
1786 lines
64 KiB
1786 lines
64 KiB
(self["webpackChunk"] = self["webpackChunk"] || []).push([[66357],{
|
|
|
|
/***/ 25035:
|
|
/*!***************************************************************************************!*\
|
|
!*** ./node_modules/@ant-design/icons/es/icons/QuestionCircleOutlined.js + 1 modules ***!
|
|
\***************************************************************************************/
|
|
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
// EXPORTS
|
|
__webpack_require__.d(__webpack_exports__, {
|
|
"Z": function() { return /* binding */ icons_QuestionCircleOutlined; }
|
|
});
|
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js
|
|
var esm_extends = __webpack_require__(87462);
|
|
// EXTERNAL MODULE: ./node_modules/react/index.js
|
|
var react = __webpack_require__(67294);
|
|
;// CONCATENATED MODULE: ./node_modules/@ant-design/icons-svg/es/asn/QuestionCircleOutlined.js
|
|
// This icon file is generated automatically.
|
|
var QuestionCircleOutlined = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm0 820c-205.4 0-372-166.6-372-372s166.6-372 372-372 372 166.6 372 372-166.6 372-372 372z" } }, { "tag": "path", "attrs": { "d": "M623.6 316.7C593.6 290.4 554 276 512 276s-81.6 14.5-111.6 40.7C369.2 344 352 380.7 352 420v7.6c0 4.4 3.6 8 8 8h48c4.4 0 8-3.6 8-8V420c0-44.1 43.1-80 96-80s96 35.9 96 80c0 31.1-22 59.6-56.1 72.7-21.2 8.1-39.2 22.3-52.1 40.9-13.1 19-19.9 41.8-19.9 64.9V620c0 4.4 3.6 8 8 8h48c4.4 0 8-3.6 8-8v-22.7a48.3 48.3 0 0130.9-44.8c59-22.7 97.1-74.7 97.1-132.5.1-39.3-17.1-76-48.3-103.3zM472 732a40 40 0 1080 0 40 40 0 10-80 0z" } }] }, "name": "question-circle", "theme": "outlined" };
|
|
/* harmony default export */ var asn_QuestionCircleOutlined = (QuestionCircleOutlined);
|
|
|
|
// EXTERNAL MODULE: ./node_modules/@ant-design/icons/es/components/AntdIcon.js + 8 modules
|
|
var AntdIcon = __webpack_require__(74643);
|
|
;// CONCATENATED MODULE: ./node_modules/@ant-design/icons/es/icons/QuestionCircleOutlined.js
|
|
|
|
// GENERATE BY ./scripts/generate.ts
|
|
// DON NOT EDIT IT MANUALLY
|
|
|
|
|
|
|
|
|
|
var QuestionCircleOutlined_QuestionCircleOutlined = function QuestionCircleOutlined(props, ref) {
|
|
return /*#__PURE__*/react.createElement(AntdIcon/* default */.Z, (0,esm_extends/* default */.Z)({}, props, {
|
|
ref: ref,
|
|
icon: asn_QuestionCircleOutlined
|
|
}));
|
|
};
|
|
if (false) {}
|
|
/* harmony default export */ var icons_QuestionCircleOutlined = (/*#__PURE__*/react.forwardRef(QuestionCircleOutlined_QuestionCircleOutlined));
|
|
|
|
/***/ }),
|
|
|
|
/***/ 81643:
|
|
/*!**********************************************************!*\
|
|
!*** ./node_modules/antd/es/_util/getRenderPropValue.js ***!
|
|
\**********************************************************/
|
|
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
|
|
|
|
"use strict";
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "Z": function() { return /* binding */ getRenderPropValue; }
|
|
/* harmony export */ });
|
|
const getRenderPropValue = propValue => {
|
|
if (!propValue) {
|
|
return null;
|
|
}
|
|
if (typeof propValue === 'function') {
|
|
return propValue();
|
|
}
|
|
return propValue;
|
|
};
|
|
|
|
/***/ }),
|
|
|
|
/***/ 66330:
|
|
/*!***************************************************!*\
|
|
!*** ./node_modules/antd/es/popover/PurePanel.js ***!
|
|
\***************************************************/
|
|
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
|
|
|
|
"use strict";
|
|
/* unused harmony exports getOverlay, RawPurePanel */
|
|
/* harmony import */ var classnames__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! classnames */ 94184);
|
|
/* harmony import */ var classnames__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(classnames__WEBPACK_IMPORTED_MODULE_0__);
|
|
/* harmony import */ var rc_tooltip__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! rc-tooltip */ 92419);
|
|
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! react */ 67294);
|
|
/* harmony import */ var _config_provider__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../config-provider */ 53124);
|
|
/* harmony import */ var _util_getRenderPropValue__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../_util/getRenderPropValue */ 81643);
|
|
/* harmony import */ var _style__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./style */ 20136);
|
|
var __rest = undefined && undefined.__rest || function (s, e) {
|
|
var t = {};
|
|
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
|
|
if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
|
|
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
|
|
}
|
|
return t;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const getOverlay = (prefixCls, title, content) => {
|
|
if (!title && !content) return undefined;
|
|
return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_2__.createElement(react__WEBPACK_IMPORTED_MODULE_2__.Fragment, null, title && /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_2__.createElement("div", {
|
|
className: `${prefixCls}-title`
|
|
}, (0,_util_getRenderPropValue__WEBPACK_IMPORTED_MODULE_3__/* .getRenderPropValue */ .Z)(title)), /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_2__.createElement("div", {
|
|
className: `${prefixCls}-inner-content`
|
|
}, (0,_util_getRenderPropValue__WEBPACK_IMPORTED_MODULE_3__/* .getRenderPropValue */ .Z)(content)));
|
|
};
|
|
const RawPurePanel = props => {
|
|
const {
|
|
hashId,
|
|
prefixCls,
|
|
className,
|
|
style,
|
|
placement = 'top',
|
|
title,
|
|
content,
|
|
children
|
|
} = props;
|
|
return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_2__.createElement("div", {
|
|
className: classnames__WEBPACK_IMPORTED_MODULE_0___default()(hashId, prefixCls, `${prefixCls}-pure`, `${prefixCls}-placement-${placement}`, className),
|
|
style: style
|
|
}, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_2__.createElement("div", {
|
|
className: `${prefixCls}-arrow`
|
|
}), /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_2__.createElement(rc_tooltip__WEBPACK_IMPORTED_MODULE_1__/* .Popup */ .G, Object.assign({}, props, {
|
|
className: hashId,
|
|
prefixCls: prefixCls
|
|
}), children || getOverlay(prefixCls, title, content)));
|
|
};
|
|
const PurePanel = props => {
|
|
const {
|
|
prefixCls: customizePrefixCls
|
|
} = props,
|
|
restProps = __rest(props, ["prefixCls"]);
|
|
const {
|
|
getPrefixCls
|
|
} = react__WEBPACK_IMPORTED_MODULE_2__.useContext(_config_provider__WEBPACK_IMPORTED_MODULE_4__/* .ConfigContext */ .E_);
|
|
const prefixCls = getPrefixCls('popover', customizePrefixCls);
|
|
const [wrapSSR, hashId] = (0,_style__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .Z)(prefixCls);
|
|
return wrapSSR( /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_2__.createElement(RawPurePanel, Object.assign({}, restProps, {
|
|
prefixCls: prefixCls,
|
|
hashId: hashId
|
|
})));
|
|
};
|
|
/* harmony default export */ __webpack_exports__["ZP"] = (PurePanel);
|
|
|
|
/***/ }),
|
|
|
|
/***/ 55241:
|
|
/*!***********************************************!*\
|
|
!*** ./node_modules/antd/es/popover/index.js ***!
|
|
\***********************************************/
|
|
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
|
|
|
|
"use strict";
|
|
/* harmony import */ var classnames__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! classnames */ 94184);
|
|
/* harmony import */ var classnames__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(classnames__WEBPACK_IMPORTED_MODULE_0__);
|
|
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! react */ 67294);
|
|
/* harmony import */ var _util_getRenderPropValue__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../_util/getRenderPropValue */ 81643);
|
|
/* harmony import */ var _util_motion__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../_util/motion */ 33603);
|
|
/* harmony import */ var _config_provider__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../config-provider */ 53124);
|
|
/* harmony import */ var _tooltip__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../tooltip */ 83062);
|
|
/* harmony import */ var _PurePanel__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./PurePanel */ 66330);
|
|
/* harmony import */ var _style__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./style */ 20136);
|
|
'use client';
|
|
|
|
var __rest = undefined && undefined.__rest || function (s, e) {
|
|
var t = {};
|
|
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
|
|
if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
|
|
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
|
|
}
|
|
return t;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// CSSINJS
|
|
|
|
const Overlay = _ref => {
|
|
let {
|
|
title,
|
|
content,
|
|
prefixCls
|
|
} = _ref;
|
|
return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_1__.createElement(react__WEBPACK_IMPORTED_MODULE_1__.Fragment, null, title && /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_1__.createElement("div", {
|
|
className: `${prefixCls}-title`
|
|
}, (0,_util_getRenderPropValue__WEBPACK_IMPORTED_MODULE_2__/* .getRenderPropValue */ .Z)(title)), /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_1__.createElement("div", {
|
|
className: `${prefixCls}-inner-content`
|
|
}, (0,_util_getRenderPropValue__WEBPACK_IMPORTED_MODULE_2__/* .getRenderPropValue */ .Z)(content)));
|
|
};
|
|
const Popover = /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_1__.forwardRef((props, ref) => {
|
|
const {
|
|
prefixCls: customizePrefixCls,
|
|
title,
|
|
content,
|
|
overlayClassName,
|
|
placement = 'top',
|
|
trigger = 'hover',
|
|
mouseEnterDelay = 0.1,
|
|
mouseLeaveDelay = 0.1,
|
|
overlayStyle = {}
|
|
} = props,
|
|
otherProps = __rest(props, ["prefixCls", "title", "content", "overlayClassName", "placement", "trigger", "mouseEnterDelay", "mouseLeaveDelay", "overlayStyle"]);
|
|
const {
|
|
getPrefixCls
|
|
} = react__WEBPACK_IMPORTED_MODULE_1__.useContext(_config_provider__WEBPACK_IMPORTED_MODULE_3__/* .ConfigContext */ .E_);
|
|
const prefixCls = getPrefixCls('popover', customizePrefixCls);
|
|
const [wrapSSR, hashId] = (0,_style__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .Z)(prefixCls);
|
|
const rootPrefixCls = getPrefixCls();
|
|
const overlayCls = classnames__WEBPACK_IMPORTED_MODULE_0___default()(overlayClassName, hashId);
|
|
return wrapSSR( /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_1__.createElement(_tooltip__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .Z, Object.assign({
|
|
placement: placement,
|
|
trigger: trigger,
|
|
mouseEnterDelay: mouseEnterDelay,
|
|
mouseLeaveDelay: mouseLeaveDelay,
|
|
overlayStyle: overlayStyle
|
|
}, otherProps, {
|
|
prefixCls: prefixCls,
|
|
overlayClassName: overlayCls,
|
|
ref: ref,
|
|
overlay: title || content ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_1__.createElement(Overlay, {
|
|
prefixCls: prefixCls,
|
|
title: title,
|
|
content: content
|
|
}) : null,
|
|
transitionName: (0,_util_motion__WEBPACK_IMPORTED_MODULE_6__/* .getTransitionName */ .mL)(rootPrefixCls, 'zoom-big', otherProps.transitionName),
|
|
"data-popover-inject": true
|
|
})));
|
|
});
|
|
if (false) {}
|
|
Popover._InternalPanelDoNotUseOrYouWillBeFired = _PurePanel__WEBPACK_IMPORTED_MODULE_7__/* ["default"] */ .ZP;
|
|
/* harmony default export */ __webpack_exports__["Z"] = (Popover);
|
|
|
|
/***/ }),
|
|
|
|
/***/ 20136:
|
|
/*!*****************************************************!*\
|
|
!*** ./node_modules/antd/es/popover/style/index.js ***!
|
|
\*****************************************************/
|
|
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
|
|
|
|
"use strict";
|
|
/* harmony import */ var _style__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../style */ 14747);
|
|
/* harmony import */ var _style_motion__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../../style/motion */ 50438);
|
|
/* harmony import */ var _style_placementArrow__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../style/placementArrow */ 97414);
|
|
/* harmony import */ var _theme_internal__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../theme/internal */ 8796);
|
|
/* harmony import */ var _theme_internal__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../../theme/internal */ 67968);
|
|
/* harmony import */ var _theme_internal__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../../theme/internal */ 45503);
|
|
|
|
|
|
|
|
|
|
const genBaseStyle = token => {
|
|
const {
|
|
componentCls,
|
|
popoverColor,
|
|
minWidth,
|
|
fontWeightStrong,
|
|
popoverPadding,
|
|
boxShadowSecondary,
|
|
colorTextHeading,
|
|
borderRadiusLG: borderRadius,
|
|
zIndexPopup,
|
|
marginXS,
|
|
colorBgElevated,
|
|
popoverBg
|
|
} = token;
|
|
return [{
|
|
[componentCls]: Object.assign(Object.assign({}, (0,_style__WEBPACK_IMPORTED_MODULE_0__/* .resetComponent */ .Wf)(token)), {
|
|
position: 'absolute',
|
|
top: 0,
|
|
// use `left` to fix https://github.com/ant-design/ant-design/issues/39195
|
|
left: {
|
|
_skip_check_: true,
|
|
value: 0
|
|
},
|
|
zIndex: zIndexPopup,
|
|
fontWeight: 'normal',
|
|
whiteSpace: 'normal',
|
|
textAlign: 'start',
|
|
cursor: 'auto',
|
|
userSelect: 'text',
|
|
transformOrigin: `var(--arrow-x, 50%) var(--arrow-y, 50%)`,
|
|
'--antd-arrow-background-color': colorBgElevated,
|
|
'&-rtl': {
|
|
direction: 'rtl'
|
|
},
|
|
'&-hidden': {
|
|
display: 'none'
|
|
},
|
|
[`${componentCls}-content`]: {
|
|
position: 'relative'
|
|
},
|
|
[`${componentCls}-inner`]: {
|
|
backgroundColor: popoverBg,
|
|
backgroundClip: 'padding-box',
|
|
borderRadius,
|
|
boxShadow: boxShadowSecondary,
|
|
padding: popoverPadding
|
|
},
|
|
[`${componentCls}-title`]: {
|
|
minWidth,
|
|
marginBottom: marginXS,
|
|
color: colorTextHeading,
|
|
fontWeight: fontWeightStrong
|
|
},
|
|
[`${componentCls}-inner-content`]: {
|
|
color: popoverColor
|
|
}
|
|
})
|
|
},
|
|
// Arrow Style
|
|
(0,_style_placementArrow__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .ZP)(token, {
|
|
colorBg: 'var(--antd-arrow-background-color)'
|
|
}),
|
|
// Pure Render
|
|
{
|
|
[`${componentCls}-pure`]: {
|
|
position: 'relative',
|
|
maxWidth: 'none',
|
|
margin: token.sizePopupArrow,
|
|
display: 'inline-block',
|
|
[`${componentCls}-content`]: {
|
|
display: 'inline-block'
|
|
}
|
|
}
|
|
}];
|
|
};
|
|
const genColorStyle = token => {
|
|
const {
|
|
componentCls
|
|
} = token;
|
|
return {
|
|
[componentCls]: _theme_internal__WEBPACK_IMPORTED_MODULE_2__/* .PresetColors.map */ .i.map(colorKey => {
|
|
const lightColor = token[`${colorKey}6`];
|
|
return {
|
|
[`&${componentCls}-${colorKey}`]: {
|
|
'--antd-arrow-background-color': lightColor,
|
|
[`${componentCls}-inner`]: {
|
|
backgroundColor: lightColor
|
|
},
|
|
[`${componentCls}-arrow`]: {
|
|
background: 'transparent'
|
|
}
|
|
}
|
|
};
|
|
})
|
|
};
|
|
};
|
|
const genWireframeStyle = token => {
|
|
const {
|
|
componentCls,
|
|
lineWidth,
|
|
lineType,
|
|
colorSplit,
|
|
paddingSM,
|
|
controlHeight,
|
|
fontSize,
|
|
lineHeight,
|
|
padding
|
|
} = token;
|
|
const titlePaddingBlockDist = controlHeight - Math.round(fontSize * lineHeight);
|
|
const popoverTitlePaddingBlockTop = titlePaddingBlockDist / 2;
|
|
const popoverTitlePaddingBlockBottom = titlePaddingBlockDist / 2 - lineWidth;
|
|
const popoverPaddingHorizontal = padding;
|
|
return {
|
|
[componentCls]: {
|
|
[`${componentCls}-inner`]: {
|
|
padding: 0
|
|
},
|
|
[`${componentCls}-title`]: {
|
|
margin: 0,
|
|
padding: `${popoverTitlePaddingBlockTop}px ${popoverPaddingHorizontal}px ${popoverTitlePaddingBlockBottom}px`,
|
|
borderBottom: `${lineWidth}px ${lineType} ${colorSplit}`
|
|
},
|
|
[`${componentCls}-inner-content`]: {
|
|
padding: `${paddingSM}px ${popoverPaddingHorizontal}px`
|
|
}
|
|
}
|
|
};
|
|
};
|
|
/* harmony default export */ __webpack_exports__["Z"] = ((0,_theme_internal__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .Z)('Popover', token => {
|
|
const {
|
|
colorBgElevated,
|
|
colorText,
|
|
wireframe
|
|
} = token;
|
|
const popoverToken = (0,_theme_internal__WEBPACK_IMPORTED_MODULE_4__/* .merge */ .TS)(token, {
|
|
popoverPadding: 12,
|
|
popoverBg: colorBgElevated,
|
|
popoverColor: colorText
|
|
});
|
|
return [genBaseStyle(popoverToken), genColorStyle(popoverToken), wireframe && genWireframeStyle(popoverToken), (0,_style_motion__WEBPACK_IMPORTED_MODULE_5__/* .initZoomMotion */ ._y)(popoverToken, 'zoom-big')];
|
|
}, token => ({
|
|
width: 177,
|
|
minWidth: 177,
|
|
zIndexPopup: token.zIndexPopupBase + 30
|
|
}), {
|
|
deprecatedTokens: [['width', 'minWidth']]
|
|
}));
|
|
|
|
/***/ }),
|
|
|
|
/***/ 73453:
|
|
/*!***************************************************************!*\
|
|
!*** ./node_modules/rc-virtual-list/es/index.js + 14 modules ***!
|
|
\***************************************************************/
|
|
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
// 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/defineProperty.js
|
|
var defineProperty = __webpack_require__(4942);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectSpread2.js
|
|
var objectSpread2 = __webpack_require__(1413);
|
|
// 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/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);
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/raf.js
|
|
var raf = __webpack_require__(75164);
|
|
;// CONCATENATED MODULE: ./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();
|
|
};
|
|
_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 () {
|
|
var _this$scrollbarRef$cu;
|
|
window.removeEventListener('mousemove', _this.onMouseMove);
|
|
window.removeEventListener('mouseup', _this.onMouseUp);
|
|
(_this$scrollbarRef$cu = _this.scrollbarRef.current) === null || _this$scrollbarRef$cu === void 0 ? void 0 : _this$scrollbarRef$cu.removeEventListener('touchstart', _this.onScrollbarTouchStart);
|
|
if (_this.thumbRef.current) {
|
|
_this.thumbRef.current.removeEventListener('touchstart', _this.onMouseDown);
|
|
_this.thumbRef.current.removeEventListener('touchmove', _this.onMouseMove);
|
|
_this.thumbRef.current.removeEventListener('touchend', _this.onMouseUp);
|
|
}
|
|
raf/* default.cancel */.Z.cancel(_this.moveRaf);
|
|
};
|
|
_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/* default.cancel */.Z.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 = (0,raf/* default */.Z)(function () {
|
|
onScroll(newScrollTop);
|
|
});
|
|
}
|
|
};
|
|
_this.onMouseUp = function () {
|
|
var onStopMove = _this.props.onStopMove;
|
|
_this.setState({
|
|
dragging: false
|
|
});
|
|
onStopMove();
|
|
_this.removeEvents();
|
|
};
|
|
_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;
|
|
};
|
|
_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() {
|
|
this.removeEvents();
|
|
clearTimeout(this.visibleTimeout);
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value:
|
|
// ====================== Render =======================
|
|
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_default()("".concat(prefixCls, "-scrollbar"), (0,defineProperty/* default */.Z)({}, "".concat(prefixCls, "-scrollbar-show"), canScroll)),
|
|
style: {
|
|
width: 8,
|
|
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_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/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/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/rc-util/es/Dom/findDOMNode.js
|
|
var findDOMNode = __webpack_require__(34203);
|
|
;// CONCATENATED MODULE: ./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/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() {
|
|
raf/* default.cancel */.Z.cancel(collectRafRef.current);
|
|
}
|
|
function collectHeight() {
|
|
cancelRaf();
|
|
collectRafRef.current = (0,raf/* default */.Z)(function () {
|
|
instanceRef.current.forEach(function (element, key) {
|
|
if (element && element.offsetParent) {
|
|
var htmlElement = (0,findDOMNode/* default */.Z)(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/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
|
|
raf/* default.cancel */.Z.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 = (0,raf/* default */.Z)(function () {
|
|
if (needCollectHeight) {
|
|
collectHeight();
|
|
}
|
|
syncScroll(times - 1, newTargetAlign);
|
|
}, 2); // Delay 2 to wait for List collect heights
|
|
};
|
|
|
|
syncScroll(3);
|
|
}
|
|
};
|
|
}
|
|
;// CONCATENATED MODULE: ./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/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/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/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/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;
|
|
raf/* default.cancel */.Z.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 = (0,raf/* default */.Z)(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];
|
|
}
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/hooks/useLayoutEffect.js
|
|
var useLayoutEffect = __webpack_require__(8410);
|
|
;// CONCATENATED MODULE: ./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);
|
|
}
|
|
};
|
|
(0,useLayoutEffect/* default */.Z)(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/rc-virtual-list/es/List.js
|
|
|
|
|
|
|
|
|
|
|
|
var _excluded = ["prefixCls", "className", "height", "itemHeight", "fullHeight", "style", "data", "children", "itemKey", "virtual", "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,
|
|
_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, 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;
|
|
});
|
|
(0,useLayoutEffect/* default */.Z)(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 */
|
|
(0,useLayoutEffect/* default */.Z)(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,
|
|
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/rc-virtual-list/es/index.js
|
|
|
|
/* harmony default export */ var rc_virtual_list_es = (es_List);
|
|
|
|
/***/ }),
|
|
|
|
/***/ 57761:
|
|
/*!*********************************************************************!*\
|
|
!*** ./node_modules/react-infinite-scroller/dist/InfiniteScroll.js ***!
|
|
\*********************************************************************/
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", ({
|
|
value: true
|
|
}));
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _react = __webpack_require__(/*! react */ 67294);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _propTypes = __webpack_require__(/*! prop-types */ 45697);
|
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
var InfiniteScroll = function (_Component) {
|
|
_inherits(InfiniteScroll, _Component);
|
|
|
|
function InfiniteScroll(props) {
|
|
_classCallCheck(this, InfiniteScroll);
|
|
|
|
var _this = _possibleConstructorReturn(this, (InfiniteScroll.__proto__ || Object.getPrototypeOf(InfiniteScroll)).call(this, props));
|
|
|
|
_this.scrollListener = _this.scrollListener.bind(_this);
|
|
_this.eventListenerOptions = _this.eventListenerOptions.bind(_this);
|
|
_this.mousewheelListener = _this.mousewheelListener.bind(_this);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(InfiniteScroll, [{
|
|
key: 'componentDidMount',
|
|
value: function componentDidMount() {
|
|
this.pageLoaded = this.props.pageStart;
|
|
this.options = this.eventListenerOptions();
|
|
this.attachScrollListener();
|
|
}
|
|
}, {
|
|
key: 'componentDidUpdate',
|
|
value: function componentDidUpdate() {
|
|
if (this.props.isReverse && this.loadMore) {
|
|
var parentElement = this.getParentElement(this.scrollComponent);
|
|
parentElement.scrollTop = parentElement.scrollHeight - this.beforeScrollHeight + this.beforeScrollTop;
|
|
this.loadMore = false;
|
|
}
|
|
this.attachScrollListener();
|
|
}
|
|
}, {
|
|
key: 'componentWillUnmount',
|
|
value: function componentWillUnmount() {
|
|
this.detachScrollListener();
|
|
this.detachMousewheelListener();
|
|
}
|
|
}, {
|
|
key: 'isPassiveSupported',
|
|
value: function isPassiveSupported() {
|
|
var passive = false;
|
|
|
|
var testOptions = {
|
|
get passive() {
|
|
passive = true;
|
|
}
|
|
};
|
|
|
|
try {
|
|
document.addEventListener('test', null, testOptions);
|
|
document.removeEventListener('test', null, testOptions);
|
|
} catch (e) {
|
|
// ignore
|
|
}
|
|
return passive;
|
|
}
|
|
}, {
|
|
key: 'eventListenerOptions',
|
|
value: function eventListenerOptions() {
|
|
var options = this.props.useCapture;
|
|
|
|
if (this.isPassiveSupported()) {
|
|
options = {
|
|
useCapture: this.props.useCapture,
|
|
passive: true
|
|
};
|
|
}
|
|
return options;
|
|
}
|
|
|
|
// Set a defaut loader for all your `InfiniteScroll` components
|
|
|
|
}, {
|
|
key: 'setDefaultLoader',
|
|
value: function setDefaultLoader(loader) {
|
|
this.defaultLoader = loader;
|
|
}
|
|
}, {
|
|
key: 'detachMousewheelListener',
|
|
value: function detachMousewheelListener() {
|
|
var scrollEl = window;
|
|
if (this.props.useWindow === false) {
|
|
scrollEl = this.scrollComponent.parentNode;
|
|
}
|
|
|
|
scrollEl.removeEventListener('mousewheel', this.mousewheelListener, this.options ? this.options : this.props.useCapture);
|
|
}
|
|
}, {
|
|
key: 'detachScrollListener',
|
|
value: function detachScrollListener() {
|
|
var scrollEl = window;
|
|
if (this.props.useWindow === false) {
|
|
scrollEl = this.getParentElement(this.scrollComponent);
|
|
}
|
|
|
|
scrollEl.removeEventListener('scroll', this.scrollListener, this.options ? this.options : this.props.useCapture);
|
|
scrollEl.removeEventListener('resize', this.scrollListener, this.options ? this.options : this.props.useCapture);
|
|
}
|
|
}, {
|
|
key: 'getParentElement',
|
|
value: function getParentElement(el) {
|
|
var scrollParent = this.props.getScrollParent && this.props.getScrollParent();
|
|
if (scrollParent != null) {
|
|
return scrollParent;
|
|
}
|
|
return el && el.parentNode;
|
|
}
|
|
}, {
|
|
key: 'filterProps',
|
|
value: function filterProps(props) {
|
|
return props;
|
|
}
|
|
}, {
|
|
key: 'attachScrollListener',
|
|
value: function attachScrollListener() {
|
|
var parentElement = this.getParentElement(this.scrollComponent);
|
|
|
|
if (!this.props.hasMore || !parentElement) {
|
|
return;
|
|
}
|
|
|
|
var scrollEl = window;
|
|
if (this.props.useWindow === false) {
|
|
scrollEl = parentElement;
|
|
}
|
|
|
|
scrollEl.addEventListener('mousewheel', this.mousewheelListener, this.options ? this.options : this.props.useCapture);
|
|
scrollEl.addEventListener('scroll', this.scrollListener, this.options ? this.options : this.props.useCapture);
|
|
scrollEl.addEventListener('resize', this.scrollListener, this.options ? this.options : this.props.useCapture);
|
|
|
|
if (this.props.initialLoad) {
|
|
this.scrollListener();
|
|
}
|
|
}
|
|
}, {
|
|
key: 'mousewheelListener',
|
|
value: function mousewheelListener(e) {
|
|
// Prevents Chrome hangups
|
|
// See: https://stackoverflow.com/questions/47524205/random-high-content-download-time-in-chrome/47684257#47684257
|
|
if (e.deltaY === 1 && !this.isPassiveSupported()) {
|
|
e.preventDefault();
|
|
}
|
|
}
|
|
}, {
|
|
key: 'scrollListener',
|
|
value: function scrollListener() {
|
|
var el = this.scrollComponent;
|
|
var scrollEl = window;
|
|
var parentNode = this.getParentElement(el);
|
|
|
|
var offset = void 0;
|
|
if (this.props.useWindow) {
|
|
var doc = document.documentElement || document.body.parentNode || document.body;
|
|
var scrollTop = scrollEl.pageYOffset !== undefined ? scrollEl.pageYOffset : doc.scrollTop;
|
|
if (this.props.isReverse) {
|
|
offset = scrollTop;
|
|
} else {
|
|
offset = this.calculateOffset(el, scrollTop);
|
|
}
|
|
} else if (this.props.isReverse) {
|
|
offset = parentNode.scrollTop;
|
|
} else {
|
|
offset = el.scrollHeight - parentNode.scrollTop - parentNode.clientHeight;
|
|
}
|
|
|
|
// Here we make sure the element is visible as well as checking the offset
|
|
if (offset < Number(this.props.threshold) && el && el.offsetParent !== null) {
|
|
this.detachScrollListener();
|
|
this.beforeScrollHeight = parentNode.scrollHeight;
|
|
this.beforeScrollTop = parentNode.scrollTop;
|
|
// Call loadMore after detachScrollListener to allow for non-async loadMore functions
|
|
if (typeof this.props.loadMore === 'function') {
|
|
this.props.loadMore(this.pageLoaded += 1);
|
|
this.loadMore = true;
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: 'calculateOffset',
|
|
value: function calculateOffset(el, scrollTop) {
|
|
if (!el) {
|
|
return 0;
|
|
}
|
|
|
|
return this.calculateTopPosition(el) + (el.offsetHeight - scrollTop - window.innerHeight);
|
|
}
|
|
}, {
|
|
key: 'calculateTopPosition',
|
|
value: function calculateTopPosition(el) {
|
|
if (!el) {
|
|
return 0;
|
|
}
|
|
return el.offsetTop + this.calculateTopPosition(el.offsetParent);
|
|
}
|
|
}, {
|
|
key: 'render',
|
|
value: function render() {
|
|
var _this2 = this;
|
|
|
|
var renderProps = this.filterProps(this.props);
|
|
|
|
var children = renderProps.children,
|
|
element = renderProps.element,
|
|
hasMore = renderProps.hasMore,
|
|
initialLoad = renderProps.initialLoad,
|
|
isReverse = renderProps.isReverse,
|
|
loader = renderProps.loader,
|
|
loadMore = renderProps.loadMore,
|
|
pageStart = renderProps.pageStart,
|
|
ref = renderProps.ref,
|
|
threshold = renderProps.threshold,
|
|
useCapture = renderProps.useCapture,
|
|
useWindow = renderProps.useWindow,
|
|
getScrollParent = renderProps.getScrollParent,
|
|
props = _objectWithoutProperties(renderProps, ['children', 'element', 'hasMore', 'initialLoad', 'isReverse', 'loader', 'loadMore', 'pageStart', 'ref', 'threshold', 'useCapture', 'useWindow', 'getScrollParent']);
|
|
|
|
props.ref = function (node) {
|
|
_this2.scrollComponent = node;
|
|
if (ref) {
|
|
ref(node);
|
|
}
|
|
};
|
|
|
|
var childrenArray = [children];
|
|
if (hasMore) {
|
|
if (loader) {
|
|
isReverse ? childrenArray.unshift(loader) : childrenArray.push(loader);
|
|
} else if (this.defaultLoader) {
|
|
isReverse ? childrenArray.unshift(this.defaultLoader) : childrenArray.push(this.defaultLoader);
|
|
}
|
|
}
|
|
return _react2.default.createElement(element, props, childrenArray);
|
|
}
|
|
}]);
|
|
|
|
return InfiniteScroll;
|
|
}(_react.Component);
|
|
|
|
InfiniteScroll.propTypes = {
|
|
children: _propTypes2.default.node.isRequired,
|
|
element: _propTypes2.default.node,
|
|
hasMore: _propTypes2.default.bool,
|
|
initialLoad: _propTypes2.default.bool,
|
|
isReverse: _propTypes2.default.bool,
|
|
loader: _propTypes2.default.node,
|
|
loadMore: _propTypes2.default.func.isRequired,
|
|
pageStart: _propTypes2.default.number,
|
|
ref: _propTypes2.default.func,
|
|
getScrollParent: _propTypes2.default.func,
|
|
threshold: _propTypes2.default.number,
|
|
useCapture: _propTypes2.default.bool,
|
|
useWindow: _propTypes2.default.bool
|
|
};
|
|
InfiniteScroll.defaultProps = {
|
|
element: 'div',
|
|
hasMore: false,
|
|
initialLoad: true,
|
|
pageStart: 0,
|
|
ref: null,
|
|
threshold: 250,
|
|
useWindow: true,
|
|
isReverse: false,
|
|
useCapture: false,
|
|
loader: null,
|
|
getScrollParent: null
|
|
};
|
|
exports["default"] = InfiniteScroll;
|
|
module.exports = exports['default'];
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 246:
|
|
/*!*******************************************************!*\
|
|
!*** ./node_modules/react-infinite-scroller/index.js ***!
|
|
\*******************************************************/
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
module.exports = __webpack_require__(/*! ./dist/InfiniteScroll */ 57761)
|
|
|
|
|
|
/***/ })
|
|
|
|
}]); |