umwd-components 0.1.758 → 0.1.760

package/dist/esm/node_modules/recharts/lib/util/isDomainSpecifiedByUser.js

@@ -1,200 +0,0 @@
-/*
- * UMWD-Components
- * @copyright Jelle Paulus
- * @license MIT
- */
-  
-import { __exports as isDomainSpecifiedByUser } from '../../../../_virtual/isDomainSpecifiedByUser.js';
-import './ChartUtils.js';
-import './DataUtils.js';
-import './isWellBehavedNumber.js';
-import { __exports as isWellBehavedNumber } from '../../../../_virtual/isWellBehavedNumber.js';
-import { __exports as DataUtils } from '../../../../_virtual/DataUtils.js';
-import { __exports as ChartUtils } from '../../../../_virtual/ChartUtils.js';
-
-Object.defineProperty(isDomainSpecifiedByUser, "__esModule", {
-  value: true
-});
-isDomainSpecifiedByUser.extendDomain = extendDomain;
-isDomainSpecifiedByUser.isWellFormedNumberDomain = isWellFormedNumberDomain;
-isDomainSpecifiedByUser.numericalDomainSpecifiedWithoutRequiringData = numericalDomainSpecifiedWithoutRequiringData;
-isDomainSpecifiedByUser.parseNumericalUserDomain = parseNumericalUserDomain;
-var _ChartUtils = ChartUtils;
-var _DataUtils = DataUtils;
-var _isWellBehavedNumber = isWellBehavedNumber;
-function isWellFormedNumberDomain(v) {
-  if (Array.isArray(v) && v.length === 2) {
-    var [min, max] = v;
-    if ((0, _isWellBehavedNumber.isWellBehavedNumber)(min) && (0, _isWellBehavedNumber.isWellBehavedNumber)(max)) {
-      return true;
-    }
-  }
-  return false;
-}
-function extendDomain(providedDomain, boundaryDomain, allowDataOverflow) {
-  if (allowDataOverflow) {
-    // If the data are allowed to overflow - we're fine with whatever user provided
-    return providedDomain;
-  }
-  /*
-   * If the data are not allowed to overflow - we need to extend the domain.
-   * Means that effectively the user is allowed to make the domain larger
-   * but not smaller.
-   */
-  return [Math.min(providedDomain[0], boundaryDomain[0]), Math.max(providedDomain[1], boundaryDomain[1])];
-}
-
-/**
- * So Recharts allows users to provide their own domains,
- * but it also places some expectations on what the domain is.
- * We can improve on the typescript typing, but we also need a runtime test
- to observe that the user-provided domain is well-formed,
- * that is: an array with exactly two numbers.
- *
- * This function does not accept data as an argument.
- * This is to enable a performance optimization - if the domain is there,
- * and we know what it is without traversing all the data,
- * then we don't have to traverse all the data!
- *
- * If the user-provided domain is not well-formed,
- * this function will return undefined - in which case we should traverse the data to calculate the real domain.
- *
- * This function is for parsing the numerical domain only.
- *
- * @param userDomain external prop, user provided, before validation. Can have various shapes: array, function, special magical strings inside too.
- * @param allowDataOverflow boolean, provided by users. If true then the data domain wins
- *
- * @return [min, max] domain if it's well-formed; undefined if the domain is invalid
- */
-function numericalDomainSpecifiedWithoutRequiringData(userDomain, allowDataOverflow) {
-  if (!allowDataOverflow) {
-    // Cannot compute data overflow if the data is not provided
-    return undefined;
-  }
-  if (typeof userDomain === 'function') {
-    // The user function expects the data to be provided as an argument
-    return undefined;
-  }
-  if (Array.isArray(userDomain) && userDomain.length === 2) {
-    var [providedMin, providedMax] = userDomain;
-    var finalMin, finalMax;
-    if ((0, _isWellBehavedNumber.isWellBehavedNumber)(providedMin)) {
-      finalMin = providedMin;
-    } else if (typeof providedMin === 'function') {
-      // The user function expects the data to be provided as an argument
-      return undefined;
-    }
-    if ((0, _isWellBehavedNumber.isWellBehavedNumber)(providedMax)) {
-      finalMax = providedMax;
-    } else if (typeof providedMax === 'function') {
-      // The user function expects the data to be provided as an argument
-      return undefined;
-    }
-    var candidate = [finalMin, finalMax];
-    if (isWellFormedNumberDomain(candidate)) {
-      return candidate;
-    }
-  }
-  return undefined;
-}
-
-/**
- * So Recharts allows users to provide their own domains,
- * but it also places some expectations on what the domain is.
- * We can improve on the typescript typing, but we also need a runtime test
- * to observe that the user-provided domain is well-formed,
- * that is: an array with exactly two numbers.
- * If the user-provided domain is not well-formed,
- * this function will return undefined - in which case we should traverse the data to calculate the real domain.
- *
- * This function is for parsing the numerical domain only.
- *
- * You are probably thinking, why does domain need tick count?
- * Well it adjusts the domain based on where the "nice ticks" land, and nice ticks depend on the tick count.
- *
- * @param userDomain external prop, user provided, before validation. Can have various shapes: array, function, special magical strings inside too.
- * @param dataDomain calculated from data. Can be undefined, as an option for performance optimization
- * @param allowDataOverflow provided by users. If true then the data domain wins
- *
- * @return [min, max] domain if it's well-formed; undefined if the domain is invalid
- */
-function parseNumericalUserDomain(userDomain, dataDomain, allowDataOverflow) {
-  if (!allowDataOverflow && dataDomain == null) {
-    // Cannot compute data overflow if the data is not provided
-    return undefined;
-  }
-  if (typeof userDomain === 'function' && dataDomain != null) {
-    try {
-      var result = userDomain(dataDomain, allowDataOverflow);
-      if (isWellFormedNumberDomain(result)) {
-        return extendDomain(result, dataDomain, allowDataOverflow);
-      }
-    } catch (_unused) {
-      /* ignore the exception and compute domain from data later */
-    }
-  }
-  if (Array.isArray(userDomain) && userDomain.length === 2) {
-    var [providedMin, providedMax] = userDomain;
-    var finalMin, finalMax;
-    if (providedMin === 'auto') {
-      if (dataDomain != null) {
-        finalMin = Math.min(...dataDomain);
-      }
-    } else if ((0, _DataUtils.isNumber)(providedMin)) {
-      finalMin = providedMin;
-    } else if (typeof providedMin === 'function') {
-      try {
-        if (dataDomain != null) {
-          finalMin = providedMin(dataDomain === null || dataDomain === void 0 ? void 0 : dataDomain[0]);
-        }
-      } catch (_unused2) {
-        /* ignore the exception and compute domain from data later */
-      }
-    } else if (typeof providedMin === 'string' && _ChartUtils.MIN_VALUE_REG.test(providedMin)) {
-      var match = _ChartUtils.MIN_VALUE_REG.exec(providedMin);
-      if (match == null || dataDomain == null) {
-        finalMin = undefined;
-      } else {
-        var value = +match[1];
-        finalMin = dataDomain[0] - value;
-      }
-    } else {
-      finalMin = dataDomain === null || dataDomain === void 0 ? void 0 : dataDomain[0];
-    }
-    if (providedMax === 'auto') {
-      if (dataDomain != null) {
-        finalMax = Math.max(...dataDomain);
-      }
-    } else if ((0, _DataUtils.isNumber)(providedMax)) {
-      finalMax = providedMax;
-    } else if (typeof providedMax === 'function') {
-      try {
-        if (dataDomain != null) {
-          finalMax = providedMax(dataDomain === null || dataDomain === void 0 ? void 0 : dataDomain[1]);
-        }
-      } catch (_unused3) {
-        /* ignore the exception and compute domain from data later */
-      }
-    } else if (typeof providedMax === 'string' && _ChartUtils.MAX_VALUE_REG.test(providedMax)) {
-      var _match = _ChartUtils.MAX_VALUE_REG.exec(providedMax);
-      if (_match == null || dataDomain == null) {
-        finalMax = undefined;
-      } else {
-        var _value = +_match[1];
-        finalMax = dataDomain[1] + _value;
-      }
-    } else {
-      finalMax = dataDomain === null || dataDomain === void 0 ? void 0 : dataDomain[1];
-    }
-    var candidate = [finalMin, finalMax];
-    if (isWellFormedNumberDomain(candidate)) {
-      if (dataDomain == null) {
-        return candidate;
-      }
-      return extendDomain(candidate, dataDomain, allowDataOverflow);
-    }
-  }
-  return undefined;
-}
-
-export { isDomainSpecifiedByUser as default };

package/dist/esm/node_modules/recharts/lib/util/isWellBehavedNumber.js

@@ -1,21 +0,0 @@
-/*
- * UMWD-Components
- * @copyright Jelle Paulus
- * @license MIT
- */
-  
-import { __exports as isWellBehavedNumber$1 } from '../../../../_virtual/isWellBehavedNumber.js';
-
-Object.defineProperty(isWellBehavedNumber$1, "__esModule", {
-  value: true
-});
-isWellBehavedNumber$1.isPositiveNumber = isPositiveNumber;
-isWellBehavedNumber$1.isWellBehavedNumber = isWellBehavedNumber;
-function isWellBehavedNumber(n) {
-  return Number.isFinite(n);
-}
-function isPositiveNumber(n) {
-  return typeof n === 'number' && n > 0 && Number.isFinite(n);
-}
-
-export { isWellBehavedNumber$1 as default };

package/dist/esm/node_modules/recharts/lib/util/payload/getUniqPayload.js

@@ -1,34 +0,0 @@
-/*
- * UMWD-Components
- * @copyright Jelle Paulus
- * @license MIT
- */
-  
-import { __exports as getUniqPayload$1 } from '../../../../../_virtual/getUniqPayload.js';
-import { u as uniqBy } from '../../../../es-toolkit/compat/uniqBy.js';
-
-Object.defineProperty(getUniqPayload$1, "__esModule", {
-  value: true
-});
-getUniqPayload$1.getUniqPayload = getUniqPayload;
-var _uniqBy = _interopRequireDefault(uniqBy);
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-/**
- * This is configuration option that decides how to filter for unique values only:
- *
- * - `false` means "no filter"
- * - `true` means "use recharts default filter"
- * - function means "use return of this function as the default key"
- */
-
-function getUniqPayload(payload, option, defaultUniqBy) {
-  if (option === true) {
-    return (0, _uniqBy.default)(payload, defaultUniqBy);
-  }
-  if (typeof option === 'function') {
-    return (0, _uniqBy.default)(payload, option);
-  }
-  return payload;
-}
-
-export { getUniqPayload$1 as default };

package/dist/esm/node_modules/recharts/lib/util/resolveDefaultProps.js

@@ -1,69 +0,0 @@
-/*
- * UMWD-Components
- * @copyright Jelle Paulus
- * @license MIT
- */
-  
-import { __exports as resolveDefaultProps$1 } from '../../../../_virtual/resolveDefaultProps.js';
-
-Object.defineProperty(resolveDefaultProps$1, "__esModule", {
-  value: true
-});
-resolveDefaultProps$1.resolveDefaultProps = resolveDefaultProps;
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), true).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: true, configurable: true, writable: true }) : e[r] = t, e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-/**
- * This function mimics the behavior of the `defaultProps` static property in React.
- * Functional components do not have a defaultProps property, so this function is useful to resolve default props.
- *
- * The common recommendation is to use ES6 destructuring with default values in the function signature,
- * but you need to be careful there and make sure you destructure all the individual properties
- * and not the whole object. See the test file for example.
- *
- * And because destructuring all properties one by one is a faff, and it's easy to miss one property,
- * this function exists.
- *
- * @param realProps - the props object passed to the component by the user
- * @param defaultProps - the default props object defined in the component by Recharts
- * @returns - the props object with all the default props resolved. All `undefined` values are replaced with the default value.
- */
-function resolveDefaultProps(realProps, defaultProps) {
-  /*
-   * To avoid mutating the original `realProps` object passed to the function, create a shallow copy of it.
-   * `resolvedProps` will be modified directly with the defaults.
-   */
-  var resolvedProps = _objectSpread({}, realProps);
-  /*
-   * Since the function guarantees `D extends Partial<T>`, this assignment is safe.
-   * It allows TypeScript to work with the well-defined `Partial<T>` type inside the loop,
-   * making subsequent type inference (especially for `dp[key]`) much more straightforward for the compiler.
-   * This is a key step to improve type safety *without* value assertions later.
-   */
-  var dp = defaultProps;
-  /*
-   * `Object.keys` doesn't preserve strong key types - it always returns Array<string>.
-   * However, due to the `D extends Partial<T>` constraint,
-   * we know these keys *must* also be valid keys of `T`.
-   * This assertion informs TypeScript of this relationship, avoiding type errors when using `key` to index `acc` (type T).
-   *
-   * Type assertions are not sound but in this case it's necessary
-   * as `Object.keys` does not do what we want it to do.
-   */
-  var keys = Object.keys(defaultProps);
-  var withDefaults = keys.reduce((acc, key) => {
-    if (acc[key] === undefined && dp[key] !== undefined) {
-      acc[key] = dp[key];
-    }
-    return acc;
-  }, resolvedProps);
-  /*
-   * And again type assertions are not safe but here we have done the runtime work
-   * so let's bypass the lack of static type safety and tell the compiler what happened.
-   */
-  return withDefaults;
-}
-
-export { resolveDefaultProps$1 as default };

package/dist/esm/node_modules/recharts/lib/util/scale/getNiceTickValues.js

@@ -1,231 +0,0 @@
-/*
- * UMWD-Components
- * @copyright Jelle Paulus
- * @license MIT
- */
-  
-import { __exports as getNiceTickValues } from '../../../../../_virtual/getNiceTickValues.js';
-import { d as decimalExports } from '../../../../decimal.js-light/decimal.js';
-import './util/utils.js';
-import './util/arithmetic.js';
-import { __exports as utils } from '../../../../../_virtual/utils.js';
-import { __exports as arithmetic } from '../../../../../_virtual/arithmetic.js';
-
-Object.defineProperty(getNiceTickValues, "__esModule", {
-  value: true
-});
-getNiceTickValues.getValidInterval = getNiceTickValues.getTickValuesFixedDomain = getNiceTickValues.getTickOfSingleValue = getNiceTickValues.getNiceTickValues = getNiceTickValues.getFormatStep = getNiceTickValues.calculateStep = void 0;
-var _decimal = _interopRequireDefault(decimalExports);
-var _utils = utils;
-var _arithmetic = arithmetic;
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-/**
- * @fileOverview calculate tick values of scale
- * @author xile611, arcthur
- * @date 2015-09-17
- */
-
-/**
- * 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
- */
-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
- */
-getNiceTickValues.getValidInterval = getValidInterval;
-var getFormatStep = (roughStep, allowDecimals, correctionFactor) => {
-  if (roughStep.lte(0)) {
-    return new _decimal.default(0);
-  }
-  var digitCount = (0, _arithmetic.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.default(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.default(Math.ceil(stepRatio.div(stepRatioScale).toNumber())).add(correctionFactor).mul(stepRatioScale);
-  var formatStep = amendStepRatio.mul(digitCountValue);
-  return allowDecimals ? new _decimal.default(formatStep.toNumber()) : new _decimal.default(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
- */
-getNiceTickValues.getFormatStep = getFormatStep;
-var getTickOfSingleValue = (value, tickCount, allowDecimals) => {
-  var step = new _decimal.default(1);
-  // calculate the middle value of ticks
-  var middle = new _decimal.default(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.default(10).pow((0, _arithmetic.getDigitCount)(value) - 1);
-      middle = new _decimal.default(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.default(Math.floor(value));
-    }
-  } else if (value === 0) {
-    middle = new _decimal.default(Math.floor((tickCount - 1) / 2));
-  } else if (!allowDecimals) {
-    middle = new _decimal.default(Math.floor(value));
-  }
-  var middleIndex = Math.floor((tickCount - 1) / 2);
-  var fn = (0, _utils.compose)((0, _utils.map)(n => middle.add(new _decimal.default(n - middleIndex).mul(step)).toNumber()), _utils.range);
-  return fn(0, tickCount);
-};
-
-/**
- * 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
- */
-getNiceTickValues.getTickOfSingleValue = getTickOfSingleValue;
-var _calculateStep = getNiceTickValues.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.default(0),
-      tickMin: new _decimal.default(0),
-      tickMax: new _decimal.default(0)
-    };
-  }
-
-  // The step which is easy to understand between two ticks
-  var step = getFormatStep(new _decimal.default(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.default(0);
-  } else {
-    // calculate the middle value
-    middle = new _decimal.default(min).add(max).div(2);
-    // minus modulo value
-    middle = middle.sub(new _decimal.default(middle).mod(step));
-  }
-  var belowCount = Math.ceil(middle.sub(min).div(step).toNumber());
-  var upCount = Math.ceil(new _decimal.default(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.default(belowCount).mul(step)),
-    tickMax: middle.add(new _decimal.default(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
- */
-function getNiceTickValuesFn(_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, ...(0, _utils.range)(0, tickCount - 1).map(() => Infinity)] : [...(0, _utils.range)(0, tickCount - 1).map(() => -Infinity), cormax];
-    return min > max ? (0, _utils.reverse)(_values) : _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 = (0, _arithmetic.rangeStep)(tickMin, tickMax.add(new _decimal.default(0.1).mul(step)), step);
-  return min > max ? (0, _utils.reverse)(values) : 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
- */
-function getTickValuesFixedDomainFn(_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.default(cormax).sub(cormin).div(count - 1), allowDecimals, 0);
-  var values = [...(0, _arithmetic.rangeStep)(new _decimal.default(cormin), new _decimal.default(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 ? (0, _utils.reverse)(values) : values;
-}
-getNiceTickValues.getNiceTickValues = (0, _utils.memoize)(getNiceTickValuesFn);
-getNiceTickValues.getTickValuesFixedDomain = (0, _utils.memoize)(getTickValuesFixedDomainFn);
-
-export { getNiceTickValues as default };

package/dist/esm/node_modules/recharts/lib/util/scale/index.js

@@ -1,29 +0,0 @@
-/*
- * UMWD-Components
- * @copyright Jelle Paulus
- * @license MIT
- */
-  
-import { __exports as scale } from '../../../../../_virtual/index2.js';
-import './getNiceTickValues.js';
-import { __exports as getNiceTickValues } from '../../../../../_virtual/getNiceTickValues.js';
-
-(function (exports) {
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	Object.defineProperty(exports, "getNiceTickValues", {
-	  enumerable: true,
-	  get: function get() {
-	    return _getNiceTickValues.getNiceTickValues;
-	  }
-	});
-	Object.defineProperty(exports, "getTickValuesFixedDomain", {
-	  enumerable: true,
-	  get: function get() {
-	    return _getNiceTickValues.getTickValuesFixedDomain;
-	  }
-	});
-	var _getNiceTickValues = getNiceTickValues; 
-} (scale));