Remove ticksToTimestamps and change ticks to numbers

Author: benmccann

docs/getting-started/v3-migration.md

@@ -124,10 +124,9 @@ Chart.js 3.0 introduces a number of breaking changes. Chart.js 2.0 was released
 ##### Ticks
 
 * When the `autoSkip` option is enabled, `Scale.ticks` now contains only the non-skipped ticks instead of all ticks.
-* `Scale.ticks` now contains objects instead of strings
-* `Scale.buildTicks` is now expected to return tick objects
+* `Scale.ticks` now contains the tick values instead of labels, which are now available in `Scale.labels`
 * `Scale.afterBuildTicks` now has no parameters like the other callbacks
-* `Scale.convertTicksToLabels` was renamed to `generateTickLabels`. It is now expected to set the label property on the ticks given as input
+* `TimeScale.buildTicks` is now expected to return `number`s like the other scales
 
 ##### Time Scale
 

src/core/core.helpers.js

@@ -82,17 +82,6 @@ module.exports = function() {
 			}
 		}
 	};
-	helpers._setMinAndMaxByKey = function(array, target, property) {
-		var i, ilen, value;
-
-		for (i = 0, ilen = array.length; i < ilen; i++) {
-			value = array[i][property];
-			if (!isNaN(value)) {
-				target.min = Math.min(target.min, value);
-				target.max = Math.max(target.max, value);
-			}
-		}
-	};
 	helpers.sign = Math.sign ?
 		function(x) {
 			return Math.sign(x);

src/core/core.scale.js

@@ -123,16 +123,17 @@ function garbageCollect(caches, length) {
  * Returns {width, height, offset} objects for the first, last, widest, highest tick
  * labels where offset indicates the anchor point offset from the top in pixels.
  */
-function computeLabelSizes(ctx, tickFonts, ticks, caches) {
-	var length = ticks.length;
+function computeLabelSizes(ctx, tickFonts, labels, tickMeta, caches) {
+	var length = labels.length;
 	var widths = [];
 	var heights = [];
 	var offsets = [];
-	var i, j, jlen, label, tickFont, fontString, cache, lineHeight, width, height, nestedLabel, widest, highest;
+	var i, j, jlen, label, meta, tickFont, fontString, cache, lineHeight, width, height, nestedLabel, widest, highest;
 
 	for (i = 0; i < length; ++i) {
-		label = ticks[i].label;
-		tickFont = ticks[i].major ? tickFonts.major : tickFonts.minor;
+		label = labels[i];
+		meta = tickMeta[i];
+		tickFont = meta && meta.major ? tickFonts.major : tickFonts.minor;
 		ctx.font = fontString = tickFont.string;
 		cache = caches[fontString] = caches[fontString] || {data: {}, gc: []};
 		lineHeight = tickFont.lineHeight;
@@ -249,18 +250,18 @@ function calculateSpacing(majorIndices, ticks, axisLength, ticksLimit) {
 	return Math.max(spacing, 1);
 }
 
-function getMajorIndices(ticks) {
+function getMajorIndices(meta) {
 	var result = [];
 	var i, ilen;
-	for (i = 0, ilen = ticks.length; i < ilen; i++) {
-		if (ticks[i].major) {
+	for (i = 0, ilen = meta.length; i < ilen; i++) {
+		if (meta[i] && meta[i].major) {
 			result.push(i);
 		}
 	}
 	return result;
 }
 
-function skipMajors(ticks, newTicks, majorIndices, spacing) {
+function skipMajors(ticks, meta, newTicks, newMeta, majorIndices, spacing) {
 	let count = 0;
 	let next = majorIndices[0];
 	let i;
@@ -269,13 +270,14 @@ function skipMajors(ticks, newTicks, majorIndices, spacing) {
 	for (i = 0; i < ticks.length; i++) {
 		if (i === next) {
 			newTicks.push(ticks[i]);
+			newMeta.push(meta[i]);
 			count++;
 			next = majorIndices[count * spacing];
 		}
 	}
 }
 
-function skip(ticks, newTicks, spacing, majorStart, majorEnd) {
+function skip(ticks, meta, newTicks, newMeta, spacing, majorStart, majorEnd) {
 	const start = valueOrDefault(majorStart, 0);
 	const end = Math.min(valueOrDefault(majorEnd, ticks.length), ticks.length);
 	let count = 0;
@@ -297,6 +299,7 @@ function skip(ticks, newTicks, spacing, majorStart, majorEnd) {
 	for (i = Math.max(start, 0); i < end; i++) {
 		if (i === next) {
 			newTicks.push(ticks[i]);
+			newMeta.push(meta[i]);
 			count++;
 			next = Math.round(start + count * spacing);
 		}
@@ -427,10 +430,10 @@ class Scale extends Element {
 	 *     - thickness of scales or legends in another orientation
 	 */
 	update(maxWidth, maxHeight, margins) {
-		var me = this;
-		var tickOpts = me.options.ticks;
-		var sampleSize = tickOpts.sampleSize;
-		var samplingEnabled;
+		const me = this;
+		const tickOpts = me.options.ticks;
+		const sampleSize = tickOpts.sampleSize;
+		const autoSkipEnabled = tickOpts.autoSkip || tickOpts.source === 'auto';
 
 		// Update Lifecycle - Probably don't want to ever extend or overwrite this function ;)
 		me.beforeUpdate();
@@ -446,6 +449,7 @@ class Scale extends Element {
 		}, margins);
 
 		me.ticks = null;
+		me._tickMeta = [];
 		me._labelSizes = null;
 		me._maxLabelLines = 0;
 		me.longestLabelWidth = 0;
@@ -472,8 +476,8 @@ class Scale extends Element {
 
 		// Compute tick rotation and fit using a sampled subset of labels
 		// We generally don't need to compute the size of every single label for determining scale size
-		samplingEnabled = sampleSize < me.ticks.length;
-		me._convertTicksToLabels(samplingEnabled ? sample(me.ticks, sampleSize) : me.ticks);
+		const samplingEnabled = sampleSize < me.ticks.length;
+		me.labels = me._convertTicksToLabels(samplingEnabled ? sample(me.ticks, sampleSize) : me.ticks);
 
 		// _configure is called twice, once here, once from core.controller.updateLayout.
 		// Here we haven't been positioned yet, but dimensions are correct.
@@ -491,11 +495,13 @@ class Scale extends Element {
 		me.afterFit();
 
 		// Auto-skip
-		me.ticks = tickOpts.display && (tickOpts.autoSkip || tickOpts.source === 'auto') ? me._autoSkip(me.ticks) : me.ticks;
+		if (tickOpts.display && autoSkipEnabled) {
+			me._autoSkip();
+		}
 
-		if (samplingEnabled) {
+		if (tickOpts.display && (samplingEnabled || autoSkipEnabled)) {
 			// Generate labels using all non-skipped ticks
-			me._convertTicksToLabels(me.ticks);
+			me.labels = me._convertTicksToLabels(me.ticks);
 		}
 
 		// IMPORTANT: after this point, we consider that `this.ticks` will NEVER change!
@@ -589,14 +595,15 @@ class Scale extends Element {
 	/**
 	 * Convert ticks to label strings
 	 */
-	generateTickLabels(ticks) {
+	convertTicksToLabels(ticks) {
 		var me = this;
 		var tickOpts = me.options.ticks;
-		var i, ilen, tick;
+		var labels = [];
+		var i, ilen;
 		for (i = 0, ilen = ticks.length; i < ilen; i++) {
-			tick = ticks[i];
-			tick.label = helpers.callback(tickOpts.callback, [tick.value, i, ticks], me);
+			labels[i] = helpers.callback(tickOpts.callback, [ticks[i], i, ticks], me);
 		}
+		return labels;
 	}
 	afterTickToLabelConversion() {
 		helpers.callback(this.options.afterTickToLabelConversion, [this]);
@@ -787,12 +794,15 @@ class Scale extends Element {
 
 	_convertTicksToLabels(ticks) {
 		var me = this;
+		var labels;
 
 		me.beforeTickToLabelConversion();
 
-		me.generateTickLabels(ticks);
+		labels = me.convertTicksToLabels(ticks);
 
 		me.afterTickToLabelConversion();
+
+		return labels;
 	}
 
 	/**
@@ -803,7 +813,7 @@ class Scale extends Element {
 		var labelSizes = me._labelSizes;
 
 		if (!labelSizes) {
-			me._labelSizes = labelSizes = computeLabelSizes(me.ctx, parseTickFontOptions(me.options.ticks), me.ticks, me.longestTextCache);
+			me._labelSizes = labelSizes = computeLabelSizes(me.ctx, parseTickFontOptions(me.options.ticks), me.labels, me._tickMeta, me.longestTextCache);
 			me.longestLabelWidth = labelSizes.widest.width;
 		}
 
@@ -891,37 +901,46 @@ class Scale extends Element {
 	 * Returns a subset of ticks to be plotted to avoid overlapping labels.
 	 * @private
 	 */
-	_autoSkip(ticks) {
+	_autoSkip() {
 		const me = this;
 		const tickOpts = me.options.ticks;
+		const ticks = me.ticks;
+		const meta = me._tickMeta;
 		const axisLength = me._length;
 		const ticksLimit = tickOpts.maxTicksLimit || axisLength / me._tickSize() + 1;
-		const majorIndices = tickOpts.major.enabled ? getMajorIndices(ticks) : [];
+		const majorIndices = tickOpts.major.enabled ? getMajorIndices(meta) : [];
 		const numMajorIndices = majorIndices.length;
 		const first = majorIndices[0];
 		const last = majorIndices[numMajorIndices - 1];
 		const newTicks = [];
+		const newMeta = [];
 
 		// If there are too many major ticks to display them all
 		if (numMajorIndices > ticksLimit) {
-			skipMajors(ticks, newTicks, majorIndices, numMajorIndices / ticksLimit);
-			return newTicks;
+			skipMajors(ticks, meta, newTicks, newMeta, majorIndices, numMajorIndices / ticksLimit);
+			me._tickMeta = newMeta;
+			me.ticks = newTicks;
+			return;
 		}
 
 		const spacing = calculateSpacing(majorIndices, ticks, axisLength, ticksLimit);
 
 		if (numMajorIndices > 0) {
 			let i, ilen;
 			const avgMajorSpacing = numMajorIndices > 1 ? (last - first) / (numMajorIndices - 1) : null;
-			skip(ticks, newTicks, spacing, helpers.isNullOrUndef(avgMajorSpacing) ? 0 : first - avgMajorSpacing, first);
+			skip(ticks, meta, newTicks, newMeta, spacing, helpers.isNullOrUndef(avgMajorSpacing) ? 0 : first - avgMajorSpacing, first);
 			for (i = 0, ilen = numMajorIndices - 1; i < ilen; i++) {
-				skip(ticks, newTicks, spacing, majorIndices[i], majorIndices[i + 1]);
+				skip(ticks, meta, newTicks, newMeta, spacing, majorIndices[i], majorIndices[i + 1]);
 			}
-			skip(ticks, newTicks, spacing, last, helpers.isNullOrUndef(avgMajorSpacing) ? ticks.length : last + avgMajorSpacing);
-			return newTicks;
+			skip(ticks, meta, newTicks, newMeta, spacing, last, helpers.isNullOrUndef(avgMajorSpacing) ? ticks.length : last + avgMajorSpacing);
+			me._tickMeta = newMeta;
+			me.ticks = newTicks;
+			return;
 		}
-		skip(ticks, newTicks, spacing);
-		return newTicks;
+		skip(ticks, meta, newTicks, newMeta, spacing);
+		me._tickMeta = newMeta;
+		me.ticks = newTicks;
+		return;
 	}
 
 	/**
@@ -943,8 +962,8 @@ class Scale extends Element {
 
 		// Calculate space needed for 1 tick in axis direction.
 		return me.isHorizontal()
-			? h * cos > w * sin ? w / cos : h / sin
-			: h * sin < w * cos ? h / cos : w / sin;
+			? (h * cos > w * sin ? w / cos : h / sin)
+			: (h * sin < w * cos ? h / cos : w / sin);
 	}
 
 	/**
@@ -1080,7 +1099,7 @@ class Scale extends Element {
 		var tl = getTickMarkLength(options.gridLines);
 		var rotation = -helpers.toRadians(me.labelRotation);
 		var items = [];
-		var i, ilen, tick, label, x, y, textAlign, pixel, font, lineHeight, lineCount, textOffset;
+		var i, ilen, meta, label, x, y, textAlign, pixel, font, lineHeight, lineCount, textOffset;
 
 		if (position === 'top') {
 			y = me.bottom - tl - tickPadding;
@@ -1097,11 +1116,11 @@ class Scale extends Element {
 		}
 
 		for (i = 0, ilen = ticks.length; i < ilen; ++i) {
-			tick = ticks[i];
-			label = tick.label;
+			meta = me._tickMeta[i];
+			label = me.labels[i];
 
 			pixel = me.getPixelForTick(i) + optionTicks.labelOffset;
-			font = tick.major ? fonts.major : fonts.minor;
+			font = meta && meta.major ? fonts.major : fonts.minor;
 			lineHeight = font.lineHeight;
 			lineCount = isArray(label) ? label.length : 1;
 

src/core/core.ticks.js

@@ -33,7 +33,7 @@ module.exports = {
 		 */
 		linear: function(tickValue, index, ticks) {
 			// If we have lots of ticks, don't use the ones
-			var delta = ticks.length > 3 ? ticks[2].value - ticks[1].value : ticks[1].value - ticks[0].value;
+			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) {
@@ -47,7 +47,7 @@ module.exports = {
 			var tickString = '';
 
 			if (tickValue !== 0) {
-				var maxTick = Math.max(Math.abs(ticks[0].value), Math.abs(ticks[ticks.length - 1].value));
+				var maxTick = Math.max(Math.abs(ticks[0]), Math.abs(ticks[ticks.length - 1]));
 				if (maxTick < 1e-4) { // all ticks are small numbers; use scientific notation
 					var logTick = math.log10(Math.abs(tickValue));
 					var numExponential = Math.floor(logTick) - Math.floor(logDelta);

src/scales/scale.category.js

@@ -31,7 +31,7 @@ class CategroyScale extends Scale {
 		// If we are viewing some subset of labels, slice the original array
 		labels = (min === 0 && max === labels.length - 1) ? labels : labels.slice(min, max + 1);
 		return labels.map(function(l) {
-			return {value: l};
+			return l;
 		});
 	}
 

src/scales/scale.linear.js

@@ -64,7 +64,7 @@ class LinearScale extends LinearScaleBase {
 	}
 
 	getPixelForTick(index) {
-		var ticks = this._tickValues;
+		var ticks = this.ticks;
 		if (index < 0 || index > ticks.length - 1) {
 			return null;
 		}

src/scales/scale.linearbase.js

@@ -32,7 +32,7 @@ function generateTicks(generationOptions, dataRange) {
 	// Beyond MIN_SPACING floating point numbers being to lose precision
 	// such that we can't do the math necessary to generate ticks
 	if (spacing < MIN_SPACING && isNullOrUndef(min) && isNullOrUndef(max)) {
-		return [{value: rmin}, {value: rmax}];
+		return [rmin, rmax];
 	}
 
 	numSpaces = Math.ceil(rmax / spacing) - Math.floor(rmin / spacing);
@@ -74,11 +74,11 @@ function generateTicks(generationOptions, dataRange) {
 
 	niceMin = Math.round(niceMin * factor) / factor;
 	niceMax = Math.round(niceMax * factor) / factor;
-	ticks.push({value: isNullOrUndef(min) ? niceMin : min});
+	ticks.push(isNullOrUndef(min) ? niceMin : min);
 	for (var j = 1; j < numSpaces; ++j) {
-		ticks.push({value: Math.round((niceMin + j * spacing) * factor) / factor});
+		ticks.push(Math.round((niceMin + j * spacing) * factor) / factor);
 	}
-	ticks.push({value: isNullOrUndef(max) ? niceMax : max});
+	ticks.push(isNullOrUndef(max) ? niceMax : max);
 
 	return ticks;
 }
@@ -215,7 +215,7 @@ class LinearScaleBase extends Scale {
 
 		// At this point, we need to update our max and min given the tick values since we have expanded the
 		// range of the scale
-		helpers._setMinAndMaxByKey(ticks, me, 'value');
+		helpers._setMinAndMax(ticks, me);
 
 		if (opts.reverse) {
 			ticks.reverse();
@@ -230,12 +230,6 @@ class LinearScaleBase extends Scale {
 		return ticks;
 	}
 
-	generateTickLabels(ticks) {
-		var me = this;
-		me._tickValues = ticks.map(t => t.value);
-		Scale.prototype.generateTickLabels.call(me, ticks);
-	}
-
 	_configure() {
 		var me = this;
 		var ticks = me.getTicks();