@octanejs/recharts 0.1.0

package/src/state/selectors/combiners/combineTooltipPayload.js

@@ -0,0 +1,248 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/selectors/combiners/combineTooltipPayload.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+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);
+}
+import { findEntryInArray } from '../../../util/DataUtils';
+import { getTooltipEntry, getValueByDataKey } from '../../../util/ChartUtils';
+import { getSliced } from '../../../util/getSliced';
+function parseName(value) {
+	if (typeof value === 'string' || typeof value === 'number') {
+		return value;
+	}
+	return undefined;
+}
+function parseUnit(value) {
+	if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+		return value;
+	}
+	return undefined;
+}
+function parseDataKey(value) {
+	if (typeof value === 'string' || typeof value === 'number') {
+		return value;
+	}
+	if (typeof value === 'function') {
+		return (obj) => value(obj);
+	}
+	return undefined;
+}
+function parseColor(value) {
+	if (typeof value === 'string') {
+		return value;
+	}
+	return undefined;
+}
+function parseTooltipPayloadItem(item) {
+	if (item == null || typeof item !== 'object') {
+		return undefined;
+	}
+	var name = 'name' in item ? parseName(item.name) : undefined;
+	var unit = 'unit' in item ? parseUnit(item.unit) : undefined;
+	var dataKey = 'dataKey' in item ? parseDataKey(item.dataKey) : undefined;
+	var payload = 'payload' in item ? item.payload : undefined;
+	var color = 'color' in item ? parseColor(item.color) : undefined;
+	var fill = 'fill' in item ? parseColor(item.fill) : undefined;
+	return {
+		name,
+		unit,
+		dataKey,
+		payload,
+		color,
+		fill,
+	};
+}
+function selectFinalData(dataDefinedOnItem, dataDefinedOnChart) {
+	/*
+	 * If a payload has data specified directly from the graphical item, prefer that.
+	 * Otherwise, fill in data from the chart level, using the same index.
+	 */
+	if (dataDefinedOnItem != null) {
+		return dataDefinedOnItem;
+	}
+	return dataDefinedOnChart;
+}
+export var combineTooltipPayload = (
+	tooltipPayloadConfigurations,
+	activeIndex,
+	chartDataState,
+	tooltipAxisDataKey,
+	activeLabel,
+	tooltipPayloadSearcher,
+	tooltipEventType,
+) => {
+	if (activeIndex == null || tooltipPayloadSearcher == null) {
+		return undefined;
+	}
+	var chartData = chartDataState.chartData,
+		computedData = chartDataState.computedData,
+		dataStartIndex = chartDataState.dataStartIndex,
+		dataEndIndex = chartDataState.dataEndIndex;
+	var init = [];
+	return tooltipPayloadConfigurations.reduce((agg, _ref) => {
+		var _settings$dataKey;
+		var dataDefinedOnItem = _ref.dataDefinedOnItem,
+			settings = _ref.settings;
+		var finalData = selectFinalData(dataDefinedOnItem, chartData);
+		var sliced = Array.isArray(finalData)
+			? getSliced(finalData, dataStartIndex, dataEndIndex)
+			: finalData;
+		var finalDataKey =
+			(_settings$dataKey = settings === null || settings === void 0 ? void 0 : settings.dataKey) !==
+				null && _settings$dataKey !== void 0
+				? _settings$dataKey
+				: tooltipAxisDataKey;
+		// BaseAxisProps does not support nameKey but it could!
+		var finalNameKey = settings === null || settings === void 0 ? void 0 : settings.nameKey; // ?? tooltipAxis?.nameKey;
+		var tooltipPayload;
+		if (
+			tooltipAxisDataKey &&
+			Array.isArray(sliced) &&
+			/*
+			 * findEntryInArray won't work for Scatter because Scatter provides an array of arrays
+			 * as tooltip payloads and findEntryInArray is not prepared to handle that.
+			 * Sad but also ScatterChart only allows 'item' tooltipEventType
+			 * and also this is only a problem if there are multiple Scatters and each has its own data array
+			 * so let's fix that some other time.
+			 */
+			!Array.isArray(sliced[0]) &&
+			/*
+			 * If the tooltipEventType is 'axis', we should search for the dataKey in the sliced data
+			 * because thanks to allowDuplicatedCategory=false, the order of elements in the array
+			 * no longer matches the order of elements in the original data
+			 * and so we need to search by the active dataKey + label rather than by index.
+			 *
+			 * The same happens if multiple graphical items are present in the chart
+			 * and each of them has its own data array. Those arrays get concatenated
+			 * and again the tooltip index no longer matches the original data.
+			 *
+			 * On the other hand the tooltipEventType 'item' should always search by index
+			 * because we get the index from interacting over the individual elements
+			 * which is always accurate, irrespective of the allowDuplicatedCategory setting.
+			 */
+			tooltipEventType === 'axis'
+		) {
+			tooltipPayload = findEntryInArray(sliced, tooltipAxisDataKey, activeLabel);
+		} else {
+			/*
+			 * This is a problem because it assumes that the index is pointing to the displayed data
+			 * which it isn't because the index is pointing to the tooltip ticks array.
+			 * The above approach (with findEntryInArray) is the correct one, but it only works
+			 * if the axis dataKey is defined explicitly, and if the data is an array of objects.
+			 */
+			tooltipPayload = tooltipPayloadSearcher(sliced, activeIndex, computedData, finalNameKey);
+		}
+		if (Array.isArray(tooltipPayload)) {
+			tooltipPayload.forEach((item) => {
+				var _parsedItem$color, _parsedItem$fill;
+				var parsedItem = parseTooltipPayloadItem(item);
+				var itemName = parsedItem === null || parsedItem === void 0 ? void 0 : parsedItem.name;
+				var itemDataKey =
+					parsedItem === null || parsedItem === void 0 ? void 0 : parsedItem.dataKey;
+				var itemPayload =
+					parsedItem === null || parsedItem === void 0 ? void 0 : parsedItem.payload;
+				var newSettings = _objectSpread(
+					_objectSpread({}, settings),
+					{},
+					{
+						name: itemName,
+						unit: parsedItem === null || parsedItem === void 0 ? void 0 : parsedItem.unit,
+						// Preserve item-level color/fill from graphical items.
+						color:
+							(_parsedItem$color =
+								parsedItem === null || parsedItem === void 0 ? void 0 : parsedItem.color) !==
+								null && _parsedItem$color !== void 0
+								? _parsedItem$color
+								: settings === null || settings === void 0
+									? void 0
+									: settings.color,
+						fill:
+							(_parsedItem$fill =
+								parsedItem === null || parsedItem === void 0 ? void 0 : parsedItem.fill) !== null &&
+							_parsedItem$fill !== void 0
+								? _parsedItem$fill
+								: settings === null || settings === void 0
+									? void 0
+									: settings.fill,
+					},
+				);
+				agg.push(
+					getTooltipEntry({
+						tooltipEntrySettings: newSettings,
+						dataKey: itemDataKey,
+						payload: itemPayload,
+						value: getValueByDataKey(itemPayload, itemDataKey),
+						name: itemName == null ? undefined : String(itemName),
+					}),
+				);
+			});
+		} else {
+			var _getValueByDataKey;
+			// I am not quite sure why these two branches (Array vs Array of Arrays) have to behave differently - I imagine we should unify these. 3.x breaking change?
+			agg.push(
+				getTooltipEntry({
+					tooltipEntrySettings: settings,
+					dataKey: finalDataKey,
+					payload: tooltipPayload,
+					// getValueByDataKey does not validate the output type
+					value: getValueByDataKey(tooltipPayload, finalDataKey),
+					// getValueByDataKey does not validate the output type
+					name:
+						(_getValueByDataKey = getValueByDataKey(tooltipPayload, finalNameKey)) !== null &&
+						_getValueByDataKey !== void 0
+							? _getValueByDataKey
+							: settings === null || settings === void 0
+								? void 0
+								: settings.name,
+				}),
+			);
+		}
+		return agg;
+	}, init);
+};

package/src/state/selectors/combiners/combineTooltipPayloadConfigurations.js

@@ -0,0 +1,59 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/selectors/combiners/combineTooltipPayloadConfigurations.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+export var combineTooltipPayloadConfigurations = (
+	tooltipState,
+	tooltipEventType,
+	trigger,
+	defaultIndex,
+) => {
+	// if tooltip reacts to axis interaction, then we display all items at the same time.
+	if (tooltipEventType === 'axis') {
+		return tooltipState.tooltipItemPayloads;
+	}
+	/*
+	 * By now we already know that tooltipEventType is 'item', so we can only search in itemInteractions.
+	 * item means that only the hovered or clicked item will be present in the tooltip.
+	 */
+	if (tooltipState.tooltipItemPayloads.length === 0) {
+		// No point filtering if the payload is empty
+		return [];
+	}
+	var filterByGraphicalItemId;
+	if (trigger === 'hover') {
+		filterByGraphicalItemId = tooltipState.itemInteraction.hover.graphicalItemId;
+	} else {
+		filterByGraphicalItemId = tooltipState.itemInteraction.click.graphicalItemId;
+	}
+	if (tooltipState.syncInteraction.active && filterByGraphicalItemId == null) {
+		/*
+		 * When a tooltip is synchronised from another chart, the local itemInteraction
+		 * has no graphicalItemId because the user hasn't hovered over this chart.
+		 * In that case we show all tooltip items so the receiving chart can display
+		 * its own data at the synced index — matching the behaviour of axis-type tooltips.
+		 */
+		return tooltipState.tooltipItemPayloads;
+	}
+	if (
+		filterByGraphicalItemId == null &&
+		(defaultIndex != null || tooltipState.keyboardInteraction.active)
+	) {
+		/*
+		 * So when we use `defaultIndex` - we don't have a dataKey to filter by because user did not hover over anything yet.
+		 * In that case let's display the first item in the tooltip; after all, this is `item` interaction case,
+		 * so we should display only one item at a time instead of all.
+		 */
+		var firstItemPayload = tooltipState.tooltipItemPayloads[0];
+		if (firstItemPayload != null) {
+			return [firstItemPayload];
+		}
+		return [];
+	}
+	return tooltipState.tooltipItemPayloads.filter((tpc) => {
+		var _tpc$settings;
+		return (
+			((_tpc$settings = tpc.settings) === null || _tpc$settings === void 0
+				? void 0
+				: _tpc$settings.graphicalItemId) === filterByGraphicalItemId
+		);
+	});
+};

package/src/state/selectors/containerSelectors.js

@@ -0,0 +1,6 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/selectors/containerSelectors.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+export var selectChartWidth = (state) => state.layout.width;
+export var selectChartHeight = (state) => state.layout.height;
+export var selectContainerScale = (state) => state.layout.scale;
+export var selectMargin = (state) => state.layout.margin;

package/src/state/selectors/dataSelectors.js

@@ -0,0 +1,97 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/selectors/dataSelectors.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+import { createSelector } from 'reselect';
+/**
+ * This selector always returns the data with the indexes set by a Brush.
+ * Trouble is, that might or might not be what you want.
+ *
+ * In charts with Brush, you will sometimes want to select the full range of data, and sometimes the one decided by the Brush
+ * - even if the Brush is active, the panorama inside the Brush should show the full range of data.
+ *
+ * So instead of this selector, consider using either selectChartDataAndAlwaysIgnoreIndexes or selectChartDataWithIndexesIfNotInPanorama
+ *
+ * @param state RechartsRootState
+ * @returns data defined on the chart root element, such as BarChart or ScatterChart
+ */
+export var selectChartDataWithIndexes = (state) => state.chartData;
+
+/**
+ * This selector will always return the full range of data, ignoring the indexes set by a Brush.
+ * Useful for when you want to render the full range of data, even if a Brush is active.
+ * For example: in the Brush panorama, in Legend, in Tooltip.
+ */
+export var selectChartDataAndAlwaysIgnoreIndexes = createSelector(
+	[selectChartDataWithIndexes],
+	(dataState) => {
+		var dataEndIndex = dataState.chartData != null ? dataState.chartData.length - 1 : 0;
+		return {
+			chartData: dataState.chartData,
+			computedData: dataState.computedData,
+			dataEndIndex,
+			dataStartIndex: 0,
+		};
+	},
+);
+export var selectChartDataWithIndexesIfNotInPanoramaPosition4 = (
+	state,
+	_unused1,
+	_unused2,
+	isPanorama,
+) => {
+	if (isPanorama) {
+		return selectChartDataAndAlwaysIgnoreIndexes(state);
+	}
+	return selectChartDataWithIndexes(state);
+};
+export var selectChartDataWithIndexesIfNotInPanoramaPosition3 = (state, _unused1, isPanorama) => {
+	if (isPanorama) {
+		return selectChartDataAndAlwaysIgnoreIndexes(state);
+	}
+	return selectChartDataWithIndexes(state);
+};
+
+/**
+ * Returns the chart-level data slice (respecting Brush indexes), memoized by content so that
+ * spurious Immer reference changes (e.g. dispatching `setChartData(undefined)` when data is
+ * already `undefined`) do not propagate to downstream selectors.
+ *
+ * Used when a selector needs chart-level data but must avoid extra recomputes when the
+ * data content has not actually changed.
+ */
+export var selectChartDataSliceIfNotInPanorama = createSelector(
+	[selectChartDataWithIndexesIfNotInPanoramaPosition4],
+	(_ref) => {
+		var chartData = _ref.chartData,
+			dataStartIndex = _ref.dataStartIndex,
+			dataEndIndex = _ref.dataEndIndex;
+		return chartData != null ? chartData.slice(dataStartIndex, dataEndIndex + 1) : [];
+	},
+);
+
+/**
+ * Returns the chart-level data slice (ignoring Brush indexes), memoized by content.
+ * Used in tooltip and polar selectors that always need the full data range.
+ */
+export var selectChartDataSliceIgnoringIndexes = createSelector(
+	[selectChartDataAndAlwaysIgnoreIndexes],
+	(_ref2) => {
+		var chartData = _ref2.chartData,
+			dataStartIndex = _ref2.dataStartIndex,
+			dataEndIndex = _ref2.dataEndIndex;
+		return chartData != null ? chartData.slice(dataStartIndex, dataEndIndex + 1) : [];
+	},
+);
+
+/**
+ * Returns the chart-level data slice (with Brush indexes applied), memoized by content.
+ * Used in tooltip selectors.
+ */
+export var selectChartDataSliceWithIndexes = createSelector(
+	[selectChartDataWithIndexes],
+	(_ref3) => {
+		var chartData = _ref3.chartData,
+			dataStartIndex = _ref3.dataStartIndex,
+			dataEndIndex = _ref3.dataEndIndex;
+		return chartData != null ? chartData.slice(dataStartIndex, dataEndIndex + 1) : [];
+	},
+);

package/src/state/selectors/graphicalItemSelectors.js

@@ -0,0 +1,25 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/selectors/graphicalItemSelectors.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+import { defaultAxisId } from '../cartesianAxisSlice';
+export function selectXAxisIdFromGraphicalItemId(state, id) {
+	var _state$graphicalItems, _state$graphicalItems2;
+	return (_state$graphicalItems =
+		(_state$graphicalItems2 = state.graphicalItems.cartesianItems.find(
+			(item) => item.id === id,
+		)) === null || _state$graphicalItems2 === void 0
+			? void 0
+			: _state$graphicalItems2.xAxisId) !== null && _state$graphicalItems !== void 0
+		? _state$graphicalItems
+		: defaultAxisId;
+}
+export function selectYAxisIdFromGraphicalItemId(state, id) {
+	var _state$graphicalItems3, _state$graphicalItems4;
+	return (_state$graphicalItems3 =
+		(_state$graphicalItems4 = state.graphicalItems.cartesianItems.find(
+			(item) => item.id === id,
+		)) === null || _state$graphicalItems4 === void 0
+			? void 0
+			: _state$graphicalItems4.yAxisId) !== null && _state$graphicalItems3 !== void 0
+		? _state$graphicalItems3
+		: defaultAxisId;
+}

package/src/state/selectors/legendSelectors.js

@@ -0,0 +1,18 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/selectors/legendSelectors.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+// Sanctioned deviation: es-toolkit compat imports normalized to the ESM barrel
+// ('es-toolkit/compat') — the per-function subpaths are CJS-only and break
+// consumers that compile this binding from source (vite dev prebundle).
+import { createSelector } from 'reselect';
+import { sortBy } from 'es-toolkit/compat';
+export var selectLegendSettings = (state) => state.legend.settings;
+export var selectLegendSize = (state) => state.legend.size;
+var selectAllLegendPayload2DArray = (state) => state.legend.payload;
+export var selectLegendPayload = createSelector(
+	[selectAllLegendPayload2DArray, selectLegendSettings],
+	(payloads, _ref) => {
+		var itemSorter = _ref.itemSorter;
+		var flat = payloads.flat(1);
+		return itemSorter ? sortBy(flat, itemSorter) : flat;
+	},
+);

package/src/state/selectors/lineSelectors.js

@@ -0,0 +1,106 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/selectors/lineSelectors.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+import { createSelector } from 'reselect';
+import { computeLinePoints } from '../../cartesian/Line';
+import { selectChartDataWithIndexesIfNotInPanoramaPosition4 } from './dataSelectors';
+import { selectChartLayout } from '../../context/chartLayoutContext';
+import {
+	selectAxisWithScale,
+	selectTicksOfGraphicalItem,
+	selectUnfilteredCartesianItems,
+} from './axisSelectors';
+import { getBandSizeOfAxis, isCategoricalAxis } from '../../util/ChartUtils';
+var selectXAxisWithScale = (state, xAxisId, _yAxisId, isPanorama) =>
+	selectAxisWithScale(state, 'xAxis', xAxisId, isPanorama);
+var selectXAxisTicks = (state, xAxisId, _yAxisId, isPanorama) =>
+	selectTicksOfGraphicalItem(state, 'xAxis', xAxisId, isPanorama);
+var selectYAxisWithScale = (state, _xAxisId, yAxisId, isPanorama) =>
+	selectAxisWithScale(state, 'yAxis', yAxisId, isPanorama);
+var selectYAxisTicks = (state, _xAxisId, yAxisId, isPanorama) =>
+	selectTicksOfGraphicalItem(state, 'yAxis', yAxisId, isPanorama);
+var selectBandSize = createSelector(
+	[
+		selectChartLayout,
+		selectXAxisWithScale,
+		selectYAxisWithScale,
+		selectXAxisTicks,
+		selectYAxisTicks,
+	],
+	(layout, xAxis, yAxis, xAxisTicks, yAxisTicks) => {
+		if (isCategoricalAxis(layout, 'xAxis')) {
+			return getBandSizeOfAxis(xAxis, xAxisTicks, false);
+		}
+		return getBandSizeOfAxis(yAxis, yAxisTicks, false);
+	},
+);
+var pickLineId = (_state, _xAxisId, _yAxisId, _isPanorama, id) => id;
+function isLineSettings(item) {
+	return item.type === 'line';
+}
+
+/*
+ * There is a race condition problem because we read some data from props and some from the state.
+ * The state is updated through a dispatch and is one render behind,
+ * and so we have this weird one tick render where the displayedData in one selector have the old dataKey
+ * but the new dataKey in another selector.
+ *
+ * So here instead of reading the dataKey from the props, we always read it from the state.
+ */
+var selectSynchronisedLineSettings = createSelector(
+	[selectUnfilteredCartesianItems, pickLineId],
+	(graphicalItems, id) => graphicalItems.filter(isLineSettings).find((x) => x.id === id),
+);
+export var selectLinePoints = createSelector(
+	[
+		selectChartLayout,
+		selectXAxisWithScale,
+		selectYAxisWithScale,
+		selectXAxisTicks,
+		selectYAxisTicks,
+		selectSynchronisedLineSettings,
+		selectBandSize,
+		selectChartDataWithIndexesIfNotInPanoramaPosition4,
+	],
+	(layout, xAxis, yAxis, xAxisTicks, yAxisTicks, lineSettings, bandSize, _ref) => {
+		var chartData = _ref.chartData,
+			dataStartIndex = _ref.dataStartIndex,
+			dataEndIndex = _ref.dataEndIndex;
+		if (
+			lineSettings == null ||
+			xAxis == null ||
+			yAxis == null ||
+			xAxisTicks == null ||
+			yAxisTicks == null ||
+			xAxisTicks.length === 0 ||
+			yAxisTicks.length === 0 ||
+			bandSize == null ||
+			(layout !== 'horizontal' && layout !== 'vertical')
+		) {
+			return undefined;
+		}
+		var dataKey = lineSettings.dataKey,
+			data = lineSettings.data;
+		var displayedData;
+		if (data != null && data.length > 0) {
+			displayedData = data;
+		} else {
+			displayedData =
+				chartData === null || chartData === void 0
+					? void 0
+					: chartData.slice(dataStartIndex, dataEndIndex + 1);
+		}
+		if (displayedData == null) {
+			return undefined;
+		}
+		return computeLinePoints({
+			layout,
+			xAxis,
+			yAxis,
+			xAxisTicks,
+			yAxisTicks,
+			dataKey,
+			bandSize,
+			displayedData,
+		});
+	},
+);

package/src/state/selectors/numberDomainEqualityCheck.js

@@ -0,0 +1,11 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/selectors/numberDomainEqualityCheck.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+export var numberDomainEqualityCheck = (a, b) => {
+	if (a === b) {
+		return true;
+	}
+	if (a == null || b == null) {
+		return false;
+	}
+	return a[0] === b[0] && a[1] === b[1];
+};

package/src/state/selectors/pickAxisId.js

@@ -0,0 +1,3 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/selectors/pickAxisId.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+export var pickAxisId = (_state, _axisType, axisId) => axisId;

package/src/state/selectors/pickAxisType.js

@@ -0,0 +1,3 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/selectors/pickAxisType.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+export var pickAxisType = (_state, axisType) => axisType;