choerodon-ui/es/list/Item.js

An enterprise-class UI design language and React-based implementation

import _defineProperty from "@babel/runtime/helpers/defineProperty";
import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
import _createClass from "@babel/runtime/helpers/createClass";
import _inherits from "@babel/runtime/helpers/inherits";
import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
import _extends from "@babel/runtime/helpers/extends";
import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";

function _createSuper(Derived) {
  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;
    }
  }

  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);
  };
}

import React, { Children, Component } from 'react';
import PropTypes from 'prop-types';
import classNames from 'classnames';
import { Col } from '../grid';
import { getPrefixCls } from '../configure';
export var Meta = function Meta(props) {
  var customizePrefixCls = props.prefixCls,
      className = props.className,
      avatar = props.avatar,
      title = props.title,
      description = props.description,
      others = _objectWithoutProperties(props, ["prefixCls", "className", "avatar", "title", "description"]);

  var prefixCls = getPrefixCls('list', customizePrefixCls);
  var classString = classNames("".concat(prefixCls, "-item-meta"), className);
  var content = React.createElement("div", {
    className: "".concat(prefixCls, "-item-meta-content")
  }, title && React.createElement("h4", {
    className: "".concat(prefixCls, "-item-meta-title")
  }, title), description && React.createElement("div", {
    className: "".concat(prefixCls, "-item-meta-description")
  }, description));
  return React.createElement("div", _extends({}, others, {
    className: classString
  }), avatar && React.createElement("div", {
    className: "".concat(prefixCls, "-item-meta-avatar")
  }, avatar), (title || description) && content);
};
Meta.displayName = 'ListMeta';

function getGrid(grid, t) {
  return grid[t] && Math.floor(24 / grid[t]);
}

var GridColumns = ['', 1, 2, 3, 4, 6, 8, 12, 24];

var Item =
/*#__PURE__*/
function (_Component) {
  _inherits(Item, _Component);

  var _super = _createSuper(Item);

  function Item() {
    _classCallCheck(this, Item);

    return _super.apply(this, arguments);
  }

  _createClass(Item, [{
    key: "render",
    value: function render() {
      var grid = this.context.grid;

      var _this$props = this.props,
          customizePrefixCls = _this$props.prefixCls,
          children = _this$props.children,
          actions = _this$props.actions,
          extra = _this$props.extra,
          className = _this$props.className,
          others = _objectWithoutProperties(_this$props, ["prefixCls", "children", "actions", "extra", "className"]);

      var prefixCls = getPrefixCls('list', customizePrefixCls);
      var classString = classNames("".concat(prefixCls, "-item"), className);
      var metaContent = [];
      var otherContent = [];
      Children.forEach(children, function (element) {
        if (element && element.type && element.type === Meta) {
          metaContent.push(element);
        } else {
          otherContent.push(element);
        }
      });
      var contentClassString = classNames("".concat(prefixCls, "-item-content"), _defineProperty({}, "".concat(prefixCls, "-item-content-single"), metaContent.length < 1));
      var content = otherContent.length > 0 ? React.createElement("div", {
        className: contentClassString
      }, otherContent) : null;
      var actionsContent;

      if (actions && actions.length > 0) {
        var actionsContentItem = function actionsContentItem(action, i) {
          return React.createElement("li", {
            key: "".concat(prefixCls, "-item-action-").concat(i)
          }, action, i !== actions.length - 1 && React.createElement("em", {
            className: "".concat(prefixCls, "-item-action-split")
          }));
        };

        actionsContent = React.createElement("ul", {
          className: "".concat(prefixCls, "-item-action")
        }, actions.map(function (action, i) {
          return actionsContentItem(action, i);
        }));
      }

      var extraContent = React.createElement("div", {
        className: "".concat(prefixCls, "-item-extra-wrap")
      }, React.createElement("div", {
        className: "".concat(prefixCls, "-item-main")
      }, metaContent, content, actionsContent), React.createElement("div", {
        className: "".concat(prefixCls, "-item-extra")
      }, extra));
      var mainContent = grid ? 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')
      }, React.createElement("div", _extends({}, others, {
        className: classString
      }), extra && extraContent, !extra && metaContent, !extra && content, !extra && actionsContent)) : React.createElement("div", _extends({}, others, {
        className: classString
      }), extra && extraContent, !extra && metaContent, !extra && content, !extra && actionsContent);
      return mainContent;
    }
  }]);

  return Item;
}(Component);

export { Item as default };
Item.displayName = 'ListItem';
Item.Meta = Meta;
Item.propTypes = {
  column: PropTypes.oneOf(GridColumns),
  xs: PropTypes.oneOf(GridColumns),
  sm: PropTypes.oneOf(GridColumns),
  md: PropTypes.oneOf(GridColumns),
  lg: PropTypes.oneOf(GridColumns),
  xl: PropTypes.oneOf(GridColumns),
  xxl: PropTypes.oneOf(GridColumns)
};
Item.contextTypes = {
  grid: PropTypes.any
};
//# sourceMappingURL=Item.js.map