victory-chart
Version:
Chart Component for Victory
213 lines (178 loc) • 8.63 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", {
value: true
});
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };
var _invert = require("lodash/invert");
var _invert2 = _interopRequireDefault(_invert);
var _sortBy = require("lodash/sortBy");
var _sortBy2 = _interopRequireDefault(_sortBy);
var _values = require("lodash/values");
var _values2 = _interopRequireDefault(_values);
var _identity = require("lodash/identity");
var _identity2 = _interopRequireDefault(_identity);
var _uniq = require("lodash/uniq");
var _uniq2 = _interopRequireDefault(_uniq);
var _flatten = require("lodash/flatten");
var _flatten2 = _interopRequireDefault(_flatten);
var _axis = require("../../helpers/axis");
var _axis2 = _interopRequireDefault(_axis);
var _data = require("../../helpers/data");
var _data2 = _interopRequireDefault(_data);
var _domain = require("../../helpers/domain");
var _domain2 = _interopRequireDefault(_domain);
var _wrapper = require("../../helpers/wrapper");
var _wrapper2 = _interopRequireDefault(_wrapper);
var _react = require("react");
var _react2 = _interopRequireDefault(_react);
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 = {
getChildComponents: function getChildComponents(props, defaultAxes) {
var childComponents = _react2.default.Children.toArray(props.children);
if (childComponents.length === 0) {
return [defaultAxes.independent, defaultAxes.dependent];
}
var axisComponents = childComponents.filter(function (component) {
return component.type && component.type.role === "axis";
});
if (axisComponents.length === 0) {
return childComponents.concat(defaultAxes.independent, defaultAxes.dependent);
}
var dependentAxes = axisComponents.filter(function (component) {
return component.props.dependentAxis;
});
var independentAxes = axisComponents.filter(function (component) {
return !component.props.dependentAxis;
});
if (dependentAxes.length > 1 || independentAxes.length > 1) {
var msg = "Only one VictoryAxis component of each axis type is allowed when" + "using the VictoryChart wrapper. Only the first axis will be used. Please compose " + "multi-axis charts manually";
_victoryCore.Log.warn(msg);
var dataComponents = childComponents.filter(function (component) {
return component.type && component.type.role !== "axis";
});
return _victoryCore.Collection.removeUndefined(dataComponents.concat(independentAxes[0], dependentAxes[0]));
}
return childComponents;
},
getDataComponents: function getDataComponents(childComponents) {
return childComponents.filter(function (child) {
var role = child.type && child.type.role;
return role !== "axis";
});
},
getDomain: function getDomain(props, childComponents, axis) {
var domain = _wrapper2.default.getDomainFromChildren(props, axis);
var orientations = _axis2.default.getAxisOrientations(childComponents);
return _domain2.default.orientDomain(domain, orientations, axis);
},
getAxisOffset: function getAxisOffset(props, calculatedProps) {
var axisComponents = calculatedProps.axisComponents;
var domain = calculatedProps.domain;
var scale = calculatedProps.scale;
// make the axes line up, and cross when appropriate
var origin = {
x: Math.max(Math.min.apply(Math, _toConsumableArray(domain.x)), 0),
y: Math.max(Math.min.apply(Math, _toConsumableArray(domain.y)), 0)
};
var axisOrientations = {
x: _axis2.default.getOrientation(axisComponents.x, "x"),
y: _axis2.default.getOrientation(axisComponents.y, "y")
};
var orientationOffset = {
x: axisOrientations.y === "left" ? 0 : props.width,
y: axisOrientations.x === "bottom" ? props.height : 0
};
var calculatedOffset = {
x: Math.abs(orientationOffset.x - scale.x.call(null, origin.x)),
y: Math.abs(orientationOffset.y - scale.y.call(null, origin.y))
};
return {
x: axisComponents.x && axisComponents.x.offsetX || calculatedOffset.x,
y: axisComponents.y && axisComponents.y.offsetY || calculatedOffset.y
};
},
getTicksFromData: function getTicksFromData(calculatedProps, axis) {
var stringMap = calculatedProps.stringMap[axis];
// if tickValues are defined for an axis component use them
var categoryArray = calculatedProps.categories[axis];
var ticksFromCategories = categoryArray && _victoryCore.Collection.containsOnlyStrings(categoryArray) ? categoryArray.map(function (tick) {
return stringMap[tick];
}) : categoryArray;
var ticksFromStringMap = stringMap && (0, _values2.default)(stringMap);
// when ticks is undefined, axis will determine it's own ticks
return ticksFromCategories && ticksFromCategories.length !== 0 ? ticksFromCategories : ticksFromStringMap;
},
getTicksFromAxis: function getTicksFromAxis(calculatedProps, axis, component) {
var tickValues = component.props.tickValues;
if (!tickValues) {
return undefined;
}
var stringMap = calculatedProps.stringMap[axis];
return _victoryCore.Collection.containsOnlyStrings(tickValues) && stringMap ? tickValues.map(function (tick) {
return stringMap[tick];
}) : tickValues;
},
getTicks: function getTicks() {
return this.getTicksFromAxis.apply(this, arguments) || this.getTicksFromData.apply(this, arguments);
},
getTickFormat: function getTickFormat(component, axis, calculatedProps) {
var tickValues = component.props.tickValues;
var stringMap = calculatedProps.stringMap[axis];
if (tickValues && !_victoryCore.Collection.containsStrings(tickValues)) {
return _identity2.default;
} else if (stringMap !== null) {
var _ret = function () {
var tickValueArray = (0, _sortBy2.default)((0, _values2.default)(stringMap), function (n) {
return n;
});
var invertedStringMap = (0, _invert2.default)(stringMap);
var dataNames = tickValueArray.map(function (tick) {
return invertedStringMap[tick];
});
// string ticks should have one tick of padding at the beginning
var dataTicks = [""].concat(_toConsumableArray(dataNames), [""]);
return {
v: function v(x) {
return dataTicks[x];
}
};
}();
if ((typeof _ret === "undefined" ? "undefined" : _typeof(_ret)) === "object") return _ret.v;
} else {
return calculatedProps.scale[axis].tickFormat() || _identity2.default;
}
},
getStringsFromChildData: function getStringsFromChildData(child, axis) {
if (!child.props.data && !child.type.getData) {
return [];
}
if (child.props.data) {
return _data2.default.getStringsFromData(child.props, axis);
}
var data = (0, _flatten2.default)(child.type.getData(child.props));
var attr = axis === "x" ? "xName" : "yName";
return data.reduce(function (prev, datum) {
return datum[attr] ? prev.concat(datum[attr]) : prev;
}, []);
},
createStringMap: function createStringMap(childComponents, axis) {
var _this = this;
var axisComponent = _axis2.default.getAxisComponent(childComponents, axis);
var tickStrings = axisComponent ? _data2.default.getStringsFromAxes(axisComponent.props, axis) : [];
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 = _this.getStringsFromChildData(component, axis);
return stringData ? prev.concat(stringData) : prev;
}, []);
var allStrings = (0, _uniq2.default)((0, _flatten2.default)([].concat(_toConsumableArray(tickStrings), _toConsumableArray(categoryStrings), _toConsumableArray(dataStrings))));
return allStrings.length === 0 ? null : allStrings.reduce(function (memo, string, index) {
memo[string] = index + 1;
return memo;
}, {});
}
};