victory-chart/lib/helpers/wrapper.js

Chart Component for Victory

"use strict";

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

var _defaults = require("lodash/defaults");

var _defaults2 = _interopRequireDefault(_defaults);

var _uniq = require("lodash/uniq");

var _uniq2 = _interopRequireDefault(_uniq);

var _flatten = require("lodash/flatten");

var _flatten2 = _interopRequireDefault(_flatten);

var _partialRight = require("lodash/partialRight");

var _partialRight2 = _interopRequireDefault(_partialRight);

var _react = require("react");

var _react2 = _interopRequireDefault(_react);

var _data = require("./data");

var _data2 = _interopRequireDefault(_data);

var _domain = require("./domain");

var _domain2 = _interopRequireDefault(_domain);

var _victoryCore = require("victory-core");

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

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

exports.default = {
  getData: function getData(props) {
    var childComponents = _react2.default.Children.toArray(props.children);
    return childComponents.map(function (child) {
      var getData = child.type.getData || _data2.default.getData;
      return getData(child.props);
    });
  },
  setAnimationState: function setAnimationState(nextProps) {
    if (!this.props.animate) {
      return;
    }
    if (this.props.animate.parentState) {
      var nodesWillExit = this.props.animate.parentState.nodesWillExit;
      var oldProps = nodesWillExit ? this.props : null;
      this.setState((0, _defaults2.default)({ oldProps: oldProps }, this.props.animate.parentState));
    } else {
      var oldChildren = _react2.default.Children.toArray(this.props.children);
      var nextChildren = _react2.default.Children.toArray(nextProps.children);

      var _Transitions$getIniti = _victoryCore.Transitions.getInitialTransitionState(oldChildren, nextChildren);

      var _nodesWillExit = _Transitions$getIniti.nodesWillExit;
      var nodesWillEnter = _Transitions$getIniti.nodesWillEnter;
      var childrenTransitions = _Transitions$getIniti.childrenTransitions;
      var nodesShouldEnter = _Transitions$getIniti.nodesShouldEnter;


      this.setState({
        nodesWillExit: _nodesWillExit,
        nodesWillEnter: nodesWillEnter,
        childrenTransitions: childrenTransitions,
        nodesShouldEnter: nodesShouldEnter,
        oldProps: _nodesWillExit ? this.props : null
      });
    }
  },
  getAnimationProps: function getAnimationProps(props, child, index) {
    var _this = this;

    if (!props.animate) {
      return child.props.animate;
    }
    var getFilteredState = function getFilteredState() {
      var childrenTransitions = _this.state && _this.state.childrenTransitions;
      childrenTransitions = _victoryCore.Collection.isArrayOfArrays(childrenTransitions) ? childrenTransitions[index] : childrenTransitions;
      return (0, _defaults2.default)({ childrenTransitions: childrenTransitions }, _this.state);
    };

    var getTransitions = props.animate && props.animate.getTransitions;
    var state = getFilteredState();
    var parentState = props.animate && props.animate.parentState || state;
    if (!getTransitions) {
      var getTransitionProps = _victoryCore.Transitions.getTransitionPropsFactory(props, state, function (newState) {
        return _this.setState(newState);
      });
      getTransitions = (0, _partialRight2.default)(getTransitionProps, index);
    }
    return (0, _defaults2.default)({ getTransitions: getTransitions, parentState: parentState }, props.animate, child.props.animate);
  },
  getDomainFromChildren: function getDomainFromChildren(props, axis) {
    var childComponents = _react2.default.Children.toArray(props.children);
    var domain = void 0;
    if (props.domain && (Array.isArray(props.domain) || props.domain[axis])) {
      domain = Array.isArray(props.domain) ? props.domain : props.domain[axis];
    } else {
      var childDomains = childComponents.reduce(function (prev, component) {
        var childDomain = component.type.getDomain(component.props, axis);
        return childDomain ? prev.concat(childDomain) : prev;
      }, []);
      domain = childDomains.length === 0 ? [0, 1] : [Math.min.apply(Math, _toConsumableArray(childDomains)), Math.max.apply(Math, _toConsumableArray(childDomains))];
    }
    return _domain2.default.padDomain(domain, props, axis);
  },
  getStackedDomain: function getStackedDomain(props, axis) {
    var propsDomain = _domain2.default.getDomainFromProps(props, axis);
    if (propsDomain) {
      return _domain2.default.padDomain(propsDomain, props, axis);
    }
    var ensureZero = function ensureZero(domain) {
      return axis === "y" ? [Math.min.apply(Math, _toConsumableArray(domain).concat([0])), Math.max.apply(Math, _toConsumableArray(domain).concat([0]))] : domain;
    };
    var childComponents = _react2.default.Children.toArray(props.children);
    var getData = function getData(child) {
      return child.type.getData(child.props) || _data2.default.getData(child.props);
    };
    var datasets = childComponents.map(function (child) {
      return child.props.children ? _react2.default.Children.toArray(child.props.children).map(function (ch) {
        return getData(ch);
      }) : getData(child);
    });
    var dataDomain = ensureZero(_domain2.default.getDomainFromGroupedData(props, axis, datasets));
    return _domain2.default.padDomain(dataDomain, props, axis);
  },
  getColor: function getColor(calculatedProps, index) {
    // check for styles first
    var style = calculatedProps.style;
    var colorScale = calculatedProps.colorScale;

    if (style && style.data && style.data.fill) {
      return style.data.fill;
    }
    var colors = Array.isArray(colorScale) ? colorScale : _victoryCore.Style.getColorScale(colorScale);
    return colors[index % colors.length];
  },
  getChildStyle: function getChildStyle(child, index, calculatedProps) {
    var style = calculatedProps.style;

    var role = child.type && child.type.role;
    var defaultFill = role === "group-wrapper" || role === "stack-wrapper" ? undefined : this.getColor(calculatedProps, index);
    var childStyle = child.props.style || {};
    var dataStyle = (0, _defaults2.default)({}, childStyle.data, style.data, { fill: defaultFill });
    var labelsStyle = (0, _defaults2.default)({}, childStyle.labels, style.labels);
    return {
      parent: style.parent,
      data: dataStyle,
      labels: labelsStyle
    };
  },
  getStringsFromChildren: function getStringsFromChildren(props, axis) {
    var childComponents = _react2.default.Children.toArray(props.children);
    var categoryStrings = childComponents.reduce(function (prev, component) {
      var categoryData = _data2.default.getStringsFromCategories(component.props, axis);
      return categoryData ? prev.concat(categoryData) : prev;
    }, []);
    var dataStrings = childComponents.reduce(function (prev, component) {
      var stringData = _data2.default.getStringsFromData(component.props, axis);
      return stringData ? prev.concat(stringData) : prev;
    }, []);
    return (0, _uniq2.default)((0, _flatten2.default)([].concat(_toConsumableArray(categoryStrings), _toConsumableArray(dataStrings))));
  },
  getCategories: function getCategories(props, axis) {
    var categories = _data2.default.getCategories(props, axis) || this.getStringsFromChildren(props, axis);
    return categories.length > 0 ? categories : undefined;
  },
  getY0: function getY0(datum, index, calculatedProps) {
    var datasets = calculatedProps.datasets;

    var y = datum.y;
    var previousDataSets = datasets.slice(0, index);
    var previousPoints = previousDataSets.reduce(function (prev, dataset) {
      return prev.concat(dataset.filter(function (previousDatum) {
        return datum.x instanceof Date ? previousDatum.x.getTime() === datum.x.getTime() : previousDatum.x === datum.x;
      }).map(function (previousDatum) {
        return previousDatum.y || 0;
      }));
    }, []);
    return previousPoints.reduce(function (memo, value) {
      var sameSign = y < 0 && value < 0 || y >= 0 && value >= 0;
      return sameSign ? memo + value : memo;
    }, 0);
  }
};