@octanejs/recharts 0.1.41 → 0.1.42

package/src/util/scale/{getNiceTickValues.js → getNiceTickValues.ts}

@@ -1,68 +1,4 @@
-// Vendored verbatim from recharts@3.9.2 es6/util/scale/getNiceTickValues.js (framework-agnostic).
-// Do not edit — update by re-vendoring when the recharts devDependency moves.
-function _slicedToArray(r, e) {
-	return (
-		_arrayWithHoles(r) ||
-		_iterableToArrayLimit(r, e) ||
-		_unsupportedIterableToArray(r, e) ||
-		_nonIterableRest()
-	);
-}
-function _nonIterableRest() {
-	throw new TypeError(
-		'Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.',
-	);
-}
-function _unsupportedIterableToArray(r, a) {
-	if (r) {
-		if ('string' == typeof r) return _arrayLikeToArray(r, a);
-		var t = {}.toString.call(r).slice(8, -1);
-		return (
-			'Object' === t && r.constructor && (t = r.constructor.name),
-			'Map' === t || 'Set' === t
-				? Array.from(r)
-				: 'Arguments' === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t)
-					? _arrayLikeToArray(r, a)
-					: void 0
-		);
-	}
-}
-function _arrayLikeToArray(r, a) {
-	(null == a || a > r.length) && (a = r.length);
-	for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
-	return n;
-}
-function _iterableToArrayLimit(r, l) {
-	var t =
-		null == r ? null : ('undefined' != typeof Symbol && r[Symbol.iterator]) || r['@@iterator'];
-	if (null != t) {
-		var e,
-			n,
-			i,
-			u,
-			a = [],
-			f = !0,
-			o = !1;
-		try {
-			if (((i = (t = t.call(r)).next), 0 === l)) {
-				if (Object(t) !== t) return;
-				f = !1;
-			} else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
-		} catch (r) {
-			((o = !0), (n = r));
-		} finally {
-			try {
-				if (!f && null != t.return && ((u = t.return()), Object(u) !== u)) return;
-			} finally {
-				if (o) throw n;
-			}
-		}
-		return a;
-	}
-}
-function _arrayWithHoles(r) {
-	if (Array.isArray(r)) return r;
-}
+// Adapted from recharts@3.9.2, commit b3451050c027a23957ffa50a2665c9119df21e47.
 /**
  * @fileOverview calculate tick values of scale
  * @author xile611, arcthur
@@ -70,6 +6,9 @@ function _arrayWithHoles(r) {
  */
 import Decimal from 'decimal.js-light';
 import { getDigitCount, rangeStep } from './util/arithmetic';
+import { NumberDomain } from '../types';
+import { NiceTicksAlgorithm } from '../../state/cartesianAxisSlice';
+
 /**
  * Calculate a interval of a minimum value and a maximum value
  *
@@ -77,18 +16,14 @@ import { getDigitCount, rangeStep } from './util/arithmetic';
  * @param  {Number} max       The maximum value
  * @return {Array} An interval
  */
-export var getValidInterval = (_ref) => {
-	var _ref2 = _slicedToArray(_ref, 2),
-		min = _ref2[0],
-		max = _ref2[1];
-	var validMin = min,
-		validMax = max;
+export const getValidInterval = ([min, max]: [number, number]): [number, number] => {
+	let [validMin, validMax] = [min, max];
 
 	// exchange
 	if (min > max) {
-		validMin = max;
-		validMax = min;
+		[validMin, validMax] = [max, min];
 	}
+
 	return [validMin, validMax];
 };
 
@@ -100,25 +35,39 @@ export var getValidInterval = (_ref) => {
  * @param  correctionFactor A correction factor
  * @return The step which is easy to understand between two ticks
  */
-export var getAdaptiveStep = (roughStep, allowDecimals, correctionFactor) => {
+export const getAdaptiveStep = (
+	roughStep: Decimal,
+	allowDecimals: boolean,
+	correctionFactor: number,
+) => {
 	if (roughStep.lte(0)) {
 		return new Decimal(0);
 	}
-	var digitCount = getDigitCount(roughStep.toNumber());
+
+	const digitCount = getDigitCount(roughStep.toNumber());
 	// The ratio between the rough step and the smallest number which has a bigger
 	// order of magnitudes than the rough step
-	var digitCountValue = new Decimal(10).pow(digitCount);
-	var stepRatio = roughStep.div(digitCountValue);
+	const digitCountValue = new Decimal(10).pow(digitCount);
+	const stepRatio = roughStep.div(digitCountValue);
 	// When an integer and a float multiplied, the accuracy of result may be wrong
-	var stepRatioScale = digitCount !== 1 ? 0.05 : 0.1;
-	var amendStepRatio = new Decimal(Math.ceil(stepRatio.div(stepRatioScale).toNumber()))
+	const stepRatioScale = digitCount !== 1 ? 0.05 : 0.1;
+	const amendStepRatio = new Decimal(Math.ceil(stepRatio.div(stepRatioScale).toNumber()))
 		.add(correctionFactor)
 		.mul(stepRatioScale);
-	var formatStep = amendStepRatio.mul(digitCountValue);
+
+	const formatStep = amendStepRatio.mul(digitCountValue);
+
 	return allowDecimals
 		? new Decimal(formatStep.toNumber())
 		: new Decimal(Math.ceil(formatStep.toNumber()));
 };
+
+type StepFunction = (
+	roughStep: Decimal,
+	allowDecimals: boolean,
+	correctionFactor: number,
+) => Decimal;
+
 /**
  * The snap125 step algorithm snaps to nice numbers (1, 2, 2.5, 5) at each
  * order of magnitude, producing human-friendly tick intervals like
@@ -131,21 +80,26 @@ export var getAdaptiveStep = (roughStep, allowDecimals, correctionFactor) => {
  * @param  correctionFactor A correction factor
  * @return The step which is easy to understand between two ticks
  */
-export var getSnap125Step = (roughStep, allowDecimals, correctionFactor) => {
-	var _NICE_STEPS$niceIdx;
+export const getSnap125Step: StepFunction = (
+	roughStep: Decimal,
+	allowDecimals: boolean,
+	correctionFactor: number,
+) => {
 	if (roughStep.lte(0)) {
 		return new Decimal(0);
 	}
-	var NICE_STEPS = [1, 2, 2.5, 5];
-	var roughNum = roughStep.toNumber();
-	var exponent = Math.floor(new Decimal(roughNum).abs().log(10).toNumber());
-	var magnitude = new Decimal(10).pow(exponent);
+
+	const NICE_STEPS = [1, 2, 2.5, 5];
+
+	const roughNum = roughStep.toNumber();
+	const exponent = Math.floor(new Decimal(roughNum).abs().log(10).toNumber());
+	let magnitude = new Decimal(10).pow(exponent);
 
 	// normalized is in the range [1, 10)
-	var normalized = roughStep.div(magnitude).toNumber();
+	const normalized = roughStep.div(magnitude).toNumber();
 
 	// Find the smallest nice step >= normalized (ceiling)
-	var niceIdx = NICE_STEPS.findIndex((s) => s >= normalized - 1e-10);
+	let niceIdx = NICE_STEPS.findIndex((s) => s >= normalized - 1e-10);
 	if (niceIdx === -1) {
 		// normalized > 5 (e.g. 7.3), move to next order of magnitude
 		magnitude = magnitude.mul(10);
@@ -155,15 +109,14 @@ export var getSnap125Step = (roughStep, allowDecimals, correctionFactor) => {
 	// Apply correction factor by stepping through the nice number sequence
 	niceIdx += correctionFactor;
 	if (niceIdx >= NICE_STEPS.length) {
-		var extraMag = Math.floor(niceIdx / NICE_STEPS.length);
+		const extraMag = Math.floor(niceIdx / NICE_STEPS.length);
 		niceIdx %= NICE_STEPS.length;
 		magnitude = magnitude.mul(new Decimal(10).pow(extraMag));
 	}
-	var niceStep =
-		(_NICE_STEPS$niceIdx = NICE_STEPS[niceIdx]) !== null && _NICE_STEPS$niceIdx !== void 0
-			? _NICE_STEPS$niceIdx
-			: 1;
-	var formatStep = new Decimal(niceStep).mul(magnitude);
+
+	const niceStep = NICE_STEPS[niceIdx] ?? 1;
+	const formatStep = new Decimal(niceStep).mul(magnitude);
+
 	return allowDecimals ? formatStep : new Decimal(Math.ceil(formatStep.toNumber()));
 };
 
@@ -175,15 +128,22 @@ export var getSnap125Step = (roughStep, allowDecimals, correctionFactor) => {
  * @param  allowDecimals Allow the ticks to be decimals or not
  * @return array of ticks
  */
-export var getTickOfSingleValue = (value, tickCount, allowDecimals) => {
-	var step = new Decimal(1);
+export const getTickOfSingleValue = (
+	value: number,
+	tickCount: number,
+	allowDecimals: boolean,
+): Array<number> => {
+	let step: Decimal = new Decimal(1);
 	// calculate the middle value of ticks
-	var middle = new Decimal(value);
+	let middle = new Decimal(value);
+
 	if (!middle.isint() && allowDecimals) {
-		var absVal = Math.abs(value);
+		const absVal = Math.abs(value);
+
 		if (absVal < 1) {
 			// The step should be a float number when the difference is smaller than 1
 			step = new Decimal(10).pow(getDigitCount(value) - 1);
+
 			middle = new Decimal(Math.floor(middle.div(step).toNumber())).mul(step);
 		} else if (absVal > 1) {
 			// Return the maximum integer which is smaller than 'value' when 'value' is greater than 1
@@ -194,11 +154,14 @@ export var getTickOfSingleValue = (value, tickCount, allowDecimals) => {
 	} else if (!allowDecimals) {
 		middle = new Decimal(Math.floor(value));
 	}
-	var middleIndex = Math.floor((tickCount - 1) / 2);
-	var ticks = [];
-	for (var i = 0; i < tickCount; i++) {
+
+	const middleIndex = Math.floor((tickCount - 1) / 2);
+	const ticks: Array<number> = [];
+
+	for (let i = 0; i < tickCount; i++) {
 		ticks.push(middle.add(new Decimal(i - middleIndex).mul(step)).toNumber());
 	}
+
 	return ticks;
 };
 
@@ -212,9 +175,18 @@ export var getTickOfSingleValue = (value, tickCount, allowDecimals) => {
  * @param  correctionFactor A correction factor
  * @return The step, minimum value of ticks, maximum value of ticks
  */
-var _calculateStep = function calculateStep(min, max, tickCount, allowDecimals) {
-	var correctionFactor = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0;
-	var stepFn = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : getAdaptiveStep;
+export const calculateStep = (
+	min: number,
+	max: number,
+	tickCount: number,
+	allowDecimals: boolean,
+	correctionFactor: number = 0,
+	stepFn: StepFunction = getAdaptiveStep,
+): {
+	step: Decimal;
+	tickMin: Decimal;
+	tickMax: Decimal;
+} => {
 	// dirty hack (for recharts' test)
 	if (!Number.isFinite((max - min) / (tickCount - 1))) {
 		return {
@@ -225,10 +197,14 @@ var _calculateStep = function calculateStep(min, max, tickCount, allowDecimals)
 	}
 
 	// The step which is easy to understand between two ticks
-	var step = stepFn(new Decimal(max).sub(min).div(tickCount - 1), allowDecimals, correctionFactor);
+	const step = stepFn(
+		new Decimal(max).sub(min).div(tickCount - 1),
+		allowDecimals,
+		correctionFactor,
+	);
 
 	// A medial value of ticks
-	var middle;
+	let middle;
 
 	// When 0 is inside the interval, 0 should be a tick
 	if (min <= 0 && max >= 0) {
@@ -239,18 +215,21 @@ var _calculateStep = function calculateStep(min, max, tickCount, allowDecimals)
 		// minus modulo value
 		middle = middle.sub(new Decimal(middle).mod(step));
 	}
-	var belowCount = Math.ceil(middle.sub(min).div(step).toNumber());
-	var upCount = Math.ceil(new Decimal(max).sub(middle).div(step).toNumber());
-	var scaleCount = belowCount + upCount + 1;
+
+	let belowCount = Math.ceil(middle.sub(min).div(step).toNumber());
+	let upCount = Math.ceil(new Decimal(max).sub(middle).div(step).toNumber());
+	const scaleCount = belowCount + upCount + 1;
+
 	if (scaleCount > tickCount) {
 		// When more ticks need to cover the interval, step should be bigger.
-		return _calculateStep(min, max, tickCount, allowDecimals, correctionFactor + 1, stepFn);
+		return calculateStep(min, max, tickCount, allowDecimals, correctionFactor + 1, stepFn);
 	}
 	if (scaleCount < tickCount) {
 		// When less ticks can cover the interval, we should add some additional ticks
 		upCount = max > 0 ? upCount + (tickCount - scaleCount) : upCount;
 		belowCount = max > 0 ? belowCount : belowCount + (tickCount - scaleCount);
 	}
+
 	return {
 		step,
 		tickMin: middle.sub(new Decimal(belowCount).mul(step)),
@@ -268,38 +247,36 @@ var _calculateStep = function calculateStep(min, max, tickCount, allowDecimals)
  * @param niceTicksMode The algorithm to use for calculating nice ticks.
  * @return array of ticks
  */
-export { _calculateStep as calculateStep };
-export var getNiceTickValues = function getNiceTickValues(_ref3) {
-	var _ref4 = _slicedToArray(_ref3, 2),
-		min = _ref4[0],
-		max = _ref4[1];
-	var tickCount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 6;
-	var allowDecimals = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-	var niceTicksMode = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'auto';
+export const getNiceTickValues = (
+	[min, max]: NumberDomain,
+	tickCount = 6,
+	allowDecimals = true,
+	niceTicksMode: NiceTicksAlgorithm = 'auto',
+): number[] => {
 	// More than two ticks should be return
-	var count = Math.max(tickCount, 2);
-	var _getValidInterval = getValidInterval([min, max]),
-		_getValidInterval2 = _slicedToArray(_getValidInterval, 2),
-		cormin = _getValidInterval2[0],
-		cormax = _getValidInterval2[1];
+	const count = Math.max(tickCount, 2);
+	const [cormin, cormax] = getValidInterval([min, max]);
+
 	if (cormin === -Infinity || cormax === Infinity) {
-		var _values =
+		const values: Array<number> =
 			cormax === Infinity
 				? [cormin, ...Array(tickCount - 1).fill(Infinity)]
 				: [...Array(tickCount - 1).fill(-Infinity), cormax];
-		return min > max ? _values.reverse() : _values;
+
+		return min > max ? values.reverse() : values;
 	}
+
 	if (cormin === cormax) {
 		return getTickOfSingleValue(cormin, tickCount, allowDecimals);
 	}
-	var stepFn = niceTicksMode === 'snap125' ? getSnap125Step : getAdaptiveStep;
+
+	const stepFn = niceTicksMode === 'snap125' ? getSnap125Step : getAdaptiveStep;
 
 	// Get the step between two ticks
-	var _calculateStep2 = _calculateStep(cormin, cormax, count, allowDecimals, 0, stepFn),
-		step = _calculateStep2.step,
-		tickMin = _calculateStep2.tickMin,
-		tickMax = _calculateStep2.tickMax;
-	var values = rangeStep(tickMin, tickMax.add(new Decimal(0.1).mul(step)), step);
+	const { step, tickMin, tickMax } = calculateStep(cormin, cormax, count, allowDecimals, 0, stepFn);
+
+	const values = rangeStep(tickMin, tickMax.add(new Decimal(0.1).mul(step)), step);
+
 	return min > max ? values.reverse() : values;
 };
 
@@ -313,27 +290,28 @@ export var getNiceTickValues = function getNiceTickValues(_ref3) {
  * @param niceTicksMode          The algorithm to use for calculating nice ticks. See {@link NiceTicksAlgorithm}.
  * @return array of ticks
  */
-export var getTickValuesFixedDomain = function getTickValuesFixedDomain(_ref5, tickCount) {
-	var _ref6 = _slicedToArray(_ref5, 2),
-		min = _ref6[0],
-		max = _ref6[1];
-	var allowDecimals = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-	var niceTicksMode = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'auto';
+export const getTickValuesFixedDomain = (
+	[min, max]: NumberDomain,
+	tickCount: number,
+	allowDecimals = true,
+	niceTicksMode: NiceTicksAlgorithm = 'auto',
+) => {
 	// More than two ticks should be return
-	var _getValidInterval3 = getValidInterval([min, max]),
-		_getValidInterval4 = _slicedToArray(_getValidInterval3, 2),
-		cormin = _getValidInterval4[0],
-		cormax = _getValidInterval4[1];
+	const [cormin, cormax] = getValidInterval([min, max]);
+
 	if (cormin === -Infinity || cormax === Infinity) {
 		return [min, max];
 	}
+
 	if (cormin === cormax) {
 		return [cormin];
 	}
-	var stepFn = niceTicksMode === 'snap125' ? getSnap125Step : getAdaptiveStep;
-	var count = Math.max(tickCount, 2);
-	var step = stepFn(new Decimal(cormax).sub(cormin).div(count - 1), allowDecimals, 0);
-	var values = [...rangeStep(new Decimal(cormin), new Decimal(cormax), step), cormax];
+
+	const stepFn = niceTicksMode === 'snap125' ? getSnap125Step : getAdaptiveStep;
+	const count = Math.max(tickCount, 2);
+	const step = stepFn(new Decimal(cormax).sub(cormin).div(count - 1), allowDecimals, 0);
+	let values = [...rangeStep(new Decimal(cormin), new Decimal(cormax), step), cormax];
+
 	if (allowDecimals === false) {
 		/*
 		 * allowDecimals is false means that we want to have integer ticks.
@@ -345,10 +323,11 @@ export var getTickValuesFixedDomain = function getTickValuesFixedDomain(_ref5, t
 		 * with a duplicate trailing tick. Remove it.
 		 */
 		values = values.map((value) => Math.round(value));
-		var last = values.length - 1;
+		const last = values.length - 1;
 		if (last > 0 && values[last] === values[last - 1]) {
 			values = values.slice(0, last);
 		}
 	}
+
 	return min > max ? values.reverse() : values;
 };

package/src/util/scale/index.ts

@@ -0,0 +1,2 @@
+// Adapted from recharts@3.9.2, commit b3451050c027a23957ffa50a2665c9119df21e47.
+export { getNiceTickValues, getTickValuesFixedDomain } from './getNiceTickValues';

package/src/util/scale/util/{arithmetic.js → arithmetic.ts}

@@ -1,5 +1,4 @@
-// Vendored verbatim from recharts@3.9.2 es6/util/scale/util/arithmetic.js (framework-agnostic).
-// Do not edit — update by re-vendoring when the recharts devDependency moves.
+// Adapted from recharts@3.9.2, commit b3451050c027a23957ffa50a2665c9119df21e47.
 /**
  * @fileOverview Some common arithmetic methods
  * @author xile611
@@ -16,13 +15,15 @@ import Decimal from 'decimal.js-light';
  * @param  {Number} value The number
  * @return {Integer}      Digit count
  */
-function getDigitCount(value) {
-	var result;
+function getDigitCount(value: number) {
+	let result;
+
 	if (value === 0) {
 		result = 1;
 	} else {
 		result = Math.floor(new Decimal(value).abs().log(10).toNumber()) + 1;
 	}
+
 	return result;
 }
 
@@ -35,17 +36,20 @@ function getDigitCount(value) {
  * @param  {Decimal} step  Step size
  * @return {Array}         Array of numbers
  */
-function rangeStep(start, end, step) {
-	var num = new Decimal(start);
-	var i = 0;
-	var result = [];
+function rangeStep(start: Decimal, end: Decimal, step: Decimal): Array<number> {
+	let num = new Decimal(start);
+	let i = 0;
+	const result: Array<number> = [];
 
 	// magic number to prevent infinite loop
 	while (num.lt(end) && i < 100000) {
 		result.push(num.toNumber());
+
 		num = num.add(step);
 		i++;
 	}
+
 	return result;
 }
+
 export { rangeStep, getDigitCount };

package/src/util/stacks/getStackSeriesIdentifier.ts

@@ -0,0 +1,21 @@
+// Adapted from recharts@3.9.2, commit b3451050c027a23957ffa50a2665c9119df21e47.
+import { StackSeriesIdentifier } from './stackTypes';
+import { MaybeStackedGraphicalItem } from '../../state/types/StackedGraphicalItem';
+
+export function getStackSeriesIdentifier(
+	graphicalItem: MaybeStackedGraphicalItem,
+): StackSeriesIdentifier;
+export function getStackSeriesIdentifier(graphicalItem: undefined): undefined;
+export function getStackSeriesIdentifier(
+	graphicalItem: MaybeStackedGraphicalItem | undefined,
+): StackSeriesIdentifier | undefined;
+/**
+ * Returns identifier for stack series which is one individual graphical item in the stack.
+ * @param graphicalItem - The graphical item representing the series in the stack.
+ * @return The identifier for the series in the stack
+ */
+export function getStackSeriesIdentifier(
+	graphicalItem: MaybeStackedGraphicalItem | undefined,
+): StackSeriesIdentifier | undefined {
+	return graphicalItem?.id;
+}

package/src/util/stacks/stackTypes.ts

@@ -0,0 +1,58 @@
+// Adapted from recharts@3.9.2, commit b3451050c027a23957ffa50a2665c9119df21e47.
+import { Series } from 'victory-vendor/d3-shape';
+import { StackId } from '../ChartUtils';
+import { GraphicalItemId } from '../../state/graphicalItemsSlice';
+import { MaybeStackedGraphicalItem } from '../../state/types/StackedGraphicalItem';
+
+/*
+ * So chart stacks come in layers:
+ *
+ * - The top layer is the stack itself, which is a collection of series. The stack is identified by the `StackId` of the stack.
+ *   The StackId is defined by the `stackId` prop of the graphical items.
+ *   A typical stacked chart will have a single stack, but Recharts allows for multiple stacks.
+ *
+ * - One stack will have multiple series, which are the individual data series that make up the stack.
+ *   This is the second layer of the stack.
+ *   One series is represented by a single `GraphicalItem` in the stack.
+ *   This function returns the identifier for the series.
+ *
+ * - Finally the third layer is the data point itself, which is a tuple of two numbers.
+ */
+
+/**
+ * Collection of all stacks in the chart.
+ * A simple stacked chart will have a single stack. Recharts allows for multiple stacks.
+ * In a chart without stacks, this will be an empty object.
+ */
+export type AllStackGroups = Record<StackId, StackGroup>;
+
+/**
+ * One stack group is a collection of series that are stacked together.
+ * The stack series and graphical items are joined by the StackSeriesIdentifier.
+ */
+export type StackGroup = {
+	readonly stackedData: ReadonlyArray<StackSeries>;
+	readonly graphicalItems: ReadonlyArray<MaybeStackedGraphicalItem>;
+};
+
+/**
+ * Stack series is a collection of data points. This represents one individual graphical item in the stack.
+ * There are presumably other series in the stack, which are represented by other `StackSeries` objects
+ * that this object will not know about.
+ * The coordinates of the data points in the series already include the baseline of the previous series in the stack.
+ */
+export type StackSeries = Series<StackDataPoint, StackSeriesIdentifier>;
+
+/**
+ * Stack data point is a tuple of two numbers:
+ * first, where the previous stack series ended,
+ * and second, where the current stack series ends.
+ * This allows for setting the baseline of the next series in the stack.
+ */
+export type StackDataPoint = [number, number];
+
+/**
+ * Identifier for a series in the stack.
+ * Used to join the stack series with the graphical items in the stack.
+ */
+export type StackSeriesIdentifier = GraphicalItemId;