import React, { Fragment, Component, PureComponent } from 'react';
import { scaleLinear } from 'd3-scale';
import setDisplayName from 'recompose/setDisplayName';
import { motionPropTypes, colorMotionSpring, getInterpolatedColor, themePropType, noop, withMotion, getColorScale, BasicTooltip, Axis, withDimensions, withTheme, Container, SvgWrapper, ResponsiveWrapper } from '@nivo/core';
import PropTypes from 'prop-types';
import isString from 'lodash/isString';
import { TransitionMotion, spring, Motion } from 'react-motion';
import partial from 'lodash/partial';
import compose from 'recompose/compose';
import defaultProps from 'recompose/defaultProps';
import withPropsOnChange from 'recompose/withPropsOnChange';
import pure from 'recompose/pure';
import last from '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.createElement(Fragment, null, markers.map(function (marker) {
          return React.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.createElement(TransitionMotion, {
        styles: markers.map(function (marker, i) {
          var position = getPosition(marker);
          return {
            key: "".concat(i),
            data: marker,
            style: _objectSpread$1({
              x: spring(position.x, springConfig),
              y: spring(position.y, springConfig),
              size: spring(position.size, springConfig),
              rotation: spring(position.rotation, springConfig)
            }, colorMotionSpring(marker.color, springConfig))
          };
        })
      }, function (interpolatedStyles) {
        return React.createElement(Fragment, null, interpolatedStyles.map(function (_ref2) {
          var key = _ref2.key,
              style = _ref2.style,
              marker = _ref2.data;
          var color = getInterpolatedColor(style);
          return React.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;
}(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
}, 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.createElement("g", {
          transform: transform
        }, rects.map(function (rect) {
          return React.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.createElement("g", {
        transform: transform
      }, React.createElement(TransitionMotion, {
        styles: rects.map(function (rect) {
          return {
            key: "".concat(rect.data.index),
            data: rect.data,
            style: _objectSpread$2({
              x: spring(rect.x, springConfig),
              y: spring(rect.y, springConfig),
              width: spring(rect.width, springConfig),
              height: spring(rect.height, springConfig)
            }, colorMotionSpring(rect.data.color, springConfig))
          };
        })
      }, function (interpolatedStyles) {
        return React.createElement(Fragment, null, interpolatedStyles.map(function (_ref) {
          var key = _ref.key,
              style = _ref.style,
              data = _ref.data;
          var color = getInterpolatedColor(style);
          return React.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;
}(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
}, 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.createElement("rect", {
        x: x,
        y: y,
        width: width,
        height: height,
        fill: color,
        onMouseMove: onMouseMove,
        onMouseEnter: onMouseEnter,
        onMouseLeave: onMouseLeave,
        onClick: onClick
      });
    }
  }]);

  return BulletRectsItem;
}(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.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;
}(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.createElement(BasicTooltip, {
        id: React.createElement("span", null, React.createElement("strong", null, range.v0), " to ", React.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.createElement(BasicTooltip, {
        id: React.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.createElement(BasicTooltip, {
        id: React.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.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.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.createElement(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.createElement("g", {
        transform: "translate(".concat(titleX, ",").concat(titleY, ") rotate(").concat(titleRotation, ")")
      }, isString(title) ? React.createElement("text", {
        style: _objectSpread$3({}, theme.labels.text, {
          alignmentBaseline: 'central',
          textAnchor: titleAlign
        })
      }, title) : title);

      if (animate !== true) {
        return React.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.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.createElement(Motion, {
        style: {
          x: spring(x, springConfig),
          y: spring(y, springConfig),
          measuresY: spring((height - measureHeight) / 2, springConfig)
        }
      }, function (values) {
        return React.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.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;
}(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: 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: noop,
  measureComponent: BulletRectsItem,
  measureColors: 'seq:red_purple',
  onMeasureClick: noop,
  markers: [],
  markerComponent: BulletMarkersItem,
  markerColors: 'seq:red_purple',
  onMarkerClick: noop,
  showTooltip: noop,
  hideTooltip: noop
}), withMotion(), withPropsOnChange(['rangeColors', 'scale'], function (_ref) {
  var rangeColors = _ref.rangeColors,
      scale = _ref.scale;
  return {
    rangeColorScale: 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: 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: 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: 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
    })
  })).isRequired
};
var BulletPropTypes = _objectSpread$4({}, commonPropTypes);
var commonDefaultProps = {
  layout: EnhancedBulletItem.defaultProps.layout,
  reverse: EnhancedBulletItem.defaultProps.reverse,
  spacing: 30,
  titlePosition: EnhancedBulletItem.defaultProps.titlePosition,
  titleAlign: EnhancedBulletItem.defaultProps.titleAlign,
  titleOffsetX: EnhancedBulletItem.defaultProps.titleOffsetX,
  titleOffsetY: EnhancedBulletItem.defaultProps.titleOffsetY,
  titleRotation: EnhancedBulletItem.defaultProps.titleRotation,
  rangeBorderWidth: 0,
  rangeBorderColor: 'inherit',
  measureSize: 0.4,
  measureBorderWidth: 0,
  measureBorderColor: 'inherit',
  markerSize: 0.6,
  markerColors: EnhancedBulletItem.defaultProps.markerColors,
  axisPosition: EnhancedBulletItem.defaultProps.axisPosition,
  rangeColors: EnhancedBulletItem.defaultProps.rangeColors,
  measureColors: EnhancedBulletItem.defaultProps.measureColors,
  isInteractive: true,
  onClick: noop,
  overrides: []
};
var BulletDefaultProps = _objectSpread$4({}, commonDefaultProps);

var props = /*#__PURE__*/Object.freeze({
    BulletPropTypes: BulletPropTypes,
    BulletDefaultProps: BulletDefaultProps
});

var commonEnhancers = [withDimensions(), withTheme()];
var enhance = (function (Component) {
  var implDefaultProps = props["".concat(Component.displayName, "DefaultProps")];

  switch (Component.displayName) {
    case 'Bullet':
      return compose.apply(void 0, [defaultProps(implDefaultProps)].concat(commonEnhancers, [withMotion(), pure]))(Component);
  }

  return Component;
});

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

function _extends$1() { _extends$1 = 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$1.apply(this, arguments); }

function _toConsumableArray$1(arr) { return _arrayWithoutHoles$1(arr) || _iterableToArray$1(arr) || _nonIterableSpread$1(); }

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

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

function _arrayWithoutHoles$1(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }

function _objectSpread$5(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$7(target, key, source[key]); }); } return target; }

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

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

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

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

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

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

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

function _defineProperty$7(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 Bullet =
/*#__PURE__*/
function (_Component) {
  _inherits$5(Bullet, _Component);

  function Bullet() {
    var _getPrototypeOf2;

    var _this;

    _classCallCheck$5(this, Bullet);

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

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

    _defineProperty$7(_assertThisInitialized$5(_this), "handleBulletTooltip", function (showTooltip, bullet, event) {
      var _this$props = _this.props,
          bulletTooltip = _this$props.bulletTooltip,
          theme = _this$props.theme;
      showTooltip(React.createElement(BasicTooltip, {
        id: bullet.id,
        enableChip: true,
        color: bullet.color,
        theme: theme //format={format}
        ,
        renderContent: typeof bulletTooltip === 'function' ? bulletTooltip.bind(null, _objectSpread$5({}, bullet)) : null
      }), event);
    });

    return _this;
  }

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

      var _this$props2 = this.props,
          data = _this$props2.data,
          layout = _this$props2.layout,
          spacing = _this$props2.spacing,
          measureSize = _this$props2.measureSize,
          markerSize = _this$props2.markerSize,
          reverse = _this$props2.reverse,
          axisPosition = _this$props2.axisPosition,
          axisValueFormat = _this$props2.axisValueFormat,
          margin = _this$props2.margin,
          width = _this$props2.width,
          height = _this$props2.height,
          outerWidth = _this$props2.outerWidth,
          outerHeight = _this$props2.outerHeight,
          titlePosition = _this$props2.titlePosition,
          titleAlign = _this$props2.titleAlign,
          titleOffsetX = _this$props2.titleOffsetX,
          titleOffsetY = _this$props2.titleOffsetY,
          titleRotation = _this$props2.titleRotation,
          rangeComponent = _this$props2.rangeComponent,
          rangeColors = _this$props2.rangeColors,
          measureComponent = _this$props2.measureComponent,
          measureColors = _this$props2.measureColors,
          markerComponent = _this$props2.markerComponent,
          markerColors = _this$props2.markerColors,
          theme = _this$props2.theme,
          measureTooltip = _this$props2.measureTooltip,
          rangeTooltip = _this$props2.rangeTooltip,
          markerTooltip = _this$props2.markerTooltip,
          bulletTooltip = _this$props2.bulletTooltip,
          animate = _this$props2.animate,
          motionStiffness = _this$props2.motionStiffness,
          motionDamping = _this$props2.motionDamping,
          isInteractive = _this$props2.isInteractive,
          onRangeClick = _this$props2.onRangeClick,
          onMeasureClick = _this$props2.onMeasureClick,
          onMarkerClick = _this$props2.onMarkerClick;
      var itemHeight;

      if (layout === 'horizontal') {
        itemHeight = (height - spacing * (data.length - 1)) / data.length;
      } else {
        itemHeight = (width - spacing * (data.length - 1)) / data.length;
      }

      var measureHeight = itemHeight * measureSize;
      var markerHeight = itemHeight * markerSize;
      var enhancedData = data.map(function (d) {
        var all = [].concat(_toConsumableArray$1(d.ranges), _toConsumableArray$1(d.measures), _toConsumableArray$1(d.markers));
        var max = Math.max.apply(Math, _toConsumableArray$1(all));
        var scale = scaleLinear().domain([0, max]);

        if (layout === 'horizontal') {
          scale.range(reverse === true ? [width, 0] : [0, width]);
        } else {
          scale.range(reverse === true ? [0, height] : [height, 0]);
        }

        return _objectSpread$5({}, d, {
          scale: scale
        });
      });
      var motionProps = {
        animate: animate,
        motionDamping: motionDamping,
        motionStiffness: motionStiffness
      };
      return React.createElement(Container, {
        isInteractive: isInteractive,
        theme: theme
      }, function (_ref) {
        var showTooltip = _ref.showTooltip,
            hideTooltip = _ref.hideTooltip;
        return React.createElement(SvgWrapper, {
          width: outerWidth,
          height: outerHeight,
          margin: margin,
          theme: theme
        }, enhancedData.map(function (d, i) {
          return React.createElement(EnhancedBulletItem, _extends$1({
            key: d.id,
            data: d
          }, d, {
            layout: layout,
            reverse: reverse,
            x: layout === 'vertical' ? itemHeight * i + spacing * i : 0,
            y: layout === 'horizontal' ? itemHeight * i + spacing * i : 0,
            width: width,
            height: itemHeight,
            titlePosition: titlePosition,
            titleAlign: titleAlign,
            titleOffsetX: titleOffsetX,
            titleOffsetY: titleOffsetY,
            titleRotation: titleRotation,
            measureHeight: measureHeight,
            markerHeight: markerHeight,
            rangeComponent: rangeComponent,
            rangeColors: rangeColors,
            measureComponent: measureComponent,
            measureColors: measureColors,
            markerComponent: markerComponent,
            markerColors: markerColors,
            theme: theme,
            axisPosition: axisPosition,
            axisValueFormat: axisValueFormat
          }, motionProps, {
            showTooltip: showTooltip,
            hideTooltip: hideTooltip,
            onRangeClick: onRangeClick,
            onMeasureClick: onMeasureClick,
            onMarkerClick: onMarkerClick,
            onMouseEnter: partial(_this2.handleBulletTooltip, showTooltip),
            onMouseLeave: hideTooltip,
            measureTooltip: measureTooltip,
            rangeTooltip: rangeTooltip,
            markerTooltip: markerTooltip
          }));
        }));
      });
    }
  }]);

  return Bullet;
}(Component);

_defineProperty$7(Bullet, "propTypes", BulletPropTypes);

Bullet.displayName = 'Bullet';
var Bullet$1 = setDisplayName(Bullet.displayName)(enhance(Bullet));

function _extends$2() { _extends$2 = 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$2.apply(this, arguments); }

var ResponsiveBullet = function ResponsiveBullet(props) {
  return React.createElement(ResponsiveWrapper, null, function (_ref) {
    var width = _ref.width,
        height = _ref.height;
    return React.createElement(Bullet$1, _extends$2({
      width: width,
      height: height
    }, props));
  });
};

export { Bullet$1 as Bullet, BulletDefaultProps, EnhancedBulletItem as BulletItem, BulletPropTypes, ResponsiveBullet };