@nocobase/plugin-client 0.11.1-alpha.5 → 0.12.0-alpha.2

package/dist/locale/antd/anchor/style/index.js

@@ -0,0 +1,146 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _style = require("../../style");
+var _internal = require("../../theme/internal");
+// ============================== Shared ==============================
+const genSharedAnchorStyle = token => {
+  const {
+    componentCls,
+    holderOffsetBlock,
+    motionDurationSlow,
+    lineWidthBold,
+    colorPrimary,
+    lineType,
+    colorSplit
+  } = token;
+  return {
+    [`${componentCls}-wrapper`]: {
+      marginBlockStart: -holderOffsetBlock,
+      paddingBlockStart: holderOffsetBlock,
+      // delete overflow: auto
+      // overflow: 'auto',
+      [componentCls]: Object.assign(Object.assign({}, (0, _style.resetComponent)(token)), {
+        position: 'relative',
+        paddingInlineStart: lineWidthBold,
+        [`${componentCls}-link`]: {
+          paddingBlock: token.linkPaddingBlock,
+          paddingInline: `${token.linkPaddingInlineStart}px 0`,
+          '&-title': Object.assign(Object.assign({}, _style.textEllipsis), {
+            position: 'relative',
+            display: 'block',
+            marginBlockEnd: token.anchorTitleBlock,
+            color: token.colorText,
+            transition: `all ${token.motionDurationSlow}`,
+            '&:only-child': {
+              marginBlockEnd: 0
+            }
+          }),
+          [`&-active > ${componentCls}-link-title`]: {
+            color: token.colorPrimary
+          },
+          // link link
+          [`${componentCls}-link`]: {
+            paddingBlock: token.anchorPaddingBlockSecondary
+          }
+        }
+      }),
+      [`&:not(${componentCls}-wrapper-horizontal)`]: {
+        [componentCls]: {
+          '&::before': {
+            position: 'absolute',
+            insetInlineStart: 0,
+            top: 0,
+            height: '100%',
+            borderInlineStart: `${lineWidthBold}px ${lineType} ${colorSplit}`,
+            content: '" "'
+          },
+          [`${componentCls}-ink`]: {
+            position: 'absolute',
+            insetInlineStart: 0,
+            display: 'none',
+            transform: 'translateY(-50%)',
+            transition: `top ${motionDurationSlow} ease-in-out`,
+            width: lineWidthBold,
+            backgroundColor: colorPrimary,
+            [`&${componentCls}-ink-visible`]: {
+              display: 'inline-block'
+            }
+          }
+        }
+      },
+      [`${componentCls}-fixed ${componentCls}-ink ${componentCls}-ink`]: {
+        display: 'none'
+      }
+    }
+  };
+};
+const genSharedAnchorHorizontalStyle = token => {
+  const {
+    componentCls,
+    motionDurationSlow,
+    lineWidthBold,
+    colorPrimary
+  } = token;
+  return {
+    [`${componentCls}-wrapper-horizontal`]: {
+      position: 'relative',
+      '&::before': {
+        position: 'absolute',
+        left: {
+          _skip_check_: true,
+          value: 0
+        },
+        right: {
+          _skip_check_: true,
+          value: 0
+        },
+        bottom: 0,
+        borderBottom: `1px ${token.lineType} ${token.colorSplit}`,
+        content: '" "'
+      },
+      [componentCls]: {
+        overflowX: 'scroll',
+        position: 'relative',
+        display: 'flex',
+        scrollbarWidth: 'none' /* Firefox */,
+        '&::-webkit-scrollbar': {
+          display: 'none' /* Safari and Chrome */
+        },
+
+        [`${componentCls}-link:first-of-type`]: {
+          paddingInline: 0
+        },
+        [`${componentCls}-ink`]: {
+          position: 'absolute',
+          bottom: 0,
+          transition: `left ${motionDurationSlow} ease-in-out, width ${motionDurationSlow} ease-in-out`,
+          height: lineWidthBold,
+          backgroundColor: colorPrimary
+        }
+      }
+    }
+  };
+};
+// ============================== Export ==============================
+var _default = (0, _internal.genComponentStyleHook)('Anchor', token => {
+  const {
+    fontSize,
+    fontSizeLG,
+    paddingXXS
+  } = token;
+  const anchorToken = (0, _internal.mergeToken)(token, {
+    holderOffsetBlock: paddingXXS,
+    anchorPaddingBlockSecondary: paddingXXS / 2,
+    anchorTitleBlock: fontSize / 14 * 3,
+    anchorBallSize: fontSizeLG / 2
+  });
+  return [genSharedAnchorStyle(anchorToken), genSharedAnchorHorizontalStyle(anchorToken)];
+}, token => ({
+  linkPaddingBlock: token.paddingXXS,
+  linkPaddingInlineStart: token.padding
+}));
+exports.default = _default;

package/dist/locale/antd/app/context.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import type { MessageInstance, ConfigOptions as MessageConfig } from '../message/interface';
+import type { NotificationInstance, NotificationConfig } from '../notification/interface';
+import type { ModalStaticFunctions } from '../modal/confirm';
+export type AppConfig = {
+    message?: MessageConfig;
+    notification?: NotificationConfig;
+};
+export declare const AppConfigContext: React.Context<AppConfig>;
+type ModalType = Omit<ModalStaticFunctions, 'warn'>;
+export interface useAppProps {
+    message: MessageInstance;
+    notification: NotificationInstance;
+    modal: ModalType;
+}
+declare const AppContext: React.Context<useAppProps>;
+export default AppContext;

package/dist/locale/antd/app/context.js

@@ -0,0 +1,17 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.AppConfigContext = void 0;
+var _react = _interopRequireDefault(require("react"));
+const AppConfigContext = /*#__PURE__*/_react.default.createContext({});
+exports.AppConfigContext = AppConfigContext;
+const AppContext = /*#__PURE__*/_react.default.createContext({
+  message: {},
+  notification: {},
+  modal: {}
+});
+var _default = AppContext;
+exports.default = _default;

package/dist/locale/antd/app/index.d.ts

@@ -0,0 +1,15 @@
+import type { ReactNode } from 'react';
+import React from 'react';
+import type { AppConfig, useAppProps } from './context';
+export interface AppProps extends AppConfig {
+    style?: React.CSSProperties;
+    className?: string;
+    rootClassName?: string;
+    prefixCls?: string;
+    children?: ReactNode;
+}
+declare const useApp: () => useAppProps;
+declare const App: React.FC<AppProps> & {
+    useApp: typeof useApp;
+};
+export default App;

package/dist/locale/antd/app/index.js

@@ -0,0 +1,62 @@
+"use strict";
+'use client';
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _classnames = _interopRequireDefault(require("classnames"));
+var _react = _interopRequireWildcard(require("react"));
+var _configProvider = require("../config-provider");
+var _useMessage = _interopRequireDefault(require("../message/useMessage"));
+var _useModal = _interopRequireDefault(require("../modal/useModal"));
+var _useNotification = _interopRequireDefault(require("../notification/useNotification"));
+var _context = _interopRequireWildcard(require("./context"));
+var _style = _interopRequireDefault(require("./style"));
+const useApp = () => _react.default.useContext(_context.default);
+const App = props => {
+  const {
+    prefixCls: customizePrefixCls,
+    children,
+    className,
+    rootClassName,
+    message,
+    notification,
+    style
+  } = props;
+  const {
+    getPrefixCls
+  } = (0, _react.useContext)(_configProvider.ConfigContext);
+  const prefixCls = getPrefixCls('app', customizePrefixCls);
+  const [wrapSSR, hashId] = (0, _style.default)(prefixCls);
+  const customClassName = (0, _classnames.default)(hashId, prefixCls, className, rootClassName);
+  const appConfig = (0, _react.useContext)(_context.AppConfigContext);
+  const mergedAppConfig = _react.default.useMemo(() => ({
+    message: Object.assign(Object.assign({}, appConfig.message), message),
+    notification: Object.assign(Object.assign({}, appConfig.notification), notification)
+  }), [message, notification, appConfig.message, appConfig.notification]);
+  const [messageApi, messageContextHolder] = (0, _useMessage.default)(mergedAppConfig.message);
+  const [notificationApi, notificationContextHolder] = (0, _useNotification.default)(mergedAppConfig.notification);
+  const [ModalApi, ModalContextHolder] = (0, _useModal.default)();
+  const memoizedContextValue = _react.default.useMemo(() => ({
+    message: messageApi,
+    notification: notificationApi,
+    modal: ModalApi
+  }), [messageApi, notificationApi, ModalApi]);
+  return wrapSSR( /*#__PURE__*/_react.default.createElement(_context.default.Provider, {
+    value: memoizedContextValue
+  }, /*#__PURE__*/_react.default.createElement(_context.AppConfigContext.Provider, {
+    value: mergedAppConfig
+  }, /*#__PURE__*/_react.default.createElement("div", {
+    className: customClassName,
+    style: style
+  }, ModalContextHolder, messageContextHolder, notificationContextHolder, children))));
+};
+if (process.env.NODE_ENV !== 'production') {
+  App.displayName = 'App';
+}
+App.useApp = useApp;
+var _default = App;
+exports.default = _default;

package/dist/locale/antd/app/style/index.d.ts

@@ -0,0 +1,3 @@
+export type ComponentToken = {};
+declare const _default: (prefixCls: string) => import("../../theme/interface").UseComponentStyleResult;
+export default _default;

package/dist/locale/antd/app/style/index.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _internal = require("../../theme/internal");
+// =============================== Base ===============================
+const genBaseStyle = token => {
+  const {
+    componentCls,
+    colorText,
+    fontSize,
+    lineHeight,
+    fontFamily
+  } = token;
+  return {
+    [componentCls]: {
+      color: colorText,
+      fontSize,
+      lineHeight,
+      fontFamily
+    }
+  };
+};
+// ============================== Export ==============================
+var _default = (0, _internal.genComponentStyleHook)('App', token => [genBaseStyle(token)]);
+exports.default = _default;

package/dist/locale/antd/auto-complete/index.d.ts

@@ -0,0 +1,31 @@
+import type { BaseSelectRef } from 'rc-select';
+import * as React from 'react';
+import type { InputStatus } from '../_util/statusUtils';
+import type { BaseOptionType, DefaultOptionType, InternalSelectProps } from '../select';
+declare const Option: import("rc-select/lib/Option").OptionFC;
+export interface DataSourceItemObject {
+    value: string;
+    text: string;
+}
+export type DataSourceItemType = DataSourceItemObject | React.ReactNode;
+export interface AutoCompleteProps<ValueType = any, OptionType extends BaseOptionType | DefaultOptionType = DefaultOptionType> extends Omit<InternalSelectProps<ValueType, OptionType>, 'inputIcon' | 'loading' | 'mode' | 'optionLabelProp' | 'labelInValue'> {
+    dataSource?: DataSourceItemType[];
+    status?: InputStatus;
+    popupClassName?: string;
+    /** @deprecated Please use `popupClassName` instead */
+    dropdownClassName?: string;
+    /** @deprecated Please use `popupMatchSelectWidth` instead */
+    dropdownMatchSelectWidth?: boolean | number;
+    popupMatchSelectWidth?: boolean | number;
+}
+declare const RefAutoComplete: (<ValueType = any, OptionType extends BaseOptionType | DefaultOptionType = DefaultOptionType>(props: AutoCompleteProps<ValueType, OptionType> & {
+    children?: React.ReactNode;
+} & {
+    ref?: React.Ref<BaseSelectRef> | undefined;
+}) => React.ReactElement) & {
+    displayName?: string | undefined;
+    Option: typeof Option;
+    _InternalPanelDoNotUseOrYouWillBeFired: typeof PurePanel;
+};
+declare const PurePanel: any;
+export default RefAutoComplete;

package/dist/locale/antd/auto-complete/index.js

@@ -0,0 +1,104 @@
+"use strict";
+'use client';
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _classnames = _interopRequireDefault(require("classnames"));
+var _toArray = _interopRequireDefault(require("rc-util/lib/Children/toArray"));
+var _omit = _interopRequireDefault(require("rc-util/lib/omit"));
+var React = _interopRequireWildcard(require("react"));
+var _PurePanel = _interopRequireDefault(require("../_util/PurePanel"));
+var _reactNode = require("../_util/reactNode");
+var _warning = _interopRequireDefault(require("../_util/warning"));
+var _configProvider = require("../config-provider");
+var _select = _interopRequireDefault(require("../select"));
+const {
+  Option
+} = _select.default;
+function isSelectOptionOrSelectOptGroup(child) {
+  return child && child.type && (child.type.isSelectOption || child.type.isSelectOptGroup);
+}
+const AutoComplete = (props, ref) => {
+  const {
+    prefixCls: customizePrefixCls,
+    className,
+    popupClassName,
+    dropdownClassName,
+    children,
+    dataSource
+  } = props;
+  const childNodes = (0, _toArray.default)(children);
+  // ============================= Input =============================
+  let customizeInput;
+  if (childNodes.length === 1 && (0, _reactNode.isValidElement)(childNodes[0]) && !isSelectOptionOrSelectOptGroup(childNodes[0])) {
+    [customizeInput] = childNodes;
+  }
+  const getInputElement = customizeInput ? () => customizeInput : undefined;
+  // ============================ Options ============================
+  let optionChildren;
+  // [Legacy] convert `children` or `dataSource` into option children
+  if (childNodes.length && isSelectOptionOrSelectOptGroup(childNodes[0])) {
+    optionChildren = children;
+  } else {
+    optionChildren = dataSource ? dataSource.map(item => {
+      if ((0, _reactNode.isValidElement)(item)) {
+        return item;
+      }
+      switch (typeof item) {
+        case 'string':
+          return /*#__PURE__*/React.createElement(Option, {
+            key: item,
+            value: item
+          }, item);
+        case 'object':
+          {
+            const {
+              value: optionValue
+            } = item;
+            return /*#__PURE__*/React.createElement(Option, {
+              key: optionValue,
+              value: optionValue
+            }, item.text);
+          }
+        default:
+          process.env.NODE_ENV !== "production" ? (0, _warning.default)(false, 'AutoComplete', '`dataSource` is only supports type `string[] | Object[]`.') : void 0;
+          return undefined;
+      }
+    }) : [];
+  }
+  if (process.env.NODE_ENV !== 'production') {
+    process.env.NODE_ENV !== "production" ? (0, _warning.default)(!('dataSource' in props), 'AutoComplete', '`dataSource` is deprecated, please use `options` instead.') : void 0;
+    process.env.NODE_ENV !== "production" ? (0, _warning.default)(!customizeInput || !('size' in props), 'AutoComplete', 'You need to control style self instead of setting `size` when using customize input.') : void 0;
+    process.env.NODE_ENV !== "production" ? (0, _warning.default)(!dropdownClassName, 'AutoComplete', '`dropdownClassName` is deprecated, please use `popupClassName` instead.') : void 0;
+  }
+  const {
+    getPrefixCls
+  } = React.useContext(_configProvider.ConfigContext);
+  const prefixCls = getPrefixCls('select', customizePrefixCls);
+  return /*#__PURE__*/React.createElement(_select.default, Object.assign({
+    ref: ref,
+    showArrow: false
+  }, (0, _omit.default)(props, ['dataSource', 'dropdownClassName']), {
+    prefixCls: prefixCls,
+    popupClassName: popupClassName || dropdownClassName,
+    className: (0, _classnames.default)(`${prefixCls}-auto-complete`, className),
+    mode: _select.default.SECRET_COMBOBOX_MODE_DO_NOT_USE,
+    // Internal api
+    getInputElement
+  }), optionChildren);
+};
+const RefAutoComplete = /*#__PURE__*/React.forwardRef(AutoComplete);
+// We don't care debug panel
+/* istanbul ignore next */
+const PurePanel = (0, _PurePanel.default)(RefAutoComplete);
+RefAutoComplete.Option = Option;
+RefAutoComplete._InternalPanelDoNotUseOrYouWillBeFired = PurePanel;
+if (process.env.NODE_ENV !== 'production') {
+  RefAutoComplete.displayName = 'AutoComplete';
+}
+var _default = RefAutoComplete;
+exports.default = _default;

package/dist/locale/antd/avatar/SizeContext.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+import type { ScreenSizeMap } from '../_util/responsiveObserver';
+export type AvatarSize = 'large' | 'small' | 'default' | number | ScreenSizeMap;
+declare const SizeContext: React.Context<AvatarSize>;
+export interface SizeContextProps {
+    size?: AvatarSize;
+    children?: React.ReactNode;
+}
+export declare const SizeContextProvider: React.FC<SizeContextProps>;
+export default SizeContext;

package/dist/locale/antd/avatar/SizeContext.js

@@ -0,0 +1,22 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.SizeContextProvider = void 0;
+var React = _interopRequireWildcard(require("react"));
+const SizeContext = /*#__PURE__*/React.createContext('default');
+const SizeContextProvider = _ref => {
+  let {
+    children,
+    size
+  } = _ref;
+  const originSize = React.useContext(SizeContext);
+  return /*#__PURE__*/React.createElement(SizeContext.Provider, {
+    value: size || originSize
+  }, children);
+};
+exports.SizeContextProvider = SizeContextProvider;
+var _default = SizeContext;
+exports.default = _default;

package/dist/locale/antd/avatar/avatar.d.ts

@@ -0,0 +1,26 @@
+import * as React from 'react';
+import type { AvatarSize } from './SizeContext';
+export interface AvatarProps {
+    /** Shape of avatar, options: `circle`, `square` */
+    shape?: 'circle' | 'square';
+    size?: AvatarSize;
+    gap?: number;
+    /** Src of image avatar */
+    src?: React.ReactNode;
+    /** Srcset of image avatar */
+    srcSet?: string;
+    draggable?: boolean | 'true' | 'false';
+    /** Icon to be used in avatar */
+    icon?: React.ReactNode;
+    style?: React.CSSProperties;
+    prefixCls?: string;
+    className?: string;
+    rootClassName?: string;
+    children?: React.ReactNode;
+    alt?: string;
+    crossOrigin?: '' | 'anonymous' | 'use-credentials';
+    onClick?: (e?: React.MouseEvent<HTMLElement>) => void;
+    onError?: () => boolean;
+}
+declare const Avatar: React.ForwardRefExoticComponent<AvatarProps & React.RefAttributes<HTMLSpanElement>>;
+export default Avatar;

package/dist/locale/antd/avatar/avatar.js

@@ -0,0 +1,177 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _classnames = _interopRequireDefault(require("classnames"));
+var _rcResizeObserver = _interopRequireDefault(require("rc-resize-observer"));
+var _ref = require("rc-util/lib/ref");
+var React = _interopRequireWildcard(require("react"));
+var _responsiveObserver = require("../_util/responsiveObserver");
+var _warning = _interopRequireDefault(require("../_util/warning"));
+var _configProvider = require("../config-provider");
+var _useBreakpoint = _interopRequireDefault(require("../grid/hooks/useBreakpoint"));
+var _SizeContext = _interopRequireDefault(require("./SizeContext"));
+var _style = _interopRequireDefault(require("./style"));
+var __rest = void 0 && (void 0).__rest || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+const InternalAvatar = (props, ref) => {
+  const contextSize = React.useContext(_SizeContext.default);
+  const [scale, setScale] = React.useState(1);
+  const [mounted, setMounted] = React.useState(false);
+  const [isImgExist, setIsImgExist] = React.useState(true);
+  const avatarNodeRef = React.useRef(null);
+  const avatarChildrenRef = React.useRef(null);
+  const avatarNodeMergeRef = (0, _ref.composeRef)(ref, avatarNodeRef);
+  const {
+    getPrefixCls,
+    avatar
+  } = React.useContext(_configProvider.ConfigContext);
+  const setScaleParam = () => {
+    if (!avatarChildrenRef.current || !avatarNodeRef.current) {
+      return;
+    }
+    const childrenWidth = avatarChildrenRef.current.offsetWidth; // offsetWidth avoid affecting be transform scale
+    const nodeWidth = avatarNodeRef.current.offsetWidth;
+    // denominator is 0 is no meaning
+    if (childrenWidth !== 0 && nodeWidth !== 0) {
+      const {
+        gap = 4
+      } = props;
+      if (gap * 2 < nodeWidth) {
+        setScale(nodeWidth - gap * 2 < childrenWidth ? (nodeWidth - gap * 2) / childrenWidth : 1);
+      }
+    }
+  };
+  React.useEffect(() => {
+    setMounted(true);
+  }, []);
+  React.useEffect(() => {
+    setIsImgExist(true);
+    setScale(1);
+  }, [props.src]);
+  React.useEffect(setScaleParam, [props.gap]);
+  const handleImgLoadError = () => {
+    const {
+      onError
+    } = props;
+    const errorFlag = onError === null || onError === void 0 ? void 0 : onError();
+    if (errorFlag !== false) {
+      setIsImgExist(false);
+    }
+  };
+  const {
+      prefixCls: customizePrefixCls,
+      shape = 'circle',
+      size: customSize = 'default',
+      src,
+      srcSet,
+      icon,
+      className,
+      rootClassName,
+      alt,
+      draggable,
+      children,
+      crossOrigin
+    } = props,
+    others = __rest(props, ["prefixCls", "shape", "size", "src", "srcSet", "icon", "className", "rootClassName", "alt", "draggable", "children", "crossOrigin"]);
+  const size = customSize === 'default' ? contextSize : customSize;
+  const needResponsive = Object.keys(typeof size === 'object' ? size || {} : {}).some(key => ['xs', 'sm', 'md', 'lg', 'xl', 'xxl'].includes(key));
+  const screens = (0, _useBreakpoint.default)(needResponsive);
+  const responsiveSizeStyle = React.useMemo(() => {
+    if (typeof size !== 'object') {
+      return {};
+    }
+    const currentBreakpoint = _responsiveObserver.responsiveArray.find(screen => screens[screen]);
+    const currentSize = size[currentBreakpoint];
+    return currentSize ? {
+      width: currentSize,
+      height: currentSize,
+      lineHeight: `${currentSize}px`,
+      fontSize: icon ? currentSize / 2 : 18
+    } : {};
+  }, [screens, size]);
+  process.env.NODE_ENV !== "production" ? (0, _warning.default)(!(typeof icon === 'string' && icon.length > 2), 'Avatar', `\`icon\` is using ReactNode instead of string naming in v4. Please check \`${icon}\` at https://ant.design/components/icon`) : void 0;
+  const prefixCls = getPrefixCls('avatar', customizePrefixCls);
+  const [wrapSSR, hashId] = (0, _style.default)(prefixCls);
+  const sizeCls = (0, _classnames.default)({
+    [`${prefixCls}-lg`]: size === 'large',
+    [`${prefixCls}-sm`]: size === 'small'
+  });
+  const hasImageElement = /*#__PURE__*/React.isValidElement(src);
+  const classString = (0, _classnames.default)(prefixCls, sizeCls, avatar === null || avatar === void 0 ? void 0 : avatar.className, {
+    [`${prefixCls}-${shape}`]: !!shape,
+    [`${prefixCls}-image`]: hasImageElement || src && isImgExist,
+    [`${prefixCls}-icon`]: !!icon
+  }, className, rootClassName, hashId);
+  const sizeStyle = typeof size === 'number' ? {
+    width: size,
+    height: size,
+    lineHeight: `${size}px`,
+    fontSize: icon ? size / 2 : 18
+  } : {};
+  let childrenToRender;
+  if (typeof src === 'string' && isImgExist) {
+    childrenToRender = /*#__PURE__*/React.createElement("img", {
+      src: src,
+      draggable: draggable,
+      srcSet: srcSet,
+      onError: handleImgLoadError,
+      alt: alt,
+      crossOrigin: crossOrigin
+    });
+  } else if (hasImageElement) {
+    childrenToRender = src;
+  } else if (icon) {
+    childrenToRender = icon;
+  } else if (mounted || scale !== 1) {
+    const transformString = `scale(${scale}) translateX(-50%)`;
+    const childrenStyle = {
+      msTransform: transformString,
+      WebkitTransform: transformString,
+      transform: transformString
+    };
+    const sizeChildrenStyle = typeof size === 'number' ? {
+      lineHeight: `${size}px`
+    } : {};
+    childrenToRender = /*#__PURE__*/React.createElement(_rcResizeObserver.default, {
+      onResize: setScaleParam
+    }, /*#__PURE__*/React.createElement("span", {
+      className: `${prefixCls}-string`,
+      ref: avatarChildrenRef,
+      style: Object.assign(Object.assign({}, sizeChildrenStyle), childrenStyle)
+    }, children));
+  } else {
+    childrenToRender = /*#__PURE__*/React.createElement("span", {
+      className: `${prefixCls}-string`,
+      style: {
+        opacity: 0
+      },
+      ref: avatarChildrenRef
+    }, children);
+  }
+  // The event is triggered twice from bubbling up the DOM tree.
+  // see https://codesandbox.io/s/kind-snow-9lidz
+  delete others.onError;
+  delete others.gap;
+  return wrapSSR( /*#__PURE__*/React.createElement("span", Object.assign({}, others, {
+    style: Object.assign(Object.assign(Object.assign(Object.assign({}, sizeStyle), responsiveSizeStyle), avatar === null || avatar === void 0 ? void 0 : avatar.style), others.style),
+    className: classString,
+    ref: avatarNodeMergeRef
+  }), childrenToRender));
+};
+const Avatar = /*#__PURE__*/React.forwardRef(InternalAvatar);
+if (process.env.NODE_ENV !== 'production') {
+  Avatar.displayName = 'Avatar';
+}
+var _default = Avatar;
+exports.default = _default;