antd-management-fast-framework 1.1.63 → 1.1.67

package/es/customComponents/ArticleListContent/index.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+require("antd/es/avatar/style");
+
+var _avatar = _interopRequireDefault(require("antd/es/avatar"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _moment = _interopRequireDefault(require("moment"));
+
+var _constants = require("../../utils/constants");
+
+var _index = _interopRequireDefault(require("./index.less"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var ArticleListContent = function ArticleListContent(_ref) {
+  var _ref$data = _ref.data,
+      content = _ref$data.content,
+      updatedAt = _ref$data.updatedAt,
+      avatar = _ref$data.avatar,
+      owner = _ref$data.owner,
+      href = _ref$data.href;
+  return /*#__PURE__*/_react["default"].createElement("div", {
+    className: _index["default"].listContent
+  }, /*#__PURE__*/_react["default"].createElement("div", {
+    className: _index["default"].description
+  }, content), /*#__PURE__*/_react["default"].createElement("div", {
+    className: _index["default"].extra
+  }, /*#__PURE__*/_react["default"].createElement(_avatar["default"], {
+    src: avatar,
+    size: "small"
+  }), /*#__PURE__*/_react["default"].createElement("a", {
+    href: href
+  }, owner), " \u53D1\u5E03\u5728 ", /*#__PURE__*/_react["default"].createElement("a", {
+    href: href
+  }, href), /*#__PURE__*/_react["default"].createElement("em", null, (0, _moment["default"])(updatedAt).format(_constants.datetimeFormat.yearMonthDayHourMinute))));
+};
+
+var _default = ArticleListContent;
+exports["default"] = _default;

package/es/customComponents/Authorized/Authorized.d.ts

@@ -0,0 +1,6 @@
+export default Authorized;
+declare function Authorized({ children, authority, noMatch, }: {
+    children: any;
+    authority: any;
+    noMatch?: JSX.Element | undefined;
+}): JSX.Element;

package/es/customComponents/Authorized/Authorized.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+require("antd/es/result/style");
+
+var _result = _interopRequireDefault(require("antd/es/result"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _CheckPermissions = _interopRequireDefault(require("./CheckPermissions"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var Authorized = function Authorized(_ref) {
+  var children = _ref.children,
+      authority = _ref.authority,
+      _ref$noMatch = _ref.noMatch,
+      noMatch = _ref$noMatch === void 0 ? /*#__PURE__*/_react["default"].createElement(_result["default"], {
+    status: "403",
+    title: "403",
+    subTitle: "Sorry, you are not authorized to access this page."
+  }) : _ref$noMatch;
+  var childrenRender = typeof children === 'undefined' ? null : children;
+  var dom = (0, _CheckPermissions["default"])(authority, childrenRender, noMatch);
+  return /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, null, dom);
+};
+
+var _default = Authorized;
+exports["default"] = _default;

package/es/customComponents/Authorized/AuthorizedRoute.d.ts

@@ -0,0 +1,8 @@
+export default AuthorizedRoute;
+declare function AuthorizedRoute({ component: Component, render, authority, redirectPath, ...rest }: {
+    [x: string]: any;
+    component: any;
+    render: any;
+    authority: any;
+    redirectPath: any;
+}): JSX.Element;

package/es/customComponents/Authorized/AuthorizedRoute.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _umi = require("umi");
+
+var _react = _interopRequireDefault(require("react"));
+
+var _Authorized = _interopRequireDefault(require("./Authorized"));
+
+var _excluded = ["component", "render", "authority", "redirectPath"];
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+var AuthorizedRoute = function AuthorizedRoute(_ref) {
+  var Component = _ref.component,
+      _render = _ref.render,
+      authority = _ref.authority,
+      redirectPath = _ref.redirectPath,
+      rest = _objectWithoutProperties(_ref, _excluded);
+
+  return /*#__PURE__*/_react["default"].createElement(_Authorized["default"], {
+    authority: authority,
+    noMatch: /*#__PURE__*/_react["default"].createElement(_umi.Route, _extends({}, rest, {
+      render: function render() {
+        return /*#__PURE__*/_react["default"].createElement(_umi.Redirect, {
+          to: {
+            pathname: redirectPath
+          }
+        });
+      }
+    }))
+  }, /*#__PURE__*/_react["default"].createElement(_umi.Route, _extends({}, rest, {
+    render: function render(props) {
+      return Component ? /*#__PURE__*/_react["default"].createElement(Component, props) : _render(props);
+    }
+  })));
+};
+
+var _default = AuthorizedRoute;
+exports["default"] = _default;

package/es/customComponents/Authorized/CheckPermissions.d.ts

@@ -0,0 +1,11 @@
+export default check;
+/**
+ * 通用权限检查方法
+ * Common check permissions method
+ * @param { 权限判定 | Permission judgment } authority
+ * @param { 你的权限 | Your permission description } currentAuthority
+ * @param { 通过的组件 | Passing components } target
+ * @param { 未通过的组件 | no pass components } Exception
+ */
+export function checkPermissions(authority: any, currentAuthority: any, target: any, Exception: any): any;
+declare function check(authority: any, target: any, Exception: any): any;

package/es/customComponents/Authorized/CheckPermissions.js

@@ -0,0 +1,106 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.checkPermissions = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _tools = require("../../utils/tools");
+
+var _renderAuthorize = require("./renderAuthorize");
+
+var _PromiseRender = _interopRequireDefault(require("./PromiseRender"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * 通用权限检查方法
+ * Common check permissions method
+ * @param { 权限判定 | Permission judgment } authority
+ * @param { 你的权限 | Your permission description } currentAuthority
+ * @param { 通过的组件 | Passing components } target
+ * @param { 未通过的组件 | no pass components } Exception
+ */
+var checkPermissions = function checkPermissions(authority, currentAuthority, target, Exception) {
+  // 没有判定权限.默认查看所有
+  // Retirement authority, return target;
+  if (!authority) {
+    return target;
+  } // 数组处理
+
+
+  if (Array.isArray(authority)) {
+    if (Array.isArray(currentAuthority)) {
+      if (currentAuthority.some(function (item) {
+        return authority.includes(item);
+      })) {
+        return target;
+      }
+    } else if (authority.includes(currentAuthority)) {
+      return target;
+    }
+
+    return Exception;
+  } // string 处理
+
+
+  if (typeof authority === 'string') {
+    if (Array.isArray(currentAuthority)) {
+      if (currentAuthority.some(function (item) {
+        return authority === item;
+      })) {
+        return target;
+      }
+    } else if (authority === currentAuthority) {
+      return target;
+    }
+
+    return Exception;
+  } // Promise 处理
+
+
+  if (authority instanceof Promise) {
+    return /*#__PURE__*/_react["default"].createElement(_PromiseRender["default"], {
+      ok: target,
+      error: Exception,
+      promise: authority
+    });
+  } // Function 处理
+
+
+  if (typeof authority === 'function') {
+    try {
+      var bool = authority(currentAuthority); // 函数执行后返回值是 Promise
+
+      if (bool instanceof Promise) {
+        return /*#__PURE__*/_react["default"].createElement(_PromiseRender["default"], {
+          ok: target,
+          error: Exception,
+          promise: bool
+        });
+      }
+
+      if (bool) {
+        return target;
+      }
+
+      return Exception;
+    } catch (error) {
+      (0, _tools.recordObject)(error);
+      throw error;
+    }
+  }
+
+  throw new Error('unsupported parameters');
+};
+
+exports.checkPermissions = checkPermissions;
+
+function check(authority, target, Exception) {
+  return checkPermissions(authority, _renderAuthorize.CURRENT, target, Exception);
+}
+
+var _default = check;
+exports["default"] = _default;

package/es/customComponents/Authorized/PromiseRender.d.ts

@@ -0,0 +1,7 @@
+export default class PromiseRender extends React.Component<any, any, any> {
+    constructor(props: any);
+    constructor(props: any, context: any);
+    setRenderComponent(props: any): void;
+    checkIsInstantiation: (target: any) => ((props: any) => JSX.Element) | (() => any);
+}
+import React from "react";

package/es/customComponents/Authorized/PromiseRender.js

@@ -0,0 +1,159 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+require("antd/es/spin/style");
+
+var _spin = _interopRequireDefault(require("antd/es/spin"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _isEqual = _interopRequireDefault(require("lodash/isEqual"));
+
+var _Secured = require("./Secured");
+
+var _excluded = ["ok", "error", "promise"];
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+var PromiseRender = /*#__PURE__*/function (_React$Component) {
+  _inherits(PromiseRender, _React$Component);
+
+  var _super = _createSuper(PromiseRender);
+
+  function PromiseRender() {
+    var _this;
+
+    _classCallCheck(this, PromiseRender);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _super.call.apply(_super, [this].concat(args));
+    _this.state = {
+      component: function component() {
+        return null;
+      }
+    };
+
+    _this.shouldComponentUpdate = function (nextProps, nextState) {
+      var component = _this.state.component;
+
+      if (!(0, _isEqual["default"])(nextProps, _this.props)) {
+        _this.setRenderComponent(nextProps);
+      }
+
+      if (nextState.component !== component) return true;
+      return false;
+    };
+
+    _this.checkIsInstantiation = function (target) {
+      if ((0, _Secured.isComponentClass)(target)) {
+        var Target = target;
+        return function (props) {
+          return /*#__PURE__*/_react["default"].createElement(Target, props);
+        };
+      }
+
+      if ( /*#__PURE__*/_react["default"].isValidElement(target)) {
+        return function (props) {
+          return /*#__PURE__*/_react["default"].cloneElement(target, props);
+        };
+      }
+
+      return function () {
+        return target;
+      };
+    };
+
+    return _this;
+  }
+
+  _createClass(PromiseRender, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this.setRenderComponent(this.props);
+    }
+  }, {
+    key: "setRenderComponent",
+    value: // set render Component : ok or error
+    function setRenderComponent(props) {
+      var _this2 = this;
+
+      var ok = this.checkIsInstantiation(props.ok);
+      var error = this.checkIsInstantiation(props.error);
+      props.promise.then(function () {
+        _this2.setState({
+          component: ok
+        });
+
+        return true;
+      })["catch"](function () {
+        _this2.setState({
+          component: error
+        });
+      });
+    } // Determine whether the incoming component has been instantiated
+    // AuthorizedRoute is already instantiated
+    // Authorized  render is already instantiated, children is no instantiated
+    // Secured is not instantiated
+
+  }, {
+    key: "render",
+    value: function render() {
+      var Component = this.state.component;
+
+      var _this$props = this.props,
+          ok = _this$props.ok,
+          error = _this$props.error,
+          promise = _this$props.promise,
+          rest = _objectWithoutProperties(_this$props, _excluded);
+
+      return Component ? /*#__PURE__*/_react["default"].createElement(Component, rest) : /*#__PURE__*/_react["default"].createElement("div", {
+        style: {
+          width: '100%',
+          height: '100%',
+          margin: 'auto',
+          paddingTop: 50,
+          textAlign: 'center'
+        }
+      }, /*#__PURE__*/_react["default"].createElement(_spin["default"], {
+        size: "large"
+      }));
+    }
+  }]);
+
+  return PromiseRender;
+}(_react["default"].Component);
+
+exports["default"] = PromiseRender;

package/es/customComponents/Authorized/Secured.d.ts

@@ -0,0 +1,18 @@
+export function isComponentClass(component: any): any;
+export default authorize;
+/**
+ * 用于判断是否拥有权限访问此 view 权限
+ * authority 支持传入 string, () => boolean | Promise
+ * e.g. 'user' 只有 user 用户能访问
+ * e.g. 'user,admin' user 和 admin 都能访问
+ * e.g. ()=>boolean 返回true能访问,返回false不能访问
+ * e.g. Promise  then 能访问   catch不能访问
+ * e.g. authority support incoming string, () => boolean | Promise
+ * e.g. 'user' only user user can access
+ * e.g. 'user, admin' user and admin can access
+ * e.g. () => boolean true to be able to visit, return false can not be accessed
+ * e.g. Promise then can not access the visit to catch
+ * @param {string | function | Promise} authority
+ * @param {ReactNode} error 非必需参数
+ */
+declare function authorize(authority: string | Function | Promise<any>, error: any): (target: any) => ((props: any) => JSX.Element) | (() => any);

package/{src/customComponents/Authorized/Secured.jsx → es/customComponents/Authorized/Secured.js}

@@ -1,35 +1,54 @@
-import React from 'react';
+"use strict";
 
-import CheckPermissions from './CheckPermissions';
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.isComponentClass = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _CheckPermissions = _interopRequireDefault(require("./CheckPermissions"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
 
 /**
  * 默认不能访问任何页面
  * default is "NULL"
  */
+var Exception403 = function Exception403() {
+  return 403;
+};
 
-const Exception403 = () => 403;
-
-export const isComponentClass = (component) => {
+var isComponentClass = function isComponentClass(component) {
   if (!component) return false;
-  const proto = Object.getPrototypeOf(component);
-  if (proto === React.Component || proto === Function.prototype) return true;
+  var proto = Object.getPrototypeOf(component);
+  if (proto === _react["default"].Component || proto === Function.prototype) return true;
   return isComponentClass(proto);
 }; // Determine whether the incoming component has been instantiated
 // AuthorizedRoute is already instantiated
 // Authorized  render is already instantiated, children is no instantiated
 // Secured is not instantiated
 
-const checkIsInstantiation = (target) => {
+
+exports.isComponentClass = isComponentClass;
+
+var checkIsInstantiation = function checkIsInstantiation(target) {
   if (isComponentClass(target)) {
-    const Target = target;
-    return (props) => <Target {...props} />;
+    var Target = target;
+    return function (props) {
+      return /*#__PURE__*/_react["default"].createElement(Target, props);
+    };
   }
 
-  if (React.isValidElement(target)) {
-    return (props) => React.cloneElement(target, props);
+  if ( /*#__PURE__*/_react["default"].isValidElement(target)) {
+    return function (props) {
+      return /*#__PURE__*/_react["default"].cloneElement(target, props);
+    };
   }
 
-  return () => target;
+  return function () {
+    return target;
+  };
 };
 /**
  * 用于判断是否拥有权限访问此 view 权限
@@ -47,16 +66,19 @@ const checkIsInstantiation = (target) => {
  * @param {ReactNode} error 非必需参数
  */
 
-const authorize = (authority, error) => {
+
+var authorize = function authorize(authority, error) {
   /**
    * conversion into a class
    * 防止传入字符串时找不到staticContext造成报错
    * String parameters can cause staticContext not found error
    */
-  let classError = false;
+  var classError = false;
 
   if (error) {
-    classError = () => error;
+    classError = function classError() {
+      return error;
+    };
   }
 
   if (!authority) {
@@ -64,13 +86,10 @@ const authorize = (authority, error) => {
   }
 
   return function decideAuthority(target) {
-    const component = CheckPermissions(
-      authority,
-      target,
-      classError || Exception403,
-    );
+    var component = (0, _CheckPermissions["default"])(authority, target, classError || Exception403);
     return checkIsInstantiation(component);
   };
 };
 
-export default authorize;
+var _default = authorize;
+exports["default"] = _default;

package/es/customComponents/Authorized/index.d.ts

@@ -0,0 +1,2 @@
+export default RenderAuthorize;
+declare const RenderAuthorize: (currentAuthority: any) => any;

package/es/customComponents/Authorized/index.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _Authorized = _interopRequireDefault(require("./Authorized"));
+
+var _Secured = _interopRequireDefault(require("./Secured"));
+
+var _CheckPermissions = _interopRequireDefault(require("./CheckPermissions"));
+
+var _renderAuthorize = _interopRequireDefault(require("./renderAuthorize"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+_Authorized["default"].Secured = _Secured["default"];
+_Authorized["default"].check = _CheckPermissions["default"];
+var RenderAuthorize = (0, _renderAuthorize["default"])(_Authorized["default"]);
+var _default = RenderAuthorize;
+exports["default"] = _default;

package/es/customComponents/Authorized/renderAuthorize.d.ts

@@ -0,0 +1,3 @@
+declare function _default(Authorized: any): (currentAuthority: any) => any;
+export default _default;
+export let CURRENT: string;

package/es/customComponents/Authorized/renderAuthorize.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.CURRENT = void 0;
+var CURRENT = 'NULL';
+/**
+ * use  authority or getAuthority
+ * @param {string|()=>String} currentAuthority
+ */
+
+exports.CURRENT = CURRENT;
+
+var renderAuthorize = function renderAuthorize(Authorized) {
+  return function (currentAuthority) {
+    if (currentAuthority) {
+      if (typeof currentAuthority === 'function') {
+        exports.CURRENT = CURRENT = currentAuthority();
+      }
+
+      if (Object.prototype.toString.call(currentAuthority) === '[object String]' || Array.isArray(currentAuthority)) {
+        exports.CURRENT = CURRENT = currentAuthority;
+      }
+    } else {
+      exports.CURRENT = CURRENT = 'NULL';
+    }
+
+    return Authorized;
+  };
+};
+
+var _default = function _default(Authorized) {
+  return renderAuthorize(Authorized);
+};
+
+exports["default"] = _default;

package/es/customComponents/AvatarList/index.d.ts

@@ -0,0 +1,17 @@
+export default AvatarList;
+declare function AvatarList({ children, size, maxLength, excessItemsStyle, ...other }: {
+    [x: string]: any;
+    children: any;
+    size: any;
+    maxLength: any;
+    excessItemsStyle: any;
+}): JSX.Element;
+declare namespace AvatarList {
+    export { Item };
+}
+declare function Item({ src, size, tips, onClick }: {
+    src: any;
+    size: any;
+    tips: any;
+    onClick?: (() => void) | undefined;
+}): JSX.Element;