'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _react = require('react');

var _react2 = _interopRequireDefault(_react);

var _propTypes = require('prop-types');

var _propTypes2 = _interopRequireDefault(_propTypes);

var _Logo = require('./Logo');

var _Logo2 = _interopRequireDefault(_Logo);

var _styledComponents = require('styled-components');

var _styledComponents2 = _interopRequireDefault(_styledComponents);

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

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Container = _styledComponents2.default.div.withConfig({
  displayName: 'LogoHeader__Container'
})(['margin: auto 0;display: flex;flex-direction: row;']);

var Text = _styledComponents2.default.span.withConfig({
  displayName: 'LogoHeader__Text'
})(['font-size: ', ';font-weight: ', ';line-height: 30px;border-left: 1px solid;margin-left: 0.5em;padding-left: 0.5em;height: 30px;display: inline-block;font-family: ', ';'], function (_ref) {
  var theme = _ref.theme;
  return theme.header.fontSize;
}, function (_ref2) {
  var theme = _ref2.theme;
  return theme.header.fontWeight;
}, function (_ref3) {
  var theme = _ref3.theme;
  return theme.header.fontFamily;
});

var LogoHeader = function (_React$Component) {
  _inherits(LogoHeader, _React$Component);

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

    return _possibleConstructorReturn(this, (LogoHeader.__proto__ || Object.getPrototypeOf(LogoHeader)).apply(this, arguments));
  }

  _createClass(LogoHeader, [{
    key: 'render',
    value: function render() {
      return _react2.default.createElement(
        Container,
        null,
        _react2.default.createElement(_Logo2.default, null),
        _react2.default.createElement(
          Text,
          null,
          this.props.children
        )
      );
    }
  }]);

  return LogoHeader;
}(_react2.default.Component);

LogoHeader.propTypes = {
  children: _propTypes2.default.string
};
LogoHeader.defaultProps = {
  children: 'Bandwidth'
};


LogoHeader.usage = '\n# LogoHeader\n\nLogoHeader is mostly used for the top nav. It\'s just like Header, except it renders a logo before the text you supply.\n\nBandwidth and the BW logo are trademarks of Bandwidth.com, Inc.  Bandwidth reserves all rights to these trademarks, as well as any others that may be included from time to time.\n\n```\n<LogoHeader>Bandwidth</LogoHeader>\n```\n';

exports.default = LogoHeader;