1261179630

Build Type

push

github

Committed by GitHub

Commit Message

Add chart method for getting initial scale bounds (#585)

Run Details

252 of 316 branches covered (79.75%)

Branch coverage included in aggregate %.

15 of 16 new or added lines in 2 files covered. (93.75%)

3 existing lines in 1 file now uncovered.

389 of 450 relevant lines covered (86.44%)

1017.66 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

81.9

/src/core.js

import {each, callback as call, sign, valueOrDefault} from 'chart.js/helpers';
import {panFunctions, updateRange, zoomFunctions} from './scale.types';
import {getState} from './state';
import {directionEnabled, getEnabledScalesByPoint} from './utils';

function shouldUpdateScaleLimits(scale, originalScaleLimits, updatedScaleLimits) {
  const {id, options: {min, max}} = scale;
  if (!originalScaleLimits[id] || !updatedScaleLimits[id]) {
    return true;
  }
  const previous = updatedScaleLimits[id];
  return previous.min !== min || previous.max !== max;
}

function removeMissingScales(limits, scales) {
  each(limits, (opt, key) => {
    if (!scales[key]) {
      delete limits[key];
    }
  });
}

function storeOriginalScaleLimits(chart, state) {
  const {scales} = chart;
  const {originalScaleLimits, updatedScaleLimits} = state;

  each(scales, function(scale) {
    if (shouldUpdateScaleLimits(scale, originalScaleLimits, updatedScaleLimits)) {
      originalScaleLimits[scale.id] = {
        min: {scale: scale.min, options: scale.options.min},
        max: {scale: scale.max, options: scale.options.max},
      };
    }
  });

  removeMissingScales(originalScaleLimits, scales);
  removeMissingScales(updatedScaleLimits, scales);
  return originalScaleLimits;
}

function doZoom(scale, amount, center, limits) {
  const fn = zoomFunctions[scale.type] || zoomFunctions.default;
  call(fn, [scale, amount, center, limits]);
}

function getCenter(chart) {
  const ca = chart.chartArea;
  return {
    x: (ca.left + ca.right) / 2,
    y: (ca.top + ca.bottom) / 2,
  };
}

/**
 * @param chart The chart instance
 * @param {number | {x?: number, y?: number, focalPoint?: {x: number, y: number}}} amount The zoom percentage or percentages and focal point
 * @param {string} [transition] Which transition mode to use. Defaults to 'none'
 */
export function zoom(chart, amount, transition = 'none') {
  const {x = 1, y = 1, focalPoint = getCenter(chart)} = typeof amount === 'number' ? {x: amount, y: amount} : amount;
  const state = getState(chart);
  const {options: {limits, zoom: zoomOptions}} = state;
  const {mode = 'xy', overScaleMode} = zoomOptions || {};

  storeOriginalScaleLimits(chart, state);

  const xEnabled = x !== 1 && directionEnabled(mode, 'x', chart);
  const yEnabled = y !== 1 && directionEnabled(mode, 'y', chart);
  const enabledScales = overScaleMode && getEnabledScalesByPoint(overScaleMode, focalPoint, chart);

  each(enabledScales || chart.scales, function(scale) {
    if (scale.isHorizontal() && xEnabled) {
      doZoom(scale, x, focalPoint, limits);
    } else if (!scale.isHorizontal() && yEnabled) {
      doZoom(scale, y, focalPoint, limits);
    }
  });

  chart.update(transition);

  call(zoomOptions.onZoom, [{chart}]);
}

function getRange(scale, pixel0, pixel1) {
  const v0 = scale.getValueForPixel(pixel0);
  const v1 = scale.getValueForPixel(pixel1);
  return {
    min: Math.min(v0, v1),
    max: Math.max(v0, v1)
  };
}

export function zoomRect(chart, p0, p1, transition = 'none') {
  const state = getState(chart);
  const {options: {limits, zoom: zoomOptions}} = state;
  const {mode = 'xy'} = zoomOptions;

  storeOriginalScaleLimits(chart, state);
  const xEnabled = directionEnabled(mode, 'x', chart);
  const yEnabled = directionEnabled(mode, 'y', chart);

  each(chart.scales, function(scale) {
    if (scale.isHorizontal() && xEnabled) {
      updateRange(scale, getRange(scale, p0.x, p1.x), limits, true);
    } else if (!scale.isHorizontal() && yEnabled) {
      updateRange(scale, getRange(scale, p0.y, p1.y), limits, true);
    }
  });

  chart.update(transition);

  call(zoomOptions.onZoom, [{chart}]);
}

export function zoomScale(chart, scaleId, range, transition = 'none') {
  storeOriginalScaleLimits(chart, getState(chart));
  const scale = chart.scales[scaleId];
  updateRange(scale, range, undefined, true);
  chart.update(transition);
}

export function resetZoom(chart, transition = 'default') {
  const state = getState(chart);
  const originalScaleLimits = storeOriginalScaleLimits(chart, state);

  each(chart.scales, function(scale) {
    const scaleOptions = scale.options;
    if (originalScaleLimits[scale.id]) {
      scaleOptions.min = originalScaleLimits[scale.id].min.options;
      scaleOptions.max = originalScaleLimits[scale.id].max.options;
    } else {
      delete scaleOptions.min;
      delete scaleOptions.max;
    }
  });
  chart.update(transition);
  call(state.options.zoom.onZoomComplete, [{chart}]);
}

function getOriginalRange(state, scaleId) {
  const original = state.originalScaleLimits[scaleId];
  if (!original) {
    return;
  }
  const {min, max} = original;
  return valueOrDefault(max.options, max.scale) - valueOrDefault(min.options, min.scale);
}

export function getZoomLevel(chart) {
  const state = getState(chart);
  let min = 1;
  let max = 1;
  each(chart.scales, function(scale) {
    const origRange = getOriginalRange(state, scale.id);
    if (origRange) {
      const level = Math.round(origRange / (scale.max - scale.min) * 100) / 100;
      min = Math.min(min, level);
      max = Math.max(max, level);
    }
  });
  return min < 1 ? min : max;
}

function panScale(scale, delta, limits, state) {
  const {panDelta} = state;
  // Add possible cumulative delta from previous pan attempts where scale did not change
  const storedDelta = panDelta[scale.id] || 0;
  if (sign(storedDelta) === sign(delta)) {
    delta += storedDelta;
  }
  const fn = panFunctions[scale.type] || panFunctions.default;
  if (call(fn, [scale, delta, limits])) {
    // The scale changed, reset cumulative delta
    panDelta[scale.id] = 0;
  } else {
    // The scale did not change, store cumulative delta
    panDelta[scale.id] = delta;
  }
}

export function pan(chart, delta, enabledScales, transition = 'none') {
  const {x = 0, y = 0} = typeof delta === 'number' ? {x: delta, y: delta} : delta;
  const state = getState(chart);
  const {options: {pan: panOptions, limits}} = state;
  const {mode = 'xy', onPan} = panOptions || {};

  storeOriginalScaleLimits(chart, state);

  const xEnabled = x !== 0 && directionEnabled(mode, 'x', chart);
  const yEnabled = y !== 0 && directionEnabled(mode, 'y', chart);

  each(enabledScales || chart.scales, function(scale) {
    if (scale.isHorizontal() && xEnabled) {
      panScale(scale, x, limits, state);
    } else if (!scale.isHorizontal() && yEnabled) {
      panScale(scale, y, limits, state);
    }
  });

  chart.update(transition);

  call(onPan, [{chart}]);
}

export function getInitialScaleBounds(chart) {
  const state = getState(chart);
  const scaleBounds = {};
  for (const scaleId of Object.keys(chart.scales)) {
    const {min, max} = state.originalScaleLimits[scaleId] || {min: {}, max: {}};
    scaleBounds[scaleId] = {min: min.scale, max: max.scale};
  }

  return scaleBounds;
}

export function isZoomedOrPanned(chart) {
  const scaleBounds = getInitialScaleBounds(chart);
  for (const scaleId of Object.keys(chart.scales)) {
    const {min: originalMin, max: originalMax} = scaleBounds[scaleId];

    if (chart.scales[scaleId].min !== originalMin) {
      return true;
    }

    if (chart.scales[scaleId].max !== originalMax) {
      return true;
    }
  }

  return false;
}

1	import {each, callback as call, sign, valueOrDefault} from 'chart.js/helpers';
2	import {panFunctions, updateRange, zoomFunctions} from './scale.types';
3	import {getState} from './state';
4	import {directionEnabled, getEnabledScalesByPoint} from './utils';
5
6	function shouldUpdateScaleLimits(scale, originalScaleLimits, updatedScaleLimits) {
7	const {id, options: {min, max}} = scale;	1,640✔
8	if (!originalScaleLimits[id] \|\| !updatedScaleLimits[id]) {	1,640✔
9	return true;	956✔
10	}
11	const previous = updatedScaleLimits[id];	684✔
12	return previous.min !== min \|\| previous.max !== max;	684✔
13	}
14
15	function removeMissingScales(limits, scales) {
16	each(limits, (opt, key) => {	1,640✔
17	if (!scales[key]) {	2,324!
18	delete limits[key];	×
19	}
20	});
21	}
22
23	function storeOriginalScaleLimits(chart, state) {
24	const {scales} = chart;	820✔
25	const {originalScaleLimits, updatedScaleLimits} = state;	820✔
26
27	each(scales, function(scale) {	820✔
28	if (shouldUpdateScaleLimits(scale, originalScaleLimits, updatedScaleLimits)) {	1,640✔
29	originalScaleLimits[scale.id] = {	968✔
30	min: {scale: scale.min, options: scale.options.min},
31	max: {scale: scale.max, options: scale.options.max},
32	};
33	}
34	});
35
36	removeMissingScales(originalScaleLimits, scales);	820✔
37	removeMissingScales(updatedScaleLimits, scales);	820✔
38	return originalScaleLimits;	820✔
39	}
40
41	function doZoom(scale, amount, center, limits) {
42	const fn = zoomFunctions[scale.type] \|\| zoomFunctions.default;	208✔
43	call(fn, [scale, amount, center, limits]);	208✔
44	}
45
46	function getCenter(chart) {
47	const ca = chart.chartArea;	64✔
48	return {	64✔
49	x: (ca.left + ca.right) / 2,
50	y: (ca.top + ca.bottom) / 2,
51	};
52	}
53
54	/**
55	* @param chart The chart instance
56	* @param {number \| {x?: number, y?: number, focalPoint?: {x: number, y: number}}} amount The zoom percentage or percentages and focal point
57	* @param {string} [transition] Which transition mode to use. Defaults to 'none'
58	*/
59	export function zoom(chart, amount, transition = 'none') {	168✔
60	const {x = 1, y = 1, focalPoint = getCenter(chart)} = typeof amount === 'number' ? {x: amount, y: amount} : amount;	168!
61	const state = getState(chart);	168✔
62	const {options: {limits, zoom: zoomOptions}} = state;	168✔
63	const {mode = 'xy', overScaleMode} = zoomOptions \|\| {};	168!
64
65	storeOriginalScaleLimits(chart, state);	168✔
66
67	const xEnabled = x !== 1 && directionEnabled(mode, 'x', chart);	168✔
68	const yEnabled = y !== 1 && directionEnabled(mode, 'y', chart);	168✔
69	const enabledScales = overScaleMode && getEnabledScalesByPoint(overScaleMode, focalPoint, chart);	168✔
70
71	each(enabledScales \|\| chart.scales, function(scale) {	168✔
72	if (scale.isHorizontal() && xEnabled) {	328✔
73	doZoom(scale, x, focalPoint, limits);	140✔
74	} else if (!scale.isHorizontal() && yEnabled) {	188✔
75	doZoom(scale, y, focalPoint, limits);	68✔
76	}
77	});
78
79	chart.update(transition);	168✔
80
81	call(zoomOptions.onZoom, [{chart}]);	168✔
82	}
83
84	function getRange(scale, pixel0, pixel1) {
85	const v0 = scale.getValueForPixel(pixel0);	64✔
86	const v1 = scale.getValueForPixel(pixel1);	64✔
87	return {	64✔
88	min: Math.min(v0, v1),
89	max: Math.max(v0, v1)
90	};
91	}
92
93	export function zoomRect(chart, p0, p1, transition = 'none') {	×
94	const state = getState(chart);	56✔
95	const {options: {limits, zoom: zoomOptions}} = state;	56✔
96	const {mode = 'xy'} = zoomOptions;	56!
97
98	storeOriginalScaleLimits(chart, state);	56✔
99	const xEnabled = directionEnabled(mode, 'x', chart);	56✔
100	const yEnabled = directionEnabled(mode, 'y', chart);	56✔
101
102	each(chart.scales, function(scale) {	56✔
103	if (scale.isHorizontal() && xEnabled) {	112✔
104	updateRange(scale, getRange(scale, p0.x, p1.x), limits, true);	48✔
105	} else if (!scale.isHorizontal() && yEnabled) {	64✔
106	updateRange(scale, getRange(scale, p0.y, p1.y), limits, true);	16✔
107	}
108	});
109
110	chart.update(transition);	56✔
111
112	call(zoomOptions.onZoom, [{chart}]);	56✔
113	}
114
115	export function zoomScale(chart, scaleId, range, transition = 'none') {	8✔
116	storeOriginalScaleLimits(chart, getState(chart));	8✔
117	const scale = chart.scales[scaleId];	8✔
118	updateRange(scale, range, undefined, true);	8✔
119	chart.update(transition);	8✔
120	}
121
122	export function resetZoom(chart, transition = 'default') {	44✔
123	const state = getState(chart);	44✔
124	const originalScaleLimits = storeOriginalScaleLimits(chart, state);	44✔
125
126	each(chart.scales, function(scale) {	44✔
127	const scaleOptions = scale.options;	88✔
128	if (originalScaleLimits[scale.id]) {	88!
129	scaleOptions.min = originalScaleLimits[scale.id].min.options;	88✔
130	scaleOptions.max = originalScaleLimits[scale.id].max.options;	88✔
131	} else {
132	delete scaleOptions.min;	×
133	delete scaleOptions.max;	×
134	}
135	});
136	chart.update(transition);	44✔
137	call(state.options.zoom.onZoomComplete, [{chart}]);	44✔
138	}
139
140	function getOriginalRange(state, scaleId) {
141	const original = state.originalScaleLimits[scaleId];	×
142	if (!original) {	×
143	return;	×
144	}
145	const {min, max} = original;	×
146	return valueOrDefault(max.options, max.scale) - valueOrDefault(min.options, min.scale);	×
147	}
148
149	export function getZoomLevel(chart) {
150	const state = getState(chart);	×
151	let min = 1;	×
152	let max = 1;	×
153	each(chart.scales, function(scale) {	×
154	const origRange = getOriginalRange(state, scale.id);	×
155	if (origRange) {	×
156	const level = Math.round(origRange / (scale.max - scale.min) * 100) / 100;	×
157	min = Math.min(min, level);	×
158	max = Math.max(max, level);	×
159	}
160	});
161	return min < 1 ? min : max;	×
162	}
163
164	function panScale(scale, delta, limits, state) {
165	const {panDelta} = state;	552✔
166	// Add possible cumulative delta from previous pan attempts where scale did not change
167	const storedDelta = panDelta[scale.id] \|\| 0;	552✔
168	if (sign(storedDelta) === sign(delta)) {	552✔
169	delta += storedDelta;	72✔
170	}
171	const fn = panFunctions[scale.type] \|\| panFunctions.default;	552✔
172	if (call(fn, [scale, delta, limits])) {	552✔
173	// The scale changed, reset cumulative delta
174	panDelta[scale.id] = 0;	476✔
175	} else {
176	// The scale did not change, store cumulative delta
177	panDelta[scale.id] = delta;	76✔
178	}
179	}
180
181	export function pan(chart, delta, enabledScales, transition = 'none') {	544✔
182	const {x = 0, y = 0} = typeof delta === 'number' ? {x: delta, y: delta} : delta;	544!
183	const state = getState(chart);	544✔
184	const {options: {pan: panOptions, limits}} = state;	544✔
185	const {mode = 'xy', onPan} = panOptions \|\| {};	544!
186
187	storeOriginalScaleLimits(chart, state);	544✔
188
189	const xEnabled = x !== 0 && directionEnabled(mode, 'x', chart);	544✔
190	const yEnabled = y !== 0 && directionEnabled(mode, 'y', chart);	544✔
191
192	each(enabledScales \|\| chart.scales, function(scale) {	544✔
193	if (scale.isHorizontal() && xEnabled) {	1,088✔
194	panScale(scale, x, limits, state);	536✔
195	} else if (!scale.isHorizontal() && yEnabled) {	552✔
196	panScale(scale, y, limits, state);	16✔
197	}
198	});
199
200	chart.update(transition);	544✔
201
202	call(onPan, [{chart}]);	544✔
203	}
204
205	export function getInitialScaleBounds(chart) {
206	const state = getState(chart);	60✔
207	const scaleBounds = {};	60✔
208	for (const scaleId of Object.keys(chart.scales)) {	60✔
209	const {min, max} = state.originalScaleLimits[scaleId] \|\| {min: {}, max: {}};	120!
210	scaleBounds[scaleId] = {min: min.scale, max: max.scale};	120✔
211	}
212
213	return scaleBounds;	60✔
214	}
215
216	export function isZoomedOrPanned(chart) {
217	const scaleBounds = getInitialScaleBounds(chart);	28✔
218	for (const scaleId of Object.keys(chart.scales)) {	28✔
219	const {min: originalMin, max: originalMax} = scaleBounds[scaleId];	44✔
220
221	if (chart.scales[scaleId].min !== originalMin) {	44✔
222	return true;	12✔
223	}
224
225	if (chart.scales[scaleId].max !== originalMax) {	32!
NEW 226	return true;	×
227	}
228	}
229
230	return false;	16✔
231	}

chartjs / chartjs-plugin-zoom / 1261179630

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous