1778 lines
60 KiB
JavaScript
1778 lines
60 KiB
JavaScript
/*
|
|
* Extracted from browser-delivered Turbopack chunk: 5d5b47876e53e564.da1ba52a93.js
|
|
* Module id: 766403
|
|
* For reading/searching only; this factory depends on the original Turbopack runtime.
|
|
*/
|
|
|
|
const moduleFactory = (e) => {
|
|
"use strict";
|
|
var t = e.i(358379),
|
|
r = e.i(602752);
|
|
e.i(23741);
|
|
var n = e.i(264458),
|
|
o = e.i(422136),
|
|
a = e.i(389524),
|
|
i = e.i(33419),
|
|
l = e.i(259543),
|
|
s = e.i(556957),
|
|
c = e.i(831599),
|
|
u = e.i(859128),
|
|
d = e.i(144281),
|
|
f = e.i(545977),
|
|
m = e.i(786410),
|
|
p = e.i(687306),
|
|
h = e.i(576871);
|
|
e.i(6177);
|
|
var g = e.i(723378),
|
|
b = e.i(817856),
|
|
v = e.i(102904),
|
|
_ = e.i(117394),
|
|
y = e.i(570860),
|
|
x = e.i(601112),
|
|
C = e.i(372566);
|
|
e.i(196312), e.i(383647);
|
|
var E = e.i(791566),
|
|
S = e.i(549195),
|
|
w = e.i(238137),
|
|
k = e.i(511334),
|
|
j = e.i(935492),
|
|
P = e.i(552659),
|
|
R = e.i(624977),
|
|
N = e.i(992734),
|
|
$ = e.i(992008),
|
|
O = e.i(599841),
|
|
T = e.i(161977);
|
|
function M(e) {
|
|
var t = e;
|
|
if (!Array.isArray(t)) {
|
|
var r = (0, R.default)(t);
|
|
t = "number" === r || "string" === r ? [t] : [];
|
|
}
|
|
return t.map(function (e) {
|
|
return String(e);
|
|
});
|
|
}
|
|
let I = Object.assign(
|
|
t.default.forwardRef(function (e, r) {
|
|
var o = e.prefixCls,
|
|
a = void 0 === o ? "rc-collapse" : o,
|
|
i = e.destroyInactivePanel,
|
|
l = e.style,
|
|
s = e.accordion,
|
|
c = e.className,
|
|
u = e.children,
|
|
d = e.collapsible,
|
|
f = e.openMotion,
|
|
m = e.expandIcon,
|
|
p = e.activeKey,
|
|
h = e.defaultActiveKey,
|
|
g = e.onChange,
|
|
b = e.items,
|
|
v = (0, n.default)(a, c),
|
|
_ = (0, S.default)([], {
|
|
value: p,
|
|
onChange: function (e) {
|
|
return null == g ? void 0 : g(e);
|
|
},
|
|
defaultValue: h,
|
|
postState: M,
|
|
}),
|
|
y = (0, P.default)(_, 2),
|
|
x = y[0],
|
|
C = y[1];
|
|
(0, N.default)(
|
|
!u,
|
|
"[rc-collapse] `children` will be removed in next major version. Please use `items` instead.",
|
|
);
|
|
var E = (0, $.default)(b, u, {
|
|
prefixCls: a,
|
|
accordion: s,
|
|
openMotion: f,
|
|
expandIcon: m,
|
|
collapsible: d,
|
|
destroyInactivePanel: void 0 !== i && i,
|
|
onItemClick: function (e) {
|
|
return C(function () {
|
|
return s
|
|
? x[0] === e
|
|
? []
|
|
: [e]
|
|
: x.indexOf(e) > -1
|
|
? x.filter(function (t) {
|
|
return t !== e;
|
|
})
|
|
: [].concat((0, j.default)(x), [e]);
|
|
});
|
|
},
|
|
activeKey: x,
|
|
});
|
|
return t.default.createElement(
|
|
"div",
|
|
(0, k.default)(
|
|
{ ref: r, className: v, style: l, role: s ? "tablist" : void 0 },
|
|
(0, T.default)(e, { aria: !0, data: !0 }),
|
|
),
|
|
E,
|
|
);
|
|
}),
|
|
{ Panel: O.default },
|
|
);
|
|
I.Panel;
|
|
var A = e.i(484274),
|
|
L = e.i(553829),
|
|
B = e.i(126542);
|
|
let D = t.forwardRef((e, r) => {
|
|
let { getPrefixCls: o } = t.useContext(s.ConfigContext),
|
|
{ prefixCls: a, className: i, showArrow: l = !0 } = e,
|
|
c = o("collapse", a),
|
|
u = (0, n.default)({ [`${c}-no-arrow`]: !l }, i);
|
|
return t.createElement(
|
|
I.Panel,
|
|
Object.assign({ ref: r }, e, { prefixCls: c, className: u }),
|
|
);
|
|
}),
|
|
H = (0, _.genStyleHooks)(
|
|
"Collapse",
|
|
(e) => {
|
|
let t = (0, y.mergeToken)(e, {
|
|
collapseHeaderPaddingSM: `${(0, g.unit)(e.paddingXS)} ${(0, g.unit)(e.paddingSM)}`,
|
|
collapseHeaderPaddingLG: `${(0, g.unit)(e.padding)} ${(0, g.unit)(e.paddingLG)}`,
|
|
collapsePanelBorderRadius: e.borderRadiusLG,
|
|
});
|
|
return [
|
|
((e) => {
|
|
let {
|
|
componentCls: t,
|
|
contentBg: r,
|
|
padding: n,
|
|
headerBg: o,
|
|
headerPadding: a,
|
|
collapseHeaderPaddingSM: i,
|
|
collapseHeaderPaddingLG: l,
|
|
collapsePanelBorderRadius: s,
|
|
lineWidth: c,
|
|
lineType: u,
|
|
colorBorder: d,
|
|
colorText: f,
|
|
colorTextHeading: m,
|
|
colorTextDisabled: p,
|
|
fontSizeLG: h,
|
|
lineHeight: v,
|
|
lineHeightLG: _,
|
|
marginSM: y,
|
|
paddingSM: x,
|
|
paddingLG: C,
|
|
paddingXS: E,
|
|
motionDurationSlow: S,
|
|
fontSizeIcon: w,
|
|
contentPadding: k,
|
|
fontHeight: j,
|
|
fontHeightLG: P,
|
|
} = e,
|
|
R = `${(0, g.unit)(c)} ${u} ${d}`;
|
|
return {
|
|
[t]: Object.assign(
|
|
Object.assign({}, (0, b.resetComponent)(e)),
|
|
{
|
|
backgroundColor: o,
|
|
border: R,
|
|
borderRadius: s,
|
|
"&-rtl": { direction: "rtl" },
|
|
[`& > ${t}-item`]: {
|
|
borderBottom: R,
|
|
"&:first-child": {
|
|
[`
|
|
&,
|
|
& > ${t}-header`]: {
|
|
borderRadius: `${(0, g.unit)(s)} ${(0, g.unit)(s)} 0 0`,
|
|
},
|
|
},
|
|
"&:last-child": {
|
|
[`
|
|
&,
|
|
& > ${t}-header`]: {
|
|
borderRadius: `0 0 ${(0, g.unit)(s)} ${(0, g.unit)(s)}`,
|
|
},
|
|
},
|
|
[`> ${t}-header`]: Object.assign(
|
|
Object.assign(
|
|
{
|
|
position: "relative",
|
|
display: "flex",
|
|
flexWrap: "nowrap",
|
|
alignItems: "flex-start",
|
|
padding: a,
|
|
color: m,
|
|
lineHeight: v,
|
|
cursor: "pointer",
|
|
transition: `all ${S}, visibility 0s`,
|
|
},
|
|
(0, b.genFocusStyle)(e),
|
|
),
|
|
{
|
|
[`> ${t}-header-text`]: { flex: "auto" },
|
|
[`${t}-expand-icon`]: {
|
|
height: j,
|
|
display: "flex",
|
|
alignItems: "center",
|
|
paddingInlineEnd: y,
|
|
},
|
|
[`${t}-arrow`]: Object.assign(
|
|
Object.assign({}, (0, b.resetIcon)()),
|
|
{
|
|
fontSize: w,
|
|
transition: `transform ${S}`,
|
|
svg: { transition: `transform ${S}` },
|
|
},
|
|
),
|
|
[`${t}-header-text`]: { marginInlineEnd: "auto" },
|
|
},
|
|
),
|
|
[`${t}-collapsible-header`]: {
|
|
cursor: "default",
|
|
[`${t}-header-text`]: {
|
|
flex: "none",
|
|
cursor: "pointer",
|
|
},
|
|
[`${t}-expand-icon`]: { cursor: "pointer" },
|
|
},
|
|
[`${t}-collapsible-icon`]: {
|
|
cursor: "unset",
|
|
[`${t}-expand-icon`]: { cursor: "pointer" },
|
|
},
|
|
},
|
|
[`${t}-content`]: {
|
|
color: f,
|
|
backgroundColor: r,
|
|
borderTop: R,
|
|
[`& > ${t}-content-box`]: { padding: k },
|
|
"&-hidden": { display: "none" },
|
|
},
|
|
"&-small": {
|
|
[`> ${t}-item`]: {
|
|
[`> ${t}-header`]: {
|
|
padding: i,
|
|
paddingInlineStart: E,
|
|
[`> ${t}-expand-icon`]: {
|
|
marginInlineStart: e.calc(x).sub(E).equal(),
|
|
},
|
|
},
|
|
[`> ${t}-content > ${t}-content-box`]: { padding: x },
|
|
},
|
|
},
|
|
"&-large": {
|
|
[`> ${t}-item`]: {
|
|
fontSize: h,
|
|
lineHeight: _,
|
|
[`> ${t}-header`]: {
|
|
padding: l,
|
|
paddingInlineStart: n,
|
|
[`> ${t}-expand-icon`]: {
|
|
height: P,
|
|
marginInlineStart: e.calc(C).sub(n).equal(),
|
|
},
|
|
},
|
|
[`> ${t}-content > ${t}-content-box`]: { padding: C },
|
|
},
|
|
},
|
|
[`${t}-item:last-child`]: {
|
|
borderBottom: 0,
|
|
[`> ${t}-content`]: {
|
|
borderRadius: `0 0 ${(0, g.unit)(s)} ${(0, g.unit)(s)}`,
|
|
},
|
|
},
|
|
[`& ${t}-item-disabled > ${t}-header`]: {
|
|
[`
|
|
&,
|
|
& > .arrow
|
|
`]: { color: p, cursor: "not-allowed" },
|
|
},
|
|
[`&${t}-icon-position-end`]: {
|
|
[`& > ${t}-item`]: {
|
|
[`> ${t}-header`]: {
|
|
[`${t}-expand-icon`]: {
|
|
order: 1,
|
|
paddingInlineEnd: 0,
|
|
paddingInlineStart: y,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
),
|
|
};
|
|
})(t),
|
|
((e) => {
|
|
let {
|
|
componentCls: t,
|
|
headerBg: r,
|
|
borderlessContentPadding: n,
|
|
borderlessContentBg: o,
|
|
colorBorder: a,
|
|
} = e;
|
|
return {
|
|
[`${t}-borderless`]: {
|
|
backgroundColor: r,
|
|
border: 0,
|
|
[`> ${t}-item`]: { borderBottom: `1px solid ${a}` },
|
|
[`
|
|
> ${t}-item:last-child,
|
|
> ${t}-item:last-child ${t}-header
|
|
`]: { borderRadius: 0 },
|
|
[`> ${t}-item:last-child`]: { borderBottom: 0 },
|
|
[`> ${t}-item > ${t}-content`]: {
|
|
backgroundColor: o,
|
|
borderTop: 0,
|
|
},
|
|
[`> ${t}-item > ${t}-content > ${t}-content-box`]: {
|
|
padding: n,
|
|
},
|
|
},
|
|
};
|
|
})(t),
|
|
((e) => {
|
|
let { componentCls: t, paddingSM: r } = e;
|
|
return {
|
|
[`${t}-ghost`]: {
|
|
backgroundColor: "transparent",
|
|
border: 0,
|
|
[`> ${t}-item`]: {
|
|
borderBottom: 0,
|
|
[`> ${t}-content`]: {
|
|
backgroundColor: "transparent",
|
|
border: 0,
|
|
[`> ${t}-content-box`]: { paddingBlock: r },
|
|
},
|
|
},
|
|
},
|
|
};
|
|
})(t),
|
|
((e) => {
|
|
let { componentCls: t } = e,
|
|
r = `> ${t}-item > ${t}-header ${t}-arrow`;
|
|
return { [`${t}-rtl`]: { [r]: { transform: "rotate(180deg)" } } };
|
|
})(t),
|
|
{
|
|
[t.componentCls]: {
|
|
[`${t.antCls}-motion-collapse-legacy`]: {
|
|
overflow: "hidden",
|
|
"&-active": {
|
|
transition: `height ${t.motionDurationMid} ${t.motionEaseInOut},
|
|
opacity ${t.motionDurationMid} ${t.motionEaseInOut} !important`,
|
|
},
|
|
},
|
|
[`${t.antCls}-motion-collapse`]: {
|
|
overflow: "hidden",
|
|
transition: `height ${t.motionDurationMid} ${t.motionEaseInOut},
|
|
opacity ${t.motionDurationMid} ${t.motionEaseInOut} !important`,
|
|
},
|
|
},
|
|
},
|
|
];
|
|
},
|
|
(e) => ({
|
|
headerPadding: `${e.paddingSM}px ${e.padding}px`,
|
|
headerBg: e.colorFillAlter,
|
|
contentPadding: `${e.padding}px 16px`,
|
|
contentBg: e.colorBgContainer,
|
|
borderlessContentPadding: `${e.paddingXXS}px 16px ${e.padding}px`,
|
|
borderlessContentBg: "transparent",
|
|
}),
|
|
);
|
|
Object.assign(
|
|
t.forwardRef((e, r) => {
|
|
let {
|
|
getPrefixCls: a,
|
|
direction: i,
|
|
expandIcon: l,
|
|
className: c,
|
|
style: d,
|
|
} = (0, s.useComponentConfig)("collapse"),
|
|
{
|
|
prefixCls: f,
|
|
className: m,
|
|
rootClassName: p,
|
|
style: h,
|
|
bordered: g = !0,
|
|
ghost: b,
|
|
size: v,
|
|
expandIconPosition: _ = "start",
|
|
children: y,
|
|
destroyInactivePanel: x,
|
|
destroyOnHidden: C,
|
|
expandIcon: E,
|
|
} = e,
|
|
S = (0, u.default)((e) => {
|
|
var t;
|
|
return null != (t = null != v ? v : e) ? t : "middle";
|
|
}),
|
|
k = a("collapse", f),
|
|
j = a(),
|
|
[P, R, N] = H(k),
|
|
$ = t.useMemo(
|
|
() => ("left" === _ ? "start" : "right" === _ ? "end" : _),
|
|
[_],
|
|
),
|
|
O = null != E ? E : l,
|
|
T = t.useCallback(
|
|
(e = {}) => {
|
|
let r =
|
|
"function" == typeof O
|
|
? O(e)
|
|
: t.createElement(w.default, {
|
|
rotate: e.isActive ? ("rtl" === i ? -90 : 90) : void 0,
|
|
"aria-label": e.isActive ? "expanded" : "collapsed",
|
|
});
|
|
return (0, B.cloneElement)(r, () => {
|
|
var e;
|
|
return {
|
|
className: (0, n.default)(
|
|
null == (e = r.props) ? void 0 : e.className,
|
|
`${k}-arrow`,
|
|
),
|
|
};
|
|
});
|
|
},
|
|
[O, k, i],
|
|
),
|
|
M = (0, n.default)(
|
|
`${k}-icon-position-${$}`,
|
|
{
|
|
[`${k}-borderless`]: !g,
|
|
[`${k}-rtl`]: "rtl" === i,
|
|
[`${k}-ghost`]: !!b,
|
|
[`${k}-${S}`]: "middle" !== S,
|
|
},
|
|
c,
|
|
m,
|
|
p,
|
|
R,
|
|
N,
|
|
),
|
|
D = t.useMemo(
|
|
() =>
|
|
Object.assign(Object.assign({}, (0, L.default)(j)), {
|
|
motionAppear: !1,
|
|
leavedClassName: `${k}-content-hidden`,
|
|
}),
|
|
[j, k],
|
|
),
|
|
z = t.useMemo(
|
|
() =>
|
|
y
|
|
? (0, A.default)(y).map((e, t) => {
|
|
var r, n;
|
|
let a = e.props;
|
|
if (null == a ? void 0 : a.disabled) {
|
|
let i = null != (r = e.key) ? r : String(t),
|
|
l = Object.assign(
|
|
Object.assign(
|
|
{},
|
|
(0, o.default)(e.props, ["disabled"]),
|
|
),
|
|
{
|
|
key: i,
|
|
collapsible:
|
|
null != (n = a.collapsible) ? n : "disabled",
|
|
},
|
|
);
|
|
return (0, B.cloneElement)(e, l);
|
|
}
|
|
return e;
|
|
})
|
|
: null,
|
|
[y],
|
|
);
|
|
return P(
|
|
t.createElement(
|
|
I,
|
|
Object.assign(
|
|
{ ref: r, openMotion: D },
|
|
(0, o.default)(e, ["rootClassName"]),
|
|
{
|
|
expandIcon: T,
|
|
prefixCls: k,
|
|
className: M,
|
|
style: Object.assign(Object.assign({}, d), h),
|
|
destroyInactivePanel: null != C ? C : x,
|
|
},
|
|
),
|
|
z,
|
|
),
|
|
);
|
|
}),
|
|
{ Panel: D },
|
|
),
|
|
e.i(461993),
|
|
e.i(840127),
|
|
e.i(490116);
|
|
var z = e.i(80620),
|
|
W = e.i(637521);
|
|
let F = (e) => {
|
|
let { paddingInline: t, onlyIconSize: r } = e;
|
|
return (0, y.mergeToken)(e, {
|
|
buttonPaddingHorizontal: t,
|
|
buttonPaddingVertical: 0,
|
|
buttonIconOnlyFontSize: r,
|
|
});
|
|
},
|
|
U = (e) => {
|
|
var t, r, n, o, a, i;
|
|
let l = null != (t = e.contentFontSize) ? t : e.fontSize,
|
|
s = null != (r = e.contentFontSizeSM) ? r : e.fontSize,
|
|
c = null != (n = e.contentFontSizeLG) ? n : e.fontSizeLG,
|
|
u = null != (o = e.contentLineHeight) ? o : (0, z.getLineHeight)(l),
|
|
d = null != (a = e.contentLineHeightSM) ? a : (0, z.getLineHeight)(s),
|
|
f = null != (i = e.contentLineHeightLG) ? i : (0, z.getLineHeight)(c),
|
|
m = ((e, t) => {
|
|
let { r, g: n, b: o, a } = e.toRgb(),
|
|
i = new E.Color(e.toRgbString()).onBackground(t).toHsv();
|
|
return a <= 0.5
|
|
? i.v > 0.5
|
|
: 0.299 * r + 0.587 * n + 0.114 * o > 192;
|
|
})(new C.AggregationColor(e.colorBgSolid), "#fff")
|
|
? "#000"
|
|
: "#fff";
|
|
return Object.assign(
|
|
Object.assign(
|
|
{},
|
|
v.PresetColors.reduce(
|
|
(t, r) =>
|
|
Object.assign(Object.assign({}, t), {
|
|
[`${r}ShadowColor`]: `0 ${(0, g.unit)(e.controlOutlineWidth)} 0 ${(0, W.default)(e[`${r}1`], e.colorBgContainer)}`,
|
|
}),
|
|
{},
|
|
),
|
|
),
|
|
{
|
|
fontWeight: 400,
|
|
iconGap: e.marginXS,
|
|
defaultShadow: `0 ${e.controlOutlineWidth}px 0 ${e.controlTmpOutline}`,
|
|
primaryShadow: `0 ${e.controlOutlineWidth}px 0 ${e.controlOutline}`,
|
|
dangerShadow: `0 ${e.controlOutlineWidth}px 0 ${e.colorErrorOutline}`,
|
|
primaryColor: e.colorTextLightSolid,
|
|
dangerColor: e.colorTextLightSolid,
|
|
borderColorDisabled: e.colorBorder,
|
|
defaultGhostColor: e.colorBgContainer,
|
|
ghostBg: "transparent",
|
|
defaultGhostBorderColor: e.colorBgContainer,
|
|
paddingInline: e.paddingContentHorizontal - e.lineWidth,
|
|
paddingInlineLG: e.paddingContentHorizontal - e.lineWidth,
|
|
paddingInlineSM: 8 - e.lineWidth,
|
|
onlyIconSize: "inherit",
|
|
onlyIconSizeSM: "inherit",
|
|
onlyIconSizeLG: "inherit",
|
|
groupBorderColor: e.colorPrimaryHover,
|
|
linkHoverBg: "transparent",
|
|
textTextColor: e.colorText,
|
|
textTextHoverColor: e.colorText,
|
|
textTextActiveColor: e.colorText,
|
|
textHoverBg: e.colorFillTertiary,
|
|
defaultColor: e.colorText,
|
|
defaultBg: e.colorBgContainer,
|
|
defaultBorderColor: e.colorBorder,
|
|
defaultBorderColorDisabled: e.colorBorder,
|
|
defaultHoverBg: e.colorBgContainer,
|
|
defaultHoverColor: e.colorPrimaryHover,
|
|
defaultHoverBorderColor: e.colorPrimaryHover,
|
|
defaultActiveBg: e.colorBgContainer,
|
|
defaultActiveColor: e.colorPrimaryActive,
|
|
defaultActiveBorderColor: e.colorPrimaryActive,
|
|
solidTextColor: m,
|
|
contentFontSize: l,
|
|
contentFontSizeSM: s,
|
|
contentFontSizeLG: c,
|
|
contentLineHeight: u,
|
|
contentLineHeightSM: d,
|
|
contentLineHeightLG: f,
|
|
paddingBlock: Math.max(
|
|
(e.controlHeight - l * u) / 2 - e.lineWidth,
|
|
0,
|
|
),
|
|
paddingBlockSM: Math.max(
|
|
(e.controlHeightSM - s * d) / 2 - e.lineWidth,
|
|
0,
|
|
),
|
|
paddingBlockLG: Math.max(
|
|
(e.controlHeightLG - c * f) / 2 - e.lineWidth,
|
|
0,
|
|
),
|
|
},
|
|
);
|
|
},
|
|
G = (e, t, r) => ({
|
|
[`&:not(:disabled):not(${e}-disabled)`]: {
|
|
"&:hover": t,
|
|
"&:active": r,
|
|
},
|
|
}),
|
|
q = (e, t, r, n, o, a, i, l) => ({
|
|
[`&${e}-background-ghost`]: Object.assign(
|
|
Object.assign(
|
|
{
|
|
color: r || void 0,
|
|
background: t,
|
|
borderColor: n || void 0,
|
|
boxShadow: "none",
|
|
},
|
|
G(
|
|
e,
|
|
Object.assign({ background: t }, i),
|
|
Object.assign({ background: t }, l),
|
|
),
|
|
),
|
|
{
|
|
"&:disabled": {
|
|
cursor: "not-allowed",
|
|
color: o || void 0,
|
|
borderColor: a || void 0,
|
|
},
|
|
},
|
|
),
|
|
}),
|
|
X = (e, t, r, n) =>
|
|
Object.assign(
|
|
Object.assign(
|
|
{},
|
|
(n && ["link", "text"].includes(n)
|
|
? (e) => ({
|
|
[`&:disabled, &${e.componentCls}-disabled`]: {
|
|
cursor: "not-allowed",
|
|
color: e.colorTextDisabled,
|
|
},
|
|
})
|
|
: (e) => ({
|
|
[`&:disabled, &${e.componentCls}-disabled`]: Object.assign(
|
|
{},
|
|
{
|
|
cursor: "not-allowed",
|
|
borderColor: e.borderColorDisabled,
|
|
color: e.colorTextDisabled,
|
|
background: e.colorBgContainerDisabled,
|
|
boxShadow: "none",
|
|
},
|
|
),
|
|
}))(e),
|
|
),
|
|
G(e.componentCls, t, r),
|
|
),
|
|
K = (e, t, r, n, o) => ({
|
|
[`&${e.componentCls}-variant-solid`]: Object.assign(
|
|
{ color: t, background: r },
|
|
X(e, n, o),
|
|
),
|
|
}),
|
|
V = (e, t, r, n, o) => ({
|
|
[`&${e.componentCls}-variant-outlined, &${e.componentCls}-variant-dashed`]:
|
|
Object.assign({ borderColor: t, background: r }, X(e, n, o)),
|
|
}),
|
|
Y = (e) => ({
|
|
[`&${e.componentCls}-variant-dashed`]: { borderStyle: "dashed" },
|
|
}),
|
|
Q = (e, t, r, n) => ({
|
|
[`&${e.componentCls}-variant-filled`]: Object.assign(
|
|
{ boxShadow: "none", background: t },
|
|
X(e, r, n),
|
|
),
|
|
}),
|
|
Z = (e, t, r, n, o) => ({
|
|
[`&${e.componentCls}-variant-${r}`]: Object.assign(
|
|
{ color: t, boxShadow: "none" },
|
|
X(e, n, o, r),
|
|
),
|
|
}),
|
|
J = (e, t = "") => {
|
|
let {
|
|
componentCls: r,
|
|
controlHeight: n,
|
|
fontSize: o,
|
|
borderRadius: a,
|
|
buttonPaddingHorizontal: i,
|
|
iconCls: l,
|
|
buttonPaddingVertical: s,
|
|
buttonIconOnlyFontSize: c,
|
|
} = e;
|
|
return [
|
|
{
|
|
[t]: {
|
|
fontSize: o,
|
|
height: n,
|
|
padding: `${(0, g.unit)(s)} ${(0, g.unit)(i)}`,
|
|
borderRadius: a,
|
|
[`&${r}-icon-only`]: { width: n, [l]: { fontSize: c } },
|
|
},
|
|
},
|
|
{
|
|
[`${r}${r}-circle${t}`]: {
|
|
minWidth: e.controlHeight,
|
|
paddingInline: 0,
|
|
borderRadius: "50%",
|
|
},
|
|
},
|
|
{
|
|
[`${r}${r}-round${t}`]: {
|
|
borderRadius: e.controlHeight,
|
|
[`&:not(${r}-icon-only)`]: {
|
|
paddingInline: e.buttonPaddingHorizontal,
|
|
},
|
|
},
|
|
},
|
|
];
|
|
},
|
|
ee = (0, _.genStyleHooks)(
|
|
"Button",
|
|
(e) => {
|
|
let t = F(e);
|
|
return [
|
|
((e) => {
|
|
let {
|
|
componentCls: t,
|
|
iconCls: r,
|
|
fontWeight: n,
|
|
opacityLoading: o,
|
|
motionDurationSlow: a,
|
|
motionEaseInOut: i,
|
|
iconGap: l,
|
|
calc: s,
|
|
} = e;
|
|
return {
|
|
[t]: {
|
|
outline: "none",
|
|
position: "relative",
|
|
display: "inline-flex",
|
|
gap: l,
|
|
alignItems: "center",
|
|
justifyContent: "center",
|
|
fontWeight: n,
|
|
whiteSpace: "nowrap",
|
|
textAlign: "center",
|
|
backgroundImage: "none",
|
|
background: "transparent",
|
|
border: `${(0, g.unit)(e.lineWidth)} ${e.lineType} transparent`,
|
|
cursor: "pointer",
|
|
transition: `all ${e.motionDurationMid} ${e.motionEaseInOut}`,
|
|
userSelect: "none",
|
|
touchAction: "manipulation",
|
|
color: e.colorText,
|
|
"&:disabled > *": { pointerEvents: "none" },
|
|
[`${t}-icon > svg`]: (0, b.resetIcon)(),
|
|
"> a": { color: "currentColor" },
|
|
"&:not(:disabled)": (0, b.genFocusStyle)(e),
|
|
[`&${t}-two-chinese-chars::first-letter`]: {
|
|
letterSpacing: "0.34em",
|
|
},
|
|
[`&${t}-two-chinese-chars > *:not(${r})`]: {
|
|
marginInlineEnd: "-0.34em",
|
|
letterSpacing: "0.34em",
|
|
},
|
|
[`&${t}-icon-only`]: {
|
|
paddingInline: 0,
|
|
[`&${t}-compact-item`]: { flex: "none" },
|
|
},
|
|
[`&${t}-loading`]: { opacity: o, cursor: "default" },
|
|
[`${t}-loading-icon`]: {
|
|
transition: ["width", "opacity", "margin"]
|
|
.map((e) => `${e} ${a} ${i}`)
|
|
.join(","),
|
|
},
|
|
[`&:not(${t}-icon-end)`]: {
|
|
[`${t}-loading-icon-motion`]: {
|
|
"&-appear-start, &-enter-start": {
|
|
marginInlineEnd: s(l).mul(-1).equal(),
|
|
},
|
|
"&-appear-active, &-enter-active": { marginInlineEnd: 0 },
|
|
"&-leave-start": { marginInlineEnd: 0 },
|
|
"&-leave-active": {
|
|
marginInlineEnd: s(l).mul(-1).equal(),
|
|
},
|
|
},
|
|
},
|
|
"&-icon-end": {
|
|
flexDirection: "row-reverse",
|
|
[`${t}-loading-icon-motion`]: {
|
|
"&-appear-start, &-enter-start": {
|
|
marginInlineStart: s(l).mul(-1).equal(),
|
|
},
|
|
"&-appear-active, &-enter-active": {
|
|
marginInlineStart: 0,
|
|
},
|
|
"&-leave-start": { marginInlineStart: 0 },
|
|
"&-leave-active": {
|
|
marginInlineStart: s(l).mul(-1).equal(),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
};
|
|
})(t),
|
|
J(
|
|
(0, y.mergeToken)(t, { fontSize: t.contentFontSize }),
|
|
t.componentCls,
|
|
),
|
|
J(
|
|
(0, y.mergeToken)(t, {
|
|
controlHeight: t.controlHeightSM,
|
|
fontSize: t.contentFontSizeSM,
|
|
padding: t.paddingXS,
|
|
buttonPaddingHorizontal: t.paddingInlineSM,
|
|
buttonPaddingVertical: 0,
|
|
borderRadius: t.borderRadiusSM,
|
|
buttonIconOnlyFontSize: t.onlyIconSizeSM,
|
|
}),
|
|
`${t.componentCls}-sm`,
|
|
),
|
|
J(
|
|
(0, y.mergeToken)(t, {
|
|
controlHeight: t.controlHeightLG,
|
|
fontSize: t.contentFontSizeLG,
|
|
buttonPaddingHorizontal: t.paddingInlineLG,
|
|
buttonPaddingVertical: 0,
|
|
borderRadius: t.borderRadiusLG,
|
|
buttonIconOnlyFontSize: t.onlyIconSizeLG,
|
|
}),
|
|
`${t.componentCls}-lg`,
|
|
),
|
|
((e) => {
|
|
let { componentCls: t } = e;
|
|
return { [t]: { [`&${t}-block`]: { width: "100%" } } };
|
|
})(t),
|
|
((e) => {
|
|
let { componentCls: t } = e;
|
|
return Object.assign(
|
|
{
|
|
[`${t}-color-default`]: Object.assign(
|
|
Object.assign(
|
|
Object.assign(
|
|
Object.assign(
|
|
Object.assign(
|
|
{
|
|
color: e.defaultColor,
|
|
boxShadow: e.defaultShadow,
|
|
},
|
|
K(
|
|
e,
|
|
e.solidTextColor,
|
|
e.colorBgSolid,
|
|
{
|
|
color: e.solidTextColor,
|
|
background: e.colorBgSolidHover,
|
|
},
|
|
{
|
|
color: e.solidTextColor,
|
|
background: e.colorBgSolidActive,
|
|
},
|
|
),
|
|
),
|
|
Y(e),
|
|
),
|
|
Q(
|
|
e,
|
|
e.colorFillTertiary,
|
|
{
|
|
color: e.defaultColor,
|
|
background: e.colorFillSecondary,
|
|
},
|
|
{ color: e.defaultColor, background: e.colorFill },
|
|
),
|
|
),
|
|
q(
|
|
e.componentCls,
|
|
e.ghostBg,
|
|
e.defaultGhostColor,
|
|
e.defaultGhostBorderColor,
|
|
e.colorTextDisabled,
|
|
e.colorBorder,
|
|
),
|
|
),
|
|
Z(
|
|
e,
|
|
e.textTextColor,
|
|
"link",
|
|
{ color: e.colorLinkHover, background: e.linkHoverBg },
|
|
{ color: e.colorLinkActive },
|
|
),
|
|
),
|
|
[`${t}-color-primary`]: Object.assign(
|
|
Object.assign(
|
|
Object.assign(
|
|
Object.assign(
|
|
Object.assign(
|
|
Object.assign(
|
|
{
|
|
color: e.colorPrimary,
|
|
boxShadow: e.primaryShadow,
|
|
},
|
|
V(
|
|
e,
|
|
e.colorPrimary,
|
|
e.colorBgContainer,
|
|
{
|
|
color: e.colorPrimaryTextHover,
|
|
borderColor: e.colorPrimaryHover,
|
|
background: e.colorBgContainer,
|
|
},
|
|
{
|
|
color: e.colorPrimaryTextActive,
|
|
borderColor: e.colorPrimaryActive,
|
|
background: e.colorBgContainer,
|
|
},
|
|
),
|
|
),
|
|
Y(e),
|
|
),
|
|
Q(
|
|
e,
|
|
e.colorPrimaryBg,
|
|
{
|
|
color: e.colorPrimary,
|
|
background: e.colorPrimaryBgHover,
|
|
},
|
|
{
|
|
color: e.colorPrimary,
|
|
background: e.colorPrimaryBorder,
|
|
},
|
|
),
|
|
),
|
|
Z(
|
|
e,
|
|
e.colorPrimaryText,
|
|
"text",
|
|
{
|
|
color: e.colorPrimaryTextHover,
|
|
background: e.colorPrimaryBg,
|
|
},
|
|
{
|
|
color: e.colorPrimaryTextActive,
|
|
background: e.colorPrimaryBorder,
|
|
},
|
|
),
|
|
),
|
|
Z(
|
|
e,
|
|
e.colorPrimaryText,
|
|
"link",
|
|
{
|
|
color: e.colorPrimaryTextHover,
|
|
background: e.linkHoverBg,
|
|
},
|
|
{ color: e.colorPrimaryTextActive },
|
|
),
|
|
),
|
|
q(
|
|
e.componentCls,
|
|
e.ghostBg,
|
|
e.colorPrimary,
|
|
e.colorPrimary,
|
|
e.colorTextDisabled,
|
|
e.colorBorder,
|
|
{
|
|
color: e.colorPrimaryHover,
|
|
borderColor: e.colorPrimaryHover,
|
|
},
|
|
{
|
|
color: e.colorPrimaryActive,
|
|
borderColor: e.colorPrimaryActive,
|
|
},
|
|
),
|
|
),
|
|
[`${t}-color-dangerous`]: Object.assign(
|
|
Object.assign(
|
|
Object.assign(
|
|
Object.assign(
|
|
Object.assign(
|
|
Object.assign(
|
|
Object.assign(
|
|
{
|
|
color: e.colorError,
|
|
boxShadow: e.dangerShadow,
|
|
},
|
|
K(
|
|
e,
|
|
e.dangerColor,
|
|
e.colorError,
|
|
{ background: e.colorErrorHover },
|
|
{ background: e.colorErrorActive },
|
|
),
|
|
),
|
|
V(
|
|
e,
|
|
e.colorError,
|
|
e.colorBgContainer,
|
|
{
|
|
color: e.colorErrorHover,
|
|
borderColor: e.colorErrorBorderHover,
|
|
},
|
|
{
|
|
color: e.colorErrorActive,
|
|
borderColor: e.colorErrorActive,
|
|
},
|
|
),
|
|
),
|
|
Y(e),
|
|
),
|
|
Q(
|
|
e,
|
|
e.colorErrorBg,
|
|
{
|
|
color: e.colorError,
|
|
background: e.colorErrorBgFilledHover,
|
|
},
|
|
{
|
|
color: e.colorError,
|
|
background: e.colorErrorBgActive,
|
|
},
|
|
),
|
|
),
|
|
Z(
|
|
e,
|
|
e.colorError,
|
|
"text",
|
|
{
|
|
color: e.colorErrorHover,
|
|
background: e.colorErrorBg,
|
|
},
|
|
{
|
|
color: e.colorErrorHover,
|
|
background: e.colorErrorBgActive,
|
|
},
|
|
),
|
|
),
|
|
Z(
|
|
e,
|
|
e.colorError,
|
|
"link",
|
|
{ color: e.colorErrorHover },
|
|
{ color: e.colorErrorActive },
|
|
),
|
|
),
|
|
q(
|
|
e.componentCls,
|
|
e.ghostBg,
|
|
e.colorError,
|
|
e.colorError,
|
|
e.colorTextDisabled,
|
|
e.colorBorder,
|
|
{
|
|
color: e.colorErrorHover,
|
|
borderColor: e.colorErrorHover,
|
|
},
|
|
{
|
|
color: e.colorErrorActive,
|
|
borderColor: e.colorErrorActive,
|
|
},
|
|
),
|
|
),
|
|
[`${t}-color-link`]: Object.assign(
|
|
Object.assign(
|
|
{},
|
|
Z(
|
|
e,
|
|
e.colorLink,
|
|
"link",
|
|
{ color: e.colorLinkHover },
|
|
{ color: e.colorLinkActive },
|
|
),
|
|
),
|
|
q(
|
|
e.componentCls,
|
|
e.ghostBg,
|
|
e.colorInfo,
|
|
e.colorInfo,
|
|
e.colorTextDisabled,
|
|
e.colorBorder,
|
|
{
|
|
color: e.colorInfoHover,
|
|
borderColor: e.colorInfoHover,
|
|
},
|
|
{
|
|
color: e.colorInfoActive,
|
|
borderColor: e.colorInfoActive,
|
|
},
|
|
),
|
|
),
|
|
},
|
|
((e) => {
|
|
let { componentCls: t } = e;
|
|
return v.PresetColors.reduce((r, n) => {
|
|
let o = e[`${n}6`],
|
|
a = e[`${n}1`],
|
|
i = e[`${n}5`],
|
|
l = e[`${n}2`],
|
|
s = e[`${n}3`],
|
|
c = e[`${n}7`];
|
|
return Object.assign(Object.assign({}, r), {
|
|
[`&${t}-color-${n}`]: Object.assign(
|
|
Object.assign(
|
|
Object.assign(
|
|
Object.assign(
|
|
Object.assign(
|
|
Object.assign(
|
|
{ color: o, boxShadow: e[`${n}ShadowColor`] },
|
|
K(
|
|
e,
|
|
e.colorTextLightSolid,
|
|
o,
|
|
{ background: i },
|
|
{ background: c },
|
|
),
|
|
),
|
|
V(
|
|
e,
|
|
o,
|
|
e.colorBgContainer,
|
|
{
|
|
color: i,
|
|
borderColor: i,
|
|
background: e.colorBgContainer,
|
|
},
|
|
{
|
|
color: c,
|
|
borderColor: c,
|
|
background: e.colorBgContainer,
|
|
},
|
|
),
|
|
),
|
|
Y(e),
|
|
),
|
|
Q(
|
|
e,
|
|
a,
|
|
{ color: o, background: l },
|
|
{ color: o, background: s },
|
|
),
|
|
),
|
|
Z(e, o, "link", { color: i }, { color: c }),
|
|
),
|
|
Z(
|
|
e,
|
|
o,
|
|
"text",
|
|
{ color: i, background: a },
|
|
{ color: c, background: s },
|
|
),
|
|
),
|
|
});
|
|
}, {});
|
|
})(e),
|
|
);
|
|
})(t),
|
|
Object.assign(
|
|
Object.assign(
|
|
Object.assign(
|
|
Object.assign(
|
|
{},
|
|
V(
|
|
t,
|
|
t.defaultBorderColor,
|
|
t.defaultBg,
|
|
{
|
|
color: t.defaultHoverColor,
|
|
borderColor: t.defaultHoverBorderColor,
|
|
background: t.defaultHoverBg,
|
|
},
|
|
{
|
|
color: t.defaultActiveColor,
|
|
borderColor: t.defaultActiveBorderColor,
|
|
background: t.defaultActiveBg,
|
|
},
|
|
),
|
|
),
|
|
Z(
|
|
t,
|
|
t.textTextColor,
|
|
"text",
|
|
{ color: t.textTextHoverColor, background: t.textHoverBg },
|
|
{
|
|
color: t.textTextActiveColor,
|
|
background: t.colorBgTextActive,
|
|
},
|
|
),
|
|
),
|
|
K(
|
|
t,
|
|
t.primaryColor,
|
|
t.colorPrimary,
|
|
{ background: t.colorPrimaryHover, color: t.primaryColor },
|
|
{ background: t.colorPrimaryActive, color: t.primaryColor },
|
|
),
|
|
),
|
|
Z(
|
|
t,
|
|
t.colorLink,
|
|
"link",
|
|
{ color: t.colorLinkHover, background: t.linkHoverBg },
|
|
{ color: t.colorLinkActive },
|
|
),
|
|
),
|
|
(0, x.default)(t),
|
|
];
|
|
},
|
|
U,
|
|
{
|
|
unitless: {
|
|
fontWeight: !0,
|
|
contentLineHeight: !0,
|
|
contentLineHeightSM: !0,
|
|
contentLineHeightLG: !0,
|
|
},
|
|
},
|
|
);
|
|
function et(e, t = { focus: !0 }) {
|
|
let { componentCls: r } = e,
|
|
n = `${r}-compact`;
|
|
return {
|
|
[n]: Object.assign(
|
|
Object.assign(
|
|
{},
|
|
(function (e, t, r, n) {
|
|
let { focusElCls: o, focus: a, borderElCls: i } = r,
|
|
l = i ? "> *" : "",
|
|
s = ["hover", a ? "focus" : null, "active"]
|
|
.filter(Boolean)
|
|
.map((e) => `&:${e} ${l}`)
|
|
.join(",");
|
|
return {
|
|
[`&-item:not(${t}-last-item)`]: {
|
|
marginInlineEnd: e.calc(e.lineWidth).mul(-1).equal(),
|
|
},
|
|
[`&-item:not(${n}-status-success)`]: { zIndex: 2 },
|
|
"&-item": Object.assign(
|
|
Object.assign(
|
|
{ [s]: { zIndex: 3 } },
|
|
o ? { [`&${o}`]: { zIndex: 3 } } : {},
|
|
),
|
|
{ [`&[disabled] ${l}`]: { zIndex: 0 } },
|
|
),
|
|
};
|
|
})(e, n, t, r),
|
|
),
|
|
(function (e, t, r) {
|
|
let { borderElCls: n } = r,
|
|
o = n ? `> ${n}` : "";
|
|
return {
|
|
[`&-item:not(${t}-first-item):not(${t}-last-item) ${o}`]: {
|
|
borderRadius: 0,
|
|
},
|
|
[`&-item:not(${t}-last-item)${t}-first-item`]: {
|
|
[`& ${o}, &${e}-sm ${o}, &${e}-lg ${o}`]: {
|
|
borderStartEndRadius: 0,
|
|
borderEndEndRadius: 0,
|
|
},
|
|
},
|
|
[`&-item:not(${t}-first-item)${t}-last-item`]: {
|
|
[`& ${o}, &${e}-sm ${o}, &${e}-lg ${o}`]: {
|
|
borderStartStartRadius: 0,
|
|
borderEndStartRadius: 0,
|
|
},
|
|
},
|
|
};
|
|
})(r, n, t),
|
|
),
|
|
};
|
|
}
|
|
e.s(["genCompactItemStyle", () => et], 675695);
|
|
let er = (0, _.genSubStyleComponent)(
|
|
["Button", "compact"],
|
|
(e) => {
|
|
var t, r;
|
|
let n,
|
|
o = F(e);
|
|
return [
|
|
et(o),
|
|
{
|
|
[(n = `${o.componentCls}-compact-vertical`)]: Object.assign(
|
|
Object.assign(
|
|
{},
|
|
((t = o.componentCls),
|
|
{
|
|
[`&-item:not(${n}-last-item)`]: {
|
|
marginBottom: o.calc(o.lineWidth).mul(-1).equal(),
|
|
},
|
|
[`&-item:not(${t}-status-success)`]: { zIndex: 2 },
|
|
"&-item": {
|
|
"&:hover,&:focus,&:active": { zIndex: 3 },
|
|
"&[disabled]": { zIndex: 0 },
|
|
},
|
|
}),
|
|
),
|
|
((r = o.componentCls),
|
|
{
|
|
[`&-item:not(${n}-first-item):not(${n}-last-item)`]: {
|
|
borderRadius: 0,
|
|
},
|
|
[`&-item${n}-first-item:not(${n}-last-item)`]: {
|
|
[`&, &${r}-sm, &${r}-lg`]: {
|
|
borderEndEndRadius: 0,
|
|
borderEndStartRadius: 0,
|
|
},
|
|
},
|
|
[`&-item${n}-last-item:not(${n}-first-item)`]: {
|
|
[`&, &${r}-sm, &${r}-lg`]: {
|
|
borderStartStartRadius: 0,
|
|
borderStartEndRadius: 0,
|
|
},
|
|
},
|
|
}),
|
|
),
|
|
},
|
|
((e) => {
|
|
let {
|
|
componentCls: t,
|
|
colorPrimaryHover: r,
|
|
lineWidth: n,
|
|
calc: o,
|
|
} = e,
|
|
a = o(n).mul(-1).equal(),
|
|
i = (e) => {
|
|
let o = `${t}-compact${e ? "-vertical" : ""}-item${t}-primary:not([disabled])`;
|
|
return {
|
|
[`${o} + ${o}::before`]: {
|
|
position: "absolute",
|
|
top: e ? a : 0,
|
|
insetInlineStart: e ? 0 : a,
|
|
backgroundColor: r,
|
|
content: '""',
|
|
width: e ? "100%" : n,
|
|
height: e ? n : "100%",
|
|
},
|
|
};
|
|
};
|
|
return Object.assign(Object.assign({}, i()), i(!0));
|
|
})(o),
|
|
];
|
|
},
|
|
U,
|
|
);
|
|
var en = function (e, t) {
|
|
var r = {};
|
|
for (var n in e)
|
|
Object.prototype.hasOwnProperty.call(e, n) &&
|
|
0 > t.indexOf(n) &&
|
|
(r[n] = e[n]);
|
|
if (null != e && "function" == typeof Object.getOwnPropertySymbols)
|
|
for (var o = 0, n = Object.getOwnPropertySymbols(e); o < n.length; o++)
|
|
0 > t.indexOf(n[o]) &&
|
|
Object.prototype.propertyIsEnumerable.call(e, n[o]) &&
|
|
(r[n[o]] = e[n[o]]);
|
|
return r;
|
|
};
|
|
let eo = {
|
|
default: ["default", "outlined"],
|
|
primary: ["primary", "solid"],
|
|
dashed: ["default", "dashed"],
|
|
link: ["link", "link"],
|
|
text: ["default", "text"],
|
|
},
|
|
ea = t.default.forwardRef((e, r) => {
|
|
var g, b;
|
|
let {
|
|
loading: v = !1,
|
|
prefixCls: _,
|
|
color: y,
|
|
variant: x,
|
|
type: C,
|
|
danger: E = !1,
|
|
shape: S,
|
|
size: w,
|
|
styles: k,
|
|
disabled: j,
|
|
className: P,
|
|
rootClassName: R,
|
|
children: N,
|
|
icon: $,
|
|
iconPosition: O = "start",
|
|
ghost: T = !1,
|
|
block: M = !1,
|
|
htmlType: I = "button",
|
|
classNames: A,
|
|
style: L = {},
|
|
autoInsertSpace: B,
|
|
autoFocus: D,
|
|
} = e,
|
|
H = en(e, [
|
|
"loading",
|
|
"prefixCls",
|
|
"color",
|
|
"variant",
|
|
"type",
|
|
"danger",
|
|
"shape",
|
|
"size",
|
|
"styles",
|
|
"disabled",
|
|
"className",
|
|
"rootClassName",
|
|
"children",
|
|
"icon",
|
|
"iconPosition",
|
|
"ghost",
|
|
"block",
|
|
"htmlType",
|
|
"classNames",
|
|
"style",
|
|
"autoInsertSpace",
|
|
"autoFocus",
|
|
]),
|
|
z = C || "default",
|
|
{ button: W } = t.default.useContext(s.ConfigContext),
|
|
F = S || (null == W ? void 0 : W.shape) || "default",
|
|
[U, G] = (0, t.useMemo)(() => {
|
|
if (y && x) return [y, x];
|
|
if (C || E) {
|
|
let e = eo[z] || [];
|
|
return E ? ["danger", e[1]] : e;
|
|
}
|
|
return (null == W ? void 0 : W.color) &&
|
|
(null == W ? void 0 : W.variant)
|
|
? [W.color, W.variant]
|
|
: ["default", "outlined"];
|
|
}, [
|
|
C,
|
|
y,
|
|
x,
|
|
E,
|
|
null == W ? void 0 : W.variant,
|
|
null == W ? void 0 : W.color,
|
|
]),
|
|
q = "danger" === U ? "dangerous" : U,
|
|
{
|
|
getPrefixCls: X,
|
|
direction: K,
|
|
autoInsertSpace: V,
|
|
className: Y,
|
|
style: Q,
|
|
classNames: Z,
|
|
styles: J,
|
|
} = (0, s.useComponentConfig)("button"),
|
|
et = null == (g = null != B ? B : V) || g,
|
|
ea = X("btn", _),
|
|
[ei, el, es] = ee(ea),
|
|
ec = (0, t.useContext)(c.default),
|
|
eu = null != j ? j : ec,
|
|
ed = (0, t.useContext)(f.GroupSizeContext),
|
|
ef = (0, t.useMemo)(
|
|
() =>
|
|
(function (e) {
|
|
if ("object" == typeof e && e) {
|
|
let t = null == e ? void 0 : e.delay;
|
|
return {
|
|
loading:
|
|
(t = Number.isNaN(t) || "number" != typeof t ? 0 : t) <=
|
|
0,
|
|
delay: t,
|
|
};
|
|
}
|
|
return { loading: !!e, delay: 0 };
|
|
})(v),
|
|
[v],
|
|
),
|
|
[em, ep] = (0, t.useState)(ef.loading),
|
|
[eh, eg] = (0, t.useState)(!1),
|
|
eb = (0, t.useRef)(null),
|
|
ev = (0, a.useComposeRef)(r, eb),
|
|
e_ =
|
|
1 === t.Children.count(N) &&
|
|
!$ &&
|
|
!(0, m.isUnBorderedButtonVariant)(G),
|
|
ey = (0, t.useRef)(!0);
|
|
t.default.useEffect(
|
|
() => (
|
|
(ey.current = !1),
|
|
() => {
|
|
ey.current = !0;
|
|
}
|
|
),
|
|
[],
|
|
),
|
|
(0, i.default)(() => {
|
|
let e = null;
|
|
return (
|
|
ef.delay > 0
|
|
? (e = setTimeout(() => {
|
|
(e = null), ep(!0);
|
|
}, ef.delay))
|
|
: ep(ef.loading),
|
|
function () {
|
|
e && (clearTimeout(e), (e = null));
|
|
}
|
|
);
|
|
}, [ef.delay, ef.loading]),
|
|
(0, t.useEffect)(() => {
|
|
if (!eb.current || !et) return;
|
|
let e = eb.current.textContent || "";
|
|
e_ && (0, m.isTwoCNChar)(e) ? eh || eg(!0) : eh && eg(!1);
|
|
}),
|
|
(0, t.useEffect)(() => {
|
|
D && eb.current && eb.current.focus();
|
|
}, []);
|
|
let ex = t.default.useCallback(
|
|
(t) => {
|
|
var r;
|
|
em || eu
|
|
? t.preventDefault()
|
|
: null == (r = e.onClick) || r.call(e, ("href" in e, t));
|
|
},
|
|
[e.onClick, em, eu],
|
|
),
|
|
{ compactSize: eC, compactItemClassnames: eE } = (0,
|
|
d.useCompactItemContext)(ea, K),
|
|
eS = (0, u.default)((e) => {
|
|
var t, r;
|
|
return null != (r = null != (t = null != w ? w : eC) ? t : ed)
|
|
? r
|
|
: e;
|
|
}),
|
|
ew =
|
|
eS && null != (b = { large: "lg", small: "sm", middle: void 0 }[eS])
|
|
? b
|
|
: "",
|
|
ek = em ? "loading" : $,
|
|
ej = (0, o.default)(H, ["navigate"]),
|
|
eP = (0, n.default)(
|
|
ea,
|
|
el,
|
|
es,
|
|
{
|
|
[`${ea}-${F}`]: "default" !== F && F,
|
|
[`${ea}-${z}`]: z,
|
|
[`${ea}-dangerous`]: E,
|
|
[`${ea}-color-${q}`]: q,
|
|
[`${ea}-variant-${G}`]: G,
|
|
[`${ea}-${ew}`]: ew,
|
|
[`${ea}-icon-only`]: !N && 0 !== N && !!ek,
|
|
[`${ea}-background-ghost`]:
|
|
T && !(0, m.isUnBorderedButtonVariant)(G),
|
|
[`${ea}-loading`]: em,
|
|
[`${ea}-two-chinese-chars`]: eh && et && !em,
|
|
[`${ea}-block`]: M,
|
|
[`${ea}-rtl`]: "rtl" === K,
|
|
[`${ea}-icon-end`]: "end" === O,
|
|
},
|
|
eE,
|
|
P,
|
|
R,
|
|
Y,
|
|
),
|
|
eR = Object.assign(Object.assign({}, Q), L),
|
|
eN = (0, n.default)(null == A ? void 0 : A.icon, Z.icon),
|
|
e$ = Object.assign(
|
|
Object.assign({}, (null == k ? void 0 : k.icon) || {}),
|
|
J.icon || {},
|
|
),
|
|
eO =
|
|
$ && !em
|
|
? t.default.createElement(
|
|
h.default,
|
|
{ prefixCls: ea, className: eN, style: e$ },
|
|
$,
|
|
)
|
|
: v && "object" == typeof v && v.icon
|
|
? t.default.createElement(
|
|
h.default,
|
|
{ prefixCls: ea, className: eN, style: e$ },
|
|
v.icon,
|
|
)
|
|
: t.default.createElement(p.default, {
|
|
existIcon: !!$,
|
|
prefixCls: ea,
|
|
loading: em,
|
|
mount: ey.current,
|
|
}),
|
|
eT = N || 0 === N ? (0, m.spaceChildren)(N, e_ && et) : null;
|
|
if (void 0 !== ej.href)
|
|
return ei(
|
|
t.default.createElement(
|
|
"a",
|
|
Object.assign({}, ej, {
|
|
className: (0, n.default)(eP, { [`${ea}-disabled`]: eu }),
|
|
href: eu ? void 0 : ej.href,
|
|
style: eR,
|
|
onClick: ex,
|
|
ref: ev,
|
|
tabIndex: eu ? -1 : 0,
|
|
"aria-disabled": eu,
|
|
}),
|
|
eO,
|
|
eT,
|
|
),
|
|
);
|
|
let eM = t.default.createElement(
|
|
"button",
|
|
Object.assign({}, H, {
|
|
type: I,
|
|
className: eP,
|
|
style: eR,
|
|
onClick: ex,
|
|
disabled: eu,
|
|
ref: ev,
|
|
}),
|
|
eO,
|
|
eT,
|
|
eE && t.default.createElement(er, { prefixCls: ea }),
|
|
);
|
|
return (
|
|
(0, m.isUnBorderedButtonVariant)(G) ||
|
|
(eM = t.default.createElement(
|
|
l.default,
|
|
{ component: "Button", disabled: em },
|
|
eM,
|
|
)),
|
|
ei(eM)
|
|
);
|
|
});
|
|
(ea.Group = f.default),
|
|
(ea.__ANT_BUTTON = !0),
|
|
e.s(["default", 0, ea], 430336);
|
|
let ei = (e) => "function" == typeof (null == e ? void 0 : e.then),
|
|
el = (e) => {
|
|
let {
|
|
type: n,
|
|
children: o,
|
|
prefixCls: a,
|
|
buttonProps: i,
|
|
close: l,
|
|
autoFocus: s,
|
|
emitEvent: c,
|
|
isSilent: u,
|
|
quitOnNullishReturnValue: d,
|
|
actionFn: f,
|
|
} = e,
|
|
p = t.useRef(!1),
|
|
h = t.useRef(null),
|
|
[g, b] = (0, r.default)(!1),
|
|
v = (...e) => {
|
|
null == l || l.apply(void 0, e);
|
|
};
|
|
return (
|
|
t.useEffect(() => {
|
|
let e = null;
|
|
return (
|
|
s &&
|
|
(e = setTimeout(() => {
|
|
var e;
|
|
null == (e = h.current) || e.focus({ preventScroll: !0 });
|
|
})),
|
|
() => {
|
|
e && clearTimeout(e);
|
|
}
|
|
);
|
|
}, [s]),
|
|
t.createElement(
|
|
ea,
|
|
Object.assign(
|
|
{},
|
|
(0, m.convertLegacyProps)(n),
|
|
{
|
|
onClick: (e) => {
|
|
let t;
|
|
if (!p.current) {
|
|
var r;
|
|
if (((p.current = !0), !f)) return void v();
|
|
if (c) {
|
|
if (((t = f(e)), d && !ei(t))) {
|
|
(p.current = !1), v(e);
|
|
return;
|
|
}
|
|
} else if (f.length) (t = f(l)), (p.current = !1);
|
|
else if (!ei((t = f()))) return void v();
|
|
ei((r = t)) &&
|
|
(b(!0),
|
|
r.then(
|
|
(...e) => {
|
|
b(!1, !0), v.apply(void 0, e), (p.current = !1);
|
|
},
|
|
(e) => {
|
|
if ((b(!1, !0), (p.current = !1), null == u || !u()))
|
|
return Promise.reject(e);
|
|
},
|
|
));
|
|
}
|
|
},
|
|
loading: g,
|
|
prefixCls: a,
|
|
},
|
|
i,
|
|
{ ref: h },
|
|
),
|
|
o,
|
|
)
|
|
);
|
|
},
|
|
es = t.default.createContext({}),
|
|
{ Provider: ec } = es;
|
|
e.s(["ModalContext", 0, es, "ModalContextProvider", 0, ec], 46089),
|
|
e.s(
|
|
[
|
|
"default",
|
|
0,
|
|
() => {
|
|
let {
|
|
autoFocusButton: e,
|
|
cancelButtonProps: r,
|
|
cancelTextLocale: n,
|
|
isSilent: o,
|
|
mergedOkCancel: a,
|
|
rootPrefixCls: i,
|
|
close: l,
|
|
onCancel: s,
|
|
onConfirm: c,
|
|
} = (0, t.useContext)(es);
|
|
return a
|
|
? t.default.createElement(
|
|
el,
|
|
{
|
|
isSilent: o,
|
|
actionFn: s,
|
|
close: (...e) => {
|
|
null == l || l.apply(void 0, e), null == c || c(!1);
|
|
},
|
|
autoFocus: "cancel" === e,
|
|
buttonProps: r,
|
|
prefixCls: `${i}-btn`,
|
|
},
|
|
n,
|
|
)
|
|
: null;
|
|
},
|
|
],
|
|
888307,
|
|
),
|
|
e.s(
|
|
[
|
|
"default",
|
|
0,
|
|
() => {
|
|
let {
|
|
autoFocusButton: e,
|
|
close: r,
|
|
isSilent: n,
|
|
okButtonProps: o,
|
|
rootPrefixCls: a,
|
|
okTextLocale: i,
|
|
okType: l,
|
|
onConfirm: s,
|
|
onOk: c,
|
|
} = (0, t.useContext)(es);
|
|
return t.default.createElement(
|
|
el,
|
|
{
|
|
isSilent: n,
|
|
type: l || "primary",
|
|
actionFn: c,
|
|
close: (...e) => {
|
|
null == r || r.apply(void 0, e), null == s || s(!0);
|
|
},
|
|
autoFocus: "ok" === e,
|
|
buttonProps: o,
|
|
prefixCls: `${a}-btn`,
|
|
},
|
|
i,
|
|
);
|
|
},
|
|
],
|
|
766403,
|
|
);
|
|
};
|
|
|
|
export default moduleFactory;
|