Fix remaining handleEvent issues

Author: kurkle

docs/getting-started/v3-migration.md

@@ -85,8 +85,13 @@ Animation system was completely rewritten in Chart.js v3. Each property can now
 
 ### Removed
 
+* `Chart.borderWidth`
 * `Chart.chart.chart`
 * `Chart.Controller`
+* `Chart.innerRadius`
+* `Chart.offsetX`
+* `Chart.offsetY`
+* `Chart.outerRadius`
 * `Chart.prototype.generateLegend`
 * `Chart.types`
 * `Chart.Tooltip` is now provided by the tooltip plugin. The positioners can be accessed from `tooltipPlugin.positioners`

src/controllers/controller.doughnut.js

@@ -5,6 +5,10 @@ import defaults from '../core/core.defaults';
 import Arc from '../elements/element.arc';
 import {isArray, valueOrDefault} from '../helpers/helpers.core';
 
+/**
+ * @typedef { import("../core/core.controller").default } Chart
+ */
+
 const PI = Math.PI;
 const DOUBLE_PI = PI * 2;
 const HALF_PI = PI / 2;
@@ -96,13 +100,45 @@ defaults.set('doughnut', {
 	}
 });
 
+function getRatioAndOffset(rotation, circumference, cutout) {
+	let ratioX = 1;
+	let ratioY = 1;
+	let offsetX = 0;
+	let offsetY = 0;
+	// If the chart's circumference isn't a full circle, calculate size as a ratio of the width/height of the arc
+	if (circumference < DOUBLE_PI) {
+		let startAngle = rotation % DOUBLE_PI;
+		startAngle += startAngle >= PI ? -DOUBLE_PI : startAngle < -PI ? DOUBLE_PI : 0;
+		const endAngle = startAngle + circumference;
+		const startX = Math.cos(startAngle);
+		const startY = Math.sin(startAngle);
+		const endX = Math.cos(endAngle);
+		const endY = Math.sin(endAngle);
+		const contains0 = (startAngle <= 0 && endAngle >= 0) || endAngle >= DOUBLE_PI;
+		const contains90 = (startAngle <= HALF_PI && endAngle >= HALF_PI) || endAngle >= DOUBLE_PI + HALF_PI;
+		const contains180 = startAngle === -PI || endAngle >= PI;
+		const contains270 = (startAngle <= -HALF_PI && endAngle >= -HALF_PI) || endAngle >= PI + HALF_PI;
+		const minX = contains180 ? -1 : Math.min(startX, startX * cutout, endX, endX * cutout);
+		const minY = contains270 ? -1 : Math.min(startY, startY * cutout, endY, endY * cutout);
+		const maxX = contains0 ? 1 : Math.max(startX, startX * cutout, endX, endX * cutout);
+		const maxY = contains90 ? 1 : Math.max(startY, startY * cutout, endY, endY * cutout);
+		ratioX = (maxX - minX) / 2;
+		ratioY = (maxY - minY) / 2;
+		offsetX = -(maxX + minX) / 2;
+		offsetY = -(maxY + minY) / 2;
+	}
+	return {ratioX, ratioY, offsetX, offsetY};
+}
+
 class DoughnutController extends DatasetController {
 
 	constructor(chart, datasetIndex) {
 		super(chart, datasetIndex);
 
 		this.innerRadius = undefined;
 		this.outerRadius = undefined;
+		this.offsetX = undefined;
+		this.offsetY = undefined;
 	}
 
 	linkScales() {}
@@ -133,62 +169,33 @@ class DoughnutController extends DatasetController {
 		return ringIndex;
 	}
 
+	/**
+	 * @param {string} mode
+	 */
 	update(mode) {
-		var me = this;
-		var chart = me.chart;
-		var chartArea = chart.chartArea;
-		var opts = chart.options;
-		var ratioX = 1;
-		var ratioY = 1;
-		var offsetX = 0;
-		var offsetY = 0;
-		var meta = me._cachedMeta;
-		var arcs = meta.data;
-		var cutout = opts.cutoutPercentage / 100 || 0;
-		var circumference = opts.circumference;
-		var chartWeight = me._getRingWeight(me.index);
-		var maxWidth, maxHeight, i, ilen;
-
-		// If the chart's circumference isn't a full circle, calculate size as a ratio of the width/height of the arc
-		if (circumference < DOUBLE_PI) {
-			var startAngle = opts.rotation % DOUBLE_PI;
-			startAngle += startAngle >= PI ? -DOUBLE_PI : startAngle < -PI ? DOUBLE_PI : 0;
-			var endAngle = startAngle + circumference;
-			var startX = Math.cos(startAngle);
-			var startY = Math.sin(startAngle);
-			var endX = Math.cos(endAngle);
-			var endY = Math.sin(endAngle);
-			var contains0 = (startAngle <= 0 && endAngle >= 0) || endAngle >= DOUBLE_PI;
-			var contains90 = (startAngle <= HALF_PI && endAngle >= HALF_PI) || endAngle >= DOUBLE_PI + HALF_PI;
-			var contains180 = startAngle === -PI || endAngle >= PI;
-			var contains270 = (startAngle <= -HALF_PI && endAngle >= -HALF_PI) || endAngle >= PI + HALF_PI;
-			var minX = contains180 ? -1 : Math.min(startX, startX * cutout, endX, endX * cutout);
-			var minY = contains270 ? -1 : Math.min(startY, startY * cutout, endY, endY * cutout);
-			var maxX = contains0 ? 1 : Math.max(startX, startX * cutout, endX, endX * cutout);
-			var maxY = contains90 ? 1 : Math.max(startY, startY * cutout, endY, endY * cutout);
-			ratioX = (maxX - minX) / 2;
-			ratioY = (maxY - minY) / 2;
-			offsetX = -(maxX + minX) / 2;
-			offsetY = -(maxY + minY) / 2;
-		}
-
-		for (i = 0, ilen = arcs.length; i < ilen; ++i) {
-			arcs[i]._options = me._resolveDataElementOptions(i, mode);
-		}
-
-		chart.borderWidth = me.getMaxBorderWidth();
-		maxWidth = (chartArea.right - chartArea.left - chart.borderWidth) / ratioX;
-		maxHeight = (chartArea.bottom - chartArea.top - chart.borderWidth) / ratioY;
-		chart.outerRadius = Math.max(Math.min(maxWidth, maxHeight) / 2, 0);
-		chart.innerRadius = Math.max(chart.outerRadius * cutout, 0);
-		chart.radiusLength = (chart.outerRadius - chart.innerRadius) / (me._getVisibleDatasetWeightTotal() || 1);
-		chart.offsetX = offsetX * chart.outerRadius;
-		chart.offsetY = offsetY * chart.outerRadius;
+		const me = this;
+		/** @type {Chart} */
+		const chart = me.chart;
+		const {chartArea, options} = chart;
+		const meta = me._cachedMeta;
+		/** @type {Arc[]} */
+		const arcs = meta.data;
+		const cutout = options.cutoutPercentage / 100 || 0;
+		const chartWeight = me._getRingWeight(me.index);
+		const {ratioX, ratioY, offsetX, offsetY} = getRatioAndOffset(options.rotation, options.circumference, cutout);
+		const borderWidth = me.getMaxBorderWidth();
+		const maxWidth = (chartArea.right - chartArea.left - borderWidth) / ratioX;
+		const maxHeight = (chartArea.bottom - chartArea.top - borderWidth) / ratioY;
+		const outerRadius = Math.max(Math.min(maxWidth, maxHeight) / 2, 0);
+		const innerRadius = Math.max(outerRadius * cutout, 0);
+		const radiusLength = (outerRadius - innerRadius) / (me._getVisibleDatasetWeightTotal() || 1);
+		me.offsetX = offsetX * outerRadius;
+		me.offsetY = offsetY * outerRadius;
 
 		meta.total = me.calculateTotal();
 
-		me.outerRadius = chart.outerRadius - chart.radiusLength * me._getRingWeightOffset(me.index);
-		me.innerRadius = Math.max(me.outerRadius - chart.radiusLength * chartWeight, 0);
+		me.outerRadius = outerRadius - radiusLength * me._getRingWeightOffset(me.index);
+		me.innerRadius = Math.max(me.outerRadius - radiusLength * chartWeight, 0);
 
 		me.updateElements(arcs, 0, mode);
 	}
@@ -203,9 +210,15 @@ class DoughnutController extends DatasetController {
 		return reset && opts.animation.animateRotate ? 0 : meta.data[i].hidden ? 0 : me.calculateCircumference(meta._parsed[i] * opts.circumference / DOUBLE_PI);
 	}
 
+	/**
+	 * @param {Arc[]} arcs
+	 * @param {number} start
+	 * @param {string} mode
+	 */
 	updateElements(arcs, start, mode) {
 		const me = this;
 		const reset = mode === 'reset';
+		/** @type {Chart} */
 		const chart = me.chart;
 		const chartArea = chart.chartArea;
 		const opts = chart.options;
@@ -214,6 +227,9 @@ class DoughnutController extends DatasetController {
 		const centerY = (chartArea.top + chartArea.bottom) / 2;
 		const innerRadius = reset && animationOpts.animateScale ? 0 : me.innerRadius;
 		const outerRadius = reset && animationOpts.animateScale ? 0 : me.outerRadius;
+		const firstOpts = me._resolveDataElementOptions(start, mode);
+		const sharedOptions = me._getSharedOptions(mode, arcs[start], firstOpts);
+		const includeOptions = me._includeOptions(mode, sharedOptions);
 		let startAngle = opts.rotation;
 		let i;
 
@@ -225,21 +241,23 @@ class DoughnutController extends DatasetController {
 			const index = start + i;
 			const circumference = me._circumference(index, reset);
 			const arc = arcs[i];
-			const options = arc._options || {};
 			const properties = {
-				x: centerX + chart.offsetX,
-				y: centerY + chart.offsetY,
+				x: centerX + me.offsetX,
+				y: centerY + me.offsetY,
 				startAngle,
 				endAngle: startAngle + circumference,
 				circumference,
 				outerRadius,
-				innerRadius,
-				options
+				innerRadius
 			};
+			if (includeOptions) {
+				properties.options = me._resolveDataElementOptions(index, mode);
+			}
 			startAngle += circumference;
 
 			me._updateElement(arc, index, properties, mode);
 		}
+		me._updateSharedOptions(sharedOptions, mode);
 	}
 
 	calculateTotal() {
@@ -255,13 +273,12 @@ class DoughnutController extends DatasetController {
 			}
 		}
 
-		/* if (total === 0) {
-			total = NaN;
-		}*/
-
 		return total;
 	}
 
+	/**
+	 * @param {number} value
+	 */
 	calculateCircumference(value) {
 		var total = this._cachedMeta.total;
 		if (total > 0 && !isNaN(value)) {
@@ -270,7 +287,10 @@ class DoughnutController extends DatasetController {
 		return 0;
 	}
 
-	// gets the max border or hover width to properly scale pie charts
+	/**
+	 * gets the max border or hover width to properly scale pie charts
+	 * @param {Arc[]} [arcs]
+	 */
 	getMaxBorderWidth(arcs) {
 		var me = this;
 		var max = 0;
@@ -307,6 +327,7 @@ class DoughnutController extends DatasetController {
 
 	/**
 	 * Get radius length offset of the dataset in relation to the visible datasets weights. This allows determining the inner and outer radius correctly
+	 * @param {number} datasetIndex
 	 * @private
 	 */
 	_getRingWeightOffset(datasetIndex) {
@@ -322,10 +343,11 @@ class DoughnutController extends DatasetController {
 	}
 
 	/**
+	 * @param {number} datasetIndex
 	 * @private
 	 */
-	_getRingWeight(dataSetIndex) {
-		return Math.max(valueOrDefault(this.chart.data.datasets[dataSetIndex].weight, 1), 0);
+	_getRingWeight(datasetIndex) {
+		return Math.max(valueOrDefault(this.chart.data.datasets[datasetIndex].weight, 1), 0);
 	}
 
 	/**

src/core/core.controller.js

@@ -201,7 +201,7 @@ class Chart {
 		this.chartArea = undefined;
 		this.data = undefined;
 		this.active = undefined;
-		this.lastActive = undefined;
+		this.lastActive = [];
 		this._lastEvent = undefined;
 		this._listeners = {resize: undefined};
 		this._sortedMetasets = [];
@@ -561,7 +561,7 @@ class Chart {
 
 		// Replay last event from before update
 		if (me._lastEvent) {
-			me.eventHandler(me._lastEvent);
+			me.eventHandler(me._lastEvent, true);
 		}
 
 		me.render();
@@ -788,10 +788,16 @@ class Chart {
 		return Interaction.modes.index(this, e, {intersect: false});
 	}
 
-	getElementsAtEventForMode(e, mode, options) {
+	/**
+	 * @param {IEvent} e
+	 * @param {string} mode
+	 * @param {any} options
+	 * @param {boolean} [useFinalPosition]
+	 */
+	getElementsAtEventForMode(e, mode, options, useFinalPosition) {
 		const method = Interaction.modes[mode];
 		if (typeof method === 'function') {
-			return method(this, e, options);
+			return method(this, e, options, useFinalPosition);
 		}
 
 		return [];
@@ -961,6 +967,11 @@ class Chart {
 		});
 	}
 
+	/**
+	 * @param {{datasetIndex: number, index: number, element: Element}[]} items
+	 * @param {string} mode
+	 * @param {boolean} enabled
+	 */
 	updateHoverStyle(items, mode, enabled) {
 		const prefix = enabled ? 'set' : 'remove';
 		let meta, item, i, ilen;
@@ -998,18 +1009,20 @@ class Chart {
 	}
 
 	/**
+	 * @param {IEvent} e
+	 * @param {boolean} [replay]
 	 * @private
 	 */
-	eventHandler(e) {
+	eventHandler(e, replay) {
 		const me = this;
 
-		if (plugins.notify(me, 'beforeEvent', [e]) === false) {
+		if (plugins.notify(me, 'beforeEvent', [e, replay]) === false) {
 			return;
 		}
 
-		me.handleEvent(e);
+		me.handleEvent(e, replay);
 
-		plugins.notify(me, 'afterEvent', [e]);
+		plugins.notify(me, 'afterEvent', [e, replay]);
 
 		me.render();
 
@@ -1020,22 +1033,21 @@ class Chart {
 	 * Handle an event
 	 * @private
 	 * @param {IEvent} e the event to handle
+	 * @param {boolean} [replay]
 	 * @return {boolean} true if the chart needs to re-render
 	 */
-	handleEvent(e) {
+	handleEvent(e, replay) {
 		const me = this;
-		const options = me.options || {};
+		const options = me.options;
 		const hoverOptions = options.hover;
 		let changed = false;
 
-		me.lastActive = me.lastActive || [];
-
 		// Find Active Elements for hover and tooltips
 		if (e.type === 'mouseout') {
 			me.active = [];
 			me._lastEvent = null;
 		} else {
-			me.active = me.getElementsAtEventForMode(e, hoverOptions.mode, hoverOptions);
+			me.active = me.getElementsAtEventForMode(e, hoverOptions.mode, hoverOptions, replay);
 			me._lastEvent = e.type === 'click' ? me._lastEvent : e;
 		}
 
@@ -1051,7 +1063,7 @@ class Chart {
 		}
 
 		changed = !helpers._elementsEqual(me.active, me.lastActive);
-		if (changed) {
+		if (changed || replay) {
 			me._updateHoverStyles();
 		}