Remove `index` and `datasetIndex` properties from elements.
##### Time Scale
* `getValueForPixel` now returns milliseconds since the epoch
+
+#### Controllers
+
+##### Core Controller
+
+* The first parameter to `updateHoverStyle` is now an array of objects containing the `element`, `datasetIndex`, and `index`
+
+##### Dataset Controllers
+
+* `setHoverStyle` now additionally takes the `datasetIndex` and `index`
+
+#### Interactions
+
+* Interaction mode methods now return an array of objects containing the `element`, `datasetIndex`, and `index`
var me = this;
var options = me._resolveDataElementOptions(index);
- rectangle._datasetIndex = me.index;
- rectangle._index = index;
rectangle._model = {
backgroundColor: options.backgroundColor,
borderColor: options.borderColor,
var y = reset ? yScale.getBasePixel() : yScale.getPixelForValue(parsed[yScale.id]);
point._options = options;
- point._datasetIndex = me.index;
- point._index = index;
point._model = {
backgroundColor: options.backgroundColor,
borderColor: options.borderColor,
var options = arc._options || {};
helpers.extend(arc, {
- // Utility
- _datasetIndex: me.index,
- _index: index,
-
// Desired view properties
_model: {
backgroundColor: options.backgroundColor,
// Update Line
if (showLine) {
- // Utility
- line._datasetIndex = me.index;
// Data
line._children = points;
// Model
updateElement: function(point, index, reset) {
var me = this;
var meta = me.getMeta();
- var datasetIndex = me.index;
var xScale = me._xScale;
var yScale = me._yScale;
var lineModel = meta.dataset._model;
// Utility
point._options = options;
- point._datasetIndex = datasetIndex;
- point._index = index;
// Desired view properties
point._model = {
var options = arc._options || {};
helpers.extend(arc, {
- // Utility
- _datasetIndex: me.index,
- _index: index,
-
// Desired view properties
_model: {
backgroundColor: options.backgroundColor,
config.lineTension = config.tension;
}
- // Utility
- line._datasetIndex = me.index;
// Data
line._children = points;
line._loop = true;
// Utility
point._options = options;
- point._datasetIndex = me.index;
- point._index = index;
// Desired view properties
point._model = {
});
},
- updateHoverStyle: function(elements, mode, enabled) {
+ updateHoverStyle: function(items, mode, enabled) {
var prefix = enabled ? 'set' : 'remove';
- var element, i, ilen;
+ var meta, item, i, ilen;
- for (i = 0, ilen = elements.length; i < ilen; ++i) {
- element = elements[i];
- if (element) {
- this.getDatasetMeta(element._datasetIndex).controller[prefix + 'HoverStyle'](element);
+ if (mode === 'dataset') {
+ meta = this.getDatasetMeta(items[0].datasetIndex);
+ meta.controller['_' + prefix + 'DatasetHoverStyle']();
+ for (i = 0, ilen = meta.data.length; i < ilen; ++i) {
+ meta.controller[prefix + 'HoverStyle'](meta.data[i], items[0].datasetIndex, i);
}
+ return;
}
- if (mode === 'dataset') {
- this.getDatasetMeta(elements[0]._datasetIndex).controller['_' + prefix + 'DatasetHoverStyle']();
+ for (i = 0, ilen = items.length; i < ilen; ++i) {
+ item = items[i];
+ if (item) {
+ this.getDatasetMeta(item.datasetIndex).controller[prefix + 'HoverStyle'](item.element, item.datasetIndex, item.index);
+ }
}
},
}
me._updateHoverStyles();
- changed = !helpers.arrayEquals(me.active, me.lastActive);
+ changed = !helpers._elementsEqual(me.active, me.lastActive);
// Remember Last Actives
me.lastActive = me.active;
delete element.$previousStyle;
},
- setHoverStyle: function(element) {
- var dataset = this.chart.data.datasets[element._datasetIndex];
- var index = element._index;
+ setHoverStyle: function(element, datasetIndex, index) {
+ var dataset = this.chart.data.datasets[datasetIndex];
var model = element._model;
var getHoverColor = helpers.getHoverColor;
constructor(configuration) {
helpers.extend(this, configuration);
+
+ // this.hidden = false; we assume Element has an attribute called hidden, but do not initialize to save memory
+
this.initialize.apply(this, arguments);
}
- initialize() {
- this.hidden = false;
- }
+ initialize() {}
pivot(animationsDisabled) {
var me = this;
for (j = 0, jlen = metadata.length; j < jlen; ++j) {
element = metadata[j];
if (!element._view.skip) {
- handler(element);
+ handler(element, i, j);
}
}
}
function getIntersectItems(chart, position) {
var elements = [];
- parseVisibleItems(chart, function(element) {
+ parseVisibleItems(chart, function(element, datasetIndex, index) {
if (element.inRange(position.x, position.y)) {
- elements.push(element);
+ elements.push({element, datasetIndex, index});
}
});
var minDistance = Number.POSITIVE_INFINITY;
var nearestItems = [];
- parseVisibleItems(chart, function(element) {
+ parseVisibleItems(chart, function(element, datasetIndex, index) {
if (intersect && !element.inRange(position.x, position.y)) {
return;
}
var center = element.getCenterPoint();
var distance = distanceMetric(position, center);
if (distance < minDistance) {
- nearestItems = [element];
+ nearestItems = [{element, datasetIndex, index}];
minDistance = distance;
} else if (distance === minDistance) {
// Can have multiple items at the same distance in which case we sort by size
- nearestItems.push(element);
+ nearestItems.push({element, datasetIndex, index});
}
});
}
chart._getSortedVisibleDatasetMetas().forEach(function(meta) {
- var element = meta.data[items[0]._index];
+ var index = items[0].index;
+ var element = meta.data[index];
// don't count items that are skipped (null data)
if (element && !element._view.skip) {
- elements.push(element);
+ elements.push({element, datasetIndex: meta.index, index});
}
});
* @param {Chart} chart - the chart we are returning items from
* @param {Event} e - the event we are find things at
* @param {IInteractionOptions} options - options to use during interaction
- * @return {Chart.Element[]} Array of elements that are under the point. If none are found, an empty array is returned
+ * @return {Object[]} Array of elements that are under the point. If none are found, an empty array is returned
*/
index: indexMode,
* @param {Chart} chart - the chart we are returning items from
* @param {Event} e - the event we are find things at
* @param {IInteractionOptions} options - options to use during interaction
- * @return {Chart.Element[]} Array of elements that are under the point. If none are found, an empty array is returned
+ * @return {Object[]} Array of elements that are under the point. If none are found, an empty array is returned
*/
dataset: function(chart, e, options) {
var position = getRelativePosition(e, chart);
var items = options.intersect ? getIntersectItems(chart, position) : getNearestItems(chart, position, false, distanceMetric);
if (items.length > 0) {
- items = chart.getDatasetMeta(items[0]._datasetIndex).data;
+ items = [{datasetIndex: items[0].datasetIndex}]; // when mode: 'dataset' we only need to return datasetIndex
}
return items;
* @function Chart.Interaction.modes.intersect
* @param {Chart} chart - the chart we are returning items from
* @param {Event} e - the event we are find things at
- * @return {Chart.Element[]} Array of elements that are under the point. If none are found, an empty array is returned
+ * @return {Object[]} Array of elements that are under the point. If none are found, an empty array is returned
*/
point: function(chart, e) {
var position = getRelativePosition(e, chart);
* @param {Chart} chart - the chart we are returning items from
* @param {Event} e - the event we are find things at
* @param {IInteractionOptions} options - options to use
- * @return {Chart.Element[]} Array of elements that are under the point. If none are found, an empty array is returned
+ * @return {Object[]} Array of elements that are under the point. If none are found, an empty array is returned
*/
nearest: function(chart, e, options) {
var position = getRelativePosition(e, chart);
* @param {Chart} chart - the chart we are returning items from
* @param {Event} e - the event we are find things at
* @param {IInteractionOptions} options - options to use
- * @return {Chart.Element[]} Array of elements that are under the point. If none are found, an empty array is returned
+ * @return {Object[]} Array of elements that are under the point. If none are found, an empty array is returned
*/
x: function(chart, e, options) {
var position = getRelativePosition(e, chart);
var items = [];
var intersectsItem = false;
- parseVisibleItems(chart, function(element) {
+ parseVisibleItems(chart, function(element, datasetIndex, index) {
if (element.inXRange(position.x)) {
- items.push(element);
+ items.push({element, datasetIndex, index});
}
if (element.inRange(position.x, position.y)) {
* @param {Chart} chart - the chart we are returning items from
* @param {Event} e - the event we are find things at
* @param {IInteractionOptions} options - options to use
- * @return {Chart.Element[]} Array of elements that are under the point. If none are found, an empty array is returned
+ * @return {Object[]} Array of elements that are under the point. If none are found, an empty array is returned
*/
y: function(chart, e, options) {
var position = getRelativePosition(e, chart);
var items = [];
var intersectsItem = false;
- parseVisibleItems(chart, function(element) {
+ parseVisibleItems(chart, function(element, datasetIndex, index) {
if (element.inYRange(position.y)) {
- items.push(element);
+ items.push({element, datasetIndex, index});
}
if (element.inRange(position.x, position.y)) {
var count = 0;
for (i = 0, len = elements.length; i < len; ++i) {
- var el = elements[i];
+ var el = elements[i].element;
if (el && el.hasValue()) {
var pos = el.tooltipPosition();
x += pos.x;
var i, len, nearestElement;
for (i = 0, len = elements.length; i < len; ++i) {
- var el = elements[i];
+ var el = elements[i].element;
if (el && el.hasValue()) {
var center = el.getCenterPoint();
var d = helpers.distanceBetweenPoints(eventPosition, center);
/**
* Private helper to create a tooltip item model
- * @param element - the chart element (point, arc, bar) to create the tooltip item for
+ * @param item - the chart element (point, arc, bar) to create the tooltip item for
* @return new tooltip item
*/
-function createTooltipItem(chart, element) {
- var datasetIndex = element._datasetIndex;
- var index = element._index;
- var controller = chart.getDatasetMeta(datasetIndex).controller;
- var indexScale = controller._getIndexScale();
- var valueScale = controller._getValueScale();
- var parsed = controller._getParsed(index);
+function createTooltipItem(chart, item) {
+ const {datasetIndex, element, index} = item;
+ const controller = chart.getDatasetMeta(datasetIndex).controller;
+ const indexScale = controller._getIndexScale();
+ const valueScale = controller._getValueScale();
+ const parsed = controller._getParsed(index);
return {
label: indexScale ? '' + indexScale.getLabelForValue(parsed[indexScale.id]) : '',
}
// Remember Last Actives
- changed = !helpers.arrayEquals(me._active, me._lastActive);
+ changed = !helpers._elementsEqual(me._active, me._lastActive);
// Only handle target event on tooltip change
if (changed) {
return true;
},
+ /**
+ * Returns true if the `a0` and `a1` arrays have the same content, else returns false.
+ * @param {Array} a0 - The array to compare
+ * @param {Array} a1 - The array to compare
+ * @returns {boolean}
+ */
+ _elementsEqual: function(a0, a1) {
+ let i, ilen, v0, v1;
+
+ if (!a0 || !a1 || a0.length !== a1.length) {
+ return false;
+ }
+
+ for (i = 0, ilen = a0.length; i < ilen; ++i) {
+ v0 = a0[i];
+ v1 = a1[i];
+
+ if (v0.datasetIndex !== v1.datasetIndex || v0.index !== v1.index) {
+ return false;
+ }
+ }
+
+ return true;
+ },
+
/**
* Returns a deep copy of `source` without keeping references on objects and arrays.
* @param {*} source - The value to clone.
var meta = chart.getDatasetMeta(1);
var bar = meta.data[0];
- meta.controller.setHoverStyle(bar);
+ meta.controller.setHoverStyle(bar, 1, 0);
expect(bar._model.backgroundColor).toBe('rgb(230, 0, 0)');
expect(bar._model.borderColor).toBe('rgb(0, 0, 230)');
expect(bar._model.borderWidth).toBe(2);
chart.data.datasets[1].hoverBorderColor = 'rgb(0, 0, 0)';
chart.data.datasets[1].hoverBorderWidth = 5;
- meta.controller.setHoverStyle(bar);
+ meta.controller.setHoverStyle(bar, 1, 0);
expect(bar._model.backgroundColor).toBe('rgb(128, 128, 128)');
expect(bar._model.borderColor).toBe('rgb(0, 0, 0)');
expect(bar._model.borderWidth).toBe(5);
chart.data.datasets[1].hoverBorderColor = ['rgb(9, 9, 9)', 'rgb(0, 0, 0)'];
chart.data.datasets[1].hoverBorderWidth = [2.5, 5];
- meta.controller.setHoverStyle(bar);
+ meta.controller.setHoverStyle(bar, 1, 0);
expect(bar._model.backgroundColor).toBe('rgb(255, 255, 255)');
expect(bar._model.borderColor).toBe('rgb(9, 9, 9)');
expect(bar._model.borderWidth).toBe(2.5);
expect(bar._model.backgroundColor).toBe('rgb(128, 128, 128)');
expect(bar._model.borderColor).toBe('rgb(15, 15, 15)');
expect(bar._model.borderWidth).toBe(3.14);
- meta.controller.setHoverStyle(bar);
+ meta.controller.setHoverStyle(bar, 1, 0);
expect(bar._model.backgroundColor).toBe(helpers.getHoverColor('rgb(128, 128, 128)'));
expect(bar._model.borderColor).toBe(helpers.getHoverColor('rgb(15, 15, 15)'));
expect(bar._model.borderWidth).toBe(3.14);
expect(bar._model.backgroundColor).toBe('rgb(255, 255, 255)');
expect(bar._model.borderColor).toBe('rgb(9, 9, 9)');
expect(bar._model.borderWidth).toBe(2.5);
- meta.controller.setHoverStyle(bar);
+ meta.controller.setHoverStyle(bar, 1, 0);
expect(bar._model.backgroundColor).toBe(helpers.getHoverColor('rgb(255, 255, 255)'));
expect(bar._model.borderColor).toBe(helpers.getHoverColor('rgb(9, 9, 9)'));
expect(bar._model.borderWidth).toBe(2.5);
// Check and see if tooltip was displayed
var tooltip = chart.tooltip;
- expect(chart.lastActive).toEqual([point]);
- expect(tooltip._lastActive).toEqual([point]);
+ expect(chart.lastActive[0].element).toEqual(point);
+ expect(tooltip._lastActive[0].element).toEqual(point);
// Update and confirm tooltip is updated
chart.update();
- expect(chart.lastActive).toEqual([point]);
- expect(tooltip._lastActive).toEqual([point]);
+ expect(chart.lastActive[0].element).toEqual(point);
+ expect(tooltip._lastActive[0].element).toEqual(point);
});
it ('should update the metadata', function() {
y: point._model.y,
};
- var elements = Chart.Interaction.modes.point(chart, evt);
+ var elements = Chart.Interaction.modes.point(chart, evt).map(item => item.element);
expect(elements).toEqual([point, meta1.data[1]]);
});
y: 0
};
- var elements = Chart.Interaction.modes.point(chart, evt);
+ var elements = Chart.Interaction.modes.point(chart, evt).map(item => item.element);
expect(elements).toEqual([]);
});
});
y: point._model.y,
};
- var elements = Chart.Interaction.modes.index(chart, evt, {intersect: true});
+ var elements = Chart.Interaction.modes.index(chart, evt, {intersect: true}).map(item => item.element);
expect(elements).toEqual([point, meta1.data[1]]);
});
y: 0,
};
- var elements = Chart.Interaction.modes.index(chart, evt, {intersect: true});
+ var elements = Chart.Interaction.modes.index(chart, evt, {intersect: true}).map(item => item.element);
expect(elements).toEqual([]);
});
});
y: 0
};
- var elements = Chart.Interaction.modes.index(chart, evt, {intersect: false});
+ var elements = Chart.Interaction.modes.index(chart, evt, {intersect: false}).map(item => item.element);
expect(elements).toEqual([meta0.data[0], meta1.data[0]]);
});
y: center.y + 30,
};
- var elements = Chart.Interaction.modes.index(chart, evt, {axis: 'y', intersect: false});
+ var elements = Chart.Interaction.modes.index(chart, evt, {axis: 'y', intersect: false}).map(item => item.element);
expect(elements).toEqual([meta0.data[0], meta1.data[0]]);
});
y: 0
};
- var elements = Chart.Interaction.modes.index(chart, evt, {axis: 'xy', intersect: false});
+ var elements = Chart.Interaction.modes.index(chart, evt, {axis: 'xy', intersect: false}).map(item => item.element);
expect(elements).toEqual([meta0.data[0], meta1.data[0]]);
});
});
};
var elements = Chart.Interaction.modes.dataset(chart, evt, {intersect: true});
- expect(elements).toEqual(meta.data);
+ expect(elements).toEqual([{datasetIndex: 0}]);
});
it ('should return an empty array if nothing found', function() {
};
var elements = Chart.Interaction.modes.dataset(chart, evt, {axis: 'x', intersect: false});
-
- var meta = chart.getDatasetMeta(0);
- expect(elements).toEqual(meta.data);
+ expect(elements).toEqual([{datasetIndex: 0}]);
});
it ('axis: y gets correct items', function() {
};
var elements = Chart.Interaction.modes.dataset(chart, evt, {axis: 'y', intersect: false});
-
- var meta = chart.getDatasetMeta(1);
- expect(elements).toEqual(meta.data);
+ expect(elements).toEqual([{datasetIndex: 1}]);
});
it ('axis: xy gets correct items', function() {
};
var elements = Chart.Interaction.modes.dataset(chart, evt, {intersect: false});
-
- var meta = chart.getDatasetMeta(1);
- expect(elements).toEqual(meta.data);
+ expect(elements).toEqual([{datasetIndex: 1}]);
});
});
});
};
// Nearest to 0,0 (top left) will be first point of dataset 2
- var elements = Chart.Interaction.modes.nearest(chart, evt, {intersect: false});
+ var elements = Chart.Interaction.modes.nearest(chart, evt, {intersect: false}).map(item => item.element);
var meta = chart.getDatasetMeta(1);
expect(elements).toEqual([meta.data[0]]);
});
};
// Both points are nearest
- var elements = Chart.Interaction.modes.nearest(chart, evt, {intersect: false});
+ var elements = Chart.Interaction.modes.nearest(chart, evt, {intersect: false}).map(item => item.element);
expect(elements).toEqual([meta0.data[1], meta1.data[1]]);
});
});
};
// Middle point from both series are nearest
- var elements = Chart.Interaction.modes.nearest(chart, evt, {axis: 'x', intersect: false});
+ var elements = Chart.Interaction.modes.nearest(chart, evt, {axis: 'x', intersect: false}).map(item => item.element);
expect(elements).toEqual([meta0.data[1], meta1.data[1]]);
});
};
// Should return all (4) points from 'Point 1' and 'Point 2'
- var elements = Chart.Interaction.modes.nearest(chart, evt, {axis: 'x', intersect: false});
+ var elements = Chart.Interaction.modes.nearest(chart, evt, {axis: 'x', intersect: false}).map(item => item.element);
expect(elements).toEqual([meta0.data[0], meta0.data[1], meta1.data[0], meta1.data[1]]);
});
});
};
// Middle point from both series are nearest
- var elements = Chart.Interaction.modes.nearest(chart, evt, {axis: 'y', intersect: false});
+ var elements = Chart.Interaction.modes.nearest(chart, evt, {axis: 'y', intersect: false}).map(item => item.element);
expect(elements).toEqual([meta0.data[2]]);
});
};
// Should return points with value 40
- var elements = Chart.Interaction.modes.nearest(chart, evt, {axis: 'y', intersect: false});
+ var elements = Chart.Interaction.modes.nearest(chart, evt, {axis: 'y', intersect: false}).map(item => item.element);
expect(elements).toEqual([meta0.data[1], meta1.data[0], meta1.data[1], meta1.data[2]]);
});
});
};
// Nothing intersects so find nothing
- var elements = Chart.Interaction.modes.nearest(chart, evt, {intersect: true});
+ var elements = Chart.Interaction.modes.nearest(chart, evt, {intersect: true}).map(item => item.element);
expect(elements).toEqual([]);
evt = {
x: point._view.x,
y: point._view.y
};
- elements = Chart.Interaction.modes.nearest(chart, evt, {intersect: true});
+ elements = Chart.Interaction.modes.nearest(chart, evt, {intersect: true}).map(item => item.element);
expect(elements).toEqual([point]);
});
y: pt.y
};
- var elements = Chart.Interaction.modes.nearest(chart, evt, {intersect: true});
+ var elements = Chart.Interaction.modes.nearest(chart, evt, {intersect: true}).map(item => item.element);
expect(elements).toEqual([meta0.data[1]]);
});
y: pt.y
};
- var elements = Chart.Interaction.modes.nearest(chart, evt, {intersect: true});
+ var elements = Chart.Interaction.modes.nearest(chart, evt, {intersect: true}).map(item => item.element);
expect(elements).toEqual([meta0.data[1], meta1.data[1]]);
});
});
y: 0
};
- var elements = Chart.Interaction.modes.x(chart, evt, {intersect: false});
+ var elements = Chart.Interaction.modes.x(chart, evt, {intersect: false}).map(item => item.element);
expect(elements).toEqual([meta0.data[1], meta1.data[1]]);
evt = {
y: 0
};
- elements = Chart.Interaction.modes.x(chart, evt, {intersect: false});
+ elements = Chart.Interaction.modes.x(chart, evt, {intersect: false}).map(item => item.element);
expect(elements).toEqual([]);
});
y: 0
};
- var elements = Chart.Interaction.modes.x(chart, evt, {intersect: true});
+ var elements = Chart.Interaction.modes.x(chart, evt, {intersect: true}).map(item => item.element);
expect(elements).toEqual([]); // we don't intersect anything
evt = {
y: pt.y
};
- elements = Chart.Interaction.modes.x(chart, evt, {intersect: true});
+ elements = Chart.Interaction.modes.x(chart, evt, {intersect: true}).map(item => item.element);
expect(elements).toEqual([meta0.data[1], meta1.data[1]]);
});
});
y: pt.y,
};
- var elements = Chart.Interaction.modes.y(chart, evt, {intersect: false});
+ var elements = Chart.Interaction.modes.y(chart, evt, {intersect: false}).map(item => item.element);
expect(elements).toEqual([meta0.data[1], meta1.data[0], meta1.data[1], meta1.data[2]]);
evt = {
y: pt.y + 20, // out of range
};
- elements = Chart.Interaction.modes.y(chart, evt, {intersect: false});
+ elements = Chart.Interaction.modes.y(chart, evt, {intersect: false}).map(item => item.element);
expect(elements).toEqual([]);
});
y: pt.y
};
- var elements = Chart.Interaction.modes.y(chart, evt, {intersect: true});
+ var elements = Chart.Interaction.modes.y(chart, evt, {intersect: true}).map(item => item.element);
expect(elements).toEqual([]); // we don't intersect anything
evt = {
y: pt.y,
};
- elements = Chart.Interaction.modes.y(chart, evt, {intersect: true});
+ elements = Chart.Interaction.modes.y(chart, evt, {intersect: true}).map(item => item.element);
expect(elements).toEqual([meta0.data[1], meta1.data[0], meta1.data[1], meta1.data[2]]);
});
});
});
// fake out the tooltip hover and force the tooltip to update
- chart.tooltip._active = [chart.getDatasetMeta(0).data[0]];
+ chart.tooltip._active = [{element: chart.getDatasetMeta(0).data[0], datasetIndex: 0, index: 0}];
chart.tooltip.update();
// Title is always blank
});
// fake out the tooltip hover and force the tooltip to update
- chart.tooltip._active = [chart.getDatasetMeta(0).data[1]];
+ chart.tooltip._active = [{element: chart.getDatasetMeta(0).data[1], datasetIndex: 0, index: 1}];
chart.tooltip.update();
// Title is always blank
});
// fake out the tooltip hover and force the tooltip to update
- chart.tooltip._active = [chart.getDatasetMeta(0).data[1]];
+ chart.tooltip._active = [{element: chart.getDatasetMeta(0).data[1], datasetIndex: 0, index: 1}];
chart.tooltip.update();
// Title is always blank
var expected = [{
text: 'label1',
fillStyle: 'red',
- hidden: false,
+ hidden: undefined,
index: 0,
strokeStyle: '#000',
lineWidth: 2
}, {
text: 'label2',
fillStyle: 'green',
- hidden: false,
+ hidden: undefined,
index: 1,
strokeStyle: '#000',
lineWidth: 2
});
// fake out the tooltip hover and force the tooltip to update
- chart.tooltip._active = [chart.getDatasetMeta(0).data[1]];
+ chart.tooltip._active = [{element: chart.getDatasetMeta(0).data[1], datasetIndex: 0, index: 1}];
chart.tooltip.update();
// Title is always blank
var expected = [{
text: 'label1',
fillStyle: 'red',
- hidden: false,
+ hidden: undefined,
index: 0,
strokeStyle: '#000',
lineWidth: 2
}, {
text: 'label2',
fillStyle: 'green',
- hidden: false,
+ hidden: undefined,
index: 1,
strokeStyle: '#000',
lineWidth: 2
});
});
+ describe('_elementsEqual', function() {
+ it('should return true if arrays are the same', function() {
+ expect(helpers._elementsEqual(
+ [{datasetIndex: 0, index: 1}, {datasetIndex: 0, index: 2}],
+ [{datasetIndex: 0, index: 1}, {datasetIndex: 0, index: 2}])).toBeTruthy();
+ });
+ it('should return false if arrays are not the same', function() {
+ expect(helpers._elementsEqual([], [{datasetIndex: 0, index: 1}])).toBeFalsy();
+ expect(helpers._elementsEqual([{datasetIndex: 0, index: 2}], [{datasetIndex: 0, index: 1}])).toBeFalsy();
+ });
+ });
+
describe('clone', function() {
it('should clone primitive values', function() {
expect(helpers.clone()).toBe(undefined);