#### Renamed private APIs
+* `BarController.calculateBarIndexPixels` was renamed to `BarController._calculateBarIndexPixels`
+* `BarController.calculateBarValuePixels` was renamed to `BarController._calculateBarValuePixels`
+* `BarController.getStackCount` was renamed to `BarController._getStackCount`
+* `BarController.getStackIndex` was renamed to `BarController._getStackIndex`
+* `BarController.getRuler` was renamed to `BarController._getRuler`
+* `Chart.destroyDatasetMeta` was renamed to `Chart._destroyDatasetMeta`
+* `Chart.drawDataset` was renamed to `Chart._drawDataset`
+* `Chart.drawDatasets` was renamed to `Chart._drawDatasets`
+* `Chart.eventHandler` was renamed to `Chart._eventHandler`
+* `Chart.handleEvent` was renamed to `Chart._handleEvent`
+* `Chart.initialize` was renamed to `Chart._initialize`
+* `Chart.resetElements` was renamed to `Chart._resetElements`
+* `Chart.unbindEvents` was renamed to `Chart._unbindEvents`
+* `Chart.updateDataset` was renamed to `Chart._updateDataset`
+* `Chart.updateDatasets` was renamed to `Chart._updateDatasets`
+* `Chart.updateLayout` was renamed to `Chart._updateLayout`
+* `DatasetController.destroy` was renamed to `DatasetController._destroy`
+* `DatasetController.insertElements` was renamed to `DatasetController._insertElements`
+* `DatasetController.onDataPop` was renamed to `DatasetController._onDataPop`
+* `DatasetController.onDataPush` was renamed to `DatasetController._onDataPush`
+* `DatasetController.onDataShift` was renamed to `DatasetController._onDataShift`
+* `DatasetController.onDataSplice` was renamed to `DatasetController._onDataSplice`
+* `DatasetController.onDataUnshift` was renamed to `DatasetController._onDataUnshift`
+* `DatasetController.removeElements` was renamed to `DatasetController._removeElements`
+* `DatasetController.resyncElements` was renamed to `DatasetController._resyncElements`
* `helpers._alignPixel` was renamed to `helpers.canvas._alignPixel`
* `helpers._decimalPlaces` was renamed to `helpers.math._decimalPlaces`
-* `chart.initialize` was renamed to `chart._initialize` (labeled as private but not named as such)
### Changed
const vscale = me._cachedMeta.vScale;
const base = vscale.getBasePixel();
const horizontal = vscale.isHorizontal();
- const ruler = me.getRuler();
+ const ruler = me._getRuler();
const firstOpts = me._resolveDataElementOptions(start, mode);
const sharedOptions = me._getSharedOptions(mode, rectangles[start], firstOpts);
const includeOptions = me._includeOptions(mode, sharedOptions);
for (i = 0; i < rectangles.length; i++) {
const index = start + i;
const options = me._resolveDataElementOptions(index, mode);
- const vpixels = me.calculateBarValuePixels(index, options);
- const ipixels = me.calculateBarIndexPixels(index, ruler, options);
+ const vpixels = me._calculateBarValuePixels(index, options);
+ const ipixels = me._calculateBarIndexPixels(index, ruler, options);
const properties = {
horizontal,
* Returns the effective number of stacks based on groups and bar visibility.
* @private
*/
- getStackCount() {
+ _getStackCount() {
return this._getStacks().length;
}
* @returns {number} The stack index
* @private
*/
- getStackIndex(datasetIndex, name) {
+ _getStackIndex(datasetIndex, name) {
var stacks = this._getStacks(datasetIndex);
var index = (name !== undefined)
? stacks.indexOf(name)
/**
* @private
*/
- getRuler() {
+ _getRuler() {
const me = this;
const meta = me._cachedMeta;
const iScale = meta.iScale;
pixels,
start: iScale._startPixel,
end: iScale._endPixel,
- stackCount: me.getStackCount(),
+ stackCount: me._getStackCount(),
scale: iScale
};
}
* Note: pixel values are not clamped to the scale area.
* @private
*/
- calculateBarValuePixels(index, options) {
+ _calculateBarValuePixels(index, options) {
const me = this;
const meta = me._cachedMeta;
const vScale = meta.vScale;
/**
* @private
*/
- calculateBarIndexPixels(index, ruler, options) {
+ _calculateBarIndexPixels(index, ruler, options) {
var me = this;
var range = options.barThickness === 'flex'
? computeFlexCategoryTraits(index, ruler, options)
: computeFitCategoryTraits(index, ruler, options);
- var stackIndex = me.getStackIndex(me.index, me._cachedMeta.stack);
+ var stackIndex = me._getStackIndex(me.index, me._cachedMeta.stack);
var center = range.start + (range.chunk * stackIndex) + (range.chunk / 2);
var size = Math.min(
valueOrDefault(options.maxBarThickness, Infinity),
}
}
+ /**
+ * @private
+ */
_getAnims(chart) {
const charts = this._charts;
let anims = charts.get(chart);
this._updating = false;
this.scales = {};
this.scale = undefined;
+ this.$plugins = undefined;
// Add the chart instance to the global namespace
Chart.instances[me.id] = me;
if (numMeta > numData) {
for (let i = numData; i < numMeta; ++i) {
- me.destroyDatasetMeta(i);
+ me._destroyDatasetMeta(i);
}
metasets.splice(numData, numMeta - numData);
}
const type = dataset.type || me.config.type;
if (meta.type && meta.type !== type) {
- me.destroyDatasetMeta(i);
+ me._destroyDatasetMeta(i);
meta = me.getDatasetMeta(i);
}
meta.type = type;
* Reset the elements of all datasets
* @private
*/
- resetElements() {
+ _resetElements() {
const me = this;
helpers.each(me.data.datasets, function(dataset, datasetIndex) {
me.getDatasetMeta(datasetIndex).controller.reset();
* Resets the chart back to its state before the initial animation
*/
reset() {
- this.resetElements();
+ this._resetElements();
plugins.notify(this, 'reset');
}
me.getDatasetMeta(i).controller.buildOrUpdateElements();
}
- me.updateLayout();
+ me._updateLayout();
// Can only reset the new controllers after the scales have been updated
if (me.options.animation) {
});
}
- me.updateDatasets(mode);
+ me._updateDatasets(mode);
// Do this before render so that any plugins that need final scale updates can use it
plugins.notify(me, 'afterUpdate');
// Replay last event from before update
if (me._lastEvent) {
- me.eventHandler(me._lastEvent);
+ me._eventHandler(me._lastEvent);
}
me.render();
* hook, in which case, plugins will not be called on `afterLayout`.
* @private
*/
- updateLayout() {
+ _updateLayout() {
const me = this;
if (plugins.notify(me, 'beforeLayout') === false) {
* hook, in which case, plugins will not be called on `afterDatasetsUpdate`.
* @private
*/
- updateDatasets(mode) {
+ _updateDatasets(mode) {
const me = this;
const isFunction = typeof mode === 'function';
}
for (let i = 0, ilen = me.data.datasets.length; i < ilen; ++i) {
- me.updateDataset(i, isFunction ? mode({datasetIndex: i}) : mode);
+ me._updateDataset(i, isFunction ? mode({datasetIndex: i}) : mode);
}
plugins.notify(me, 'afterDatasetsUpdate');
* hook, in which case, plugins will not be called on `afterDatasetUpdate`.
* @private
*/
- updateDataset(index, mode) {
+ _updateDataset(index, mode) {
const me = this;
const meta = me.getDatasetMeta(index);
const args = {meta, index, mode};
layers[i].draw(me.chartArea);
}
- me.drawDatasets();
+ me._drawDatasets();
// Rest of layers
for (; i < layers.length; ++i) {
* hook, in which case, plugins will not be called on `afterDatasetsDraw`.
* @private
*/
- drawDatasets() {
+ _drawDatasets() {
const me = this;
let metasets, i;
metasets = me._getSortedVisibleDatasetMetas();
for (i = metasets.length - 1; i >= 0; --i) {
- me.drawDataset(metasets[i]);
+ me._drawDataset(metasets[i]);
}
plugins.notify(me, 'afterDatasetsDraw');
* hook, in which case, plugins will not be called on `afterDatasetDraw`.
* @private
*/
- drawDataset(meta) {
+ _drawDataset(meta) {
const me = this;
const ctx = me.ctx;
const clip = meta._clip;
/**
* @private
*/
- destroyDatasetMeta(datasetIndex) {
+ _destroyDatasetMeta(datasetIndex) {
const me = this;
const meta = me._metasets && me._metasets[datasetIndex];
if (meta) {
- meta.controller.destroy();
+ meta.controller._destroy();
delete me._metasets[datasetIndex];
}
}
// dataset controllers need to cleanup associated data
for (i = 0, ilen = me.data.datasets.length; i < ilen; ++i) {
- me.destroyDatasetMeta(i);
+ me._destroyDatasetMeta(i);
}
if (canvas) {
const me = this;
const listeners = me._listeners;
let listener = function() {
- me.eventHandler.apply(me, arguments);
+ me._eventHandler.apply(me, arguments);
};
helpers.each(me.options.events, function(type) {
/**
* @private
*/
- eventHandler(e) {
+ _eventHandler(e) {
const me = this;
if (plugins.notify(me, 'beforeEvent', [e]) === false) {
return;
}
- me.handleEvent(e);
+ me._handleEvent(e);
plugins.notify(me, 'afterEvent', [e]);
/**
* Handle an event
- * @private
* @param {IEvent} e the event to handle
* @return {boolean} true if the chart needs to re-render
+ * @private
*/
- handleEvent(e) {
+ _handleEvent(e) {
const me = this;
const options = me.options || {};
const hoverOptions = options.hover;
/**
* Hooks the array methods that add or remove values ('push', pop', 'shift', 'splice',
* 'unshift') and notify the listener AFTER the array has been altered. Listeners are
- * called on the 'onData*' callbacks (e.g. onDataPush, etc.) with same arguments.
+ * called on the '_onData*' callbacks (e.g. _onDataPush, etc.) with same arguments.
*/
function listenArrayEvents(array, listener) {
if (array._chartjs) {
});
arrayEvents.forEach(function(key) {
- var method = 'onData' + key.charAt(0).toUpperCase() + key.slice(1);
+ var method = '_onData' + key.charAt(0).toUpperCase() + key.slice(1);
var base = array[key];
Object.defineProperty(array, key, {
/**
* @private
*/
- destroy() {
+ _destroy() {
if (this._data) {
unlistenArrayEvents(this._data, this);
}
// Re-sync meta data in case the user replaced the data array or if we missed
// any updates and so make sure that we handle number of datapoints changing.
- me.resyncElements(dataChanged || labelsChanged || scaleChanged || stackChanged);
+ me._resyncElements(dataChanged || labelsChanged || scaleChanged || stackChanged);
// if stack changed, update stack values for the whole dataset
if (stackChanged) {
/**
* @private
*/
- resyncElements(changed) {
+ _resyncElements(changed) {
const me = this;
const meta = me._cachedMeta;
const numMeta = meta.data.length;
const numData = me._data.length;
if (numData > numMeta) {
- me.insertElements(numMeta, numData - numMeta);
+ me._insertElements(numMeta, numData - numMeta);
if (changed && numMeta) {
- // insertElements parses the new elements. The old ones might need parsing too.
+ // _insertElements parses the new elements. The old ones might need parsing too.
me._parse(0, numMeta);
}
} else if (numData < numMeta) {
/**
* @private
*/
- insertElements(start, count) {
+ _insertElements(start, count) {
const me = this;
const elements = new Array(count);
const meta = me._cachedMeta;
/**
* @private
*/
- removeElements(start, count) {
+ _removeElements(start, count) {
const me = this;
if (me._parsing) {
me._cachedMeta._parsed.splice(start, count);
/**
* @private
*/
- onDataPush() {
+ _onDataPush() {
const count = arguments.length;
- this.insertElements(this.getDataset().data.length - count, count);
+ this._insertElements(this.getDataset().data.length - count, count);
}
/**
* @private
*/
- onDataPop() {
- this.removeElements(this._cachedMeta.data.length - 1, 1);
+ _onDataPop() {
+ this._removeElements(this._cachedMeta.data.length - 1, 1);
}
/**
* @private
*/
- onDataShift() {
- this.removeElements(0, 1);
+ _onDataShift() {
+ this._removeElements(0, 1);
}
/**
* @private
*/
- onDataSplice(start, count) {
- this.removeElements(start, count);
- this.insertElements(start, arguments.length - 2);
+ _onDataSplice(start, count) {
+ this._removeElements(start, count);
+ this._insertElements(start, arguments.length - 2);
}
/**
* @private
*/
- onDataUnshift() {
- this.insertElements(0, arguments.length);
+ _onDataUnshift() {
+ this._insertElements(0, arguments.length);
}
}
* @returns {boolean} false if any of the plugins return false, else returns true.
*/
notify(chart, hook, args) {
- var descriptors = this.descriptors(chart);
+ var descriptors = this._descriptors(chart);
var ilen = descriptors.length;
var i, descriptor, plugin, params, method;
/**
* Returns descriptors of enabled plugins for the given chart.
+ * @param {Chart} chart
* @returns {object[]} [{ plugin, options }]
* @private
*/
- descriptors(chart) {
+ _descriptors(chart) {
var cache = chart.$plugins || (chart.$plugins = {});
if (cache.id === this._cacheId) {
return cache.descriptors;
* Invalidates cache for the given chart: descriptors hold a reference on plugin option,
* but in some cases, this reference can be changed by the user when updating options.
* https://github.com/chartjs/Chart.js/issues/5111#issuecomment-355934167
+ * @param {Chart} chart
* @private
*/
_invalidate(chart) {
clientX: rect.left + point.x,
clientY: rect.top + point.y
};
- chart.handleEvent(event);
+ chart._handleEvent(event);
chart.tooltip.handleEvent(event);
chart.tooltip.opacity = j / 10;
chart.tooltip.draw(chart.ctx);
});
var meta = chart.getDatasetMeta(1);
- expect(meta.controller.getStackCount()).toBe(2);
+ expect(meta.controller._getStackCount()).toBe(2);
});
});
});
var meta = chart.getDatasetMeta(1);
- expect(meta.controller.getStackCount()).toBe(4);
+ expect(meta.controller._getStackCount()).toBe(4);
});
});
});
var meta = chart.getDatasetMeta(1);
- expect(meta.controller.getStackCount()).toBe(1);
+ expect(meta.controller._getStackCount()).toBe(1);
});
});
});
var meta = chart.getDatasetMeta(1);
- expect(meta.controller.getStackCount()).toBe(4);
+ expect(meta.controller._getStackCount()).toBe(4);
});
});
});
var meta = chart.getDatasetMeta(3);
- expect(meta.controller.getStackCount()).toBe(3);
+ expect(meta.controller._getStackCount()).toBe(3);
});
});
});
var meta = chart.getDatasetMeta(3);
- expect(meta.controller.getStackCount()).toBe(2);
+ expect(meta.controller._getStackCount()).toBe(2);
});
});
});
var meta = chart.getDatasetMeta(3);
- expect(meta.controller.getStackCount()).toBe(4);
+ expect(meta.controller._getStackCount()).toBe(4);
});
});
});
var meta = chart.getDatasetMeta(3);
- expect(meta.controller.getStackCount()).toBe(2);
+ expect(meta.controller._getStackCount()).toBe(2);
});
});
});
var meta = chart.getDatasetMeta(3);
- expect(meta.controller.getStackCount()).toBe(2);
+ expect(meta.controller._getStackCount()).toBe(2);
});
});
});
var meta = chart.getDatasetMeta(3);
- expect(meta.controller.getStackCount()).toBe(4);
+ expect(meta.controller._getStackCount()).toBe(4);
});
});
});
var meta = chart.getDatasetMeta(1);
- expect(meta.controller.getStackIndex(0)).toBe(0);
- expect(meta.controller.getStackIndex(3)).toBe(1);
+ expect(meta.controller._getStackIndex(0)).toBe(0);
+ expect(meta.controller._getStackIndex(3)).toBe(1);
});
});
});
var meta = chart.getDatasetMeta(1);
- expect(meta.controller.getStackIndex(0)).toBe(0);
- expect(meta.controller.getStackIndex(1)).toBe(1);
- expect(meta.controller.getStackIndex(2)).toBe(2);
- expect(meta.controller.getStackIndex(3)).toBe(3);
+ expect(meta.controller._getStackIndex(0)).toBe(0);
+ expect(meta.controller._getStackIndex(1)).toBe(1);
+ expect(meta.controller._getStackIndex(2)).toBe(2);
+ expect(meta.controller._getStackIndex(3)).toBe(3);
});
});
});
var meta = chart.getDatasetMeta(1);
- expect(meta.controller.getStackIndex(0)).toBe(0);
- expect(meta.controller.getStackIndex(1)).toBe(0);
- expect(meta.controller.getStackIndex(2)).toBe(0);
- expect(meta.controller.getStackIndex(3)).toBe(0);
+ expect(meta.controller._getStackIndex(0)).toBe(0);
+ expect(meta.controller._getStackIndex(1)).toBe(0);
+ expect(meta.controller._getStackIndex(2)).toBe(0);
+ expect(meta.controller._getStackIndex(3)).toBe(0);
});
});
});
var meta = chart.getDatasetMeta(1);
- expect(meta.controller.getStackIndex(0)).toBe(0);
- expect(meta.controller.getStackIndex(1)).toBe(1);
- expect(meta.controller.getStackIndex(2)).toBe(2);
- expect(meta.controller.getStackIndex(3)).toBe(3);
+ expect(meta.controller._getStackIndex(0)).toBe(0);
+ expect(meta.controller._getStackIndex(1)).toBe(1);
+ expect(meta.controller._getStackIndex(2)).toBe(2);
+ expect(meta.controller._getStackIndex(3)).toBe(3);
});
});
});
var meta = chart.getDatasetMeta(1);
- expect(meta.controller.getStackIndex(0)).toBe(0);
- expect(meta.controller.getStackIndex(1)).toBe(0);
- expect(meta.controller.getStackIndex(2)).toBe(1);
- expect(meta.controller.getStackIndex(3)).toBe(2);
+ expect(meta.controller._getStackIndex(0)).toBe(0);
+ expect(meta.controller._getStackIndex(1)).toBe(0);
+ expect(meta.controller._getStackIndex(2)).toBe(1);
+ expect(meta.controller._getStackIndex(3)).toBe(2);
});
});
});
var meta = chart.getDatasetMeta(1);
- expect(meta.controller.getStackIndex(0)).toBe(0);
- expect(meta.controller.getStackIndex(1)).toBe(0);
- expect(meta.controller.getStackIndex(2)).toBe(1);
- expect(meta.controller.getStackIndex(3)).toBe(1);
+ expect(meta.controller._getStackIndex(0)).toBe(0);
+ expect(meta.controller._getStackIndex(1)).toBe(0);
+ expect(meta.controller._getStackIndex(2)).toBe(1);
+ expect(meta.controller._getStackIndex(3)).toBe(1);
});
});
});
var meta = chart.getDatasetMeta(1);
- expect(meta.controller.getStackIndex(0)).toBe(0);
- expect(meta.controller.getStackIndex(1)).toBe(1);
- expect(meta.controller.getStackIndex(2)).toBe(2);
- expect(meta.controller.getStackIndex(3)).toBe(3);
+ expect(meta.controller._getStackIndex(0)).toBe(0);
+ expect(meta.controller._getStackIndex(1)).toBe(1);
+ expect(meta.controller._getStackIndex(2)).toBe(2);
+ expect(meta.controller._getStackIndex(3)).toBe(3);
});
});
});
var meta = chart.getDatasetMeta(1);
- expect(meta.controller.getStackIndex(0)).toBe(0);
- expect(meta.controller.getStackIndex(1)).toBe(0);
- expect(meta.controller.getStackIndex(2)).toBe(1);
- expect(meta.controller.getStackIndex(3)).toBe(1);
+ expect(meta.controller._getStackIndex(0)).toBe(0);
+ expect(meta.controller._getStackIndex(1)).toBe(0);
+ expect(meta.controller._getStackIndex(2)).toBe(1);
+ expect(meta.controller._getStackIndex(3)).toBe(1);
});
});
});
var meta = chart.getDatasetMeta(1);
- expect(meta.controller.getStackIndex(0)).toBe(0);
- expect(meta.controller.getStackIndex(1)).toBe(0);
- expect(meta.controller.getStackIndex(2)).toBe(1);
- expect(meta.controller.getStackIndex(3)).toBe(1);
+ expect(meta.controller._getStackIndex(0)).toBe(0);
+ expect(meta.controller._getStackIndex(1)).toBe(0);
+ expect(meta.controller._getStackIndex(2)).toBe(1);
+ expect(meta.controller._getStackIndex(3)).toBe(1);
});
});
});
var meta = chart.getDatasetMeta(1);
- expect(meta.controller.getStackIndex(0)).toBe(0);
- expect(meta.controller.getStackIndex(1)).toBe(1);
- expect(meta.controller.getStackIndex(2)).toBe(2);
- expect(meta.controller.getStackIndex(3)).toBe(3);
+ expect(meta.controller._getStackIndex(0)).toBe(0);
+ expect(meta.controller._getStackIndex(1)).toBe(1);
+ expect(meta.controller._getStackIndex(2)).toBe(2);
+ expect(meta.controller._getStackIndex(3)).toBe(3);
});
});
var controller = chart.getDatasetMeta(0).controller;
var methods = [
- 'onDataPush',
- 'onDataPop',
- 'onDataShift',
- 'onDataSplice',
- 'onDataUnshift'
+ '_onDataPush',
+ '_onDataPop',
+ '_onDataShift',
+ '_onDataSplice',
+ '_onDataUnshift'
];
methods.forEach(function(method) {
}
function afterEvent(chart, type, callback) {
- var override = chart.eventHandler;
- chart.eventHandler = function(event) {
+ var override = chart._eventHandler;
+ chart._eventHandler = function(event) {
override.call(this, event);
if (event.type === type) {
- chart.eventHandler = override;
+ chart._eventHandler = override;
// eslint-disable-next-line callback-return
callback();
}
projects / thirdparty / Chart.js.git / commitdiff
