can be assigned an empty object {},
+ * it means K is optional (or potentially missing), so we keep K; otherwise, we discard it (never).
+ * [keyof T] at the end creates a union of the kept keys.
+ */
+
+/**
+ * Helper type to ensure keys of D exist in T.
+ * For each key K in D, if K is also a key of T, keep the type D[K].
+ * If K is NOT a key of T, map it to type `never`.
+ * An object cannot have a property of type `never`, effectively disallowing extra keys.
+ */
+
+/**
+ * This type will take a source type `Props` and a default type `Defaults` and will return a new type
+ * where all properties that are optional in `Props` but required in `Defaults` are made required in the result.
+ * Properties that are required in `Props` and optional in `Defaults` will remain required.
+ * Properties that are optional in both `Props` and `Defaults` will remain optional.
+ *
+ * This is useful for creating a type that represents the resolved props of a component with default props.
+ */
Index: node_modules/recharts/es6/util/round.js
===================================================================
--- node_modules/recharts/es6/util/round.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
+++ node_modules/recharts/es6/util/round.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
@@ -0,0 +1,32 @@
+// if you go lower than 3, wild wild things happen during rendering
+var defaultRoundPrecision = 4;
+export function round(num) {
+ var roundPrecision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultRoundPrecision;
+ var factor = 10 ** roundPrecision;
+ var rounded = Math.round(num * factor) / factor;
+ if (Object.is(rounded, -0)) {
+ return 0;
+ }
+ return rounded;
+}
+
+/**
+ * This function will accept a string template literal and for each
+ * variable placeholder, it will round the value to avoid long float numbers in
+ * the SVG path which might cause rendering issues in some browsers.
+ */
+export function roundTemplateLiteral(strings) {
+ for (var _len = arguments.length, values = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ values[_key - 1] = arguments[_key];
+ }
+ return strings.reduce((result, string, i) => {
+ var value = values[i - 1];
+ if (typeof value === 'string') {
+ return result + value + string;
+ }
+ if (value !== undefined) {
+ return result + round(value) + string;
+ }
+ return result + string;
+ }, '');
+}
Index: node_modules/recharts/es6/util/scale/CartesianScaleHelper.js
===================================================================
--- node_modules/recharts/es6/util/scale/CartesianScaleHelper.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
+++ node_modules/recharts/es6/util/scale/CartesianScaleHelper.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
@@ -0,0 +1,66 @@
+/**
+ * Groups X and Y scale functions together and provides helper methods.
+ */
+export class CartesianScaleHelperImpl {
+ constructor(_ref) {
+ var {
+ x,
+ y
+ } = _ref;
+ this.xAxisScale = x;
+ this.yAxisScale = y;
+ }
+ map(value, _ref2) {
+ var _this$xAxisScale$map, _this$yAxisScale$map;
+ var {
+ position
+ } = _ref2;
+ return {
+ x: (_this$xAxisScale$map = this.xAxisScale.map(value.x, {
+ position
+ })) !== null && _this$xAxisScale$map !== void 0 ? _this$xAxisScale$map : 0,
+ y: (_this$yAxisScale$map = this.yAxisScale.map(value.y, {
+ position
+ })) !== null && _this$yAxisScale$map !== void 0 ? _this$yAxisScale$map : 0
+ };
+ }
+ mapWithFallback(value, _ref3) {
+ var _this$xAxisScale$map2, _this$yAxisScale$map2;
+ var {
+ position,
+ fallback
+ } = _ref3;
+ var fallbackY, fallbackX;
+ if (fallback === 'rangeMin') {
+ fallbackY = this.yAxisScale.rangeMin();
+ } else if (fallback === 'rangeMax') {
+ fallbackY = this.yAxisScale.rangeMax();
+ } else {
+ fallbackY = 0;
+ }
+ if (fallback === 'rangeMin') {
+ fallbackX = this.xAxisScale.rangeMin();
+ } else if (fallback === 'rangeMax') {
+ fallbackX = this.xAxisScale.rangeMax();
+ } else {
+ fallbackX = 0;
+ }
+ return {
+ x: (_this$xAxisScale$map2 = this.xAxisScale.map(value.x, {
+ position
+ })) !== null && _this$xAxisScale$map2 !== void 0 ? _this$xAxisScale$map2 : fallbackX,
+ y: (_this$yAxisScale$map2 = this.yAxisScale.map(value.y, {
+ position
+ })) !== null && _this$yAxisScale$map2 !== void 0 ? _this$yAxisScale$map2 : fallbackY
+ };
+ }
+ isInRange(_ref4) {
+ var {
+ x,
+ y
+ } = _ref4;
+ var xInRange = x == null || this.xAxisScale.isInRange(x);
+ var yInRange = y == null || this.yAxisScale.isInRange(y);
+ return xInRange && yInRange;
+ }
+}
Index: node_modules/recharts/es6/util/scale/CustomScaleDefinition.js
===================================================================
--- node_modules/recharts/es6/util/scale/CustomScaleDefinition.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
+++ node_modules/recharts/es6/util/scale/CustomScaleDefinition.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
@@ -0,0 +1,1 @@
+export {};
Index: node_modules/recharts/es6/util/scale/RechartsScale.js
===================================================================
--- node_modules/recharts/es6/util/scale/RechartsScale.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
+++ node_modules/recharts/es6/util/scale/RechartsScale.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
@@ -0,0 +1,100 @@
+import * as d3Scales from 'victory-vendor/d3-scale';
+import { upperFirst } from '../DataUtils';
+
+/**
+ * This is internal representation of scale used in Recharts.
+ * Users will provide CustomScaleDefinition or a string, which we will parse into RechartsScale.
+ * Most importantly, RechartsScale is fully immutable - there are no setters that mutate the scale in place.
+ * This is important for React integration - if the scale changes, we want to trigger re-renders.
+ * Mutating the scale in place would not trigger re-renders, leading to stale UI.
+ */
+
+/**
+ * Position within a band for banded scales.
+ * In scales that are not banded, this parameter is ignored.
+ *
+ * @inline
+ */
+
+function getD3ScaleFromType(realScaleType) {
+ if (realScaleType in d3Scales) {
+ // @ts-expect-error we should do better type verification here
+ return d3Scales[realScaleType]();
+ }
+ var name = "scale".concat(upperFirst(realScaleType));
+ if (name in d3Scales) {
+ // @ts-expect-error we should do better type verification here
+ return d3Scales[name]();
+ }
+ return undefined;
+}
+export function d3ScaleToRechartsScale(d3Scale) {
+ var ticksFn = d3Scale.ticks;
+ var bandwidthFn = d3Scale.bandwidth;
+ var d3Range = d3Scale.range();
+ var range = [Math.min(...d3Range), Math.max(...d3Range)];
+ return {
+ domain: () => d3Scale.domain(),
+ range: function (_range) {
+ function range() {
+ return _range.apply(this, arguments);
+ }
+ range.toString = function () {
+ return _range.toString();
+ };
+ return range;
+ }(() => range),
+ rangeMin: () => range[0],
+ rangeMax: () => range[1],
+ isInRange(value) {
+ var first = range[0];
+ var last = range[1];
+ return first <= last ? value >= first && value <= last : value >= last && value <= first;
+ },
+ bandwidth: bandwidthFn ? () => bandwidthFn.call(d3Scale) : undefined,
+ ticks: ticksFn ? count => ticksFn.call(d3Scale, count) : undefined,
+ map: (input, options) => {
+ var baseValue = d3Scale(input);
+ if (baseValue == null) {
+ return undefined;
+ }
+ if (d3Scale.bandwidth && options !== null && options !== void 0 && options.position) {
+ var bandWidth = d3Scale.bandwidth();
+ switch (options.position) {
+ case 'middle':
+ baseValue += bandWidth / 2;
+ break;
+ case 'end':
+ baseValue += bandWidth;
+ break;
+ default:
+ // 'start' requires no adjustment
+ break;
+ }
+ }
+ return baseValue;
+ }
+ };
+}
+
+/**
+ * Converts external scale definition into internal RechartsScale definition.
+ * @param scale custom function scale - if you have the string, use `combineRealScaleType` first
+ * @param axisDomain
+ * @param axisRange
+ */
+
+export function rechartsScaleFactory(scale, axisDomain, axisRange) {
+ if (typeof scale === 'function') {
+ return d3ScaleToRechartsScale(scale.copy().domain(axisDomain).range(axisRange));
+ }
+ if (scale == null) {
+ return undefined;
+ }
+ var d3ScaleFunction = getD3ScaleFromType(scale);
+ if (d3ScaleFunction == null) {
+ return undefined;
+ }
+ d3ScaleFunction.domain(axisDomain).range(axisRange);
+ return d3ScaleToRechartsScale(d3ScaleFunction);
+}
Index: node_modules/recharts/es6/util/scale/getNiceTickValues.js
===================================================================
--- node_modules/recharts/es6/util/scale/getNiceTickValues.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
+++ node_modules/recharts/es6/util/scale/getNiceTickValues.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
@@ -0,0 +1,208 @@
+/**
+ * @fileOverview calculate tick values of scale
+ * @author xile611, arcthur
+ * @date 2015-09-17
+ */
+import Decimal from 'decimal.js-light';
+import { getDigitCount, rangeStep } from './util/arithmetic';
+/**
+ * Calculate a interval of a minimum value and a maximum value
+ *
+ * @param {Number} min The minimum value
+ * @param {Number} max The maximum value
+ * @return {Array} An interval
+ */
+export var getValidInterval = _ref => {
+ var [min, max] = _ref;
+ var [validMin, validMax] = [min, max];
+
+ // exchange
+ if (min > max) {
+ [validMin, validMax] = [max, min];
+ }
+ return [validMin, validMax];
+};
+
+/**
+ * Calculate the step which is easy to understand between ticks, like 10, 20, 25
+ *
+ * @param roughStep The rough step calculated by dividing the difference by the tickCount
+ * @param allowDecimals Allow the ticks to be decimals or not
+ * @param correctionFactor A correction factor
+ * @return The step which is easy to understand between two ticks
+ */
+export var getFormatStep = (roughStep, allowDecimals, correctionFactor) => {
+ if (roughStep.lte(0)) {
+ return new Decimal(0);
+ }
+ var 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);
+ // 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())).add(correctionFactor).mul(stepRatioScale);
+ var formatStep = amendStepRatio.mul(digitCountValue);
+ return allowDecimals ? new Decimal(formatStep.toNumber()) : new Decimal(Math.ceil(formatStep.toNumber()));
+};
+
+/**
+ * calculate the ticks when the minimum value equals to the maximum value
+ *
+ * @param value The minimum value which is also the maximum value
+ * @param tickCount The count of ticks
+ * @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);
+ // calculate the middle value of ticks
+ var middle = new Decimal(value);
+ if (!middle.isint() && allowDecimals) {
+ var 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
+ middle = new Decimal(Math.floor(value));
+ }
+ } else if (value === 0) {
+ middle = new Decimal(Math.floor((tickCount - 1) / 2));
+ } 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++) {
+ ticks.push(middle.add(new Decimal(i - middleIndex).mul(step)).toNumber());
+ }
+ return ticks;
+};
+
+/**
+ * Calculate the step
+ *
+ * @param min The minimum value of an interval
+ * @param max The maximum value of an interval
+ * @param tickCount The count of ticks
+ * @param allowDecimals Allow the ticks to be decimals or not
+ * @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;
+ // dirty hack (for recharts' test)
+ if (!Number.isFinite((max - min) / (tickCount - 1))) {
+ return {
+ step: new Decimal(0),
+ tickMin: new Decimal(0),
+ tickMax: new Decimal(0)
+ };
+ }
+
+ // The step which is easy to understand between two ticks
+ var step = getFormatStep(new Decimal(max).sub(min).div(tickCount - 1), allowDecimals, correctionFactor);
+
+ // A medial value of ticks
+ var middle;
+
+ // When 0 is inside the interval, 0 should be a tick
+ if (min <= 0 && max >= 0) {
+ middle = new Decimal(0);
+ } else {
+ // calculate the middle value
+ middle = new Decimal(min).add(max).div(2);
+ // 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;
+ if (scaleCount > tickCount) {
+ // When more ticks need to cover the interval, step should be bigger.
+ return _calculateStep(min, max, tickCount, allowDecimals, correctionFactor + 1);
+ }
+ 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)),
+ tickMax: middle.add(new Decimal(upCount).mul(step))
+ };
+};
+
+/**
+ * Calculate the ticks of an interval. Ticks can appear outside the interval
+ * if it makes them more rounded and nice.
+ *
+ * @param tuple of [min,max] min: The minimum value, max: The maximum value
+ * @param tickCount The count of ticks
+ * @param allowDecimals Allow the ticks to be decimals or not
+ * @return array of ticks
+ */
+export { _calculateStep as calculateStep };
+export var getNiceTickValues = function getNiceTickValues(_ref2) {
+ var [min, max] = _ref2;
+ var tickCount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 6;
+ var allowDecimals = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+ // More than two ticks should be return
+ var count = Math.max(tickCount, 2);
+ var [cormin, cormax] = getValidInterval([min, max]);
+ if (cormin === -Infinity || cormax === Infinity) {
+ var _values = cormax === Infinity ? [cormin, ...Array(tickCount - 1).fill(Infinity)] : [...Array(tickCount - 1).fill(-Infinity), cormax];
+ return min > max ? _values.reverse() : _values;
+ }
+ if (cormin === cormax) {
+ return getTickOfSingleValue(cormin, tickCount, allowDecimals);
+ }
+
+ // Get the step between two ticks
+ var {
+ step,
+ tickMin,
+ tickMax
+ } = _calculateStep(cormin, cormax, count, allowDecimals, 0);
+ var values = rangeStep(tickMin, tickMax.add(new Decimal(0.1).mul(step)), step);
+ return min > max ? values.reverse() : values;
+};
+
+/**
+ * Calculate the ticks of an interval.
+ * Ticks will be constrained to the interval [min, max] even if it makes them less rounded and nice.
+ *
+ * @param tuple of [min,max] min: The minimum value, max: The maximum value
+ * @param tickCount The count of ticks. This function may return less than tickCount ticks if the interval is too small.
+ * @param allowDecimals Allow the ticks to be decimals or not
+ * @return array of ticks
+ */
+export var getTickValuesFixedDomain = function getTickValuesFixedDomain(_ref3, tickCount) {
+ var [min, max] = _ref3;
+ var allowDecimals = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+ // More than two ticks should be return
+ var [cormin, cormax] = getValidInterval([min, max]);
+ if (cormin === -Infinity || cormax === Infinity) {
+ return [min, max];
+ }
+ if (cormin === cormax) {
+ return [cormin];
+ }
+ var count = Math.max(tickCount, 2);
+ var step = getFormatStep(new Decimal(cormax).sub(cormin).div(count - 1), allowDecimals, 0);
+ var values = [...rangeStep(new Decimal(cormin), new Decimal(cormax), step), cormax];
+ if (allowDecimals === false) {
+ /*
+ * allowDecimals is false means that we want to have integer ticks.
+ * The step is guaranteed to be an integer in the code above which is great start
+ * but when the first step is not an integer, it will start stepping from a decimal value anyway.
+ * So we need to round all the values to integers after the fact.
+ */
+ values = values.map(value => Math.round(value));
+ }
+ return min > max ? values.reverse() : values;
+};
Index: node_modules/recharts/es6/util/scale/index.js
===================================================================
--- node_modules/recharts/es6/util/scale/index.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
+++ node_modules/recharts/es6/util/scale/index.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
@@ -0,0 +1,1 @@
+export { getNiceTickValues, getTickValuesFixedDomain } from './getNiceTickValues';
Index: node_modules/recharts/es6/util/scale/util/arithmetic.js
===================================================================
--- node_modules/recharts/es6/util/scale/util/arithmetic.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
+++ node_modules/recharts/es6/util/scale/util/arithmetic.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
@@ -0,0 +1,49 @@
+/**
+ * @fileOverview Some common arithmetic methods
+ * @author xile611
+ * @date 2015-09-17
+ */
+import Decimal from 'decimal.js-light';
+
+/**
+ * Get the digit count of a number.
+ * If the absolute value is in the interval [0.1, 1), the result is 0.
+ * If the absolute value is in the interval [0.01, 0.1), the digit count is -1.
+ * If the absolute value is in the interval [0.001, 0.01), the digit count is -2.
+ *
+ * @param {Number} value The number
+ * @return {Integer} Digit count
+ */
+function getDigitCount(value) {
+ var result;
+ if (value === 0) {
+ result = 1;
+ } else {
+ result = Math.floor(new Decimal(value).abs().log(10).toNumber()) + 1;
+ }
+ return result;
+}
+
+/**
+ * Get the data in the interval [start, end) with a fixed step.
+ * Also handles JS calculation precision issues.
+ *
+ * @param {Decimal} start Start point
+ * @param {Decimal} end End point, not included
+ * @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 = [];
+
+ // 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 };
Index: node_modules/recharts/es6/util/stacks/getStackSeriesIdentifier.js
===================================================================
--- node_modules/recharts/es6/util/stacks/getStackSeriesIdentifier.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
+++ node_modules/recharts/es6/util/stacks/getStackSeriesIdentifier.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
@@ -0,0 +1,8 @@
+/**
+ * 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) {
+ return graphicalItem === null || graphicalItem === void 0 ? void 0 : graphicalItem.id;
+}
Index: node_modules/recharts/es6/util/stacks/stackTypes.js
===================================================================
--- node_modules/recharts/es6/util/stacks/stackTypes.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
+++ node_modules/recharts/es6/util/stacks/stackTypes.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
@@ -0,0 +1,1 @@
+export {};
Index: node_modules/recharts/es6/util/svgPropertiesAndEvents.js
===================================================================
--- node_modules/recharts/es6/util/svgPropertiesAndEvents.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
+++ node_modules/recharts/es6/util/svgPropertiesAndEvents.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
@@ -0,0 +1,50 @@
+import { isValidElement } from 'react';
+import { isEventKey } from './excludeEventProps';
+import { isDataAttribute, isSvgElementPropKey } from './svgPropertiesNoEvents';
+/**
+ * Filters an object to only include SVG properties, data attributes, and event handlers.
+ * @param obj - The object to filter.
+ * @returns A new object containing only valid SVG properties, data attributes, and event handlers.
+ */
+export function svgPropertiesAndEvents(obj) {
+ var result = {};
+ // for ... in loop is 10x faster than Object.entries + filter + Object.fromEntries in Chrome
+
+ for (var key in obj) {
+ if (Object.prototype.hasOwnProperty.call(obj, key)) {
+ if (isSvgElementPropKey(key) || isDataAttribute(key) || isEventKey(key)) {
+ result[key] = obj[key];
+ }
+ }
+ }
+ return result;
+}
+
+/**
+ * Function to filter SVG properties from various input types.
+ * The input types can be:
+ * - A record of string keys to any values, in which case it returns a record of only SVG properties
+ * - A React element, in which case it returns the props of the element filtered to only SVG properties
+ * - Anything else, in which case it returns null
+ *
+ * This function has a wide-open return type, because it will read and filter the props of an arbitrary React element.
+ * This can be SVG, HTML, whatnot, with arbitrary values, so we can't type it more specifically.
+ *
+ * If you wish to have a type-safe version, use svgPropertiesNoEvents directly with a typed object.
+ *
+ * @param input - The input to filter, which can be a record, a React element, or other types.
+ * @returns A record of SVG properties if the input is a record or React element, otherwise null.
+ */
+export function svgPropertiesAndEventsFromUnknown(input) {
+ if (input == null) {
+ return null;
+ }
+ if (/*#__PURE__*/isValidElement(input)) {
+ // @ts-expect-error we can't type this better because input can be any React element
+ return svgPropertiesAndEvents(input.props);
+ }
+ if (typeof input === 'object' && !Array.isArray(input)) {
+ return svgPropertiesAndEvents(input);
+ }
+ return null;
+}
Index: node_modules/recharts/es6/util/svgPropertiesNoEvents.js
===================================================================
--- node_modules/recharts/es6/util/svgPropertiesNoEvents.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
+++ node_modules/recharts/es6/util/svgPropertiesNoEvents.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
@@ -0,0 +1,74 @@
+import { isValidElement } from 'react';
+var SVGElementPropKeys = ['aria-activedescendant', 'aria-atomic', 'aria-autocomplete', 'aria-busy', 'aria-checked', 'aria-colcount', 'aria-colindex', 'aria-colspan', 'aria-controls', 'aria-current', 'aria-describedby', 'aria-details', 'aria-disabled', 'aria-errormessage', 'aria-expanded', 'aria-flowto', 'aria-haspopup', 'aria-hidden', 'aria-invalid', 'aria-keyshortcuts', 'aria-label', 'aria-labelledby', 'aria-level', 'aria-live', 'aria-modal', 'aria-multiline', 'aria-multiselectable', 'aria-orientation', 'aria-owns', 'aria-placeholder', 'aria-posinset', 'aria-pressed', 'aria-readonly', 'aria-relevant', 'aria-required', 'aria-roledescription', 'aria-rowcount', 'aria-rowindex', 'aria-rowspan', 'aria-selected', 'aria-setsize', 'aria-sort', 'aria-valuemax', 'aria-valuemin', 'aria-valuenow', 'aria-valuetext', 'className', 'color', 'height', 'id', 'lang', 'max', 'media', 'method', 'min', 'name', 'style',
+/*
+ * removed 'type' SVGElementPropKey because we do not currently use any SVG elements
+ * that can use it, and it conflicts with the recharts prop 'type'
+ * https://github.com/recharts/recharts/pull/3327
+ * https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/type
+ */
+// 'type',
+'target', 'width', 'role', 'tabIndex', 'accentHeight', 'accumulate', 'additive', 'alignmentBaseline', 'allowReorder', 'alphabetic', 'amplitude', 'arabicForm', 'ascent', 'attributeName', 'attributeType', 'autoReverse', 'azimuth', 'baseFrequency', 'baselineShift', 'baseProfile', 'bbox', 'begin', 'bias', 'by', 'calcMode', 'capHeight', 'clip', 'clipPath', 'clipPathUnits', 'clipRule', 'colorInterpolation', 'colorInterpolationFilters', 'colorProfile', 'colorRendering', 'contentScriptType', 'contentStyleType', 'cursor', 'cx', 'cy', 'd', 'decelerate', 'descent', 'diffuseConstant', 'direction', 'display', 'divisor', 'dominantBaseline', 'dur', 'dx', 'dy', 'edgeMode', 'elevation', 'enableBackground', 'end', 'exponent', 'externalResourcesRequired', 'fill', 'fillOpacity', 'fillRule', 'filter', 'filterRes', 'filterUnits', 'floodColor', 'floodOpacity', 'focusable', 'fontFamily', 'fontSize', 'fontSizeAdjust', 'fontStretch', 'fontStyle', 'fontVariant', 'fontWeight', 'format', 'from', 'fx', 'fy', 'g1', 'g2', 'glyphName', 'glyphOrientationHorizontal', 'glyphOrientationVertical', 'glyphRef', 'gradientTransform', 'gradientUnits', 'hanging', 'horizAdvX', 'horizOriginX', 'href', 'ideographic', 'imageRendering', 'in2', 'in', 'intercept', 'k1', 'k2', 'k3', 'k4', 'k', 'kernelMatrix', 'kernelUnitLength', 'kerning', 'keyPoints', 'keySplines', 'keyTimes', 'lengthAdjust', 'letterSpacing', 'lightingColor', 'limitingConeAngle', 'local', 'markerEnd', 'markerHeight', 'markerMid', 'markerStart', 'markerUnits', 'markerWidth', 'mask', 'maskContentUnits', 'maskUnits', 'mathematical', 'mode', 'numOctaves', 'offset', 'opacity', 'operator', 'order', 'orient', 'orientation', 'origin', 'overflow', 'overlinePosition', 'overlineThickness', 'paintOrder', 'panose1', 'pathLength', 'patternContentUnits', 'patternTransform', 'patternUnits', 'pointerEvents', 'pointsAtX', 'pointsAtY', 'pointsAtZ', 'preserveAlpha', 'preserveAspectRatio', 'primitiveUnits', 'r', 'radius', 'refX', 'refY', 'renderingIntent', 'repeatCount', 'repeatDur', 'requiredExtensions', 'requiredFeatures', 'restart', 'result', 'rotate', 'rx', 'ry', 'seed', 'shapeRendering', 'slope', 'spacing', 'specularConstant', 'specularExponent', 'speed', 'spreadMethod', 'startOffset', 'stdDeviation', 'stemh', 'stemv', 'stitchTiles', 'stopColor', 'stopOpacity', 'strikethroughPosition', 'strikethroughThickness', 'string', 'stroke', 'strokeDasharray', 'strokeDashoffset', 'strokeLinecap', 'strokeLinejoin', 'strokeMiterlimit', 'strokeOpacity', 'strokeWidth', 'surfaceScale', 'systemLanguage', 'tableValues', 'targetX', 'targetY', 'textAnchor', 'textDecoration', 'textLength', 'textRendering', 'to', 'transform', 'u1', 'u2', 'underlinePosition', 'underlineThickness', 'unicode', 'unicodeBidi', 'unicodeRange', 'unitsPerEm', 'vAlphabetic', 'values', 'vectorEffect', 'version', 'vertAdvY', 'vertOriginX', 'vertOriginY', 'vHanging', 'vIdeographic', 'viewTarget', 'visibility', 'vMathematical', 'widths', 'wordSpacing', 'writingMode', 'x1', 'x2', 'x', 'xChannelSelector', 'xHeight', 'xlinkActuate', 'xlinkArcrole', 'xlinkHref', 'xlinkRole', 'xlinkShow', 'xlinkTitle', 'xlinkType', 'xmlBase', 'xmlLang', 'xmlns', 'xmlnsXlink', 'xmlSpace', 'y1', 'y2', 'y', 'yChannelSelector', 'z', 'zoomAndPan', 'ref', 'key', 'angle'];
+var SVGElementPropKeySet = new Set(SVGElementPropKeys);
+export function isSvgElementPropKey(key) {
+ if (typeof key !== 'string') {
+ return false;
+ }
+ return SVGElementPropKeySet.has(key);
+}
+/**
+ * Checks if the property is a data attribute.
+ * @param key The property key.
+ * @returns True if the key starts with 'data-', false otherwise.
+ */
+export function isDataAttribute(key) {
+ return typeof key === 'string' && key.startsWith('data-');
+}
+
+/**
+ * Filters an object to only include SVG properties. Removes all event handlers too.
+ * @param obj - The object to filter
+ * @returns A new object containing only valid SVG properties, excluding event handlers.
+ */
+export function svgPropertiesNoEvents(obj) {
+ if (typeof obj !== 'object' || obj === null) {
+ return {};
+ }
+ var result = {};
+ for (var key in obj) {
+ if (Object.prototype.hasOwnProperty.call(obj, key)) {
+ if (isSvgElementPropKey(key) || isDataAttribute(key)) {
+ result[key] = obj[key];
+ }
+ }
+ }
+ return result;
+}
+
+/**
+ * Function to filter SVG properties from various input types.
+ * The input types can be:
+ * - A record of string keys to any values, in which case it returns a record of only SVG properties
+ * - A React element, in which case it returns the props of the element filtered to only SVG properties
+ * - Anything else, in which case it returns null
+ *
+ * This function has a wide-open return type, because it will read and filter the props of an arbitrary React element.
+ * This can be SVG, HTML, whatnot, with arbitrary values, so we can't type it more specifically.
+ *
+ * If you wish to have a type-safe version, use svgPropertiesNoEvents directly with a typed object.
+ *
+ * @param input - The input to filter, which can be a record, a React element, or other types.
+ * @returns A record of SVG properties if the input is a record or React element, otherwise null.
+ */
+export function svgPropertiesNoEventsFromUnknown(input) {
+ if (input == null) {
+ return null;
+ }
+ if (/*#__PURE__*/isValidElement(input) && typeof input.props === 'object' && input.props !== null) {
+ var p = input.props;
+ return svgPropertiesNoEvents(p);
+ }
+ if (typeof input === 'object' && !Array.isArray(input)) {
+ return svgPropertiesNoEvents(input);
+ }
+ return null;
+}
Index: node_modules/recharts/es6/util/tooltip/translate.js
===================================================================
--- node_modules/recharts/es6/util/tooltip/translate.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
+++ node_modules/recharts/es6/util/tooltip/translate.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
@@ -0,0 +1,124 @@
+import { clsx } from 'clsx';
+import { isNumber } from '../DataUtils';
+var CSS_CLASS_PREFIX = 'recharts-tooltip-wrapper';
+var TOOLTIP_HIDDEN = {
+ visibility: 'hidden'
+};
+export function getTooltipCSSClassName(_ref) {
+ var {
+ coordinate,
+ translateX,
+ translateY
+ } = _ref;
+ return clsx(CSS_CLASS_PREFIX, {
+ ["".concat(CSS_CLASS_PREFIX, "-right")]: isNumber(translateX) && coordinate && isNumber(coordinate.x) && translateX >= coordinate.x,
+ ["".concat(CSS_CLASS_PREFIX, "-left")]: isNumber(translateX) && coordinate && isNumber(coordinate.x) && translateX < coordinate.x,
+ ["".concat(CSS_CLASS_PREFIX, "-bottom")]: isNumber(translateY) && coordinate && isNumber(coordinate.y) && translateY >= coordinate.y,
+ ["".concat(CSS_CLASS_PREFIX, "-top")]: isNumber(translateY) && coordinate && isNumber(coordinate.y) && translateY < coordinate.y
+ });
+}
+export function getTooltipTranslateXY(_ref2) {
+ var {
+ allowEscapeViewBox,
+ coordinate,
+ key,
+ offset,
+ position,
+ reverseDirection,
+ tooltipDimension,
+ viewBox,
+ viewBoxDimension
+ } = _ref2;
+ if (position && isNumber(position[key])) {
+ return position[key];
+ }
+ var negative = coordinate[key] - tooltipDimension - (offset > 0 ? offset : 0);
+ var positive = coordinate[key] + offset;
+ if (allowEscapeViewBox[key]) {
+ return reverseDirection[key] ? negative : positive;
+ }
+ var viewBoxKey = viewBox[key];
+ if (viewBoxKey == null) {
+ return 0;
+ }
+ if (reverseDirection[key]) {
+ var _tooltipBoundary = negative;
+ var _viewBoxBoundary = viewBoxKey;
+ if (_tooltipBoundary < _viewBoxBoundary) {
+ return Math.max(positive, viewBoxKey);
+ }
+ return Math.max(negative, viewBoxKey);
+ }
+ if (viewBoxDimension == null) {
+ return 0;
+ }
+ var tooltipBoundary = positive + tooltipDimension;
+ var viewBoxBoundary = viewBoxKey + viewBoxDimension;
+ if (tooltipBoundary > viewBoxBoundary) {
+ return Math.max(negative, viewBoxKey);
+ }
+ return Math.max(positive, viewBoxKey);
+}
+export function getTransformStyle(_ref3) {
+ var {
+ translateX,
+ translateY,
+ useTranslate3d
+ } = _ref3;
+ return {
+ transform: useTranslate3d ? "translate3d(".concat(translateX, "px, ").concat(translateY, "px, 0)") : "translate(".concat(translateX, "px, ").concat(translateY, "px)")
+ };
+}
+export function getTooltipTranslate(_ref4) {
+ var {
+ allowEscapeViewBox,
+ coordinate,
+ offsetTop,
+ offsetLeft,
+ position,
+ reverseDirection,
+ tooltipBox,
+ useTranslate3d,
+ viewBox
+ } = _ref4;
+ var cssProperties, translateX, translateY;
+ if (tooltipBox.height > 0 && tooltipBox.width > 0 && coordinate) {
+ translateX = getTooltipTranslateXY({
+ allowEscapeViewBox,
+ coordinate,
+ key: 'x',
+ offset: offsetLeft,
+ position,
+ reverseDirection,
+ tooltipDimension: tooltipBox.width,
+ viewBox,
+ viewBoxDimension: viewBox.width
+ });
+ translateY = getTooltipTranslateXY({
+ allowEscapeViewBox,
+ coordinate,
+ key: 'y',
+ offset: offsetTop,
+ position,
+ reverseDirection,
+ tooltipDimension: tooltipBox.height,
+ viewBox,
+ viewBoxDimension: viewBox.height
+ });
+ cssProperties = getTransformStyle({
+ translateX,
+ translateY,
+ useTranslate3d
+ });
+ } else {
+ cssProperties = TOOLTIP_HIDDEN;
+ }
+ return {
+ cssProperties,
+ cssClasses: getTooltipCSSClassName({
+ translateX,
+ translateY,
+ coordinate
+ })
+ };
+}
Index: node_modules/recharts/es6/util/types.js
===================================================================
--- node_modules/recharts/es6/util/types.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
+++ node_modules/recharts/es6/util/types.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
@@ -0,0 +1,247 @@
+import { isValidElement } from 'react';
+import { isEventKey } from './excludeEventProps';
+
+/**
+ * Determines how values are stacked:
+ *
+ * - `none` is the default, it adds values on top of each other. No smarts. Negative values will overlap.
+ * - `expand` make it so that the values always add up to 1 - so the chart will look like a rectangle.
+ * - `wiggle` and `silhouette` tries to keep the chart centered.
+ * - `sign` stacks positive values above zero and negative values below zero. Similar to `none` but handles negatives.
+ * - `positive` ignores all negative values, and then behaves like \`none\`.
+ *
+ * @see {@link https://d3js.org/d3-shape/stack#stack-offsets}
+ * (note that the `diverging` offset in d3 is named `sign` in recharts)
+ *
+ * @inline
+ */
+
+/**
+ * @deprecated use either `CartesianLayout` or `PolarLayout` instead.
+ * Mixing both charts families leads to ambiguity in the type system.
+ * These two layouts share very few properties, so it is best to keep them separate.
+ */
+
+/**
+ * The type of axis.
+ *
+ * `category`: Treats data as distinct values.
+ * Each value is in the same distance from its neighbors, regardless of their actual numeric difference.
+ *
+ * `number`: Treats data as continuous range.
+ * Values that are numerically closer are placed closer together on the axis.
+ *
+ * `auto`: the type is inferred based on the chart layout.
+ *
+ * This is external type - users will provide this type in props.
+ * Internally we will evaluate it to either 'category' or 'number' based on the layout,
+ * before sending it to the store.
+ *
+ * @inline
+ */
+
+/**
+ * Individual axes are responsible for resolving the 'auto' type to either 'number' or 'category',
+ * based on the chart layout and axis kind. Then they can start using this type.
+ */
+
+/**
+ * Extracts values from data objects.
+ *
+ * @inline
+ */
+
+/**
+ * @inline
+ */
+
+/**
+ * @inline
+ */
+
+/**
+ * @deprecated do not use: too many properties, mixing too many concepts, cartesian and polar together, everything optional.
+ * Instead, use either `Coordinate` or `PolarCoordinate`.
+ */
+
+export var isPolarCoordinate = c => {
+ return 'radius' in c && 'startAngle' in c && 'endAngle' in c;
+};
+
+/**
+ * String shortcuts for scale types.
+ * In case none of these does what you want you can also provide your own scale function
+ * @see {@link CustomScaleDefinition}
+ */
+
+//
+// Event Handler Types -- Copied from @types/react/index.d.ts and adapted for Props.
+//
+
+/**
+ * The type of easing function to use for animations
+ *
+ * @inline
+ */
+
+/** Specifies the duration of animation, the unit of this option is ms. */
+
+/**
+ * This object defines the offset of the chart area and width and height and brush and ... it's a bit too much information all in one.
+ * We use it internally but let's not expose it to the outside world.
+ * If you are looking for this information, instead import `ChartOffset` or `PlotArea` from `recharts`.
+ */
+
+/**
+ * The domain of axis.
+ * This is the definition
+ *
+ * Numeric domain is always defined by an array of exactly two values, for the min and the max of the axis.
+ * Categorical domain is defined as array of all possible values.
+ *
+ * Can be specified in many ways:
+ * - array of numbers
+ * - with special strings like 'dataMin' and 'dataMax'
+ * - with special string math like 'dataMin - 100'
+ * - with keyword 'auto'
+ * - or a function
+ * - array of functions
+ * - or a combination of the above
+ */
+
+/**
+ * NumberDomain is an evaluated {@link AxisDomain}.
+ * Unlike {@link AxisDomain}, it has no variety - it's a tuple of two number.
+ * This is after all the keywords and functions were evaluated and what is left is [min, max].
+ *
+ * Know that the min, max values are not guaranteed to be nice numbers - values like -Infinity or NaN are possible.
+ *
+ * There are also `category` axes that have different things than numbers in their domain.
+ */
+
+/**
+ * Props shared in all renderable axes - meaning the ones that are drawn on the chart,
+ * can have ticks, axis line, etc.
+ */
+
+/** Defines how ticks are placed and whether / how tick collisions are handled.
+ * 'preserveStart' keeps the left tick on collision and ensures that the first tick is always shown.
+ * 'preserveEnd' keeps the right tick on collision and ensures that the last tick is always shown.
+ * 'preserveStartEnd' keeps the left tick on collision and ensures that the first and last ticks always show.
+ * 'equidistantPreserveStart' selects a number N such that every nTh tick will be shown without collision.
+ * 'equidistantPreserveEnd' selects a number N such that every nTh tick will be shown, ensuring the last tick is always visible.
+ */
+
+/**
+ * Ticks can be any type when the axis is the type of category.
+ *
+ * Ticks must be numbers when the axis is the type of number.
+ */
+
+/**
+ * @inline
+ */
+
+/**
+ * @inline
+ */
+
+export var adaptEventHandlers = (props, newHandler) => {
+ if (!props || typeof props === 'function' || typeof props === 'boolean') {
+ return null;
+ }
+ var inputProps = props;
+ if (/*#__PURE__*/isValidElement(props)) {
+ inputProps = props.props;
+ }
+ if (typeof inputProps !== 'object' && typeof inputProps !== 'function') {
+ return null;
+ }
+ var out = {};
+ Object.keys(inputProps).forEach(key => {
+ if (isEventKey(key)) {
+ out[key] = newHandler || (e => inputProps[key](inputProps, e));
+ }
+ });
+ return out;
+};
+var getEventHandlerOfChild = (originalHandler, data, index) => e => {
+ originalHandler(data, index, e);
+ return null;
+};
+export var adaptEventsOfChild = (props, data, index) => {
+ if (props === null || typeof props !== 'object' && typeof props !== 'function') {
+ return null;
+ }
+ var out = null;
+ Object.keys(props).forEach(key => {
+ var item = props[key];
+ if (isEventKey(key) && typeof item === 'function') {
+ if (!out) out = {};
+ out[key] = getEventHandlerOfChild(item, data, index);
+ }
+ });
+ return out;
+};
+
+/**
+ * 'axis' means that all graphical items belonging to this axis tick will be highlighted,
+ * and all will be present in the tooltip.
+ * Tooltip with 'axis' will display when hovering on the chart background.
+ *
+ * 'item' means only the one graphical item being hovered will show in the tooltip.
+ * Tooltip with 'item' will display when hovering over individual graphical items.
+ *
+ * This is calculated internally;
+ * charts have a `defaultTooltipEventType` and `validateTooltipEventTypes` options.
+ *
+ * Users then use or to control their preference,
+ * and charts will then see what is allowed and what is not.
+ */
+
+/**
+ * These are the props we are going to pass to an `activeDot` or `dot` if it is a function or a custom Component
+ */
+
+/**
+ * This is the type of `activeDot` prop on:
+ * - Area
+ * - Line
+ * - Radar
+ *
+ * @inline
+ */
+
+/**
+ * Inside the dot event handlers we provide extra information about the dot point
+ * that the Dot component itself does not need but users might find useful.
+ */
+
+/**
+ * This is the type of `dot` prop on:
+ * - Area
+ * - Line
+ * - Radar
+ *
+ * @inline
+ */
+
+/**
+ * Simplified version of the MouseEvent so that we don't have to mock the whole thing in tests.
+ *
+ * This is meant to represent the React.MouseEvent
+ * which is a wrapper on top of https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent
+ */
+
+/**
+ * Coordinates relative to the top-left corner of the chart.
+ * Also include scale which means that a chart that's scaled will return the same coordinates as a chart that's not scaled.
+ */
+
+/**
+ * Props shared with all charts.
+ */
+
+export var isNonEmptyArray = arr => {
+ return Array.isArray(arr) && arr.length > 0;
+};
Index: node_modules/recharts/es6/util/useAnimationId.js
===================================================================
--- node_modules/recharts/es6/util/useAnimationId.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
+++ node_modules/recharts/es6/util/useAnimationId.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
@@ -0,0 +1,27 @@
+import { useRef } from 'react';
+import { uniqueId } from './DataUtils';
+
+/**
+ * This hook returns a unique animation id for the object input.
+ * If input changes (as in, reference equality is different), the animation id will change.
+ * If input does not change, the animation id will not change.
+ *
+ * This is useful for animations. The Animate component
+ * does have a `shouldReAnimate` prop but that doesn't seem to be doing what the name implies.
+ * Also, we don't always want to re-animate on every render;
+ * we only want to re-animate when the input changes. Not the internal state (e.g. `isAnimating`).
+ *
+ * @param input The object to check for changes. Uses reference equality (=== operator)
+ * @param prefix Optional prefix to use for the animation id
+ * @returns A unique animation id
+ */
+export function useAnimationId(input) {
+ var prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'animation-';
+ var animationId = useRef(uniqueId(prefix));
+ var prevProps = useRef(input);
+ if (prevProps.current !== input) {
+ animationId.current = uniqueId(prefix);
+ prevProps.current = input;
+ }
+ return animationId.current;
+}
Index: node_modules/recharts/es6/util/useElementOffset.js
===================================================================
--- node_modules/recharts/es6/util/useElementOffset.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
+++ node_modules/recharts/es6/util/useElementOffset.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
@@ -0,0 +1,47 @@
+import { useCallback, useState } from 'react';
+var EPS = 1;
+
+/**
+ * TODO this documentation does not reflect what this hook is doing, update it.
+ * Stores the `offsetHeight`, `offsetLeft`, `offsetTop`, and `offsetWidth` of a DOM element.
+ */
+
+/**
+ * Use this to listen to element layout changes.
+ *
+ * Very useful for reading actual sizes of DOM elements relative to the viewport.
+ *
+ * @param extraDependencies use this to trigger new DOM dimensions read when any of these change. Good for things like payload and label, that will re-render something down in the children array, but you want to read the layout box of a parent.
+ * @returns [lastElementOffset, updateElementOffset] most recent value, and setter. Pass the setter to a DOM element ref like this: ``
+ */
+export function useElementOffset() {
+ var extraDependencies = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+ var [lastBoundingBox, setLastBoundingBox] = useState({
+ height: 0,
+ left: 0,
+ top: 0,
+ width: 0
+ });
+ var updateBoundingBox = useCallback(node => {
+ if (node != null) {
+ var rect = node.getBoundingClientRect();
+ var box = {
+ height: rect.height,
+ left: rect.left,
+ top: rect.top,
+ width: rect.width
+ };
+ if (Math.abs(box.height - lastBoundingBox.height) > EPS || Math.abs(box.left - lastBoundingBox.left) > EPS || Math.abs(box.top - lastBoundingBox.top) > EPS || Math.abs(box.width - lastBoundingBox.width) > EPS) {
+ setLastBoundingBox({
+ height: box.height,
+ left: box.left,
+ top: box.top,
+ width: box.width
+ });
+ }
+ }
+ },
+ // eslint-disable-next-line react-hooks/exhaustive-deps
+ [lastBoundingBox.width, lastBoundingBox.height, lastBoundingBox.top, lastBoundingBox.left, ...extraDependencies]);
+ return [lastBoundingBox, updateBoundingBox];
+}
Index: node_modules/recharts/es6/util/useId.js
===================================================================
--- node_modules/recharts/es6/util/useId.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
+++ node_modules/recharts/es6/util/useId.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
@@ -0,0 +1,20 @@
+var _ref;
+import * as React from 'react';
+import { uniqueId } from './DataUtils';
+
+/**
+ * Fallback for React.useId() for versions prior to React 18.
+ * Generates a unique ID using a simple counter and a prefix.
+ *
+ * @returns A unique ID that remains consistent across renders.
+ */
+export var useIdFallback = () => {
+ var [id] = React.useState(() => uniqueId('uid-'));
+ return id;
+};
+
+/*
+ * This weird syntax is used to avoid a build-time error in React 17 and earlier when building with Webpack.
+ * See https://github.com/webpack/webpack/issues/14814
+ */
+export var useId = (_ref = React['useId'.toString()]) !== null && _ref !== void 0 ? _ref : useIdFallback;
Index: node_modules/recharts/es6/util/useReportScale.js
===================================================================
--- node_modules/recharts/es6/util/useReportScale.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
+++ node_modules/recharts/es6/util/useReportScale.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
@@ -0,0 +1,21 @@
+import { useEffect, useState } from 'react';
+import { useAppDispatch, useAppSelector } from '../state/hooks';
+import { selectContainerScale } from '../state/selectors/containerSelectors';
+import { setScale } from '../state/layoutSlice';
+import { isWellBehavedNumber } from './isWellBehavedNumber';
+export function useReportScale() {
+ var dispatch = useAppDispatch();
+ var [ref, setRef] = useState(null);
+ var scale = useAppSelector(selectContainerScale);
+ useEffect(() => {
+ if (ref == null) {
+ return;
+ }
+ var rect = ref.getBoundingClientRect();
+ var newScale = rect.width / ref.offsetWidth;
+ if (isWellBehavedNumber(newScale) && newScale !== scale) {
+ dispatch(setScale(newScale));
+ }
+ }, [ref, dispatch, scale]);
+ return setRef;
+}
Index: node_modules/recharts/es6/util/useUniqueId.js
===================================================================
--- node_modules/recharts/es6/util/useUniqueId.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
+++ node_modules/recharts/es6/util/useUniqueId.js (revision a762898ecd37a452c782821d4c2c4955c6ed2521)
@@ -0,0 +1,32 @@
+import { useId } from './useId';
+
+/**
+ * A hook that generates a unique ID. It uses React.useId() in React 18+ for SSR safety
+ * and falls back to a client-side-only unique ID generator for older versions.
+ *
+ * The ID will stay the same across renders, and you can optionally provide a prefix.
+ *
+ * @param [prefix] - An optional prefix for the generated ID.
+ * @param [customId] - An optional custom ID to override the generated one.
+ * @returns The unique ID.
+ */
+export function useUniqueId(prefix, customId) {
+ /*
+ * We have to call this hook here even if we don't use the result because
+ * rules of hooks demand that hooks are never called conditionally.
+ */
+ var generatedId = useId();
+
+ // If a custom ID is provided, it always takes precedence.
+ if (customId) {
+ return customId;
+ }
+
+ // Apply the prefix if one was provided.
+ return prefix ? "".concat(prefix, "-").concat(generatedId) : generatedId;
+}
+
+/**
+ * The useUniqueId hook returns a unique ID that is either reused from external props or generated internally.
+ * Either way the ID is now guaranteed to be present so no more nulls or undefined.
+ */