victory-chart/lib/helpers/data.js

Chart Component for Victory

"use strict";

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

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

var _uniq2 = _interopRequireDefault(_uniq);

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

var _defaults2 = _interopRequireDefault(_defaults);

var _assign = require("lodash/assign");

var _assign2 = _interopRequireDefault(_assign);

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

var _scale = require("./scale");

var _scale2 = _interopRequireDefault(_scale);

var _react = require("react");

var _react2 = _interopRequireDefault(_react);

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 = {
  // String Data

  createStringMap: function createStringMap(props, axis) {
    var hasMultipleDatasets = arguments.length <= 2 || arguments[2] === undefined ? false : arguments[2];

    var stringsFromAxes = this.getStringsFromAxes(props, axis);
    var stringsFromCategories = this.getStringsFromCategories(props, axis);
    var stringsFromData = hasMultipleDatasets ? props.data.reduce(function (prev, dataset) {
      return prev.concat(_victoryCore.Helpers.getStringsFromData((0, _defaults2.default)({}, { data: dataset }, props), axis));
    }, []) : this.getStringsFromData(props, axis);

    var allStrings = (0, _uniq2.default)([].concat(_toConsumableArray(stringsFromAxes), _toConsumableArray(stringsFromCategories), _toConsumableArray(stringsFromData)));
    return allStrings.length === 0 ? null : allStrings.reduce(function (memo, string, index) {
      memo[string] = index + 1;
      return memo;
    }, {});
  },
  getStringsFromAxes: function getStringsFromAxes(props, axis) {
    if (!props.tickValues || !Array.isArray(props.tickValues) && !props.tickValues[axis]) {
      return [];
    }
    var tickValueArray = props.tickValues[axis] || props.tickValues;
    return tickValueArray.filter(function (val) {
      return typeof val === "string";
    });
  },
  getStringsFromCategories: function getStringsFromCategories(props, axis) {
    var _this = this;

    var childComponents = props.children && _react2.default.Children.toArray(props.children);
    if (!props.categories && !props.children) {
      return [];
    }

    var getCategoryStrings = function getCategoryStrings(childProps) {
      var categories = _this.getCategories(childProps, axis);
      return categories && categories.filter(function (val) {
        return typeof val === "string";
      });
    };

    var categories = props.categories ? getCategoryStrings(props) : childComponents.map(function (child) {
      return getCategoryStrings(child.props);
    });

    return categories ? _victoryCore.Collection.removeUndefined(categories) : [];
  },
  getCategories: function getCategories(props, axis) {
    if (!props.categories) {
      return undefined;
    }
    return Array.isArray(props.categories) ? props.categories : props.categories[axis];
  },
  getStringsFromData: function getStringsFromData(props, axis) {
    var childComponents = props.children && _react2.default.Children.toArray(props.children);
    if (!props.data && !props.children) {
      return [];
    }

    var getStrings = function getStrings(childProps) {
      var accessor = _victoryCore.Helpers.createAccessor(typeof childProps[axis] !== "undefined" ? childProps[axis] : axis);
      return childProps.data ? childProps.data.reduce(function (prev, curr) {
        var datum = accessor(curr);
        return typeof datum === "string" && prev.indexOf(datum) === -1 ? prev.concat(datum) : prev;
      }, []) : undefined;
    };

    return props.data ? getStrings(props) : childComponents.map(function (child) {
      return getStrings(child.props);
    });
  },


  // for components that take single datasets
  getData: function getData(props) {
    if (props.data) {
      return this.formatData(props.data, props);
    }
    var data = this.generateData(props);
    return this.formatData(data, props);
  },
  generateData: function generateData(props) {
    // create an array of values evenly spaced across the x domain that include domain min/max
    var domain = props.domain ? props.domain.x || props.domain : _scale2.default.getBaseScale(props, "x").domain();
    var samples = props.samples || 1;
    var max = Math.max.apply(Math, _toConsumableArray(domain));
    var values = Array.apply(undefined, _toConsumableArray(Array(samples))).map(function (val, index) {
      var v = max / samples * index + Math.min.apply(Math, _toConsumableArray(domain));
      return { x: v, y: v };
    });
    return values[samples - 1].x === max ? values : values.concat([{ x: max, y: max }]);
  },
  formatData: function formatData(dataset, props, stringMap) {
    if (!dataset) {
      return [];
    }
    stringMap = stringMap || {
      x: this.createStringMap(props, "x"),
      y: this.createStringMap(props, "y")
    };
    var accessor = {
      x: _victoryCore.Helpers.createAccessor(props.x),
      y: _victoryCore.Helpers.createAccessor(props.y)
    };
    return this.cleanData(dataset, props).map(function (datum) {
      var x = accessor.x(datum);
      var y = accessor.y(datum);
      return (0, _assign2.default)({}, datum, { x: x, y: y },
      // map string data to numeric values, and add names
      typeof x === "string" ? { x: stringMap.x[x], xName: x } : {}, typeof y === "string" ? { y: stringMap.y[y], yName: y } : {});
    });
  },
  cleanData: function cleanData(dataset, props) {
    // Some scale types break when certain data is supplies. This method will
    // remove data points that break scales. So far this method only removes
    // zeroes for log scales
    // TODO other cases?
    var scaleType = {
      x: _scale2.default.getScaleType(props, "x"),
      y: _scale2.default.getScaleType(props, "y")
    };
    var accessor = {
      x: _victoryCore.Helpers.createAccessor(props.x),
      y: _victoryCore.Helpers.createAccessor(props.y)
    };
    if (scaleType.x !== "log" && scaleType.y !== "log") {
      return dataset;
    }
    var rules = function rules(datum, axis) {
      return scaleType[axis] === "log" ? accessor[axis](datum) !== 0 : true;
    };
    return dataset.filter(function (datum) {
      return rules(datum, "x") && rules(datum, "y");
    });
  }
};