@txdfe/at
Version:
一个设计体系组件库
716 lines (714 loc) • 30.4 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports["default"] = void 0;
var _react = _interopRequireWildcard(require("react"));
var _reactDom = require("react-dom");
var _propTypes = _interopRequireDefault(require("prop-types"));
var _classnames2 = _interopRequireDefault(require("classnames"));
var _util = require("../util");
var _manager = _interopRequireDefault(require("./manager"));
var _gateway = _interopRequireDefault(require("./gateway"));
var _position = _interopRequireDefault(require("./position"));
var _findNode = _interopRequireDefault(require("./utils/find-node"));
function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
function _possibleConstructorReturn(t, e) { if (e && ("object" == _typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return _assertThisInitialized(t); }
function _assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
function _getPrototypeOf(t) { return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, _getPrototypeOf(t); }
function _inherits(t, e) { if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function"); t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), e && _setPrototypeOf(t, e); }
function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
var saveLastFocusNode = _util.focus.saveLastFocusNode,
getFocusNodeList = _util.focus.getFocusNodeList,
backLastFocusNode = _util.focus.backLastFocusNode;
var makeChain = _util.func.makeChain,
noop = _util.func.noop;
var isScrollDisplay = function isScrollDisplay(element) {
try {
var scrollbarStyle = window.getComputedStyle(element, '::-webkit-scrollbar');
return !scrollbarStyle || scrollbarStyle.getPropertyValue('display') !== 'none';
} catch (e) {
// ignore error for firefox
}
return true;
};
var hasScroll = function hasScroll() {
var doc = document.documentElement;
return doc.scrollHeight > doc.clientHeight && _util.dom.scrollbar().width > 0 && isScrollDisplay(document.documentElement) && isScrollDisplay(document.body);
};
var prefixes = ['-webkit-', '-moz-', '-o-', 'ms-', ''];
var getStyleProperty = function getStyleProperty(node, name) {
var style = window.getComputedStyle(node);
var ret = '';
for (var i = 0; i < prefixes.length; i++) {
ret = style.getPropertyValue(prefixes[i] + name);
if (ret) {
break;
}
}
return ret;
};
var modals = [];
var bodyOverflowY;
var bodyPaddingRight;
/**
* Overlay
* */
var Overlay = exports["default"] = /*#__PURE__*/function (_Component) {
function Overlay(_props) {
var _this;
_classCallCheck(this, Overlay);
_this = _callSuper(this, Overlay, [_props]);
_defineProperty(_this, "getAnimation", function (props) {
if (props.animation === false) {
return false;
}
if (props.animation) {
return props.animation;
}
return _this.getAnimationByAlign(props.align);
});
_defineProperty(_this, "getAnimationByAlign", function (align) {
switch (align[0]) {
case 't':
return {
"in": 'fadeInDown',
out: 'fadeOutUp'
};
case 'b':
return {
"in": 'fadeInUp',
out: 'fadeOutDown'
};
default:
return {
"in": 'fadeInDown',
out: 'fadeOutUp'
};
}
});
_defineProperty(_this, "addAnimationEvents", function () {
setTimeout(function () {
var node = _this.getContentNode();
if (node) {
var id = (0, _util.guid)();
_this._animation = _util.events.on(node, _util.support.animation.end, _this.handleAnimateEnd.bind(_this, id));
var animationDelay = parseFloat(getStyleProperty(node, 'animation-delay')) || 0;
var animationDuration = parseFloat(getStyleProperty(node, 'animation-duration')) || 0;
var time = animationDelay + animationDuration;
if (time) {
_this.timeoutMap[id] = setTimeout(function () {
_this.handleAnimateEnd(id);
}, time * 1000 + 200);
}
}
});
});
_defineProperty(_this, "handlePosition", function (config) {
var align = config.align.join(' ');
if (!('animation' in _this.props) && _this.props.needAdjust && _this.lastAlign !== align) {
_this.setState({
animation: _this.getAnimationByAlign(align)
});
}
_this.lastAlign = align;
_this.props.onPosition(config);
});
_defineProperty(_this, "handleAnimateEnd", function (id) {
if (_this.timeoutMap[id]) {
clearTimeout(_this.timeoutMap[id]);
}
delete _this.timeoutMap[id];
if (_this._animation) {
_this._animation.off();
_this._animation = null;
}
if (!_this._isMounted) {
return;
}
if (_this.state.status === 'leaving') {
_this.setState({
visible: false,
status: 'none'
});
_this.onLeaved();
} else if (_this.state.status === 'entering') {
_this.setState({
status: 'none'
});
_this.onEntered();
}
});
_defineProperty(_this, "enter", function () {
_this.setState({
visible: true,
status: 'entering'
}, function () {
// NOTE: setState callback (second argument) now fires immediately after componentDidMount / componentDidUpdate instead of after all components have rendered.
setTimeout(function () {
if (!_this._isDestroyed) {
_this.onEntering();
}
});
});
});
_defineProperty(_this, "leave", function () {
_this.setState({
status: 'leaving'
});
_this.onLeaving();
});
_defineProperty(_this, "onEntering", function () {
var wrapperNode = _this.getWrapperNode();
_util.dom.addClass(wrapperNode, 'opened');
_this.props.onOpen();
});
_defineProperty(_this, "onLeaving", function () {
var wrapperNode = _this.getWrapperNode();
_util.dom.removeClass(wrapperNode, 'opened');
_this.props.onClose();
});
_defineProperty(_this, "onEntered", function () {
_manager["default"].addOverlay(_this);
_this.setFocusNode();
_this.props.afterOpen();
});
_defineProperty(_this, "onLeaved", function () {
_manager["default"].removeOverlay(_this);
_this.setFocusNode();
_this.props.afterClose();
});
_defineProperty(_this, "beforeOpen", function () {
if (_this.props.disableScroll) {
if (modals.length === 0) {
var style = {
overflowY: 'hidden'
};
var _document = document,
body = _document.body;
bodyOverflowY = body.style.overflowY;
if (hasScroll()) {
bodyPaddingRight = body.style.paddingRight;
style.paddingRight = "".concat(_util.dom.getStyle(body, 'paddingRight') + _util.dom.scrollbar().width, "px");
}
_util.dom.setStyle(body, style);
}
modals.push(_this);
}
});
_defineProperty(_this, "beforeClose", function () {
if (_this.props.disableScroll) {
var index = modals.indexOf(_this);
if (index > -1) {
if (modals.length === 1) {
var style = {
overflowY: bodyOverflowY
};
if (hasScroll()) {
style.paddingRight = bodyPaddingRight;
}
_util.dom.setStyle(document.body, style);
bodyOverflowY = undefined;
bodyPaddingRight = undefined;
}
modals.splice(index, 1);
}
}
});
_defineProperty(_this, "setFocusNode", function () {
if (!_this.props.autoFocus) {
return;
}
if (_this.state.visible && !_this._hasFocused) {
saveLastFocusNode();
// 这个时候很可能上一个弹层的关闭事件还未触发，导致焦点已经回到触发的元素
// 这里延时处理一下，延时的时间为 document.click 捕获触发的延时时间
_this.focusTimeout = setTimeout(function () {
var node = _this.getContentNode();
if (node) {
var focusNodeList = getFocusNodeList(node);
if (focusNodeList.length) {
focusNodeList[0].focus();
}
_this._hasFocused = true;
}
}, 100);
} else if (!_this.state.visible && _this._hasFocused) {
backLastFocusNode();
_this._hasFocused = false;
}
});
_defineProperty(_this, "getContent", function () {
return _this.contentRef;
});
_defineProperty(_this, "getContentNode", function () {
return (0, _reactDom.findDOMNode)(_this.contentRef);
});
_defineProperty(_this, "getWrapperNode", function () {
return _this.gatewayRef ? _this.gatewayRef.getChildNode() : null;
});
_defineProperty(_this, "addDocumentEvents", function () {
if (_this.props.canCloseByEsc) {
_this._keydownEvents = _util.events.on(document, 'keydown', _this.handleDocumentKeyDown);
}
if (_this.props.canCloseByOutSideClick) {
_this._clickEvents = _util.events.on(document, 'click', _this.handleDocumentClick);
_this._touchEvents = _util.events.on(document, 'touchend', _this.handleDocumentClick);
}
});
_defineProperty(_this, "removeDocumentEvents", function () {
if (_this._keydownEvents) {
_this._keydownEvents.off();
_this._keydownEvents = null;
}
if (_this._clickEvents) {
_this._clickEvents.off();
_this._clickEvents = null;
}
if (_this._touchEvents) {
_this._touchEvents.off();
_this._touchEvents = null;
}
});
_defineProperty(_this, "handleDocumentKeyDown", function (e) {
if (_this.state.visible && e.keyCode === _util.KEYCODE.ESC && _manager["default"].isCurrentOverlay(_this)) {
_this.props.onRequestClose('keyboard', e);
}
});
_defineProperty(_this, "handleDocumentClick", function (e) {
if (_this.state.visible) {
var safeNode = _this.props.safeNode;
var safeNodes = Array.isArray(safeNode) ? _toConsumableArray(safeNode) : [safeNode];
safeNodes.unshift(function () {
return _this.getWrapperNode();
});
var path = e.path || e.composedPath && e.composedPath();
for (var i = 0; i < safeNodes.length; i++) {
var node = (0, _findNode["default"])(safeNodes[i], _this.props);
// HACK: 如果触发点击的节点是弹层内部的节点，并且在被点击后立即销毁，那么此时无法使用 node.contains(e.target)
// 来判断此时点击的节点是否是弹层内部的节点，额外判断
if (node && (node === e.target || node.contains && node.contains(e.target) || e.target !== document && !document.documentElement.contains(e.target)) || path && path.indexOf(node) > -1 // 如果 node 在 e.path 中，则表示点击了 node 的后代
) {
return;
}
}
_this.props.onRequestClose('docClick', e);
}
});
_defineProperty(_this, "handleMaskClick", function (e) {
if (_this.props.canCloseByMask) {
_this.props.onRequestClose('maskClick', e);
}
});
_defineProperty(_this, "saveContentRef", function (ref) {
_this.contentRef = ref;
});
_defineProperty(_this, "saveGatewayRef", function (ref) {
_this.gatewayRef = ref;
});
// 兼容过去的用法: this.popupRef.getInstance().overlay.getInstance().getContentNode()
_defineProperty(_this, "getInstance", function () {
return _this;
});
_this.state = {
visible: _props.visible,
status: 'none',
animation: _this.getAnimation(_props)
};
_this.lastAlign = _props.align;
_this.timeoutMap = {};
return _this;
}
_inherits(Overlay, _Component);
return _createClass(Overlay, [{
key: "UNSAFE_componentWillMount",
value: function UNSAFE_componentWillMount() {
if (this.props.visible) {
this.beforeOpen();
this.props.beforeOpen();
if (this.state.animation && _util.support.animation) {
this.enter();
}
}
}
}, {
key: "componentDidMount",
value: function componentDidMount() {
this.componentDidUpdate({
visible: false
});
this.addDocumentEvents();
_manager["default"].addOverlay(this);
if (this.state.visible) {
this._isMounted = true;
}
}
}, {
key: "UNSAFE_componentWillReceiveProps",
value: function UNSAFE_componentWillReceiveProps(nextProps) {
if (!this._isMounted && nextProps.visible) {
this._isMounted = true;
}
var willOpen = !this.props.visible && nextProps.visible;
var willClose = this.props.visible && !nextProps.visible;
if (willOpen) {
this.beforeOpen();
nextProps.beforeOpen();
} else if (willClose) {
this.beforeClose();
nextProps.beforeClose();
}
if (nextProps.animation || nextProps.animation === false) {
this.setState({
animation: nextProps.animation
});
}
if (nextProps.animation !== false && _util.support.animation) {
if (willOpen) {
this.enter();
} else if (willClose) {
this.leave();
}
} else {
this.setState({
visible: nextProps.visible
});
}
}
}, {
key: "componentDidUpdate",
value: function componentDidUpdate(prevProps) {
var _this2 = this;
var open = !prevProps.visible && this.props.visible;
var close = prevProps.visible && !this.props.visible;
if (this.state.animation && _util.support.animation) {
if (open || close) {
this.addAnimationEvents();
}
} else {
var wrapperNode = this.getWrapperNode();
if (open) {
setTimeout(function () {
_this2.props.onOpen();
_this2.props.afterOpen();
_util.dom.addClass(wrapperNode, 'opened');
_manager["default"].addOverlay(_this2);
});
} else if (close) {
this.props.onClose();
this.props.afterClose();
_util.dom.removeClass(wrapperNode, 'opened');
_manager["default"].removeOverlay(this);
}
this.setFocusNode();
}
}
}, {
key: "componentWillUnmount",
value: function componentWillUnmount() {
this._isDestroyed = true;
this._isMounted = false;
_manager["default"].removeOverlay(this);
this.removeDocumentEvents();
if (this.focusTimeout) {
clearTimeout(this.focusTimeout);
}
if (this._animation) {
this._animation.off();
this._animation = null;
}
this.beforeClose();
}
}, {
key: "render",
value: function render() {
var _this$props = this.props,
role = _this$props.role,
prefix = _this$props.prefix,
className = _this$props.className,
style = _this$props.style,
propChildren = _this$props.children,
needListenResize = _this$props.needListenResize,
needListenScroll = _this$props.needListenScroll,
target = _this$props.target,
align = _this$props.align,
offset = _this$props.offset,
container = _this$props.container,
hasMask = _this$props.hasMask,
maskStyle = _this$props.maskStyle,
needAdjust = _this$props.needAdjust,
beforePosition = _this$props.beforePosition,
wrapperStyle = _this$props.wrapperStyle,
rtl = _this$props.rtl,
propShouldUpdatePosition = _this$props.shouldUpdatePosition,
cache = _this$props.cache,
wrapperClassName = _this$props.wrapperClassName,
onMaskMouseEnter = _this$props.onMaskMouseEnter,
onMaskMouseLeave = _this$props.onMaskMouseLeave;
var _this$state = this.state,
stateVisible = _this$state.visible,
status = _this$state.status,
animation = _this$state.animation;
var children = stateVisible || cache ? propChildren : null;
if (children) {
var child = _react.Children.only(children);
// if chlild is a functional component wrap in a component to allow a ref to be set
if (typeof child.type === 'function' && !(child.type.prototype instanceof _react.Component)) {
child = /*#__PURE__*/_react["default"].createElement("div", {
role: "none"
}, child);
}
var childClazz = (0, _classnames2["default"])(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, "".concat(prefix, "overlay-inner"), true), animation["in"], status === 'entering'), animation.out, status === 'leaving'), child.props.className, !!child.props.className), className, !!className));
if (typeof child.ref === 'string') {
throw new Error('Can not set ref by string in Overlay, use function instead.');
}
children = /*#__PURE__*/_react["default"].cloneElement(child, {
className: childClazz,
style: _objectSpread(_objectSpread({}, child.props.style), style),
ref: makeChain(this.saveContentRef, child.ref),
'aria-hidden': !stateVisible && cache && this._isMounted,
onClick: this.props.onClick
});
if (align) {
var shouldUpdatePosition = status === 'leaving' ? false : propShouldUpdatePosition;
// role用于区分是否是tooltip，对于tooltip定位机制有特殊处理
children = /*#__PURE__*/_react["default"].createElement(_position["default"], {
role: role,
container: container,
visible: stateVisible,
children: children,
target: target,
align: align,
offset: offset,
needListenResize: needListenResize,
needListenScroll: needListenScroll,
needAdjust: needAdjust,
beforePosition: beforePosition,
onPosition: this.handlePosition,
shouldUpdatePosition: shouldUpdatePosition,
rtl: rtl
});
}
var wrapperClazz = (0, _classnames2["default"])(["".concat(prefix, "overlay-wrapper"), wrapperClassName]);
var newWrapperStyle = _extends({}, {
display: stateVisible ? '' : 'none'
}, wrapperStyle);
children = /*#__PURE__*/_react["default"].createElement("div", {
className: wrapperClazz,
style: newWrapperStyle,
dir: rtl ? 'rtl' : undefined
}, hasMask ? /*#__PURE__*/_react["default"].createElement("div", {
className: "".concat(prefix, "overlay-backdrop"),
onClick: this.handleMaskClick,
onMouseEnter: onMaskMouseEnter,
onMouseLeave: onMaskMouseLeave,
dir: rtl ? 'rtl' : undefined,
style: maskStyle
}) : null, children);
}
return /*#__PURE__*/_react["default"].createElement(_gateway["default"], {
container: container,
target: target,
children: children,
ref: this.saveGatewayRef
});
}
}]);
}(_react.Component);
_defineProperty(Overlay, "propTypes", {
role: _propTypes["default"].string,
prefix: _propTypes["default"].string,
pure: _propTypes["default"].bool,
rtl: _propTypes["default"].bool,
className: _propTypes["default"].string,
style: _propTypes["default"].object,
/**
* 弹层内容
*/
children: _propTypes["default"].any,
/**
* 是否显示弹层
*/
visible: _propTypes["default"].bool,
/**
* 弹层请求关闭时触发事件的回调函数
* @param {String} type 弹层关闭的来源
* @param {Object} e DOM 事件
*/
onRequestClose: _propTypes["default"].func,
/**
* 是否监听resize事件
*/
needListenResize: _propTypes["default"].bool,
/**
* 是否监听scroll事件
*/
needListenScroll: _propTypes["default"].bool,
/**
* 弹层定位的参照元素
*/
target: _propTypes["default"].any,
/**
* 弹层相对于参照元素的定位, 详见开发指南的[定位部分](#定位)
*/
align: _propTypes["default"].oneOfType([_propTypes["default"].string, _propTypes["default"].bool]),
/**
* 弹层相对于trigger的定位的微调, 接收数组[hoz, ver], 表示弹层在 left / top 上的增量
* e.g. [100, 100] 表示往右(RTL 模式下是往左) 、下分布偏移100px
*/
offset: _propTypes["default"].array,
/**
* 渲染组件的容器，如果是函数需要返回 ref，如果是字符串则是该 DOM 的 id，也可以直接传入 DOM 节点
*/
container: _propTypes["default"].any,
/**
* 是否显示遮罩
*/
hasMask: _propTypes["default"].bool,
/**
* 遮罩样式
*/
maskStyle: _propTypes["default"].object,
/**
* 是否支持 esc 按键关闭弹层
*/
canCloseByEsc: _propTypes["default"].bool,
/**
* 点击弹层外的区域是否关闭弹层，不显示遮罩时生效
*/
canCloseByOutSideClick: _propTypes["default"].bool,
/**
* 点击遮罩区域是否关闭弹层，显示遮罩时生效
*/
canCloseByMask: _propTypes["default"].bool,
/**
* 弹层打开前触发事件的回调函数
*/
beforeOpen: _propTypes["default"].func,
/**
* 弹层打开时触发事件的回调函数
*/
onOpen: _propTypes["default"].func,
/**
* 弹层打开后触发事件的回调函数, 如果有动画，则在动画结束后触发
*/
afterOpen: _propTypes["default"].func,
/**
* 弹层关闭前触发事件的回调函数
*/
beforeClose: _propTypes["default"].func,
/**
* 弹层关闭时触发事件的回调函数
*/
onClose: _propTypes["default"].func,
/**
* 弹层关闭后触发事件的回调函数, 如果有动画，则在动画结束后触发
*/
afterClose: _propTypes["default"].func,
/**
* 弹层定位完成前触发的事件
*/
beforePosition: _propTypes["default"].func,
/**
* 弹层定位完成时触发的事件
* @param {Object} config 定位的参数
* @param {Array} config.align 对齐方式，如 ['cc', 'cc']（如果开启 needAdjust，可能和预先设置的 align 不同）
* @param {Number} config.top 距离视口顶部距离
* @param {Number} config.left 距离视口左侧距离
* @param {Object} node 定位参照的容器节点
*/
onPosition: _propTypes["default"].func,
/**
* 是否在每次弹层重新渲染后强制更新定位信息，一般用于弹层内容区域大小发生变化时，仍需保持原来的定位方式
*/
shouldUpdatePosition: _propTypes["default"].bool,
/**
* 弹层打开时是否让其中的元素自动获取焦点
*/
autoFocus: _propTypes["default"].bool,
/**
* 当弹层由于页面滚动等情况不在可视区域时，是否自动调整定位以出现在可视区域
*/
needAdjust: _propTypes["default"].bool,
/**
* 是否禁用页面滚动
*/
disableScroll: _propTypes["default"].bool,
/**
* 隐藏时是否保留子节点
*/
cache: _propTypes["default"].bool,
/**
* 安全节点，当点击 document 的时候，如果包含该节点则不会关闭弹层，如果是函数需要返回 ref，如果是字符串则是该 DOM 的 id，也可以直接传入 DOM 节点，或者以上值组成的数组
*/
safeNode: _propTypes["default"].any,
/**
* 弹层的根节点的样式类
*/
wrapperClassName: _propTypes["default"].string,
/**
* 弹层的根节点的内联样式
*/
wrapperStyle: _propTypes["default"].object,
/**
* 配置动画的播放方式，支持 { in: 'enter-class', out: 'leave-class' } 的对象参数，如果设置为 false，则不播放动画。 请参考 Animate 组件的文档获取可用的动画名
* @default { in: 'expandInDown', out: 'expandOutUp' }
*/
animation: _propTypes["default"].oneOfType([_propTypes["default"].object, _propTypes["default"].bool]),
onMaskMouseEnter: _propTypes["default"].func,
onMaskMouseLeave: _propTypes["default"].func,
onClick: _propTypes["default"].func
});
_defineProperty(Overlay, "defaultProps", {
prefix: 'next-',
pure: false,
visible: false,
needListenResize: true,
needListenScroll: true,
onRequestClose: noop,
target: _position["default"].VIEWPORT,
align: 'tl bl',
offset: [0, 4],
hasMask: false,
canCloseByEsc: true,
canCloseByOutSideClick: true,
canCloseByMask: true,
beforeOpen: noop,
onOpen: noop,
afterOpen: noop,
beforeClose: noop,
onClose: noop,
afterClose: noop,
beforePosition: noop,
onPosition: noop,
onMaskMouseEnter: noop,
onMaskMouseLeave: noop,
shouldUpdatePosition: false,
autoFocus: false,
needAdjust: true,
disableScroll: false,
cache: false,
onClick: function onClick(e) {
return e.stopPropagation();
}
});