@razorpay/blade 12.68.0 → 12.89.1

package/build/lib/web/development/node_modules/recharts/es6/state/selectors/axisSelectors.js

@@ -0,0 +1,1339 @@
+import { createSelector } from '../../../../reselect/dist/reselect.js';
+import range from '../../../../es-toolkit/compat/range.js';
+import * as d3Scale from '../../../../victory-vendor/es/d3-scale.js';
+import { selectChartLayout } from '../../context/chartLayoutContext.js';
+import { getValueByDataKey, getStackedData, getDomainOfStackGroups, isCategoricalAxis } from '../../util/ChartUtils.js';
+import { selectChartDataWithIndexesIfNotInPanoramaPosition4, selectChartDataWithIndexes } from './dataSelectors.js';
+import { isWellFormedNumberDomain, numericalDomainSpecifiedWithoutRequiringData, parseNumericalUserDomain } from '../../util/isDomainSpecifiedByUser.js';
+import { isNumOrStr, isNotNil, isNan, hasDuplicate, upperFirst, getPercentValue, mathSign } from '../../util/DataUtils.js';
+import { isWellBehavedNumber } from '../../util/isWellBehavedNumber.js';
+import '../../util/scale/index.js';
+import { selectChartHeight, selectChartWidth } from './containerSelectors.js';
+import { selectAllXAxes, selectAllYAxes } from './selectAllAxes.js';
+import { selectChartOffsetInternal } from './selectChartOffsetInternal.js';
+import { selectBrushDimensions, selectBrushSettings } from './brushSelectors.js';
+import { selectStackOffsetType, selectReverseStackOrder, selectChartName, selectBarCategoryGap } from './rootPropsSelectors.js';
+import { selectRadiusAxis, selectAngleAxis, selectRadiusAxisRange, selectAngleAxisRange } from './polarAxisSelectors.js';
+import { pickAxisType } from './pickAxisType.js';
+import { pickAxisId } from './pickAxisId.js';
+import { combineAxisRangeWithReverse } from './combiners/combineAxisRangeWithReverse.js';
+import { DEFAULT_Y_AXIS_WIDTH } from '../../util/Constants.js';
+import { getStackSeriesIdentifier } from '../../util/stacks/getStackSeriesIdentifier.js';
+import { combineDisplayedStackedData } from './combiners/combineDisplayedStackedData.js';
+import { isStacked } from '../types/StackedGraphicalItem.js';
+import { numberDomainEqualityCheck } from './numberDomainEqualityCheck.js';
+import { emptyArraysAreEqualCheck } from './arrayEqualityCheck.js';
+import { selectTooltipAxisType } from './selectTooltipAxisType.js';
+import { selectTooltipAxisId } from './selectTooltipAxisId.js';
+import { rechartsScaleFactory } from '../../util/scale/RechartsScale.js';
+import { combineCheckedDomain } from './combiners/combineCheckedDomain.js';
+import { getNiceTickValues, getTickValuesFixedDomain } from '../../util/scale/getNiceTickValues.js';
+
+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), !0).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: !0, configurable: !0, writable: !0 }) : 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 || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var defaultNumericDomain = [0, 'auto'];
+/**
+ * If an axis is not explicitly defined as an element,
+ * we still need to render something in the chart and we need
+ * some object to hold the domain and default settings.
+ */
+var implicitXAxis = {
+  allowDataOverflow: false,
+  allowDecimals: true,
+  allowDuplicatedCategory: true,
+  angle: 0,
+  dataKey: undefined,
+  domain: undefined,
+  height: 30,
+  hide: true,
+  id: 0,
+  includeHidden: false,
+  interval: 'preserveEnd',
+  minTickGap: 5,
+  mirror: false,
+  name: undefined,
+  orientation: 'bottom',
+  padding: {
+    left: 0,
+    right: 0
+  },
+  reversed: false,
+  scale: 'auto',
+  tick: true,
+  tickCount: 5,
+  tickFormatter: undefined,
+  ticks: undefined,
+  type: 'category',
+  unit: undefined
+};
+var selectXAxisSettingsNoDefaults = (state, axisId) => {
+  return state.cartesianAxis.xAxis[axisId];
+};
+var selectXAxisSettings = (state, axisId) => {
+  var axis = selectXAxisSettingsNoDefaults(state, axisId);
+  if (axis == null) {
+    return implicitXAxis;
+  }
+  return axis;
+};
+
+/**
+ * If an axis is not explicitly defined as an element,
+ * we still need to render something in the chart and we need
+ * some object to hold the domain and default settings.
+ */
+var implicitYAxis = {
+  allowDataOverflow: false,
+  allowDecimals: true,
+  allowDuplicatedCategory: true,
+  angle: 0,
+  dataKey: undefined,
+  domain: defaultNumericDomain,
+  hide: true,
+  id: 0,
+  includeHidden: false,
+  interval: 'preserveEnd',
+  minTickGap: 5,
+  mirror: false,
+  name: undefined,
+  orientation: 'left',
+  padding: {
+    top: 0,
+    bottom: 0
+  },
+  reversed: false,
+  scale: 'auto',
+  tick: true,
+  tickCount: 5,
+  tickFormatter: undefined,
+  ticks: undefined,
+  type: 'number',
+  unit: undefined,
+  width: DEFAULT_Y_AXIS_WIDTH
+};
+var selectYAxisSettingsNoDefaults = (state, axisId) => {
+  return state.cartesianAxis.yAxis[axisId];
+};
+var selectYAxisSettings = (state, axisId) => {
+  var axis = selectYAxisSettingsNoDefaults(state, axisId);
+  if (axis == null) {
+    return implicitYAxis;
+  }
+  return axis;
+};
+var implicitZAxis = {
+  domain: [0, 'auto'],
+  includeHidden: false,
+  reversed: false,
+  allowDataOverflow: false,
+  allowDuplicatedCategory: false,
+  dataKey: undefined,
+  id: 0,
+  name: '',
+  range: [64, 64],
+  scale: 'auto',
+  type: 'number',
+  unit: ''
+};
+var selectZAxisSettings = (state, axisId) => {
+  var axis = state.cartesianAxis.zAxis[axisId];
+  if (axis == null) {
+    return implicitZAxis;
+  }
+  return axis;
+};
+var selectBaseAxis = (state, axisType, axisId) => {
+  switch (axisType) {
+    case 'xAxis':
+      {
+        return selectXAxisSettings(state, axisId);
+      }
+    case 'yAxis':
+      {
+        return selectYAxisSettings(state, axisId);
+      }
+    case 'zAxis':
+      {
+        return selectZAxisSettings(state, axisId);
+      }
+    case 'angleAxis':
+      {
+        return selectAngleAxis(state, axisId);
+      }
+    case 'radiusAxis':
+      {
+        return selectRadiusAxis(state, axisId);
+      }
+    default:
+      throw new Error("Unexpected axis type: ".concat(axisType));
+  }
+};
+var selectCartesianAxisSettings = (state, axisType, axisId) => {
+  switch (axisType) {
+    case 'xAxis':
+      {
+        return selectXAxisSettings(state, axisId);
+      }
+    case 'yAxis':
+      {
+        return selectYAxisSettings(state, axisId);
+      }
+    default:
+      throw new Error("Unexpected axis type: ".concat(axisType));
+  }
+};
+
+/**
+ * Selects either an X or Y axis. Doesn't work with Z axis - for that, instead use selectBaseAxis.
+ * @param state Root state
+ * @param axisType xAxis | yAxis
+ * @param axisId xAxisId | yAxisId
+ * @returns axis settings object
+ */
+var selectRenderableAxisSettings = (state, axisType, axisId) => {
+  switch (axisType) {
+    case 'xAxis':
+      {
+        return selectXAxisSettings(state, axisId);
+      }
+    case 'yAxis':
+      {
+        return selectYAxisSettings(state, axisId);
+      }
+    case 'angleAxis':
+      {
+        return selectAngleAxis(state, axisId);
+      }
+    case 'radiusAxis':
+      {
+        return selectRadiusAxis(state, axisId);
+      }
+    default:
+      throw new Error("Unexpected axis type: ".concat(axisType));
+  }
+};
+
+/**
+ * @param state RechartsRootState
+ * @return boolean true if there is at least one Bar or RadialBar
+ */
+var selectHasBar = state => state.graphicalItems.cartesianItems.some(item => item.type === 'bar') || state.graphicalItems.polarItems.some(item => item.type === 'radialBar');
+
+/**
+ * Filters CartesianGraphicalItemSettings by the relevant axis ID
+ * @param axisType 'xAxis' | 'yAxis' | 'zAxis' | 'radiusAxis' | 'angleAxis'
+ * @param axisId from props, defaults to 0
+ *
+ * @returns Predicate function that return true for CartesianGraphicalItemSettings that are relevant to the specified axis
+ */
+function itemAxisPredicate(axisType, axisId) {
+  return item => {
+    switch (axisType) {
+      case 'xAxis':
+        // This is sensitive to the data type, as 0 !== '0'. I wonder if we should be more flexible. How does 2.x branch behave? TODO write test for that
+        return 'xAxisId' in item && item.xAxisId === axisId;
+      case 'yAxis':
+        return 'yAxisId' in item && item.yAxisId === axisId;
+      case 'zAxis':
+        return 'zAxisId' in item && item.zAxisId === axisId;
+      case 'angleAxis':
+        return 'angleAxisId' in item && item.angleAxisId === axisId;
+      case 'radiusAxis':
+        return 'radiusAxisId' in item && item.radiusAxisId === axisId;
+      default:
+        return false;
+    }
+  };
+}
+
+// TODO appears there is a bug where this selector is called from polar context, find and fix it.
+var selectUnfilteredCartesianItems = state => state.graphicalItems.cartesianItems;
+var selectAxisPredicate = createSelector([pickAxisType, pickAxisId], itemAxisPredicate);
+var combineGraphicalItemsSettings = (graphicalItems, axisSettings, axisPredicate) => graphicalItems.filter(axisPredicate).filter(item => {
+  if ((axisSettings === null || axisSettings === void 0 ? void 0 : axisSettings.includeHidden) === true) {
+    return true;
+  }
+  return !item.hide;
+});
+var selectCartesianItemsSettings = createSelector([selectUnfilteredCartesianItems, selectBaseAxis, selectAxisPredicate], combineGraphicalItemsSettings, {
+  memoizeOptions: {
+    resultEqualityCheck: emptyArraysAreEqualCheck
+  }
+});
+var selectStackedCartesianItemsSettings = createSelector([selectCartesianItemsSettings], cartesianItems => {
+  return cartesianItems.filter(item => item.type === 'area' || item.type === 'bar').filter(isStacked);
+});
+var filterGraphicalNotStackedItems = cartesianItems => cartesianItems.filter(item => !('stackId' in item) || item.stackId === undefined);
+var selectCartesianItemsSettingsExceptStacked = createSelector([selectCartesianItemsSettings], filterGraphicalNotStackedItems);
+var combineGraphicalItemsData = cartesianItems => cartesianItems.map(item => item.data).filter(Boolean).flat(1);
+
+/**
+ * This is a "cheap" selector - it returns the data but doesn't iterate them, so it is not sensitive on the array length.
+ * Also does not apply dataKey yet.
+ * @param state RechartsRootState
+ * @returns data defined on the chart graphical items, such as Line or Scatter or Pie, and filtered with appropriate dataKey
+ */
+var selectCartesianGraphicalItemsData = createSelector([selectCartesianItemsSettings], combineGraphicalItemsData, {
+  memoizeOptions: {
+    resultEqualityCheck: emptyArraysAreEqualCheck
+  }
+});
+var combineDisplayedData = (graphicalItemsData, _ref) => {
+  var {
+    chartData = [],
+    dataStartIndex,
+    dataEndIndex
+  } = _ref;
+  if (graphicalItemsData.length > 0) {
+    /*
+     * There is no slicing when data is defined on graphical items. Why?
+     * Because Brush ignores data defined on graphical items,
+     * and does not render.
+     * So Brush will never show up in a Scatter chart for example.
+     * This is something we will need to fix.
+     *
+     * Now, when the root chart data is not defined, the dataEndIndex is 0,
+     * which means the itemsData will be sliced to an empty array anyway.
+     * But that's an implementation detail, and we can fix that too.
+     *
+     * Also, in absence of Axis dataKey, we use the dataKey from each item, respectively.
+     * This is the usual pattern for numerical axis, that is the one where bars go up:
+     * users don't specify any dataKey by default and expect the axis to "just match the data".
+     */
+    return graphicalItemsData;
+  }
+  return chartData.slice(dataStartIndex, dataEndIndex + 1);
+};
+
+/**
+ * This selector will return all data there is in the chart: graphical items, chart root, all together.
+ * Useful for figuring out an axis domain (because that needs to know of everything),
+ * not useful for rendering individual graphical elements (because they need to know which data is theirs and which is not).
+ *
+ * This function will discard the original indexes, so it is also not useful for anything that depends on ordering.
+ */
+var selectDisplayedData = createSelector([selectCartesianGraphicalItemsData, selectChartDataWithIndexesIfNotInPanoramaPosition4], combineDisplayedData);
+var combineAppliedValues = (data, axisSettings, items) => {
+  if ((axisSettings === null || axisSettings === void 0 ? void 0 : axisSettings.dataKey) != null) {
+    return data.map(item => ({
+      value: getValueByDataKey(item, axisSettings.dataKey)
+    }));
+  }
+  if (items.length > 0) {
+    return items.map(item => item.dataKey).flatMap(dataKey => data.map(entry => ({
+      value: getValueByDataKey(entry, dataKey)
+    })));
+  }
+  return data.map(entry => ({
+    value: entry
+  }));
+};
+
+/**
+ * This selector will return all values with the appropriate dataKey applied on them.
+ * Which dataKey is appropriate depends on where it is defined.
+ *
+ * This is an expensive selector - it will iterate all data and compute their value using the provided dataKey.
+ */
+var selectAllAppliedValues = createSelector([selectDisplayedData, selectBaseAxis, selectCartesianItemsSettings], combineAppliedValues);
+function isErrorBarRelevantForAxisType(axisType, errorBar) {
+  switch (axisType) {
+    case 'xAxis':
+      return errorBar.direction === 'x';
+    case 'yAxis':
+      return errorBar.direction === 'y';
+    default:
+      return false;
+  }
+}
+function makeNumber(val) {
+  if (isNumOrStr(val) || val instanceof Date) {
+    var n = Number(val);
+    if (isWellBehavedNumber(n)) {
+      return n;
+    }
+  }
+  return undefined;
+}
+function makeDomain(val) {
+  if (Array.isArray(val)) {
+    var attempt = [makeNumber(val[0]), makeNumber(val[1])];
+    if (isWellFormedNumberDomain(attempt)) {
+      return attempt;
+    }
+    return undefined;
+  }
+  var n = makeNumber(val);
+  if (n == null) {
+    return undefined;
+  }
+  return [n, n];
+}
+function onlyAllowNumbers(data) {
+  return data.map(makeNumber).filter(isNotNil);
+}
+
+/**
+ * @param entry One item in the 'data' array. Could be anything really - this is defined externally. This is the raw, before dataKey application
+ * @param appliedValue This is the result of applying the 'main' dataKey on the `entry`.
+ * @param relevantErrorBars Error bars that are relevant for the current axis and layout and all that.
+ * @return either undefined or an array of ErrorValue
+ */
+function getErrorDomainByDataKey(entry, appliedValue, relevantErrorBars) {
+  if (!relevantErrorBars || typeof appliedValue !== 'number' || isNan(appliedValue)) {
+    return [];
+  }
+  if (!relevantErrorBars.length) {
+    return [];
+  }
+  return onlyAllowNumbers(relevantErrorBars.flatMap(eb => {
+    var errorValue = getValueByDataKey(entry, eb.dataKey);
+    var lowBound, highBound;
+    if (Array.isArray(errorValue)) {
+      [lowBound, highBound] = errorValue;
+    } else {
+      lowBound = highBound = errorValue;
+    }
+    if (!isWellBehavedNumber(lowBound) || !isWellBehavedNumber(highBound)) {
+      return undefined;
+    }
+    return [appliedValue - lowBound, appliedValue + highBound];
+  }));
+}
+var selectTooltipAxis = state => {
+  var axisType = selectTooltipAxisType(state);
+  var axisId = selectTooltipAxisId(state);
+  return selectRenderableAxisSettings(state, axisType, axisId);
+};
+var selectTooltipAxisDataKey = createSelector([selectTooltipAxis], axis => axis === null || axis === void 0 ? void 0 : axis.dataKey);
+var selectDisplayedStackedData = createSelector([selectStackedCartesianItemsSettings, selectChartDataWithIndexesIfNotInPanoramaPosition4, selectTooltipAxis], combineDisplayedStackedData);
+var combineStackGroups = (displayedData, items, stackOffsetType, reverseStackOrder) => {
+  var initialItemsGroups = {};
+  var itemsGroup = items.reduce((acc, item) => {
+    if (item.stackId == null) {
+      return acc;
+    }
+    var stack = acc[item.stackId];
+    if (stack == null) {
+      stack = [];
+    }
+    stack.push(item);
+    acc[item.stackId] = stack;
+    return acc;
+  }, initialItemsGroups);
+  return Object.fromEntries(Object.entries(itemsGroup).map(_ref2 => {
+    var [stackId, graphicalItems] = _ref2;
+    var orderedGraphicalItems = reverseStackOrder ? [...graphicalItems].reverse() : graphicalItems;
+    var dataKeys = orderedGraphicalItems.map(getStackSeriesIdentifier);
+    return [stackId, {
+      // @ts-expect-error getStackedData requires that the input is array of objects, Recharts does not test for that
+      stackedData: getStackedData(displayedData, dataKeys, stackOffsetType),
+      graphicalItems: orderedGraphicalItems
+    }];
+  }));
+};
+
+/**
+ * Stack groups are groups of graphical items that stack on each other.
+ * Stack is a function of axis type (X, Y), axis ID, and stack ID.
+ * Graphical items that do not have a stack ID are not going to be present in stack groups.
+ */
+var selectStackGroups = createSelector([selectDisplayedStackedData, selectStackedCartesianItemsSettings, selectStackOffsetType, selectReverseStackOrder], combineStackGroups);
+var combineDomainOfStackGroups = (stackGroups, _ref3, axisType, domainFromUserPreference) => {
+  var {
+    dataStartIndex,
+    dataEndIndex
+  } = _ref3;
+  if (domainFromUserPreference != null) {
+    // User has specified a domain, so we respect that and we can skip computing anything else
+    return undefined;
+  }
+  if (axisType === 'zAxis') {
+    // ZAxis ignores stacks
+    return undefined;
+  }
+  var domainOfStackGroups = getDomainOfStackGroups(stackGroups, dataStartIndex, dataEndIndex);
+  if (domainOfStackGroups != null && domainOfStackGroups[0] === 0 && domainOfStackGroups[1] === 0) {
+    return undefined;
+  }
+  return domainOfStackGroups;
+};
+var selectAllowsDataOverflow = createSelector([selectBaseAxis], axisSettings => axisSettings.allowDataOverflow);
+var getDomainDefinition = axisSettings => {
+  var _axisSettings$domain;
+  if (axisSettings == null || !('domain' in axisSettings)) {
+    return defaultNumericDomain;
+  }
+  if (axisSettings.domain != null) {
+    return axisSettings.domain;
+  }
+  if ('ticks' in axisSettings && axisSettings.ticks != null) {
+    if (axisSettings.type === 'number') {
+      var allValues = onlyAllowNumbers(axisSettings.ticks);
+      return [Math.min(...allValues), Math.max(...allValues)];
+    }
+    if (axisSettings.type === 'category') {
+      return axisSettings.ticks.map(String);
+    }
+  }
+  return (_axisSettings$domain = axisSettings === null || axisSettings === void 0 ? void 0 : axisSettings.domain) !== null && _axisSettings$domain !== void 0 ? _axisSettings$domain : defaultNumericDomain;
+};
+var selectDomainDefinition = createSelector([selectBaseAxis], getDomainDefinition);
+
+/**
+ * Under certain circumstances, we can determine the domain without looking at the data at all.
+ * This is the case when the domain is explicitly specified as numbers, or when it is specified
+ * as 'auto' or 'dataMin'/'dataMax' and data overflow is not allowed.
+ *
+ * In that case, this function will return the domain, otherwise it returns undefined.
+ *
+ * This is an optimization to avoid unnecessary data processing.
+ * @param state
+ * @param axisType
+ * @param axisId
+ * @param isPanorama
+ */
+var selectDomainFromUserPreference = createSelector([selectDomainDefinition, selectAllowsDataOverflow], numericalDomainSpecifiedWithoutRequiringData);
+var selectDomainOfStackGroups = createSelector([selectStackGroups, selectChartDataWithIndexes, pickAxisType, selectDomainFromUserPreference], combineDomainOfStackGroups, {
+  memoizeOptions: {
+    resultEqualityCheck: numberDomainEqualityCheck
+  }
+});
+var selectAllErrorBarSettings = state => state.errorBars;
+var combineRelevantErrorBarSettings = (cartesianItemsSettings, allErrorBarSettings, axisType) => {
+  return cartesianItemsSettings.flatMap(item => {
+    return allErrorBarSettings[item.id];
+  }).filter(Boolean).filter(e => {
+    return isErrorBarRelevantForAxisType(axisType, e);
+  });
+};
+var mergeDomains = function mergeDomains() {
+  for (var _len = arguments.length, domains = new Array(_len), _key = 0; _key < _len; _key++) {
+    domains[_key] = arguments[_key];
+  }
+  var allDomains = domains.filter(Boolean);
+  if (allDomains.length === 0) {
+    return undefined;
+  }
+  var allValues = allDomains.flat();
+  var min = Math.min(...allValues);
+  var max = Math.max(...allValues);
+  return [min, max];
+};
+var combineDomainOfAllAppliedNumericalValuesIncludingErrorValues = (data, axisSettings, items, errorBars, axisType) => {
+  var lowerEnd, upperEnd;
+  if (items.length > 0) {
+    data.forEach(entry => {
+      items.forEach(item => {
+        var _errorBars$item$id, _axisSettings$dataKey;
+        var relevantErrorBars = (_errorBars$item$id = errorBars[item.id]) === null || _errorBars$item$id === void 0 ? void 0 : _errorBars$item$id.filter(errorBar => isErrorBarRelevantForAxisType(axisType, errorBar));
+        var valueByDataKey = getValueByDataKey(entry, (_axisSettings$dataKey = axisSettings.dataKey) !== null && _axisSettings$dataKey !== void 0 ? _axisSettings$dataKey : item.dataKey);
+        var errorDomain = getErrorDomainByDataKey(entry, valueByDataKey, relevantErrorBars);
+        if (errorDomain.length >= 2) {
+          var localLower = Math.min(...errorDomain);
+          var localUpper = Math.max(...errorDomain);
+          if (lowerEnd == null || localLower < lowerEnd) {
+            lowerEnd = localLower;
+          }
+          if (upperEnd == null || localUpper > upperEnd) {
+            upperEnd = localUpper;
+          }
+        }
+        var dataValueDomain = makeDomain(valueByDataKey);
+        if (dataValueDomain != null) {
+          lowerEnd = lowerEnd == null ? dataValueDomain[0] : Math.min(lowerEnd, dataValueDomain[0]);
+          upperEnd = upperEnd == null ? dataValueDomain[1] : Math.max(upperEnd, dataValueDomain[1]);
+        }
+      });
+    });
+  }
+  if ((axisSettings === null || axisSettings === void 0 ? void 0 : axisSettings.dataKey) != null) {
+    data.forEach(item => {
+      var dataValueDomain = makeDomain(getValueByDataKey(item, axisSettings.dataKey));
+      if (dataValueDomain != null) {
+        lowerEnd = lowerEnd == null ? dataValueDomain[0] : Math.min(lowerEnd, dataValueDomain[0]);
+        upperEnd = upperEnd == null ? dataValueDomain[1] : Math.max(upperEnd, dataValueDomain[1]);
+      }
+    });
+  }
+  if (isWellBehavedNumber(lowerEnd) && isWellBehavedNumber(upperEnd)) {
+    return [lowerEnd, upperEnd];
+  }
+  return undefined;
+};
+var selectDomainOfAllAppliedNumericalValuesIncludingErrorValues = createSelector([selectDisplayedData, selectBaseAxis, selectCartesianItemsSettingsExceptStacked, selectAllErrorBarSettings, pickAxisType], combineDomainOfAllAppliedNumericalValuesIncludingErrorValues, {
+  memoizeOptions: {
+    resultEqualityCheck: numberDomainEqualityCheck
+  }
+});
+function onlyAllowNumbersAndStringsAndDates(item) {
+  var {
+    value
+  } = item;
+  if (isNumOrStr(value) || value instanceof Date) {
+    return value;
+  }
+  return undefined;
+}
+var computeDomainOfTypeCategory = (allDataSquished, axisSettings, isCategorical) => {
+  var categoricalDomain = allDataSquished.map(onlyAllowNumbersAndStringsAndDates).filter(v => v != null);
+  if (isCategorical && (axisSettings.dataKey == null || axisSettings.allowDuplicatedCategory && hasDuplicate(categoricalDomain))) {
+    /*
+     * 1. In an absence of dataKey, Recharts will use array indexes as its categorical domain
+     * 2. When category axis has duplicated text, serial numbers are used to generate scale
+     */
+    return range(0, allDataSquished.length);
+  }
+  if (axisSettings.allowDuplicatedCategory) {
+    return categoricalDomain;
+  }
+  return Array.from(new Set(categoricalDomain));
+};
+var selectReferenceDots = state => state.referenceElements.dots;
+var filterReferenceElements = (elements, axisType, axisId) => {
+  return elements.filter(el => el.ifOverflow === 'extendDomain').filter(el => {
+    if (axisType === 'xAxis') {
+      return el.xAxisId === axisId;
+    }
+    return el.yAxisId === axisId;
+  });
+};
+var selectReferenceDotsByAxis = createSelector([selectReferenceDots, pickAxisType, pickAxisId], filterReferenceElements);
+var selectReferenceAreas = state => state.referenceElements.areas;
+var selectReferenceAreasByAxis = createSelector([selectReferenceAreas, pickAxisType, pickAxisId], filterReferenceElements);
+var selectReferenceLines = state => state.referenceElements.lines;
+var selectReferenceLinesByAxis = createSelector([selectReferenceLines, pickAxisType, pickAxisId], filterReferenceElements);
+var combineDotsDomain = (dots, axisType) => {
+  if (dots == null) {
+    return undefined;
+  }
+  var allCoords = onlyAllowNumbers(dots.map(dot => axisType === 'xAxis' ? dot.x : dot.y));
+  if (allCoords.length === 0) {
+    return undefined;
+  }
+  return [Math.min(...allCoords), Math.max(...allCoords)];
+};
+var selectReferenceDotsDomain = createSelector(selectReferenceDotsByAxis, pickAxisType, combineDotsDomain);
+var combineAreasDomain = (areas, axisType) => {
+  if (areas == null) {
+    return undefined;
+  }
+  var allCoords = onlyAllowNumbers(areas.flatMap(area => [axisType === 'xAxis' ? area.x1 : area.y1, axisType === 'xAxis' ? area.x2 : area.y2]));
+  if (allCoords.length === 0) {
+    return undefined;
+  }
+  return [Math.min(...allCoords), Math.max(...allCoords)];
+};
+var selectReferenceAreasDomain = createSelector([selectReferenceAreasByAxis, pickAxisType], combineAreasDomain);
+function extractXCoordinates(line) {
+  var _line$segment;
+  if (line.x != null) {
+    return onlyAllowNumbers([line.x]);
+  }
+  var segmentCoordinates = (_line$segment = line.segment) === null || _line$segment === void 0 ? void 0 : _line$segment.map(s => s.x);
+  if (segmentCoordinates == null || segmentCoordinates.length === 0) {
+    return [];
+  }
+  return onlyAllowNumbers(segmentCoordinates);
+}
+function extractYCoordinates(line) {
+  var _line$segment2;
+  if (line.y != null) {
+    return onlyAllowNumbers([line.y]);
+  }
+  var segmentCoordinates = (_line$segment2 = line.segment) === null || _line$segment2 === void 0 ? void 0 : _line$segment2.map(s => s.y);
+  if (segmentCoordinates == null || segmentCoordinates.length === 0) {
+    return [];
+  }
+  return onlyAllowNumbers(segmentCoordinates);
+}
+var combineLinesDomain = (lines, axisType) => {
+  if (lines == null) {
+    return undefined;
+  }
+  var allCoords = lines.flatMap(line => axisType === 'xAxis' ? extractXCoordinates(line) : extractYCoordinates(line));
+  if (allCoords.length === 0) {
+    return undefined;
+  }
+  return [Math.min(...allCoords), Math.max(...allCoords)];
+};
+var selectReferenceLinesDomain = createSelector([selectReferenceLinesByAxis, pickAxisType], combineLinesDomain);
+var selectReferenceElementsDomain = createSelector(selectReferenceDotsDomain, selectReferenceLinesDomain, selectReferenceAreasDomain, (dotsDomain, linesDomain, areasDomain) => {
+  return mergeDomains(dotsDomain, areasDomain, linesDomain);
+});
+var combineNumericalDomain = (axisSettings, domainDefinition, domainFromUserPreference, domainOfStackGroups, dataAndErrorBarsDomain, referenceElementsDomain, layout, axisType) => {
+  if (domainFromUserPreference != null) {
+    // We're done! No need to compute anything else.
+    return domainFromUserPreference;
+  }
+  var shouldIncludeDomainOfStackGroups = layout === 'vertical' && axisType === 'xAxis' || layout === 'horizontal' && axisType === 'yAxis';
+  var mergedDomains = shouldIncludeDomainOfStackGroups ? mergeDomains(domainOfStackGroups, referenceElementsDomain, dataAndErrorBarsDomain) : mergeDomains(referenceElementsDomain, dataAndErrorBarsDomain);
+  return parseNumericalUserDomain(domainDefinition, mergedDomains, axisSettings.allowDataOverflow);
+};
+var selectNumericalDomain = createSelector([selectBaseAxis, selectDomainDefinition, selectDomainFromUserPreference, selectDomainOfStackGroups, selectDomainOfAllAppliedNumericalValuesIncludingErrorValues, selectReferenceElementsDomain, selectChartLayout, pickAxisType], combineNumericalDomain, {
+  memoizeOptions: {
+    resultEqualityCheck: numberDomainEqualityCheck
+  }
+});
+
+/**
+ * Expand by design maps everything between 0 and 1,
+ * there is nothing to compute.
+ * See https://d3js.org/d3-shape/stack#stack-offsets
+ */
+var expandDomain = [0, 1];
+var combineAxisDomain = (axisSettings, layout, displayedData, allAppliedValues, stackOffsetType, axisType, numericalDomain) => {
+  if ((axisSettings == null || displayedData == null || displayedData.length === 0) && numericalDomain === undefined) {
+    return undefined;
+  }
+  var {
+    dataKey,
+    type
+  } = axisSettings;
+  var isCategorical = isCategoricalAxis(layout, axisType);
+  if (isCategorical && dataKey == null) {
+    var _displayedData$length;
+    return range(0, (_displayedData$length = displayedData === null || displayedData === void 0 ? void 0 : displayedData.length) !== null && _displayedData$length !== void 0 ? _displayedData$length : 0);
+  }
+  if (type === 'category') {
+    return computeDomainOfTypeCategory(allAppliedValues, axisSettings, isCategorical);
+  }
+  if (stackOffsetType === 'expand') {
+    return expandDomain;
+  }
+  return numericalDomain;
+};
+var selectAxisDomain = createSelector([selectBaseAxis, selectChartLayout, selectDisplayedData, selectAllAppliedValues, selectStackOffsetType, pickAxisType, selectNumericalDomain], combineAxisDomain);
+function isSupportedScaleName(name) {
+  return name in d3Scale;
+}
+var combineRealScaleType = (axisConfig, hasBar, chartType) => {
+  if (axisConfig == null) {
+    return undefined;
+  }
+  var {
+    scale,
+    type
+  } = axisConfig;
+  if (scale === 'auto') {
+    if (type === 'category' && chartType && (chartType.indexOf('LineChart') >= 0 || chartType.indexOf('AreaChart') >= 0 || chartType.indexOf('ComposedChart') >= 0 && !hasBar)) {
+      return 'point';
+    }
+    if (type === 'category') {
+      return 'band';
+    }
+    return 'linear';
+  }
+  if (typeof scale === 'string') {
+    var name = "scale".concat(upperFirst(scale));
+    return isSupportedScaleName(name) ? name : 'point';
+  }
+  return undefined;
+};
+var selectRealScaleType = createSelector([selectBaseAxis, selectHasBar, selectChartName], combineRealScaleType);
+function combineScaleFunction(axis, realScaleType, axisDomain, axisRange) {
+  if (axisDomain == null || axisRange == null) {
+    return undefined;
+  }
+  if (typeof axis.scale === 'function') {
+    return rechartsScaleFactory(axis.scale, axisDomain, axisRange);
+  }
+  return rechartsScaleFactory(realScaleType, axisDomain, axisRange);
+}
+var combineNiceTicks = (axisDomain, axisSettings, realScaleType) => {
+  var domainDefinition = getDomainDefinition(axisSettings);
+  if (realScaleType !== 'auto' && realScaleType !== 'linear') {
+    return undefined;
+  }
+  if (axisSettings != null && axisSettings.tickCount && Array.isArray(domainDefinition) && (domainDefinition[0] === 'auto' || domainDefinition[1] === 'auto') && isWellFormedNumberDomain(axisDomain)) {
+    return getNiceTickValues(axisDomain, axisSettings.tickCount, axisSettings.allowDecimals);
+  }
+  if (axisSettings != null && axisSettings.tickCount && axisSettings.type === 'number' && isWellFormedNumberDomain(axisDomain)) {
+    return getTickValuesFixedDomain(axisDomain, axisSettings.tickCount, axisSettings.allowDecimals);
+  }
+  return undefined;
+};
+var selectNiceTicks = createSelector([selectAxisDomain, selectRenderableAxisSettings, selectRealScaleType], combineNiceTicks);
+var combineAxisDomainWithNiceTicks = (axisSettings, domain, niceTicks, axisType) => {
+  if (
+  /*
+   * Angle axis for some reason uses nice ticks when rendering axis tick labels,
+   * but doesn't use nice ticks for extending domain like all the other axes do.
+   * Not really sure why? Is there a good reason,
+   * or is it just because someone added support for nice ticks to the other axes and forgot this one?
+   */
+  axisType !== 'angleAxis' && (axisSettings === null || axisSettings === void 0 ? void 0 : axisSettings.type) === 'number' && isWellFormedNumberDomain(domain) && Array.isArray(niceTicks) && niceTicks.length > 0) {
+    var _niceTicks$, _niceTicks;
+    var minFromDomain = domain[0];
+    var minFromTicks = (_niceTicks$ = niceTicks[0]) !== null && _niceTicks$ !== void 0 ? _niceTicks$ : 0;
+    var maxFromDomain = domain[1];
+    var maxFromTicks = (_niceTicks = niceTicks[niceTicks.length - 1]) !== null && _niceTicks !== void 0 ? _niceTicks : 0;
+    return [Math.min(minFromDomain, minFromTicks), Math.max(maxFromDomain, maxFromTicks)];
+  }
+  return domain;
+};
+var selectAxisDomainIncludingNiceTicks = createSelector([selectBaseAxis, selectAxisDomain, selectNiceTicks, pickAxisType], combineAxisDomainWithNiceTicks);
+
+/**
+ * Returns the smallest gap, between two numbers in the data, as a ratio of the whole range (max - min).
+ * Ignores domain provided by user and only considers domain from data.
+ *
+ * The result is a number between 0 and 1.
+ */
+var selectSmallestDistanceBetweenValues = createSelector(selectAllAppliedValues, selectBaseAxis, (allDataSquished, axisSettings) => {
+  if (!axisSettings || axisSettings.type !== 'number') {
+    return undefined;
+  }
+  var smallestDistanceBetweenValues = Infinity;
+  var sortedValues = Array.from(onlyAllowNumbers(allDataSquished.map(d => d.value))).sort((a, b) => a - b);
+  var first = sortedValues[0];
+  var last = sortedValues[sortedValues.length - 1];
+  if (first == null || last == null) {
+    return Infinity;
+  }
+  var diff = last - first;
+  if (diff === 0) {
+    return Infinity;
+  }
+  // Only do n - 1 distance calculations because there's only n - 1 distances between n values.
+  for (var i = 0; i < sortedValues.length - 1; i++) {
+    var curr = sortedValues[i];
+    var next = sortedValues[i + 1];
+    if (curr == null || next == null) {
+      continue;
+    }
+    var distance = next - curr;
+    smallestDistanceBetweenValues = Math.min(smallestDistanceBetweenValues, distance);
+  }
+  return smallestDistanceBetweenValues / diff;
+});
+var selectCalculatedPadding = createSelector(selectSmallestDistanceBetweenValues, selectChartLayout, selectBarCategoryGap, selectChartOffsetInternal, (_1, _2, _3, _4, padding) => padding, (smallestDistanceInPercent, layout, barCategoryGap, offset, padding) => {
+  if (!isWellBehavedNumber(smallestDistanceInPercent)) {
+    return 0;
+  }
+  var rangeWidth = layout === 'vertical' ? offset.height : offset.width;
+  if (padding === 'gap') {
+    return smallestDistanceInPercent * rangeWidth / 2;
+  }
+  if (padding === 'no-gap') {
+    var gap = getPercentValue(barCategoryGap, smallestDistanceInPercent * rangeWidth);
+    var halfBand = smallestDistanceInPercent * rangeWidth / 2;
+    return halfBand - gap - (halfBand - gap) / rangeWidth * gap;
+  }
+  return 0;
+});
+var selectCalculatedXAxisPadding = (state, axisId, isPanorama) => {
+  var xAxisSettings = selectXAxisSettings(state, axisId);
+  if (xAxisSettings == null || typeof xAxisSettings.padding !== 'string') {
+    return 0;
+  }
+  return selectCalculatedPadding(state, 'xAxis', axisId, isPanorama, xAxisSettings.padding);
+};
+var selectCalculatedYAxisPadding = (state, axisId, isPanorama) => {
+  var yAxisSettings = selectYAxisSettings(state, axisId);
+  if (yAxisSettings == null || typeof yAxisSettings.padding !== 'string') {
+    return 0;
+  }
+  return selectCalculatedPadding(state, 'yAxis', axisId, isPanorama, yAxisSettings.padding);
+};
+var selectXAxisPadding = createSelector(selectXAxisSettings, selectCalculatedXAxisPadding, (xAxisSettings, calculated) => {
+  var _padding$left, _padding$right;
+  if (xAxisSettings == null) {
+    return {
+      left: 0,
+      right: 0
+    };
+  }
+  var {
+    padding
+  } = xAxisSettings;
+  if (typeof padding === 'string') {
+    return {
+      left: calculated,
+      right: calculated
+    };
+  }
+  return {
+    left: ((_padding$left = padding.left) !== null && _padding$left !== void 0 ? _padding$left : 0) + calculated,
+    right: ((_padding$right = padding.right) !== null && _padding$right !== void 0 ? _padding$right : 0) + calculated
+  };
+});
+var selectYAxisPadding = createSelector(selectYAxisSettings, selectCalculatedYAxisPadding, (yAxisSettings, calculated) => {
+  var _padding$top, _padding$bottom;
+  if (yAxisSettings == null) {
+    return {
+      top: 0,
+      bottom: 0
+    };
+  }
+  var {
+    padding
+  } = yAxisSettings;
+  if (typeof padding === 'string') {
+    return {
+      top: calculated,
+      bottom: calculated
+    };
+  }
+  return {
+    top: ((_padding$top = padding.top) !== null && _padding$top !== void 0 ? _padding$top : 0) + calculated,
+    bottom: ((_padding$bottom = padding.bottom) !== null && _padding$bottom !== void 0 ? _padding$bottom : 0) + calculated
+  };
+});
+var combineXAxisRange = createSelector([selectChartOffsetInternal, selectXAxisPadding, selectBrushDimensions, selectBrushSettings, (_state, _axisId, isPanorama) => isPanorama], (offset, padding, brushDimensions, _ref4, isPanorama) => {
+  var {
+    padding: brushPadding
+  } = _ref4;
+  if (isPanorama) {
+    return [brushPadding.left, brushDimensions.width - brushPadding.right];
+  }
+  return [offset.left + padding.left, offset.left + offset.width - padding.right];
+});
+var combineYAxisRange = createSelector([selectChartOffsetInternal, selectChartLayout, selectYAxisPadding, selectBrushDimensions, selectBrushSettings, (_state, _axisId, isPanorama) => isPanorama], (offset, layout, padding, brushDimensions, _ref5, isPanorama) => {
+  var {
+    padding: brushPadding
+  } = _ref5;
+  if (isPanorama) {
+    return [brushDimensions.height - brushPadding.bottom, brushPadding.top];
+  }
+  if (layout === 'horizontal') {
+    return [offset.top + offset.height - padding.bottom, offset.top + padding.top];
+  }
+  return [offset.top + padding.top, offset.top + offset.height - padding.bottom];
+});
+var selectAxisRange = (state, axisType, axisId, isPanorama) => {
+  var _selectZAxisSettings;
+  switch (axisType) {
+    case 'xAxis':
+      return combineXAxisRange(state, axisId, isPanorama);
+    case 'yAxis':
+      return combineYAxisRange(state, axisId, isPanorama);
+    case 'zAxis':
+      return (_selectZAxisSettings = selectZAxisSettings(state, axisId)) === null || _selectZAxisSettings === void 0 ? void 0 : _selectZAxisSettings.range;
+    case 'angleAxis':
+      return selectAngleAxisRange(state);
+    case 'radiusAxis':
+      return selectRadiusAxisRange(state, axisId);
+    default:
+      return undefined;
+  }
+};
+var selectAxisRangeWithReverse = createSelector([selectBaseAxis, selectAxisRange], combineAxisRangeWithReverse);
+var selectCheckedAxisDomain = createSelector([selectRealScaleType, selectAxisDomainIncludingNiceTicks], combineCheckedDomain);
+var selectAxisScale = createSelector([selectBaseAxis, selectRealScaleType, selectCheckedAxisDomain, selectAxisRangeWithReverse], combineScaleFunction);
+var selectErrorBarsSettings = createSelector([selectCartesianItemsSettings, selectAllErrorBarSettings, pickAxisType], combineRelevantErrorBarSettings);
+function compareIds(a, b) {
+  if (a.id < b.id) {
+    return -1;
+  }
+  if (a.id > b.id) {
+    return 1;
+  }
+  return 0;
+}
+var pickAxisOrientation = (_state, orientation) => orientation;
+var pickMirror = (_state, _orientation, mirror) => mirror;
+var selectAllXAxesWithOffsetType = createSelector(selectAllXAxes, pickAxisOrientation, pickMirror, (allAxes, orientation, mirror) => allAxes.filter(axis => axis.orientation === orientation).filter(axis => axis.mirror === mirror).sort(compareIds));
+var selectAllYAxesWithOffsetType = createSelector(selectAllYAxes, pickAxisOrientation, pickMirror, (allAxes, orientation, mirror) => allAxes.filter(axis => axis.orientation === orientation).filter(axis => axis.mirror === mirror).sort(compareIds));
+var getXAxisSize = (offset, axisSettings) => {
+  return {
+    width: offset.width,
+    height: axisSettings.height
+  };
+};
+var getYAxisSize = (offset, axisSettings) => {
+  var width = typeof axisSettings.width === 'number' ? axisSettings.width : DEFAULT_Y_AXIS_WIDTH;
+  return {
+    width,
+    height: offset.height
+  };
+};
+var selectXAxisSize = createSelector(selectChartOffsetInternal, selectXAxisSettings, getXAxisSize);
+var combineXAxisPositionStartingPoint = (offset, orientation, chartHeight) => {
+  switch (orientation) {
+    case 'top':
+      return offset.top;
+    case 'bottom':
+      return chartHeight - offset.bottom;
+    default:
+      return 0;
+  }
+};
+var combineYAxisPositionStartingPoint = (offset, orientation, chartWidth) => {
+  switch (orientation) {
+    case 'left':
+      return offset.left;
+    case 'right':
+      return chartWidth - offset.right;
+    default:
+      return 0;
+  }
+};
+var selectAllXAxesOffsetSteps = createSelector(selectChartHeight, selectChartOffsetInternal, selectAllXAxesWithOffsetType, pickAxisOrientation, pickMirror, (chartHeight, offset, allAxesWithSameOffsetType, orientation, mirror) => {
+  var steps = {};
+  var position;
+  allAxesWithSameOffsetType.forEach(axis => {
+    var axisSize = getXAxisSize(offset, axis);
+    if (position == null) {
+      position = combineXAxisPositionStartingPoint(offset, orientation, chartHeight);
+    }
+    var needSpace = orientation === 'top' && !mirror || orientation === 'bottom' && mirror;
+    steps[axis.id] = position - Number(needSpace) * axisSize.height;
+    position += (needSpace ? -1 : 1) * axisSize.height;
+  });
+  return steps;
+});
+var selectAllYAxesOffsetSteps = createSelector(selectChartWidth, selectChartOffsetInternal, selectAllYAxesWithOffsetType, pickAxisOrientation, pickMirror, (chartWidth, offset, allAxesWithSameOffsetType, orientation, mirror) => {
+  var steps = {};
+  var position;
+  allAxesWithSameOffsetType.forEach(axis => {
+    var axisSize = getYAxisSize(offset, axis);
+    if (position == null) {
+      position = combineYAxisPositionStartingPoint(offset, orientation, chartWidth);
+    }
+    var needSpace = orientation === 'left' && !mirror || orientation === 'right' && mirror;
+    steps[axis.id] = position - Number(needSpace) * axisSize.width;
+    position += (needSpace ? -1 : 1) * axisSize.width;
+  });
+  return steps;
+});
+var selectXAxisOffsetSteps = (state, axisId) => {
+  var axisSettings = selectXAxisSettings(state, axisId);
+  if (axisSettings == null) {
+    return undefined;
+  }
+  return selectAllXAxesOffsetSteps(state, axisSettings.orientation, axisSettings.mirror);
+};
+var selectXAxisPosition = createSelector([selectChartOffsetInternal, selectXAxisSettings, selectXAxisOffsetSteps, (_, axisId) => axisId], (offset, axisSettings, allSteps, axisId) => {
+  if (axisSettings == null) {
+    return undefined;
+  }
+  var stepOfThisAxis = allSteps === null || allSteps === void 0 ? void 0 : allSteps[axisId];
+  if (stepOfThisAxis == null) {
+    return {
+      x: offset.left,
+      y: 0
+    };
+  }
+  return {
+    x: offset.left,
+    y: stepOfThisAxis
+  };
+});
+var selectYAxisOffsetSteps = (state, axisId) => {
+  var axisSettings = selectYAxisSettings(state, axisId);
+  if (axisSettings == null) {
+    return undefined;
+  }
+  return selectAllYAxesOffsetSteps(state, axisSettings.orientation, axisSettings.mirror);
+};
+var selectYAxisPosition = createSelector([selectChartOffsetInternal, selectYAxisSettings, selectYAxisOffsetSteps, (_, axisId) => axisId], (offset, axisSettings, allSteps, axisId) => {
+  if (axisSettings == null) {
+    return undefined;
+  }
+  var stepOfThisAxis = allSteps === null || allSteps === void 0 ? void 0 : allSteps[axisId];
+  if (stepOfThisAxis == null) {
+    return {
+      x: 0,
+      y: offset.top
+    };
+  }
+  return {
+    x: stepOfThisAxis,
+    y: offset.top
+  };
+});
+var selectYAxisSize = createSelector(selectChartOffsetInternal, selectYAxisSettings, (offset, axisSettings) => {
+  var width = typeof axisSettings.width === 'number' ? axisSettings.width : DEFAULT_Y_AXIS_WIDTH;
+  return {
+    width,
+    height: offset.height
+  };
+});
+var selectCartesianAxisSize = (state, axisType, axisId) => {
+  switch (axisType) {
+    case 'xAxis':
+      {
+        return selectXAxisSize(state, axisId).width;
+      }
+    case 'yAxis':
+      {
+        return selectYAxisSize(state, axisId).height;
+      }
+    default:
+      {
+        return undefined;
+      }
+  }
+};
+var combineDuplicateDomain = (chartLayout, appliedValues, axis, axisType) => {
+  if (axis == null) {
+    return undefined;
+  }
+  var {
+    allowDuplicatedCategory,
+    type,
+    dataKey
+  } = axis;
+  var isCategorical = isCategoricalAxis(chartLayout, axisType);
+  var allData = appliedValues.map(av => av.value);
+  if (dataKey && isCategorical && type === 'category' && allowDuplicatedCategory && hasDuplicate(allData)) {
+    return allData;
+  }
+  return undefined;
+};
+var selectDuplicateDomain = createSelector([selectChartLayout, selectAllAppliedValues, selectBaseAxis, pickAxisType], combineDuplicateDomain);
+var combineCategoricalDomain = (layout, appliedValues, axis, axisType) => {
+  if (axis == null || axis.dataKey == null) {
+    return undefined;
+  }
+  var {
+    type,
+    scale
+  } = axis;
+  var isCategorical = isCategoricalAxis(layout, axisType);
+  if (isCategorical && (type === 'number' || scale !== 'auto')) {
+    return appliedValues.map(d => d.value);
+  }
+  return undefined;
+};
+var selectCategoricalDomain = createSelector([selectChartLayout, selectAllAppliedValues, selectRenderableAxisSettings, pickAxisType], combineCategoricalDomain);
+var selectAxisPropsNeededForCartesianGridTicksGenerator = createSelector([selectChartLayout, selectCartesianAxisSettings, selectRealScaleType, selectAxisScale, selectDuplicateDomain, selectCategoricalDomain, selectAxisRange, selectNiceTicks, pickAxisType], (layout, axis, realScaleType, scale, duplicateDomain, categoricalDomain, axisRange, niceTicks, axisType) => {
+  if (axis == null) {
+    return undefined;
+  }
+  var isCategorical = isCategoricalAxis(layout, axisType);
+  return {
+    angle: axis.angle,
+    interval: axis.interval,
+    minTickGap: axis.minTickGap,
+    orientation: axis.orientation,
+    tick: axis.tick,
+    tickCount: axis.tickCount,
+    tickFormatter: axis.tickFormatter,
+    ticks: axis.ticks,
+    type: axis.type,
+    unit: axis.unit,
+    axisType,
+    categoricalDomain,
+    duplicateDomain,
+    isCategorical,
+    niceTicks,
+    range: axisRange,
+    realScaleType,
+    scale
+  };
+});
+
+/**
+ * Of on four almost identical implementations of tick generation.
+ * The four horsemen of tick generation are:
+ * - {@link selectTooltipAxisTicks}
+ * - {@link combineAxisTicks}
+ * - {@link getTicksOfAxis}.
+ * - {@link combineGraphicalItemTicks}
+ */
+var combineAxisTicks = (layout, axis, realScaleType, scale, niceTicks, axisRange, duplicateDomain, categoricalDomain, axisType) => {
+  if (axis == null || scale == null) {
+    return undefined;
+  }
+  var isCategorical = isCategoricalAxis(layout, axisType);
+  var {
+    type,
+    ticks,
+    tickCount
+  } = axis;
+  var offsetForBand =
+  // @ts-expect-error This is testing for `scaleBand` but for band axis the type is reported as `band` so this looks like a dead code with a workaround elsewhere?
+  realScaleType === 'scaleBand' && typeof scale.bandwidth === 'function' ? scale.bandwidth() / 2 : 2;
+  var offset = type === 'category' && scale.bandwidth ? scale.bandwidth() / offsetForBand : 0;
+  offset = axisType === 'angleAxis' && axisRange != null && axisRange.length >= 2 ? mathSign(axisRange[0] - axisRange[1]) * 2 * offset : offset;
+
+  // The ticks set by user should only affect the ticks adjacent to axis line
+  var ticksOrNiceTicks = ticks || niceTicks;
+  if (ticksOrNiceTicks) {
+    return ticksOrNiceTicks.map((entry, index) => {
+      var scaleContent = duplicateDomain ? duplicateDomain.indexOf(entry) : entry;
+      var scaled = scale.map(scaleContent);
+      if (!isWellBehavedNumber(scaled)) {
+        return null;
+      }
+      return {
+        index,
+        coordinate: scaled + offset,
+        value: entry,
+        offset
+      };
+    }).filter(isNotNil);
+  }
+
+  // When axis is a categorical axis, but the type of axis is number or the scale of axis is not "auto"
+  if (isCategorical && categoricalDomain) {
+    return categoricalDomain.map((entry, index) => {
+      var scaled = scale.map(entry);
+      if (!isWellBehavedNumber(scaled)) {
+        return null;
+      }
+      return {
+        coordinate: scaled + offset,
+        value: entry,
+        index,
+        offset
+      };
+    }).filter(isNotNil);
+  }
+  if (scale.ticks) {
+    return scale.ticks(tickCount).map((entry, index) => {
+      var scaled = scale.map(entry);
+      if (!isWellBehavedNumber(scaled)) {
+        return null;
+      }
+      return {
+        coordinate: scaled + offset,
+        value: entry,
+        index,
+        offset
+      };
+    }).filter(isNotNil);
+  }
+
+  // When axis has duplicated text, serial numbers are used to generate scale
+  return scale.domain().map((entry, index) => {
+    var scaled = scale.map(entry);
+    if (!isWellBehavedNumber(scaled)) {
+      return null;
+    }
+    return {
+      coordinate: scaled + offset,
+      // @ts-expect-error can't use Date as index
+      value: duplicateDomain ? duplicateDomain[entry] : entry,
+      index,
+      offset
+    };
+  }).filter(isNotNil);
+};
+var selectTicksOfAxis = createSelector([selectChartLayout, selectRenderableAxisSettings, selectRealScaleType, selectAxisScale, selectNiceTicks, selectAxisRange, selectDuplicateDomain, selectCategoricalDomain, pickAxisType], combineAxisTicks);
+
+/**
+ * Of on four almost identical implementations of tick generation.
+ * The four horsemen of tick generation are:
+ * - {@link selectTooltipAxisTicks}
+ * - {@link combineAxisTicks}
+ * - {@link getTicksOfAxis}.
+ * - {@link combineGraphicalItemTicks}
+ */
+var combineGraphicalItemTicks = (layout, axis, scale, axisRange, duplicateDomain, categoricalDomain, axisType) => {
+  if (axis == null || scale == null || axisRange == null || axisRange[0] === axisRange[1]) {
+    return undefined;
+  }
+  var isCategorical = isCategoricalAxis(layout, axisType);
+  var {
+    tickCount
+  } = axis;
+  var offset = 0;
+  offset = axisType === 'angleAxis' && (axisRange === null || axisRange === void 0 ? void 0 : axisRange.length) >= 2 ? mathSign(axisRange[0] - axisRange[1]) * 2 * offset : offset;
+
+  // When axis is a categorical axis, but the type of axis is number or the scale of axis is not "auto"
+  if (isCategorical && categoricalDomain) {
+    return categoricalDomain.map((entry, index) => {
+      var scaled = scale.map(entry);
+      if (!isWellBehavedNumber(scaled)) {
+        return null;
+      }
+      return {
+        coordinate: scaled + offset,
+        value: entry,
+        index,
+        offset
+      };
+    }).filter(isNotNil);
+  }
+  if (scale.ticks) {
+    return scale.ticks(tickCount).map((entry, index) => {
+      var scaled = scale.map(entry);
+      if (!isWellBehavedNumber(scaled)) {
+        return null;
+      }
+      return {
+        coordinate: scaled + offset,
+        value: entry,
+        index,
+        offset
+      };
+    }).filter(isNotNil);
+  }
+
+  // When axis has duplicated text, serial numbers are used to generate scale
+  return scale.domain().map((entry, index) => {
+    var scaled = scale.map(entry);
+    if (!isWellBehavedNumber(scaled)) {
+      return null;
+    }
+    return {
+      coordinate: scaled + offset,
+      // @ts-expect-error can't use unknown as index
+      value: duplicateDomain ? duplicateDomain[entry] : entry,
+      index,
+      offset
+    };
+  }).filter(isNotNil);
+};
+var selectTicksOfGraphicalItem = createSelector([selectChartLayout, selectRenderableAxisSettings, selectAxisScale, selectAxisRange, selectDuplicateDomain, selectCategoricalDomain, pickAxisType], combineGraphicalItemTicks);
+
+/**
+ * This is the internal representation of an axis along with its scale function.
+ * Here we have already computed the scale function for the axis,
+ * and replaced the union type of scale (string | function) with just the function type.
+ */
+
+var selectAxisWithScale = createSelector(selectBaseAxis, selectAxisScale, (axis, scale) => {
+  if (axis == null || scale == null) {
+    return undefined;
+  }
+  return _objectSpread(_objectSpread({}, axis), {}, {
+    scale
+  });
+});
+var selectZAxisScale = createSelector([selectBaseAxis, selectRealScaleType, selectAxisDomain, selectAxisRangeWithReverse], combineScaleFunction);
+var selectZAxisWithScale = createSelector((state, _axisType, axisId) => selectZAxisSettings(state, axisId), selectZAxisScale, (axis, scale) => {
+  if (axis == null || scale == null) {
+    return undefined;
+  }
+  return _objectSpread(_objectSpread({}, axis), {}, {
+    scale
+  });
+});
+
+/**
+ * We are also going to need to implement polar chart directions if we want to support keyboard controls for those.
+ */
+
+var selectChartDirection = createSelector([selectChartLayout, selectAllXAxes, selectAllYAxes], (layout, allXAxes, allYAxes) => {
+  switch (layout) {
+    case 'horizontal':
+      {
+        return allXAxes.some(axis => axis.reversed) ? 'right-to-left' : 'left-to-right';
+      }
+    case 'vertical':
+      {
+        return allYAxes.some(axis => axis.reversed) ? 'bottom-to-top' : 'top-to-bottom';
+      }
+    // TODO: make this better. For now, right arrow triggers "forward", left arrow "back"
+    // however, the tooltip moves an unintuitive direction because of how the indices are rendered
+    case 'centric':
+    case 'radial':
+      {
+        return 'left-to-right';
+      }
+    default:
+      {
+        return undefined;
+      }
+  }
+});
+
+export { combineAppliedValues, combineAreasDomain, combineAxisDomain, combineAxisDomainWithNiceTicks, combineAxisTicks, combineCategoricalDomain, combineDisplayedData, combineDomainOfAllAppliedNumericalValuesIncludingErrorValues, combineDomainOfStackGroups, combineDotsDomain, combineDuplicateDomain, combineGraphicalItemTicks, combineGraphicalItemsData, combineGraphicalItemsSettings, combineLinesDomain, combineNiceTicks, combineNumericalDomain, combineRealScaleType, combineScaleFunction, combineStackGroups, combineXAxisRange, combineYAxisRange, defaultNumericDomain, filterGraphicalNotStackedItems, filterReferenceElements, getDomainDefinition, getErrorDomainByDataKey, implicitXAxis, implicitYAxis, implicitZAxis, isErrorBarRelevantForAxisType, itemAxisPredicate, mergeDomains, selectAllAppliedValues, selectAllErrorBarSettings, selectAllXAxesOffsetSteps, selectAllYAxesOffsetSteps, selectAxisDomain, selectAxisDomainIncludingNiceTicks, selectAxisPropsNeededForCartesianGridTicksGenerator, selectAxisRange, selectAxisRangeWithReverse, selectAxisScale, selectAxisWithScale, selectBaseAxis, selectCalculatedXAxisPadding, selectCalculatedYAxisPadding, selectCartesianAxisSize, selectCartesianGraphicalItemsData, selectCartesianItemsSettings, selectCategoricalDomain, selectChartDirection, selectDisplayedData, selectDisplayedStackedData, selectDomainDefinition, selectDomainFromUserPreference, selectDomainOfStackGroups, selectDuplicateDomain, selectErrorBarsSettings, selectHasBar, selectNiceTicks, selectNumericalDomain, selectRealScaleType, selectReferenceAreas, selectReferenceAreasByAxis, selectReferenceDots, selectReferenceDotsByAxis, selectReferenceLines, selectReferenceLinesByAxis, selectRenderableAxisSettings, selectSmallestDistanceBetweenValues, selectStackGroups, selectStackedCartesianItemsSettings, selectTicksOfAxis, selectTicksOfGraphicalItem, selectTooltipAxis, selectTooltipAxisDataKey, selectUnfilteredCartesianItems, selectXAxisPosition, selectXAxisSettings, selectXAxisSettingsNoDefaults, selectXAxisSize, selectYAxisPosition, selectYAxisSettings, selectYAxisSettingsNoDefaults, selectYAxisSize, selectZAxisSettings, selectZAxisWithScale };
+//# sourceMappingURL=axisSelectors.js.map