"use strict"; module.exports = function(Chart) { var helpers = Chart.helpers; var defaultConfig = { position: "left", ticks: { callback: function(tickValue, index, ticks) { // If we have lots of ticks, don't use the ones var delta = ticks.length > 3 ? ticks[2] - ticks[1] : ticks[1] - ticks[0]; // If we have a number like 2.5 as the delta, figure out how many decimal places we need if (Math.abs(delta) > 1) { if (tickValue !== Math.floor(tickValue)) { // not an integer delta = tickValue - Math.floor(tickValue); } } var logDelta = helpers.log10(Math.abs(delta)); var tickString = ''; if (tickValue !== 0) { var numDecimal = -1 * Math.floor(logDelta); numDecimal = Math.max(Math.min(numDecimal, 20), 0); // toFixed has a max of 20 decimal places tickString = tickValue.toFixed(numDecimal); } else { tickString = '0'; // never show decimal places for 0 } return tickString; } } }; var LinearScale = Chart.Scale.extend({ determineDataLimits: function() { var _this = this; var opts = _this.options; var tickOpts = opts.ticks; var chart = _this.chart; var data = chart.data; var datasets = data.datasets; var isHorizontal = _this.isHorizontal(); function IDMatches(meta) { return isHorizontal ? meta.xAxisID === _this.id : meta.yAxisID === _this.id; } // First Calculate the range _this.min = null; _this.max = null; if (opts.stacked) { var valuesPerType = {}; var hasPositiveValues = false; var hasNegativeValues = false; helpers.each(datasets, function(dataset, datasetIndex) { var meta = chart.getDatasetMeta(datasetIndex); if (valuesPerType[meta.type] === undefined) { valuesPerType[meta.type] = { positiveValues: [], negativeValues: [] }; } // Store these per type var positiveValues = valuesPerType[meta.type].positiveValues; var negativeValues = valuesPerType[meta.type].negativeValues; if (chart.isDatasetVisible(datasetIndex) && IDMatches(meta)) { helpers.each(dataset.data, function(rawValue, index) { var value = +_this.getRightValue(rawValue); if (isNaN(value) || meta.data[index].hidden) { return; } positiveValues[index] = positiveValues[index] || 0; negativeValues[index] = negativeValues[index] || 0; if (opts.relativePoints) { positiveValues[index] = 100; } else { if (value < 0) { hasNegativeValues = true; negativeValues[index] += value; } else { hasPositiveValues = true; positiveValues[index] += value; } } }); } }); helpers.each(valuesPerType, function(valuesForType) { var values = valuesForType.positiveValues.concat(valuesForType.negativeValues); var minVal = helpers.min(values); var maxVal = helpers.max(values); _this.min = _this.min === null ? minVal : Math.min(_this.min, minVal); _this.max = _this.max === null ? maxVal : Math.max(_this.max, maxVal); }); } else { helpers.each(datasets, function(dataset, datasetIndex) { var meta = chart.getDatasetMeta(datasetIndex); if (chart.isDatasetVisible(datasetIndex) && IDMatches(meta)) { helpers.each(dataset.data, function(rawValue, index) { var value = +_this.getRightValue(rawValue); if (isNaN(value) || meta.data[index].hidden) { return; } if (_this.min === null) { _this.min = value; } else if (value < _this.min) { _this.min = value; } if (_this.max === null) { _this.max = value; } else if (value > _this.max) { _this.max = value; } }); } }); } // If we are forcing it to begin at 0, but 0 will already be rendered on the chart, // do nothing since that would make the chart weird. If the user really wants a weird chart // axis, they can manually override it if (tickOpts.beginAtZero) { var minSign = helpers.sign(_this.min); var maxSign = helpers.sign(_this.max); if (minSign < 0 && maxSign < 0) { // move the top up to 0 _this.max = 0; } else if (minSign > 0 && maxSign > 0) { // move the botttom down to 0 _this.min = 0; } } if (tickOpts.min !== undefined) { _this.min = tickOpts.min; } else if (tickOpts.suggestedMin !== undefined) { _this.min = Math.min(_this.min, tickOpts.suggestedMin); } if (tickOpts.max !== undefined) { _this.max = tickOpts.max; } else if (tickOpts.suggestedMax !== undefined) { _this.max = Math.max(_this.max, tickOpts.suggestedMax); } if (_this.min === _this.max) { _this.max++; if (!tickOpts.beginAtZero) { _this.min--; } } }, buildTicks: function() { var _this = this; var opts = _this.options; var tickOpts = opts.ticks; var getValueOrDefault = helpers.getValueOrDefault; var isHorizontal = _this.isHorizontal(); var ticks = _this.ticks = []; // Figure out what the max number of ticks we can support it is based on the size of // the axis area. For now, we say that the minimum tick spacing in pixels must be 50 // We also limit the maximum number of ticks to 11 which gives a nice 10 squares on // the graph var maxTicks; if (isHorizontal) { maxTicks = Math.min(tickOpts.maxTicksLimit ? tickOpts.maxTicksLimit : 11, Math.ceil(_this.width / 50)); } else { // The factor of 2 used to scale the font size has been experimentally determined. var tickFontSize = getValueOrDefault(tickOpts.fontSize, Chart.defaults.global.defaultFontSize); maxTicks = Math.min(tickOpts.maxTicksLimit ? tickOpts.maxTicksLimit : 11, Math.ceil(_this.height / (2 * tickFontSize))); } // Make sure we always have at least 2 ticks maxTicks = Math.max(2, maxTicks); // To get a "nice" value for the tick spacing, we will use the appropriately named // "nice number" algorithm. See http://stackoverflow.com/questions/8506881/nice-label-algorithm-for-charts-with-minimum-ticks // for details. var spacing; var fixedStepSizeSet = (tickOpts.fixedStepSize && tickOpts.fixedStepSize > 0) || (tickOpts.stepSize && tickOpts.stepSize > 0); if (fixedStepSizeSet) { spacing = getValueOrDefault(tickOpts.fixedStepSize, tickOpts.stepSize); } else { var niceRange = helpers.niceNum(_this.max - _this.min, false); spacing = helpers.niceNum(niceRange / (maxTicks - 1), true); } var niceMin = Math.floor(_this.min / spacing) * spacing; var niceMax = Math.ceil(_this.max / spacing) * spacing; var numSpaces = (niceMax - niceMin) / spacing; // If very close to our rounded value, use it. if (helpers.almostEquals(numSpaces, Math.round(numSpaces), spacing / 1000)) { numSpaces = Math.round(numSpaces); } else { numSpaces = Math.ceil(numSpaces); } // Put the values into the ticks array ticks.push(tickOpts.min !== undefined ? tickOpts.min : niceMin); for (var j = 1; j < numSpaces; ++j) { ticks.push(niceMin + (j * spacing)); } ticks.push(tickOpts.max !== undefined ? tickOpts.max : niceMax); if (!isHorizontal) { // We are in a vertical orientation. The top value is the highest. So reverse the array ticks.reverse(); } // At this point, we need to update our max and min given the tick values since we have expanded the // range of the scale _this.max = helpers.max(ticks); _this.min = helpers.min(ticks); if (tickOpts.reverse) { ticks.reverse(); _this.start = _this.max; _this.end = _this.min; } else { _this.start = _this.min; _this.end = _this.max; } }, getLabelForIndex: function(index, datasetIndex) { return +this.getRightValue(this.chart.data.datasets[datasetIndex].data[index]); }, convertTicksToLabels: function() { var _this = this; _this.ticksAsNumbers = _this.ticks.slice(); _this.zeroLineIndex = _this.ticks.indexOf(0); Chart.Scale.prototype.convertTicksToLabels.call(_this); }, // Utils getPixelForValue: function(value, index, datasetIndex, includeOffset) { // This must be called after fit has been run so that // this.left, this.top, this.right, and this.bottom have been defined var _this = this; var paddingLeft = _this.paddingLeft; var paddingBottom = _this.paddingBottom; var start = _this.start; var rightValue = +_this.getRightValue(value); var pixel; var innerDimension; var range = _this.end - start; if (_this.isHorizontal()) { innerDimension = _this.width - (paddingLeft + _this.paddingRight); pixel = _this.left + (innerDimension / range * (rightValue - start)); return Math.round(pixel + paddingLeft); } else { innerDimension = _this.height - (_this.paddingTop + paddingBottom); pixel = (_this.bottom - paddingBottom) - (innerDimension / range * (rightValue - start)); return Math.round(pixel); } }, getValueForPixel: function(pixel) { var _this = this; var isHorizontal = _this.isHorizontal(); var paddingLeft = _this.paddingLeft; var paddingBottom = _this.paddingBottom; var innerDimension = isHorizontal ? _this.width - (paddingLeft + _this.paddingRight) : _this.height - (_this.paddingTop + paddingBottom); var offset = (isHorizontal ? pixel - _this.left - paddingLeft : _this.bottom - paddingBottom - pixel) / innerDimension; return _this.start + ((_this.end - _this.start) * offset); }, getPixelForTick: function(index, includeOffset) { return this.getPixelForValue(this.ticksAsNumbers[index], null, null, includeOffset); } }); Chart.scaleService.registerScaleType("linear", LinearScale, defaultConfig); };