mirror of
https://github.com/MrXujiang/h5-Dooring.git
synced 2026-01-20 12:48:13 +00:00
4195 lines
138 KiB
JavaScript
4195 lines
138 KiB
JavaScript
(window.webpackJsonp = window.webpackJsonp || []).push([
|
||
[112],
|
||
{
|
||
'1j5w': function(ue, N, o) {
|
||
'use strict';
|
||
o.d(N, 'e', function() {
|
||
return H;
|
||
}),
|
||
o.d(N, 'b', function() {
|
||
return ce;
|
||
}),
|
||
o.d(N, 'd', function() {
|
||
return ce;
|
||
}),
|
||
o.d(N, 'c', function() {
|
||
return V;
|
||
}),
|
||
o.d(N, 'a', function() {
|
||
return Ue;
|
||
});
|
||
var i = o('VTBJ'),
|
||
j = o('1OyB'),
|
||
E = o('vuIU'),
|
||
y = o('JX7q'),
|
||
l = o('Ji7U'),
|
||
I = o('LK+K'),
|
||
v = o('q1tI'),
|
||
z = (function() {
|
||
var m = function(d, n) {
|
||
return (
|
||
(m =
|
||
Object.setPrototypeOf ||
|
||
({ __proto__: [] } instanceof Array &&
|
||
function(e, t) {
|
||
e.__proto__ = t;
|
||
}) ||
|
||
function(e, t) {
|
||
for (var a in t) t.hasOwnProperty(a) && (e[a] = t[a]);
|
||
}),
|
||
m(d, n)
|
||
);
|
||
};
|
||
return function(r, d) {
|
||
m(r, d);
|
||
function n() {
|
||
this.constructor = r;
|
||
}
|
||
r.prototype = d === null ? Object.create(d) : ((n.prototype = d.prototype), new n());
|
||
};
|
||
})(),
|
||
S = v.createContext(null),
|
||
g = (function(m) {
|
||
z(r, m);
|
||
function r() {
|
||
return (m !== null && m.apply(this, arguments)) || this;
|
||
}
|
||
return (
|
||
(r.prototype.render = function() {
|
||
return v.createElement(S.Provider, { value: this.props.store }, this.props.children);
|
||
}),
|
||
r
|
||
);
|
||
})(v.Component),
|
||
x = o('Gytx'),
|
||
R = o.n(x),
|
||
B = o('2mql'),
|
||
Y = o.n(B),
|
||
L = (function() {
|
||
var m = function(d, n) {
|
||
return (
|
||
(m =
|
||
Object.setPrototypeOf ||
|
||
({ __proto__: [] } instanceof Array &&
|
||
function(e, t) {
|
||
e.__proto__ = t;
|
||
}) ||
|
||
function(e, t) {
|
||
for (var a in t) t.hasOwnProperty(a) && (e[a] = t[a]);
|
||
}),
|
||
m(d, n)
|
||
);
|
||
};
|
||
return function(r, d) {
|
||
m(r, d);
|
||
function n() {
|
||
this.constructor = r;
|
||
}
|
||
r.prototype = d === null ? Object.create(d) : ((n.prototype = d.prototype), new n());
|
||
};
|
||
})(),
|
||
Z = function() {
|
||
return (
|
||
(Z =
|
||
Object.assign ||
|
||
function(m) {
|
||
for (var r, d = 1, n = arguments.length; d < n; d++) {
|
||
r = arguments[d];
|
||
for (var e in r) Object.prototype.hasOwnProperty.call(r, e) && (m[e] = r[e]);
|
||
}
|
||
return m;
|
||
}),
|
||
Z.apply(this, arguments)
|
||
);
|
||
};
|
||
function me(m) {
|
||
return m.displayName || m.name || 'Component';
|
||
}
|
||
var re = function() {
|
||
return {};
|
||
};
|
||
function Se(m, r) {
|
||
r === void 0 && (r = {});
|
||
var d = !!m,
|
||
n = m || re;
|
||
return function(t) {
|
||
var a = (function(h) {
|
||
L(p, h);
|
||
function p(u, f) {
|
||
var b = h.call(this, u, f) || this;
|
||
return (
|
||
(b.unsubscribe = null),
|
||
(b.handleChange = function() {
|
||
if (!b.unsubscribe) return;
|
||
var W = n(b.store.getState(), b.props);
|
||
b.setState({ subscribed: W });
|
||
}),
|
||
(b.store = b.context),
|
||
(b.state = { subscribed: n(b.store.getState(), u), store: b.store, props: u }),
|
||
b
|
||
);
|
||
}
|
||
return (
|
||
(p.getDerivedStateFromProps = function(u, f) {
|
||
return m && m.length === 2 && u !== f.props
|
||
? { subscribed: n(f.store.getState(), u), props: u }
|
||
: { props: u };
|
||
}),
|
||
(p.prototype.componentDidMount = function() {
|
||
this.trySubscribe();
|
||
}),
|
||
(p.prototype.componentWillUnmount = function() {
|
||
this.tryUnsubscribe();
|
||
}),
|
||
(p.prototype.shouldComponentUpdate = function(u, f) {
|
||
return !R()(this.props, u) || !R()(this.state.subscribed, f.subscribed);
|
||
}),
|
||
(p.prototype.trySubscribe = function() {
|
||
d &&
|
||
((this.unsubscribe = this.store.subscribe(this.handleChange)),
|
||
this.handleChange());
|
||
}),
|
||
(p.prototype.tryUnsubscribe = function() {
|
||
this.unsubscribe && (this.unsubscribe(), (this.unsubscribe = null));
|
||
}),
|
||
(p.prototype.render = function() {
|
||
var u = Z(Z(Z({}, this.props), this.state.subscribed), { store: this.store });
|
||
return v.createElement(t, Z({}, u, { ref: this.props.miniStoreForwardedRef }));
|
||
}),
|
||
(p.displayName = 'Connect(' + me(t) + ')'),
|
||
(p.contextType = S),
|
||
p
|
||
);
|
||
})(v.Component);
|
||
if (r.forwardRef) {
|
||
var c = v.forwardRef(function(h, p) {
|
||
return v.createElement(a, Z({}, h, { miniStoreForwardedRef: p }));
|
||
});
|
||
return Y()(c, t);
|
||
}
|
||
return Y()(a, t);
|
||
};
|
||
}
|
||
var D = function() {
|
||
return (
|
||
(D =
|
||
Object.assign ||
|
||
function(m) {
|
||
for (var r, d = 1, n = arguments.length; d < n; d++) {
|
||
r = arguments[d];
|
||
for (var e in r) Object.prototype.hasOwnProperty.call(r, e) && (m[e] = r[e]);
|
||
}
|
||
return m;
|
||
}),
|
||
D.apply(this, arguments)
|
||
);
|
||
};
|
||
function q(m) {
|
||
var r = m,
|
||
d = [];
|
||
function n(a) {
|
||
r = D(D({}, r), a);
|
||
for (var c = 0; c < d.length; c++) d[c]();
|
||
}
|
||
function e() {
|
||
return r;
|
||
}
|
||
function t(a) {
|
||
return (
|
||
d.push(a),
|
||
function() {
|
||
var h = d.indexOf(a);
|
||
d.splice(h, 1);
|
||
}
|
||
);
|
||
}
|
||
return { setState: n, getState: e, subscribe: t };
|
||
}
|
||
var Ie = o('BGR+'),
|
||
Te = o('wx14'),
|
||
ne = o('rePB'),
|
||
je = o('4IlW'),
|
||
Ye = o('2GS6'),
|
||
ze = o('Zm9Q'),
|
||
et = o('TSYQ'),
|
||
We = o.n(et),
|
||
tt = o('U8pU'),
|
||
dt = o('ODXe'),
|
||
nt = /iPhone/i,
|
||
Qe = /iPod/i,
|
||
at = /iPad/i,
|
||
He = /\bAndroid(?:.+)Mobile\b/i,
|
||
Xe = /Android/i,
|
||
Be = /\bAndroid(?:.+)SD4930UR\b/i,
|
||
Ve = /\bAndroid(?:.+)(?:KF[A-Z]{2,4})\b/i,
|
||
xe = /Windows Phone/i,
|
||
ot = /\bWindows(?:.+)ARM\b/i,
|
||
rt = /BlackBerry/i,
|
||
Je = /BB10/i,
|
||
it = /Opera Mini/i,
|
||
st = /\b(CriOS|Chrome)(?:.+)Mobile/i,
|
||
ft = /Mobile(?:.+)Firefox\b/i;
|
||
function P(m, r) {
|
||
return m.test(r);
|
||
}
|
||
function lt(m) {
|
||
var r = m || (typeof navigator != 'undefined' ? navigator.userAgent : ''),
|
||
d = r.split('[FBAN');
|
||
if (typeof d[1] != 'undefined') {
|
||
var n = d,
|
||
e = Object(dt.a)(n, 1);
|
||
r = e[0];
|
||
}
|
||
if (((d = r.split('Twitter')), typeof d[1] != 'undefined')) {
|
||
var t = d,
|
||
a = Object(dt.a)(t, 1);
|
||
r = a[0];
|
||
}
|
||
var c = {
|
||
apple: {
|
||
phone: P(nt, r) && !P(xe, r),
|
||
ipod: P(Qe, r),
|
||
tablet: !P(nt, r) && P(at, r) && !P(xe, r),
|
||
device: (P(nt, r) || P(Qe, r) || P(at, r)) && !P(xe, r),
|
||
},
|
||
amazon: { phone: P(Be, r), tablet: !P(Be, r) && P(Ve, r), device: P(Be, r) || P(Ve, r) },
|
||
android: {
|
||
phone: (!P(xe, r) && P(Be, r)) || (!P(xe, r) && P(He, r)),
|
||
tablet: !P(xe, r) && !P(Be, r) && !P(He, r) && (P(Ve, r) || P(Xe, r)),
|
||
device:
|
||
(!P(xe, r) && (P(Be, r) || P(Ve, r) || P(He, r) || P(Xe, r))) || P(/\bokhttp\b/i, r),
|
||
},
|
||
windows: { phone: P(xe, r), tablet: P(ot, r), device: P(xe, r) || P(ot, r) },
|
||
other: {
|
||
blackberry: P(rt, r),
|
||
blackberry10: P(Je, r),
|
||
opera: P(it, r),
|
||
firefox: P(ft, r),
|
||
chrome: P(st, r),
|
||
device: P(rt, r) || P(Je, r) || P(it, r) || P(ft, r) || P(st, r),
|
||
},
|
||
any: null,
|
||
phone: null,
|
||
tablet: null,
|
||
};
|
||
return (
|
||
(c.any = c.apple.device || c.android.device || c.windows.device || c.other.device),
|
||
(c.phone = c.apple.phone || c.android.phone || c.windows.phone),
|
||
(c.tablet = c.apple.tablet || c.android.tablet || c.windows.tablet),
|
||
c
|
||
);
|
||
}
|
||
var ht = Object(i.a)(Object(i.a)({}, lt()), {}, { isMobile: lt }),
|
||
bt = ht;
|
||
function Ee() {}
|
||
function $e(m, r, d) {
|
||
var n = r || '';
|
||
return m.key || ''.concat(n, 'item_').concat(d);
|
||
}
|
||
function _e(m) {
|
||
return ''.concat(m, '-menu-');
|
||
}
|
||
function ee(m, r) {
|
||
var d = -1;
|
||
v.Children.forEach(m, function(n) {
|
||
(d += 1),
|
||
n && n.type && n.type.isMenuItemGroup
|
||
? v.Children.forEach(n.props.children, function(e) {
|
||
(d += 1), r(e, d);
|
||
})
|
||
: r(n, d);
|
||
});
|
||
}
|
||
function Oe(m, r, d) {
|
||
if (!m || d.find) return;
|
||
v.Children.forEach(m, function(n) {
|
||
if (n) {
|
||
var e = n.type;
|
||
if (!e || !(e.isSubMenu || e.isMenuItem || e.isMenuItemGroup)) return;
|
||
r.indexOf(n.key) !== -1
|
||
? (d.find = !0)
|
||
: n.props.children && Oe(n.props.children, r, d);
|
||
}
|
||
});
|
||
}
|
||
var we = [
|
||
'defaultSelectedKeys',
|
||
'selectedKeys',
|
||
'defaultOpenKeys',
|
||
'openKeys',
|
||
'mode',
|
||
'getPopupContainer',
|
||
'onSelect',
|
||
'onDeselect',
|
||
'onDestroy',
|
||
'openTransitionName',
|
||
'openAnimation',
|
||
'subMenuOpenDelay',
|
||
'subMenuCloseDelay',
|
||
'forceSubMenuRender',
|
||
'triggerSubMenuAction',
|
||
'level',
|
||
'selectable',
|
||
'multiple',
|
||
'onOpenChange',
|
||
'visible',
|
||
'focusable',
|
||
'defaultActiveFirst',
|
||
'prefixCls',
|
||
'inlineIndent',
|
||
'parentMenu',
|
||
'title',
|
||
'rootPrefixCls',
|
||
'eventKey',
|
||
'active',
|
||
'onItemHover',
|
||
'onTitleMouseEnter',
|
||
'onTitleMouseLeave',
|
||
'onTitleClick',
|
||
'popupAlign',
|
||
'popupOffset',
|
||
'isOpen',
|
||
'renderMenuItem',
|
||
'manualRef',
|
||
'subMenuKey',
|
||
'disabled',
|
||
'index',
|
||
'isSelected',
|
||
'store',
|
||
'activeKey',
|
||
'builtinPlacements',
|
||
'overflowedIndicator',
|
||
'motion',
|
||
'attribute',
|
||
'value',
|
||
'popupClassName',
|
||
'inlineCollapsed',
|
||
'menu',
|
||
'theme',
|
||
'itemIcon',
|
||
'expandIcon',
|
||
],
|
||
yt = function(r) {
|
||
var d = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !1,
|
||
n =
|
||
r && typeof r.getBoundingClientRect == 'function' && r.getBoundingClientRect().width;
|
||
if (n) {
|
||
if (d) {
|
||
var e = getComputedStyle(r),
|
||
t = e.marginLeft,
|
||
a = e.marginRight;
|
||
n += +t.replace('px', '') + +a.replace('px', '');
|
||
}
|
||
n = +n.toFixed(6);
|
||
}
|
||
return n || 0;
|
||
},
|
||
mt = function(r, d, n) {
|
||
r && Object(tt.a)(r.style) === 'object' && (r.style[d] = n);
|
||
},
|
||
Lt = function() {
|
||
return bt.any;
|
||
},
|
||
It = o('KQm4'),
|
||
Dt = o('Ff2n'),
|
||
ct = o('i8i4'),
|
||
jt = o('bdgK'),
|
||
Gt = o('uciX'),
|
||
s = o('8XRh'),
|
||
O = { adjustX: 1, adjustY: 1 },
|
||
C = {
|
||
topLeft: { points: ['bl', 'tl'], overflow: O, offset: [0, -7] },
|
||
bottomLeft: { points: ['tl', 'bl'], overflow: O, offset: [0, 7] },
|
||
leftTop: { points: ['tr', 'tl'], overflow: O, offset: [-4, 0] },
|
||
rightTop: { points: ['tl', 'tr'], overflow: O, offset: [4, 0] },
|
||
},
|
||
A = {
|
||
topLeft: { points: ['bl', 'tl'], overflow: O, offset: [0, -7] },
|
||
bottomLeft: { points: ['tl', 'bl'], overflow: O, offset: [0, 7] },
|
||
rightTop: { points: ['tr', 'tl'], overflow: O, offset: [-4, 0] },
|
||
leftTop: { points: ['tl', 'tr'], overflow: O, offset: [4, 0] },
|
||
},
|
||
M = C,
|
||
T = 0,
|
||
K = {
|
||
horizontal: 'bottomLeft',
|
||
vertical: 'rightTop',
|
||
'vertical-left': 'rightTop',
|
||
'vertical-right': 'leftTop',
|
||
},
|
||
_ = function(r, d, n) {
|
||
var e = _e(d),
|
||
t = r.getState();
|
||
r.setState({
|
||
defaultActiveFirst: Object(i.a)(
|
||
Object(i.a)({}, t.defaultActiveFirst),
|
||
{},
|
||
Object(ne.a)({}, e, n),
|
||
),
|
||
});
|
||
},
|
||
U = (function(m) {
|
||
Object(l.a)(d, m);
|
||
var r = Object(I.a)(d);
|
||
function d(n) {
|
||
var e;
|
||
Object(j.a)(this, d),
|
||
(e = r.call(this, n)),
|
||
(e.onDestroy = function(u) {
|
||
e.props.onDestroy(u);
|
||
}),
|
||
(e.onKeyDown = function(u) {
|
||
var f = u.keyCode,
|
||
b = e.menuInstance,
|
||
W = e.props,
|
||
w = W.isOpen,
|
||
se = W.store;
|
||
if (f === je.a.ENTER) return e.onTitleClick(u), _(se, e.props.eventKey, !0), !0;
|
||
if (f === je.a.RIGHT)
|
||
return (
|
||
w ? b.onKeyDown(u) : (e.triggerOpenChange(!0), _(se, e.props.eventKey, !0)), !0
|
||
);
|
||
if (f === je.a.LEFT) {
|
||
var $;
|
||
if (w) $ = b.onKeyDown(u);
|
||
else return;
|
||
return $ || (e.triggerOpenChange(!1), ($ = !0)), $;
|
||
}
|
||
return w && (f === je.a.UP || f === je.a.DOWN) ? b.onKeyDown(u) : void 0;
|
||
}),
|
||
(e.onOpenChange = function(u) {
|
||
e.props.onOpenChange(u);
|
||
}),
|
||
(e.onPopupVisibleChange = function(u) {
|
||
e.triggerOpenChange(u, u ? 'mouseenter' : 'mouseleave');
|
||
}),
|
||
(e.onMouseEnter = function(u) {
|
||
var f = e.props,
|
||
b = f.eventKey,
|
||
W = f.onMouseEnter,
|
||
w = f.store;
|
||
_(w, e.props.eventKey, !1), W({ key: b, domEvent: u });
|
||
}),
|
||
(e.onMouseLeave = function(u) {
|
||
var f = e.props,
|
||
b = f.parentMenu,
|
||
W = f.eventKey,
|
||
w = f.onMouseLeave;
|
||
(b.subMenuInstance = Object(y.a)(e)), w({ key: W, domEvent: u });
|
||
}),
|
||
(e.onTitleMouseEnter = function(u) {
|
||
var f = e.props,
|
||
b = f.eventKey,
|
||
W = f.onItemHover,
|
||
w = f.onTitleMouseEnter;
|
||
W({ key: b, hover: !0 }), w({ key: b, domEvent: u });
|
||
}),
|
||
(e.onTitleMouseLeave = function(u) {
|
||
var f = e.props,
|
||
b = f.parentMenu,
|
||
W = f.eventKey,
|
||
w = f.onItemHover,
|
||
se = f.onTitleMouseLeave;
|
||
(b.subMenuInstance = Object(y.a)(e)),
|
||
w({ key: W, hover: !1 }),
|
||
se({ key: W, domEvent: u });
|
||
}),
|
||
(e.onTitleClick = function(u) {
|
||
var f = Object(y.a)(e),
|
||
b = f.props;
|
||
if (
|
||
(b.onTitleClick({ key: b.eventKey, domEvent: u }),
|
||
b.triggerSubMenuAction === 'hover')
|
||
)
|
||
return;
|
||
e.triggerOpenChange(!b.isOpen, 'click'), _(b.store, e.props.eventKey, !1);
|
||
}),
|
||
(e.onSubMenuClick = function(u) {
|
||
typeof e.props.onClick == 'function' && e.props.onClick(e.addKeyPath(u));
|
||
}),
|
||
(e.onSelect = function(u) {
|
||
e.props.onSelect(u);
|
||
}),
|
||
(e.onDeselect = function(u) {
|
||
e.props.onDeselect(u);
|
||
}),
|
||
(e.getPrefixCls = function() {
|
||
return ''.concat(e.props.rootPrefixCls, '-submenu');
|
||
}),
|
||
(e.getActiveClassName = function() {
|
||
return ''.concat(e.getPrefixCls(), '-active');
|
||
}),
|
||
(e.getDisabledClassName = function() {
|
||
return ''.concat(e.getPrefixCls(), '-disabled');
|
||
}),
|
||
(e.getSelectedClassName = function() {
|
||
return ''.concat(e.getPrefixCls(), '-selected');
|
||
}),
|
||
(e.getOpenClassName = function() {
|
||
return ''.concat(e.props.rootPrefixCls, '-submenu-open');
|
||
}),
|
||
(e.saveMenuInstance = function(u) {
|
||
e.menuInstance = u;
|
||
}),
|
||
(e.addKeyPath = function(u) {
|
||
return Object(i.a)(
|
||
Object(i.a)({}, u),
|
||
{},
|
||
{ keyPath: (u.keyPath || []).concat(e.props.eventKey) },
|
||
);
|
||
}),
|
||
(e.triggerOpenChange = function(u, f) {
|
||
var b = e.props.eventKey,
|
||
W = function() {
|
||
e.onOpenChange({ key: b, item: Object(y.a)(e), trigger: f, open: u });
|
||
};
|
||
f === 'mouseenter'
|
||
? (e.mouseenterTimeout = setTimeout(function() {
|
||
W();
|
||
}, 0))
|
||
: W();
|
||
}),
|
||
(e.isChildrenSelected = function() {
|
||
var u = { find: !1 };
|
||
return Oe(e.props.children, e.props.selectedKeys, u), u.find;
|
||
}),
|
||
(e.isOpen = function() {
|
||
return e.props.openKeys.indexOf(e.props.eventKey) !== -1;
|
||
}),
|
||
(e.adjustWidth = function() {
|
||
if (!e.subMenuTitle || !e.menuInstance) return;
|
||
var u = ct.findDOMNode(e.menuInstance);
|
||
if (u.offsetWidth >= e.subMenuTitle.offsetWidth) return;
|
||
u.style.minWidth = ''.concat(e.subMenuTitle.offsetWidth, 'px');
|
||
}),
|
||
(e.saveSubMenuTitle = function(u) {
|
||
e.subMenuTitle = u;
|
||
}),
|
||
(e.getBaseProps = function() {
|
||
var u = Object(y.a)(e),
|
||
f = u.props;
|
||
return {
|
||
mode: f.mode === 'horizontal' ? 'vertical' : f.mode,
|
||
visible: e.props.isOpen,
|
||
level: f.level + 1,
|
||
inlineIndent: f.inlineIndent,
|
||
focusable: !1,
|
||
onClick: e.onSubMenuClick,
|
||
onSelect: e.onSelect,
|
||
onDeselect: e.onDeselect,
|
||
onDestroy: e.onDestroy,
|
||
selectedKeys: f.selectedKeys,
|
||
eventKey: ''.concat(f.eventKey, '-menu-'),
|
||
openKeys: f.openKeys,
|
||
motion: f.motion,
|
||
onOpenChange: e.onOpenChange,
|
||
subMenuOpenDelay: f.subMenuOpenDelay,
|
||
parentMenu: Object(y.a)(e),
|
||
subMenuCloseDelay: f.subMenuCloseDelay,
|
||
forceSubMenuRender: f.forceSubMenuRender,
|
||
triggerSubMenuAction: f.triggerSubMenuAction,
|
||
builtinPlacements: f.builtinPlacements,
|
||
defaultActiveFirst: f.store.getState().defaultActiveFirst[_e(f.eventKey)],
|
||
multiple: f.multiple,
|
||
prefixCls: f.rootPrefixCls,
|
||
id: e.internalMenuId,
|
||
manualRef: e.saveMenuInstance,
|
||
itemIcon: f.itemIcon,
|
||
expandIcon: f.expandIcon,
|
||
direction: f.direction,
|
||
};
|
||
}),
|
||
(e.getMotion = function(u, f) {
|
||
var b = Object(y.a)(e),
|
||
W = b.haveRendered,
|
||
w = e.props,
|
||
se = w.motion,
|
||
$ = w.rootPrefixCls,
|
||
Pe = Object(i.a)(
|
||
Object(i.a)({}, se),
|
||
{},
|
||
{
|
||
leavedClassName: ''.concat($, '-hidden'),
|
||
removeOnLeave: !1,
|
||
motionAppear: W || !f || u !== 'inline',
|
||
},
|
||
);
|
||
return Pe;
|
||
});
|
||
var t = n.store,
|
||
a = n.eventKey,
|
||
c = t.getState(),
|
||
h = c.defaultActiveFirst;
|
||
e.isRootMenu = !1;
|
||
var p = !1;
|
||
return h && (p = h[a]), _(t, a, p), e;
|
||
}
|
||
return (
|
||
Object(E.a)(d, [
|
||
{
|
||
key: 'componentDidMount',
|
||
value: function() {
|
||
this.componentDidUpdate();
|
||
},
|
||
},
|
||
{
|
||
key: 'componentDidUpdate',
|
||
value: function() {
|
||
var e = this,
|
||
t = this.props,
|
||
a = t.mode,
|
||
c = t.parentMenu,
|
||
h = t.manualRef,
|
||
p = t.isOpen;
|
||
if (
|
||
(h && h(this), a !== 'horizontal' || !(c == null ? void 0 : c.isRootMenu) || !p)
|
||
)
|
||
return;
|
||
this.minWidthTimeout = setTimeout(function() {
|
||
return e.adjustWidth();
|
||
}, 0);
|
||
},
|
||
},
|
||
{
|
||
key: 'componentWillUnmount',
|
||
value: function() {
|
||
var e = this.props,
|
||
t = e.onDestroy,
|
||
a = e.eventKey;
|
||
t && t(a),
|
||
this.minWidthTimeout && clearTimeout(this.minWidthTimeout),
|
||
this.mouseenterTimeout && clearTimeout(this.mouseenterTimeout);
|
||
},
|
||
},
|
||
{
|
||
key: 'renderChildren',
|
||
value: function(e) {
|
||
var t = this,
|
||
a = this.getBaseProps(),
|
||
c = this.getMotion(a.mode, a.visible);
|
||
if (
|
||
((this.haveRendered = !0),
|
||
(this.haveOpened = this.haveOpened || a.visible || a.forceSubMenuRender),
|
||
!this.haveOpened)
|
||
)
|
||
return v.createElement('div', null);
|
||
var h = a.direction;
|
||
return v.createElement(
|
||
s.default,
|
||
Object.assign({ visible: a.visible }, c),
|
||
function(p) {
|
||
var u = p.className,
|
||
f = p.style,
|
||
b = We()(
|
||
''.concat(a.prefixCls, '-sub'),
|
||
u,
|
||
Object(ne.a)({}, ''.concat(a.prefixCls, '-rtl'), h === 'rtl'),
|
||
);
|
||
return v.createElement(
|
||
de,
|
||
Object.assign({}, a, { id: t.internalMenuId, className: b, style: f }),
|
||
e,
|
||
);
|
||
},
|
||
);
|
||
},
|
||
},
|
||
{
|
||
key: 'render',
|
||
value: function() {
|
||
var e,
|
||
t,
|
||
a = Object(i.a)({}, this.props),
|
||
c = a.isOpen,
|
||
h = this.getPrefixCls(),
|
||
p = a.mode === 'inline',
|
||
u = We()(
|
||
h,
|
||
''.concat(h, '-').concat(a.mode),
|
||
((e = {}),
|
||
Object(ne.a)(e, a.className, !!a.className),
|
||
Object(ne.a)(e, this.getOpenClassName(), c),
|
||
Object(ne.a)(e, this.getActiveClassName(), a.active || (c && !p)),
|
||
Object(ne.a)(e, this.getDisabledClassName(), a.disabled),
|
||
Object(ne.a)(e, this.getSelectedClassName(), this.isChildrenSelected()),
|
||
e),
|
||
);
|
||
this.internalMenuId ||
|
||
(a.eventKey
|
||
? (this.internalMenuId = ''.concat(a.eventKey, '$Menu'))
|
||
: ((T += 1), (this.internalMenuId = '$__$'.concat(T, '$Menu'))));
|
||
var f = {},
|
||
b = {},
|
||
W = {};
|
||
a.disabled ||
|
||
((f = { onMouseLeave: this.onMouseLeave, onMouseEnter: this.onMouseEnter }),
|
||
(b = { onClick: this.onTitleClick }),
|
||
(W = {
|
||
onMouseEnter: this.onTitleMouseEnter,
|
||
onMouseLeave: this.onTitleMouseLeave,
|
||
}));
|
||
var w = {},
|
||
se = a.direction;
|
||
p &&
|
||
(se === 'rtl'
|
||
? (w.paddingRight = a.inlineIndent * a.level)
|
||
: (w.paddingLeft = a.inlineIndent * a.level));
|
||
var $ = {};
|
||
this.props.isOpen && ($ = { 'aria-owns': this.internalMenuId });
|
||
var Pe = null;
|
||
a.mode !== 'horizontal' &&
|
||
((Pe = this.props.expandIcon),
|
||
typeof this.props.expandIcon == 'function' &&
|
||
(Pe = v.createElement(this.props.expandIcon, Object(i.a)({}, this.props))));
|
||
var Ge = v.createElement(
|
||
'div',
|
||
Object.assign(
|
||
{
|
||
ref: this.saveSubMenuTitle,
|
||
style: w,
|
||
className: ''.concat(h, '-title'),
|
||
role: 'button',
|
||
},
|
||
W,
|
||
b,
|
||
{ 'aria-expanded': c },
|
||
$,
|
||
{
|
||
'aria-haspopup': 'true',
|
||
title: typeof a.title == 'string' ? a.title : void 0,
|
||
},
|
||
),
|
||
a.title,
|
||
Pe || v.createElement('i', { className: ''.concat(h, '-arrow') }),
|
||
),
|
||
Fe = this.renderChildren(a.children),
|
||
Re = ((t = a.parentMenu) === null || t === void 0
|
||
? void 0
|
||
: t.isRootMenu)
|
||
? a.parentMenu.props.getPopupContainer
|
||
: function(vt) {
|
||
return vt.parentNode;
|
||
},
|
||
ut = K[a.mode],
|
||
Et = a.popupOffset ? { offset: a.popupOffset } : {},
|
||
Ze = a.mode === 'inline' ? '' : a.popupClassName;
|
||
Ze += se === 'rtl' ? ' '.concat(h, '-rtl') : '';
|
||
var Ke = a.disabled,
|
||
Ut = a.triggerSubMenuAction,
|
||
_t = a.subMenuOpenDelay,
|
||
Rt = a.forceSubMenuRender,
|
||
wt = a.subMenuCloseDelay,
|
||
Pt = a.builtinPlacements;
|
||
we.forEach(function(vt) {
|
||
return delete a[vt];
|
||
}),
|
||
delete a.onClick;
|
||
var Kt = se === 'rtl' ? Object.assign({}, A, Pt) : Object.assign({}, C, Pt);
|
||
return (
|
||
delete a.direction,
|
||
v.createElement(
|
||
'li',
|
||
Object.assign({}, a, f, { className: u, role: 'menuitem' }),
|
||
p && Ge,
|
||
p && Fe,
|
||
!p &&
|
||
v.createElement(
|
||
Gt.a,
|
||
{
|
||
prefixCls: h,
|
||
popupClassName: We()(''.concat(h, '-popup'), Ze),
|
||
getPopupContainer: Re,
|
||
builtinPlacements: Kt,
|
||
popupPlacement: ut,
|
||
popupVisible: c,
|
||
popupAlign: Et,
|
||
popup: Fe,
|
||
action: Ke ? [] : [Ut],
|
||
mouseEnterDelay: _t,
|
||
mouseLeaveDelay: wt,
|
||
onPopupVisibleChange: this.onPopupVisibleChange,
|
||
forceRender: Rt,
|
||
},
|
||
Ge,
|
||
),
|
||
)
|
||
);
|
||
},
|
||
},
|
||
]),
|
||
d
|
||
);
|
||
})(v.Component);
|
||
U.defaultProps = {
|
||
onMouseEnter: Ee,
|
||
onMouseLeave: Ee,
|
||
onTitleMouseEnter: Ee,
|
||
onTitleMouseLeave: Ee,
|
||
onTitleClick: Ee,
|
||
manualRef: Ee,
|
||
mode: 'vertical',
|
||
title: '',
|
||
};
|
||
var Q = Se(function(m, r) {
|
||
var d = m.openKeys,
|
||
n = m.activeKey,
|
||
e = m.selectedKeys,
|
||
t = r.eventKey,
|
||
a = r.subMenuKey;
|
||
return { isOpen: d.indexOf(t) > -1, active: n[a] === t, selectedKeys: e };
|
||
})(U);
|
||
Q.isSubMenu = !0;
|
||
var H = Q,
|
||
X = 'menuitem-overflowed',
|
||
te = 0.5,
|
||
he = (function(m) {
|
||
Object(l.a)(d, m);
|
||
var r = Object(I.a)(d);
|
||
function d() {
|
||
var n;
|
||
return (
|
||
Object(j.a)(this, d),
|
||
(n = r.apply(this, arguments)),
|
||
(n.resizeObserver = null),
|
||
(n.mutationObserver = null),
|
||
(n.originalTotalWidth = 0),
|
||
(n.overflowedItems = []),
|
||
(n.menuItemSizes = []),
|
||
(n.cancelFrameId = null),
|
||
(n.state = { lastVisibleIndex: void 0 }),
|
||
(n.getMenuItemNodes = function() {
|
||
var e = n.props.prefixCls,
|
||
t = ct.findDOMNode(Object(y.a)(n));
|
||
return t
|
||
? [].slice.call(t.children).filter(function(a) {
|
||
return (
|
||
a.className.split(' ').indexOf(''.concat(e, '-overflowed-submenu')) < 0
|
||
);
|
||
})
|
||
: [];
|
||
}),
|
||
(n.getOverflowedSubMenuItem = function(e, t, a) {
|
||
var c = n.props,
|
||
h = c.overflowedIndicator,
|
||
p = c.level,
|
||
u = c.mode,
|
||
f = c.prefixCls,
|
||
b = c.theme;
|
||
if (p !== 1 || u !== 'horizontal') return null;
|
||
var W = n.props.children[0],
|
||
w = W.props,
|
||
se = w.children,
|
||
$ = w.title,
|
||
Pe = w.style,
|
||
Ge = Object(Dt.a)(w, ['children', 'title', 'style']),
|
||
Fe = Object(i.a)({}, Pe),
|
||
Re = ''.concat(e, '-overflowed-indicator'),
|
||
ut = ''.concat(e, '-overflowed-indicator');
|
||
t.length === 0 && a !== !0
|
||
? (Fe = Object(i.a)(Object(i.a)({}, Fe), {}, { display: 'none' }))
|
||
: a &&
|
||
((Fe = Object(i.a)(
|
||
Object(i.a)({}, Fe),
|
||
{},
|
||
{ visibility: 'hidden', position: 'absolute' },
|
||
)),
|
||
(Re = ''.concat(Re, '-placeholder')),
|
||
(ut = ''.concat(ut, '-placeholder')));
|
||
var Et = b ? ''.concat(f, '-').concat(b) : '',
|
||
Ze = {};
|
||
return (
|
||
we.forEach(function(Ke) {
|
||
Ge[Ke] !== void 0 && (Ze[Ke] = Ge[Ke]);
|
||
}),
|
||
v.createElement(
|
||
H,
|
||
Object.assign(
|
||
{
|
||
title: h,
|
||
className: ''.concat(f, '-overflowed-submenu'),
|
||
popupClassName: Et,
|
||
},
|
||
Ze,
|
||
{ key: Re, eventKey: ut, disabled: !1, style: Fe },
|
||
),
|
||
t,
|
||
)
|
||
);
|
||
}),
|
||
(n.setChildrenWidthAndResize = function() {
|
||
if (n.props.mode !== 'horizontal') return;
|
||
var e = ct.findDOMNode(Object(y.a)(n));
|
||
if (!e) return;
|
||
var t = e.children;
|
||
if (!t || t.length === 0) return;
|
||
var a = e.children[t.length - 1];
|
||
mt(a, 'display', 'inline-block');
|
||
var c = n.getMenuItemNodes(),
|
||
h = c.filter(function(p) {
|
||
return p.className.split(' ').indexOf(X) >= 0;
|
||
});
|
||
h.forEach(function(p) {
|
||
mt(p, 'display', 'inline-block');
|
||
}),
|
||
(n.menuItemSizes = c.map(function(p) {
|
||
return yt(p, !0);
|
||
})),
|
||
h.forEach(function(p) {
|
||
mt(p, 'display', 'none');
|
||
}),
|
||
(n.overflowedIndicatorWidth = yt(e.children[e.children.length - 1], !0)),
|
||
(n.originalTotalWidth = n.menuItemSizes.reduce(function(p, u) {
|
||
return p + u;
|
||
}, 0)),
|
||
n.handleResize(),
|
||
mt(a, 'display', 'none');
|
||
}),
|
||
(n.handleResize = function() {
|
||
if (n.props.mode !== 'horizontal') return;
|
||
var e = ct.findDOMNode(Object(y.a)(n));
|
||
if (!e) return;
|
||
var t = yt(e);
|
||
n.overflowedItems = [];
|
||
var a = 0,
|
||
c;
|
||
n.originalTotalWidth > t + te &&
|
||
((c = -1),
|
||
n.menuItemSizes.forEach(function(h) {
|
||
(a += h), a + n.overflowedIndicatorWidth <= t && (c += 1);
|
||
})),
|
||
n.setState({ lastVisibleIndex: c });
|
||
}),
|
||
n
|
||
);
|
||
}
|
||
return (
|
||
Object(E.a)(d, [
|
||
{
|
||
key: 'componentDidMount',
|
||
value: function() {
|
||
var e = this;
|
||
if (
|
||
(this.setChildrenWidthAndResize(),
|
||
this.props.level === 1 && this.props.mode === 'horizontal')
|
||
) {
|
||
var t = ct.findDOMNode(this);
|
||
if (!t) return;
|
||
(this.resizeObserver = new jt.a(function(a) {
|
||
a.forEach(function() {
|
||
var c = e.cancelFrameId;
|
||
cancelAnimationFrame(c),
|
||
(e.cancelFrameId = requestAnimationFrame(e.setChildrenWidthAndResize));
|
||
});
|
||
})),
|
||
[].slice
|
||
.call(t.children)
|
||
.concat(t)
|
||
.forEach(function(a) {
|
||
e.resizeObserver.observe(a);
|
||
}),
|
||
typeof MutationObserver != 'undefined' &&
|
||
((this.mutationObserver = new MutationObserver(function() {
|
||
e.resizeObserver.disconnect(),
|
||
[].slice
|
||
.call(t.children)
|
||
.concat(t)
|
||
.forEach(function(a) {
|
||
e.resizeObserver.observe(a);
|
||
}),
|
||
e.setChildrenWidthAndResize();
|
||
})),
|
||
this.mutationObserver.observe(t, {
|
||
attributes: !1,
|
||
childList: !0,
|
||
subTree: !1,
|
||
}));
|
||
}
|
||
},
|
||
},
|
||
{
|
||
key: 'componentWillUnmount',
|
||
value: function() {
|
||
this.resizeObserver && this.resizeObserver.disconnect(),
|
||
this.mutationObserver && this.mutationObserver.disconnect(),
|
||
cancelAnimationFrame(this.cancelFrameId);
|
||
},
|
||
},
|
||
{
|
||
key: 'renderChildren',
|
||
value: function(e) {
|
||
var t = this,
|
||
a = this.state.lastVisibleIndex;
|
||
return (e || []).reduce(function(c, h, p) {
|
||
var u = h;
|
||
if (t.props.mode === 'horizontal') {
|
||
var f = t.getOverflowedSubMenuItem(h.props.eventKey, []);
|
||
a !== void 0 &&
|
||
t.props.className.indexOf(''.concat(t.props.prefixCls, '-root')) !== -1 &&
|
||
(p > a &&
|
||
(u = v.cloneElement(h, {
|
||
style: { display: 'none' },
|
||
eventKey: ''.concat(h.props.eventKey, '-hidden'),
|
||
className: ''.concat(X),
|
||
})),
|
||
p === a + 1 &&
|
||
((t.overflowedItems = e.slice(a + 1).map(function(W) {
|
||
return v.cloneElement(W, {
|
||
key: W.props.eventKey,
|
||
mode: 'vertical-left',
|
||
});
|
||
})),
|
||
(f = t.getOverflowedSubMenuItem(h.props.eventKey, t.overflowedItems))));
|
||
var b = [].concat(Object(It.a)(c), [f, u]);
|
||
return (
|
||
p === e.length - 1 &&
|
||
b.push(t.getOverflowedSubMenuItem(h.props.eventKey, [], !0)),
|
||
b
|
||
);
|
||
}
|
||
return [].concat(Object(It.a)(c), [u]);
|
||
}, []);
|
||
},
|
||
},
|
||
{
|
||
key: 'render',
|
||
value: function() {
|
||
var e = this.props,
|
||
t = e.visible,
|
||
a = e.prefixCls,
|
||
c = e.overflowedIndicator,
|
||
h = e.mode,
|
||
p = e.level,
|
||
u = e.tag,
|
||
f = e.children,
|
||
b = e.theme,
|
||
W = Object(Dt.a)(e, [
|
||
'visible',
|
||
'prefixCls',
|
||
'overflowedIndicator',
|
||
'mode',
|
||
'level',
|
||
'tag',
|
||
'children',
|
||
'theme',
|
||
]),
|
||
w = u;
|
||
return v.createElement(w, Object.assign({}, W), this.renderChildren(f));
|
||
},
|
||
},
|
||
]),
|
||
d
|
||
);
|
||
})(v.Component);
|
||
he.defaultProps = { tag: 'div', className: '' };
|
||
var ae = he;
|
||
function J(m) {
|
||
return m.length
|
||
? m.every(function(r) {
|
||
return !!r.props.disabled;
|
||
})
|
||
: !0;
|
||
}
|
||
function ge(m, r, d) {
|
||
var n = m.getState();
|
||
m.setState({
|
||
activeKey: Object(i.a)(Object(i.a)({}, n.activeKey), {}, Object(ne.a)({}, r, d)),
|
||
});
|
||
}
|
||
function ie(m) {
|
||
return m.eventKey || '0-menu-';
|
||
}
|
||
function le(m, r) {
|
||
var d = r,
|
||
n = m.children,
|
||
e = m.eventKey;
|
||
if (d) {
|
||
var t;
|
||
if (
|
||
(ee(n, function(a, c) {
|
||
a && a.props && !a.props.disabled && d === $e(a, e, c) && (t = !0);
|
||
}),
|
||
t)
|
||
)
|
||
return d;
|
||
}
|
||
return (
|
||
(d = null),
|
||
m.defaultActiveFirst &&
|
||
ee(n, function(a, c) {
|
||
!d && a && !a.props.disabled && (d = $e(a, e, c));
|
||
}),
|
||
d
|
||
);
|
||
}
|
||
function be(m) {
|
||
if (m) {
|
||
var r = this.instanceArray.indexOf(m);
|
||
r !== -1 ? (this.instanceArray[r] = m) : this.instanceArray.push(m);
|
||
}
|
||
}
|
||
var ve = (function(m) {
|
||
Object(l.a)(d, m);
|
||
var r = Object(I.a)(d);
|
||
function d(n) {
|
||
var e;
|
||
return (
|
||
Object(j.a)(this, d),
|
||
(e = r.call(this, n)),
|
||
(e.onKeyDown = function(t, a) {
|
||
var c = t.keyCode,
|
||
h;
|
||
if (
|
||
(e.getFlatInstanceArray().forEach(function(u) {
|
||
u && u.props.active && u.onKeyDown && (h = u.onKeyDown(t));
|
||
}),
|
||
h)
|
||
)
|
||
return 1;
|
||
var p = null;
|
||
return (
|
||
(c === je.a.UP || c === je.a.DOWN) && (p = e.step(c === je.a.UP ? -1 : 1)),
|
||
p
|
||
? (t.preventDefault(),
|
||
ge(e.props.store, ie(e.props), p.props.eventKey),
|
||
typeof a == 'function' && a(p),
|
||
1)
|
||
: void 0
|
||
);
|
||
}),
|
||
(e.onItemHover = function(t) {
|
||
var a = t.key,
|
||
c = t.hover;
|
||
ge(e.props.store, ie(e.props), c ? a : null);
|
||
}),
|
||
(e.onDeselect = function(t) {
|
||
e.props.onDeselect(t);
|
||
}),
|
||
(e.onSelect = function(t) {
|
||
e.props.onSelect(t);
|
||
}),
|
||
(e.onClick = function(t) {
|
||
e.props.onClick(t);
|
||
}),
|
||
(e.onOpenChange = function(t) {
|
||
e.props.onOpenChange(t);
|
||
}),
|
||
(e.onDestroy = function(t) {
|
||
e.props.onDestroy(t);
|
||
}),
|
||
(e.getFlatInstanceArray = function() {
|
||
return e.instanceArray;
|
||
}),
|
||
(e.step = function(t) {
|
||
var a = e.getFlatInstanceArray(),
|
||
c = e.props.store.getState().activeKey[ie(e.props)],
|
||
h = a.length;
|
||
if (!h) return null;
|
||
t < 0 && (a = a.concat().reverse());
|
||
var p = -1;
|
||
if (
|
||
(a.every(function(W, w) {
|
||
return W && W.props.eventKey === c ? ((p = w), !1) : !0;
|
||
}),
|
||
!e.props.defaultActiveFirst && p !== -1 && J(a.slice(p, h - 1)))
|
||
)
|
||
return;
|
||
var u = (p + 1) % h,
|
||
f = u;
|
||
do {
|
||
var b = a[f];
|
||
if (!b || b.props.disabled) f = (f + 1) % h;
|
||
else return b;
|
||
} while (f !== u);
|
||
return null;
|
||
}),
|
||
(e.renderCommonMenuItem = function(t, a, c) {
|
||
var h = e.props.store.getState(),
|
||
p = Object(y.a)(e),
|
||
u = p.props,
|
||
f = $e(t, u.eventKey, a),
|
||
b = t.props;
|
||
if (!b || typeof t.type == 'string') return t;
|
||
var W = f === h.activeKey,
|
||
w = Object(i.a)(
|
||
Object(i.a)(
|
||
{
|
||
mode: b.mode || u.mode,
|
||
level: u.level,
|
||
inlineIndent: u.inlineIndent,
|
||
renderMenuItem: e.renderMenuItem,
|
||
rootPrefixCls: u.prefixCls,
|
||
index: a,
|
||
parentMenu: u.parentMenu,
|
||
manualRef: b.disabled ? void 0 : Object(Ye.a)(t.ref, be.bind(Object(y.a)(e))),
|
||
eventKey: f,
|
||
active: !b.disabled && W,
|
||
multiple: u.multiple,
|
||
onClick: function($) {
|
||
(b.onClick || Ee)($), e.onClick($);
|
||
},
|
||
onItemHover: e.onItemHover,
|
||
motion: u.motion,
|
||
subMenuOpenDelay: u.subMenuOpenDelay,
|
||
subMenuCloseDelay: u.subMenuCloseDelay,
|
||
forceSubMenuRender: u.forceSubMenuRender,
|
||
onOpenChange: e.onOpenChange,
|
||
onDeselect: e.onDeselect,
|
||
onSelect: e.onSelect,
|
||
builtinPlacements: u.builtinPlacements,
|
||
itemIcon: b.itemIcon || e.props.itemIcon,
|
||
expandIcon: b.expandIcon || e.props.expandIcon,
|
||
},
|
||
c,
|
||
),
|
||
{},
|
||
{ direction: u.direction },
|
||
);
|
||
return (
|
||
(u.mode === 'inline' || Lt()) && (w.triggerSubMenuAction = 'click'),
|
||
v.cloneElement(t, Object(i.a)(Object(i.a)({}, w), {}, { key: f || a }))
|
||
);
|
||
}),
|
||
(e.renderMenuItem = function(t, a, c) {
|
||
if (!t) return null;
|
||
var h = e.props.store.getState(),
|
||
p = {
|
||
openKeys: h.openKeys,
|
||
selectedKeys: h.selectedKeys,
|
||
triggerSubMenuAction: e.props.triggerSubMenuAction,
|
||
subMenuKey: c,
|
||
};
|
||
return e.renderCommonMenuItem(t, a, p);
|
||
}),
|
||
n.store.setState({
|
||
activeKey: Object(i.a)(
|
||
Object(i.a)({}, n.store.getState().activeKey),
|
||
{},
|
||
Object(ne.a)({}, n.eventKey, le(n, n.activeKey)),
|
||
),
|
||
}),
|
||
(e.instanceArray = []),
|
||
e
|
||
);
|
||
}
|
||
return (
|
||
Object(E.a)(d, [
|
||
{
|
||
key: 'componentDidMount',
|
||
value: function() {
|
||
this.props.manualRef && this.props.manualRef(this);
|
||
},
|
||
},
|
||
{
|
||
key: 'shouldComponentUpdate',
|
||
value: function(e) {
|
||
return (
|
||
this.props.visible ||
|
||
e.visible ||
|
||
this.props.className !== e.className ||
|
||
!R()(this.props.style, e.style)
|
||
);
|
||
},
|
||
},
|
||
{
|
||
key: 'componentDidUpdate',
|
||
value: function(e) {
|
||
var t = this.props,
|
||
a = 'activeKey' in t ? t.activeKey : t.store.getState().activeKey[ie(t)],
|
||
c = le(t, a);
|
||
if (c !== a) ge(t.store, ie(t), c);
|
||
else if ('activeKey' in e) {
|
||
var h = le(e, e.activeKey);
|
||
c !== h && ge(t.store, ie(t), c);
|
||
}
|
||
},
|
||
},
|
||
{
|
||
key: 'render',
|
||
value: function() {
|
||
var e = this,
|
||
t = Object(Te.a)({}, this.props);
|
||
this.instanceArray = [];
|
||
var a = We()(t.prefixCls, t.className, ''.concat(t.prefixCls, '-').concat(t.mode)),
|
||
c = { className: a, role: t.role || 'menu' };
|
||
t.id && (c.id = t.id),
|
||
t.focusable && ((c.tabIndex = 0), (c.onKeyDown = this.onKeyDown));
|
||
var h = t.prefixCls,
|
||
p = t.eventKey,
|
||
u = t.visible,
|
||
f = t.level,
|
||
b = t.mode,
|
||
W = t.overflowedIndicator,
|
||
w = t.theme;
|
||
return (
|
||
we.forEach(function(se) {
|
||
return delete t[se];
|
||
}),
|
||
delete t.onClick,
|
||
v.createElement(
|
||
ae,
|
||
Object.assign(
|
||
{},
|
||
t,
|
||
{
|
||
prefixCls: h,
|
||
mode: b,
|
||
tag: 'ul',
|
||
level: f,
|
||
theme: w,
|
||
visible: u,
|
||
overflowedIndicator: W,
|
||
},
|
||
c,
|
||
),
|
||
Object(ze.a)(t.children).map(function(se, $) {
|
||
return e.renderMenuItem(se, $, p || '0-menu-');
|
||
}),
|
||
)
|
||
);
|
||
},
|
||
},
|
||
]),
|
||
d
|
||
);
|
||
})(v.Component);
|
||
ve.defaultProps = {
|
||
prefixCls: 'rc-menu',
|
||
className: '',
|
||
mode: 'vertical',
|
||
level: 1,
|
||
inlineIndent: 24,
|
||
visible: !0,
|
||
focusable: !0,
|
||
style: {},
|
||
manualRef: Ee,
|
||
};
|
||
var Ce = Se()(ve),
|
||
de = Ce,
|
||
Ne = o('Kwbf');
|
||
function Me(m, r, d) {
|
||
var n = m.prefixCls,
|
||
e = m.motion,
|
||
t = m.defaultMotions,
|
||
a = t === void 0 ? {} : t,
|
||
c = m.openAnimation,
|
||
h = m.openTransitionName,
|
||
p = r.switchingModeFromInline;
|
||
if (e) return e;
|
||
if (Object(tt.a)(c) === 'object' && c)
|
||
Object(Ne.a)(
|
||
!1,
|
||
'Object type of `openAnimation` is removed. Please use `motion` instead.',
|
||
);
|
||
else if (typeof c == 'string') return { motionName: ''.concat(n, '-open-').concat(c) };
|
||
if (h) return { motionName: h };
|
||
var u = a[d];
|
||
return u || (p ? null : a.other);
|
||
}
|
||
var Le = (function(m) {
|
||
Object(l.a)(d, m);
|
||
var r = Object(I.a)(d);
|
||
function d(n) {
|
||
var e;
|
||
Object(j.a)(this, d),
|
||
(e = r.call(this, n)),
|
||
(e.inlineOpenKeys = []),
|
||
(e.onSelect = function(c) {
|
||
var h = Object(y.a)(e),
|
||
p = h.props;
|
||
if (p.selectable) {
|
||
var u = e.store.getState(),
|
||
f = u.selectedKeys,
|
||
b = c.key;
|
||
p.multiple ? (f = f.concat([b])) : (f = [b]),
|
||
'selectedKeys' in p || e.store.setState({ selectedKeys: f }),
|
||
p.onSelect(Object(i.a)(Object(i.a)({}, c), {}, { selectedKeys: f }));
|
||
}
|
||
}),
|
||
(e.onClick = function(c) {
|
||
var h = e.getRealMenuMode(),
|
||
p = Object(y.a)(e),
|
||
u = p.store,
|
||
f = p.props.onOpenChange;
|
||
h !== 'inline' && !('openKeys' in e.props) && (u.setState({ openKeys: [] }), f([])),
|
||
e.props.onClick(c);
|
||
}),
|
||
(e.onKeyDown = function(c, h) {
|
||
e.innerMenu.getWrappedInstance().onKeyDown(c, h);
|
||
}),
|
||
(e.onOpenChange = function(c) {
|
||
var h = Object(y.a)(e),
|
||
p = h.props,
|
||
u = e.store.getState().openKeys.concat(),
|
||
f = !1,
|
||
b = function(w) {
|
||
var se = !1;
|
||
if (w.open) (se = u.indexOf(w.key) === -1), se && u.push(w.key);
|
||
else {
|
||
var $ = u.indexOf(w.key);
|
||
(se = $ !== -1), se && u.splice($, 1);
|
||
}
|
||
f = f || se;
|
||
};
|
||
Array.isArray(c) ? c.forEach(b) : b(c),
|
||
f &&
|
||
('openKeys' in e.props || e.store.setState({ openKeys: u }), p.onOpenChange(u));
|
||
}),
|
||
(e.onDeselect = function(c) {
|
||
var h = Object(y.a)(e),
|
||
p = h.props;
|
||
if (p.selectable) {
|
||
var u = e.store.getState().selectedKeys.concat(),
|
||
f = c.key,
|
||
b = u.indexOf(f);
|
||
b !== -1 && u.splice(b, 1),
|
||
'selectedKeys' in p || e.store.setState({ selectedKeys: u }),
|
||
p.onDeselect(Object(i.a)(Object(i.a)({}, c), {}, { selectedKeys: u }));
|
||
}
|
||
}),
|
||
(e.onMouseEnter = function(c) {
|
||
e.restoreModeVerticalFromInline();
|
||
var h = e.props.onMouseEnter;
|
||
h && h(c);
|
||
}),
|
||
(e.onTransitionEnd = function(c) {
|
||
var h = c.propertyName === 'width' && c.target === c.currentTarget,
|
||
p = c.target.className,
|
||
u =
|
||
Object.prototype.toString.call(p) === '[object SVGAnimatedString]'
|
||
? p.animVal
|
||
: p,
|
||
f = c.propertyName === 'font-size' && u.indexOf('anticon') >= 0;
|
||
(h || f) && e.restoreModeVerticalFromInline();
|
||
}),
|
||
(e.setInnerMenu = function(c) {
|
||
e.innerMenu = c;
|
||
}),
|
||
(e.isRootMenu = !0);
|
||
var t = n.defaultSelectedKeys,
|
||
a = n.defaultOpenKeys;
|
||
return (
|
||
'selectedKeys' in n && (t = n.selectedKeys || []),
|
||
'openKeys' in n && (a = n.openKeys || []),
|
||
(e.store = q({
|
||
selectedKeys: t,
|
||
openKeys: a,
|
||
activeKey: { '0-menu-': le(n, n.activeKey) },
|
||
})),
|
||
(e.state = { switchingModeFromInline: !1 }),
|
||
e
|
||
);
|
||
}
|
||
return (
|
||
Object(E.a)(d, [
|
||
{
|
||
key: 'componentDidMount',
|
||
value: function() {
|
||
this.updateMiniStore(), this.updateMenuDisplay();
|
||
},
|
||
},
|
||
{
|
||
key: 'componentDidUpdate',
|
||
value: function(e) {
|
||
this.updateOpentKeysWhenSwitchMode(e), this.updateMiniStore();
|
||
var t = this.props,
|
||
a = t.siderCollapsed,
|
||
c = t.inlineCollapsed,
|
||
h = t.onOpenChange;
|
||
((!e.inlineCollapsed && c) || (!e.siderCollapsed && a)) && h([]),
|
||
this.updateMenuDisplay();
|
||
},
|
||
},
|
||
{
|
||
key: 'updateOpentKeysWhenSwitchMode',
|
||
value: function(e) {
|
||
var t = this.props,
|
||
a = this.store,
|
||
c = this.inlineOpenKeys,
|
||
h = a.getState(),
|
||
p = {};
|
||
e.mode === 'inline' &&
|
||
t.mode !== 'inline' &&
|
||
this.setState({ switchingModeFromInline: !0 }),
|
||
'openKeys' in t ||
|
||
(((t.inlineCollapsed && !e.inlineCollapsed) ||
|
||
(t.siderCollapsed && !e.siderCollapsed)) &&
|
||
(this.setState({ switchingModeFromInline: !0 }),
|
||
(this.inlineOpenKeys = h.openKeys.concat()),
|
||
(p.openKeys = [])),
|
||
((!t.inlineCollapsed && e.inlineCollapsed) ||
|
||
(!t.siderCollapsed && e.siderCollapsed)) &&
|
||
((p.openKeys = c), (this.inlineOpenKeys = []))),
|
||
Object.keys(p).length && a.setState(p);
|
||
},
|
||
},
|
||
{
|
||
key: 'updateMenuDisplay',
|
||
value: function() {
|
||
var e = this.props.collapsedWidth,
|
||
t = this.store,
|
||
a = this.prevOpenKeys,
|
||
c = this.getInlineCollapsed() && (e === 0 || e === '0' || e === '0px');
|
||
c
|
||
? ((this.prevOpenKeys = t.getState().openKeys.concat()),
|
||
this.store.setState({ openKeys: [] }))
|
||
: a && (this.store.setState({ openKeys: a }), (this.prevOpenKeys = null));
|
||
},
|
||
},
|
||
{
|
||
key: 'getRealMenuMode',
|
||
value: function() {
|
||
var e = this.props.mode,
|
||
t = this.state.switchingModeFromInline,
|
||
a = this.getInlineCollapsed();
|
||
return t && a ? 'inline' : a ? 'vertical' : e;
|
||
},
|
||
},
|
||
{
|
||
key: 'getInlineCollapsed',
|
||
value: function() {
|
||
var e = this.props,
|
||
t = e.inlineCollapsed,
|
||
a = e.siderCollapsed;
|
||
return a !== void 0 ? a : t;
|
||
},
|
||
},
|
||
{
|
||
key: 'restoreModeVerticalFromInline',
|
||
value: function() {
|
||
var e = this.state.switchingModeFromInline;
|
||
e && this.setState({ switchingModeFromInline: !1 });
|
||
},
|
||
},
|
||
{
|
||
key: 'updateMiniStore',
|
||
value: function() {
|
||
'selectedKeys' in this.props &&
|
||
this.store.setState({ selectedKeys: this.props.selectedKeys || [] }),
|
||
'openKeys' in this.props &&
|
||
this.store.setState({ openKeys: this.props.openKeys || [] });
|
||
},
|
||
},
|
||
{
|
||
key: 'render',
|
||
value: function() {
|
||
var e = Object(i.a)(
|
||
{},
|
||
Object(Ie.default)(this.props, [
|
||
'collapsedWidth',
|
||
'siderCollapsed',
|
||
'defaultMotions',
|
||
]),
|
||
),
|
||
t = this.getRealMenuMode();
|
||
return (
|
||
(e.className += ' '.concat(e.prefixCls, '-root')),
|
||
e.direction === 'rtl' && (e.className += ' '.concat(e.prefixCls, '-rtl')),
|
||
(e = Object(i.a)(
|
||
Object(i.a)({}, e),
|
||
{},
|
||
{
|
||
mode: t,
|
||
onClick: this.onClick,
|
||
onOpenChange: this.onOpenChange,
|
||
onDeselect: this.onDeselect,
|
||
onSelect: this.onSelect,
|
||
onMouseEnter: this.onMouseEnter,
|
||
onTransitionEnd: this.onTransitionEnd,
|
||
parentMenu: this,
|
||
motion: Me(this.props, this.state, t),
|
||
},
|
||
)),
|
||
delete e.openAnimation,
|
||
delete e.openTransitionName,
|
||
v.createElement(
|
||
g,
|
||
{ store: this.store },
|
||
v.createElement(
|
||
de,
|
||
Object.assign({}, e, { ref: this.setInnerMenu }),
|
||
this.props.children,
|
||
),
|
||
)
|
||
);
|
||
},
|
||
},
|
||
]),
|
||
d
|
||
);
|
||
})(v.Component);
|
||
Le.defaultProps = {
|
||
selectable: !0,
|
||
onClick: Ee,
|
||
onSelect: Ee,
|
||
onOpenChange: Ee,
|
||
onDeselect: Ee,
|
||
defaultSelectedKeys: [],
|
||
defaultOpenKeys: [],
|
||
subMenuOpenDelay: 0.1,
|
||
subMenuCloseDelay: 0.1,
|
||
triggerSubMenuAction: 'hover',
|
||
prefixCls: 'rc-menu',
|
||
className: '',
|
||
mode: 'vertical',
|
||
style: {},
|
||
builtinPlacements: {},
|
||
overflowedIndicator: v.createElement('span', null, '···'),
|
||
};
|
||
var Ae = Le,
|
||
F = (function(m) {
|
||
Object(l.a)(d, m);
|
||
var r = Object(I.a)(d);
|
||
function d() {
|
||
var n;
|
||
return (
|
||
Object(j.a)(this, d),
|
||
(n = r.apply(this, arguments)),
|
||
(n.onKeyDown = function(e) {
|
||
var t = e.keyCode;
|
||
return t === je.a.ENTER ? (n.onClick(e), !0) : void 0;
|
||
}),
|
||
(n.onMouseLeave = function(e) {
|
||
var t = n.props,
|
||
a = t.eventKey,
|
||
c = t.onItemHover,
|
||
h = t.onMouseLeave;
|
||
c({ key: a, hover: !1 }), h({ key: a, domEvent: e });
|
||
}),
|
||
(n.onMouseEnter = function(e) {
|
||
var t = n.props,
|
||
a = t.eventKey,
|
||
c = t.onItemHover,
|
||
h = t.onMouseEnter;
|
||
c({ key: a, hover: !0 }), h({ key: a, domEvent: e });
|
||
}),
|
||
(n.onClick = function(e) {
|
||
var t = n.props,
|
||
a = t.eventKey,
|
||
c = t.multiple,
|
||
h = t.onClick,
|
||
p = t.onSelect,
|
||
u = t.onDeselect,
|
||
f = t.isSelected,
|
||
b = { key: a, keyPath: [a], item: Object(y.a)(n), domEvent: e };
|
||
h(b), c ? (f ? u(b) : p(b)) : f || p(b);
|
||
}),
|
||
(n.saveNode = function(e) {
|
||
n.node = e;
|
||
}),
|
||
n
|
||
);
|
||
}
|
||
return (
|
||
Object(E.a)(d, [
|
||
{
|
||
key: 'componentDidMount',
|
||
value: function() {
|
||
this.callRef();
|
||
},
|
||
},
|
||
{
|
||
key: 'componentDidUpdate',
|
||
value: function() {
|
||
this.callRef();
|
||
},
|
||
},
|
||
{
|
||
key: 'componentWillUnmount',
|
||
value: function() {
|
||
var e = this.props;
|
||
e.onDestroy && e.onDestroy(e.eventKey);
|
||
},
|
||
},
|
||
{
|
||
key: 'getPrefixCls',
|
||
value: function() {
|
||
return ''.concat(this.props.rootPrefixCls, '-item');
|
||
},
|
||
},
|
||
{
|
||
key: 'getActiveClassName',
|
||
value: function() {
|
||
return ''.concat(this.getPrefixCls(), '-active');
|
||
},
|
||
},
|
||
{
|
||
key: 'getSelectedClassName',
|
||
value: function() {
|
||
return ''.concat(this.getPrefixCls(), '-selected');
|
||
},
|
||
},
|
||
{
|
||
key: 'getDisabledClassName',
|
||
value: function() {
|
||
return ''.concat(this.getPrefixCls(), '-disabled');
|
||
},
|
||
},
|
||
{
|
||
key: 'callRef',
|
||
value: function() {
|
||
this.props.manualRef && this.props.manualRef(this);
|
||
},
|
||
},
|
||
{
|
||
key: 'render',
|
||
value: function() {
|
||
var e,
|
||
t = Object(i.a)({}, this.props),
|
||
a = We()(
|
||
this.getPrefixCls(),
|
||
t.className,
|
||
((e = {}),
|
||
Object(ne.a)(e, this.getActiveClassName(), !t.disabled && t.active),
|
||
Object(ne.a)(e, this.getSelectedClassName(), t.isSelected),
|
||
Object(ne.a)(e, this.getDisabledClassName(), t.disabled),
|
||
e),
|
||
),
|
||
c = Object(i.a)(
|
||
Object(i.a)({}, t.attribute),
|
||
{},
|
||
{
|
||
title: typeof t.title == 'string' ? t.title : void 0,
|
||
className: a,
|
||
role: t.role || 'menuitem',
|
||
'aria-disabled': t.disabled,
|
||
},
|
||
);
|
||
t.role === 'option'
|
||
? (c = Object(i.a)(
|
||
Object(i.a)({}, c),
|
||
{},
|
||
{ role: 'option', 'aria-selected': t.isSelected },
|
||
))
|
||
: (t.role === null || t.role === 'none') && (c.role = 'none');
|
||
var h = {
|
||
onClick: t.disabled ? null : this.onClick,
|
||
onMouseLeave: t.disabled ? null : this.onMouseLeave,
|
||
onMouseEnter: t.disabled ? null : this.onMouseEnter,
|
||
},
|
||
p = Object(i.a)({}, t.style);
|
||
t.mode === 'inline' &&
|
||
(t.direction === 'rtl'
|
||
? (p.paddingRight = t.inlineIndent * t.level)
|
||
: (p.paddingLeft = t.inlineIndent * t.level)),
|
||
we.forEach(function(f) {
|
||
return delete t[f];
|
||
}),
|
||
delete t.direction;
|
||
var u = this.props.itemIcon;
|
||
return (
|
||
typeof this.props.itemIcon == 'function' &&
|
||
(u = v.createElement(this.props.itemIcon, this.props)),
|
||
v.createElement(
|
||
'li',
|
||
Object.assign(
|
||
{},
|
||
Object(Ie.default)(t, [
|
||
'onClick',
|
||
'onMouseEnter',
|
||
'onMouseLeave',
|
||
'onSelect',
|
||
]),
|
||
c,
|
||
h,
|
||
{ style: p, ref: this.saveNode },
|
||
),
|
||
t.children,
|
||
u,
|
||
)
|
||
);
|
||
},
|
||
},
|
||
]),
|
||
d
|
||
);
|
||
})(v.Component);
|
||
(F.isMenuItem = !0),
|
||
(F.defaultProps = { onSelect: Ee, onMouseEnter: Ee, onMouseLeave: Ee, manualRef: Ee });
|
||
var k = Se(function(m, r) {
|
||
var d = m.activeKey,
|
||
n = m.selectedKeys,
|
||
e = r.eventKey,
|
||
t = r.subMenuKey;
|
||
return { active: d[t] === e, isSelected: n.indexOf(e) !== -1 };
|
||
})(F),
|
||
ce = k,
|
||
fe = (function(m) {
|
||
Object(l.a)(d, m);
|
||
var r = Object(I.a)(d);
|
||
function d() {
|
||
var n;
|
||
return (
|
||
Object(j.a)(this, d),
|
||
(n = r.apply(this, arguments)),
|
||
(n.renderInnerMenuItem = function(e) {
|
||
var t = n.props,
|
||
a = t.renderMenuItem,
|
||
c = t.index;
|
||
return a(e, c, n.props.subMenuKey);
|
||
}),
|
||
n
|
||
);
|
||
}
|
||
return (
|
||
Object(E.a)(d, [
|
||
{
|
||
key: 'render',
|
||
value: function() {
|
||
var e = Object(Te.a)({}, this.props),
|
||
t = e.className,
|
||
a = t === void 0 ? '' : t,
|
||
c = e.rootPrefixCls,
|
||
h = ''.concat(c, '-item-group-title'),
|
||
p = ''.concat(c, '-item-group-list'),
|
||
u = e.title,
|
||
f = e.children;
|
||
return (
|
||
we.forEach(function(b) {
|
||
return delete e[b];
|
||
}),
|
||
delete e.onClick,
|
||
delete e.direction,
|
||
v.createElement(
|
||
'li',
|
||
Object.assign({}, e, {
|
||
className: ''.concat(a, ' ').concat(c, '-item-group'),
|
||
}),
|
||
v.createElement(
|
||
'div',
|
||
{ className: h, title: typeof u == 'string' ? u : void 0 },
|
||
u,
|
||
),
|
||
v.createElement(
|
||
'ul',
|
||
{ className: p },
|
||
v.Children.map(f, this.renderInnerMenuItem),
|
||
),
|
||
)
|
||
);
|
||
},
|
||
},
|
||
]),
|
||
d
|
||
);
|
||
})(v.Component);
|
||
(fe.isMenuItemGroup = !0), (fe.defaultProps = { disabled: !0 });
|
||
var V = fe,
|
||
ye = function(r) {
|
||
var d = r.className,
|
||
n = r.rootPrefixCls,
|
||
e = r.style;
|
||
return v.createElement('li', {
|
||
className: ''.concat(d, ' ').concat(n, '-item-divider'),
|
||
style: e,
|
||
});
|
||
};
|
||
ye.defaultProps = { disabled: !0, className: '', style: {} };
|
||
var Ue = ye,
|
||
pe = (N.f = Ae);
|
||
},
|
||
'3flX': function(ue, N, o) {
|
||
'use strict';
|
||
var i = o('q1tI'),
|
||
j = {
|
||
icon: {
|
||
tag: 'svg',
|
||
attrs: { viewBox: '64 64 896 896', focusable: 'false' },
|
||
children: [
|
||
{
|
||
tag: 'path',
|
||
attrs: {
|
||
d:
|
||
'M744 62H280c-35.3 0-64 28.7-64 64v768c0 35.3 28.7 64 64 64h464c35.3 0 64-28.7 64-64V126c0-35.3-28.7-64-64-64zm-8 824H288V134h448v752zM472 784a40 40 0 1080 0 40 40 0 10-80 0z',
|
||
},
|
||
},
|
||
],
|
||
},
|
||
name: 'mobile',
|
||
theme: 'outlined',
|
||
},
|
||
E = j,
|
||
y = o('6VBw'),
|
||
l = function(z, S) {
|
||
return i.createElement(y.a, Object.assign({}, z, { ref: S, icon: E }));
|
||
};
|
||
l.displayName = 'MobileOutlined';
|
||
var I = (N.a = i.forwardRef(l));
|
||
},
|
||
'4IlW': function(ue, N, o) {
|
||
'use strict';
|
||
var i = {
|
||
MAC_ENTER: 3,
|
||
BACKSPACE: 8,
|
||
TAB: 9,
|
||
NUM_CENTER: 12,
|
||
ENTER: 13,
|
||
SHIFT: 16,
|
||
CTRL: 17,
|
||
ALT: 18,
|
||
PAUSE: 19,
|
||
CAPS_LOCK: 20,
|
||
ESC: 27,
|
||
SPACE: 32,
|
||
PAGE_UP: 33,
|
||
PAGE_DOWN: 34,
|
||
END: 35,
|
||
HOME: 36,
|
||
LEFT: 37,
|
||
UP: 38,
|
||
RIGHT: 39,
|
||
DOWN: 40,
|
||
PRINT_SCREEN: 44,
|
||
INSERT: 45,
|
||
DELETE: 46,
|
||
ZERO: 48,
|
||
ONE: 49,
|
||
TWO: 50,
|
||
THREE: 51,
|
||
FOUR: 52,
|
||
FIVE: 53,
|
||
SIX: 54,
|
||
SEVEN: 55,
|
||
EIGHT: 56,
|
||
NINE: 57,
|
||
QUESTION_MARK: 63,
|
||
A: 65,
|
||
B: 66,
|
||
C: 67,
|
||
D: 68,
|
||
E: 69,
|
||
F: 70,
|
||
G: 71,
|
||
H: 72,
|
||
I: 73,
|
||
J: 74,
|
||
K: 75,
|
||
L: 76,
|
||
M: 77,
|
||
N: 78,
|
||
O: 79,
|
||
P: 80,
|
||
Q: 81,
|
||
R: 82,
|
||
S: 83,
|
||
T: 84,
|
||
U: 85,
|
||
V: 86,
|
||
W: 87,
|
||
X: 88,
|
||
Y: 89,
|
||
Z: 90,
|
||
META: 91,
|
||
WIN_KEY_RIGHT: 92,
|
||
CONTEXT_MENU: 93,
|
||
NUM_ZERO: 96,
|
||
NUM_ONE: 97,
|
||
NUM_TWO: 98,
|
||
NUM_THREE: 99,
|
||
NUM_FOUR: 100,
|
||
NUM_FIVE: 101,
|
||
NUM_SIX: 102,
|
||
NUM_SEVEN: 103,
|
||
NUM_EIGHT: 104,
|
||
NUM_NINE: 105,
|
||
NUM_MULTIPLY: 106,
|
||
NUM_PLUS: 107,
|
||
NUM_MINUS: 109,
|
||
NUM_PERIOD: 110,
|
||
NUM_DIVISION: 111,
|
||
F1: 112,
|
||
F2: 113,
|
||
F3: 114,
|
||
F4: 115,
|
||
F5: 116,
|
||
F6: 117,
|
||
F7: 118,
|
||
F8: 119,
|
||
F9: 120,
|
||
F10: 121,
|
||
F11: 122,
|
||
F12: 123,
|
||
NUMLOCK: 144,
|
||
SEMICOLON: 186,
|
||
DASH: 189,
|
||
EQUALS: 187,
|
||
COMMA: 188,
|
||
PERIOD: 190,
|
||
SLASH: 191,
|
||
APOSTROPHE: 192,
|
||
SINGLE_QUOTE: 222,
|
||
OPEN_SQUARE_BRACKET: 219,
|
||
BACKSLASH: 220,
|
||
CLOSE_SQUARE_BRACKET: 221,
|
||
WIN_KEY: 224,
|
||
MAC_FF_META: 224,
|
||
WIN_IME: 229,
|
||
isTextModifyingKeyEvent: function(E) {
|
||
var y = E.keyCode;
|
||
if ((E.altKey && !E.ctrlKey) || E.metaKey || (y >= i.F1 && y <= i.F12)) return !1;
|
||
switch (y) {
|
||
case i.ALT:
|
||
case i.CAPS_LOCK:
|
||
case i.CONTEXT_MENU:
|
||
case i.CTRL:
|
||
case i.DOWN:
|
||
case i.END:
|
||
case i.ESC:
|
||
case i.HOME:
|
||
case i.INSERT:
|
||
case i.LEFT:
|
||
case i.MAC_FF_META:
|
||
case i.META:
|
||
case i.NUMLOCK:
|
||
case i.NUM_CENTER:
|
||
case i.PAGE_DOWN:
|
||
case i.PAGE_UP:
|
||
case i.PAUSE:
|
||
case i.PRINT_SCREEN:
|
||
case i.RIGHT:
|
||
case i.SHIFT:
|
||
case i.UP:
|
||
case i.WIN_KEY:
|
||
case i.WIN_KEY_RIGHT:
|
||
return !1;
|
||
default:
|
||
return !0;
|
||
}
|
||
},
|
||
isCharacterKey: function(E) {
|
||
if (E >= i.ZERO && E <= i.NINE) return !0;
|
||
if (E >= i.NUM_ZERO && E <= i.NUM_MULTIPLY) return !0;
|
||
if (E >= i.A && E <= i.Z) return !0;
|
||
if (window.navigator.userAgent.indexOf('WebKit') !== -1 && E === 0) return !0;
|
||
switch (E) {
|
||
case i.SPACE:
|
||
case i.QUESTION_MARK:
|
||
case i.NUM_PLUS:
|
||
case i.NUM_MINUS:
|
||
case i.NUM_PERIOD:
|
||
case i.NUM_DIVISION:
|
||
case i.SEMICOLON:
|
||
case i.DASH:
|
||
case i.EQUALS:
|
||
case i.COMMA:
|
||
case i.PERIOD:
|
||
case i.SLASH:
|
||
case i.APOSTROPHE:
|
||
case i.SINGLE_QUOTE:
|
||
case i.OPEN_SQUARE_BRACKET:
|
||
case i.BACKSLASH:
|
||
case i.CLOSE_SQUARE_BRACKET:
|
||
return !0;
|
||
default:
|
||
return !1;
|
||
}
|
||
},
|
||
};
|
||
N.a = i;
|
||
},
|
||
'6VBw': function(ue, N, o) {
|
||
'use strict';
|
||
var i = o('ODXe'),
|
||
j = o('rePB'),
|
||
E = o('Ff2n'),
|
||
y = o('q1tI'),
|
||
l = o.n(y),
|
||
I = o('TSYQ'),
|
||
v = o.n(I),
|
||
z = o('CJvt'),
|
||
S = o('xc4C'),
|
||
g = o('Qi1f');
|
||
Object(S.b)('#1890ff');
|
||
var x = y.forwardRef(function(R, B) {
|
||
var Y = R.className,
|
||
L = R.icon,
|
||
Z = R.spin,
|
||
me = R.rotate,
|
||
re = R.tabIndex,
|
||
Se = R.onClick,
|
||
D = R.twoToneColor,
|
||
q = Object(E.a)(R, [
|
||
'className',
|
||
'icon',
|
||
'spin',
|
||
'rotate',
|
||
'tabIndex',
|
||
'onClick',
|
||
'twoToneColor',
|
||
]),
|
||
Ie = v()('anticon', Object(j.a)({}, 'anticon-'.concat(L.name), Boolean(L.name)), Y),
|
||
Te = v()({ 'anticon-spin': !!Z || L.name === 'loading' }),
|
||
ne = re;
|
||
ne === void 0 && Se && (ne = -1);
|
||
var je = me
|
||
? { msTransform: 'rotate('.concat(me, 'deg)'), transform: 'rotate('.concat(me, 'deg)') }
|
||
: void 0,
|
||
Ye = Object(g.d)(D),
|
||
ze = Object(i.a)(Ye, 2),
|
||
et = ze[0],
|
||
We = ze[1];
|
||
return y.createElement(
|
||
'span',
|
||
Object.assign({ role: 'img', 'aria-label': L.name }, q, {
|
||
ref: B,
|
||
tabIndex: ne,
|
||
onClick: Se,
|
||
className: Ie,
|
||
}),
|
||
y.createElement(z.a, {
|
||
className: Te,
|
||
icon: L,
|
||
primaryColor: et,
|
||
secondaryColor: We,
|
||
style: je,
|
||
}),
|
||
);
|
||
});
|
||
(x.displayName = 'AntdIcon'), (x.getTwoToneColor = S.a), (x.setTwoToneColor = S.b), (N.a = x);
|
||
},
|
||
'6WrX': function(ue, N, o) {
|
||
'use strict';
|
||
var i = o('q1tI'),
|
||
j = {
|
||
icon: {
|
||
tag: 'svg',
|
||
attrs: { viewBox: '64 64 896 896', focusable: 'false' },
|
||
children: [
|
||
{ tag: 'defs', attrs: {}, children: [{ tag: 'style', attrs: {} }] },
|
||
{
|
||
tag: 'path',
|
||
attrs: {
|
||
d:
|
||
'M301.3 496.7c-23.8 0-40.2-10.5-41.6-26.9H205c.9 43.4 36.9 70.3 93.9 70.3 59.1 0 95-28.4 95-75.5 0-35.8-20-55.9-64.5-64.5l-29.1-5.6c-23.8-4.7-33.8-11.9-33.8-24.2 0-15 13.3-24.5 33.4-24.5 20.1 0 35.3 11.1 36.6 27h53c-.9-41.7-37.5-70.3-90.3-70.3-54.4 0-89.7 28.9-89.7 73 0 35.5 21.2 58 62.5 65.8l29.7 5.9c25.8 5.2 35.6 11.9 35.6 24.4.1 14.7-14.5 25.1-36 25.1z',
|
||
},
|
||
},
|
||
{
|
||
tag: 'path',
|
||
attrs: {
|
||
d:
|
||
'M928 140H96c-17.7 0-32 14.3-32 32v496c0 17.7 14.3 32 32 32h380v112H304c-8.8 0-16 7.2-16 16v48c0 4.4 3.6 8 8 8h432c4.4 0 8-3.6 8-8v-48c0-8.8-7.2-16-16-16H548V700h380c17.7 0 32-14.3 32-32V172c0-17.7-14.3-32-32-32zm-40 488H136V212h752v416z',
|
||
},
|
||
},
|
||
{
|
||
tag: 'path',
|
||
attrs: {
|
||
d:
|
||
'M828.5 486.7h-95.8V308.5h-57.4V534h153.2zm-298.6 53.4c14.1 0 27.2-2 39.1-5.8l13.3 20.3h53.3L607.9 511c21.1-20 33-51.1 33-89.8 0-73.3-43.3-118.8-110.9-118.8s-111.2 45.3-111.2 118.8c-.1 73.7 43 118.9 111.1 118.9zm0-190c31.6 0 52.7 27.7 52.7 71.1 0 16.7-3.6 30.6-10 40.5l-5.2-6.9h-48.8L542 491c-3.9.9-8 1.4-12.2 1.4-31.7 0-52.8-27.5-52.8-71.2.1-43.6 21.2-71.1 52.9-71.1z',
|
||
},
|
||
},
|
||
],
|
||
},
|
||
name: 'console-sql',
|
||
theme: 'outlined',
|
||
},
|
||
E = j,
|
||
y = o('6VBw'),
|
||
l = function(z, S) {
|
||
return i.createElement(y.a, Object.assign({}, z, { ref: S, icon: E }));
|
||
};
|
||
l.displayName = 'ConsoleSqlOutlined';
|
||
var I = (N.a = i.forwardRef(l));
|
||
},
|
||
'6cGi': function(ue, N, o) {
|
||
'use strict';
|
||
o.d(N, 'a', function() {
|
||
return S;
|
||
});
|
||
var i = o('q1tI'),
|
||
j = o.n(i);
|
||
function E(g, x) {
|
||
return z(g) || v(g, x) || l(g, x) || y();
|
||
}
|
||
function y() {
|
||
throw new TypeError(`Invalid attempt to destructure non-iterable instance.
|
||
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
|
||
}
|
||
function l(g, x) {
|
||
if (!g) return;
|
||
if (typeof g == 'string') return I(g, x);
|
||
var R = Object.prototype.toString.call(g).slice(8, -1);
|
||
if (
|
||
(R === 'Object' && g.constructor && (R = g.constructor.name), R === 'Map' || R === 'Set')
|
||
)
|
||
return Array.from(g);
|
||
if (R === 'Arguments' || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(R)) return I(g, x);
|
||
}
|
||
function I(g, x) {
|
||
(x == null || x > g.length) && (x = g.length);
|
||
for (var R = 0, B = new Array(x); R < x; R++) B[R] = g[R];
|
||
return B;
|
||
}
|
||
function v(g, x) {
|
||
if (typeof Symbol == 'undefined' || !(Symbol.iterator in Object(g))) return;
|
||
var R = [],
|
||
B = !0,
|
||
Y = !1,
|
||
L = void 0;
|
||
try {
|
||
for (
|
||
var Z = g[Symbol.iterator](), me;
|
||
!(B = (me = Z.next()).done) && !(R.push(me.value), x && R.length === x);
|
||
B = !0
|
||
);
|
||
} catch (re) {
|
||
(Y = !0), (L = re);
|
||
} finally {
|
||
try {
|
||
!B && Z.return != null && Z.return();
|
||
} finally {
|
||
if (Y) throw L;
|
||
}
|
||
}
|
||
return R;
|
||
}
|
||
function z(g) {
|
||
if (Array.isArray(g)) return g;
|
||
}
|
||
function S(g, x) {
|
||
var R = x || {},
|
||
B = R.defaultValue,
|
||
Y = R.value,
|
||
L = R.onChange,
|
||
Z = R.postState,
|
||
me = i.useState(function() {
|
||
return Y !== void 0
|
||
? Y
|
||
: B !== void 0
|
||
? typeof B == 'function'
|
||
? B()
|
||
: B
|
||
: typeof g == 'function'
|
||
? g()
|
||
: g;
|
||
}),
|
||
re = E(me, 2),
|
||
Se = re[0],
|
||
D = re[1],
|
||
q = Y !== void 0 ? Y : Se;
|
||
Z && (q = Z(q));
|
||
function Ie(ne) {
|
||
D(ne), q !== ne && L && L(ne, q);
|
||
}
|
||
var Te = i.useRef(!0);
|
||
return (
|
||
i.useEffect(
|
||
function() {
|
||
if (Te.current) {
|
||
Te.current = !1;
|
||
return;
|
||
}
|
||
Y === void 0 && D(Y);
|
||
},
|
||
[Y],
|
||
),
|
||
[q, Ie]
|
||
);
|
||
}
|
||
},
|
||
'9ama': function(ue, N, o) {},
|
||
CJvt: function(ue, N, o) {
|
||
'use strict';
|
||
var i = o('Ff2n'),
|
||
j = o('VTBJ'),
|
||
E = o('Qi1f'),
|
||
y = { primaryColor: '#333', secondaryColor: '#E6E6E6', calculated: !1 };
|
||
function l(z) {
|
||
var S = z.primaryColor,
|
||
g = z.secondaryColor;
|
||
(y.primaryColor = S), (y.secondaryColor = g || Object(E.b)(S)), (y.calculated = !!g);
|
||
}
|
||
function I() {
|
||
return Object(j.a)({}, y);
|
||
}
|
||
var v = function(S) {
|
||
var g = S.icon,
|
||
x = S.className,
|
||
R = S.onClick,
|
||
B = S.style,
|
||
Y = S.primaryColor,
|
||
L = S.secondaryColor,
|
||
Z = Object(i.a)(S, [
|
||
'icon',
|
||
'className',
|
||
'onClick',
|
||
'style',
|
||
'primaryColor',
|
||
'secondaryColor',
|
||
]),
|
||
me = y;
|
||
if (
|
||
(Y && (me = { primaryColor: Y, secondaryColor: L || Object(E.b)(Y) }),
|
||
Object(E.f)(),
|
||
Object(E.g)(Object(E.c)(g), 'icon should be icon definiton, but got '.concat(g)),
|
||
!Object(E.c)(g))
|
||
)
|
||
return null;
|
||
var re = g;
|
||
return (
|
||
re &&
|
||
typeof re.icon == 'function' &&
|
||
(re = Object(j.a)(
|
||
Object(j.a)({}, re),
|
||
{},
|
||
{ icon: re.icon(me.primaryColor, me.secondaryColor) },
|
||
)),
|
||
Object(E.a)(
|
||
re.icon,
|
||
'svg-'.concat(re.name),
|
||
Object(j.a)(
|
||
{
|
||
className: x,
|
||
onClick: R,
|
||
style: B,
|
||
'data-icon': re.name,
|
||
width: '1em',
|
||
height: '1em',
|
||
fill: 'currentColor',
|
||
'aria-hidden': 'true',
|
||
},
|
||
Z,
|
||
),
|
||
)
|
||
);
|
||
};
|
||
(v.displayName = 'IconReact'), (v.getTwoToneColors = I), (v.setTwoToneColors = l), (N.a = v);
|
||
},
|
||
Gytx: function(ue, N) {
|
||
ue.exports = function(i, j, E, y) {
|
||
var l = E ? E.call(y, i, j) : void 0;
|
||
if (l !== void 0) return !!l;
|
||
if (i === j) return !0;
|
||
if (typeof i != 'object' || !i || typeof j != 'object' || !j) return !1;
|
||
var I = Object.keys(i),
|
||
v = Object.keys(j);
|
||
if (I.length !== v.length) return !1;
|
||
for (var z = Object.prototype.hasOwnProperty.bind(j), S = 0; S < I.length; S++) {
|
||
var g = I[S];
|
||
if (!z(g)) return !1;
|
||
var x = i[g],
|
||
R = j[g];
|
||
if (((l = E ? E.call(y, x, R, g) : void 0), l === !1 || (l === void 0 && x !== R)))
|
||
return !1;
|
||
}
|
||
return !0;
|
||
};
|
||
},
|
||
KBXm: function(ue, N, o) {
|
||
'use strict';
|
||
Object.defineProperty(N, '__esModule', { value: !0 });
|
||
var i = {
|
||
icon: {
|
||
tag: 'svg',
|
||
attrs: { viewBox: '64 64 896 896', focusable: 'false' },
|
||
children: [
|
||
{
|
||
tag: 'path',
|
||
attrs: {
|
||
d:
|
||
'M176 511a56 56 0 10112 0 56 56 0 10-112 0zm280 0a56 56 0 10112 0 56 56 0 10-112 0zm280 0a56 56 0 10112 0 56 56 0 10-112 0z',
|
||
},
|
||
},
|
||
],
|
||
},
|
||
name: 'ellipsis',
|
||
theme: 'outlined',
|
||
};
|
||
N.default = i;
|
||
},
|
||
Qi1f: function(ue, N, o) {
|
||
'use strict';
|
||
o.d(N, 'g', function() {
|
||
return g;
|
||
}),
|
||
o.d(N, 'c', function() {
|
||
return x;
|
||
}),
|
||
o.d(N, 'a', function() {
|
||
return B;
|
||
}),
|
||
o.d(N, 'b', function() {
|
||
return Y;
|
||
}),
|
||
o.d(N, 'd', function() {
|
||
return L;
|
||
}),
|
||
o.d(N, 'e', function() {
|
||
return Z;
|
||
}),
|
||
o.d(N, 'f', function() {
|
||
return Se;
|
||
});
|
||
var i = o('VTBJ'),
|
||
j = o('U8pU'),
|
||
E = o('HXN9'),
|
||
y = o.n(E),
|
||
l = o('q1tI'),
|
||
I = o.n(l),
|
||
v = o('Kwbf'),
|
||
z = o('Gu+u'),
|
||
S = o.n(z);
|
||
function g(D, q) {
|
||
Object(v.a)(D, '[@ant-design/icons] '.concat(q));
|
||
}
|
||
function x(D) {
|
||
return (
|
||
Object(j.a)(D) === 'object' &&
|
||
typeof D.name == 'string' &&
|
||
typeof D.theme == 'string' &&
|
||
(Object(j.a)(D.icon) === 'object' || typeof D.icon == 'function')
|
||
);
|
||
}
|
||
function R() {
|
||
var D = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
|
||
return Object.keys(D).reduce(function(q, Ie) {
|
||
var Te = D[Ie];
|
||
switch (Ie) {
|
||
case 'class':
|
||
(q.className = Te), delete q.class;
|
||
break;
|
||
default:
|
||
q[Ie] = Te;
|
||
}
|
||
return q;
|
||
}, {});
|
||
}
|
||
function B(D, q, Ie) {
|
||
return Ie
|
||
? I.a.createElement(
|
||
D.tag,
|
||
Object(i.a)(Object(i.a)({ key: q }, R(D.attrs)), Ie),
|
||
(D.children || []).map(function(Te, ne) {
|
||
return B(
|
||
Te,
|
||
''
|
||
.concat(q, '-')
|
||
.concat(D.tag, '-')
|
||
.concat(ne),
|
||
);
|
||
}),
|
||
)
|
||
: I.a.createElement(
|
||
D.tag,
|
||
Object(i.a)({ key: q }, R(D.attrs)),
|
||
(D.children || []).map(function(Te, ne) {
|
||
return B(
|
||
Te,
|
||
''
|
||
.concat(q, '-')
|
||
.concat(D.tag, '-')
|
||
.concat(ne),
|
||
);
|
||
}),
|
||
);
|
||
}
|
||
function Y(D) {
|
||
return Object(E.generate)(D)[0];
|
||
}
|
||
function L(D) {
|
||
return D ? (Array.isArray(D) ? D : [D]) : [];
|
||
}
|
||
var Z = {
|
||
width: '1em',
|
||
height: '1em',
|
||
fill: 'currentColor',
|
||
'aria-hidden': 'true',
|
||
focusable: 'false',
|
||
},
|
||
me = `
|
||
.anticon {
|
||
display: inline-block;
|
||
color: inherit;
|
||
font-style: normal;
|
||
line-height: 0;
|
||
text-align: center;
|
||
text-transform: none;
|
||
vertical-align: -0.125em;
|
||
text-rendering: optimizeLegibility;
|
||
-webkit-font-smoothing: antialiased;
|
||
-moz-osx-font-smoothing: grayscale;
|
||
}
|
||
|
||
.anticon > * {
|
||
line-height: 1;
|
||
}
|
||
|
||
.anticon svg {
|
||
display: inline-block;
|
||
}
|
||
|
||
.anticon::before {
|
||
display: none;
|
||
}
|
||
|
||
.anticon .anticon-icon {
|
||
display: block;
|
||
}
|
||
|
||
.anticon[tabindex] {
|
||
cursor: pointer;
|
||
}
|
||
|
||
.anticon-spin::before,
|
||
.anticon-spin {
|
||
display: inline-block;
|
||
-webkit-animation: loadingCircle 1s infinite linear;
|
||
animation: loadingCircle 1s infinite linear;
|
||
}
|
||
|
||
@-webkit-keyframes loadingCircle {
|
||
100% {
|
||
-webkit-transform: rotate(360deg);
|
||
transform: rotate(360deg);
|
||
}
|
||
}
|
||
|
||
@keyframes loadingCircle {
|
||
100% {
|
||
-webkit-transform: rotate(360deg);
|
||
transform: rotate(360deg);
|
||
}
|
||
}
|
||
`,
|
||
re = !1,
|
||
Se = function() {
|
||
var q = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : me;
|
||
Object(l.useEffect)(function() {
|
||
re || (Object(z.insertCss)(q, { prepend: !0 }), (re = !0));
|
||
}, []);
|
||
};
|
||
},
|
||
SRve: function(ue, N, o) {
|
||
'use strict';
|
||
Object.defineProperty(N, '__esModule', { value: !0 });
|
||
var i = {
|
||
icon: {
|
||
tag: 'svg',
|
||
attrs: { viewBox: '64 64 896 896', focusable: 'false' },
|
||
children: [
|
||
{ tag: 'defs', attrs: {}, children: [{ tag: 'style', attrs: {} }] },
|
||
{
|
||
tag: 'path',
|
||
attrs: { d: 'M482 152h60q8 0 8 8v704q0 8-8 8h-60q-8 0-8-8V160q0-8 8-8z' },
|
||
},
|
||
{
|
||
tag: 'path',
|
||
attrs: { d: 'M176 474h672q8 0 8 8v60q0 8-8 8H176q-8 0-8-8v-60q0-8 8-8z' },
|
||
},
|
||
],
|
||
},
|
||
name: 'plus',
|
||
theme: 'outlined',
|
||
};
|
||
N.default = i;
|
||
},
|
||
ZTPi: function(ue, N, o) {
|
||
'use strict';
|
||
var i = o('pVnL'),
|
||
j = o.n(i),
|
||
E = o('lSNA'),
|
||
y = o.n(E),
|
||
l = o('q1tI'),
|
||
I = o('rePB'),
|
||
v = o('ODXe'),
|
||
z = o('Ff2n'),
|
||
S = o('VTBJ'),
|
||
g = o('TSYQ'),
|
||
x = o.n(g),
|
||
R = o('Zm9Q'),
|
||
B = o('6cGi'),
|
||
Y = o('KQm4'),
|
||
L = o('xEkU'),
|
||
Z = o.n(L),
|
||
me = o('t23M');
|
||
function re(s) {
|
||
var O = Object(l.useRef)(),
|
||
C = Object(l.useRef)(!1);
|
||
function A() {
|
||
for (var M = arguments.length, T = new Array(M), K = 0; K < M; K++) T[K] = arguments[K];
|
||
C.current ||
|
||
(Z.a.cancel(O.current),
|
||
(O.current = Z()(function() {
|
||
s.apply(void 0, T);
|
||
})));
|
||
}
|
||
return (
|
||
Object(l.useEffect)(function() {
|
||
return function() {
|
||
(C.current = !0), Z.a.cancel(O.current);
|
||
};
|
||
}, []),
|
||
A
|
||
);
|
||
}
|
||
function Se(s) {
|
||
var O = Object(l.useRef)([]),
|
||
C = Object(l.useState)({}),
|
||
A = Object(v.a)(C, 2),
|
||
M = A[1],
|
||
T = Object(l.useRef)(typeof s == 'function' ? s() : s),
|
||
K = re(function() {
|
||
var U = T.current;
|
||
O.current.forEach(function(Q) {
|
||
U = Q(U);
|
||
}),
|
||
(O.current = []),
|
||
(T.current = U),
|
||
M({});
|
||
});
|
||
function _(U) {
|
||
O.current.push(U), K();
|
||
}
|
||
return [T.current, _];
|
||
}
|
||
var D = o('4IlW');
|
||
function q(s, O) {
|
||
var C,
|
||
A = s.prefixCls,
|
||
M = s.id,
|
||
T = s.active,
|
||
K = s.rtl,
|
||
_ = s.tab,
|
||
U = _.key,
|
||
Q = _.tab,
|
||
H = _.disabled,
|
||
X = _.closeIcon,
|
||
te = s.tabBarGutter,
|
||
he = s.tabPosition,
|
||
ae = s.closable,
|
||
J = s.renderWrapper,
|
||
ge = s.removeAriaLabel,
|
||
ie = s.editable,
|
||
le = s.onClick,
|
||
be = s.onRemove,
|
||
ve = s.onFocus,
|
||
Ce = ''.concat(A, '-tab');
|
||
l.useEffect(function() {
|
||
return be;
|
||
}, []);
|
||
var de = {};
|
||
he === 'top' || he === 'bottom'
|
||
? (de[K ? 'marginLeft' : 'marginRight'] = te)
|
||
: (de.marginBottom = te);
|
||
var Ne = ie && ae !== !1 && !H;
|
||
function Me(F) {
|
||
if (H) return;
|
||
le(F);
|
||
}
|
||
function Le(F) {
|
||
F.preventDefault(), F.stopPropagation(), ie.onEdit('remove', { key: U, event: F });
|
||
}
|
||
var Ae = l.createElement(
|
||
'div',
|
||
{
|
||
key: U,
|
||
ref: O,
|
||
className: x()(
|
||
Ce,
|
||
((C = {}),
|
||
Object(I.a)(C, ''.concat(Ce, '-with-remove'), Ne),
|
||
Object(I.a)(C, ''.concat(Ce, '-active'), T),
|
||
Object(I.a)(C, ''.concat(Ce, '-disabled'), H),
|
||
C),
|
||
),
|
||
style: de,
|
||
onClick: Me,
|
||
},
|
||
l.createElement(
|
||
'div',
|
||
{
|
||
role: 'tab',
|
||
'aria-selected': T,
|
||
id: M && ''.concat(M, '-tab-').concat(U),
|
||
className: ''.concat(Ce, '-btn'),
|
||
'aria-controls': M && ''.concat(M, '-panel-').concat(U),
|
||
'aria-disabled': H,
|
||
tabIndex: H ? null : 0,
|
||
onClick: function(k) {
|
||
k.stopPropagation(), Me(k);
|
||
},
|
||
onKeyDown: function(k) {
|
||
[D.a.SPACE, D.a.ENTER].includes(k.which) && (k.preventDefault(), Me(k));
|
||
},
|
||
onFocus: ve,
|
||
},
|
||
Q,
|
||
),
|
||
Ne &&
|
||
l.createElement(
|
||
'button',
|
||
{
|
||
type: 'button',
|
||
'aria-label': ge || 'remove',
|
||
tabIndex: 0,
|
||
className: ''.concat(Ce, '-remove'),
|
||
onClick: function(k) {
|
||
k.stopPropagation(), Le(k);
|
||
},
|
||
},
|
||
X || ie.removeIcon || '×',
|
||
),
|
||
);
|
||
return J && (Ae = J(Ae)), Ae;
|
||
}
|
||
var Ie = l.forwardRef(q),
|
||
Te = { width: 0, height: 0, left: 0, top: 0 };
|
||
function ne(s, O, C) {
|
||
return Object(l.useMemo)(
|
||
function() {
|
||
for (
|
||
var A,
|
||
M = new Map(),
|
||
T = O.get((A = s[0]) === null || A === void 0 ? void 0 : A.key) || Te,
|
||
K = T.left + T.width,
|
||
_ = 0;
|
||
_ < s.length;
|
||
_ += 1
|
||
) {
|
||
var U = s[_].key,
|
||
Q = O.get(U);
|
||
if (!Q) {
|
||
var H;
|
||
Q = O.get((H = s[_ - 1]) === null || H === void 0 ? void 0 : H.key) || Te;
|
||
}
|
||
var X = M.get(U) || Object(S.a)({}, Q);
|
||
(X.right = K - X.left - X.width), M.set(U, X);
|
||
}
|
||
return M;
|
||
},
|
||
[
|
||
s
|
||
.map(function(A) {
|
||
return A.key;
|
||
})
|
||
.join('_'),
|
||
O,
|
||
C,
|
||
],
|
||
);
|
||
}
|
||
var je = { width: 0, height: 0, left: 0, top: 0, right: 0 };
|
||
function Ye(s, O, C, A, M) {
|
||
var T = M.tabs,
|
||
K = M.tabPosition,
|
||
_ = M.rtl,
|
||
U,
|
||
Q,
|
||
H;
|
||
['top', 'bottom'].includes(K)
|
||
? ((U = 'width'), (Q = _ ? 'right' : 'left'), (H = Math.abs(O.left)))
|
||
: ((U = 'height'), (Q = 'top'), (H = -O.top));
|
||
var X = O[U],
|
||
te = C[U],
|
||
he = A[U],
|
||
ae = X;
|
||
return (
|
||
te + he > X && (ae = X - he),
|
||
Object(l.useMemo)(
|
||
function() {
|
||
if (!T.length) return [0, 0];
|
||
for (var J = T.length, ge = J, ie = 0; ie < J; ie += 1) {
|
||
var le = s.get(T[ie].key) || je;
|
||
if (le[Q] + le[U] > H + ae) {
|
||
ge = ie - 1;
|
||
break;
|
||
}
|
||
}
|
||
for (var be = 0, ve = J - 1; ve >= 0; ve -= 1) {
|
||
var Ce = s.get(T[ve].key) || je;
|
||
if (Ce[Q] < H) {
|
||
be = ve + 1;
|
||
break;
|
||
}
|
||
}
|
||
return [be, ge];
|
||
},
|
||
[
|
||
s,
|
||
H,
|
||
ae,
|
||
K,
|
||
T.map(function(J) {
|
||
return J.key;
|
||
}).join('_'),
|
||
_,
|
||
],
|
||
)
|
||
);
|
||
}
|
||
var ze = o('1j5w'),
|
||
et = o('eDIo');
|
||
function We(s, O) {
|
||
var C = s.prefixCls,
|
||
A = s.editable,
|
||
M = s.locale,
|
||
T = s.style;
|
||
return !A || A.showAdd === !1
|
||
? null
|
||
: l.createElement(
|
||
'button',
|
||
{
|
||
ref: O,
|
||
type: 'button',
|
||
className: ''.concat(C, '-nav-add'),
|
||
style: T,
|
||
'aria-label': (M == null ? void 0 : M.addAriaLabel) || 'Add tab',
|
||
onClick: function(_) {
|
||
A.onEdit('add', { event: _ });
|
||
},
|
||
},
|
||
A.addIcon || '+',
|
||
);
|
||
}
|
||
var tt = l.forwardRef(We);
|
||
function dt(s, O) {
|
||
var C = s.prefixCls,
|
||
A = s.id,
|
||
M = s.tabs,
|
||
T = s.locale,
|
||
K = s.mobile,
|
||
_ = s.moreIcon,
|
||
U = _ === void 0 ? 'More' : _,
|
||
Q = s.moreTransitionName,
|
||
H = s.style,
|
||
X = s.className,
|
||
te = s.editable,
|
||
he = s.tabBarGutter,
|
||
ae = s.rtl,
|
||
J = s.onTabClick,
|
||
ge = Object(l.useState)(!1),
|
||
ie = Object(v.a)(ge, 2),
|
||
le = ie[0],
|
||
be = ie[1],
|
||
ve = Object(l.useState)(null),
|
||
Ce = Object(v.a)(ve, 2),
|
||
de = Ce[0],
|
||
Ne = Ce[1],
|
||
Me = ''.concat(A, '-more-popup'),
|
||
Le = ''.concat(C, '-dropdown'),
|
||
Ae = de !== null ? ''.concat(Me, '-').concat(de) : null,
|
||
F = T == null ? void 0 : T.dropdownAriaLabel,
|
||
k = l.createElement(
|
||
ze.f,
|
||
{
|
||
onClick: function(m) {
|
||
var r = m.key,
|
||
d = m.domEvent;
|
||
J(r, d), be(!1);
|
||
},
|
||
id: Me,
|
||
tabIndex: -1,
|
||
role: 'listbox',
|
||
'aria-activedescendant': Ae,
|
||
selectedKeys: [de],
|
||
'aria-label': F !== void 0 ? F : 'expanded dropdown',
|
||
},
|
||
M.map(function(pe) {
|
||
return l.createElement(
|
||
ze.d,
|
||
{
|
||
key: pe.key,
|
||
id: ''.concat(Me, '-').concat(pe.key),
|
||
role: 'option',
|
||
'aria-controls': A && ''.concat(A, '-panel-').concat(pe.key),
|
||
disabled: pe.disabled,
|
||
},
|
||
pe.tab,
|
||
);
|
||
}),
|
||
);
|
||
function ce(pe) {
|
||
for (
|
||
var m = M.filter(function(t) {
|
||
return !t.disabled;
|
||
}),
|
||
r =
|
||
m.findIndex(function(t) {
|
||
return t.key === de;
|
||
}) || 0,
|
||
d = m.length,
|
||
n = 0;
|
||
n < d;
|
||
n += 1
|
||
) {
|
||
r = (r + pe + d) % d;
|
||
var e = m[r];
|
||
if (!e.disabled) {
|
||
Ne(e.key);
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
function fe(pe) {
|
||
var m = pe.which;
|
||
if (!le) {
|
||
[D.a.DOWN, D.a.SPACE, D.a.ENTER].includes(m) && (be(!0), pe.preventDefault());
|
||
return;
|
||
}
|
||
switch (m) {
|
||
case D.a.UP:
|
||
ce(-1), pe.preventDefault();
|
||
break;
|
||
case D.a.DOWN:
|
||
ce(1), pe.preventDefault();
|
||
break;
|
||
case D.a.ESC:
|
||
be(!1);
|
||
break;
|
||
case D.a.SPACE:
|
||
case D.a.ENTER:
|
||
de !== null && J(de, pe);
|
||
break;
|
||
}
|
||
}
|
||
Object(l.useEffect)(
|
||
function() {
|
||
var pe = document.getElementById(Ae);
|
||
pe && pe.scrollIntoView && pe.scrollIntoView(!1);
|
||
},
|
||
[de],
|
||
),
|
||
Object(l.useEffect)(
|
||
function() {
|
||
le || Ne(null);
|
||
},
|
||
[le],
|
||
);
|
||
var V = Object(I.a)({}, ae ? 'marginLeft' : 'marginRight', he);
|
||
M.length || ((V.visibility = 'hidden'), (V.order = 1));
|
||
var ye = x()(Object(I.a)({}, ''.concat(Le, '-rtl'), ae)),
|
||
Ue = K
|
||
? null
|
||
: l.createElement(
|
||
et.a,
|
||
{
|
||
prefixCls: Le,
|
||
overlay: k,
|
||
trigger: ['hover'],
|
||
visible: le,
|
||
transitionName: Q,
|
||
onVisibleChange: be,
|
||
overlayClassName: ye,
|
||
mouseEnterDelay: 0.1,
|
||
mouseLeaveDelay: 0.1,
|
||
},
|
||
l.createElement(
|
||
'button',
|
||
{
|
||
type: 'button',
|
||
className: ''.concat(C, '-nav-more'),
|
||
style: V,
|
||
tabIndex: -1,
|
||
'aria-hidden': 'true',
|
||
'aria-haspopup': 'listbox',
|
||
'aria-controls': Me,
|
||
id: ''.concat(A, '-more'),
|
||
'aria-expanded': le,
|
||
onKeyDown: fe,
|
||
},
|
||
U,
|
||
),
|
||
);
|
||
return l.createElement(
|
||
'div',
|
||
{ className: x()(''.concat(C, '-nav-operations'), X), style: H, ref: O },
|
||
Ue,
|
||
l.createElement(tt, { prefixCls: C, locale: T, editable: te }),
|
||
);
|
||
}
|
||
var nt = l.forwardRef(dt),
|
||
Qe = Object(l.createContext)(null),
|
||
at = 0.1,
|
||
He = 0.01,
|
||
Xe = 20,
|
||
Be = Math.pow(0.995, Xe);
|
||
function Ve() {
|
||
var s = navigator.userAgent || navigator.vendor || window.opera;
|
||
return !!(
|
||
/(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino|android|ipad|playbook|silk/i.test(
|
||
s,
|
||
) ||
|
||
/1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw-(n|u)|c55\/|capi|ccwa|cdm-|cell|chtm|cldc|cmd-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc-s|devi|dica|dmob|do(c|p)o|ds(12|-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(-|_)|g1 u|g560|gene|gf-5|g-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd-(m|p|t)|hei-|hi(pt|ta)|hp( i|ip)|hs-c|ht(c(-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i-(20|go|ma)|i230|iac( |-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|-[a-w])|libw|lynx|m1-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|-([1-8]|c))|phil|pire|pl(ay|uc)|pn-2|po(ck|rt|se)|prox|psio|pt-g|qa-a|qc(07|12|21|32|60|-[2-7]|i-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h-|oo|p-)|sdk\/|se(c(-|0|1)|47|mc|nd|ri)|sgh-|shar|sie(-|m)|sk-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h-|v-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl-|tdg-|tel(i|m)|tim-|t-mo|to(pl|sh)|ts(70|m-|m3|m5)|tx-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas-|your|zeto|zte-/i.test(
|
||
s.substr(0, 4),
|
||
)
|
||
);
|
||
}
|
||
function xe(s, O) {
|
||
var C = Object(l.useState)(),
|
||
A = Object(v.a)(C, 2),
|
||
M = A[0],
|
||
T = A[1],
|
||
K = Object(l.useState)(0),
|
||
_ = Object(v.a)(K, 2),
|
||
U = _[0],
|
||
Q = _[1],
|
||
H = Object(l.useState)(0),
|
||
X = Object(v.a)(H, 2),
|
||
te = X[0],
|
||
he = X[1],
|
||
ae = Object(l.useState)(),
|
||
J = Object(v.a)(ae, 2),
|
||
ge = J[0],
|
||
ie = J[1],
|
||
le = Object(l.useRef)();
|
||
function be(F) {
|
||
var k = F.touches[0],
|
||
ce = k.screenX,
|
||
fe = k.screenY;
|
||
T({ x: ce, y: fe }), window.clearInterval(le.current);
|
||
}
|
||
function ve(F) {
|
||
if (!M) return;
|
||
F.preventDefault();
|
||
var k = F.touches[0],
|
||
ce = k.screenX,
|
||
fe = k.screenY;
|
||
T({ x: ce, y: fe });
|
||
var V = ce - M.x,
|
||
ye = fe - M.y;
|
||
O(V, ye);
|
||
var Ue = Date.now();
|
||
Q(Ue), he(Ue - U), ie({ x: V, y: ye });
|
||
}
|
||
function Ce() {
|
||
if (!M) return;
|
||
if ((T(null), ie(null), ge)) {
|
||
var F = ge.x / te,
|
||
k = ge.y / te,
|
||
ce = Math.abs(F),
|
||
fe = Math.abs(k);
|
||
if (Math.max(ce, fe) < at) return;
|
||
var V = F,
|
||
ye = k;
|
||
le.current = window.setInterval(function() {
|
||
if (Math.abs(V) < He && Math.abs(ye) < He) {
|
||
window.clearInterval(le.current);
|
||
return;
|
||
}
|
||
(V *= Be), (ye *= Be), O(V * Xe, ye * Xe);
|
||
}, Xe);
|
||
}
|
||
}
|
||
var de = Object(l.useRef)(0),
|
||
Ne = Object(l.useRef)(!1),
|
||
Me = Object(l.useRef)();
|
||
function Le(F) {
|
||
var k = F.deltaX,
|
||
ce = F.deltaY,
|
||
fe = 0,
|
||
V = Math.abs(k),
|
||
ye = Math.abs(ce);
|
||
V === ye
|
||
? (fe = Me.current === 'x' ? k : ce)
|
||
: V > ye
|
||
? ((fe = k), (Me.current = 'x'))
|
||
: ((fe = ce), (Me.current = 'y'));
|
||
var Ue = Date.now();
|
||
Ue - de.current > 100 && (Ne.current = !1),
|
||
(O(-fe, -fe) || Ne.current) && (F.preventDefault(), (Ne.current = !0)),
|
||
(de.current = Ue);
|
||
}
|
||
var Ae = Object(l.useRef)(null);
|
||
(Ae.current = { onTouchStart: be, onTouchMove: ve, onTouchEnd: Ce, onWheel: Le }),
|
||
l.useEffect(function() {
|
||
function F(V) {
|
||
Ae.current.onTouchStart(V);
|
||
}
|
||
function k(V) {
|
||
Ae.current.onTouchMove(V);
|
||
}
|
||
function ce(V) {
|
||
Ae.current.onTouchEnd(V);
|
||
}
|
||
function fe(V) {
|
||
Ae.current.onWheel(V);
|
||
}
|
||
return (
|
||
document.addEventListener('touchmove', k, { passive: !1 }),
|
||
document.addEventListener('touchend', ce, { passive: !1 }),
|
||
s.current.addEventListener('touchstart', F, { passive: !1 }),
|
||
s.current.addEventListener('wheel', fe),
|
||
function() {
|
||
document.removeEventListener('touchmove', k),
|
||
document.removeEventListener('touchend', ce);
|
||
}
|
||
);
|
||
}, []);
|
||
}
|
||
function ot() {
|
||
var s = Object(l.useRef)(new Map());
|
||
function O(A) {
|
||
return s.current.has(A) || s.current.set(A, l.createRef()), s.current.get(A);
|
||
}
|
||
function C(A) {
|
||
s.current.delete(A);
|
||
}
|
||
return [O, C];
|
||
}
|
||
function rt(s, O) {
|
||
var C = l.useRef(s),
|
||
A = l.useState({}),
|
||
M = Object(v.a)(A, 2),
|
||
T = M[1];
|
||
function K(_) {
|
||
var U = typeof _ == 'function' ? _(C.current) : _;
|
||
U !== C.current && O(U, C.current), (C.current = U), T({});
|
||
}
|
||
return [C.current, K];
|
||
}
|
||
var Je = function(O) {
|
||
var C = O.position,
|
||
A = O.prefixCls,
|
||
M = O.extra;
|
||
if (!M) return null;
|
||
var T,
|
||
K = M;
|
||
return (
|
||
C === 'right' && (T = K.right || (!K.left && K) || null),
|
||
C === 'left' && (T = K.left || null),
|
||
T ? l.createElement('div', { className: ''.concat(A, '-extra-content') }, T) : null
|
||
);
|
||
};
|
||
function it(s, O) {
|
||
var C,
|
||
A = l.useContext(Qe),
|
||
M = A.prefixCls,
|
||
T = A.tabs,
|
||
K = s.className,
|
||
_ = s.style,
|
||
U = s.id,
|
||
Q = s.animated,
|
||
H = s.activeKey,
|
||
X = s.rtl,
|
||
te = s.extra,
|
||
he = s.editable,
|
||
ae = s.locale,
|
||
J = s.tabPosition,
|
||
ge = s.tabBarGutter,
|
||
ie = s.children,
|
||
le = s.onTabClick,
|
||
be = s.onTabScroll,
|
||
ve = Object(l.useRef)(),
|
||
Ce = Object(l.useRef)(),
|
||
de = Object(l.useRef)(),
|
||
Ne = Object(l.useRef)(),
|
||
Me = ot(),
|
||
Le = Object(v.a)(Me, 2),
|
||
Ae = Le[0],
|
||
F = Le[1],
|
||
k = J === 'top' || J === 'bottom',
|
||
ce = rt(0, function(oe, G) {
|
||
k && be && be({ direction: oe > G ? 'left' : 'right' });
|
||
}),
|
||
fe = Object(v.a)(ce, 2),
|
||
V = fe[0],
|
||
ye = fe[1],
|
||
Ue = rt(0, function(oe, G) {
|
||
!k && be && be({ direction: oe > G ? 'top' : 'bottom' });
|
||
}),
|
||
pe = Object(v.a)(Ue, 2),
|
||
m = pe[0],
|
||
r = pe[1],
|
||
d = Object(l.useState)(0),
|
||
n = Object(v.a)(d, 2),
|
||
e = n[0],
|
||
t = n[1],
|
||
a = Object(l.useState)(0),
|
||
c = Object(v.a)(a, 2),
|
||
h = c[0],
|
||
p = c[1],
|
||
u = Object(l.useState)(0),
|
||
f = Object(v.a)(u, 2),
|
||
b = f[0],
|
||
W = f[1],
|
||
w = Object(l.useState)(0),
|
||
se = Object(v.a)(w, 2),
|
||
$ = se[0],
|
||
Pe = se[1],
|
||
Ge = Object(l.useState)(null),
|
||
Fe = Object(v.a)(Ge, 2),
|
||
Re = Fe[0],
|
||
ut = Fe[1],
|
||
Et = Object(l.useState)(null),
|
||
Ze = Object(v.a)(Et, 2),
|
||
Ke = Ze[0],
|
||
Ut = Ze[1],
|
||
_t = Object(l.useState)(0),
|
||
Rt = Object(v.a)(_t, 2),
|
||
wt = Rt[0],
|
||
Pt = Rt[1],
|
||
Kt = Object(l.useState)(0),
|
||
vt = Object(v.a)(Kt, 2),
|
||
bn = vt[0],
|
||
yn = vt[1],
|
||
En = Se(new Map()),
|
||
Yt = Object(v.a)(En, 2),
|
||
On = Yt[0],
|
||
gn = Yt[1],
|
||
xt = ne(T, On, e),
|
||
Qt = ''.concat(M, '-nav-operations-hidden'),
|
||
Ot = 0,
|
||
gt = 0;
|
||
k
|
||
? X
|
||
? ((Ot = 0), (gt = Math.max(0, e - Re)))
|
||
: ((Ot = Math.min(0, Re - e)), (gt = 0))
|
||
: ((Ot = Math.min(0, Ke - h)), (gt = 0));
|
||
function kt(oe) {
|
||
return oe < Ot ? [Ot, !1] : oe > gt ? [gt, !1] : [oe, !0];
|
||
}
|
||
var Jt = Object(l.useRef)(),
|
||
Cn = Object(l.useState)(),
|
||
Zt = Object(v.a)(Cn, 2),
|
||
Wt = Zt[0],
|
||
qt = Zt[1];
|
||
function Bt() {
|
||
qt(Date.now());
|
||
}
|
||
function Ft() {
|
||
window.clearTimeout(Jt.current);
|
||
}
|
||
xe(ve, function(oe, G) {
|
||
var De = !1;
|
||
function ke(Mt, Tt) {
|
||
Mt(function(Nt) {
|
||
var At = kt(Nt + Tt),
|
||
pt = Object(v.a)(At, 2),
|
||
Vt = pt[0],
|
||
$t = pt[1];
|
||
return (De = $t), Vt;
|
||
});
|
||
}
|
||
if (k) {
|
||
if (Re >= e) return De;
|
||
ke(ye, oe);
|
||
} else {
|
||
if (Ke >= h) return De;
|
||
ke(r, G);
|
||
}
|
||
return Ft(), Bt(), De;
|
||
}),
|
||
Object(l.useEffect)(
|
||
function() {
|
||
return (
|
||
Ft(),
|
||
Wt &&
|
||
(Jt.current = window.setTimeout(function() {
|
||
qt(0);
|
||
}, 100)),
|
||
Ft
|
||
);
|
||
},
|
||
[Wt],
|
||
);
|
||
function en() {
|
||
var oe = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : H,
|
||
G = xt.get(oe);
|
||
if (!G) return;
|
||
if (k) {
|
||
var De = V;
|
||
X
|
||
? G.right < V
|
||
? (De = G.right)
|
||
: G.right + G.width > V + Re && (De = G.right + G.width - Re)
|
||
: G.left < -V
|
||
? (De = -G.left)
|
||
: G.left + G.width > -V + Re && (De = -(G.left + G.width - Re)),
|
||
r(0),
|
||
ye(kt(De)[0]);
|
||
} else {
|
||
var ke = m;
|
||
G.top < -m
|
||
? (ke = -G.top)
|
||
: G.top + G.height > -m + Ke && (ke = -(G.top + G.height - Ke)),
|
||
ye(0),
|
||
r(kt(ke)[0]);
|
||
}
|
||
}
|
||
var Mn = Ye(
|
||
xt,
|
||
{ width: Re, height: Ke, left: V, top: m },
|
||
{ width: b, height: $ },
|
||
{ width: wt, height: bn },
|
||
Object(S.a)(Object(S.a)({}, s), {}, { tabs: T }),
|
||
),
|
||
tn = Object(v.a)(Mn, 2),
|
||
Tn = tn[0],
|
||
Nn = tn[1],
|
||
An = T.map(function(oe) {
|
||
var G = oe.key;
|
||
return l.createElement(Ie, {
|
||
id: U,
|
||
prefixCls: M,
|
||
key: G,
|
||
rtl: X,
|
||
tab: oe,
|
||
closable: oe.closable,
|
||
editable: he,
|
||
active: G === H,
|
||
tabPosition: J,
|
||
tabBarGutter: ge,
|
||
renderWrapper: ie,
|
||
removeAriaLabel: ae == null ? void 0 : ae.removeAriaLabel,
|
||
ref: Ae(G),
|
||
onClick: function(ke) {
|
||
le(G, ke);
|
||
},
|
||
onRemove: function() {
|
||
F(G);
|
||
},
|
||
onFocus: function() {
|
||
en(G), Bt(), X || (ve.current.scrollLeft = 0), (ve.current.scrollTop = 0);
|
||
},
|
||
});
|
||
}),
|
||
zt = re(function() {
|
||
var oe,
|
||
G,
|
||
De,
|
||
ke,
|
||
Mt,
|
||
Tt,
|
||
Nt,
|
||
At,
|
||
pt,
|
||
Vt = ((oe = ve.current) === null || oe === void 0 ? void 0 : oe.offsetWidth) || 0,
|
||
$t = ((G = ve.current) === null || G === void 0 ? void 0 : G.offsetHeight) || 0,
|
||
un = ((De = Ne.current) === null || De === void 0 ? void 0 : De.offsetWidth) || 0,
|
||
dn = ((ke = Ne.current) === null || ke === void 0 ? void 0 : ke.offsetHeight) || 0,
|
||
Pn = ((Mt = de.current) === null || Mt === void 0 ? void 0 : Mt.offsetWidth) || 0,
|
||
xn = ((Tt = de.current) === null || Tt === void 0 ? void 0 : Tt.offsetHeight) || 0;
|
||
ut(Vt), Ut($t), Pt(un), yn(dn);
|
||
var fn =
|
||
(((Nt = Ce.current) === null || Nt === void 0 ? void 0 : Nt.offsetWidth) || 0) - un,
|
||
mn =
|
||
(((At = Ce.current) === null || At === void 0 ? void 0 : At.offsetHeight) || 0) -
|
||
dn;
|
||
t(fn), p(mn);
|
||
var vn =
|
||
(pt = de.current) === null || pt === void 0 ? void 0 : pt.className.includes(Qt);
|
||
W(fn - (vn ? 0 : Pn)),
|
||
Pe(mn - (vn ? 0 : xn)),
|
||
gn(function() {
|
||
var pn = new Map();
|
||
return (
|
||
T.forEach(function(Ln) {
|
||
var hn = Ln.key,
|
||
St = Ae(hn).current;
|
||
St &&
|
||
pn.set(hn, {
|
||
width: St.offsetWidth,
|
||
height: St.offsetHeight,
|
||
left: St.offsetLeft,
|
||
top: St.offsetTop,
|
||
});
|
||
}),
|
||
pn
|
||
);
|
||
});
|
||
}),
|
||
Sn = T.slice(0, Tn),
|
||
In = T.slice(Nn + 1),
|
||
nn = [].concat(Object(Y.a)(Sn), Object(Y.a)(In)),
|
||
Dn = Object(l.useState)(),
|
||
an = Object(v.a)(Dn, 2),
|
||
jn = an[0],
|
||
Rn = an[1],
|
||
qe = xt.get(H),
|
||
on = Object(l.useRef)();
|
||
function rn() {
|
||
Z.a.cancel(on.current);
|
||
}
|
||
Object(l.useEffect)(
|
||
function() {
|
||
var oe = {};
|
||
return (
|
||
qe &&
|
||
(k
|
||
? (X ? (oe.right = qe.right) : (oe.left = qe.left), (oe.width = qe.width))
|
||
: ((oe.top = qe.top), (oe.height = qe.height))),
|
||
rn(),
|
||
(on.current = Z()(function() {
|
||
Rn(oe);
|
||
})),
|
||
rn
|
||
);
|
||
},
|
||
[qe, k, X],
|
||
),
|
||
Object(l.useEffect)(
|
||
function() {
|
||
en();
|
||
},
|
||
[H, qe, xt, k],
|
||
),
|
||
Object(l.useEffect)(
|
||
function() {
|
||
zt();
|
||
},
|
||
[
|
||
X,
|
||
ge,
|
||
H,
|
||
T.map(function(oe) {
|
||
return oe.key;
|
||
}).join('_'),
|
||
],
|
||
);
|
||
var sn = !!nn.length,
|
||
Ct = ''.concat(M, '-nav-wrap'),
|
||
Ht,
|
||
Xt,
|
||
ln,
|
||
cn;
|
||
return (
|
||
k
|
||
? X
|
||
? ((Xt = V > 0), (Ht = V + Re < e))
|
||
: ((Ht = V < 0), (Xt = -V + Re < e))
|
||
: ((ln = m < 0), (cn = -m + Ke < h)),
|
||
l.createElement(
|
||
'div',
|
||
{
|
||
ref: O,
|
||
role: 'tablist',
|
||
className: x()(''.concat(M, '-nav'), K),
|
||
style: _,
|
||
onKeyDown: function() {
|
||
Bt();
|
||
},
|
||
},
|
||
l.createElement(Je, { position: 'left', extra: te, prefixCls: M }),
|
||
l.createElement(
|
||
me.default,
|
||
{ onResize: zt },
|
||
l.createElement(
|
||
'div',
|
||
{
|
||
className: x()(
|
||
Ct,
|
||
((C = {}),
|
||
Object(I.a)(C, ''.concat(Ct, '-ping-left'), Ht),
|
||
Object(I.a)(C, ''.concat(Ct, '-ping-right'), Xt),
|
||
Object(I.a)(C, ''.concat(Ct, '-ping-top'), ln),
|
||
Object(I.a)(C, ''.concat(Ct, '-ping-bottom'), cn),
|
||
C),
|
||
),
|
||
ref: ve,
|
||
},
|
||
l.createElement(
|
||
me.default,
|
||
{ onResize: zt },
|
||
l.createElement(
|
||
'div',
|
||
{
|
||
ref: Ce,
|
||
className: ''.concat(M, '-nav-list'),
|
||
style: {
|
||
transform: 'translate('.concat(V, 'px, ').concat(m, 'px)'),
|
||
transition: Wt ? 'none' : void 0,
|
||
},
|
||
},
|
||
An,
|
||
l.createElement(tt, {
|
||
ref: Ne,
|
||
prefixCls: M,
|
||
locale: ae,
|
||
editable: he,
|
||
style: { visibility: sn ? 'hidden' : null },
|
||
}),
|
||
l.createElement('div', {
|
||
className: x()(
|
||
''.concat(M, '-ink-bar'),
|
||
Object(I.a)({}, ''.concat(M, '-ink-bar-animated'), Q.inkBar),
|
||
),
|
||
style: jn,
|
||
}),
|
||
),
|
||
),
|
||
),
|
||
),
|
||
l.createElement(
|
||
nt,
|
||
Object.assign({}, s, { ref: de, prefixCls: M, tabs: nn, className: !sn && Qt }),
|
||
),
|
||
l.createElement(Je, { position: 'right', extra: te, prefixCls: M }),
|
||
)
|
||
);
|
||
}
|
||
var st = l.forwardRef(it);
|
||
function ft(s) {
|
||
var O = s.id,
|
||
C = s.activeKey,
|
||
A = s.animated,
|
||
M = s.tabPosition,
|
||
T = s.rtl,
|
||
K = s.destroyInactiveTabPane,
|
||
_ = l.useContext(Qe),
|
||
U = _.prefixCls,
|
||
Q = _.tabs,
|
||
H = A.tabPane,
|
||
X = Q.findIndex(function(te) {
|
||
return te.key === C;
|
||
});
|
||
return l.createElement(
|
||
'div',
|
||
{ className: x()(''.concat(U, '-content-holder')) },
|
||
l.createElement(
|
||
'div',
|
||
{
|
||
className: x()(
|
||
''.concat(U, '-content'),
|
||
''.concat(U, '-content-').concat(M),
|
||
Object(I.a)({}, ''.concat(U, '-content-animated'), H),
|
||
),
|
||
style:
|
||
X && H
|
||
? Object(I.a)({}, T ? 'marginRight' : 'marginLeft', '-'.concat(X, '00%'))
|
||
: null,
|
||
},
|
||
Q.map(function(te) {
|
||
return l.cloneElement(te.node, {
|
||
key: te.key,
|
||
prefixCls: U,
|
||
tabKey: te.key,
|
||
id: O,
|
||
animated: H,
|
||
active: te.key === C,
|
||
destroyInactiveTabPane: K,
|
||
});
|
||
}),
|
||
),
|
||
);
|
||
}
|
||
function P(s) {
|
||
var O = s.prefixCls,
|
||
C = s.forceRender,
|
||
A = s.className,
|
||
M = s.style,
|
||
T = s.id,
|
||
K = s.active,
|
||
_ = s.animated,
|
||
U = s.destroyInactiveTabPane,
|
||
Q = s.tabKey,
|
||
H = s.children,
|
||
X = l.useState(C),
|
||
te = Object(v.a)(X, 2),
|
||
he = te[0],
|
||
ae = te[1];
|
||
l.useEffect(
|
||
function() {
|
||
K ? ae(!0) : U && ae(!1);
|
||
},
|
||
[K, U],
|
||
);
|
||
var J = {};
|
||
return (
|
||
K ||
|
||
(_
|
||
? ((J.visibility = 'hidden'), (J.height = 0), (J.overflowY = 'hidden'))
|
||
: (J.display = 'none')),
|
||
l.createElement(
|
||
'div',
|
||
{
|
||
id: T && ''.concat(T, '-panel-').concat(Q),
|
||
role: 'tabpanel',
|
||
tabIndex: K ? 0 : -1,
|
||
'aria-labelledby': T && ''.concat(T, '-tab-').concat(Q),
|
||
'aria-hidden': !K,
|
||
style: Object(S.a)(Object(S.a)({}, J), M),
|
||
className: x()(''.concat(O, '-tabpane'), K && ''.concat(O, '-tabpane-active'), A),
|
||
},
|
||
(K || he || C) && H,
|
||
)
|
||
);
|
||
}
|
||
var lt = 0;
|
||
function ht(s) {
|
||
return Object(R.a)(s)
|
||
.map(function(O) {
|
||
if (l.isValidElement(O)) {
|
||
var C = O.key !== void 0 ? String(O.key) : void 0;
|
||
return Object(S.a)(Object(S.a)({ key: C }, O.props), {}, { node: O });
|
||
}
|
||
return null;
|
||
})
|
||
.filter(function(O) {
|
||
return O;
|
||
});
|
||
}
|
||
function bt(s, O) {
|
||
var C,
|
||
A = s.id,
|
||
M = s.prefixCls,
|
||
T = M === void 0 ? 'rc-tabs' : M,
|
||
K = s.className,
|
||
_ = s.children,
|
||
U = s.direction,
|
||
Q = s.activeKey,
|
||
H = s.defaultActiveKey,
|
||
X = s.editable,
|
||
te = s.animated,
|
||
he = s.tabPosition,
|
||
ae = he === void 0 ? 'top' : he,
|
||
J = s.tabBarGutter,
|
||
ge = s.tabBarStyle,
|
||
ie = s.tabBarExtraContent,
|
||
le = s.locale,
|
||
be = s.moreIcon,
|
||
ve = s.moreTransitionName,
|
||
Ce = s.destroyInactiveTabPane,
|
||
de = s.renderTabBar,
|
||
Ne = s.onChange,
|
||
Me = s.onTabClick,
|
||
Le = s.onTabScroll,
|
||
Ae = Object(z.a)(s, [
|
||
'id',
|
||
'prefixCls',
|
||
'className',
|
||
'children',
|
||
'direction',
|
||
'activeKey',
|
||
'defaultActiveKey',
|
||
'editable',
|
||
'animated',
|
||
'tabPosition',
|
||
'tabBarGutter',
|
||
'tabBarStyle',
|
||
'tabBarExtraContent',
|
||
'locale',
|
||
'moreIcon',
|
||
'moreTransitionName',
|
||
'destroyInactiveTabPane',
|
||
'renderTabBar',
|
||
'onChange',
|
||
'onTabClick',
|
||
'onTabScroll',
|
||
]),
|
||
F = ht(_),
|
||
k = U === 'rtl',
|
||
ce;
|
||
te === !1
|
||
? (ce = { inkBar: !1, tabPane: !1 })
|
||
: (ce = Object(S.a)({ inkBar: !0, tabPane: !1 }, te !== !0 ? te : null));
|
||
var fe = Object(l.useState)(!1),
|
||
V = Object(v.a)(fe, 2),
|
||
ye = V[0],
|
||
Ue = V[1];
|
||
Object(l.useEffect)(function() {
|
||
Ue(Ve());
|
||
}, []);
|
||
var pe = Object(B.a)(
|
||
function() {
|
||
var $;
|
||
return ($ = F[0]) === null || $ === void 0 ? void 0 : $.key;
|
||
},
|
||
{ value: Q, defaultValue: H },
|
||
),
|
||
m = Object(v.a)(pe, 2),
|
||
r = m[0],
|
||
d = m[1],
|
||
n = Object(l.useState)(function() {
|
||
return F.findIndex(function($) {
|
||
return $.key === r;
|
||
});
|
||
}),
|
||
e = Object(v.a)(n, 2),
|
||
t = e[0],
|
||
a = e[1];
|
||
Object(l.useEffect)(
|
||
function() {
|
||
var $ = F.findIndex(function(Ge) {
|
||
return Ge.key === r;
|
||
});
|
||
if ($ === -1) {
|
||
var Pe;
|
||
($ = Math.max(0, Math.min(t, F.length - 1))),
|
||
d((Pe = F[$]) === null || Pe === void 0 ? void 0 : Pe.key);
|
||
}
|
||
a($);
|
||
},
|
||
[
|
||
F.map(function($) {
|
||
return $.key;
|
||
}).join('_'),
|
||
r,
|
||
t,
|
||
],
|
||
);
|
||
var c = Object(B.a)(null, { value: A }),
|
||
h = Object(v.a)(c, 2),
|
||
p = h[0],
|
||
u = h[1],
|
||
f = ae;
|
||
ye && !['left', 'right'].includes(ae) && (f = 'top'),
|
||
Object(l.useEffect)(function() {
|
||
A || (u('rc-tabs-'.concat(lt)), (lt += 1));
|
||
}, []);
|
||
function b($, Pe) {
|
||
Me == null || Me($, Pe), d($), Ne == null || Ne($);
|
||
}
|
||
var W = { id: p, activeKey: r, animated: ce, tabPosition: f, rtl: k, mobile: ye },
|
||
w,
|
||
se = Object(S.a)(
|
||
Object(S.a)({}, W),
|
||
{},
|
||
{
|
||
editable: X,
|
||
locale: le,
|
||
moreIcon: be,
|
||
moreTransitionName: ve,
|
||
tabBarGutter: J,
|
||
onTabClick: b,
|
||
onTabScroll: Le,
|
||
extra: ie,
|
||
style: ge,
|
||
panes: _,
|
||
},
|
||
);
|
||
return (
|
||
de ? (w = de(se, st)) : (w = l.createElement(st, Object.assign({}, se))),
|
||
l.createElement(
|
||
Qe.Provider,
|
||
{ value: { tabs: F, prefixCls: T } },
|
||
l.createElement(
|
||
'div',
|
||
Object.assign(
|
||
{
|
||
ref: O,
|
||
id: A,
|
||
className: x()(
|
||
T,
|
||
''.concat(T, '-').concat(f),
|
||
((C = {}),
|
||
Object(I.a)(C, ''.concat(T, '-mobile'), ye),
|
||
Object(I.a)(C, ''.concat(T, '-editable'), X),
|
||
Object(I.a)(C, ''.concat(T, '-rtl'), k),
|
||
C),
|
||
K,
|
||
),
|
||
},
|
||
Ae,
|
||
),
|
||
w,
|
||
l.createElement(
|
||
ft,
|
||
Object.assign({ destroyInactiveTabPane: Ce }, W, { animated: ce }),
|
||
),
|
||
),
|
||
)
|
||
);
|
||
}
|
||
var Ee = l.forwardRef(bt);
|
||
Ee.TabPane = P;
|
||
var $e = Ee,
|
||
_e = $e,
|
||
ee = o('cCPh'),
|
||
Oe = o.n(ee),
|
||
we = o('fNCr'),
|
||
yt = o.n(we),
|
||
mt = o('V/uB'),
|
||
Lt = o.n(mt),
|
||
It = o('uaoM'),
|
||
Dt = o('H84U'),
|
||
ct = function(s, O) {
|
||
var C = {};
|
||
for (var A in s)
|
||
Object.prototype.hasOwnProperty.call(s, A) && O.indexOf(A) < 0 && (C[A] = s[A]);
|
||
if (s != null && typeof Object.getOwnPropertySymbols == 'function')
|
||
for (var M = 0, A = Object.getOwnPropertySymbols(s); M < A.length; M++)
|
||
O.indexOf(A[M]) < 0 &&
|
||
Object.prototype.propertyIsEnumerable.call(s, A[M]) &&
|
||
(C[A[M]] = s[A[M]]);
|
||
return C;
|
||
};
|
||
function jt(s) {
|
||
var O,
|
||
C = s.type,
|
||
A = s.className,
|
||
M = s.size,
|
||
T = s.onEdit,
|
||
K = s.hideAdd,
|
||
_ = s.centered,
|
||
U = s.addIcon,
|
||
Q = ct(s, ['type', 'className', 'size', 'onEdit', 'hideAdd', 'centered', 'addIcon']),
|
||
H = Q.prefixCls,
|
||
X = l.useContext(Dt.b),
|
||
te = X.getPrefixCls,
|
||
he = X.direction,
|
||
ae = te('tabs', H),
|
||
J;
|
||
return (
|
||
C === 'editable-card' &&
|
||
(J = {
|
||
onEdit: function(ie, le) {
|
||
var be = le.key,
|
||
ve = le.event;
|
||
T == null || T(ie === 'add' ? ve : be, ie);
|
||
},
|
||
removeIcon: l.createElement(Lt.a, null),
|
||
addIcon: U || l.createElement(yt.a, null),
|
||
showAdd: K !== !0,
|
||
}),
|
||
Object(It.a)(
|
||
!('onPrevClick' in Q) && !('onNextClick' in Q),
|
||
'Tabs',
|
||
'`onPrevClick` and `onNextClick` has been removed. Please use `onTabScroll` instead.',
|
||
),
|
||
l.createElement(
|
||
_e,
|
||
j()({ direction: he }, Q, {
|
||
moreTransitionName: 'slide-up',
|
||
className: x()(
|
||
((O = {}),
|
||
y()(O, ''.concat(ae, '-').concat(M), M),
|
||
y()(O, ''.concat(ae, '-card'), ['card', 'editable-card'].includes(C)),
|
||
y()(O, ''.concat(ae, '-editable-card'), C === 'editable-card'),
|
||
y()(O, ''.concat(ae, '-centered'), _),
|
||
O),
|
||
A,
|
||
),
|
||
editable: J,
|
||
moreIcon: l.createElement(Oe.a, null),
|
||
prefixCls: ae,
|
||
}),
|
||
)
|
||
);
|
||
}
|
||
jt.TabPane = P;
|
||
var Gt = (N.a = jt);
|
||
},
|
||
'Znn+': function(ue, N, o) {
|
||
'use strict';
|
||
var i = o('cIOH'),
|
||
j = o.n(i),
|
||
E = o('9ama'),
|
||
y = o.n(E);
|
||
},
|
||
aJNx: function(ue, N, o) {
|
||
'use strict';
|
||
var i = o('q1tI'),
|
||
j = {
|
||
icon: {
|
||
tag: 'svg',
|
||
attrs: { viewBox: '64 64 896 896', focusable: 'false' },
|
||
children: [
|
||
{
|
||
tag: 'path',
|
||
attrs: {
|
||
d:
|
||
'M928 160H96c-17.7 0-32 14.3-32 32v640c0 17.7 14.3 32 32 32h832c17.7 0 32-14.3 32-32V192c0-17.7-14.3-32-32-32zm-40 632H136V232h752v560zM610.3 476h123.4c1.3 0 2.3-3.6 2.3-8v-48c0-4.4-1-8-2.3-8H610.3c-1.3 0-2.3 3.6-2.3 8v48c0 4.4 1 8 2.3 8zm4.8 144h185.7c3.9 0 7.1-3.6 7.1-8v-48c0-4.4-3.2-8-7.1-8H615.1c-3.9 0-7.1 3.6-7.1 8v48c0 4.4 3.2 8 7.1 8zM224 673h43.9c4.2 0 7.6-3.3 7.9-7.5 3.8-50.5 46-90.5 97.2-90.5s93.4 40 97.2 90.5c.3 4.2 3.7 7.5 7.9 7.5H522a8 8 0 008-8.4c-2.8-53.3-32-99.7-74.6-126.1a111.8 111.8 0 0029.1-75.5c0-61.9-49.9-112-111.4-112s-111.4 50.1-111.4 112c0 29.1 11 55.5 29.1 75.5a158.09 158.09 0 00-74.6 126.1c-.4 4.6 3.2 8.4 7.8 8.4zm149-262c28.5 0 51.7 23.3 51.7 52s-23.2 52-51.7 52-51.7-23.3-51.7-52 23.2-52 51.7-52z',
|
||
},
|
||
},
|
||
],
|
||
},
|
||
name: 'idcard',
|
||
theme: 'outlined',
|
||
},
|
||
E = j,
|
||
y = o('6VBw'),
|
||
l = function(z, S) {
|
||
return i.createElement(y.a, Object.assign({}, z, { ref: S, icon: E }));
|
||
};
|
||
l.displayName = 'IdcardOutlined';
|
||
var I = (N.a = i.forwardRef(l));
|
||
},
|
||
cCPh: function(ue, N, o) {
|
||
'use strict';
|
||
Object.defineProperty(N, '__esModule', { value: !0 }), (N.default = void 0);
|
||
var i = j(o('jiSn'));
|
||
function j(y) {
|
||
return y && y.__esModule ? y : { default: y };
|
||
}
|
||
var E = i;
|
||
(N.default = E), (ue.exports = E);
|
||
},
|
||
diRs: function(ue, N, o) {
|
||
'use strict';
|
||
var i = o('pVnL'),
|
||
j = o.n(i),
|
||
E = o('q1tI'),
|
||
y = o.n(E),
|
||
l = o('3S7+'),
|
||
I = o('H84U'),
|
||
v = o('bogI'),
|
||
z = function(g, x) {
|
||
var R = {};
|
||
for (var B in g)
|
||
Object.prototype.hasOwnProperty.call(g, B) && x.indexOf(B) < 0 && (R[B] = g[B]);
|
||
if (g != null && typeof Object.getOwnPropertySymbols == 'function')
|
||
for (var Y = 0, B = Object.getOwnPropertySymbols(g); Y < B.length; Y++)
|
||
x.indexOf(B[Y]) < 0 &&
|
||
Object.prototype.propertyIsEnumerable.call(g, B[Y]) &&
|
||
(R[B[Y]] = g[B[Y]]);
|
||
return R;
|
||
},
|
||
S = E.forwardRef(function(g, x) {
|
||
var R = g.prefixCls,
|
||
B = g.title,
|
||
Y = g.content,
|
||
L = z(g, ['prefixCls', 'title', 'content']),
|
||
Z = E.useContext(I.b),
|
||
me = Z.getPrefixCls,
|
||
re = function(q) {
|
||
return E.createElement(
|
||
E.Fragment,
|
||
null,
|
||
B && E.createElement('div', { className: ''.concat(q, '-title') }, Object(v.a)(B)),
|
||
E.createElement(
|
||
'div',
|
||
{ className: ''.concat(q, '-inner-content') },
|
||
Object(v.a)(Y),
|
||
),
|
||
);
|
||
},
|
||
Se = me('popover', R);
|
||
return E.createElement(l.a, j()({}, L, { prefixCls: Se, ref: x, overlay: re(Se) }));
|
||
});
|
||
(S.displayName = 'Popover'),
|
||
(S.defaultProps = {
|
||
placement: 'top',
|
||
transitionName: 'zoom-big',
|
||
trigger: 'hover',
|
||
mouseEnterDelay: 0.1,
|
||
mouseLeaveDelay: 0.1,
|
||
overlayStyle: {},
|
||
}),
|
||
(N.a = S);
|
||
},
|
||
eDIo: function(ue, N, o) {
|
||
'use strict';
|
||
var i = o('rePB'),
|
||
j = o('ODXe'),
|
||
E = o('Ff2n'),
|
||
y = o('q1tI'),
|
||
l = o('uciX'),
|
||
I = o('TSYQ'),
|
||
v = o.n(I),
|
||
z = { adjustX: 1, adjustY: 1 },
|
||
S = [0, 0],
|
||
g = {
|
||
topLeft: { points: ['bl', 'tl'], overflow: z, offset: [0, -4], targetOffset: S },
|
||
topCenter: { points: ['bc', 'tc'], overflow: z, offset: [0, -4], targetOffset: S },
|
||
topRight: { points: ['br', 'tr'], overflow: z, offset: [0, -4], targetOffset: S },
|
||
bottomLeft: { points: ['tl', 'bl'], overflow: z, offset: [0, 4], targetOffset: S },
|
||
bottomCenter: { points: ['tc', 'bc'], overflow: z, offset: [0, 4], targetOffset: S },
|
||
bottomRight: { points: ['tr', 'br'], overflow: z, offset: [0, 4], targetOffset: S },
|
||
},
|
||
x = g;
|
||
function R(L, Z) {
|
||
var me = L.arrow,
|
||
re = me === void 0 ? !1 : me,
|
||
Se = L.prefixCls,
|
||
D = Se === void 0 ? 'rc-dropdown' : Se,
|
||
q = L.transitionName,
|
||
Ie = L.animation,
|
||
Te = L.align,
|
||
ne = L.placement,
|
||
je = ne === void 0 ? 'bottomLeft' : ne,
|
||
Ye = L.placements,
|
||
ze = Ye === void 0 ? x : Ye,
|
||
et = L.getPopupContainer,
|
||
We = L.showAction,
|
||
tt = L.hideAction,
|
||
dt = L.overlayClassName,
|
||
nt = L.overlayStyle,
|
||
Qe = L.visible,
|
||
at = L.trigger,
|
||
He = at === void 0 ? ['hover'] : at,
|
||
Xe = Object(E.a)(L, [
|
||
'arrow',
|
||
'prefixCls',
|
||
'transitionName',
|
||
'animation',
|
||
'align',
|
||
'placement',
|
||
'placements',
|
||
'getPopupContainer',
|
||
'showAction',
|
||
'hideAction',
|
||
'overlayClassName',
|
||
'overlayStyle',
|
||
'visible',
|
||
'trigger',
|
||
]),
|
||
Be = y.useState(),
|
||
Ve = Object(j.a)(Be, 2),
|
||
xe = Ve[0],
|
||
ot = Ve[1],
|
||
rt = 'visible' in L ? Qe : xe,
|
||
Je = y.useRef(null);
|
||
y.useImperativeHandle(Z, function() {
|
||
return Je.current;
|
||
});
|
||
var it = function() {
|
||
var ee = L.overlay,
|
||
Oe;
|
||
return typeof ee == 'function' ? (Oe = ee()) : (Oe = ee), Oe;
|
||
},
|
||
st = function(ee) {
|
||
var Oe = L.onOverlayClick,
|
||
we = it().props;
|
||
ot(!1), Oe && Oe(ee), we.onClick && we.onClick(ee);
|
||
},
|
||
ft = function(ee) {
|
||
var Oe = L.onVisibleChange;
|
||
ot(ee), typeof Oe == 'function' && Oe(ee);
|
||
},
|
||
P = function() {
|
||
var ee = it(),
|
||
Oe = { prefixCls: ''.concat(D, '-menu'), onClick: st };
|
||
return (
|
||
typeof ee.type == 'string' && delete Oe.prefixCls,
|
||
y.createElement(
|
||
y.Fragment,
|
||
null,
|
||
re && y.createElement('div', { className: ''.concat(D, '-arrow') }),
|
||
y.cloneElement(ee, Oe),
|
||
)
|
||
);
|
||
},
|
||
lt = function() {
|
||
var ee = L.overlay;
|
||
return typeof ee == 'function' ? P : P();
|
||
},
|
||
ht = function() {
|
||
var ee = L.minOverlayWidthMatchTrigger,
|
||
Oe = L.alignPoint;
|
||
return 'minOverlayWidthMatchTrigger' in L ? ee : !Oe;
|
||
},
|
||
bt = function() {
|
||
var ee = L.openClassName;
|
||
return ee !== void 0 ? ee : ''.concat(D, '-open');
|
||
},
|
||
Ee = function() {
|
||
var ee = L.children,
|
||
Oe = ee.props ? ee.props : {},
|
||
we = v()(Oe.className, bt());
|
||
return xe && ee ? y.cloneElement(ee, { className: we }) : ee;
|
||
},
|
||
$e = tt;
|
||
return (
|
||
!$e && He.indexOf('contextMenu') !== -1 && ($e = ['click']),
|
||
y.createElement(
|
||
l.a,
|
||
Object.assign({}, Xe, {
|
||
prefixCls: D,
|
||
ref: Je,
|
||
popupClassName: v()(dt, Object(i.a)({}, ''.concat(D, '-show-arrow'), re)),
|
||
popupStyle: nt,
|
||
builtinPlacements: ze,
|
||
action: He,
|
||
showAction: We,
|
||
hideAction: $e || [],
|
||
popupPlacement: je,
|
||
popupAlign: Te,
|
||
popupTransitionName: q,
|
||
popupAnimation: Ie,
|
||
popupVisible: rt,
|
||
stretch: ht() ? 'minWidth' : '',
|
||
popup: lt(),
|
||
onPopupVisibleChange: ft,
|
||
getPopupContainer: et,
|
||
}),
|
||
Ee(),
|
||
)
|
||
);
|
||
}
|
||
var B = y.forwardRef(R),
|
||
Y = (N.a = B);
|
||
},
|
||
fNCr: function(ue, N, o) {
|
||
'use strict';
|
||
Object.defineProperty(N, '__esModule', { value: !0 }), (N.default = void 0);
|
||
var i = j(o('tSko'));
|
||
function j(y) {
|
||
return y && y.__esModule ? y : { default: y };
|
||
}
|
||
var E = i;
|
||
(N.default = E), (ue.exports = E);
|
||
},
|
||
jiSn: function(ue, N, o) {
|
||
'use strict';
|
||
var i = o('TqRt'),
|
||
j = o('284h');
|
||
Object.defineProperty(N, '__esModule', { value: !0 }), (N.default = void 0);
|
||
var E = j(o('q1tI')),
|
||
y = i(o('KBXm')),
|
||
l = i(o('KQxl')),
|
||
I = function(S, g) {
|
||
return E.createElement(l.default, Object.assign({}, S, { ref: g, icon: y.default }));
|
||
};
|
||
I.displayName = 'EllipsisOutlined';
|
||
var v = E.forwardRef(I);
|
||
N.default = v;
|
||
},
|
||
su5N: function(ue, N, o) {
|
||
'use strict';
|
||
var i = o('q1tI'),
|
||
j = {
|
||
icon: {
|
||
tag: 'svg',
|
||
attrs: { viewBox: '64 64 896 896', focusable: 'false' },
|
||
children: [
|
||
{
|
||
tag: 'path',
|
||
attrs: {
|
||
d:
|
||
'M516 673c0 4.4 3.4 8 7.5 8h185c4.1 0 7.5-3.6 7.5-8v-48c0-4.4-3.4-8-7.5-8h-185c-4.1 0-7.5 3.6-7.5 8v48zm-194.9 6.1l192-161c3.8-3.2 3.8-9.1 0-12.3l-192-160.9A7.95 7.95 0 00308 351v62.7c0 2.4 1 4.6 2.9 6.1L420.7 512l-109.8 92.2a8.1 8.1 0 00-2.9 6.1V673c0 6.8 7.9 10.5 13.1 6.1zM880 112H144c-17.7 0-32 14.3-32 32v736c0 17.7 14.3 32 32 32h736c17.7 0 32-14.3 32-32V144c0-17.7-14.3-32-32-32zm-40 728H184V184h656v656z',
|
||
},
|
||
},
|
||
],
|
||
},
|
||
name: 'code',
|
||
theme: 'outlined',
|
||
},
|
||
E = j,
|
||
y = o('6VBw'),
|
||
l = function(z, S) {
|
||
return i.createElement(y.a, Object.assign({}, z, { ref: S, icon: E }));
|
||
};
|
||
l.displayName = 'CodeOutlined';
|
||
var I = (N.a = i.forwardRef(l));
|
||
},
|
||
tSko: function(ue, N, o) {
|
||
'use strict';
|
||
var i = o('TqRt'),
|
||
j = o('284h');
|
||
Object.defineProperty(N, '__esModule', { value: !0 }), (N.default = void 0);
|
||
var E = j(o('q1tI')),
|
||
y = i(o('SRve')),
|
||
l = i(o('KQxl')),
|
||
I = function(S, g) {
|
||
return E.createElement(l.default, Object.assign({}, S, { ref: g, icon: y.default }));
|
||
};
|
||
I.displayName = 'PlusOutlined';
|
||
var v = E.forwardRef(I);
|
||
N.default = v;
|
||
},
|
||
xc4C: function(ue, N, o) {
|
||
'use strict';
|
||
o.d(N, 'b', function() {
|
||
return y;
|
||
}),
|
||
o.d(N, 'a', function() {
|
||
return l;
|
||
});
|
||
var i = o('ODXe'),
|
||
j = o('CJvt'),
|
||
E = o('Qi1f');
|
||
function y(I) {
|
||
var v = Object(E.d)(I),
|
||
z = Object(i.a)(v, 2),
|
||
S = z[0],
|
||
g = z[1];
|
||
return j.a.setTwoToneColors({ primaryColor: S, secondaryColor: g });
|
||
}
|
||
function l() {
|
||
var I = j.a.getTwoToneColors();
|
||
return I.calculated ? [I.primaryColor, I.secondaryColor] : I.primaryColor;
|
||
}
|
||
},
|
||
},
|
||
]);
|
||
|
||
//# sourceMappingURL=vendors~p__home.js.map
|