@octanejs/recharts 0.1.0

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

@@ -0,0 +1,115 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/selectors/combiners/combineBarSizeList.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+function _slicedToArray(r, e) {
+	return (
+		_arrayWithHoles(r) ||
+		_iterableToArrayLimit(r, e) ||
+		_unsupportedIterableToArray(r, e) ||
+		_nonIterableRest()
+	);
+}
+function _nonIterableRest() {
+	throw new TypeError(
+		'Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.',
+	);
+}
+function _unsupportedIterableToArray(r, a) {
+	if (r) {
+		if ('string' == typeof r) return _arrayLikeToArray(r, a);
+		var t = {}.toString.call(r).slice(8, -1);
+		return (
+			'Object' === t && r.constructor && (t = r.constructor.name),
+			'Map' === t || 'Set' === t
+				? Array.from(r)
+				: 'Arguments' === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t)
+					? _arrayLikeToArray(r, a)
+					: void 0
+		);
+	}
+}
+function _arrayLikeToArray(r, a) {
+	(null == a || a > r.length) && (a = r.length);
+	for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+	return n;
+}
+function _iterableToArrayLimit(r, l) {
+	var t =
+		null == r ? null : ('undefined' != typeof Symbol && r[Symbol.iterator]) || r['@@iterator'];
+	if (null != t) {
+		var e,
+			n,
+			i,
+			u,
+			a = [],
+			f = !0,
+			o = !1;
+		try {
+			if (((i = (t = t.call(r)).next), 0 === l)) {
+				if (Object(t) !== t) return;
+				f = !1;
+			} else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+		} catch (r) {
+			((o = !0), (n = r));
+		} finally {
+			try {
+				if (!f && null != t.return && ((u = t.return()), Object(u) !== u)) return;
+			} finally {
+				if (o) throw n;
+			}
+		}
+		return a;
+	}
+}
+function _arrayWithHoles(r) {
+	if (Array.isArray(r)) return r;
+}
+import { isStacked } from '../../types/StackedGraphicalItem';
+import { getPercentValue, isNullish } from '../../../util/DataUtils';
+var getBarSize = (globalSize, totalSize, selfSize) => {
+	var barSize = selfSize !== null && selfSize !== void 0 ? selfSize : globalSize;
+	if (isNullish(barSize)) {
+		return undefined;
+	}
+	return getPercentValue(barSize, totalSize, 0);
+};
+export var combineBarSizeList = (allBars, globalSize, totalSize) => {
+	var initialValue = {};
+	var stackedBars = allBars.filter(isStacked);
+	var unstackedBars = allBars.filter((b) => b.stackId == null);
+	var groupByStack = stackedBars.reduce((acc, bar) => {
+		var s = acc[bar.stackId];
+		if (s == null) {
+			s = [];
+		}
+		s.push(bar);
+		acc[bar.stackId] = s;
+		return acc;
+	}, initialValue);
+	var stackedSizeList = Object.entries(groupByStack).map((_ref) => {
+		var _bars$;
+		var _ref2 = _slicedToArray(_ref, 2),
+			stackId = _ref2[0],
+			bars = _ref2[1];
+		var dataKeys = bars.map((b) => b.dataKey);
+		var barSize = getBarSize(
+			globalSize,
+			totalSize,
+			(_bars$ = bars[0]) === null || _bars$ === void 0 ? void 0 : _bars$.barSize,
+		);
+		return {
+			stackId,
+			dataKeys,
+			barSize,
+		};
+	});
+	var unstackedSizeList = unstackedBars.map((b) => {
+		var dataKeys = [b.dataKey].filter((dk) => dk != null);
+		var barSize = getBarSize(globalSize, totalSize, b.barSize);
+		return {
+			stackId: undefined,
+			dataKeys,
+			barSize,
+		};
+	});
+	return [...stackedSizeList, ...unstackedSizeList];
+};

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

@@ -0,0 +1,44 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/selectors/combiners/combineCheckedDomain.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+import { isWellFormedNumberDomain } from '../../../util/isDomainSpecifiedByUser';
+import { isWellBehavedNumber } from '../../../util/isWellBehavedNumber';
+
+/**
+ * This function validates and transforms the axis domain so that it is safe to use in the provided scale.
+ */
+export var combineCheckedDomain = (realScaleType, axisDomain) => {
+	if (axisDomain == null) {
+		return undefined;
+	}
+	switch (realScaleType) {
+		case 'linear': {
+			/*
+			 * linear scale only reads the first two numbers in the domain, and ignores everything else.
+			 * So if it happens that someone somehow gave us a bigger domain,
+			 * let's pick the min and max from it.
+			 */
+			if (!isWellFormedNumberDomain(axisDomain)) {
+				var min, max;
+				for (var i = 0; i < axisDomain.length; i++) {
+					var value = axisDomain[i];
+					if (!isWellBehavedNumber(value)) {
+						continue;
+					}
+					if (min === undefined || value < min) {
+						min = value;
+					}
+					if (max === undefined || value > max) {
+						max = value;
+					}
+				}
+				if (min !== undefined && max !== undefined) {
+					return [min, max];
+				}
+				return undefined;
+			}
+			return axisDomain;
+		}
+		default:
+			return axisDomain;
+	}
+};

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

@@ -0,0 +1,46 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/selectors/combiners/combineConfiguredScale.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+import * as d3Scales from 'victory-vendor/d3-scale';
+import { upperFirst } from '../../../util/DataUtils';
+function getD3ScaleFromType(realScaleType) {
+	var scales = d3Scales;
+	if (realScaleType in scales && typeof scales[realScaleType] === 'function') {
+		return scales[realScaleType]();
+	}
+	var name = 'scale'.concat(upperFirst(realScaleType));
+	if (name in scales && typeof scales[name] === 'function') {
+		return scales[name]();
+	}
+	return undefined;
+}
+
+/**
+ * Converts external scale definition into internal RechartsScale definition.
+ * @param scale custom function scale - if you have the `string` from outside, use `combineRealScaleType` first which will validate it and return RechartsScaleType or undefined
+ * @param axisDomain
+ * @param axisRange
+ */
+
+export function combineConfiguredScaleInternal(scale, axisDomain, axisRange) {
+	if (typeof scale === 'function') {
+		return scale.copy().domain(axisDomain).range(axisRange);
+	}
+	if (scale == null) {
+		return undefined;
+	}
+	var d3ScaleFunction = getD3ScaleFromType(scale);
+	if (d3ScaleFunction == null) {
+		return undefined;
+	}
+	d3ScaleFunction.domain(axisDomain).range(axisRange);
+	return d3ScaleFunction;
+}
+export function combineConfiguredScale(axis, realScaleType, axisDomain, axisRange) {
+	if (axisDomain == null || axisRange == null) {
+		return undefined;
+	}
+	if (typeof axis.scale === 'function') {
+		return combineConfiguredScaleInternal(axis.scale, axisDomain, axisRange);
+	}
+	return combineConfiguredScaleInternal(realScaleType, axisDomain, axisRange);
+}

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

@@ -0,0 +1,48 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/selectors/combiners/combineCoordinateForDefaultIndex.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+export var combineCoordinateForDefaultIndex = (
+	width,
+	height,
+	layout,
+	offset,
+	tooltipTicks,
+	defaultIndex,
+	tooltipConfigurations,
+) => {
+	if (defaultIndex == null) {
+		return undefined;
+	}
+	/*
+	 * With defaultIndex alone, we don't have enough information to decide _which_ of the multiple tooltips to display.
+	 * Maybe one day we could add new prop `activeGraphicalItemId` to the chart to help with that.
+	 * Until then, we choose the first one.
+	 */
+	var firstConfiguration = tooltipConfigurations[0];
+	var maybePosition =
+		firstConfiguration === null || firstConfiguration === void 0
+			? void 0
+			: firstConfiguration.getPosition(defaultIndex);
+	if (maybePosition != null) {
+		return maybePosition;
+	}
+	var tick =
+		tooltipTicks === null || tooltipTicks === void 0 ? void 0 : tooltipTicks[Number(defaultIndex)];
+	if (!tick) {
+		return undefined;
+	}
+	switch (layout) {
+		case 'horizontal': {
+			return {
+				x: tick.coordinate,
+				y: (offset.top + height) / 2,
+			};
+		}
+		default: {
+			// This logic is not super sound - it conflates vertical, radial, centric layouts into just one. TODO improve!
+			return {
+				x: (offset.left + width) / 2,
+				y: tick.coordinate,
+			};
+		}
+	}
+};

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

@@ -0,0 +1,54 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/selectors/combiners/combineDisplayedStackedData.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+import { getStackSeriesIdentifier } from '../../../util/stacks/getStackSeriesIdentifier';
+import { getValueByDataKey } from '../../../util/ChartUtils';
+
+/**
+ * In a stacked chart, each graphical item has its own data. That data could be either:
+ * - defined on the chart root, in which case the item gets a unique dataKey
+ * - or defined on the item itself, in which case multiple items can share the same dataKey
+ *
+ * That means we cannot use the dataKey as a unique identifier for the item.
+ *
+ * This type represents a single data point in a stacked chart, where each key is a series identifier
+ * and the value is the numeric value for that series using the numerical axis dataKey.
+ */
+
+export function combineDisplayedStackedData(stackedGraphicalItems, _ref, tooltipAxisSettings) {
+	var _ref$chartData = _ref.chartData,
+		chartData = _ref$chartData === void 0 ? [] : _ref$chartData;
+	var allowDuplicatedCategory = tooltipAxisSettings.allowDuplicatedCategory,
+		tooltipDataKey = tooltipAxisSettings.dataKey;
+
+	// A map of tooltip data keys to the stacked data points
+	var knownItemsByDataKey = new Map();
+	stackedGraphicalItems.forEach((item) => {
+		var _item$data;
+		// If there is no data on the individual item then we use the root chart data
+		var resolvedData =
+			(_item$data = item.data) !== null && _item$data !== void 0 ? _item$data : chartData;
+		if (resolvedData == null || resolvedData.length === 0) {
+			// if that doesn't work then we skip this item
+			return;
+		}
+		var stackIdentifier = getStackSeriesIdentifier(item);
+		resolvedData.forEach((entry, index) => {
+			var tooltipValue =
+				tooltipDataKey == null || allowDuplicatedCategory
+					? index
+					: String(getValueByDataKey(entry, tooltipDataKey, null));
+			var numericValue = getValueByDataKey(entry, item.dataKey, 0);
+			var curr;
+			if (knownItemsByDataKey.has(tooltipValue)) {
+				curr = knownItemsByDataKey.get(tooltipValue);
+			} else {
+				curr = {};
+			}
+			Object.assign(curr, {
+				[stackIdentifier]: numericValue,
+			});
+			knownItemsByDataKey.set(tooltipValue, curr);
+		});
+	});
+	return Array.from(knownItemsByDataKey.values());
+}

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

@@ -0,0 +1,12 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/selectors/combiners/combineInverseScaleFunction.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+import { createCategoricalInverse } from '../../../util/scale/createCategoricalInverse';
+export function combineInverseScaleFunction(configuredScale) {
+	if (configuredScale == null) {
+		return undefined;
+	}
+	if ('invert' in configuredScale && typeof configuredScale.invert === 'function') {
+		return configuredScale.invert.bind(configuredScale);
+	}
+	return createCategoricalInverse(configuredScale, undefined);
+}

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

@@ -0,0 +1,36 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/selectors/combiners/combineRealScaleType.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+import * as d3Scales from 'victory-vendor/d3-scale';
+import { upperFirst } from '../../../util/DataUtils';
+function getD3ScaleName(name) {
+	return 'scale'.concat(upperFirst(name));
+}
+function isSupportedScaleName(name) {
+	return getD3ScaleName(name) in d3Scales;
+}
+export var combineRealScaleType = (axisConfig, hasBar, chartType) => {
+	if (axisConfig == null) {
+		return undefined;
+	}
+	var scale = axisConfig.scale,
+		type = axisConfig.type;
+	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') {
+		return isSupportedScaleName(scale) ? scale : 'point';
+	}
+	return undefined;
+};

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

@@ -0,0 +1,22 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/selectors/combiners/combineStackedData.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+import { getStackSeriesIdentifier } from '../../../util/stacks/getStackSeriesIdentifier';
+export var combineStackedData = (stackGroups, barSettings) => {
+	var stackSeriesIdentifier = getStackSeriesIdentifier(barSettings);
+	if (!stackGroups || stackSeriesIdentifier == null || barSettings == null) {
+		return undefined;
+	}
+	var stackId = barSettings.stackId;
+	if (stackId == null) {
+		return undefined;
+	}
+	var stackGroup = stackGroups[stackId];
+	if (!stackGroup) {
+		return undefined;
+	}
+	var stackedData = stackGroup.stackedData;
+	if (!stackedData) {
+		return undefined;
+	}
+	return stackedData.find((sd) => sd.key === stackSeriesIdentifier);
+};

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

@@ -0,0 +1,121 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/selectors/combiners/combineTooltipInteractionState.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 { noInteraction } from '../../tooltipSlice';
+function chooseAppropriateMouseInteraction(tooltipState, tooltipEventType, trigger) {
+	if (tooltipEventType === 'axis') {
+		if (trigger === 'click') {
+			return tooltipState.axisInteraction.click;
+		}
+		return tooltipState.axisInteraction.hover;
+	}
+	if (trigger === 'click') {
+		return tooltipState.itemInteraction.click;
+	}
+	return tooltipState.itemInteraction.hover;
+}
+function hasBeenActivePreviously(tooltipInteractionState) {
+	return tooltipInteractionState.index != null;
+}
+export var combineTooltipInteractionState = (
+	tooltipState,
+	tooltipEventType,
+	trigger,
+	defaultIndex,
+) => {
+	if (tooltipEventType == null) {
+		return noInteraction;
+	}
+	var appropriateMouseInteraction = chooseAppropriateMouseInteraction(
+		tooltipState,
+		tooltipEventType,
+		trigger,
+	);
+	if (appropriateMouseInteraction == null) {
+		return noInteraction;
+	}
+	if (appropriateMouseInteraction.active) {
+		return appropriateMouseInteraction;
+	}
+	if (tooltipState.keyboardInteraction.active) {
+		return tooltipState.keyboardInteraction;
+	}
+	if (tooltipState.syncInteraction.active && tooltipState.syncInteraction.index != null) {
+		return tooltipState.syncInteraction;
+	}
+	var activeFromProps = tooltipState.settings.active === true;
+	if (hasBeenActivePreviously(appropriateMouseInteraction)) {
+		if (activeFromProps) {
+			return _objectSpread(
+				_objectSpread({}, appropriateMouseInteraction),
+				{},
+				{
+					active: true,
+				},
+			);
+		}
+	} else if (defaultIndex != null) {
+		return {
+			active: true,
+			coordinate: undefined,
+			dataKey: undefined,
+			index: defaultIndex,
+			graphicalItemId: undefined,
+		};
+	}
+	return _objectSpread(
+		_objectSpread({}, noInteraction),
+		{},
+		{
+			coordinate: appropriateMouseInteraction.coordinate,
+		},
+	);
+};