acud 1.0.21 → 1.0.23

package/lib/avatar/avatar.js

@@ -0,0 +1,233 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof3 = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+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 _configProvider = require("../config-provider");
+
+var _useBreakpoint = _interopRequireDefault(require("../grid/hooks/useBreakpoint"));
+
+var _responsiveObserve = require("../_util/responsiveObserve");
+
+var _SizeContext = _interopRequireDefault(require("./SizeContext"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof3(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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;
+};
+
+var InternalAvatar = function InternalAvatar(props, ref) {
+  var _classNames, _classNames2;
+
+  var groupSize = React.useContext(_SizeContext["default"]);
+
+  var _React$useState = React.useState(1),
+      _React$useState2 = (0, _slicedToArray2["default"])(_React$useState, 2),
+      scale = _React$useState2[0],
+      setScale = _React$useState2[1];
+
+  var _React$useState3 = React.useState(false),
+      _React$useState4 = (0, _slicedToArray2["default"])(_React$useState3, 2),
+      mounted = _React$useState4[0],
+      setMounted = _React$useState4[1];
+
+  var _React$useState5 = React.useState(true),
+      _React$useState6 = (0, _slicedToArray2["default"])(_React$useState5, 2),
+      isImgExist = _React$useState6[0],
+      setIsImgExist = _React$useState6[1];
+
+  var avatarNodeRef = React.useRef();
+  var avatarChildrenRef = React.useRef();
+  var avatarNodeMergeRef = (0, _ref.composeRef)(ref, avatarNodeRef);
+
+  var _React$useContext = React.useContext(_configProvider.ConfigContext),
+      getPrefixCls = _React$useContext.getPrefixCls;
+
+  var setScaleParam = function setScaleParam() {
+    if (!avatarChildrenRef.current || !avatarNodeRef.current) {
+      return;
+    }
+
+    var childrenWidth = avatarChildrenRef.current.offsetWidth; // offsetWidth avoid affecting be transform scale
+
+    var nodeWidth = avatarNodeRef.current.offsetWidth; // denominator is 0 is no meaning
+
+    if (childrenWidth !== 0 && nodeWidth !== 0) {
+      var _props$gap = props.gap,
+          gap = _props$gap === void 0 ? 4 : _props$gap;
+
+      if (gap * 2 < nodeWidth) {
+        setScale(nodeWidth - gap * 2 < childrenWidth ? (nodeWidth - gap * 2) / childrenWidth : 1);
+      }
+    }
+  };
+
+  React.useEffect(function () {
+    setMounted(true);
+  }, []);
+  React.useEffect(function () {
+    setIsImgExist(true);
+    setScale(1);
+  }, [props.src]);
+  React.useEffect(function () {
+    setScaleParam();
+  }, [props.gap]);
+
+  var handleImgLoadError = function handleImgLoadError() {
+    var onError = props.onError;
+    var errorFlag = onError ? onError() : undefined;
+
+    if (errorFlag !== false) {
+      setIsImgExist(false);
+    }
+  };
+
+  var customizePrefixCls = props.prefixCls,
+      shape = props.shape,
+      customSize = props.size,
+      src = props.src,
+      srcSet = props.srcSet,
+      icon = props.icon,
+      className = props.className,
+      alt = props.alt,
+      draggable = props.draggable,
+      children = props.children,
+      crossOrigin = props.crossOrigin,
+      others = __rest(props, ["prefixCls", "shape", "size", "src", "srcSet", "icon", "className", "alt", "draggable", "children", "crossOrigin"]);
+
+  var size = customSize === 'default' ? groupSize : customSize;
+  var needResponsive = Object.keys((0, _typeof2["default"])(size) === 'object' ? size || {} : {}).some(function (key) {
+    return ['xs', 'sm', 'md', 'lg', 'xl', 'xxl'].includes(key);
+  });
+  var screens = (0, _useBreakpoint["default"])(needResponsive);
+  var responsiveSizeStyle = React.useMemo(function () {
+    if ((0, _typeof2["default"])(size) !== 'object') {
+      return {};
+    }
+
+    var currentBreakpoint = _responsiveObserve.responsiveArray.find(function (screen) {
+      return screens[screen];
+    });
+
+    var currentSize = size[currentBreakpoint];
+    return currentSize ? {
+      width: currentSize,
+      height: currentSize,
+      lineHeight: "".concat(currentSize, "px"),
+      fontSize: icon ? currentSize / 2 : 18
+    } : {};
+  }, [screens, size]);
+  console.warn(!(typeof icon === 'string' && icon.length > 2), 'Avatar', "`icon` is using ReactNode instead of string naming in v4. Please check `".concat(icon, "` at https://ant.design/components/icon"));
+  var prefixCls = getPrefixCls('avatar', customizePrefixCls);
+  var sizeCls = (0, _classnames["default"])((_classNames = {}, (0, _defineProperty2["default"])(_classNames, "".concat(prefixCls, "-lg"), size === 'large'), (0, _defineProperty2["default"])(_classNames, "".concat(prefixCls, "-sm"), size === 'small'), _classNames));
+  var hasImageElement = /*#__PURE__*/React.isValidElement(src);
+  var classString = (0, _classnames["default"])(prefixCls, sizeCls, (_classNames2 = {}, (0, _defineProperty2["default"])(_classNames2, "".concat(prefixCls, "-").concat(shape), !!shape), (0, _defineProperty2["default"])(_classNames2, "".concat(prefixCls, "-image"), hasImageElement || src && isImgExist), (0, _defineProperty2["default"])(_classNames2, "".concat(prefixCls, "-icon"), !!icon), _classNames2), className);
+  var sizeStyle = typeof size === 'number' ? {
+    width: size,
+    height: size,
+    lineHeight: "".concat(size, "px"),
+    fontSize: icon ? size / 2 : 18
+  } : {};
+  var 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) {
+    var transformString = "scale(".concat(scale, ") translateX(-50%)");
+    var childrenStyle = {
+      msTransform: transformString,
+      WebkitTransform: transformString,
+      transform: transformString
+    };
+    var sizeChildrenStyle = typeof size === 'number' ? {
+      lineHeight: "".concat(size, "px")
+    } : {};
+    childrenToRender = /*#__PURE__*/React.createElement(_rcResizeObserver["default"], {
+      onResize: setScaleParam
+    }, /*#__PURE__*/React.createElement("span", {
+      className: "".concat(prefixCls, "-string"),
+      ref: function ref(node) {
+        avatarChildrenRef.current = node;
+      },
+      style: (0, _extends2["default"])((0, _extends2["default"])({}, sizeChildrenStyle), childrenStyle)
+    }, children));
+  } else {
+    childrenToRender = /*#__PURE__*/React.createElement("span", {
+      className: "".concat(prefixCls, "-string"),
+      style: {
+        opacity: 0
+      },
+      ref: function ref(node) {
+        avatarChildrenRef.current = node;
+      }
+    }, 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 /*#__PURE__*/React.createElement("span", (0, _extends2["default"])({}, others, {
+    style: (0, _extends2["default"])((0, _extends2["default"])((0, _extends2["default"])({}, sizeStyle), responsiveSizeStyle), others.style),
+    className: classString,
+    ref: avatarNodeMergeRef
+  }), childrenToRender);
+};
+
+var Avatar = /*#__PURE__*/React.forwardRef(InternalAvatar);
+
+if (process.env.NODE_ENV !== 'production') {
+  Avatar.displayName = 'Avatar';
+}
+
+Avatar.defaultProps = {
+  shape: 'circle',
+  size: 'default'
+};
+var _default = Avatar;
+exports["default"] = _default;

package/lib/avatar/group.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import { AvatarSize } from './SizeContext';
+export interface GroupProps {
+    className?: string;
+    children?: React.ReactNode;
+    style?: React.CSSProperties;
+    prefixCls?: string;
+    maxCount?: number;
+    maxStyle?: React.CSSProperties;
+    maxPopoverPlacement?: 'top' | 'bottom';
+    maxPopoverTrigger?: 'hover' | 'focus' | 'click';
+    size?: AvatarSize;
+}
+declare const Group: React.FC<GroupProps>;
+export default Group;

package/lib/avatar/group.js

@@ -0,0 +1,88 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _toArray = _interopRequireDefault(require("rc-util/lib/Children/toArray"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _configProvider = require("../config-provider");
+
+var _popover = _interopRequireDefault(require("../popover"));
+
+var _reactNode = require("../_util/reactNode");
+
+var _avatar = _interopRequireDefault(require("./avatar"));
+
+var _SizeContext = require("./SizeContext");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var Group = function Group(props) {
+  var _React$useContext = React.useContext(_configProvider.ConfigContext),
+      getPrefixCls = _React$useContext.getPrefixCls,
+      direction = _React$useContext.direction;
+
+  var customizePrefixCls = props.prefixCls,
+      _props$className = props.className,
+      className = _props$className === void 0 ? '' : _props$className,
+      maxCount = props.maxCount,
+      maxStyle = props.maxStyle,
+      size = props.size;
+  var prefixCls = getPrefixCls('avatar-group', customizePrefixCls);
+  var cls = (0, _classnames["default"])(prefixCls, (0, _defineProperty2["default"])({}, "".concat(prefixCls, "-rtl"), direction === 'rtl'), className);
+  var children = props.children,
+      _props$maxPopoverPlac = props.maxPopoverPlacement,
+      maxPopoverPlacement = _props$maxPopoverPlac === void 0 ? 'top' : _props$maxPopoverPlac,
+      _props$maxPopoverTrig = props.maxPopoverTrigger,
+      maxPopoverTrigger = _props$maxPopoverTrig === void 0 ? 'hover' : _props$maxPopoverTrig;
+  var childrenWithProps = (0, _toArray["default"])(children).map(function (child, index) {
+    return (0, _reactNode.cloneElement)(child, {
+      key: "avatar-key-".concat(index)
+    });
+  });
+  var numOfChildren = childrenWithProps.length;
+
+  if (maxCount && maxCount < numOfChildren) {
+    var childrenShow = childrenWithProps.slice(0, maxCount);
+    var childrenHidden = childrenWithProps.slice(maxCount, numOfChildren);
+    childrenShow.push( /*#__PURE__*/React.createElement(_popover["default"], {
+      key: "avatar-popover-key",
+      content: childrenHidden,
+      trigger: maxPopoverTrigger,
+      placement: maxPopoverPlacement,
+      overlayClassName: "".concat(prefixCls, "-popover")
+    }, /*#__PURE__*/React.createElement(_avatar["default"], {
+      style: maxStyle
+    }, "+".concat(numOfChildren - maxCount))));
+    return /*#__PURE__*/React.createElement(_SizeContext.SizeContextProvider, {
+      size: size
+    }, /*#__PURE__*/React.createElement("div", {
+      className: cls,
+      style: props.style
+    }, childrenShow));
+  }
+
+  return /*#__PURE__*/React.createElement(_SizeContext.SizeContextProvider, {
+    size: size
+  }, /*#__PURE__*/React.createElement("div", {
+    className: cls,
+    style: props.style
+  }, childrenWithProps));
+};
+
+var _default = Group;
+exports["default"] = _default;

package/lib/avatar/index.d.ts

@@ -0,0 +1,11 @@
+import { ForwardRefExoticComponent, RefAttributes } from 'react';
+import { AvatarProps } from './avatar';
+import Group from './group';
+export { AvatarProps } from './avatar';
+export { GroupProps } from './group';
+export { Group };
+interface CompoundedComponent extends ForwardRefExoticComponent<AvatarProps & RefAttributes<HTMLElement>> {
+    Group: typeof Group;
+}
+declare const Avatar: CompoundedComponent;
+export default Avatar;

package/lib/avatar/index.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Group", {
+  enumerable: true,
+  get: function get() {
+    return _group["default"];
+  }
+});
+exports["default"] = void 0;
+
+var _avatar = _interopRequireDefault(require("./avatar"));
+
+var _group = _interopRequireDefault(require("./group"));
+
+var Avatar = _avatar["default"];
+Avatar.Group = _group["default"];
+var _default = Avatar;
+exports["default"] = _default;

package/lib/avatar/style/css.js

@@ -0,0 +1,7 @@
+"use strict";
+
+require("../../style/index.css");
+
+require("./index.css");
+
+require("../../popover/style/css");

package/lib/avatar/style/group.less

@@ -0,0 +1,17 @@
+.@{avatar-prefix-cls}-group {
+  display: inline-flex;
+
+  .@{avatar-prefix-cls} {
+    border: 1px solid @avatar-group-border-color;
+
+    &:not(:first-child) {
+      margin-left: @avatar-group-overlapping;
+   }
+ }
+
+  &-popover {
+    .@{acud-prefix}-avatar + .@{acud-prefix}-avatar {
+      margin-left: @avatar-group-space;
+   }
+ }
+}

package/lib/avatar/style/index.css

@@ -0,0 +1,108 @@
+/* color */
+/* 默认颜色 */
+/* 通用-icon */
+/* 标签 */
+/* 默认颜色 */
+/* 其他颜色 */
+/* 通用 */
+/* 水平 */
+/* 垂直 */
+/* 序号水平 */
+/* 序号垂直 */
+.acud-avatar {
+  margin: 0;
+  padding: 0;
+  position: relative;
+  display: inline-block;
+  overflow: hidden;
+  color: #fff;
+  white-space: nowrap;
+  text-align: center;
+  vertical-align: middle;
+  background: #ccc;
+  width: 32px;
+  height: 32px;
+  line-height: 32px;
+  border-radius: 50%;
+}
+.acud-avatar-image {
+  background: transparent;
+}
+.acud-avatar .acud-image-img {
+  display: block;
+}
+.acud-avatar-string {
+  position: absolute;
+  left: 50%;
+  transform-origin: 0 center;
+}
+.acud-avatar.acud-avatar-icon {
+  font-size: 18px;
+}
+.acud-avatar.acud-avatar-icon > .acudicon {
+  margin: 0;
+}
+.acud-avatar-lg {
+  width: 40px;
+  height: 40px;
+  line-height: 40px;
+  border-radius: 50%;
+}
+.acud-avatar-lg-string {
+  position: absolute;
+  left: 50%;
+  transform-origin: 0 center;
+}
+.acud-avatar-lg.acud-avatar-icon {
+  font-size: 24px;
+}
+.acud-avatar-lg.acud-avatar-icon > .acudicon {
+  margin: 0;
+}
+.acud-avatar-sm {
+  width: 24px;
+  height: 24px;
+  line-height: 24px;
+  border-radius: 50%;
+}
+.acud-avatar-sm-string {
+  position: absolute;
+  left: 50%;
+  transform-origin: 0 center;
+}
+.acud-avatar-sm.acud-avatar-icon {
+  font-size: 14px;
+}
+.acud-avatar-sm.acud-avatar-icon > .acudicon {
+  margin: 0;
+}
+.acud-avatar-square {
+  border-radius: 0px;
+}
+.acud-avatar > img {
+  display: block;
+  width: 100%;
+  height: 100%;
+  -o-object-fit: cover;
+     object-fit: cover;
+}
+.acud-avatar-group {
+  display: inline-flex;
+}
+.acud-avatar-group .acud-avatar {
+  border: 1px solid #fff;
+}
+.acud-avatar-group .acud-avatar:not(:first-child) {
+  margin-left: -8px;
+}
+.acud-avatar-group-popover .acud-avatar + .acud-avatar {
+  margin-left: 3px;
+}
+.acud-avatar-group-rtl .acud-avatar:not(:first-child) {
+  margin-right: -8px;
+  margin-left: 0;
+}
+.acud-avatar-group-popover.acud-popover-rtl .acud-avatar + .acud-avatar {
+  margin-right: 3px;
+  margin-left: 0;
+}

package/lib/avatar/style/index.d.ts

@@ -0,0 +1,3 @@
+import '../../style/index.less';
+import './index.less';
+import '../../popover/style';

package/lib/avatar/style/index.js

@@ -0,0 +1,7 @@
+"use strict";
+
+require("../../style/index.less");
+
+require("./index.less");
+
+require("../../popover/style");

package/lib/avatar/style/index.less

@@ -0,0 +1,68 @@
+@import '../../style/themes/index';
+@import '../../style/mixins/index';
+
+@avatar-prefix-cls: ~'@{acud-prefix}-avatar';
+.@{avatar-prefix-cls} {
+    .reset-component();
+    position: relative;
+    display: inline-block;
+    overflow: hidden;
+    color: @avatar-color;
+    white-space: nowrap;
+    text-align: center;
+    vertical-align: middle;
+    background: @avatar-bg;
+
+    &-image {
+        background: transparent;
+    }
+
+    .@{acud-prefix}-image-img {
+        display: block;
+    }
+
+    .avatar-size(@avatar-size-base, @avatar-font-size-base);
+
+    &-lg {
+        .avatar-size(@avatar-size-lg, @avatar-font-size-lg);
+    }
+
+    &-sm {
+        .avatar-size(@avatar-size-sm, @avatar-font-size-sm);
+    }
+
+    &-square {
+        border-radius: @avatar-border-radius;
+    }
+
+    & > img {
+        display: block;
+        width: 100%;
+        height: 100%;
+        object-fit: cover;
+    }
+}
+
+.avatar-size(@size, @font-size) {
+    width: @size;
+    height: @size;
+    line-height: @size;
+    border-radius: 50%;
+
+    &-string {
+        position: absolute;
+        left: 50%;
+        transform-origin: 0 center;
+    }
+
+    &.@{avatar-prefix-cls}-icon {
+        font-size: @font-size;
+
+        > .@{iconfont-css-prefix} {
+            margin: 0;
+        }
+    }
+}
+
+@import './group';
+@import './rtl';

package/lib/avatar/style/rtl.less

@@ -0,0 +1,15 @@
+.@{avatar-prefix-cls}-group {
+  &-rtl {
+    .@{avatar-prefix-cls}:not(:first-child) {
+      margin-right: @avatar-group-overlapping;
+      margin-left: 0;
+   }
+ }
+
+  &-popover.@{acud-prefix}-popover-rtl {
+    .@{acud-prefix}-avatar + .@{acud-prefix}-avatar {
+      margin-right: @avatar-group-space;
+      margin-left: 0;
+   }
+ }
+}

package/lib/divider/index.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+export interface DividerProps {
+    prefixCls?: string;
+    type?: 'horizontal' | 'vertical';
+    orientation?: 'left' | 'right' | 'center';
+    orientationMargin?: string | number;
+    className?: string;
+    children?: React.ReactNode;
+    dashed?: boolean;
+    style?: React.CSSProperties;
+    plain?: boolean;
+}
+declare const Divider: React.FC<DividerProps>;
+export default Divider;