|
|
(function webpackUniversalModuleDefinition(root, factory) {
|
|
|
if(typeof exports === 'object' && typeof module === 'object')
|
|
|
module.exports = factory(require("react"), require("react-dom"));
|
|
|
else if(typeof define === 'function' && define.amd)
|
|
|
define(["react", "react-dom"], factory);
|
|
|
else if(typeof exports === 'object')
|
|
|
exports["rc-dialog"] = factory(require("react"), require("react-dom"));
|
|
|
else
|
|
|
root["rc-dialog"] = factory(root["React"], root["ReactDOM"]);
|
|
|
})(typeof self !== 'undefined' ? self : this, function(__WEBPACK_EXTERNAL_MODULE_0__, __WEBPACK_EXTERNAL_MODULE_1__) {
|
|
|
return /******/ (function(modules) { // webpackBootstrap
|
|
|
/******/ // The module cache
|
|
|
/******/ var installedModules = {};
|
|
|
/******/
|
|
|
/******/ // The require function
|
|
|
/******/ function __webpack_require__(moduleId) {
|
|
|
/******/
|
|
|
/******/ // Check if module is in cache
|
|
|
/******/ if(installedModules[moduleId]) {
|
|
|
/******/ return installedModules[moduleId].exports;
|
|
|
/******/ }
|
|
|
/******/ // Create a new module (and put it into the cache)
|
|
|
/******/ var module = installedModules[moduleId] = {
|
|
|
/******/ i: moduleId,
|
|
|
/******/ l: false,
|
|
|
/******/ exports: {}
|
|
|
/******/ };
|
|
|
/******/
|
|
|
/******/ // Execute the module function
|
|
|
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
|
|
/******/
|
|
|
/******/ // Flag the module as loaded
|
|
|
/******/ module.l = true;
|
|
|
/******/
|
|
|
/******/ // Return the exports of the module
|
|
|
/******/ return module.exports;
|
|
|
/******/ }
|
|
|
/******/
|
|
|
/******/
|
|
|
/******/ // expose the modules object (__webpack_modules__)
|
|
|
/******/ __webpack_require__.m = modules;
|
|
|
/******/
|
|
|
/******/ // expose the module cache
|
|
|
/******/ __webpack_require__.c = installedModules;
|
|
|
/******/
|
|
|
/******/ // define getter function for harmony exports
|
|
|
/******/ __webpack_require__.d = function(exports, name, getter) {
|
|
|
/******/ if(!__webpack_require__.o(exports, name)) {
|
|
|
/******/ Object.defineProperty(exports, name, {
|
|
|
/******/ configurable: false,
|
|
|
/******/ enumerable: true,
|
|
|
/******/ get: getter
|
|
|
/******/ });
|
|
|
/******/ }
|
|
|
/******/ };
|
|
|
/******/
|
|
|
/******/ // getDefaultExport function for compatibility with non-harmony modules
|
|
|
/******/ __webpack_require__.n = function(module) {
|
|
|
/******/ var getter = module && module.__esModule ?
|
|
|
/******/ function getDefault() { return module['default']; } :
|
|
|
/******/ function getModuleExports() { return module; };
|
|
|
/******/ __webpack_require__.d(getter, 'a', getter);
|
|
|
/******/ return getter;
|
|
|
/******/ };
|
|
|
/******/
|
|
|
/******/ // Object.prototype.hasOwnProperty.call
|
|
|
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
|
|
|
/******/
|
|
|
/******/ // __webpack_public_path__
|
|
|
/******/ __webpack_require__.p = "";
|
|
|
/******/
|
|
|
/******/ // Load entry module and return exports
|
|
|
/******/ return __webpack_require__(__webpack_require__.s = 23);
|
|
|
/******/ })
|
|
|
/************************************************************************/
|
|
|
/******/ ([
|
|
|
/* 0 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
module.exports = __WEBPACK_EXTERNAL_MODULE_0__;
|
|
|
|
|
|
/***/ }),
|
|
|
/* 1 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
module.exports = __WEBPACK_EXTERNAL_MODULE_1__;
|
|
|
|
|
|
/***/ }),
|
|
|
/* 2 */
|
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
var util = {
|
|
|
isAppearSupported: function isAppearSupported(props) {
|
|
|
return props.transitionName && props.transitionAppear || props.animation.appear;
|
|
|
},
|
|
|
isEnterSupported: function isEnterSupported(props) {
|
|
|
return props.transitionName && props.transitionEnter || props.animation.enter;
|
|
|
},
|
|
|
isLeaveSupported: function isLeaveSupported(props) {
|
|
|
return props.transitionName && props.transitionLeave || props.animation.leave;
|
|
|
},
|
|
|
allowAppearCallback: function allowAppearCallback(props) {
|
|
|
return props.transitionAppear || props.animation.appear;
|
|
|
},
|
|
|
allowEnterCallback: function allowEnterCallback(props) {
|
|
|
return props.transitionEnter || props.animation.enter;
|
|
|
},
|
|
|
allowLeaveCallback: function allowLeaveCallback(props) {
|
|
|
return props.transitionLeave || props.animation.leave;
|
|
|
}
|
|
|
};
|
|
|
/* harmony default export */ __webpack_exports__["a"] = (util);
|
|
|
|
|
|
/***/ }),
|
|
|
/* 3 */
|
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
/**
|
|
|
* Easy to set element style, return previous style
|
|
|
* IE browser compatible(IE browser doesn't merge overflow style, need to set it separately)
|
|
|
* https://github.com/ant-design/ant-design/issues/19393
|
|
|
*
|
|
|
*/
|
|
|
function setStyle(style) {
|
|
|
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
|
var _options$element = options.element,
|
|
|
element = _options$element === void 0 ? document.body : _options$element;
|
|
|
var oldStyle = {};
|
|
|
var styleKeys = Object.keys(style); // IE browser compatible
|
|
|
|
|
|
styleKeys.forEach(function (key) {
|
|
|
oldStyle[key] = element.style[key];
|
|
|
});
|
|
|
styleKeys.forEach(function (key) {
|
|
|
element.style[key] = style[key];
|
|
|
});
|
|
|
return oldStyle;
|
|
|
}
|
|
|
|
|
|
/* harmony default export */ __webpack_exports__["a"] = (setStyle);
|
|
|
|
|
|
/***/ }),
|
|
|
/* 4 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
module.exports = __webpack_require__(5);
|
|
|
|
|
|
/***/ }),
|
|
|
/* 5 */
|
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__Dialog__ = __webpack_require__(6);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_rc_util_es_PortalWrapper__ = __webpack_require__(16);
|
|
|
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// fix issue #10656
|
|
|
/*
|
|
|
* getContainer remarks
|
|
|
* Custom container should not be return, because in the Portal component, it will remove the
|
|
|
* return container element here, if the custom container is the only child of it's component,
|
|
|
* like issue #10656, It will has a conflict with removeChild method in react-dom.
|
|
|
* So here should add a child (div element) to custom container.
|
|
|
* */
|
|
|
/* harmony default export */ __webpack_exports__["default"] = (function (props) {
|
|
|
var visible = props.visible,
|
|
|
getContainer = props.getContainer,
|
|
|
forceRender = props.forceRender;
|
|
|
// 渲染在当前 dom 里；
|
|
|
|
|
|
if (getContainer === false) {
|
|
|
return __WEBPACK_IMPORTED_MODULE_0_react__["createElement"](__WEBPACK_IMPORTED_MODULE_1__Dialog__["a" /* default */], _extends({}, props, { getOpenCount: function getOpenCount() {
|
|
|
return 2;
|
|
|
} }));
|
|
|
}
|
|
|
return __WEBPACK_IMPORTED_MODULE_0_react__["createElement"](__WEBPACK_IMPORTED_MODULE_2_rc_util_es_PortalWrapper__["a" /* default */], { visible: visible, forceRender: forceRender, getContainer: getContainer }, function (childProps) {
|
|
|
return __WEBPACK_IMPORTED_MODULE_0_react__["createElement"](__WEBPACK_IMPORTED_MODULE_1__Dialog__["a" /* default */], _extends({}, props, childProps));
|
|
|
});
|
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
/* 6 */
|
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_react_dom__ = __webpack_require__(1);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_react_dom___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_react_dom__);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_rc_util_es_KeyCode__ = __webpack_require__(7);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_rc_util_es_Dom_contains__ = __webpack_require__(8);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_rc_animate__ = __webpack_require__(9);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__LazyRenderBox__ = __webpack_require__(15);
|
|
|
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } 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 uuid = 0;
|
|
|
/* eslint react/no-is-mounted:0 */
|
|
|
function getScroll(w, top) {
|
|
|
var ret = w['page' + (top ? 'Y' : 'X') + 'Offset'];
|
|
|
var method = 'scroll' + (top ? 'Top' : 'Left');
|
|
|
if (typeof ret !== 'number') {
|
|
|
var d = w.document;
|
|
|
ret = d.documentElement[method];
|
|
|
if (typeof ret !== 'number') {
|
|
|
ret = d.body[method];
|
|
|
}
|
|
|
}
|
|
|
return ret;
|
|
|
}
|
|
|
function setTransformOrigin(node, value) {
|
|
|
var style = node.style;
|
|
|
['Webkit', 'Moz', 'Ms', 'ms'].forEach(function (prefix) {
|
|
|
style[prefix + 'TransformOrigin'] = value;
|
|
|
});
|
|
|
style['transformOrigin'] = value;
|
|
|
}
|
|
|
function offset(el) {
|
|
|
var rect = el.getBoundingClientRect();
|
|
|
var pos = {
|
|
|
left: rect.left,
|
|
|
top: rect.top
|
|
|
};
|
|
|
var doc = el.ownerDocument;
|
|
|
var w = doc.defaultView || doc.parentWindow;
|
|
|
pos.left += getScroll(w);
|
|
|
pos.top += getScroll(w, true);
|
|
|
return pos;
|
|
|
}
|
|
|
|
|
|
var Dialog = function (_React$Component) {
|
|
|
_inherits(Dialog, _React$Component);
|
|
|
|
|
|
function Dialog(props) {
|
|
|
_classCallCheck(this, Dialog);
|
|
|
|
|
|
var _this = _possibleConstructorReturn(this, _React$Component.call(this, props));
|
|
|
|
|
|
_this.inTransition = false;
|
|
|
_this.onAnimateLeave = function () {
|
|
|
var _this$props = _this.props,
|
|
|
afterClose = _this$props.afterClose,
|
|
|
getOpenCount = _this$props.getOpenCount;
|
|
|
// need demo?
|
|
|
// https://github.com/react-component/dialog/pull/28
|
|
|
|
|
|
if (_this.wrap) {
|
|
|
_this.wrap.style.display = 'none';
|
|
|
}
|
|
|
_this.inTransition = false;
|
|
|
// 如果没有打开的状态，则清除 effect 和 overflow: hidden;
|
|
|
// https://github.com/ant-design/ant-design/issues/21539
|
|
|
if (!getOpenCount()) {
|
|
|
_this.switchScrollingEffect();
|
|
|
}
|
|
|
if (afterClose) {
|
|
|
afterClose();
|
|
|
}
|
|
|
};
|
|
|
_this.onDialogMouseDown = function () {
|
|
|
_this.dialogMouseDown = true;
|
|
|
};
|
|
|
_this.onMaskMouseUp = function () {
|
|
|
if (_this.dialogMouseDown) {
|
|
|
_this.timeoutId = setTimeout(function () {
|
|
|
_this.dialogMouseDown = false;
|
|
|
}, 0);
|
|
|
}
|
|
|
};
|
|
|
_this.onMaskClick = function (e) {
|
|
|
// android trigger click on open (fastclick??)
|
|
|
if (Date.now() - _this.openTime < 300) {
|
|
|
return;
|
|
|
}
|
|
|
if (e.target === e.currentTarget && !_this.dialogMouseDown) {
|
|
|
_this.close(e);
|
|
|
}
|
|
|
};
|
|
|
_this.onKeyDown = function (e) {
|
|
|
var props = _this.props;
|
|
|
if (props.keyboard && e.keyCode === __WEBPACK_IMPORTED_MODULE_2_rc_util_es_KeyCode__["a" /* default */].ESC) {
|
|
|
e.stopPropagation();
|
|
|
_this.close(e);
|
|
|
return;
|
|
|
}
|
|
|
// keep focus inside dialog
|
|
|
if (props.visible) {
|
|
|
if (e.keyCode === __WEBPACK_IMPORTED_MODULE_2_rc_util_es_KeyCode__["a" /* default */].TAB) {
|
|
|
var activeElement = document.activeElement;
|
|
|
var sentinelStart = _this.sentinelStart;
|
|
|
if (e.shiftKey) {
|
|
|
if (activeElement === sentinelStart) {
|
|
|
_this.sentinelEnd.focus();
|
|
|
}
|
|
|
} else if (activeElement === _this.sentinelEnd) {
|
|
|
sentinelStart.focus();
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
};
|
|
|
_this.getDialogElement = function () {
|
|
|
var props = _this.props;
|
|
|
var closable = props.closable;
|
|
|
var prefixCls = props.prefixCls;
|
|
|
var dest = {};
|
|
|
if (props.width !== undefined) {
|
|
|
dest.width = props.width;
|
|
|
}
|
|
|
if (props.height !== undefined) {
|
|
|
dest.height = props.height;
|
|
|
}
|
|
|
var footer = void 0;
|
|
|
if (props.footer) {
|
|
|
footer = __WEBPACK_IMPORTED_MODULE_0_react__["createElement"]("div", { className: prefixCls + '-footer', ref: _this.saveRef('footer') }, props.footer);
|
|
|
}
|
|
|
var header = void 0;
|
|
|
if (props.title) {
|
|
|
header = __WEBPACK_IMPORTED_MODULE_0_react__["createElement"]("div", { className: prefixCls + '-header', ref: _this.saveRef('header') }, __WEBPACK_IMPORTED_MODULE_0_react__["createElement"]("div", { className: prefixCls + '-title', id: _this.titleId }, props.title));
|
|
|
}
|
|
|
var closer = void 0;
|
|
|
if (closable) {
|
|
|
closer = __WEBPACK_IMPORTED_MODULE_0_react__["createElement"]("button", { type: "button", onClick: _this.close, "aria-label": "Close", className: prefixCls + '-close' }, props.closeIcon || __WEBPACK_IMPORTED_MODULE_0_react__["createElement"]("span", { className: prefixCls + '-close-x' }));
|
|
|
}
|
|
|
var style = _extends({}, props.style, dest);
|
|
|
var sentinelStyle = { width: 0, height: 0, overflow: 'hidden', outline: 'none' };
|
|
|
var transitionName = _this.getTransitionName();
|
|
|
var dialogElement = __WEBPACK_IMPORTED_MODULE_0_react__["createElement"](__WEBPACK_IMPORTED_MODULE_5__LazyRenderBox__["a" /* default */], { key: "dialog-element", role: "document", ref: _this.saveRef('dialog'), style: style, className: prefixCls + ' ' + (props.className || ''), visible: props.visible, forceRender: props.forceRender, onMouseDown: _this.onDialogMouseDown }, __WEBPACK_IMPORTED_MODULE_0_react__["createElement"]("div", { tabIndex: 0, ref: _this.saveRef('sentinelStart'), style: sentinelStyle, "aria-hidden": "true" }), __WEBPACK_IMPORTED_MODULE_0_react__["createElement"]("div", { className: prefixCls + '-content' }, closer, header, __WEBPACK_IMPORTED_MODULE_0_react__["createElement"]("div", _extends({ className: prefixCls + '-body', style: props.bodyStyle, ref: _this.saveRef('body') }, props.bodyProps), props.children), footer), __WEBPACK_IMPORTED_MODULE_0_react__["createElement"]("div", { tabIndex: 0, ref: _this.saveRef('sentinelEnd'), style: sentinelStyle, "aria-hidden": "true" }));
|
|
|
return __WEBPACK_IMPORTED_MODULE_0_react__["createElement"](__WEBPACK_IMPORTED_MODULE_4_rc_animate__["a" /* default */], { key: "dialog", showProp: "visible", onLeave: _this.onAnimateLeave, transitionName: transitionName, component: "", transitionAppear: true }, props.visible || !props.destroyOnClose ? dialogElement : null);
|
|
|
};
|
|
|
_this.getZIndexStyle = function () {
|
|
|
var style = {};
|
|
|
var props = _this.props;
|
|
|
if (props.zIndex !== undefined) {
|
|
|
style.zIndex = props.zIndex;
|
|
|
}
|
|
|
return style;
|
|
|
};
|
|
|
_this.getWrapStyle = function () {
|
|
|
return _extends({}, _this.getZIndexStyle(), _this.props.wrapStyle);
|
|
|
};
|
|
|
_this.getMaskStyle = function () {
|
|
|
return _extends({}, _this.getZIndexStyle(), _this.props.maskStyle);
|
|
|
};
|
|
|
_this.getMaskElement = function () {
|
|
|
var props = _this.props;
|
|
|
var maskElement = void 0;
|
|
|
if (props.mask) {
|
|
|
var maskTransition = _this.getMaskTransitionName();
|
|
|
maskElement = __WEBPACK_IMPORTED_MODULE_0_react__["createElement"](__WEBPACK_IMPORTED_MODULE_5__LazyRenderBox__["a" /* default */], _extends({ style: _this.getMaskStyle(), key: "mask", className: props.prefixCls + '-mask', hiddenClassName: props.prefixCls + '-mask-hidden', visible: props.visible }, props.maskProps));
|
|
|
if (maskTransition) {
|
|
|
maskElement = __WEBPACK_IMPORTED_MODULE_0_react__["createElement"](__WEBPACK_IMPORTED_MODULE_4_rc_animate__["a" /* default */], { key: "mask", showProp: "visible", transitionAppear: true, component: "", transitionName: maskTransition }, maskElement);
|
|
|
}
|
|
|
}
|
|
|
return maskElement;
|
|
|
};
|
|
|
_this.getMaskTransitionName = function () {
|
|
|
var props = _this.props;
|
|
|
var transitionName = props.maskTransitionName;
|
|
|
var animation = props.maskAnimation;
|
|
|
if (!transitionName && animation) {
|
|
|
transitionName = props.prefixCls + '-' + animation;
|
|
|
}
|
|
|
return transitionName;
|
|
|
};
|
|
|
_this.getTransitionName = function () {
|
|
|
var props = _this.props;
|
|
|
var transitionName = props.transitionName;
|
|
|
var animation = props.animation;
|
|
|
if (!transitionName && animation) {
|
|
|
transitionName = props.prefixCls + '-' + animation;
|
|
|
}
|
|
|
return transitionName;
|
|
|
};
|
|
|
_this.close = function (e) {
|
|
|
var onClose = _this.props.onClose;
|
|
|
|
|
|
if (onClose) {
|
|
|
onClose(e);
|
|
|
}
|
|
|
};
|
|
|
_this.saveRef = function (name) {
|
|
|
return function (node) {
|
|
|
_this[name] = node;
|
|
|
};
|
|
|
};
|
|
|
_this.titleId = 'rcDialogTitle' + uuid++;
|
|
|
_this.switchScrollingEffect = props.switchScrollingEffect || function () {};
|
|
|
return _this;
|
|
|
}
|
|
|
|
|
|
Dialog.prototype.componentDidMount = function componentDidMount() {
|
|
|
this.componentDidUpdate({});
|
|
|
// if forceRender is true, set element style display to be none;
|
|
|
if ((this.props.forceRender || this.props.getContainer === false && !this.props.visible) && this.wrap) {
|
|
|
this.wrap.style.display = 'none';
|
|
|
}
|
|
|
};
|
|
|
|
|
|
Dialog.prototype.componentDidUpdate = function componentDidUpdate(prevProps) {
|
|
|
var _props = this.props,
|
|
|
visible = _props.visible,
|
|
|
mask = _props.mask,
|
|
|
focusTriggerAfterClose = _props.focusTriggerAfterClose;
|
|
|
|
|
|
var mousePosition = this.props.mousePosition;
|
|
|
if (visible) {
|
|
|
// first show
|
|
|
if (!prevProps.visible) {
|
|
|
this.openTime = Date.now();
|
|
|
this.switchScrollingEffect();
|
|
|
this.tryFocus();
|
|
|
var dialogNode = __WEBPACK_IMPORTED_MODULE_1_react_dom__["findDOMNode"](this.dialog);
|
|
|
if (mousePosition) {
|
|
|
var elOffset = offset(dialogNode);
|
|
|
setTransformOrigin(dialogNode, mousePosition.x - elOffset.left + 'px ' + (mousePosition.y - elOffset.top) + 'px');
|
|
|
} else {
|
|
|
setTransformOrigin(dialogNode, '');
|
|
|
}
|
|
|
}
|
|
|
} else if (prevProps.visible) {
|
|
|
this.inTransition = true;
|
|
|
if (mask && this.lastOutSideFocusNode && focusTriggerAfterClose) {
|
|
|
try {
|
|
|
this.lastOutSideFocusNode.focus();
|
|
|
} catch (e) {
|
|
|
this.lastOutSideFocusNode = null;
|
|
|
}
|
|
|
this.lastOutSideFocusNode = null;
|
|
|
}
|
|
|
}
|
|
|
};
|
|
|
|
|
|
Dialog.prototype.componentWillUnmount = function componentWillUnmount() {
|
|
|
var _props2 = this.props,
|
|
|
visible = _props2.visible,
|
|
|
getOpenCount = _props2.getOpenCount;
|
|
|
|
|
|
if ((visible || this.inTransition) && !getOpenCount()) {
|
|
|
this.switchScrollingEffect();
|
|
|
}
|
|
|
clearTimeout(this.timeoutId);
|
|
|
};
|
|
|
|
|
|
Dialog.prototype.tryFocus = function tryFocus() {
|
|
|
if (!Object(__WEBPACK_IMPORTED_MODULE_3_rc_util_es_Dom_contains__["a" /* default */])(this.wrap, document.activeElement)) {
|
|
|
this.lastOutSideFocusNode = document.activeElement;
|
|
|
this.sentinelStart.focus();
|
|
|
}
|
|
|
};
|
|
|
|
|
|
Dialog.prototype.render = function render() {
|
|
|
var props = this.props;
|
|
|
var prefixCls = props.prefixCls,
|
|
|
maskClosable = props.maskClosable;
|
|
|
|
|
|
var style = this.getWrapStyle();
|
|
|
// clear hide display
|
|
|
// and only set display after async anim, not here for hide
|
|
|
if (props.visible) {
|
|
|
style.display = null;
|
|
|
}
|
|
|
return __WEBPACK_IMPORTED_MODULE_0_react__["createElement"]("div", { className: prefixCls + '-root' }, this.getMaskElement(), __WEBPACK_IMPORTED_MODULE_0_react__["createElement"]("div", _extends({ tabIndex: -1, onKeyDown: this.onKeyDown, className: prefixCls + '-wrap ' + (props.wrapClassName || ''), ref: this.saveRef('wrap'), onClick: maskClosable ? this.onMaskClick : null, onMouseUp: maskClosable ? this.onMaskMouseUp : null, role: "dialog", "aria-labelledby": props.title ? this.titleId : null, style: style }, props.wrapProps), this.getDialogElement()));
|
|
|
};
|
|
|
|
|
|
return Dialog;
|
|
|
}(__WEBPACK_IMPORTED_MODULE_0_react__["Component"]);
|
|
|
|
|
|
/* harmony default export */ __webpack_exports__["a"] = (Dialog);
|
|
|
|
|
|
Dialog.defaultProps = {
|
|
|
className: '',
|
|
|
mask: true,
|
|
|
visible: false,
|
|
|
keyboard: true,
|
|
|
closable: true,
|
|
|
maskClosable: true,
|
|
|
destroyOnClose: false,
|
|
|
prefixCls: 'rc-dialog',
|
|
|
focusTriggerAfterClose: true
|
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
/* 7 */
|
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
/**
|
|
|
* @ignore
|
|
|
* some key-codes definition and utils from closure-library
|
|
|
* @author yiminghe@gmail.com
|
|
|
*/
|
|
|
var KeyCode = {
|
|
|
/**
|
|
|
* MAC_ENTER
|
|
|
*/
|
|
|
MAC_ENTER: 3,
|
|
|
|
|
|
/**
|
|
|
* BACKSPACE
|
|
|
*/
|
|
|
BACKSPACE: 8,
|
|
|
|
|
|
/**
|
|
|
* TAB
|
|
|
*/
|
|
|
TAB: 9,
|
|
|
|
|
|
/**
|
|
|
* NUMLOCK on FF/Safari Mac
|
|
|
*/
|
|
|
NUM_CENTER: 12,
|
|
|
|
|
|
/**
|
|
|
* ENTER
|
|
|
*/
|
|
|
ENTER: 13,
|
|
|
|
|
|
/**
|
|
|
* SHIFT
|
|
|
*/
|
|
|
SHIFT: 16,
|
|
|
|
|
|
/**
|
|
|
* CTRL
|
|
|
*/
|
|
|
CTRL: 17,
|
|
|
|
|
|
/**
|
|
|
* ALT
|
|
|
*/
|
|
|
ALT: 18,
|
|
|
|
|
|
/**
|
|
|
* PAUSE
|
|
|
*/
|
|
|
PAUSE: 19,
|
|
|
|
|
|
/**
|
|
|
* CAPS_LOCK
|
|
|
*/
|
|
|
CAPS_LOCK: 20,
|
|
|
|
|
|
/**
|
|
|
* ESC
|
|
|
*/
|
|
|
ESC: 27,
|
|
|
|
|
|
/**
|
|
|
* SPACE
|
|
|
*/
|
|
|
SPACE: 32,
|
|
|
|
|
|
/**
|
|
|
* PAGE_UP
|
|
|
*/
|
|
|
PAGE_UP: 33,
|
|
|
|
|
|
/**
|
|
|
* PAGE_DOWN
|
|
|
*/
|
|
|
PAGE_DOWN: 34,
|
|
|
|
|
|
/**
|
|
|
* END
|
|
|
*/
|
|
|
END: 35,
|
|
|
|
|
|
/**
|
|
|
* HOME
|
|
|
*/
|
|
|
HOME: 36,
|
|
|
|
|
|
/**
|
|
|
* LEFT
|
|
|
*/
|
|
|
LEFT: 37,
|
|
|
|
|
|
/**
|
|
|
* UP
|
|
|
*/
|
|
|
UP: 38,
|
|
|
|
|
|
/**
|
|
|
* RIGHT
|
|
|
*/
|
|
|
RIGHT: 39,
|
|
|
|
|
|
/**
|
|
|
* DOWN
|
|
|
*/
|
|
|
DOWN: 40,
|
|
|
|
|
|
/**
|
|
|
* PRINT_SCREEN
|
|
|
*/
|
|
|
PRINT_SCREEN: 44,
|
|
|
|
|
|
/**
|
|
|
* INSERT
|
|
|
*/
|
|
|
INSERT: 45,
|
|
|
|
|
|
/**
|
|
|
* DELETE
|
|
|
*/
|
|
|
DELETE: 46,
|
|
|
|
|
|
/**
|
|
|
* ZERO
|
|
|
*/
|
|
|
ZERO: 48,
|
|
|
|
|
|
/**
|
|
|
* ONE
|
|
|
*/
|
|
|
ONE: 49,
|
|
|
|
|
|
/**
|
|
|
* TWO
|
|
|
*/
|
|
|
TWO: 50,
|
|
|
|
|
|
/**
|
|
|
* THREE
|
|
|
*/
|
|
|
THREE: 51,
|
|
|
|
|
|
/**
|
|
|
* FOUR
|
|
|
*/
|
|
|
FOUR: 52,
|
|
|
|
|
|
/**
|
|
|
* FIVE
|
|
|
*/
|
|
|
FIVE: 53,
|
|
|
|
|
|
/**
|
|
|
* SIX
|
|
|
*/
|
|
|
SIX: 54,
|
|
|
|
|
|
/**
|
|
|
* SEVEN
|
|
|
*/
|
|
|
SEVEN: 55,
|
|
|
|
|
|
/**
|
|
|
* EIGHT
|
|
|
*/
|
|
|
EIGHT: 56,
|
|
|
|
|
|
/**
|
|
|
* NINE
|
|
|
*/
|
|
|
NINE: 57,
|
|
|
|
|
|
/**
|
|
|
* QUESTION_MARK
|
|
|
*/
|
|
|
QUESTION_MARK: 63,
|
|
|
|
|
|
/**
|
|
|
* A
|
|
|
*/
|
|
|
A: 65,
|
|
|
|
|
|
/**
|
|
|
* B
|
|
|
*/
|
|
|
B: 66,
|
|
|
|
|
|
/**
|
|
|
* C
|
|
|
*/
|
|
|
C: 67,
|
|
|
|
|
|
/**
|
|
|
* D
|
|
|
*/
|
|
|
D: 68,
|
|
|
|
|
|
/**
|
|
|
* E
|
|
|
*/
|
|
|
E: 69,
|
|
|
|
|
|
/**
|
|
|
* F
|
|
|
*/
|
|
|
F: 70,
|
|
|
|
|
|
/**
|
|
|
* G
|
|
|
*/
|
|
|
G: 71,
|
|
|
|
|
|
/**
|
|
|
* H
|
|
|
*/
|
|
|
H: 72,
|
|
|
|
|
|
/**
|
|
|
* I
|
|
|
*/
|
|
|
I: 73,
|
|
|
|
|
|
/**
|
|
|
* J
|
|
|
*/
|
|
|
J: 74,
|
|
|
|
|
|
/**
|
|
|
* K
|
|
|
*/
|
|
|
K: 75,
|
|
|
|
|
|
/**
|
|
|
* L
|
|
|
*/
|
|
|
L: 76,
|
|
|
|
|
|
/**
|
|
|
* M
|
|
|
*/
|
|
|
M: 77,
|
|
|
|
|
|
/**
|
|
|
* N
|
|
|
*/
|
|
|
N: 78,
|
|
|
|
|
|
/**
|
|
|
* O
|
|
|
*/
|
|
|
O: 79,
|
|
|
|
|
|
/**
|
|
|
* P
|
|
|
*/
|
|
|
P: 80,
|
|
|
|
|
|
/**
|
|
|
* Q
|
|
|
*/
|
|
|
Q: 81,
|
|
|
|
|
|
/**
|
|
|
* R
|
|
|
*/
|
|
|
R: 82,
|
|
|
|
|
|
/**
|
|
|
* S
|
|
|
*/
|
|
|
S: 83,
|
|
|
|
|
|
/**
|
|
|
* T
|
|
|
*/
|
|
|
T: 84,
|
|
|
|
|
|
/**
|
|
|
* U
|
|
|
*/
|
|
|
U: 85,
|
|
|
|
|
|
/**
|
|
|
* V
|
|
|
*/
|
|
|
V: 86,
|
|
|
|
|
|
/**
|
|
|
* W
|
|
|
*/
|
|
|
W: 87,
|
|
|
|
|
|
/**
|
|
|
* X
|
|
|
*/
|
|
|
X: 88,
|
|
|
|
|
|
/**
|
|
|
* Y
|
|
|
*/
|
|
|
Y: 89,
|
|
|
|
|
|
/**
|
|
|
* Z
|
|
|
*/
|
|
|
Z: 90,
|
|
|
|
|
|
/**
|
|
|
* META
|
|
|
*/
|
|
|
META: 91,
|
|
|
|
|
|
/**
|
|
|
* WIN_KEY_RIGHT
|
|
|
*/
|
|
|
WIN_KEY_RIGHT: 92,
|
|
|
|
|
|
/**
|
|
|
* CONTEXT_MENU
|
|
|
*/
|
|
|
CONTEXT_MENU: 93,
|
|
|
|
|
|
/**
|
|
|
* NUM_ZERO
|
|
|
*/
|
|
|
NUM_ZERO: 96,
|
|
|
|
|
|
/**
|
|
|
* NUM_ONE
|
|
|
*/
|
|
|
NUM_ONE: 97,
|
|
|
|
|
|
/**
|
|
|
* NUM_TWO
|
|
|
*/
|
|
|
NUM_TWO: 98,
|
|
|
|
|
|
/**
|
|
|
* NUM_THREE
|
|
|
*/
|
|
|
NUM_THREE: 99,
|
|
|
|
|
|
/**
|
|
|
* NUM_FOUR
|
|
|
*/
|
|
|
NUM_FOUR: 100,
|
|
|
|
|
|
/**
|
|
|
* NUM_FIVE
|
|
|
*/
|
|
|
NUM_FIVE: 101,
|
|
|
|
|
|
/**
|
|
|
* NUM_SIX
|
|
|
*/
|
|
|
NUM_SIX: 102,
|
|
|
|
|
|
/**
|
|
|
* NUM_SEVEN
|
|
|
*/
|
|
|
NUM_SEVEN: 103,
|
|
|
|
|
|
/**
|
|
|
* NUM_EIGHT
|
|
|
*/
|
|
|
NUM_EIGHT: 104,
|
|
|
|
|
|
/**
|
|
|
* NUM_NINE
|
|
|
*/
|
|
|
NUM_NINE: 105,
|
|
|
|
|
|
/**
|
|
|
* NUM_MULTIPLY
|
|
|
*/
|
|
|
NUM_MULTIPLY: 106,
|
|
|
|
|
|
/**
|
|
|
* NUM_PLUS
|
|
|
*/
|
|
|
NUM_PLUS: 107,
|
|
|
|
|
|
/**
|
|
|
* NUM_MINUS
|
|
|
*/
|
|
|
NUM_MINUS: 109,
|
|
|
|
|
|
/**
|
|
|
* NUM_PERIOD
|
|
|
*/
|
|
|
NUM_PERIOD: 110,
|
|
|
|
|
|
/**
|
|
|
* NUM_DIVISION
|
|
|
*/
|
|
|
NUM_DIVISION: 111,
|
|
|
|
|
|
/**
|
|
|
* F1
|
|
|
*/
|
|
|
F1: 112,
|
|
|
|
|
|
/**
|
|
|
* F2
|
|
|
*/
|
|
|
F2: 113,
|
|
|
|
|
|
/**
|
|
|
* F3
|
|
|
*/
|
|
|
F3: 114,
|
|
|
|
|
|
/**
|
|
|
* F4
|
|
|
*/
|
|
|
F4: 115,
|
|
|
|
|
|
/**
|
|
|
* F5
|
|
|
*/
|
|
|
F5: 116,
|
|
|
|
|
|
/**
|
|
|
* F6
|
|
|
*/
|
|
|
F6: 117,
|
|
|
|
|
|
/**
|
|
|
* F7
|
|
|
*/
|
|
|
F7: 118,
|
|
|
|
|
|
/**
|
|
|
* F8
|
|
|
*/
|
|
|
F8: 119,
|
|
|
|
|
|
/**
|
|
|
* F9
|
|
|
*/
|
|
|
F9: 120,
|
|
|
|
|
|
/**
|
|
|
* F10
|
|
|
*/
|
|
|
F10: 121,
|
|
|
|
|
|
/**
|
|
|
* F11
|
|
|
*/
|
|
|
F11: 122,
|
|
|
|
|
|
/**
|
|
|
* F12
|
|
|
*/
|
|
|
F12: 123,
|
|
|
|
|
|
/**
|
|
|
* NUMLOCK
|
|
|
*/
|
|
|
NUMLOCK: 144,
|
|
|
|
|
|
/**
|
|
|
* SEMICOLON
|
|
|
*/
|
|
|
SEMICOLON: 186,
|
|
|
|
|
|
/**
|
|
|
* DASH
|
|
|
*/
|
|
|
DASH: 189,
|
|
|
|
|
|
/**
|
|
|
* EQUALS
|
|
|
*/
|
|
|
EQUALS: 187,
|
|
|
|
|
|
/**
|
|
|
* COMMA
|
|
|
*/
|
|
|
COMMA: 188,
|
|
|
|
|
|
/**
|
|
|
* PERIOD
|
|
|
*/
|
|
|
PERIOD: 190,
|
|
|
|
|
|
/**
|
|
|
* SLASH
|
|
|
*/
|
|
|
SLASH: 191,
|
|
|
|
|
|
/**
|
|
|
* APOSTROPHE
|
|
|
*/
|
|
|
APOSTROPHE: 192,
|
|
|
|
|
|
/**
|
|
|
* SINGLE_QUOTE
|
|
|
*/
|
|
|
SINGLE_QUOTE: 222,
|
|
|
|
|
|
/**
|
|
|
* OPEN_SQUARE_BRACKET
|
|
|
*/
|
|
|
OPEN_SQUARE_BRACKET: 219,
|
|
|
|
|
|
/**
|
|
|
* BACKSLASH
|
|
|
*/
|
|
|
BACKSLASH: 220,
|
|
|
|
|
|
/**
|
|
|
* CLOSE_SQUARE_BRACKET
|
|
|
*/
|
|
|
CLOSE_SQUARE_BRACKET: 221,
|
|
|
|
|
|
/**
|
|
|
* WIN_KEY
|
|
|
*/
|
|
|
WIN_KEY: 224,
|
|
|
|
|
|
/**
|
|
|
* MAC_FF_META
|
|
|
*/
|
|
|
MAC_FF_META: 224,
|
|
|
|
|
|
/**
|
|
|
* WIN_IME
|
|
|
*/
|
|
|
WIN_IME: 229,
|
|
|
// ======================== Function ========================
|
|
|
|
|
|
/**
|
|
|
* whether text and modified key is entered at the same time.
|
|
|
*/
|
|
|
isTextModifyingKeyEvent: function isTextModifyingKeyEvent(e) {
|
|
|
var keyCode = e.keyCode;
|
|
|
|
|
|
if (e.altKey && !e.ctrlKey || e.metaKey || // Function keys don't generate text
|
|
|
keyCode >= KeyCode.F1 && keyCode <= KeyCode.F12) {
|
|
|
return false;
|
|
|
} // The following keys are quite harmless, even in combination with
|
|
|
// CTRL, ALT or SHIFT.
|
|
|
|
|
|
|
|
|
switch (keyCode) {
|
|
|
case KeyCode.ALT:
|
|
|
case KeyCode.CAPS_LOCK:
|
|
|
case KeyCode.CONTEXT_MENU:
|
|
|
case KeyCode.CTRL:
|
|
|
case KeyCode.DOWN:
|
|
|
case KeyCode.END:
|
|
|
case KeyCode.ESC:
|
|
|
case KeyCode.HOME:
|
|
|
case KeyCode.INSERT:
|
|
|
case KeyCode.LEFT:
|
|
|
case KeyCode.MAC_FF_META:
|
|
|
case KeyCode.META:
|
|
|
case KeyCode.NUMLOCK:
|
|
|
case KeyCode.NUM_CENTER:
|
|
|
case KeyCode.PAGE_DOWN:
|
|
|
case KeyCode.PAGE_UP:
|
|
|
case KeyCode.PAUSE:
|
|
|
case KeyCode.PRINT_SCREEN:
|
|
|
case KeyCode.RIGHT:
|
|
|
case KeyCode.SHIFT:
|
|
|
case KeyCode.UP:
|
|
|
case KeyCode.WIN_KEY:
|
|
|
case KeyCode.WIN_KEY_RIGHT:
|
|
|
return false;
|
|
|
|
|
|
default:
|
|
|
return true;
|
|
|
}
|
|
|
},
|
|
|
|
|
|
/**
|
|
|
* whether character is entered.
|
|
|
*/
|
|
|
isCharacterKey: function isCharacterKey(keyCode) {
|
|
|
if (keyCode >= KeyCode.ZERO && keyCode <= KeyCode.NINE) {
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
if (keyCode >= KeyCode.NUM_ZERO && keyCode <= KeyCode.NUM_MULTIPLY) {
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
if (keyCode >= KeyCode.A && keyCode <= KeyCode.Z) {
|
|
|
return true;
|
|
|
} // Safari sends zero key code for non-latin characters.
|
|
|
|
|
|
|
|
|
if (window.navigator.userAgent.indexOf('WebKit') !== -1 && keyCode === 0) {
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
switch (keyCode) {
|
|
|
case KeyCode.SPACE:
|
|
|
case KeyCode.QUESTION_MARK:
|
|
|
case KeyCode.NUM_PLUS:
|
|
|
case KeyCode.NUM_MINUS:
|
|
|
case KeyCode.NUM_PERIOD:
|
|
|
case KeyCode.NUM_DIVISION:
|
|
|
case KeyCode.SEMICOLON:
|
|
|
case KeyCode.DASH:
|
|
|
case KeyCode.EQUALS:
|
|
|
case KeyCode.COMMA:
|
|
|
case KeyCode.PERIOD:
|
|
|
case KeyCode.SLASH:
|
|
|
case KeyCode.APOSTROPHE:
|
|
|
case KeyCode.SINGLE_QUOTE:
|
|
|
case KeyCode.OPEN_SQUARE_BRACKET:
|
|
|
case KeyCode.BACKSLASH:
|
|
|
case KeyCode.CLOSE_SQUARE_BRACKET:
|
|
|
return true;
|
|
|
|
|
|
default:
|
|
|
return false;
|
|
|
}
|
|
|
}
|
|
|
};
|
|
|
/* harmony default export */ __webpack_exports__["a"] = (KeyCode);
|
|
|
|
|
|
/***/ }),
|
|
|
/* 8 */
|
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
/* harmony export (immutable) */ __webpack_exports__["a"] = contains;
|
|
|
function contains(root, n) {
|
|
|
var node = n;
|
|
|
|
|
|
while (node) {
|
|
|
if (node === root) {
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
node = node.parentNode;
|
|
|
}
|
|
|
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
/* 9 */
|
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_rc_util_es_unsafeLifecyclesPolyfill__ = __webpack_require__(10);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__ChildrenUtils__ = __webpack_require__(11);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__AnimateChild__ = __webpack_require__(12);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__util_animate__ = __webpack_require__(2);
|
|
|
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
|
|
|
|
|
|
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; }; }();
|
|
|
|
|
|
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
|
|
|
|
|
|
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; }
|
|
|
|
|
|
/* eslint react/prop-types: 0 */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var defaultKey = 'rc_animate_' + Date.now();
|
|
|
|
|
|
function getChildrenFromProps(props) {
|
|
|
var children = props.children;
|
|
|
if (__WEBPACK_IMPORTED_MODULE_0_react___default.a.isValidElement(children)) {
|
|
|
if (!children.key) {
|
|
|
return __WEBPACK_IMPORTED_MODULE_0_react___default.a.cloneElement(children, {
|
|
|
key: defaultKey
|
|
|
});
|
|
|
}
|
|
|
}
|
|
|
return children;
|
|
|
}
|
|
|
|
|
|
function noop() {}
|
|
|
|
|
|
var Animate = function (_React$Component) {
|
|
|
_inherits(Animate, _React$Component);
|
|
|
|
|
|
function Animate(props) {
|
|
|
_classCallCheck(this, Animate);
|
|
|
|
|
|
var _this = _possibleConstructorReturn(this, (Animate.__proto__ || Object.getPrototypeOf(Animate)).call(this, props));
|
|
|
|
|
|
_initialiseProps.call(_this);
|
|
|
|
|
|
_this.currentlyAnimatingKeys = {};
|
|
|
_this.keysToEnter = [];
|
|
|
_this.keysToLeave = [];
|
|
|
|
|
|
_this.state = {
|
|
|
children: Object(__WEBPACK_IMPORTED_MODULE_2__ChildrenUtils__["e" /* toArrayChildren */])(getChildrenFromProps(props))
|
|
|
};
|
|
|
|
|
|
_this.childrenRefs = {};
|
|
|
return _this;
|
|
|
} // eslint-disable-line
|
|
|
|
|
|
_createClass(Animate, [{
|
|
|
key: 'componentDidMount',
|
|
|
value: function componentDidMount() {
|
|
|
var _this2 = this;
|
|
|
|
|
|
var showProp = this.props.showProp;
|
|
|
var children = this.state.children;
|
|
|
if (showProp) {
|
|
|
children = children.filter(function (child) {
|
|
|
return !!child.props[showProp];
|
|
|
});
|
|
|
}
|
|
|
children.forEach(function (child) {
|
|
|
if (child) {
|
|
|
_this2.performAppear(child.key);
|
|
|
}
|
|
|
});
|
|
|
}
|
|
|
}, {
|
|
|
key: 'componentWillReceiveProps',
|
|
|
value: function componentWillReceiveProps(nextProps) {
|
|
|
var _this3 = this;
|
|
|
|
|
|
this.nextProps = nextProps;
|
|
|
var nextChildren = Object(__WEBPACK_IMPORTED_MODULE_2__ChildrenUtils__["e" /* toArrayChildren */])(getChildrenFromProps(nextProps));
|
|
|
var props = this.props;
|
|
|
// exclusive needs immediate response
|
|
|
if (props.exclusive) {
|
|
|
Object.keys(this.currentlyAnimatingKeys).forEach(function (key) {
|
|
|
_this3.stop(key);
|
|
|
});
|
|
|
}
|
|
|
var showProp = props.showProp;
|
|
|
var currentlyAnimatingKeys = this.currentlyAnimatingKeys;
|
|
|
// last props children if exclusive
|
|
|
var currentChildren = props.exclusive ? Object(__WEBPACK_IMPORTED_MODULE_2__ChildrenUtils__["e" /* toArrayChildren */])(getChildrenFromProps(props)) : this.state.children;
|
|
|
// in case destroy in showProp mode
|
|
|
var newChildren = [];
|
|
|
if (showProp) {
|
|
|
currentChildren.forEach(function (currentChild) {
|
|
|
var nextChild = currentChild && Object(__WEBPACK_IMPORTED_MODULE_2__ChildrenUtils__["a" /* findChildInChildrenByKey */])(nextChildren, currentChild.key);
|
|
|
var newChild = void 0;
|
|
|
if ((!nextChild || !nextChild.props[showProp]) && currentChild.props[showProp]) {
|
|
|
newChild = __WEBPACK_IMPORTED_MODULE_0_react___default.a.cloneElement(nextChild || currentChild, _defineProperty({}, showProp, true));
|
|
|
} else {
|
|
|
newChild = nextChild;
|
|
|
}
|
|
|
if (newChild) {
|
|
|
newChildren.push(newChild);
|
|
|
}
|
|
|
});
|
|
|
nextChildren.forEach(function (nextChild) {
|
|
|
if (!nextChild || !Object(__WEBPACK_IMPORTED_MODULE_2__ChildrenUtils__["a" /* findChildInChildrenByKey */])(currentChildren, nextChild.key)) {
|
|
|
newChildren.push(nextChild);
|
|
|
}
|
|
|
});
|
|
|
} else {
|
|
|
newChildren = Object(__WEBPACK_IMPORTED_MODULE_2__ChildrenUtils__["d" /* mergeChildren */])(currentChildren, nextChildren);
|
|
|
}
|
|
|
|
|
|
// need render to avoid update
|
|
|
this.setState({
|
|
|
children: newChildren
|
|
|
});
|
|
|
|
|
|
nextChildren.forEach(function (child) {
|
|
|
var key = child && child.key;
|
|
|
if (child && currentlyAnimatingKeys[key]) {
|
|
|
return;
|
|
|
}
|
|
|
var hasPrev = child && Object(__WEBPACK_IMPORTED_MODULE_2__ChildrenUtils__["a" /* findChildInChildrenByKey */])(currentChildren, key);
|
|
|
if (showProp) {
|
|
|
var showInNext = child.props[showProp];
|
|
|
if (hasPrev) {
|
|
|
var showInNow = Object(__WEBPACK_IMPORTED_MODULE_2__ChildrenUtils__["b" /* findShownChildInChildrenByKey */])(currentChildren, key, showProp);
|
|
|
if (!showInNow && showInNext) {
|
|
|
_this3.keysToEnter.push(key);
|
|
|
}
|
|
|
} else if (showInNext) {
|
|
|
_this3.keysToEnter.push(key);
|
|
|
}
|
|
|
} else if (!hasPrev) {
|
|
|
_this3.keysToEnter.push(key);
|
|
|
}
|
|
|
});
|
|
|
|
|
|
currentChildren.forEach(function (child) {
|
|
|
var key = child && child.key;
|
|
|
if (child && currentlyAnimatingKeys[key]) {
|
|
|
return;
|
|
|
}
|
|
|
var hasNext = child && Object(__WEBPACK_IMPORTED_MODULE_2__ChildrenUtils__["a" /* findChildInChildrenByKey */])(nextChildren, key);
|
|
|
if (showProp) {
|
|
|
var showInNow = child.props[showProp];
|
|
|
if (hasNext) {
|
|
|
var showInNext = Object(__WEBPACK_IMPORTED_MODULE_2__ChildrenUtils__["b" /* findShownChildInChildrenByKey */])(nextChildren, key, showProp);
|
|
|
if (!showInNext && showInNow) {
|
|
|
_this3.keysToLeave.push(key);
|
|
|
}
|
|
|
} else if (showInNow) {
|
|
|
_this3.keysToLeave.push(key);
|
|
|
}
|
|
|
} else if (!hasNext) {
|
|
|
_this3.keysToLeave.push(key);
|
|
|
}
|
|
|
});
|
|
|
}
|
|
|
}, {
|
|
|
key: 'componentDidUpdate',
|
|
|
value: function componentDidUpdate() {
|
|
|
var keysToEnter = this.keysToEnter;
|
|
|
this.keysToEnter = [];
|
|
|
keysToEnter.forEach(this.performEnter);
|
|
|
var keysToLeave = this.keysToLeave;
|
|
|
this.keysToLeave = [];
|
|
|
keysToLeave.forEach(this.performLeave);
|
|
|
}
|
|
|
}, {
|
|
|
key: 'isValidChildByKey',
|
|
|
value: function isValidChildByKey(currentChildren, key) {
|
|
|
var showProp = this.props.showProp;
|
|
|
if (showProp) {
|
|
|
return Object(__WEBPACK_IMPORTED_MODULE_2__ChildrenUtils__["b" /* findShownChildInChildrenByKey */])(currentChildren, key, showProp);
|
|
|
}
|
|
|
return Object(__WEBPACK_IMPORTED_MODULE_2__ChildrenUtils__["a" /* findChildInChildrenByKey */])(currentChildren, key);
|
|
|
}
|
|
|
}, {
|
|
|
key: 'stop',
|
|
|
value: function stop(key) {
|
|
|
delete this.currentlyAnimatingKeys[key];
|
|
|
var component = this.childrenRefs[key];
|
|
|
if (component) {
|
|
|
component.stop();
|
|
|
}
|
|
|
}
|
|
|
}, {
|
|
|
key: 'render',
|
|
|
value: function render() {
|
|
|
var _this4 = this;
|
|
|
|
|
|
var props = this.props;
|
|
|
this.nextProps = props;
|
|
|
var stateChildren = this.state.children;
|
|
|
var children = null;
|
|
|
if (stateChildren) {
|
|
|
children = stateChildren.map(function (child) {
|
|
|
if (child === null || child === undefined) {
|
|
|
return child;
|
|
|
}
|
|
|
if (!child.key) {
|
|
|
throw new Error('must set key for <rc-animate> children');
|
|
|
}
|
|
|
return __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(
|
|
|
__WEBPACK_IMPORTED_MODULE_3__AnimateChild__["a" /* default */],
|
|
|
{
|
|
|
key: child.key,
|
|
|
ref: function ref(node) {
|
|
|
_this4.childrenRefs[child.key] = node;
|
|
|
},
|
|
|
animation: props.animation,
|
|
|
transitionName: props.transitionName,
|
|
|
transitionEnter: props.transitionEnter,
|
|
|
transitionAppear: props.transitionAppear,
|
|
|
transitionLeave: props.transitionLeave
|
|
|
},
|
|
|
child
|
|
|
);
|
|
|
});
|
|
|
}
|
|
|
var Component = props.component;
|
|
|
if (Component) {
|
|
|
var passedProps = props;
|
|
|
if (typeof Component === 'string') {
|
|
|
passedProps = _extends({
|
|
|
className: props.className,
|
|
|
style: props.style
|
|
|
}, props.componentProps);
|
|
|
}
|
|
|
return __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(
|
|
|
Component,
|
|
|
passedProps,
|
|
|
children
|
|
|
);
|
|
|
}
|
|
|
return children[0] || null;
|
|
|
}
|
|
|
}]);
|
|
|
|
|
|
return Animate;
|
|
|
}(__WEBPACK_IMPORTED_MODULE_0_react___default.a.Component);
|
|
|
|
|
|
Animate.isAnimate = true;
|
|
|
Animate.defaultProps = {
|
|
|
animation: {},
|
|
|
component: 'span',
|
|
|
componentProps: {},
|
|
|
transitionEnter: true,
|
|
|
transitionLeave: true,
|
|
|
transitionAppear: false,
|
|
|
onEnd: noop,
|
|
|
onEnter: noop,
|
|
|
onLeave: noop,
|
|
|
onAppear: noop
|
|
|
};
|
|
|
|
|
|
var _initialiseProps = function _initialiseProps() {
|
|
|
var _this5 = this;
|
|
|
|
|
|
this.performEnter = function (key) {
|
|
|
// may already remove by exclusive
|
|
|
if (_this5.childrenRefs[key]) {
|
|
|
_this5.currentlyAnimatingKeys[key] = true;
|
|
|
_this5.childrenRefs[key].componentWillEnter(_this5.handleDoneAdding.bind(_this5, key, 'enter'));
|
|
|
}
|
|
|
};
|
|
|
|
|
|
this.performAppear = function (key) {
|
|
|
if (_this5.childrenRefs[key]) {
|
|
|
_this5.currentlyAnimatingKeys[key] = true;
|
|
|
_this5.childrenRefs[key].componentWillAppear(_this5.handleDoneAdding.bind(_this5, key, 'appear'));
|
|
|
}
|
|
|
};
|
|
|
|
|
|
this.handleDoneAdding = function (key, type) {
|
|
|
var props = _this5.props;
|
|
|
delete _this5.currentlyAnimatingKeys[key];
|
|
|
// if update on exclusive mode, skip check
|
|
|
if (props.exclusive && props !== _this5.nextProps) {
|
|
|
return;
|
|
|
}
|
|
|
var currentChildren = Object(__WEBPACK_IMPORTED_MODULE_2__ChildrenUtils__["e" /* toArrayChildren */])(getChildrenFromProps(props));
|
|
|
if (!_this5.isValidChildByKey(currentChildren, key)) {
|
|
|
// exclusive will not need this
|
|
|
_this5.performLeave(key);
|
|
|
} else if (type === 'appear') {
|
|
|
if (__WEBPACK_IMPORTED_MODULE_4__util_animate__["a" /* default */].allowAppearCallback(props)) {
|
|
|
props.onAppear(key);
|
|
|
props.onEnd(key, true);
|
|
|
}
|
|
|
} else if (__WEBPACK_IMPORTED_MODULE_4__util_animate__["a" /* default */].allowEnterCallback(props)) {
|
|
|
props.onEnter(key);
|
|
|
props.onEnd(key, true);
|
|
|
}
|
|
|
};
|
|
|
|
|
|
this.performLeave = function (key) {
|
|
|
// may already remove by exclusive
|
|
|
if (_this5.childrenRefs[key]) {
|
|
|
_this5.currentlyAnimatingKeys[key] = true;
|
|
|
_this5.childrenRefs[key].componentWillLeave(_this5.handleDoneLeaving.bind(_this5, key));
|
|
|
}
|
|
|
};
|
|
|
|
|
|
this.handleDoneLeaving = function (key) {
|
|
|
var props = _this5.props;
|
|
|
delete _this5.currentlyAnimatingKeys[key];
|
|
|
// if update on exclusive mode, skip check
|
|
|
if (props.exclusive && props !== _this5.nextProps) {
|
|
|
return;
|
|
|
}
|
|
|
var currentChildren = Object(__WEBPACK_IMPORTED_MODULE_2__ChildrenUtils__["e" /* toArrayChildren */])(getChildrenFromProps(props));
|
|
|
// in case state change is too fast
|
|
|
if (_this5.isValidChildByKey(currentChildren, key)) {
|
|
|
_this5.performEnter(key);
|
|
|
} else {
|
|
|
var end = function end() {
|
|
|
if (__WEBPACK_IMPORTED_MODULE_4__util_animate__["a" /* default */].allowLeaveCallback(props)) {
|
|
|
props.onLeave(key);
|
|
|
props.onEnd(key, false);
|
|
|
}
|
|
|
};
|
|
|
if (!Object(__WEBPACK_IMPORTED_MODULE_2__ChildrenUtils__["c" /* isSameChildren */])(_this5.state.children, currentChildren, props.showProp)) {
|
|
|
_this5.setState({
|
|
|
children: currentChildren
|
|
|
}, end);
|
|
|
} else {
|
|
|
end();
|
|
|
}
|
|
|
}
|
|
|
};
|
|
|
};
|
|
|
|
|
|
/* harmony default export */ __webpack_exports__["a"] = (Object(__WEBPACK_IMPORTED_MODULE_1_rc_util_es_unsafeLifecyclesPolyfill__["a" /* default */])(Animate));
|
|
|
|
|
|
/***/ }),
|
|
|
/* 10 */
|
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__);
|
|
|
|
|
|
|
|
|
var unsafeLifecyclesPolyfill = function unsafeLifecyclesPolyfill(Component) {
|
|
|
var prototype = Component.prototype;
|
|
|
|
|
|
if (!prototype || !prototype.isReactComponent) {
|
|
|
throw new Error('Can only polyfill class components');
|
|
|
} // only handle componentWillReceiveProps
|
|
|
|
|
|
|
|
|
if (typeof prototype.componentWillReceiveProps !== 'function') {
|
|
|
return Component;
|
|
|
} // In React 16.9, React.Profiler was introduced together with UNSAFE_componentWillReceiveProps
|
|
|
// https://reactjs.org/blog/2019/08/08/react-v16.9.0.html#performance-measurements-with-reactprofiler
|
|
|
|
|
|
|
|
|
if (!__WEBPACK_IMPORTED_MODULE_0_react___default.a.Profiler) {
|
|
|
return Component;
|
|
|
} // Here polyfill get started
|
|
|
|
|
|
|
|
|
prototype.UNSAFE_componentWillReceiveProps = prototype.componentWillReceiveProps;
|
|
|
delete prototype.componentWillReceiveProps;
|
|
|
return Component;
|
|
|
};
|
|
|
|
|
|
/* harmony default export */ __webpack_exports__["a"] = (unsafeLifecyclesPolyfill);
|
|
|
|
|
|
/***/ }),
|
|
|
/* 11 */
|
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
/* harmony export (immutable) */ __webpack_exports__["e"] = toArrayChildren;
|
|
|
/* harmony export (immutable) */ __webpack_exports__["a"] = findChildInChildrenByKey;
|
|
|
/* harmony export (immutable) */ __webpack_exports__["b"] = findShownChildInChildrenByKey;
|
|
|
/* unused harmony export findHiddenChildInChildrenByKey */
|
|
|
/* harmony export (immutable) */ __webpack_exports__["c"] = isSameChildren;
|
|
|
/* harmony export (immutable) */ __webpack_exports__["d"] = mergeChildren;
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__);
|
|
|
|
|
|
|
|
|
function toArrayChildren(children) {
|
|
|
var ret = [];
|
|
|
__WEBPACK_IMPORTED_MODULE_0_react___default.a.Children.forEach(children, function (child) {
|
|
|
ret.push(child);
|
|
|
});
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
function findChildInChildrenByKey(children, key) {
|
|
|
var ret = null;
|
|
|
if (children) {
|
|
|
children.forEach(function (child) {
|
|
|
if (ret) {
|
|
|
return;
|
|
|
}
|
|
|
if (child && child.key === key) {
|
|
|
ret = child;
|
|
|
}
|
|
|
});
|
|
|
}
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
function findShownChildInChildrenByKey(children, key, showProp) {
|
|
|
var ret = null;
|
|
|
if (children) {
|
|
|
children.forEach(function (child) {
|
|
|
if (child && child.key === key && child.props[showProp]) {
|
|
|
if (ret) {
|
|
|
throw new Error('two child with same key for <rc-animate> children');
|
|
|
}
|
|
|
ret = child;
|
|
|
}
|
|
|
});
|
|
|
}
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
function findHiddenChildInChildrenByKey(children, key, showProp) {
|
|
|
var found = 0;
|
|
|
if (children) {
|
|
|
children.forEach(function (child) {
|
|
|
if (found) {
|
|
|
return;
|
|
|
}
|
|
|
found = child && child.key === key && !child.props[showProp];
|
|
|
});
|
|
|
}
|
|
|
return found;
|
|
|
}
|
|
|
|
|
|
function isSameChildren(c1, c2, showProp) {
|
|
|
var same = c1.length === c2.length;
|
|
|
if (same) {
|
|
|
c1.forEach(function (child, index) {
|
|
|
var child2 = c2[index];
|
|
|
if (child && child2) {
|
|
|
if (child && !child2 || !child && child2) {
|
|
|
same = false;
|
|
|
} else if (child.key !== child2.key) {
|
|
|
same = false;
|
|
|
} else if (showProp && child.props[showProp] !== child2.props[showProp]) {
|
|
|
same = false;
|
|
|
}
|
|
|
}
|
|
|
});
|
|
|
}
|
|
|
return same;
|
|
|
}
|
|
|
|
|
|
function mergeChildren(prev, next) {
|
|
|
var ret = [];
|
|
|
|
|
|
// For each key of `next`, the list of keys to insert before that key in
|
|
|
// the combined list
|
|
|
var nextChildrenPending = {};
|
|
|
var pendingChildren = [];
|
|
|
prev.forEach(function (child) {
|
|
|
if (child && findChildInChildrenByKey(next, child.key)) {
|
|
|
if (pendingChildren.length) {
|
|
|
nextChildrenPending[child.key] = pendingChildren;
|
|
|
pendingChildren = [];
|
|
|
}
|
|
|
} else {
|
|
|
pendingChildren.push(child);
|
|
|
}
|
|
|
});
|
|
|
|
|
|
next.forEach(function (child) {
|
|
|
if (child && Object.prototype.hasOwnProperty.call(nextChildrenPending, child.key)) {
|
|
|
ret = ret.concat(nextChildrenPending[child.key]);
|
|
|
}
|
|
|
ret.push(child);
|
|
|
});
|
|
|
|
|
|
ret = ret.concat(pendingChildren);
|
|
|
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
/* 12 */
|
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_react_dom__ = __webpack_require__(1);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_react_dom___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_react_dom__);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__ant_design_css_animation__ = __webpack_require__(13);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__util_animate__ = __webpack_require__(2);
|
|
|
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; }; }();
|
|
|
|
|
|
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; }
|
|
|
|
|
|
/* eslint react/prop-types: 0 */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var transitionMap = {
|
|
|
enter: 'transitionEnter',
|
|
|
appear: 'transitionAppear',
|
|
|
leave: 'transitionLeave'
|
|
|
};
|
|
|
|
|
|
var AnimateChild = function (_React$Component) {
|
|
|
_inherits(AnimateChild, _React$Component);
|
|
|
|
|
|
function AnimateChild() {
|
|
|
_classCallCheck(this, AnimateChild);
|
|
|
|
|
|
return _possibleConstructorReturn(this, (AnimateChild.__proto__ || Object.getPrototypeOf(AnimateChild)).apply(this, arguments));
|
|
|
}
|
|
|
|
|
|
_createClass(AnimateChild, [{
|
|
|
key: 'componentWillUnmount',
|
|
|
value: function componentWillUnmount() {
|
|
|
this.stop();
|
|
|
}
|
|
|
}, {
|
|
|
key: 'componentWillEnter',
|
|
|
value: function componentWillEnter(done) {
|
|
|
if (__WEBPACK_IMPORTED_MODULE_3__util_animate__["a" /* default */].isEnterSupported(this.props)) {
|
|
|
this.transition('enter', done);
|
|
|
} else {
|
|
|
done();
|
|
|
}
|
|
|
}
|
|
|
}, {
|
|
|
key: 'componentWillAppear',
|
|
|
value: function componentWillAppear(done) {
|
|
|
if (__WEBPACK_IMPORTED_MODULE_3__util_animate__["a" /* default */].isAppearSupported(this.props)) {
|
|
|
this.transition('appear', done);
|
|
|
} else {
|
|
|
done();
|
|
|
}
|
|
|
}
|
|
|
}, {
|
|
|
key: 'componentWillLeave',
|
|
|
value: function componentWillLeave(done) {
|
|
|
if (__WEBPACK_IMPORTED_MODULE_3__util_animate__["a" /* default */].isLeaveSupported(this.props)) {
|
|
|
this.transition('leave', done);
|
|
|
} else {
|
|
|
// always sync, do not interupt with react component life cycle
|
|
|
// update hidden -> animate hidden ->
|
|
|
// didUpdate -> animate leave -> unmount (if animate is none)
|
|
|
done();
|
|
|
}
|
|
|
}
|
|
|
}, {
|
|
|
key: 'transition',
|
|
|
value: function transition(animationType, finishCallback) {
|
|
|
var _this2 = this;
|
|
|
|
|
|
var node = __WEBPACK_IMPORTED_MODULE_1_react_dom___default.a.findDOMNode(this);
|
|
|
var props = this.props;
|
|
|
var transitionName = props.transitionName;
|
|
|
var nameIsObj = typeof transitionName === 'object';
|
|
|
this.stop();
|
|
|
var end = function end() {
|
|
|
_this2.stopper = null;
|
|
|
finishCallback();
|
|
|
};
|
|
|
if ((__WEBPACK_IMPORTED_MODULE_2__ant_design_css_animation__["b" /* isCssAnimationSupported */] || !props.animation[animationType]) && transitionName && props[transitionMap[animationType]]) {
|
|
|
var name = nameIsObj ? transitionName[animationType] : transitionName + '-' + animationType;
|
|
|
var activeName = name + '-active';
|
|
|
if (nameIsObj && transitionName[animationType + 'Active']) {
|
|
|
activeName = transitionName[animationType + 'Active'];
|
|
|
}
|
|
|
this.stopper = Object(__WEBPACK_IMPORTED_MODULE_2__ant_design_css_animation__["a" /* default */])(node, {
|
|
|
name: name,
|
|
|
active: activeName
|
|
|
}, end);
|
|
|
} else {
|
|
|
this.stopper = props.animation[animationType](node, end);
|
|
|
}
|
|
|
}
|
|
|
}, {
|
|
|
key: 'stop',
|
|
|
value: function stop() {
|
|
|
var stopper = this.stopper;
|
|
|
if (stopper) {
|
|
|
this.stopper = null;
|
|
|
stopper.stop();
|
|
|
}
|
|
|
}
|
|
|
}, {
|
|
|
key: 'render',
|
|
|
value: function render() {
|
|
|
return this.props.children;
|
|
|
}
|
|
|
}]);
|
|
|
|
|
|
return AnimateChild;
|
|
|
}(__WEBPACK_IMPORTED_MODULE_0_react___default.a.Component);
|
|
|
|
|
|
/* harmony default export */ __webpack_exports__["a"] = (AnimateChild);
|
|
|
|
|
|
/***/ }),
|
|
|
/* 13 */
|
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return isCssAnimationSupported; });
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__Event__ = __webpack_require__(14);
|
|
|
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
|
|
|
|
|
|
|
|
|
|
|
|
var isCssAnimationSupported = __WEBPACK_IMPORTED_MODULE_0__Event__["a" /* default */].endEvents.length !== 0;
|
|
|
var capitalPrefixes = ['Webkit', 'Moz', 'O',
|
|
|
// ms is special .... !
|
|
|
'ms'];
|
|
|
var prefixes = ['-webkit-', '-moz-', '-o-', 'ms-', ''];
|
|
|
|
|
|
function getStyleProperty(node, name) {
|
|
|
// old ff need null, https://developer.mozilla.org/en-US/docs/Web/API/Window/getComputedStyle
|
|
|
var style = window.getComputedStyle(node, null);
|
|
|
var ret = '';
|
|
|
for (var i = 0; i < prefixes.length; i++) {
|
|
|
ret = style.getPropertyValue(prefixes[i] + name);
|
|
|
if (ret) {
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
function fixBrowserByTimeout(node) {
|
|
|
if (isCssAnimationSupported) {
|
|
|
var transitionDelay = parseFloat(getStyleProperty(node, 'transition-delay')) || 0;
|
|
|
var transitionDuration = parseFloat(getStyleProperty(node, 'transition-duration')) || 0;
|
|
|
var animationDelay = parseFloat(getStyleProperty(node, 'animation-delay')) || 0;
|
|
|
var animationDuration = parseFloat(getStyleProperty(node, 'animation-duration')) || 0;
|
|
|
var time = Math.max(transitionDuration + transitionDelay, animationDuration + animationDelay);
|
|
|
// sometimes, browser bug
|
|
|
node.rcEndAnimTimeout = setTimeout(function () {
|
|
|
node.rcEndAnimTimeout = null;
|
|
|
if (node.rcEndListener) {
|
|
|
node.rcEndListener();
|
|
|
}
|
|
|
}, time * 1000 + 200);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function clearBrowserBugTimeout(node) {
|
|
|
if (node.rcEndAnimTimeout) {
|
|
|
clearTimeout(node.rcEndAnimTimeout);
|
|
|
node.rcEndAnimTimeout = null;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
var cssAnimation = function cssAnimation(node, transitionName, endCallback) {
|
|
|
var nameIsObj = (typeof transitionName === 'undefined' ? 'undefined' : _typeof(transitionName)) === 'object';
|
|
|
var className = nameIsObj ? transitionName.name : transitionName;
|
|
|
var activeClassName = nameIsObj ? transitionName.active : transitionName + '-active';
|
|
|
var end = endCallback;
|
|
|
var start = void 0;
|
|
|
var active = void 0;
|
|
|
|
|
|
if (endCallback && Object.prototype.toString.call(endCallback) === '[object Object]') {
|
|
|
end = endCallback.end;
|
|
|
start = endCallback.start;
|
|
|
active = endCallback.active;
|
|
|
}
|
|
|
|
|
|
if (node.rcEndListener) {
|
|
|
node.rcEndListener();
|
|
|
}
|
|
|
|
|
|
node.rcEndListener = function (e) {
|
|
|
if (e && e.target !== node) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
if (node.rcAnimTimeout) {
|
|
|
clearTimeout(node.rcAnimTimeout);
|
|
|
node.rcAnimTimeout = null;
|
|
|
}
|
|
|
|
|
|
clearBrowserBugTimeout(node);
|
|
|
|
|
|
node.classList.remove(className);
|
|
|
node.classList.remove(activeClassName);
|
|
|
|
|
|
__WEBPACK_IMPORTED_MODULE_0__Event__["a" /* default */].removeEndEventListener(node, node.rcEndListener);
|
|
|
node.rcEndListener = null;
|
|
|
|
|
|
// Usually this optional end is used for informing an owner of
|
|
|
// a leave animation and telling it to remove the child.
|
|
|
if (end) {
|
|
|
end();
|
|
|
}
|
|
|
};
|
|
|
|
|
|
__WEBPACK_IMPORTED_MODULE_0__Event__["a" /* default */].addEndEventListener(node, node.rcEndListener);
|
|
|
|
|
|
if (start) {
|
|
|
start();
|
|
|
}
|
|
|
node.classList.add(className);
|
|
|
|
|
|
node.rcAnimTimeout = setTimeout(function () {
|
|
|
node.rcAnimTimeout = null;
|
|
|
node.classList.add(activeClassName);
|
|
|
if (active) {
|
|
|
setTimeout(active, 0);
|
|
|
}
|
|
|
fixBrowserByTimeout(node);
|
|
|
// 30ms for firefox
|
|
|
}, 30);
|
|
|
|
|
|
return {
|
|
|
stop: function stop() {
|
|
|
if (node.rcEndListener) {
|
|
|
node.rcEndListener();
|
|
|
}
|
|
|
}
|
|
|
};
|
|
|
};
|
|
|
|
|
|
cssAnimation.style = function (node, style, callback) {
|
|
|
if (node.rcEndListener) {
|
|
|
node.rcEndListener();
|
|
|
}
|
|
|
|
|
|
node.rcEndListener = function (e) {
|
|
|
if (e && e.target !== node) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
if (node.rcAnimTimeout) {
|
|
|
clearTimeout(node.rcAnimTimeout);
|
|
|
node.rcAnimTimeout = null;
|
|
|
}
|
|
|
|
|
|
clearBrowserBugTimeout(node);
|
|
|
|
|
|
__WEBPACK_IMPORTED_MODULE_0__Event__["a" /* default */].removeEndEventListener(node, node.rcEndListener);
|
|
|
node.rcEndListener = null;
|
|
|
|
|
|
// Usually this optional callback is used for informing an owner of
|
|
|
// a leave animation and telling it to remove the child.
|
|
|
if (callback) {
|
|
|
callback();
|
|
|
}
|
|
|
};
|
|
|
|
|
|
__WEBPACK_IMPORTED_MODULE_0__Event__["a" /* default */].addEndEventListener(node, node.rcEndListener);
|
|
|
|
|
|
node.rcAnimTimeout = setTimeout(function () {
|
|
|
for (var s in style) {
|
|
|
if (style.hasOwnProperty(s)) {
|
|
|
node.style[s] = style[s];
|
|
|
}
|
|
|
}
|
|
|
node.rcAnimTimeout = null;
|
|
|
fixBrowserByTimeout(node);
|
|
|
}, 0);
|
|
|
};
|
|
|
|
|
|
cssAnimation.setTransition = function (node, p, value) {
|
|
|
var property = p;
|
|
|
var v = value;
|
|
|
if (value === undefined) {
|
|
|
v = property;
|
|
|
property = '';
|
|
|
}
|
|
|
property = property || '';
|
|
|
capitalPrefixes.forEach(function (prefix) {
|
|
|
node.style[prefix + 'Transition' + property] = v;
|
|
|
});
|
|
|
};
|
|
|
|
|
|
cssAnimation.isCssAnimationSupported = isCssAnimationSupported;
|
|
|
|
|
|
|
|
|
|
|
|
/* harmony default export */ __webpack_exports__["a"] = (cssAnimation);
|
|
|
|
|
|
/***/ }),
|
|
|
/* 14 */
|
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
var START_EVENT_NAME_MAP = {
|
|
|
transitionstart: {
|
|
|
transition: 'transitionstart',
|
|
|
WebkitTransition: 'webkitTransitionStart',
|
|
|
MozTransition: 'mozTransitionStart',
|
|
|
OTransition: 'oTransitionStart',
|
|
|
msTransition: 'MSTransitionStart'
|
|
|
},
|
|
|
|
|
|
animationstart: {
|
|
|
animation: 'animationstart',
|
|
|
WebkitAnimation: 'webkitAnimationStart',
|
|
|
MozAnimation: 'mozAnimationStart',
|
|
|
OAnimation: 'oAnimationStart',
|
|
|
msAnimation: 'MSAnimationStart'
|
|
|
}
|
|
|
};
|
|
|
|
|
|
var END_EVENT_NAME_MAP = {
|
|
|
transitionend: {
|
|
|
transition: 'transitionend',
|
|
|
WebkitTransition: 'webkitTransitionEnd',
|
|
|
MozTransition: 'mozTransitionEnd',
|
|
|
OTransition: 'oTransitionEnd',
|
|
|
msTransition: 'MSTransitionEnd'
|
|
|
},
|
|
|
|
|
|
animationend: {
|
|
|
animation: 'animationend',
|
|
|
WebkitAnimation: 'webkitAnimationEnd',
|
|
|
MozAnimation: 'mozAnimationEnd',
|
|
|
OAnimation: 'oAnimationEnd',
|
|
|
msAnimation: 'MSAnimationEnd'
|
|
|
}
|
|
|
};
|
|
|
|
|
|
var startEvents = [];
|
|
|
var endEvents = [];
|
|
|
|
|
|
function detectEvents() {
|
|
|
var testEl = document.createElement('div');
|
|
|
var style = testEl.style;
|
|
|
|
|
|
if (!('AnimationEvent' in window)) {
|
|
|
delete START_EVENT_NAME_MAP.animationstart.animation;
|
|
|
delete END_EVENT_NAME_MAP.animationend.animation;
|
|
|
}
|
|
|
|
|
|
if (!('TransitionEvent' in window)) {
|
|
|
delete START_EVENT_NAME_MAP.transitionstart.transition;
|
|
|
delete END_EVENT_NAME_MAP.transitionend.transition;
|
|
|
}
|
|
|
|
|
|
function process(EVENT_NAME_MAP, events) {
|
|
|
for (var baseEventName in EVENT_NAME_MAP) {
|
|
|
if (EVENT_NAME_MAP.hasOwnProperty(baseEventName)) {
|
|
|
var baseEvents = EVENT_NAME_MAP[baseEventName];
|
|
|
for (var styleName in baseEvents) {
|
|
|
if (styleName in style) {
|
|
|
events.push(baseEvents[styleName]);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
process(START_EVENT_NAME_MAP, startEvents);
|
|
|
process(END_EVENT_NAME_MAP, endEvents);
|
|
|
}
|
|
|
|
|
|
if (typeof window !== 'undefined' && typeof document !== 'undefined') {
|
|
|
detectEvents();
|
|
|
}
|
|
|
|
|
|
function addEventListener(node, eventName, eventListener) {
|
|
|
node.addEventListener(eventName, eventListener, false);
|
|
|
}
|
|
|
|
|
|
function removeEventListener(node, eventName, eventListener) {
|
|
|
node.removeEventListener(eventName, eventListener, false);
|
|
|
}
|
|
|
|
|
|
var TransitionEvents = {
|
|
|
// Start events
|
|
|
startEvents: startEvents,
|
|
|
|
|
|
addStartEventListener: function addStartEventListener(node, eventListener) {
|
|
|
if (startEvents.length === 0) {
|
|
|
window.setTimeout(eventListener, 0);
|
|
|
return;
|
|
|
}
|
|
|
startEvents.forEach(function (startEvent) {
|
|
|
addEventListener(node, startEvent, eventListener);
|
|
|
});
|
|
|
},
|
|
|
removeStartEventListener: function removeStartEventListener(node, eventListener) {
|
|
|
if (startEvents.length === 0) {
|
|
|
return;
|
|
|
}
|
|
|
startEvents.forEach(function (startEvent) {
|
|
|
removeEventListener(node, startEvent, eventListener);
|
|
|
});
|
|
|
},
|
|
|
|
|
|
|
|
|
// End events
|
|
|
endEvents: endEvents,
|
|
|
|
|
|
addEndEventListener: function addEndEventListener(node, eventListener) {
|
|
|
if (endEvents.length === 0) {
|
|
|
window.setTimeout(eventListener, 0);
|
|
|
return;
|
|
|
}
|
|
|
endEvents.forEach(function (endEvent) {
|
|
|
addEventListener(node, endEvent, eventListener);
|
|
|
});
|
|
|
},
|
|
|
removeEndEventListener: function removeEndEventListener(node, eventListener) {
|
|
|
if (endEvents.length === 0) {
|
|
|
return;
|
|
|
}
|
|
|
endEvents.forEach(function (endEvent) {
|
|
|
removeEventListener(node, endEvent, eventListener);
|
|
|
});
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/* harmony default export */ __webpack_exports__["a"] = (TransitionEvents);
|
|
|
|
|
|
/***/ }),
|
|
|
/* 15 */
|
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__);
|
|
|
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } 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 __rest = this && this.__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) t[p[i]] = s[p[i]];
|
|
|
}return t;
|
|
|
};
|
|
|
|
|
|
|
|
|
var LazyRenderBox = function (_React$Component) {
|
|
|
_inherits(LazyRenderBox, _React$Component);
|
|
|
|
|
|
function LazyRenderBox() {
|
|
|
_classCallCheck(this, LazyRenderBox);
|
|
|
|
|
|
return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
|
|
|
}
|
|
|
|
|
|
LazyRenderBox.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {
|
|
|
if (nextProps.forceRender) {
|
|
|
return true;
|
|
|
}
|
|
|
return !!nextProps.hiddenClassName || !!nextProps.visible;
|
|
|
};
|
|
|
|
|
|
LazyRenderBox.prototype.render = function render() {
|
|
|
var _a = this.props,
|
|
|
className = _a.className,
|
|
|
hiddenClassName = _a.hiddenClassName,
|
|
|
visible = _a.visible,
|
|
|
forceRender = _a.forceRender,
|
|
|
restProps = __rest(_a, ["className", "hiddenClassName", "visible", "forceRender"]);
|
|
|
var useClassName = className;
|
|
|
if (!!hiddenClassName && !visible) {
|
|
|
useClassName += " " + hiddenClassName;
|
|
|
}
|
|
|
return __WEBPACK_IMPORTED_MODULE_0_react__["createElement"]("div", _extends({}, restProps, { className: useClassName }));
|
|
|
};
|
|
|
|
|
|
return LazyRenderBox;
|
|
|
}(__WEBPACK_IMPORTED_MODULE_0_react__["Component"]);
|
|
|
|
|
|
/* harmony default export */ __webpack_exports__["a"] = (LazyRenderBox);
|
|
|
|
|
|
/***/ }),
|
|
|
/* 16 */
|
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_react_dom__ = __webpack_require__(1);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_react_dom___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_react_dom__);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__ContainerRender__ = __webpack_require__(17);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__Portal__ = __webpack_require__(18);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__switchScrollingEffect__ = __webpack_require__(19);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__setStyle__ = __webpack_require__(3);
|
|
|
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
|
|
|
|
|
|
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
|
|
|
|
|
|
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
|
|
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a 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); } }
|
|
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
|
|
|
|
|
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
|
|
|
|
|
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
|
|
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
|
|
|
|
|
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
|
|
|
|
|
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
|
|
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
|
|
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
|
|
/* eslint-disable no-underscore-dangle,react/require-default-props */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var openCount = 0;
|
|
|
var windowIsUndefined = !(typeof window !== 'undefined' && window.document && window.document.createElement);
|
|
|
var IS_REACT_16 = ('createPortal' in __WEBPACK_IMPORTED_MODULE_1_react_dom___default.a); // https://github.com/ant-design/ant-design/issues/19340
|
|
|
// https://github.com/ant-design/ant-design/issues/19332
|
|
|
|
|
|
var cacheOverflow = {};
|
|
|
|
|
|
var getParent = function getParent(getContainer) {
|
|
|
if (windowIsUndefined) {
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
if (getContainer) {
|
|
|
if (typeof getContainer === 'string') {
|
|
|
return document.querySelectorAll(getContainer)[0];
|
|
|
}
|
|
|
|
|
|
if (typeof getContainer === 'function') {
|
|
|
return getContainer();
|
|
|
}
|
|
|
|
|
|
if (_typeof(getContainer) === 'object' && getContainer instanceof window.HTMLElement) {
|
|
|
return getContainer;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return document.body;
|
|
|
};
|
|
|
|
|
|
var PortalWrapper = /*#__PURE__*/function (_React$Component) {
|
|
|
_inherits(PortalWrapper, _React$Component);
|
|
|
|
|
|
var _super = _createSuper(PortalWrapper);
|
|
|
|
|
|
function PortalWrapper(props) {
|
|
|
var _this;
|
|
|
|
|
|
_classCallCheck(this, PortalWrapper);
|
|
|
|
|
|
_this = _super.call(this, props);
|
|
|
|
|
|
_this.getContainer = function () {
|
|
|
if (windowIsUndefined) {
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
if (!_this.container) {
|
|
|
_this.container = document.createElement('div');
|
|
|
var parent = getParent(_this.props.getContainer);
|
|
|
|
|
|
if (parent) {
|
|
|
parent.appendChild(_this.container);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
_this.setWrapperClassName();
|
|
|
|
|
|
return _this.container;
|
|
|
};
|
|
|
|
|
|
_this.setWrapperClassName = function () {
|
|
|
var wrapperClassName = _this.props.wrapperClassName;
|
|
|
|
|
|
if (_this.container && wrapperClassName && wrapperClassName !== _this.container.className) {
|
|
|
_this.container.className = wrapperClassName;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
_this.savePortal = function (c) {
|
|
|
// Warning: don't rename _component
|
|
|
// https://github.com/react-component/util/pull/65#discussion_r352407916
|
|
|
_this._component = c;
|
|
|
};
|
|
|
|
|
|
_this.removeCurrentContainer = function (visible) {
|
|
|
_this.container = null;
|
|
|
_this._component = null;
|
|
|
|
|
|
if (!IS_REACT_16) {
|
|
|
if (visible) {
|
|
|
_this.renderComponent({
|
|
|
afterClose: _this.removeContainer,
|
|
|
onClose: function onClose() {},
|
|
|
visible: false
|
|
|
});
|
|
|
} else {
|
|
|
_this.removeContainer();
|
|
|
}
|
|
|
}
|
|
|
};
|
|
|
|
|
|
_this.switchScrollingEffect = function () {
|
|
|
if (openCount === 1 && !Object.keys(cacheOverflow).length) {
|
|
|
Object(__WEBPACK_IMPORTED_MODULE_4__switchScrollingEffect__["a" /* default */])(); // Must be set after switchScrollingEffect
|
|
|
|
|
|
cacheOverflow = Object(__WEBPACK_IMPORTED_MODULE_5__setStyle__["a" /* default */])({
|
|
|
overflow: 'hidden',
|
|
|
overflowX: 'hidden',
|
|
|
overflowY: 'hidden'
|
|
|
});
|
|
|
} else if (!openCount) {
|
|
|
Object(__WEBPACK_IMPORTED_MODULE_5__setStyle__["a" /* default */])(cacheOverflow);
|
|
|
cacheOverflow = {};
|
|
|
Object(__WEBPACK_IMPORTED_MODULE_4__switchScrollingEffect__["a" /* default */])(true);
|
|
|
}
|
|
|
};
|
|
|
|
|
|
var _visible = props.visible,
|
|
|
getContainer = props.getContainer;
|
|
|
|
|
|
if (!windowIsUndefined && getParent(getContainer) === document.body) {
|
|
|
openCount = _visible ? openCount + 1 : openCount;
|
|
|
}
|
|
|
|
|
|
_this.state = {
|
|
|
_self: _assertThisInitialized(_this)
|
|
|
};
|
|
|
return _this;
|
|
|
}
|
|
|
|
|
|
_createClass(PortalWrapper, [{
|
|
|
key: "componentDidUpdate",
|
|
|
value: function componentDidUpdate() {
|
|
|
this.setWrapperClassName();
|
|
|
}
|
|
|
}, {
|
|
|
key: "componentWillUnmount",
|
|
|
value: function componentWillUnmount() {
|
|
|
var _this$props = this.props,
|
|
|
visible = _this$props.visible,
|
|
|
getContainer = _this$props.getContainer;
|
|
|
|
|
|
if (!windowIsUndefined && getParent(getContainer) === document.body) {
|
|
|
// 离开时不会 render， 导到离开时数值不变，改用 func 。。
|
|
|
openCount = visible && openCount ? openCount - 1 : openCount;
|
|
|
}
|
|
|
|
|
|
this.removeCurrentContainer(visible);
|
|
|
}
|
|
|
}, {
|
|
|
key: "render",
|
|
|
value: function render() {
|
|
|
var _this2 = this;
|
|
|
|
|
|
var _this$props2 = this.props,
|
|
|
children = _this$props2.children,
|
|
|
forceRender = _this$props2.forceRender,
|
|
|
visible = _this$props2.visible;
|
|
|
var portal = null;
|
|
|
var childProps = {
|
|
|
getOpenCount: function getOpenCount() {
|
|
|
return openCount;
|
|
|
},
|
|
|
getContainer: this.getContainer,
|
|
|
switchScrollingEffect: this.switchScrollingEffect
|
|
|
}; // suppport react15
|
|
|
|
|
|
if (!IS_REACT_16) {
|
|
|
return /*#__PURE__*/__WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_2__ContainerRender__["a" /* default */], {
|
|
|
parent: this,
|
|
|
visible: visible,
|
|
|
autoDestroy: false,
|
|
|
getComponent: function getComponent() {
|
|
|
var extra = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
|
|
|
return children(_objectSpread(_objectSpread(_objectSpread({}, extra), childProps), {}, {
|
|
|
ref: _this2.savePortal
|
|
|
}));
|
|
|
},
|
|
|
getContainer: this.getContainer,
|
|
|
forceRender: forceRender
|
|
|
}, function (_ref) {
|
|
|
var renderComponent = _ref.renderComponent,
|
|
|
removeContainer = _ref.removeContainer;
|
|
|
_this2.renderComponent = renderComponent;
|
|
|
_this2.removeContainer = removeContainer;
|
|
|
return null;
|
|
|
});
|
|
|
}
|
|
|
|
|
|
if (forceRender || visible || this._component) {
|
|
|
portal = /*#__PURE__*/__WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_3__Portal__["a" /* default */], {
|
|
|
getContainer: this.getContainer,
|
|
|
ref: this.savePortal
|
|
|
}, children(childProps));
|
|
|
}
|
|
|
|
|
|
return portal;
|
|
|
}
|
|
|
}], [{
|
|
|
key: "getDerivedStateFromProps",
|
|
|
value: function getDerivedStateFromProps(props, _ref2) {
|
|
|
var prevProps = _ref2.prevProps,
|
|
|
_self = _ref2._self;
|
|
|
var visible = props.visible,
|
|
|
getContainer = props.getContainer;
|
|
|
|
|
|
if (prevProps) {
|
|
|
var prevVisible = prevProps.visible,
|
|
|
prevGetContainer = prevProps.getContainer;
|
|
|
|
|
|
if (visible !== prevVisible && !windowIsUndefined && getParent(getContainer) === document.body) {
|
|
|
openCount = visible && !prevVisible ? openCount + 1 : openCount - 1;
|
|
|
}
|
|
|
|
|
|
var getContainerIsFunc = typeof getContainer === 'function' && typeof prevGetContainer === 'function';
|
|
|
|
|
|
if (getContainerIsFunc ? getContainer.toString() !== prevGetContainer.toString() : getContainer !== prevGetContainer) {
|
|
|
_self.removeCurrentContainer(false);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return {
|
|
|
prevProps: props
|
|
|
};
|
|
|
}
|
|
|
}]);
|
|
|
|
|
|
return PortalWrapper;
|
|
|
}(__WEBPACK_IMPORTED_MODULE_0_react___default.a.Component);
|
|
|
|
|
|
/* harmony default export */ __webpack_exports__["a"] = (PortalWrapper);
|
|
|
|
|
|
/***/ }),
|
|
|
/* 17 */
|
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return ContainerRender; });
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_react_dom__ = __webpack_require__(1);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_react_dom___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_react_dom__);
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a 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); } }
|
|
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
|
|
|
|
|
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
|
|
|
|
|
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
|
|
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
|
|
|
|
|
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
|
|
|
|
|
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
|
|
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var ContainerRender = /*#__PURE__*/function (_React$Component) {
|
|
|
_inherits(ContainerRender, _React$Component);
|
|
|
|
|
|
var _super = _createSuper(ContainerRender);
|
|
|
|
|
|
function ContainerRender() {
|
|
|
var _this;
|
|
|
|
|
|
_classCallCheck(this, ContainerRender);
|
|
|
|
|
|
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.removeContainer = function () {
|
|
|
if (_this.container) {
|
|
|
__WEBPACK_IMPORTED_MODULE_1_react_dom___default.a.unmountComponentAtNode(_this.container);
|
|
|
|
|
|
_this.container.parentNode.removeChild(_this.container);
|
|
|
|
|
|
_this.container = null;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
_this.renderComponent = function (props, ready) {
|
|
|
var _this$props = _this.props,
|
|
|
visible = _this$props.visible,
|
|
|
getComponent = _this$props.getComponent,
|
|
|
forceRender = _this$props.forceRender,
|
|
|
getContainer = _this$props.getContainer,
|
|
|
parent = _this$props.parent;
|
|
|
|
|
|
if (visible || parent._component || forceRender) {
|
|
|
if (!_this.container) {
|
|
|
_this.container = getContainer();
|
|
|
}
|
|
|
|
|
|
__WEBPACK_IMPORTED_MODULE_1_react_dom___default.a.unstable_renderSubtreeIntoContainer(parent, getComponent(props), _this.container, function callback() {
|
|
|
if (ready) {
|
|
|
ready.call(this);
|
|
|
}
|
|
|
});
|
|
|
}
|
|
|
};
|
|
|
|
|
|
return _this;
|
|
|
}
|
|
|
|
|
|
_createClass(ContainerRender, [{
|
|
|
key: "componentDidMount",
|
|
|
value: function componentDidMount() {
|
|
|
if (this.props.autoMount) {
|
|
|
this.renderComponent();
|
|
|
}
|
|
|
}
|
|
|
}, {
|
|
|
key: "componentDidUpdate",
|
|
|
value: function componentDidUpdate() {
|
|
|
if (this.props.autoMount) {
|
|
|
this.renderComponent();
|
|
|
}
|
|
|
}
|
|
|
}, {
|
|
|
key: "componentWillUnmount",
|
|
|
value: function componentWillUnmount() {
|
|
|
if (this.props.autoDestroy) {
|
|
|
this.removeContainer();
|
|
|
}
|
|
|
}
|
|
|
}, {
|
|
|
key: "render",
|
|
|
value: function render() {
|
|
|
return this.props.children({
|
|
|
renderComponent: this.renderComponent,
|
|
|
removeContainer: this.removeContainer
|
|
|
});
|
|
|
}
|
|
|
}]);
|
|
|
|
|
|
return ContainerRender;
|
|
|
}(__WEBPACK_IMPORTED_MODULE_0_react___default.a.Component);
|
|
|
|
|
|
ContainerRender.defaultProps = {
|
|
|
autoMount: true,
|
|
|
autoDestroy: true,
|
|
|
forceRender: false
|
|
|
};
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 18 */
|
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return Portal; });
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_react_dom__ = __webpack_require__(1);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_react_dom___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_react_dom__);
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a 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); } }
|
|
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
|
|
|
|
|
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
|
|
|
|
|
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
|
|
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
|
|
|
|
|
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
|
|
|
|
|
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
|
|
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var Portal = /*#__PURE__*/function (_React$Component) {
|
|
|
_inherits(Portal, _React$Component);
|
|
|
|
|
|
var _super = _createSuper(Portal);
|
|
|
|
|
|
function Portal() {
|
|
|
_classCallCheck(this, Portal);
|
|
|
|
|
|
return _super.apply(this, arguments);
|
|
|
}
|
|
|
|
|
|
_createClass(Portal, [{
|
|
|
key: "componentDidMount",
|
|
|
value: function componentDidMount() {
|
|
|
this.createContainer();
|
|
|
}
|
|
|
}, {
|
|
|
key: "componentDidUpdate",
|
|
|
value: function componentDidUpdate(prevProps) {
|
|
|
var didUpdate = this.props.didUpdate;
|
|
|
|
|
|
if (didUpdate) {
|
|
|
didUpdate(prevProps);
|
|
|
}
|
|
|
}
|
|
|
}, {
|
|
|
key: "componentWillUnmount",
|
|
|
value: function componentWillUnmount() {
|
|
|
this.removeContainer();
|
|
|
}
|
|
|
}, {
|
|
|
key: "createContainer",
|
|
|
value: function createContainer() {
|
|
|
this._container = this.props.getContainer();
|
|
|
this.forceUpdate();
|
|
|
}
|
|
|
}, {
|
|
|
key: "removeContainer",
|
|
|
value: function removeContainer() {
|
|
|
if (this._container) {
|
|
|
this._container.parentNode.removeChild(this._container);
|
|
|
}
|
|
|
}
|
|
|
}, {
|
|
|
key: "render",
|
|
|
value: function render() {
|
|
|
if (this._container) {
|
|
|
return __WEBPACK_IMPORTED_MODULE_1_react_dom___default.a.createPortal(this.props.children, this._container);
|
|
|
}
|
|
|
|
|
|
return null;
|
|
|
}
|
|
|
}]);
|
|
|
|
|
|
return Portal;
|
|
|
}(__WEBPACK_IMPORTED_MODULE_0_react___default.a.Component);
|
|
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 19 */
|
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__getScrollBarSize__ = __webpack_require__(20);
|
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__setStyle__ = __webpack_require__(3);
|
|
|
|
|
|
|
|
|
|
|
|
function isBodyOverflowing() {
|
|
|
return document.body.scrollHeight > (window.innerHeight || document.documentElement.clientHeight) && window.innerWidth > document.body.offsetWidth;
|
|
|
}
|
|
|
|
|
|
var cacheStyle = {};
|
|
|
/* harmony default export */ __webpack_exports__["a"] = (function (close) {
|
|
|
if (!isBodyOverflowing() && !close) {
|
|
|
return;
|
|
|
} // https://github.com/ant-design/ant-design/issues/19729
|
|
|
|
|
|
|
|
|
var scrollingEffectClassName = 'ant-scrolling-effect';
|
|
|
var scrollingEffectClassNameReg = new RegExp("".concat(scrollingEffectClassName), 'g');
|
|
|
var bodyClassName = document.body.className;
|
|
|
|
|
|
if (close) {
|
|
|
if (!scrollingEffectClassNameReg.test(bodyClassName)) return;
|
|
|
Object(__WEBPACK_IMPORTED_MODULE_1__setStyle__["a" /* default */])(cacheStyle);
|
|
|
cacheStyle = {};
|
|
|
document.body.className = bodyClassName.replace(scrollingEffectClassNameReg, '').trim();
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
var scrollBarSize = Object(__WEBPACK_IMPORTED_MODULE_0__getScrollBarSize__["a" /* default */])();
|
|
|
|
|
|
if (scrollBarSize) {
|
|
|
cacheStyle = Object(__WEBPACK_IMPORTED_MODULE_1__setStyle__["a" /* default */])({
|
|
|
position: 'relative',
|
|
|
width: "calc(100% - ".concat(scrollBarSize, "px)")
|
|
|
});
|
|
|
|
|
|
if (!scrollingEffectClassNameReg.test(bodyClassName)) {
|
|
|
var addClassName = "".concat(bodyClassName, " ").concat(scrollingEffectClassName);
|
|
|
document.body.className = addClassName.trim();
|
|
|
}
|
|
|
}
|
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
/* 20 */
|
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
|
|
"use strict";
|
|
|
/* harmony export (immutable) */ __webpack_exports__["a"] = getScrollBarSize;
|
|
|
var cached;
|
|
|
function getScrollBarSize(fresh) {
|
|
|
if (typeof document === 'undefined') {
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
if (fresh || cached === undefined) {
|
|
|
var inner = document.createElement('div');
|
|
|
inner.style.width = '100%';
|
|
|
inner.style.height = '200px';
|
|
|
var outer = document.createElement('div');
|
|
|
var outerStyle = outer.style;
|
|
|
outerStyle.position = 'absolute';
|
|
|
outerStyle.top = 0;
|
|
|
outerStyle.left = 0;
|
|
|
outerStyle.pointerEvents = 'none';
|
|
|
outerStyle.visibility = 'hidden';
|
|
|
outerStyle.width = '200px';
|
|
|
outerStyle.height = '150px';
|
|
|
outerStyle.overflow = 'hidden';
|
|
|
outer.appendChild(inner);
|
|
|
document.body.appendChild(outer);
|
|
|
var widthContained = inner.offsetWidth;
|
|
|
outer.style.overflow = 'scroll';
|
|
|
var widthScroll = inner.offsetWidth;
|
|
|
|
|
|
if (widthContained === widthScroll) {
|
|
|
widthScroll = outer.clientWidth;
|
|
|
}
|
|
|
|
|
|
document.body.removeChild(outer);
|
|
|
cached = widthContained - widthScroll;
|
|
|
}
|
|
|
|
|
|
return cached;
|
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
/* 21 */,
|
|
|
/* 22 */,
|
|
|
/* 23 */
|
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
__webpack_require__(4);
|
|
|
module.exports = __webpack_require__(24);
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
/* 24 */
|
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
// removed by extract-text-webpack-plugin
|
|
|
|
|
|
/***/ })
|
|
|
/******/ ])["default"];
|
|
|
});
|
|
|
//# sourceMappingURL=rc-dialog-bootstrap.js.map
|
