@x-nivo/bullet/dist/nivo-bullet.cjs.js

[](https://www.npmjs.com/package/@nivo/bullet)

'use strict';

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

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

var React = require('react');
var React__default = _interopDefault(React);
var d3Scale = require('d3-scale');
var setDisplayName = _interopDefault(require('recompose/setDisplayName'));
var core = require('@nivo/core');
var PropTypes = _interopDefault(require('prop-types'));
var isString = _interopDefault(require('lodash/isString'));
var reactMotion = require('react-motion');
var partial = _interopDefault(require('lodash/partial'));
var compose = _interopDefault(require('recompose/compose'));
var defaultProps = _interopDefault(require('recompose/defaultProps'));
var withPropsOnChange = _interopDefault(require('recompose/withPropsOnChange'));
var pure = _interopDefault(require('recompose/pure'));
var last = _interopDefault(require('lodash/last'));

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }

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 _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }

function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
var stackValues = function stackValues(values, colorScale) {
  var useAverage = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;

  var normalized = _toConsumableArray(values).filter(function (v) {
    return v !== 0;
  }).sort(function (a, b) {
    return a - b;
  });

  return normalized.reduce(function (acc, v1, index) {
    var v0 = last(acc) !== undefined ? last(acc).v1 : 0;
    var sequentialValue = useAverage === true ? v0 + (v1 - v0) / 2 : v1;
    return [].concat(_toConsumableArray(acc), [{
      index: index,
      v0: v0,
      v1: v1,
      color: colorScale(colorScale.type === 'sequential' ? sequentialValue : index)
    }]);
  }, []);
};
var getComputeRect = function getComputeRect(_ref) {
  var layout = _ref.layout,
      reverse = _ref.reverse,
      scale = _ref.scale,
      height = _ref.height;

  if (layout === 'horizontal') {
    if (reverse === true) {
      return function (d) {
        var x = scale(d.v1);
        var w = scale(d.v0) - x;
        return {
          x: x,
          y: 0,
          width: w,
          height: height
        };
      };
    }

    return function (d) {
      var x = scale(d.v0);
      var w = scale(d.v1) - x;
      return {
        x: x,
        y: 0,
        width: w,
        height: height
      };
    };
  }

  if (reverse === true) {
    return function (d) {
      var y = scale(d.v0);
      var h = scale(d.v1) - y;
      return {
        x: 0,
        y: y,
        width: height,
        height: h
      };
    };
  }

  return function (d) {
    var y = scale(d.v1);
    var h = scale(d.v0) - y;
    return {
      x: 0,
      y: y,
      width: height,
      height: h
    };
  };
};
var computeRects = function computeRects(_ref2) {
  var data = _ref2.data,
      layout = _ref2.layout,
      reverse = _ref2.reverse,
      scale = _ref2.scale,
      height = _ref2.height;
  var computeRect = getComputeRect({
    layout: layout,
    reverse: reverse,
    scale: scale,
    height: height
  });
  return data.map(function (d) {
    return _objectSpread({
      data: d
    }, computeRect(d));
  });
};

function _typeof(obj) { 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 _objectSpread$1(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty$1(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 _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

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 _defineProperty$1(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; }

var getPositionGenerator = function getPositionGenerator(_ref) {
  var layout = _ref.layout,
      reverse = _ref.reverse,
      scale = _ref.scale,
      height = _ref.height,
      markerSize = _ref.markerSize;

  if (layout === 'horizontal') {
    return function (marker) {
      var x = scale(marker.value);
      var y = height / 2;
      var rotation = reverse === true ? 180 : 0;
      return {
        x: x,
        y: y,
        size: markerSize,
        rotation: rotation
      };
    };
  }

  return function (marker) {
    var x = height / 2;
    var y = scale(marker.value);
    var rotation = reverse === true ? 270 : 90;
    return {
      x: x,
      y: y,
      size: markerSize,
      rotation: rotation
    };
  };
};

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

  function BulletMarkers() {
    var _getPrototypeOf2;

    var _this;

    _classCallCheck(this, BulletMarkers);

    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(BulletMarkers)).call.apply(_getPrototypeOf2, [this].concat(args)));

    _defineProperty$1(_assertThisInitialized(_this), "handleMouseEnter", function (data, event) {
      _this.props.onMouseEnter(data, event);
    });

    _defineProperty$1(_assertThisInitialized(_this), "handleMouseLeave", function (data, event) {
      _this.props.onMouseLeave(data, event);
    });

    _defineProperty$1(_assertThisInitialized(_this), "handleClick", function (data, event) {
      _this.props.onClick(data, event);
    });

    return _this;
  }

  _createClass(BulletMarkers, [{
    key: "render",
    value: function render() {
      var _this2 = this;

      var _this$props = this.props,
          scale = _this$props.scale,
          layout = _this$props.layout,
          reverse = _this$props.reverse,
          markers = _this$props.markers,
          height = _this$props.height,
          markerSize = _this$props.markerSize,
          component = _this$props.component,
          animate = _this$props.animate,
          motionStiffness = _this$props.motionStiffness,
          motionDamping = _this$props.motionDamping;
      var getPosition = getPositionGenerator({
        layout: layout,
        reverse: reverse,
        scale: scale,
        height: height,
        markerSize: markerSize
      });

      if (animate !== true) {
        return React__default.createElement(React.Fragment, null, markers.map(function (marker) {
          return React__default.createElement(component, _objectSpread$1({
            key: marker.index
          }, marker, getPosition(marker), {
            data: marker,
            onMouseEnter: partial(_this2.handleMouseEnter, marker),
            onMouseMove: partial(_this2.handleMouseEnter, marker),
            onMouseLeave: partial(_this2.handleMouseLeave, marker),
            onClick: partial(_this2.handleClick, marker)
          }));
        }));
      }

      var springConfig = {
        damping: motionDamping,
        stiffness: motionStiffness
      };
      return React__default.createElement(reactMotion.TransitionMotion, {
        styles: markers.map(function (marker, i) {
          var position = getPosition(marker);
          return {
            key: "".concat(i),
            data: marker,
            style: _objectSpread$1({
              x: reactMotion.spring(position.x, springConfig),
              y: reactMotion.spring(position.y, springConfig),
              size: reactMotion.spring(position.size, springConfig),
              rotation: reactMotion.spring(position.rotation, springConfig)
            }, core.colorMotionSpring(marker.color, springConfig))
          };
        })
      }, function (interpolatedStyles) {
        return React__default.createElement(React.Fragment, null, interpolatedStyles.map(function (_ref2) {
          var key = _ref2.key,
              style = _ref2.style,
              marker = _ref2.data;
          var color = core.getInterpolatedColor(style);
          return React__default.createElement(component, _objectSpread$1({
            key: key
          }, marker, style, {
            color: color,
            data: marker,
            onMouseEnter: partial(_this2.handleMouseEnter, marker),
            onMouseMove: partial(_this2.handleMouseEnter, marker),
            onMouseLeave: partial(_this2.handleMouseLeave, marker),
            onClick: partial(_this2.handleClick, marker)
          }));
        }));
      });
    }
  }]);

  return BulletMarkers;
}(React.Component);

_defineProperty$1(BulletMarkers, "propTypes", _objectSpread$1({
  scale: PropTypes.func.isRequired,
  layout: PropTypes.oneOf(['horizontal', 'vertical']).isRequired,
  reverse: PropTypes.bool.isRequired,
  markers: PropTypes.arrayOf(PropTypes.shape({
    value: PropTypes.number.isRequired,
    index: PropTypes.number.isRequired,
    color: PropTypes.string.isRequired
  })).isRequired,
  height: PropTypes.number.isRequired,
  markerSize: PropTypes.number.isRequired,
  component: PropTypes.func.isRequired,
  onMouseEnter: PropTypes.func.isRequired,
  onMouseLeave: PropTypes.func.isRequired,
  onClick: PropTypes.func.isRequired
}, core.motionPropTypes));

function _typeof$1(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1 = function _typeof(obj) { return typeof obj; }; } else { _typeof$1 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1(obj); }

function _objectSpread$2(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty$2(target, key, source[key]); }); } return target; }

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

function _defineProperties$1(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$1(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1(Constructor, staticProps); return Constructor; }

function _possibleConstructorReturn$1(self, call) { if (call && (_typeof$1(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$1(self); }

function _getPrototypeOf$1(o) { _getPrototypeOf$1 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$1(o); }

function _assertThisInitialized$1(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

function _inherits$1(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$1(subClass, superClass); }

function _setPrototypeOf$1(o, p) { _setPrototypeOf$1 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$1(o, p); }

function _defineProperty$2(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; }

var BulletRects =
/*#__PURE__*/
function (_Component) {
  _inherits$1(BulletRects, _Component);

  function BulletRects() {
    var _getPrototypeOf2;

    var _this;

    _classCallCheck$1(this, BulletRects);

    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    _this = _possibleConstructorReturn$1(this, (_getPrototypeOf2 = _getPrototypeOf$1(BulletRects)).call.apply(_getPrototypeOf2, [this].concat(args)));

    _defineProperty$2(_assertThisInitialized$1(_this), "handleMouseEnter", function (data, event) {
      _this.props.onMouseEnter(data, event);
    });

    _defineProperty$2(_assertThisInitialized$1(_this), "handleMouseLeave", function (data, event) {
      _this.props.onMouseLeave(data, event);
    });

    _defineProperty$2(_assertThisInitialized$1(_this), "handleClick", function (data, event) {
      _this.props.onClick(data, event);
    });

    return _this;
  }

  _createClass$1(BulletRects, [{
    key: "render",
    value: function render() {
      var _this2 = this;

      var _this$props = this.props,
          rects = _this$props.rects,
          layout = _this$props.layout,
          y = _this$props.y,
          component = _this$props.component,
          animate = _this$props.animate,
          motionStiffness = _this$props.motionStiffness,
          motionDamping = _this$props.motionDamping;
      var transform = "translate(".concat(layout === 'horizontal' ? 0 : y, ",").concat(layout === 'horizontal' ? y : 0, ")");

      if (animate !== true) {
        return React__default.createElement("g", {
          transform: transform
        }, rects.map(function (rect) {
          return React__default.createElement(component, _objectSpread$2({
            key: rect.data.index,
            index: rect.data.index,
            color: rect.data.color
          }, rect, {
            onMouseEnter: partial(_this2.handleMouseEnter, rect.data),
            onMouseMove: partial(_this2.handleMouseEnter, rect.data),
            onMouseLeave: partial(_this2.handleMouseLeave, rect.data),
            onClick: partial(_this2.handleClick, rect.data)
          }));
        }));
      }

      var springConfig = {
        damping: motionDamping,
        stiffness: motionStiffness
      };
      return React__default.createElement("g", {
        transform: transform
      }, React__default.createElement(reactMotion.TransitionMotion, {
        styles: rects.map(function (rect) {
          return {
            key: "".concat(rect.data.index),
            data: rect.data,
            style: _objectSpread$2({
              x: reactMotion.spring(rect.x, springConfig),
              y: reactMotion.spring(rect.y, springConfig),
              width: reactMotion.spring(rect.width, springConfig),
              height: reactMotion.spring(rect.height, springConfig)
            }, core.colorMotionSpring(rect.data.color, springConfig))
          };
        })
      }, function (interpolatedStyles) {
        return React__default.createElement(React.Fragment, null, interpolatedStyles.map(function (_ref) {
          var key = _ref.key,
              style = _ref.style,
              data = _ref.data;
          var color = core.getInterpolatedColor(style);
          return React__default.createElement(component, {
            key: key,
            index: Number(key),
            data: data,
            x: style.x,
            y: style.y,
            width: Math.max(style.width, 0),
            height: Math.max(style.height, 0),
            color: color,
            onMouseEnter: partial(_this2.handleMouseEnter, data),
            onMouseMove: partial(_this2.handleMouseEnter, data),
            onMouseLeave: partial(_this2.handleMouseLeave, data),
            onClick: partial(_this2.handleClick, data)
          });
        }));
      }));
    }
  }]);

  return BulletRects;
}(React.Component);

_defineProperty$2(BulletRects, "propTypes", _objectSpread$2({
  scale: PropTypes.func.isRequired,
  data: PropTypes.arrayOf(PropTypes.shape({
    v0: PropTypes.number.isRequired,
    v1: PropTypes.number.isRequired
  })).isRequired,
  layout: PropTypes.oneOf(['horizontal', 'vertical']).isRequired,
  reverse: PropTypes.bool.isRequired,
  x: PropTypes.number.isRequired,
  y: PropTypes.number.isRequired,
  width: PropTypes.number.isRequired,
  height: PropTypes.number.isRequired,
  rects: PropTypes.arrayOf(PropTypes.shape({
    x: PropTypes.number.isRequired,
    y: PropTypes.number.isRequired,
    width: PropTypes.number.isRequired,
    height: PropTypes.number.isRequired,
    data: PropTypes.shape({
      index: PropTypes.number.isRequired,
      v0: PropTypes.number.isRequired,
      v1: PropTypes.number.isRequired,
      color: PropTypes.string.isRequired
    }).isRequired
  })).isRequired,
  component: PropTypes.func.isRequired,
  onMouseEnter: PropTypes.func.isRequired,
  onMouseLeave: PropTypes.func.isRequired,
  onClick: PropTypes.func.isRequired
}, core.motionPropTypes));

var EnhancedBulletRects = compose(withPropsOnChange(['data', 'layout', 'reverse', 'scale', 'height'], function (_ref2) {
  var data = _ref2.data,
      layout = _ref2.layout,
      reverse = _ref2.reverse,
      scale = _ref2.scale,
      height = _ref2.height;
  return {
    rects: computeRects({
      data: data,
      layout: layout,
      reverse: reverse,
      scale: scale,
      height: height
    })
  };
}), pure)(BulletRects);
EnhancedBulletRects.displayName = 'BulletRects';

function _typeof$2(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$2 = function _typeof(obj) { return typeof obj; }; } else { _typeof$2 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$2(obj); }

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

function _defineProperties$2(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$2(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2(Constructor, staticProps); return Constructor; }

function _possibleConstructorReturn$2(self, call) { if (call && (_typeof$2(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$2(self); }

function _assertThisInitialized$2(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

function _getPrototypeOf$2(o) { _getPrototypeOf$2 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$2(o); }

function _inherits$2(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$2(subClass, superClass); }

function _setPrototypeOf$2(o, p) { _setPrototypeOf$2 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$2(o, p); }

function _defineProperty$3(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; }

var BulletRectsItem =
/*#__PURE__*/
function (_PureComponent) {
  _inherits$2(BulletRectsItem, _PureComponent);

  function BulletRectsItem() {
    _classCallCheck$2(this, BulletRectsItem);

    return _possibleConstructorReturn$2(this, _getPrototypeOf$2(BulletRectsItem).apply(this, arguments));
  }

  _createClass$2(BulletRectsItem, [{
    key: "render",
    value: function render() {
      var _this$props = this.props,
          x = _this$props.x,
          y = _this$props.y,
          width = _this$props.width,
          height = _this$props.height,
          color = _this$props.color,
          onMouseEnter = _this$props.onMouseEnter,
          onMouseMove = _this$props.onMouseMove,
          onMouseLeave = _this$props.onMouseLeave,
          onClick = _this$props.onClick;
      return React__default.createElement("rect", {
        x: x,
        y: y,
        width: width,
        height: height,
        fill: color,
        onMouseMove: onMouseMove,
        onMouseEnter: onMouseEnter,
        onMouseLeave: onMouseLeave,
        onClick: onClick
      });
    }
  }]);

  return BulletRectsItem;
}(React.PureComponent);

_defineProperty$3(BulletRectsItem, "propTypes", {
  index: PropTypes.number.isRequired,
  x: PropTypes.number.isRequired,
  y: PropTypes.number.isRequired,
  width: PropTypes.number.isRequired,
  height: PropTypes.number.isRequired,
  color: PropTypes.string.isRequired,
  data: PropTypes.shape({
    v0: PropTypes.number.isRequired,
    v1: PropTypes.number.isRequired
  }).isRequired,
  onMouseEnter: PropTypes.func.isRequired,
  onMouseMove: PropTypes.func.isRequired,
  onMouseLeave: PropTypes.func.isRequired,
  onClick: PropTypes.func.isRequired
});

function _typeof$3(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$3 = function _typeof(obj) { return typeof obj; }; } else { _typeof$3 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$3(obj); }

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

function _defineProperties$3(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$3(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$3(Constructor.prototype, protoProps); if (staticProps) _defineProperties$3(Constructor, staticProps); return Constructor; }

function _possibleConstructorReturn$3(self, call) { if (call && (_typeof$3(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$3(self); }

function _assertThisInitialized$3(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

function _getPrototypeOf$3(o) { _getPrototypeOf$3 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$3(o); }

function _inherits$3(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$3(subClass, superClass); }

function _setPrototypeOf$3(o, p) { _setPrototypeOf$3 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$3(o, p); }

function _defineProperty$4(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; }

var BulletMarkersItem =
/*#__PURE__*/
function (_PureComponent) {
  _inherits$3(BulletMarkersItem, _PureComponent);

  function BulletMarkersItem() {
    _classCallCheck$3(this, BulletMarkersItem);

    return _possibleConstructorReturn$3(this, _getPrototypeOf$3(BulletMarkersItem).apply(this, arguments));
  }

  _createClass$3(BulletMarkersItem, [{
    key: "render",
    value: function render() {
      var _this$props = this.props,
          x = _this$props.x,
          y = _this$props.y,
          size = _this$props.size,
          rotation = _this$props.rotation,
          color = _this$props.color,
          onMouseEnter = _this$props.onMouseEnter,
          onMouseMove = _this$props.onMouseMove,
          onMouseLeave = _this$props.onMouseLeave,
          onClick = _this$props.onClick;
      return React__default.createElement("line", {
        transform: "rotate(".concat(rotation, ", ").concat(x, ", ").concat(y, ")"),
        x1: x,
        x2: x,
        y1: y - size / 2,
        y2: y + size / 2,
        fill: "none",
        stroke: color,
        strokeWidth: "5",
        onMouseMove: onMouseMove,
        onMouseEnter: onMouseEnter,
        onMouseLeave: onMouseLeave,
        onClick: onClick
      });
    }
  }]);

  return BulletMarkersItem;
}(React.PureComponent);

_defineProperty$4(BulletMarkersItem, "propTypes", {
  x: PropTypes.number.isRequired,
  y: PropTypes.number.isRequired,
  size: PropTypes.number.isRequired,
  rotation: PropTypes.number.isRequired,
  color: PropTypes.string.isRequired,
  data: PropTypes.shape({
    index: PropTypes.number.isRequired,
    value: PropTypes.number.isRequired,
    color: PropTypes.string.isRequired
  }).isRequired,
  onMouseEnter: PropTypes.func.isRequired,
  onMouseMove: PropTypes.func.isRequired,
  onMouseLeave: PropTypes.func.isRequired,
  onClick: PropTypes.func.isRequired
});

function _typeof$4(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$4 = function _typeof(obj) { return typeof obj; }; } else { _typeof$4 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$4(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 _objectSpread$3(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty$5(target, key, source[key]); }); } return target; }

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

function _defineProperties$4(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$4(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$4(Constructor.prototype, protoProps); if (staticProps) _defineProperties$4(Constructor, staticProps); return Constructor; }

function _possibleConstructorReturn$4(self, call) { if (call && (_typeof$4(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$4(self); }

function _getPrototypeOf$4(o) { _getPrototypeOf$4 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$4(o); }

function _assertThisInitialized$4(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

function _inherits$4(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$4(subClass, superClass); }

function _setPrototypeOf$4(o, p) { _setPrototypeOf$4 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$4(o, p); }

function _defineProperty$5(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; }

var BulletItem =
/*#__PURE__*/
function (_Component) {
  _inherits$4(BulletItem, _Component);

  function BulletItem() {
    var _getPrototypeOf2;

    var _this;

    _classCallCheck$4(this, BulletItem);

    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    _this = _possibleConstructorReturn$4(this, (_getPrototypeOf2 = _getPrototypeOf$4(BulletItem)).call.apply(_getPrototypeOf2, [this].concat(args)));

    _defineProperty$5(_assertThisInitialized$4(_this), "handleMouseEnter", function (data, event) {
      _this.props.onMouseEnter(data, event);
    });

    _defineProperty$5(_assertThisInitialized$4(_this), "handleMouseLeave", function (data, event) {
      _this.props.onMouseLeave(data, event);
    });

    _defineProperty$5(_assertThisInitialized$4(_this), "handleRangeTooltip", function (showTooltip, range, event) {
      var _this$props = _this.props,
          rangeTooltip = _this$props.rangeTooltip,
          theme = _this$props.theme;
      showTooltip(React__default.createElement(core.BasicTooltip, {
        id: React__default.createElement("span", null, React__default.createElement("strong", null, range.v0), " to ", React__default.createElement("strong", null, range.v1)),
        enableChip: true,
        color: range.color,
        theme: theme //format={format}
        ,
        renderContent: typeof rangeTooltip === 'function' ? rangeTooltip.bind(null, _objectSpread$3({}, range)) : null
      }), event);
    });

    _defineProperty$5(_assertThisInitialized$4(_this), "handleMeasureTooltip", function (showTooltip, measure, event) {
      var _this$props2 = _this.props,
          measureTooltip = _this$props2.measureTooltip,
          theme = _this$props2.theme;
      showTooltip(React__default.createElement(core.BasicTooltip, {
        id: React__default.createElement("strong", null, measure.v1),
        enableChip: true,
        color: measure.color,
        theme: theme //format={format}
        ,
        renderContent: typeof measureTooltip === 'function' ? measureTooltip.bind(null, _objectSpread$3({}, measure)) : null
      }), event);
    });

    _defineProperty$5(_assertThisInitialized$4(_this), "handleMarkerTooltip", function (showTooltip, marker, event) {
      var _this$props3 = _this.props,
          markerTooltip = _this$props3.markerTooltip,
          theme = _this$props3.theme;
      showTooltip(React__default.createElement(core.BasicTooltip, {
        id: React__default.createElement("strong", null, marker.value),
        enableChip: true,
        color: marker.color,
        theme: theme //format={format}
        ,
        renderContent: typeof markerTooltip === 'function' ? markerTooltip.bind(null, _objectSpread$3({}, marker)) : null
      }), event);
    });

    _defineProperty$5(_assertThisInitialized$4(_this), "handleRangeClick", function (range, event) {
      var _this$props4 = _this.props,
          id = _this$props4.id,
          onRangeClick = _this$props4.onRangeClick;
      onRangeClick(_objectSpread$3({
        id: id
      }, range), event);
    });

    _defineProperty$5(_assertThisInitialized$4(_this), "handleMeasureClick", function (measure, event) {
      var _this$props5 = _this.props,
          id = _this$props5.id,
          onMeasureClick = _this$props5.onMeasureClick;
      onMeasureClick(_objectSpread$3({
        id: id
      }, measure), event);
    });

    _defineProperty$5(_assertThisInitialized$4(_this), "handleMarkerClick", function (marker, event) {
      var _this$props6 = _this.props,
          id = _this$props6.id,
          onMarkerClick = _this$props6.onMarkerClick;
      onMarkerClick(_objectSpread$3({
        id: id
      }, marker), event);
    });

    return _this;
  }

  _createClass$4(BulletItem, [{
    key: "render",
    value: function render() {
      var _this2 = this;

      var _this$props7 = this.props,
          id = _this$props7.id,
          data = _this$props7.data,
          scale = _this$props7.scale,
          layout = _this$props7.layout,
          reverse = _this$props7.reverse,
          _axisPosition = _this$props7.axisPosition,
          axisValueFormat = _this$props7.axisValueFormat,
          x = _this$props7.x,
          y = _this$props7.y,
          width = _this$props7.width,
          height = _this$props7.height,
          _title = _this$props7.title,
          titlePosition = _this$props7.titlePosition,
          titleAlign = _this$props7.titleAlign,
          titleOffsetX = _this$props7.titleOffsetX,
          titleOffsetY = _this$props7.titleOffsetY,
          titleRotation = _this$props7.titleRotation,
          computedRanges = _this$props7.computedRanges,
          rangeComponent = _this$props7.rangeComponent,
          computedMeasures = _this$props7.computedMeasures,
          measureComponent = _this$props7.measureComponent,
          measureHeight = _this$props7.measureHeight,
          computedMarkers = _this$props7.computedMarkers,
          markerComponent = _this$props7.markerComponent,
          markerHeight = _this$props7.markerHeight,
          theme = _this$props7.theme,
          showTooltip = _this$props7.showTooltip,
          hideTooltip = _this$props7.hideTooltip,
          measureTooltip = _this$props7.measureTooltip,
          rangeTooltip = _this$props7.rangeTooltip,
          markerTooltip = _this$props7.markerTooltip,
          animate = _this$props7.animate,
          motionStiffness = _this$props7.motionStiffness,
          motionDamping = _this$props7.motionDamping;
      var motionProps = {
        animate: animate,
        motionStiffness: motionStiffness,
        motionDamping: motionDamping
      };
      var axisPosition;

      if (layout === 'horizontal') {
        axisPosition = _axisPosition === 'before' ? 'top' : 'bottom';
      } else {
        axisPosition = _axisPosition === 'before' ? 'left' : 'right';
      }

      var rangeNodes = React__default.createElement(EnhancedBulletRects, _extends({
        data: computedRanges,
        scale: scale,
        layout: layout,
        reverse: reverse,
        x: 0,
        y: 0,
        width: width,
        height: height,
        component: rangeComponent,
        onMouseEnter: partial(this.handleRangeTooltip, showTooltip),
        onMouseLeave: hideTooltip,
        onClick: this.handleRangeClick
      }, motionProps));
      var markerNodes = React__default.createElement(BulletMarkers, _extends({
        markers: computedMarkers,
        scale: scale,
        layout: layout,
        reverse: reverse,
        height: height,
        markerSize: markerHeight,
        component: markerComponent,
        onMouseEnter: partial(this.handleMarkerTooltip, showTooltip),
        onMouseLeave: hideTooltip,
        onClick: this.handleMarkerClick
      }, motionProps));
      var axis = React__default.createElement(core.Axis, _extends({
        width: layout === 'horizontal' ? width : height,
        height: layout === 'horizontal' ? height : width,
        scale: scale,
        position: axisPosition,
        theme: theme,
        format: axisValueFormat
      }, motionProps));
      var title = _title || id;
      var titleX;
      var titleY;

      if (layout === 'horizontal') {
        titleX = titlePosition === 'before' ? titleOffsetX : width + titleOffsetX;
        titleY = height / 2 + titleOffsetY;
      } else {
        titleX = height / 2 + titleOffsetX;
        titleY = titlePosition === 'before' ? titleOffsetY : width + titleOffsetY;
      }

      var titleNode = React__default.createElement("g", {
        transform: "translate(".concat(titleX, ",").concat(titleY, ") rotate(").concat(titleRotation, ")")
      }, isString(title) ? React__default.createElement("text", {
        style: _objectSpread$3({}, theme.labels.text, {
          alignmentBaseline: 'central',
          textAnchor: titleAlign
        })
      }, title) : title);

      if (animate !== true) {
        return React__default.createElement("g", {
          transform: "translate(".concat(x, ",").concat(y, ")"),
          onMouseEnter: partial(this.handleMouseEnter, data),
          onMouseMove: partial(this.handleMouseEnter, data),
          onMouseLeave: partial(this.handleMouseLeave, data)
        }, rangeNodes, React__default.createElement(EnhancedBulletRects, _extends({
          data: computedMeasures,
          scale: scale,
          layout: layout,
          reverse: reverse,
          x: 0,
          y: (height - measureHeight) / 2,
          width: width,
          height: measureHeight,
          component: measureComponent,
          onMouseEnter: partial(this.handleMeasureTooltip, showTooltip),
          onMouseLeave: hideTooltip,
          onClick: this.handleMeasureClick
        }, motionProps)), axis, markerNodes, titleNode);
      }

      var springConfig = {
        damping: motionDamping,
        stiffness: motionStiffness
      };
      return React__default.createElement(reactMotion.Motion, {
        style: {
          x: reactMotion.spring(x, springConfig),
          y: reactMotion.spring(y, springConfig),
          measuresY: reactMotion.spring((height - measureHeight) / 2, springConfig)
        }
      }, function (values) {
        return React__default.createElement("g", {
          transform: "translate(".concat(values.x, ",").concat(values.y, ")"),
          onMouseEnter: partial(_this2.handleMouseEnter, data),
          onMouseMove: partial(_this2.handleMouseEnter, data),
          onMouseLeave: partial(_this2.handleMouseLeave, data)
        }, rangeNodes, React__default.createElement(EnhancedBulletRects, _extends({
          data: computedMeasures,
          scale: scale,
          layout: layout,
          reverse: reverse,
          x: 0,
          y: values.measuresY,
          width: width,
          height: measureHeight,
          component: measureComponent,
          onMouseEnter: partial(_this2.handleMeasureTooltip, showTooltip),
          onMouseLeave: hideTooltip,
          onClick: _this2.handleMeasureClick
        }, motionProps)), axis, markerNodes, titleNode);
      });
    }
  }]);

  return BulletItem;
}(React.Component);

_defineProperty$5(BulletItem, "propTypes", {
  id: PropTypes.string.isRequired,
  scale: PropTypes.func.isRequired,
  ranges: PropTypes.arrayOf(PropTypes.number).isRequired,
  computedRanges: PropTypes.arrayOf(PropTypes.shape({
    index: PropTypes.number.isRequired,
    v0: PropTypes.number.isRequired,
    v1: PropTypes.number.isRequired,
    color: PropTypes.string.isRequired
  })).isRequired,
  measures: PropTypes.arrayOf(PropTypes.number).isRequired,
  computedMeasures: PropTypes.arrayOf(PropTypes.shape({
    index: PropTypes.number.isRequired,
    v0: PropTypes.number.isRequired,
    v1: PropTypes.number.isRequired,
    color: PropTypes.string.isRequired
  })).isRequired,
  markers: PropTypes.arrayOf(PropTypes.number).isRequired,
  computedMarkers: PropTypes.arrayOf(PropTypes.shape({
    value: PropTypes.number.isRequired,
    index: PropTypes.number.isRequired,
    color: PropTypes.string.isRequired
  })).isRequired,
  layout: PropTypes.oneOf(['horizontal', 'vertical']).isRequired,
  reverse: PropTypes.bool.isRequired,
  axisPosition: PropTypes.oneOf(['before', 'after']).isRequired,
  axisValueFormat: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
  x: PropTypes.number.isRequired,
  y: PropTypes.number.isRequired,
  width: PropTypes.number.isRequired,
  height: PropTypes.number.isRequired,
  title: PropTypes.node,
  titlePosition: PropTypes.oneOf(['before', 'after']).isRequired,
  titleAlign: PropTypes.oneOf(['start', 'middle', 'end']).isRequired,
  titleOffsetX: PropTypes.number.isRequired,
  titleOffsetY: PropTypes.number.isRequired,
  titleRotation: PropTypes.number.isRequired,
  rangeComponent: PropTypes.func.isRequired,
  rangeColors: PropTypes.any.isRequired,
  rangeColorScale: PropTypes.func.isRequired,
  onRangeClick: PropTypes.func.isRequired,
  measureHeight: PropTypes.number.isRequired,
  measureComponent: PropTypes.func.isRequired,
  measureColors: PropTypes.any.isRequired,
  measureColorScale: PropTypes.func.isRequired,
  onMeasureClick: PropTypes.func.isRequired,
  markerHeight: PropTypes.number.isRequired,
  markerComponent: PropTypes.func.isRequired,
  markerColors: PropTypes.any.isRequired,
  markerColorScale: PropTypes.func.isRequired,
  onMarkerClick: PropTypes.func.isRequired,
  markerTooltip: PropTypes.func,
  measureTooltip: PropTypes.func,
  rangeTooltip: PropTypes.func,
  theme: core.themePropType.isRequired,
  showTooltip: PropTypes.func.isRequired,
  hideTooltip: PropTypes.func.isRequired,
  onMouseEnter: PropTypes.func.isRequired,
  onMouseLeave: PropTypes.func.isRequired
});

var EnhancedBulletItem = compose(defaultProps({
  layout: 'horizontal',
  reverse: false,
  axisPosition: 'after',
  titlePosition: 'before',
  titleAlign: 'middle',
  titleRotation: 0,
  titleOffsetX: 0,
  titleOffsetY: 0,
  rangeComponent: BulletRectsItem,
  rangeColors: 'seq:cool',
  onRangeClick: core.noop,
  measureComponent: BulletRectsItem,
  measureColors: 'seq:red_purple',
  onMeasureClick: core.noop,
  markers: [],
  markerComponent: BulletMarkersItem,
  markerColors: 'seq:red_purple',
  onMarkerClick: core.noop,
  showTooltip: core.noop,
  hideTooltip: core.noop
}), core.withMotion(), withPropsOnChange(['rangeColors', 'scale'], function (_ref) {
  var rangeColors = _ref.rangeColors,
      scale = _ref.scale;
  return {
    rangeColorScale: core.getColorScale(rangeColors, scale, true)
  };
}), withPropsOnChange(['ranges', 'rangeColorScale'], function (_ref2) {
  var ranges = _ref2.ranges,
      rangeColorScale = _ref2.rangeColorScale;
  return {
    computedRanges: stackValues(ranges, rangeColorScale)
  };
}), withPropsOnChange(['measureColors', 'scale'], function (_ref3) {
  var measureColors = _ref3.measureColors,
      scale = _ref3.scale;
  return {
    measureColorScale: core.getColorScale(measureColors, scale)
  };
}), withPropsOnChange(['measures', 'measureColorScale'], function (_ref4) {
  var measures = _ref4.measures,
      measureColorScale = _ref4.measureColorScale;
  return {
    computedMeasures: stackValues(measures, measureColorScale)
  };
}), withPropsOnChange(['markerColors', 'scale'], function (_ref5) {
  var markerColors = _ref5.markerColors,
      scale = _ref5.scale;
  return {
    markerColorScale: core.getColorScale(markerColors, scale)
  };
}), withPropsOnChange(['markers', 'markerColorScale'], function (_ref6) {
  var markers = _ref6.markers,
      markerColorScale = _ref6.markerColorScale;
  return {
    computedMarkers: markers.map(function (marker, index) {
      return {
        value: marker,
        index: index,
        color: markerColorScale(markerColorScale.type === 'sequential' ? marker : index)
      };
    })
  };
}), pure)(BulletItem);
EnhancedBulletItem.displayName = 'BulletItem';

function _objectSpread$4(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty$6(target, key, source[key]); }); } return target; }

function _defineProperty$6(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; }
var commonPropTypes = {
  data: PropTypes.arrayOf(PropTypes.shape({
    id: PropTypes.string.isRequired,
    title: PropTypes.node,
    ranges: PropTypes.arrayOf(PropTypes.number).isRequired,
    measures: PropTypes.arrayOf(PropTypes.number).isRequired,
    markers: PropTypes.arrayOf(PropTypes.number)
  })).isRequired,
  layout: PropTypes.oneOf(['horizontal', 'vertical']).isRequired,
  reverse: PropTypes.bool.isRequired,
  spacing: PropTypes.number.isRequired,
  titlePosition: PropTypes.oneOf(['before', 'after']).isRequired,
  titleAlign: PropTypes.oneOf(['start', 'middle', 'end']).isRequired,
  titleOffsetX: PropTypes.number.isRequired,
  titleOffsetY: PropTypes.number.isRequired,
  titleRotation: PropTypes.number.isRequired,
  rangeColors: PropTypes.any.isRequired,
  rangeBorderWidth: PropTypes.number.isRequired,
  rangeBorderColor: PropTypes.any.isRequired,
  onRangeClick: PropTypes.func,
  measureColors: PropTypes.any.isRequired,
  measureSize: PropTypes.number.isRequired,
  measureBorderWidth: PropTypes.number.isRequired,
  measureBorderColor: PropTypes.any.isRequired,
  onMeasureClick: PropTypes.func,
  markerColors: PropTypes.any.isRequired,
  markerSize: PropTypes.number.isRequired,
  onMarkerClick: PropTypes.func,
  axisPosition: PropTypes.oneOf(['before', 'after']).isRequired,
  theme: core.themePropType.isRequired,
  overrides: PropTypes.arrayOf(PropTypes.shape({
    id: PropTypes.string.isRequired,
    reverse: PropTypes.bool,
    rangeColors: PropTypes.any,
    rangeBorderWidth: PropTypes.number,
    rangeBorderColor: PropTypes.any,
    measureColors: PropTypes.any,
    measureBorderWidth: PropTypes.number,
    measureBorderColor: PropTypes.any,
    axis: PropTypes.shape({
      position: PropTypes.oneOf(['before', 'after']),
      min: PropTypes.number,
      max: PropTypes.number
    })