Latest updates from IceHrmPro

web/node_modules/antd/es/list/Item.d.ts

@@ -0,0 +1,35 @@
+import * as React from 'react';
+import * as PropTypes from 'prop-types';
+import { ListGridType } from './index';
+import { ConfigConsumerProps } from '../config-provider';
+export interface ListItemProps extends React.HTMLAttributes<HTMLDivElement> {
+    className?: string;
+    children?: React.ReactNode;
+    prefixCls?: string;
+    style?: React.CSSProperties;
+    extra?: React.ReactNode;
+    actions?: React.ReactNode[];
+    grid?: ListGridType;
+}
+export interface ListItemMetaProps {
+    avatar?: React.ReactNode;
+    className?: string;
+    children?: React.ReactNode;
+    description?: React.ReactNode;
+    prefixCls?: string;
+    style?: React.CSSProperties;
+    title?: React.ReactNode;
+}
+export declare const Meta: (props: ListItemMetaProps) => JSX.Element;
+export default class Item extends React.Component<ListItemProps, any> {
+    static Meta: typeof Meta;
+    static contextTypes: {
+        grid: PropTypes.Requireable<any>;
+        itemLayout: PropTypes.Requireable<string>;
+    };
+    context: any;
+    isItemContainsTextNodeAndNotSingular(): undefined;
+    isFlexMode(): boolean;
+    renderItem: ({ getPrefixCls }: ConfigConsumerProps) => JSX.Element;
+    render(): JSX.Element;
+}

web/node_modules/antd/es/list/Item.js

@@ -0,0 +1,185 @@
+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); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+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) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct()) { 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; } 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 { Date.prototype.toString.call(Reflect.construct(Date, [], 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); }
+
+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); }
+
+var __rest = this && this.__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;
+};
+
+import * as React from 'react';
+import * as PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { Col } from '../grid';
+import { ConfigConsumer } from '../config-provider';
+import { cloneElement } from '../_util/reactNode';
+export var Meta = function Meta(props) {
+  return /*#__PURE__*/React.createElement(ConfigConsumer, null, function (_ref) {
+    var getPrefixCls = _ref.getPrefixCls;
+
+    var customizePrefixCls = props.prefixCls,
+        className = props.className,
+        avatar = props.avatar,
+        title = props.title,
+        description = props.description,
+        others = __rest(props, ["prefixCls", "className", "avatar", "title", "description"]);
+
+    var prefixCls = getPrefixCls('list', customizePrefixCls);
+    var classString = classNames("".concat(prefixCls, "-item-meta"), className);
+    var content = /*#__PURE__*/React.createElement("div", {
+      className: "".concat(prefixCls, "-item-meta-content")
+    }, title && /*#__PURE__*/React.createElement("h4", {
+      className: "".concat(prefixCls, "-item-meta-title")
+    }, title), description && /*#__PURE__*/React.createElement("div", {
+      className: "".concat(prefixCls, "-item-meta-description")
+    }, description));
+    return /*#__PURE__*/React.createElement("div", _extends({}, others, {
+      className: classString
+    }), avatar && /*#__PURE__*/React.createElement("div", {
+      className: "".concat(prefixCls, "-item-meta-avatar")
+    }, avatar), (title || description) && content);
+  });
+};
+
+function getGrid(grid, t) {
+  return grid[t] && Math.floor(24 / grid[t]);
+}
+
+var Item = /*#__PURE__*/function (_React$Component) {
+  _inherits(Item, _React$Component);
+
+  var _super = _createSuper(Item);
+
+  function Item() {
+    var _this;
+
+    _classCallCheck(this, Item);
+
+    _this = _super.apply(this, arguments);
+
+    _this.renderItem = function (_ref2) {
+      var getPrefixCls = _ref2.getPrefixCls;
+      var _this$context = _this.context,
+          grid = _this$context.grid,
+          itemLayout = _this$context.itemLayout;
+
+      var _a = _this.props,
+          customizePrefixCls = _a.prefixCls,
+          children = _a.children,
+          actions = _a.actions,
+          extra = _a.extra,
+          className = _a.className,
+          others = __rest(_a, ["prefixCls", "children", "actions", "extra", "className"]);
+
+      var prefixCls = getPrefixCls('list', customizePrefixCls);
+      var actionsContent = actions && actions.length > 0 && /*#__PURE__*/React.createElement("ul", {
+        className: "".concat(prefixCls, "-item-action"),
+        key: "actions"
+      }, actions.map(function (action, i) {
+        return (
+          /*#__PURE__*/
+          // eslint-disable-next-line react/no-array-index-key
+          React.createElement("li", {
+            key: "".concat(prefixCls, "-item-action-").concat(i)
+          }, action, i !== actions.length - 1 && /*#__PURE__*/React.createElement("em", {
+            className: "".concat(prefixCls, "-item-action-split")
+          }))
+        );
+      }));
+      var Tag = grid ? 'div' : 'li';
+      var itemChildren = /*#__PURE__*/React.createElement(Tag, _extends({}, others, {
+        // `li` element `onCopy` prop args is not same as `div`
+        className: classNames("".concat(prefixCls, "-item"), className, _defineProperty({}, "".concat(prefixCls, "-item-no-flex"), !_this.isFlexMode()))
+      }), itemLayout === 'vertical' && extra ? [/*#__PURE__*/React.createElement("div", {
+        className: "".concat(prefixCls, "-item-main"),
+        key: "content"
+      }, children, actionsContent), /*#__PURE__*/React.createElement("div", {
+        className: "".concat(prefixCls, "-item-extra"),
+        key: "extra"
+      }, extra)] : [children, actionsContent, cloneElement(extra, {
+        key: 'extra'
+      })]);
+      return grid ? /*#__PURE__*/React.createElement(Col, {
+        span: getGrid(grid, 'column'),
+        xs: getGrid(grid, 'xs'),
+        sm: getGrid(grid, 'sm'),
+        md: getGrid(grid, 'md'),
+        lg: getGrid(grid, 'lg'),
+        xl: getGrid(grid, 'xl'),
+        xxl: getGrid(grid, 'xxl')
+      }, itemChildren) : itemChildren;
+    };
+
+    return _this;
+  }
+
+  _createClass(Item, [{
+    key: "isItemContainsTextNodeAndNotSingular",
+    value: function isItemContainsTextNodeAndNotSingular() {
+      var children = this.props.children;
+      var result;
+      React.Children.forEach(children, function (element) {
+        if (typeof element === 'string') {
+          result = true;
+        }
+      });
+      return result && React.Children.count(children) > 1;
+    }
+  }, {
+    key: "isFlexMode",
+    value: function isFlexMode() {
+      var extra = this.props.extra;
+      var itemLayout = this.context.itemLayout;
+
+      if (itemLayout === 'vertical') {
+        return !!extra;
+      }
+
+      return !this.isItemContainsTextNodeAndNotSingular();
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/React.createElement(ConfigConsumer, null, this.renderItem);
+    }
+  }]);
+
+  return Item;
+}(React.Component);
+
+export { Item as default };
+Item.Meta = Meta;
+Item.contextTypes = {
+  grid: PropTypes.any,
+  itemLayout: PropTypes.string
+};

web/node_modules/antd/es/list/index.d.ts

@@ -0,0 +1,82 @@
+import * as React from 'react';
+import * as PropTypes from 'prop-types';
+import { SpinProps } from '../spin';
+import { ConfigConsumerProps } from '../config-provider';
+import { PaginationConfig } from '../pagination';
+import Item from './Item';
+export { ListItemProps, ListItemMetaProps } from './Item';
+export declare type ColumnCount = 1 | 2 | 3 | 4 | 6 | 8 | 12 | 24;
+export declare type ColumnType = 'gutter' | 'column' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
+export interface ListGridType {
+    gutter?: number;
+    column?: ColumnCount;
+    xs?: ColumnCount;
+    sm?: ColumnCount;
+    md?: ColumnCount;
+    lg?: ColumnCount;
+    xl?: ColumnCount;
+    xxl?: ColumnCount;
+}
+export declare type ListSize = 'small' | 'default' | 'large';
+export declare type ListItemLayout = 'horizontal' | 'vertical';
+export interface ListProps<T> {
+    bordered?: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+    children?: React.ReactNode;
+    dataSource?: T[];
+    extra?: React.ReactNode;
+    grid?: ListGridType;
+    id?: string;
+    itemLayout?: ListItemLayout;
+    loading?: boolean | SpinProps;
+    loadMore?: React.ReactNode;
+    pagination?: PaginationConfig | false;
+    prefixCls?: string;
+    rowKey?: ((item: T) => string) | string;
+    renderItem?: (item: T, index: number) => React.ReactNode;
+    size?: ListSize;
+    split?: boolean;
+    header?: React.ReactNode;
+    footer?: React.ReactNode;
+    locale?: ListLocale;
+}
+export interface ListLocale {
+    emptyText: React.ReactNode | (() => React.ReactNode);
+}
+interface ListState {
+    paginationCurrent: number;
+    paginationSize: number;
+}
+export default class List<T> extends React.Component<ListProps<T>, ListState> {
+    static Item: typeof Item;
+    static childContextTypes: {
+        grid: PropTypes.Requireable<any>;
+        itemLayout: PropTypes.Requireable<string>;
+    };
+    static defaultProps: {
+        dataSource: never[];
+        bordered: boolean;
+        split: boolean;
+        loading: boolean;
+        pagination: false | PaginationConfig | undefined;
+    };
+    defaultPaginationProps: {
+        current: number;
+        total: number;
+    };
+    private keys;
+    private onPaginationChange;
+    private onPaginationShowSizeChange;
+    constructor(props: ListProps<T>);
+    getChildContext(): {
+        grid: ListGridType | undefined;
+        itemLayout: "horizontal" | "vertical" | undefined;
+    };
+    triggerPaginationEvent(eventName: string): (page: number, pageSize: number) => void;
+    renderItem: (item: any, index: number) => {} | null | undefined;
+    isSomethingAfterLastItem(): boolean;
+    renderEmpty: (prefixCls: string, renderEmpty: (componentName?: string | undefined) => React.ReactNode) => JSX.Element;
+    renderList: ({ getPrefixCls, renderEmpty, direction }: ConfigConsumerProps) => JSX.Element;
+    render(): JSX.Element;
+}

web/node_modules/antd/es/list/index.js

@@ -0,0 +1,297 @@
+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); }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(n); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+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 _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+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) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct()) { 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; } 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 { Date.prototype.toString.call(Reflect.construct(Date, [], 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 __rest = this && this.__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;
+};
+
+import * as React from 'react';
+import * as PropTypes from 'prop-types';
+import classNames from 'classnames';
+import omit from 'omit.js';
+import Spin from '../spin';
+import { ConfigConsumer } from '../config-provider';
+import Pagination from '../pagination';
+import { Row } from '../grid';
+import Item from './Item';
+
+var List = /*#__PURE__*/function (_React$Component) {
+  _inherits(List, _React$Component);
+
+  var _super = _createSuper(List);
+
+  function List(props) {
+    var _this;
+
+    _classCallCheck(this, List);
+
+    _this = _super.call(this, props);
+    _this.defaultPaginationProps = {
+      current: 1,
+      total: 0
+    };
+    _this.keys = {};
+    _this.onPaginationChange = _this.triggerPaginationEvent('onChange');
+    _this.onPaginationShowSizeChange = _this.triggerPaginationEvent('onShowSizeChange');
+
+    _this.renderItem = function (item, index) {
+      var _this$props = _this.props,
+          renderItem = _this$props.renderItem,
+          rowKey = _this$props.rowKey;
+      if (!renderItem) return null;
+      var key;
+
+      if (typeof rowKey === 'function') {
+        key = rowKey(item);
+      } else if (typeof rowKey === 'string') {
+        key = item[rowKey];
+      } else {
+        key = item.key;
+      }
+
+      if (!key) {
+        key = "list-item-".concat(index);
+      }
+
+      _this.keys[index] = key;
+      return renderItem(item, index);
+    };
+
+    _this.renderEmpty = function (prefixCls, renderEmpty) {
+      var locale = _this.props.locale;
+      return /*#__PURE__*/React.createElement("div", {
+        className: "".concat(prefixCls, "-empty-text")
+      }, locale && locale.emptyText || renderEmpty('List'));
+    };
+
+    _this.renderList = function (_ref) {
+      var _classNames;
+
+      var getPrefixCls = _ref.getPrefixCls,
+          renderEmpty = _ref.renderEmpty,
+          direction = _ref.direction;
+      var _this$state = _this.state,
+          paginationCurrent = _this$state.paginationCurrent,
+          paginationSize = _this$state.paginationSize;
+
+      var _a = _this.props,
+          customizePrefixCls = _a.prefixCls,
+          bordered = _a.bordered,
+          split = _a.split,
+          className = _a.className,
+          children = _a.children,
+          itemLayout = _a.itemLayout,
+          loadMore = _a.loadMore,
+          pagination = _a.pagination,
+          grid = _a.grid,
+          _a$dataSource = _a.dataSource,
+          dataSource = _a$dataSource === void 0 ? [] : _a$dataSource,
+          size = _a.size,
+          header = _a.header,
+          footer = _a.footer,
+          loading = _a.loading,
+          rest = __rest(_a, ["prefixCls", "bordered", "split", "className", "children", "itemLayout", "loadMore", "pagination", "grid", "dataSource", "size", "header", "footer", "loading"]);
+
+      var prefixCls = getPrefixCls('list', customizePrefixCls);
+      var loadingProp = loading;
+
+      if (typeof loadingProp === 'boolean') {
+        loadingProp = {
+          spinning: loadingProp
+        };
+      }
+
+      var isLoading = loadingProp && loadingProp.spinning; // large => lg
+      // small => sm
+
+      var sizeCls = '';
+
+      switch (size) {
+        case 'large':
+          sizeCls = 'lg';
+          break;
+
+        case 'small':
+          sizeCls = 'sm';
+          break;
+
+        default:
+          break;
+      }
+
+      var classString = classNames(prefixCls, className, (_classNames = {}, _defineProperty(_classNames, "".concat(prefixCls, "-vertical"), itemLayout === 'vertical'), _defineProperty(_classNames, "".concat(prefixCls, "-").concat(sizeCls), sizeCls), _defineProperty(_classNames, "".concat(prefixCls, "-split"), split), _defineProperty(_classNames, "".concat(prefixCls, "-bordered"), bordered), _defineProperty(_classNames, "".concat(prefixCls, "-loading"), isLoading), _defineProperty(_classNames, "".concat(prefixCls, "-grid"), grid), _defineProperty(_classNames, "".concat(prefixCls, "-something-after-last-item"), _this.isSomethingAfterLastItem()), _defineProperty(_classNames, "".concat(prefixCls, "-rtl"), direction === 'rtl'), _classNames));
+
+      var paginationProps = _extends(_extends(_extends({}, _this.defaultPaginationProps), {
+        total: dataSource.length,
+        current: paginationCurrent,
+        pageSize: paginationSize
+      }), pagination || {});
+
+      var largestPage = Math.ceil(paginationProps.total / paginationProps.pageSize);
+
+      if (paginationProps.current > largestPage) {
+        paginationProps.current = largestPage;
+      }
+
+      var paginationContent = pagination ? /*#__PURE__*/React.createElement("div", {
+        className: "".concat(prefixCls, "-pagination")
+      }, /*#__PURE__*/React.createElement(Pagination, _extends({}, paginationProps, {
+        onChange: _this.onPaginationChange,
+        onShowSizeChange: _this.onPaginationShowSizeChange
+      }))) : null;
+
+      var splitDataSource = _toConsumableArray(dataSource);
+
+      if (pagination) {
+        if (dataSource.length > (paginationProps.current - 1) * paginationProps.pageSize) {
+          splitDataSource = _toConsumableArray(dataSource).splice((paginationProps.current - 1) * paginationProps.pageSize, paginationProps.pageSize);
+        }
+      }
+
+      var childrenContent;
+      childrenContent = isLoading && /*#__PURE__*/React.createElement("div", {
+        style: {
+          minHeight: 53
+        }
+      });
+
+      if (splitDataSource.length > 0) {
+        var items = splitDataSource.map(function (item, index) {
+          return _this.renderItem(item, index);
+        });
+        var childrenList = [];
+        React.Children.forEach(items, function (child, index) {
+          childrenList.push(React.cloneElement(child, {
+            key: _this.keys[index]
+          }));
+        });
+        childrenContent = grid ? /*#__PURE__*/React.createElement(Row, {
+          gutter: grid.gutter
+        }, childrenList) : /*#__PURE__*/React.createElement("ul", {
+          className: "".concat(prefixCls, "-items")
+        }, childrenList);
+      } else if (!children && !isLoading) {
+        childrenContent = _this.renderEmpty(prefixCls, renderEmpty);
+      }
+
+      var paginationPosition = paginationProps.position || 'bottom';
+      return /*#__PURE__*/React.createElement("div", _extends({
+        className: classString
+      }, omit(rest, ['rowKey', 'renderItem', 'locale'])), (paginationPosition === 'top' || paginationPosition === 'both') && paginationContent, header && /*#__PURE__*/React.createElement("div", {
+        className: "".concat(prefixCls, "-header")
+      }, header), /*#__PURE__*/React.createElement(Spin, loadingProp, childrenContent, children), footer && /*#__PURE__*/React.createElement("div", {
+        className: "".concat(prefixCls, "-footer")
+      }, footer), loadMore || (paginationPosition === 'bottom' || paginationPosition === 'both') && paginationContent);
+    };
+
+    var pagination = props.pagination;
+    var paginationObj = pagination && _typeof(pagination) === 'object' ? pagination : {};
+    _this.state = {
+      paginationCurrent: paginationObj.defaultCurrent || 1,
+      paginationSize: paginationObj.defaultPageSize || 10
+    };
+    return _this;
+  }
+
+  _createClass(List, [{
+    key: "getChildContext",
+    value: function getChildContext() {
+      return {
+        grid: this.props.grid,
+        itemLayout: this.props.itemLayout
+      };
+    }
+  }, {
+    key: "triggerPaginationEvent",
+    value: function triggerPaginationEvent(eventName) {
+      var _this2 = this;
+
+      return function (page, pageSize) {
+        var pagination = _this2.props.pagination;
+
+        _this2.setState({
+          paginationCurrent: page,
+          paginationSize: pageSize
+        });
+
+        if (pagination && pagination[eventName]) {
+          pagination[eventName](page, pageSize);
+        }
+      };
+    }
+  }, {
+    key: "isSomethingAfterLastItem",
+    value: function isSomethingAfterLastItem() {
+      var _this$props2 = this.props,
+          loadMore = _this$props2.loadMore,
+          pagination = _this$props2.pagination,
+          footer = _this$props2.footer;
+      return !!(loadMore || pagination || footer);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/React.createElement(ConfigConsumer, null, this.renderList);
+    }
+  }]);
+
+  return List;
+}(React.Component);
+
+export { List as default };
+List.Item = Item;
+List.childContextTypes = {
+  grid: PropTypes.any,
+  itemLayout: PropTypes.string
+};
+List.defaultProps = {
+  dataSource: [],
+  bordered: false,
+  split: true,
+  loading: false,
+  pagination: false
+};

web/node_modules/antd/es/list/style/bordered.less

@@ -0,0 +1,44 @@
+@import '../../style/themes/index';
+
+.@{list-prefix-cls}-bordered {
+  border: 1px solid @border-color-base;
+  border-radius: @border-radius-base;
+  .@{list-prefix-cls}-header {
+    padding-right: @padding-lg;
+    padding-left: @padding-lg;
+  }
+
+  .@{list-prefix-cls}-footer {
+    padding-right: @padding-lg;
+    padding-left: @padding-lg;
+  }
+
+  .@{list-prefix-cls}-item {
+    padding-right: @padding-lg;
+    padding-left: @padding-lg;
+  }
+
+  .@{list-prefix-cls}-pagination {
+    margin: @margin-md @margin-lg;
+  }
+
+  &.@{list-prefix-cls}-sm {
+    .@{list-prefix-cls}-item {
+      padding: @list-item-padding-sm;
+    }
+    .@{list-prefix-cls}-header,
+    .@{list-prefix-cls}-footer {
+      padding: @list-item-padding-sm;
+    }
+  }
+
+  &.@{list-prefix-cls}-lg {
+    .@{list-prefix-cls}-item {
+      padding: @list-item-padding-lg;
+    }
+    .@{list-prefix-cls}-header,
+    .@{list-prefix-cls}-footer {
+      padding: @list-item-padding-lg;
+    }
+  }
+}

web/node_modules/antd/es/list/style/css.js

@@ -0,0 +1,7 @@
+import '../../style/index.css';
+import './index.css'; // style dependencies
+
+import '../../empty/style/css';
+import '../../spin/style/css';
+import '../../pagination/style/css';
+import '../../grid/style/css';

web/node_modules/antd/es/list/style/customize.less

@@ -0,0 +1,12 @@
+@import './index.less';
+
+@card-prefix-cls: ~'@{ant-prefix}-card';
+
+.@{list-prefix-cls} {
+  // =================== Dard Hook Components ===================
+  .@{card-prefix-cls} {
+    & when (@theme = dark) {
+      background: @list-customize-card-bg;
+    }
+  }
+}

web/node_modules/antd/es/list/style/index.css

@@ -0,0 +1,343 @@
+/* stylelint-disable at-rule-empty-line-before,at-rule-name-space-after,at-rule-no-unknown */
+/* stylelint-disable no-duplicate-selectors */
+/* stylelint-disable */
+/* stylelint-disable declaration-bang-space-before,no-duplicate-selectors,string-no-newline */
+.ant-list {
+  -webkit-box-sizing: border-box;
+          box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+  color: rgba(0, 0, 0, 0.65);
+  font-size: 14px;
+  font-variant: tabular-nums;
+  line-height: 1.5715;
+  list-style: none;
+  -webkit-font-feature-settings: 'tnum';
+          font-feature-settings: 'tnum';
+  position: relative;
+}
+.ant-list * {
+  outline: none;
+}
+.ant-list-pagination {
+  margin-top: 24px;
+  text-align: right;
+}
+.ant-list-pagination .ant-pagination-options {
+  text-align: left;
+}
+.ant-list-more {
+  margin-top: 12px;
+  text-align: center;
+}
+.ant-list-more button {
+  padding-right: 32px;
+  padding-left: 32px;
+}
+.ant-list-spin {
+  min-height: 40px;
+  text-align: center;
+}
+.ant-list-empty-text {
+  padding: 16px;
+  color: rgba(0, 0, 0, 0.25);
+  font-size: 14px;
+  text-align: center;
+}
+.ant-list-items {
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+.ant-list-item {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -webkit-box-align: center;
+      -ms-flex-align: center;
+          align-items: center;
+  -webkit-box-pack: justify;
+      -ms-flex-pack: justify;
+          justify-content: space-between;
+  padding: 12px 0;
+}
+.ant-list-item-content {
+  color: rgba(0, 0, 0, 0.65);
+}
+.ant-list-item-meta {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -webkit-box-flex: 1;
+      -ms-flex: 1;
+          flex: 1;
+  -webkit-box-align: start;
+      -ms-flex-align: start;
+          align-items: flex-start;
+  font-size: 0;
+}
+.ant-list-item-meta-avatar {
+  margin-right: 16px;
+}
+.ant-list-item-meta-content {
+  -webkit-box-flex: 1;
+      -ms-flex: 1 0;
+          flex: 1 0;
+}
+.ant-list-item-meta-title {
+  margin-bottom: 4px;
+  color: rgba(0, 0, 0, 0.65);
+  font-size: 14px;
+  line-height: 22px;
+}
+.ant-list-item-meta-title > a {
+  color: rgba(0, 0, 0, 0.65);
+  -webkit-transition: all 0.3s;
+  transition: all 0.3s;
+}
+.ant-list-item-meta-title > a:hover {
+  color: #1890ff;
+}
+.ant-list-item-meta-description {
+  color: rgba(0, 0, 0, 0.45);
+  font-size: 14px;
+  line-height: 22px;
+}
+.ant-list-item-action {
+  -webkit-box-flex: 0;
+      -ms-flex: 0 0 auto;
+          flex: 0 0 auto;
+  margin-left: 48px;
+  padding: 0;
+  font-size: 0;
+  list-style: none;
+}
+.ant-list-item-action > li {
+  position: relative;
+  display: inline-block;
+  padding: 0 8px;
+  color: rgba(0, 0, 0, 0.45);
+  font-size: 14px;
+  line-height: 22px;
+  text-align: center;
+  cursor: pointer;
+}
+.ant-list-item-action > li:first-child {
+  padding-left: 0;
+}
+.ant-list-item-action-split {
+  position: absolute;
+  top: 50%;
+  right: 0;
+  width: 1px;
+  height: 14px;
+  margin-top: -7px;
+  background-color: #f0f0f0;
+}
+.ant-list-header {
+  background: transparent;
+}
+.ant-list-footer {
+  background: transparent;
+}
+.ant-list-header,
+.ant-list-footer {
+  padding-top: 12px;
+  padding-bottom: 12px;
+}
+.ant-list-empty {
+  padding: 16px 0;
+  color: rgba(0, 0, 0, 0.45);
+  font-size: 12px;
+  text-align: center;
+}
+.ant-list-split .ant-list-item {
+  border-bottom: 1px solid #f0f0f0;
+}
+.ant-list-split .ant-list-item:last-child {
+  border-bottom: none;
+}
+.ant-list-split .ant-list-header {
+  border-bottom: 1px solid #f0f0f0;
+}
+.ant-list-split.ant-list-empty .ant-list-footer {
+  border-top: 1px solid #f0f0f0;
+}
+.ant-list-loading .ant-list-spin-nested-loading {
+  min-height: 32px;
+}
+.ant-list-split.ant-list-something-after-last-item .ant-spin-container > .ant-list-items > .ant-list-item:last-child {
+  border-bottom: 1px solid #f0f0f0;
+}
+.ant-list-lg .ant-list-item {
+  padding: 16px 24px;
+}
+.ant-list-sm .ant-list-item {
+  padding: 8px 16px;
+}
+.ant-list-vertical .ant-list-item {
+  -webkit-box-align: initial;
+      -ms-flex-align: initial;
+          align-items: initial;
+}
+.ant-list-vertical .ant-list-item-main {
+  display: block;
+  -webkit-box-flex: 1;
+      -ms-flex: 1;
+          flex: 1;
+}
+.ant-list-vertical .ant-list-item-extra {
+  margin-left: 40px;
+}
+.ant-list-vertical .ant-list-item-meta {
+  margin-bottom: 16px;
+}
+.ant-list-vertical .ant-list-item-meta-title {
+  margin-bottom: 12px;
+  color: rgba(0, 0, 0, 0.85);
+  font-size: 16px;
+  line-height: 24px;
+}
+.ant-list-vertical .ant-list-item-action {
+  margin-top: 16px;
+  margin-left: auto;
+}
+.ant-list-vertical .ant-list-item-action > li {
+  padding: 0 16px;
+}
+.ant-list-vertical .ant-list-item-action > li:first-child {
+  padding-left: 0;
+}
+.ant-list-grid .ant-col > .ant-list-item {
+  display: block;
+  max-width: 100%;
+  margin-bottom: 16px;
+  padding-top: 0;
+  padding-bottom: 0;
+  border-bottom: none;
+}
+.ant-list-item-no-flex {
+  display: block;
+}
+.ant-list:not(.ant-list-vertical) .ant-list-item-no-flex .ant-list-item-action {
+  float: right;
+}
+.ant-list-bordered {
+  border: 1px solid #d9d9d9;
+  border-radius: 2px;
+}
+.ant-list-bordered .ant-list-header {
+  padding-right: 24px;
+  padding-left: 24px;
+}
+.ant-list-bordered .ant-list-footer {
+  padding-right: 24px;
+  padding-left: 24px;
+}
+.ant-list-bordered .ant-list-item {
+  padding-right: 24px;
+  padding-left: 24px;
+}
+.ant-list-bordered .ant-list-pagination {
+  margin: 16px 24px;
+}
+.ant-list-bordered.ant-list-sm .ant-list-item {
+  padding: 8px 16px;
+}
+.ant-list-bordered.ant-list-sm .ant-list-header,
+.ant-list-bordered.ant-list-sm .ant-list-footer {
+  padding: 8px 16px;
+}
+.ant-list-bordered.ant-list-lg .ant-list-item {
+  padding: 16px 24px;
+}
+.ant-list-bordered.ant-list-lg .ant-list-header,
+.ant-list-bordered.ant-list-lg .ant-list-footer {
+  padding: 16px 24px;
+}
+@media screen and (max-width: 768px) {
+  .ant-list-item-action {
+    margin-left: 24px;
+  }
+  .ant-list-vertical .ant-list-item-extra {
+    margin-left: 24px;
+  }
+}
+@media screen and (max-width: 576px) {
+  .ant-list-item {
+    -ms-flex-wrap: wrap;
+        flex-wrap: wrap;
+  }
+  .ant-list-item-action {
+    margin-left: 12px;
+  }
+  .ant-list-vertical .ant-list-item {
+    -ms-flex-wrap: wrap-reverse;
+        flex-wrap: wrap-reverse;
+  }
+  .ant-list-vertical .ant-list-item-main {
+    min-width: 220px;
+  }
+  .ant-list-vertical .ant-list-item-extra {
+    margin: auto auto 16px;
+  }
+}
+.ant-list-rtl {
+  direction: rtl;
+  text-align: right;
+}
+.ant-list-rtl .ReactVirtualized__List .ant-list-item {
+  direction: rtl;
+}
+.ant-list-rtl .ant-list-pagination {
+  text-align: left;
+}
+.ant-list-rtl .ant-list-item-meta-avatar {
+  margin-right: 0;
+  margin-left: 16px;
+}
+.ant-list-rtl .ant-list-item-action {
+  margin-right: 48px;
+  margin-left: 0;
+}
+.ant-list-rtl .ant-list-item-action > li:first-child {
+  padding-right: 0;
+  padding-left: 8px;
+}
+.ant-list-rtl .ant-list-item-action-split {
+  right: auto;
+  left: 0;
+}
+.ant-list-rtl.ant-list-vertical .ant-list-item-extra {
+  margin-right: 40px;
+  margin-left: 0;
+}
+.ant-list-rtl .ant-list-vertical .ant-list-item-action {
+  margin-right: auto;
+}
+.ant-list-rtl .ant-list-vertical .ant-list-item-action > li:first-child {
+  padding-right: 0;
+  padding-left: 16px;
+}
+.ant-list-rtl .ant-list:not(.ant-list-vertical) .ant-list-item-no-flex .ant-list-item-action {
+  float: left;
+}
+@media screen and (max-width: 768px) {
+  .ant-list-rtl .ant-list-item-action {
+    margin-right: 24px;
+    margin-left: 0;
+  }
+  .ant-list-rtl .ant-list-vertical .ant-list-item-extra {
+    margin-right: 24px;
+    margin-left: 0;
+  }
+}
+@media screen and (max-width: 576px) {
+  .ant-list-rtl .ant-list-item-action {
+    margin-right: 22px;
+    margin-left: 0;
+  }
+  .ant-list-rtl.ant-list-vertical .ant-list-item-extra {
+    margin: auto auto 16px;
+  }
+}

web/node_modules/antd/es/list/style/index.d.ts

@@ -0,0 +1,6 @@
+import '../../style/index.less';
+import './index.less';
+import '../../empty/style';
+import '../../spin/style';
+import '../../pagination/style';
+import '../../grid/style';

web/node_modules/antd/es/list/style/index.js

@@ -0,0 +1,7 @@
+import '../../style/index.less';
+import './index.less'; // style dependencies
+
+import '../../empty/style';
+import '../../spin/style';
+import '../../pagination/style';
+import '../../grid/style';

web/node_modules/antd/es/list/style/index.less

@@ -0,0 +1,240 @@
+@import '../../style/themes/index';
+@import '../../style/mixins/index';
+@import './customize.less';
+
+@list-prefix-cls: ~'@{ant-prefix}-list';
+
+.@{list-prefix-cls} {
+  .reset-component;
+
+  position: relative;
+
+  * {
+    outline: none;
+  }
+
+  &-pagination {
+    margin-top: @margin-lg;
+    text-align: right;
+
+    // https://github.com/ant-design/ant-design/issues/20037
+    .@{ant-prefix}-pagination-options {
+      text-align: left;
+    }
+  }
+
+  &-more {
+    margin-top: @margin-sm;
+    text-align: center;
+    button {
+      padding-right: 32px;
+      padding-left: 32px;
+    }
+  }
+
+  &-spin {
+    min-height: 40px;
+    text-align: center;
+  }
+
+  &-empty-text {
+    padding: @list-empty-text-padding;
+    color: @disabled-color;
+    font-size: @font-size-base;
+    text-align: center;
+  }
+
+  &-items {
+    margin: 0;
+    padding: 0;
+    list-style: none;
+  }
+
+  &-item {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: @list-item-padding;
+
+    &-content {
+      color: @text-color;
+    }
+
+    &-meta {
+      display: flex;
+      flex: 1;
+      align-items: flex-start;
+      font-size: 0;
+
+      &-avatar {
+        margin-right: @list-item-meta-avatar-margin-right;
+      }
+      &-content {
+        flex: 1 0;
+      }
+      &-title {
+        margin-bottom: 4px;
+        color: @text-color;
+        font-size: @font-size-base;
+        line-height: 22px;
+        > a {
+          color: @text-color;
+          transition: all 0.3s;
+          &:hover {
+            color: @primary-color;
+          }
+        }
+      }
+      &-description {
+        color: @text-color-secondary;
+        font-size: @list-item-meta-description-font-size;
+        line-height: 22px;
+      }
+    }
+    &-action {
+      flex: 0 0 auto;
+      margin-left: 48px;
+      padding: 0;
+      font-size: 0;
+      list-style: none;
+
+      & > li {
+        position: relative;
+        display: inline-block;
+        padding: 0 @padding-xs;
+        color: @text-color-secondary;
+        font-size: @font-size-base;
+        line-height: 22px;
+        text-align: center;
+        cursor: pointer;
+      }
+      & > li:first-child {
+        padding-left: 0;
+      }
+      &-split {
+        position: absolute;
+        top: 50%;
+        right: 0;
+        width: 1px;
+        height: 14px;
+        margin-top: -7px;
+        background-color: @border-color-split;
+      }
+    }
+  }
+
+  &-header {
+    background: @list-header-background;
+  }
+
+  &-footer {
+    background: @list-footer-background;
+  }
+
+  &-header,
+  &-footer {
+    padding-top: @padding-sm;
+    padding-bottom: @padding-sm;
+  }
+
+  &-empty {
+    padding: @padding-md 0;
+    color: @text-color-secondary;
+    font-size: 12px;
+    text-align: center;
+  }
+
+  &-split &-item {
+    border-bottom: 1px solid @border-color-split;
+    &:last-child {
+      border-bottom: none;
+    }
+  }
+
+  &-split &-header {
+    border-bottom: 1px solid @border-color-split;
+  }
+
+  &-split&-empty &-footer {
+    border-top: 1px solid @border-color-split;
+  }
+
+  &-loading &-spin-nested-loading {
+    min-height: 32px;
+  }
+
+  &-split&-something-after-last-item .@{ant-prefix}-spin-container > &-items > &-item:last-child {
+    border-bottom: 1px solid @border-color-split;
+  }
+
+  &-lg &-item {
+    padding: @list-item-padding-lg;
+  }
+
+  &-sm &-item {
+    padding: @list-item-padding-sm;
+  }
+
+  &-vertical &-item {
+    align-items: initial;
+
+    &-main {
+      display: block;
+      flex: 1;
+    }
+
+    &-extra {
+      margin-left: 40px;
+    }
+
+    &-meta {
+      margin-bottom: @list-item-meta-margin-bottom;
+
+      &-title {
+        margin-bottom: @list-item-meta-title-margin-bottom;
+        color: @heading-color;
+        font-size: @font-size-lg;
+        line-height: 24px;
+      }
+    }
+
+    &-action {
+      margin-top: @padding-md;
+      margin-left: auto;
+
+      > li {
+        padding: 0 @padding-md;
+        &:first-child {
+          padding-left: 0;
+        }
+      }
+    }
+  }
+
+  &-grid .@{ant-prefix}-col > &-item {
+    display: block;
+    max-width: 100%;
+    margin-bottom: @margin-md;
+    padding-top: 0;
+    padding-bottom: 0;
+    border-bottom: none;
+  }
+
+  // ============================ without flex ============================
+  &-item-no-flex {
+    display: block;
+  }
+
+  // Horizontal
+  &:not(.@{list-prefix-cls}-vertical) {
+    .@{list-prefix-cls}-item-no-flex {
+      .@{list-prefix-cls}-item-action {
+        float: right;
+      }
+    }
+  }
+}
+
+@import './bordered';
+@import './responsive';
+@import './rtl';

web/node_modules/antd/es/list/style/responsive.less

@@ -0,0 +1,40 @@
+@media screen and (max-width: @screen-md) {
+  .@{list-prefix-cls} {
+    &-item {
+      &-action {
+        margin-left: 24px;
+      }
+    }
+  }
+
+  .@{list-prefix-cls}-vertical {
+    .@{list-prefix-cls}-item {
+      &-extra {
+        margin-left: 24px;
+      }
+    }
+  }
+}
+
+@media screen and (max-width: @screen-sm) {
+  .@{list-prefix-cls} {
+    &-item {
+      flex-wrap: wrap;
+      &-action {
+        margin-left: 12px;
+      }
+    }
+  }
+
+  .@{list-prefix-cls}-vertical {
+    .@{list-prefix-cls}-item {
+      flex-wrap: wrap-reverse;
+      &-main {
+        min-width: 220px;
+      }
+      &-extra {
+        margin: auto auto 16px;
+      }
+    }
+  }
+}

web/node_modules/antd/es/list/style/rtl.less

@@ -0,0 +1,139 @@
+@import '../../style/themes/index';
+@import '../../style/mixins/index';
+@import './customize.less';
+
+@list-prefix-cls: ~'@{ant-prefix}-list';
+
+.@{list-prefix-cls} {
+  &-rtl {
+    direction: rtl;
+    text-align: right;
+
+    // fix for virtual scroll style attribute > (direction:ltr)
+    .ReactVirtualized__List .@{list-prefix-cls}-item {
+      direction: rtl;
+    }
+  }
+
+  &-pagination {
+    .@{list-prefix-cls}-rtl & {
+      text-align: left;
+    }
+  }
+
+  &-item {
+    &-meta {
+      &-avatar {
+        .@{list-prefix-cls}-rtl & {
+          margin-right: 0;
+          margin-left: @list-item-meta-avatar-margin-right;
+        }
+      }
+    }
+
+    &-action {
+      .@{list-prefix-cls}-rtl & {
+        margin-right: 48px;
+        margin-left: 0;
+      }
+
+      & > li:first-child {
+        .@{list-prefix-cls}-rtl & {
+          padding-right: 0;
+          padding-left: 8px;
+        }
+      }
+
+      &-split {
+        .@{list-prefix-cls}-rtl & {
+          right: auto;
+          left: 0;
+        }
+      }
+    }
+  }
+
+  &-vertical &-item {
+    &-extra {
+      .@{list-prefix-cls}-rtl& {
+        margin-right: 40px;
+        margin-left: 0;
+      }
+    }
+
+    &-action {
+      .@{list-prefix-cls}-rtl & {
+        margin-right: auto;
+      }
+
+      > li {
+        &:first-child {
+          .@{list-prefix-cls}-rtl & {
+            padding-right: 0;
+            padding-left: 16px;
+          }
+        }
+      }
+    }
+  }
+
+  // Horizontal
+  &:not(.@{list-prefix-cls}-vertical) {
+    .@{list-prefix-cls}-item-no-flex {
+      .@{list-prefix-cls}-item-action {
+        .@{list-prefix-cls}-rtl & {
+          float: left;
+        }
+      }
+    }
+  }
+}
+
+// responsive
+@media screen and (max-width: @screen-md) {
+  .@{list-prefix-cls} {
+    &-item {
+      &-action {
+        .@{list-prefix-cls}-rtl & {
+          margin-right: 24px;
+          margin-left: 0;
+        }
+      }
+    }
+  }
+
+  .@{list-prefix-cls}-vertical {
+    .@{list-prefix-cls}-item {
+      &-extra {
+        .@{list-prefix-cls}-rtl & {
+          margin-right: 24px;
+          margin-left: 0;
+        }
+      }
+    }
+  }
+}
+
+@media screen and (max-width: @screen-sm) {
+  .@{list-prefix-cls} {
+    &-item {
+      &-action {
+        .@{list-prefix-cls}-rtl & {
+          margin-right: 22px;
+          margin-left: 0;
+        }
+      }
+    }
+  }
+
+  .@{list-prefix-cls}-vertical {
+    .@{list-prefix-cls}-item {
+      &-extra {
+        // to override margins on rtl view
+        .@{list-prefix-cls}-rtl& {
+          margin: auto auto 16px;
+        }
+      }
+    }
+  }
+}