react-cm-ui/core/dataDisplay/header/header.js

React UI for Healthy Church

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _classnames = _interopRequireDefault(require("classnames"));

var _propTypes = _interopRequireDefault(require("prop-types"));

var _react = _interopRequireDefault(require("react"));

var _headerSubheader = _interopRequireDefault(require("./headerSubheader"));

var _icon = _interopRequireDefault(require("../icon"));

var _utils = _interopRequireDefault(require("../../utils/utils"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

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 _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; } 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 asEnums = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'];
var colorEnums = ['static', 'text'];
var weightEnums = ['bold', 'normal', 'semibold'];
var propTypes = {
  anchor: _propTypes["default"].string,
  as: _propTypes["default"].oneOf(asEnums),
  className: _propTypes["default"].string,
  color: _propTypes["default"].oneOf(colorEnums),
  icon: _propTypes["default"].bool,
  inverse: _propTypes["default"].bool,
  size: _propTypes["default"].oneOf(_utils["default"].sizeEnums()),
  style: _propTypes["default"].shape({}),
  sub: _propTypes["default"].bool,
  title: _propTypes["default"].string,
  weight: _propTypes["default"].oneOf(weightEnums)
};
var defaultProps = {
  anchor: undefined,
  as: undefined,
  className: undefined,
  color: undefined,
  icon: false,
  inverse: false,
  size: undefined,
  style: {},
  sub: false,
  title: undefined,
  weight: undefined
};

var Header = /*#__PURE__*/function (_React$PureComponent) {
  _inherits(Header, _React$PureComponent);

  var _super = _createSuper(Header);

  function Header() {
    var _this;

    _classCallCheck(this, Header);

    _this = _super.call(this);
    _this.onAnchorClick = _this.onAnchorClick.bind(_assertThisInitialized(_this));
    return _this;
  }

  _createClass(Header, [{
    key: "onAnchorClick",
    value: function onAnchorClick() {
      var anchor = this.props.anchor;
      window.location.hash = anchor;
    }
  }, {
    key: "render",
    value: function render() {
      var _this$props = this.props,
          anchor = _this$props.anchor,
          as = _this$props.as,
          children = _this$props.children,
          className = _this$props.className,
          color = _this$props.color,
          icon = _this$props.icon,
          inverse = _this$props.inverse,
          size = _this$props.size,
          style = _this$props.style,
          sub = _this$props.sub,
          title = _this$props.title,
          weight = _this$props.weight;

      var ElementType = _utils["default"].getElementType(as);

      var containerClasses = (0, _classnames["default"])('ui', 'header', className, {
        'header-anchor': anchor,
        'header-color-inverse': inverse,
        'header-color-static': color === 'static',
        'header-color-text': color === 'text',
        'header-icon': icon,
        'header-size-large': size === 'large',
        'header-size-medium': size === 'medium',
        'header-size-small': size === 'small',
        'header-size-xlarge': size === 'xlarge',
        'header-size-xsmall': size === 'xsmall',
        'header-size-xxsmall': size === 'xxsmall',
        'header-subheader': sub,
        'header-weight-bold': weight === 'bold',
        'header-weight-normal': weight === 'normal',
        'header-weight-semibold': weight === 'semibold'
      });
      var anchorIcon;

      if (anchor) {
        anchorIcon = /*#__PURE__*/_react["default"].createElement(_icon["default"], {
          className: "header-anchor-icon",
          color: "static",
          compact: true,
          onClick: this.onAnchorClick,
          size: "small",
          type: "link"
        });
      }

      if (icon && sub) {
        return /*#__PURE__*/_react["default"].createElement(ElementType, {
          className: containerClasses,
          id: anchor,
          style: style
        }, /*#__PURE__*/_react["default"].createElement("span", {
          style: {
            display: 'inline-flex',
            alignItems: 'center'
          }
        }, children[0], anchorIcon), /*#__PURE__*/_react["default"].createElement("div", null, children[1], children[2]));
      }

      return /*#__PURE__*/_react["default"].createElement(ElementType, {
        className: containerClasses,
        id: anchor,
        style: style,
        title: title
      }, anchor ? /*#__PURE__*/_react["default"].createElement("span", null, _react["default"].Children.map(children, function (child, index) {
        if (index === 0) {
          return /*#__PURE__*/_react["default"].createElement("span", {
            style: {
              display: 'inline-flex',
              alignItems: 'center'
            }
          }, child, anchorIcon);
        }

        return child;
      })) : children);
    }
  }]);

  return Header;
}(_react["default"].PureComponent);

Header.Subheader = _headerSubheader["default"];
Header.propTypes = propTypes;
Header.defaultProps = defaultProps;
var _default = Header;
exports["default"] = _default;