"use strict";(self.webpackChunkant_design_pro=self.webpackChunkant_design_pro||[]).push([[8997],{81643:function(ce,R,e){e.d(R,{Z:function(){return t}});const t=M=>M?typeof M=="function"?M():M:null},68997:function(ce,R,e){e.d(R,{Z:function(){return J}});var t=e(67294),M=e(93967),x=e.n(M),ne=e(48555),G=e(42550),w=e(74443),F=e(53124),H=e(35792),X=e(98675),Q=e(25378),n=t.createContext({}),v=e(11568),a=e(14747),i=e(83559),o=e(83262);const P=r=>{const{antCls:c,componentCls:d,iconCls:s,avatarBg:g,avatarColor:z,containerSize:D,containerSizeLG:T,containerSizeSM:$,textFontSize:I,textFontSizeLG:W,textFontSizeSM:re,borderRadius:B,borderRadiusLG:S,borderRadiusSM:U,lineWidth:k,lineType:ae}=r,Z=(l,h,p)=>({width:l,height:l,borderRadius:"50%",[`&${d}-square`]:{borderRadius:p},[`&${d}-icon`]:{fontSize:h,[`> ${s}`]:{margin:0}}});return{[d]:Object.assign(Object.assign(Object.assign(Object.assign({},(0,a.Wf)(r)),{position:"relative",display:"inline-flex",justifyContent:"center",alignItems:"center",overflow:"hidden",color:z,whiteSpace:"nowrap",textAlign:"center",verticalAlign:"middle",background:g,border:`${(0,v.bf)(k)} ${ae} transparent`,"&-image":{background:"transparent"},[`${c}-image-img`]:{display:"block"}}),Z(D,I,B)),{"&-lg":Object.assign({},Z(T,W,S)),"&-sm":Object.assign({},Z($,re,U)),"> img":{display:"block",width:"100%",height:"100%",objectFit:"cover"}})}},O=r=>{const{componentCls:c,groupBorderColor:d,groupOverlapping:s,groupSpace:g}=r;return{[`${c}-group`]:{display:"inline-flex",[c]:{borderColor:d},"> *:not(:first-child)":{marginInlineStart:s}},[`${c}-group-popover`]:{[`${c} + ${c}`]:{marginInlineStart:g}}}},u=r=>{const{controlHeight:c,controlHeightLG:d,controlHeightSM:s,fontSize:g,fontSizeLG:z,fontSizeXL:D,fontSizeHeading3:T,marginXS:$,marginXXS:I,colorBorderBg:W}=r;return{containerSize:c,containerSizeLG:d,containerSizeSM:s,textFontSize:Math.round((z+D)/2),textFontSizeLG:T,textFontSizeSM:g,groupSpace:I,groupOverlapping:-$,groupBorderColor:W}};var m=(0,i.I$)("Avatar",r=>{const{colorTextLightSolid:c,colorTextPlaceholder:d}=r,s=(0,o.IX)(r,{avatarBg:d,avatarColor:c});return[P(s),O(s)]},u),A=function(r,c){var d={};for(var s in r)Object.prototype.hasOwnProperty.call(r,s)&&c.indexOf(s)<0&&(d[s]=r[s]);if(r!=null&&typeof Object.getOwnPropertySymbols=="function")for(var g=0,s=Object.getOwnPropertySymbols(r);g<s.length;g++)c.indexOf(s[g])<0&&Object.prototype.propertyIsEnumerable.call(r,s[g])&&(d[s[g]]=r[s[g]]);return d};const N=(r,c)=>{const[d,s]=t.useState(1),[g,z]=t.useState(!1),[D,T]=t.useState(!0),$=t.useRef(null),I=t.useRef(null),W=(0,G.sQ)(c,$),{getPrefixCls:re,avatar:B}=t.useContext(F.E_),S=t.useContext(n),U=()=>{if(!I.current||!$.current)return;const C=I.current.offsetWidth,E=$.current.offsetWidth;if(C!==0&&E!==0){const{gap:V=4}=r;V*2<E&&s(E-V*2<C?(E-V*2)/C:1)}};t.useEffect(()=>{z(!0)},[]),t.useEffect(()=>{T(!0),s(1)},[r.src]),t.useEffect(U,[r.gap]);const k=()=>{const{onError:C}=r;(C==null?void 0:C())!==!1&&T(!1)},{prefixCls:ae,shape:Z,size:l,src:h,srcSet:p,icon:_,className:q,rootClassName:Oe,alt:Ce,draggable:ue,children:ee,crossOrigin:se}=r,te=A(r,["prefixCls","shape","size","src","srcSet","icon","className","rootClassName","alt","draggable","children","crossOrigin"]),y=(0,X.Z)(C=>{var E,V;return(V=(E=l!=null?l:S==null?void 0:S.size)!==null&&E!==void 0?E:C)!==null&&V!==void 0?V:"default"}),ie=Object.keys(typeof y=="object"?y||{}:{}).some(C=>["xs","sm","md","lg","xl","xxl"].includes(C)),ge=(0,Q.Z)(ie),Ee=t.useMemo(()=>{if(typeof y!="object")return{};const C=w.c4.find(V=>ge[V]),E=y[C];return E?{width:E,height:E,fontSize:E&&(_||ee)?E/2:18}:{}},[ge,y]),j=re("avatar",ae),me=(0,H.Z)(j),[Pe,he,xe]=m(j,me),Se=x()({[`${j}-lg`]:y==="large",[`${j}-sm`]:y==="small"}),ye=t.isValidElement(h),_e=Z||(S==null?void 0:S.shape)||"circle",Me=x()(j,Se,B==null?void 0:B.className,`${j}-${_e}`,{[`${j}-image`]:ye||h&&D,[`${j}-icon`]:!!_},xe,me,q,Oe,he),be=typeof y=="number"?{width:y,height:y,fontSize:_?y/2:18}:{};let le;if(typeof h=="string"&&D)le=t.createElement("img",{src:h,draggable:ue,srcSet:p,onError:k,alt:Ce,crossOrigin:se});else if(ye)le=h;else if(_)le=_;else if(g||d!==1){const C=`scale(${d})`,E={msTransform:C,WebkitTransform:C,transform:C};le=t.createElement(ne.Z,{onResize:U},t.createElement("span",{className:`${j}-string`,ref:I,style:Object.assign({},E)},ee))}else le=t.createElement("span",{className:`${j}-string`,style:{opacity:0},ref:I},ee);return delete te.onError,delete te.gap,Pe(t.createElement("span",Object.assign({},te,{style:Object.assign(Object.assign(Object.assign(Object.assign({},be),Ee),B==null?void 0:B.style),te.style),className:Me,ref:W}),le))};var Y=t.forwardRef(N),oe=e(50344),b=e(96159),fe=e(55241);const de=r=>{const{size:c,shape:d}=t.useContext(n),s=t.useMemo(()=>({size:r.size||c,shape:r.shape||d}),[r.size,r.shape,c,d]);return t.createElement(n.Provider,{value:s},r.children)};var pe=r=>{var c,d,s,g;const{getPrefixCls:z,direction:D}=t.useContext(F.E_),{prefixCls:T,className:$,rootClassName:I,style:W,maxCount:re,maxStyle:B,size:S,shape:U,maxPopoverPlacement:k,maxPopoverTrigger:ae,children:Z,max:l}=r,h=z("avatar",T),p=`${h}-group`,_=(0,H.Z)(h),[q,Oe,Ce]=m(h,_),ue=x()(p,{[`${p}-rtl`]:D==="rtl"},Ce,_,$,I,Oe),ee=(0,oe.Z)(Z).map((y,ie)=>(0,b.Tm)(y,{key:`avatar-key-${ie}`})),se=(l==null?void 0:l.count)||re,te=ee.length;if(se&&se<te){const y=ee.slice(0,se),ie=ee.slice(se,te),ge=(l==null?void 0:l.style)||B,Ee=((c=l==null?void 0:l.popover)===null||c===void 0?void 0:c.trigger)||ae||"hover",j=((d=l==null?void 0:l.popover)===null||d===void 0?void 0:d.placement)||k||"top",me=Object.assign(Object.assign({content:ie},l==null?void 0:l.popover),{classNames:{root:x()(`${p}-popover`,(g=(s=l==null?void 0:l.popover)===null||s===void 0?void 0:s.classNames)===null||g===void 0?void 0:g.root)},placement:j,trigger:Ee});return y.push(t.createElement(fe.Z,Object.assign({key:"avatar-popover-key",destroyTooltipOnHide:!0},me),t.createElement(Y,{style:ge},`+${te-se}`))),q(t.createElement(de,{shape:U,size:S},t.createElement("div",{className:ue,style:W},y)))}return q(t.createElement(de,{shape:U,size:S},t.createElement("div",{className:ue,style:W},ee)))};const K=Y;K.Group=pe;var J=K},66330:function(ce,R,e){e.d(R,{aV:function(){return X}});var t=e(67294),M=e(93967),x=e.n(M),ne=e(92419),G=e(81643),w=e(53124),F=e(20136),H=function(n,v){var a={};for(var i in n)Object.prototype.hasOwnProperty.call(n,i)&&v.indexOf(i)<0&&(a[i]=n[i]);if(n!=null&&typeof Object.getOwnPropertySymbols=="function")for(var o=0,i=Object.getOwnPropertySymbols(n);o<i.length;o++)v.indexOf(i[o])<0&&Object.prototype.propertyIsEnumerable.call(n,i[o])&&(a[i[o]]=n[i[o]]);return a};const X=n=>{let{title:v,content:a,prefixCls:i}=n;return!v&&!a?null:t.createElement(t.Fragment,null,v&&t.createElement("div",{className:`${i}-title`},v),a&&t.createElement("div",{className:`${i}-inner-content`},a))},Q=n=>{const{hashId:v,prefixCls:a,className:i,style:o,placement:P="top",title:O,content:u,children:m}=n,A=(0,G.Z)(O),N=(0,G.Z)(u),L=x()(v,a,`${a}-pure`,`${a}-placement-${P}`,i);return t.createElement("div",{className:L,style:o},t.createElement("div",{className:`${a}-arrow`}),t.createElement(ne.G,Object.assign({},n,{className:v,prefixCls:a}),m||t.createElement(X,{prefixCls:a,title:A,content:N})))},f=n=>{const{prefixCls:v,className:a}=n,i=H(n,["prefixCls","className"]),{getPrefixCls:o}=t.useContext(w.E_),P=o("popover",v),[O,u,m]=(0,F.Z)(P);return O(t.createElement(Q,Object.assign({},i,{prefixCls:P,hashId:u,className:x()(a,m)})))};R.ZP=f},55241:function(ce,R,e){var t=e(67294),M=e(93967),x=e.n(M),ne=e(21770),G=e(15105),w=e(81643),F=e(33603),H=e(96159),X=e(83062),Q=e(66330),f=e(53124),n=e(20136),v=function(o,P){var O={};for(var u in o)Object.prototype.hasOwnProperty.call(o,u)&&P.indexOf(u)<0&&(O[u]=o[u]);if(o!=null&&typeof Object.getOwnPropertySymbols=="function")for(var m=0,u=Object.getOwnPropertySymbols(o);m<u.length;m++)P.indexOf(u[m])<0&&Object.prototype.propertyIsEnumerable.call(o,u[m])&&(O[u[m]]=o[u[m]]);return O};const i=t.forwardRef((o,P)=>{var O,u;const{prefixCls:m,title:A,content:N,overlayClassName:L,placement:Y="top",trigger:oe="hover",children:b,mouseEnterDelay:fe=.1,mouseLeaveDelay:de=.1,onOpenChange:ve,overlayStyle:pe={},styles:K,classNames:J}=o,r=v(o,["prefixCls","title","content","overlayClassName","placement","trigger","children","mouseEnterDelay","mouseLeaveDelay","onOpenChange","overlayStyle","styles","classNames"]),{getPrefixCls:c,className:d,style:s,classNames:g,styles:z}=(0,f.dj)("popover"),D=c("popover",m),[T,$,I]=(0,n.Z)(D),W=c(),re=x()(L,$,I,d,g.root,J==null?void 0:J.root),B=x()(g.body,J==null?void 0:J.body),[S,U]=(0,ne.Z)(!1,{value:(O=o.open)!==null&&O!==void 0?O:o.visible,defaultValue:(u=o.defaultOpen)!==null&&u!==void 0?u:o.defaultVisible}),k=(p,_)=>{U(p,!0),ve==null||ve(p,_)},ae=p=>{p.keyCode===G.Z.ESC&&k(!1,p)},Z=p=>{k(p)},l=(0,w.Z)(A),h=(0,w.Z)(N);return T(t.createElement(X.Z,Object.assign({placement:Y,trigger:oe,mouseEnterDelay:fe,mouseLeaveDelay:de},r,{prefixCls:D,classNames:{root:re,body:B},styles:{root:Object.assign(Object.assign(Object.assign(Object.assign({},z.root),s),pe),K==null?void 0:K.root),body:Object.assign(Object.assign({},z.body),K==null?void 0:K.body)},ref:P,open:S,onOpenChange:Z,overlay:l||h?t.createElement(Q.aV,{prefixCls:D,title:l,content:h}):null,transitionName:(0,F.m)(W,"zoom-big",r.transitionName),"data-popover-inject":!0}),(0,H.Tm)(b,{onKeyDown:p=>{var _,q;t.isValidElement(b)&&((q=b==null?void 0:(_=b.props).onKeyDown)===null||q===void 0||q.call(_,p)),ae(p)}})))});i._InternalPanelDoNotUseOrYouWillBeFired=Q.ZP,R.Z=i},20136:function(ce,R,e){var t=e(14747),M=e(50438),x=e(97414),ne=e(79511),G=e(8796),w=e(83559),F=e(83262);const H=f=>{const{componentCls:n,popoverColor:v,titleMinWidth:a,fontWeightStrong:i,innerPadding:o,boxShadowSecondary:P,colorTextHeading:O,borderRadiusLG:u,zIndexPopup:m,titleMarginBottom:A,colorBgElevated:N,popoverBg:L,titleBorderBottom:Y,innerContentPadding:oe,titlePadding:b}=f;return[{[n]:Object.assign(Object.assign({},(0,t.Wf)(f)),{position:"absolute",top:0,left:{_skip_check_:!0,value:0},zIndex:m,fontWeight:"normal",whiteSpace:"normal",textAlign:"start",cursor:"auto",userSelect:"text","--valid-offset-x":"var(--arrow-offset-horizontal, var(--arrow-x))",transformOrigin:["var(--valid-offset-x, 50%)","var(--arrow-y, 50%)"].join(" "),"--antd-arrow-background-color":N,width:"max-content",maxWidth:"100vw","&-rtl":{direction:"rtl"},"&-hidden":{display:"none"},[`${n}-content`]:{position:"relative"},[`${n}-inner`]:{backgroundColor:L,backgroundClip:"padding-box",borderRadius:u,boxShadow:P,padding:o},[`${n}-title`]:{minWidth:a,marginBottom:A,color:O,fontWeight:i,borderBottom:Y,padding:b},[`${n}-inner-content`]:{color:v,padding:oe}})},(0,x.ZP)(f,"var(--antd-arrow-background-color)"),{[`${n}-pure`]:{position:"relative",maxWidth:"none",margin:f.sizePopupArrow,display:"inline-block",[`${n}-content`]:{display:"inline-block"}}}]},X=f=>{const{componentCls:n}=f;return{[n]:G.i.map(v=>{const a=f[`${v}6`];return{[`&${n}-${v}`]:{"--antd-arrow-background-color":a,[`${n}-inner`]:{backgroundColor:a},[`${n}-arrow`]:{background:"transparent"}}}})}},Q=f=>{const{lineWidth:n,controlHeight:v,fontHeight:a,padding:i,wireframe:o,zIndexPopupBase:P,borderRadiusLG:O,marginXS:u,lineType:m,colorSplit:A,paddingSM:N}=f,L=v-a,Y=L/2,oe=L/2-n,b=i;return Object.assign(Object.assign(Object.assign({titleMinWidth:177,zIndexPopup:P+30},(0,ne.w)(f)),(0,x.wZ)({contentRadius:O,limitVerticalRadius:!0})),{innerPadding:o?0:12,titleMarginBottom:o?0:u,titlePadding:o?`${Y}px ${b}px ${oe}px`:0,titleBorderBottom:o?`${n}px ${m} ${A}`:"none",innerContentPadding:o?`${N}px ${b}px`:0})};R.Z=(0,w.I$)("Popover",f=>{const{colorBgElevated:n,colorText:v}=f,a=(0,F.IX)(f,{popoverBg:n,popoverColor:v});return[H(a),X(a),(0,M._y)(a,"zoom-big")]},Q,{resetStyle:!1,deprecatedTokens:[["width","titleMinWidth"],["minWidth","titleMinWidth"]]})}}]);
