vccs 0.1.0 → 0.2.0

package/dist/es/state/selectors/tooltipSelectors.mjs

@@ -1,220 +1,269 @@
-import { isCategoricalAxis as e } from "../../utils/validate.mjs";
-import { selectChartDataWithIndexes as t } from "./dataSelectors.mjs";
-import { selectChartHeight as n, selectChartWidth as r } from "./containerSelectors.mjs";
-import { selectChartOffset as i } from "./selectChartOffset.mjs";
-import { selectChartName as a, selectStackOffsetType as o } from "./rootPropsSelectors.mjs";
-import { combineAxisRangeWithReverse as s } from "./combiners/combineAxisRangeWithReverse.mjs";
-import { findEntryInArray as c, mathSign as l } from "../../utils/data.mjs";
-import { selectChartLayout as u } from "./common.mjs";
-import { getTooltipEntry as d, getValueByDataKey as f } from "../../utils/chart.mjs";
-import { combineAppliedNumericalValuesIncludingErrorValues as p, combineAppliedValues as m, combineAreasDomain as h, combineAxisDomain as g, combineAxisDomainWithNiceTicks as _, combineCategoricalDomain as v, combineDisplayedData as y, combineDomainOfStackGroups as ee, combineDotsDomain as te, combineDuplicateDomain as ne, combineGraphicalItemsData as re, combineGraphicalItemsSettings as ie, combineLinesDomain as ae, combineNiceTicks as b, combineNumericalDomain as x, combineRealScaleType as S, combineScaleFunction as oe, combineStackGroups as se, filterGraphicalNotStackedItems as ce, filterReferenceElements as C, getDomainDefinition as le, itemAxisPredicate as ue, mergeDomains as de, selectAxisRange as fe, selectAxisSettings as pe, selectHasBar as me, selectReferenceAreas as he, selectReferenceDots as ge, selectReferenceLines as _e } from "./axisSelectors.mjs";
-import { combineTooltipEventType as ve, selectDefaultTooltipEventType as ye, selectValidateTooltipEventTypes as be } from "./selectTooltipEventType.mjs";
-import { combineActiveLabel as w } from "./combiners/combineActiveLabel.mjs";
-import { selectTooltipSettings as T } from "./selectTooltipSettings.mjs";
-import { combineTooltipInteractionState as E } from "./combiners/combineTooltipInteractionState.mjs";
-import { combineActiveTooltipIndex as D } from "./combiners/combineActiveTooltipIndex.mjs";
-import { combineCoordinateForDefaultIndex as O } from "./combiners/combineCoordinateForDefaultIndex.mjs";
-import { combineTooltipPayloadConfigurations as k } from "./combiners/combineTooltipPayloadConfigurations.mjs";
-import { selectTooltipPayloadSearcher as A } from "./selectTooltipPayloadSearcher.mjs";
-import { selectTooltipState as j } from "./selectTooltipState.mjs";
-import { createSelector as M } from "@reduxjs/toolkit";
+import { isCategoricalAxis } from "../../utils/validate.mjs";
+import { selectChartDataWithIndexes } from "./dataSelectors.mjs";
+import { selectChartHeight, selectChartWidth } from "./containerSelectors.mjs";
+import { selectChartOffset } from "./selectChartOffset.mjs";
+import { selectChartName, selectStackOffsetType } from "./rootPropsSelectors.mjs";
+import { combineAxisRangeWithReverse } from "./combiners/combineAxisRangeWithReverse.mjs";
+import { findEntryInArray, mathSign } from "../../utils/data.mjs";
+import { selectChartLayout } from "./common.mjs";
+import { getTooltipEntry, getValueByDataKey } from "../../utils/chart.mjs";
+import { combineAppliedNumericalValuesIncludingErrorValues, combineAppliedValues, combineAreasDomain, combineAxisDomain, combineAxisDomainWithNiceTicks, combineCategoricalDomain, combineDisplayedData, combineDomainOfStackGroups, combineDotsDomain, combineDuplicateDomain, combineGraphicalItemsData, combineGraphicalItemsSettings, combineLinesDomain, combineNiceTicks, combineNumericalDomain, combineRealScaleType, combineScaleFunction, combineStackGroups, filterGraphicalNotStackedItems, filterReferenceElements, getDomainDefinition, itemAxisPredicate, mergeDomains, selectAxisRange, selectAxisSettings, selectHasBar, selectReferenceAreas, selectReferenceDots, selectReferenceLines } from "./axisSelectors.mjs";
+import { combineTooltipEventType, selectDefaultTooltipEventType, selectValidateTooltipEventTypes } from "./selectTooltipEventType.mjs";
+import { combineActiveLabel } from "./combiners/combineActiveLabel.mjs";
+import { selectTooltipSettings } from "./selectTooltipSettings.mjs";
+import { combineTooltipInteractionState } from "./combiners/combineTooltipInteractionState.mjs";
+import { combineActiveTooltipIndex } from "./combiners/combineActiveTooltipIndex.mjs";
+import { combineCoordinateForDefaultIndex } from "./combiners/combineCoordinateForDefaultIndex.mjs";
+import { combineTooltipPayloadConfigurations } from "./combiners/combineTooltipPayloadConfigurations.mjs";
+import { selectTooltipPayloadSearcher } from "./selectTooltipPayloadSearcher.mjs";
+import { selectTooltipState } from "./selectTooltipState.mjs";
+import { createSelector } from "@reduxjs/toolkit";
 //#region src/state/selectors/tooltipSelectors.ts
-function N(e, t, n) {
-	return Array.isArray(e) && e && t + n !== 0 ? e.slice(t, n + 1) : e;
+function getSliced(arr, startIndex, endIndex) {
+	if (!Array.isArray(arr)) return arr;
+	if (arr && startIndex + endIndex !== 0) return arr.slice(startIndex, endIndex + 1);
+	return arr;
 }
-function xe(e, t) {
-	return e ?? t;
+function selectFinalData(dataDefinedOnItem, dataDefinedOnChart) {
+	if (dataDefinedOnItem != null) return dataDefinedOnItem;
+	return dataDefinedOnChart;
 }
-function P(e, t, n, r, i, a, o) {
-	if (t == null || a == null) return;
-	let { chartData: s, computedData: l, dataStartIndex: u, dataEndIndex: p } = n;
-	return e.reduce((e, { dataDefinedOnItem: n, settings: m }) => {
-		let h = N(xe(n, s), u, p), g = m?.dataKey ?? r?.dataKey, _ = m?.nameKey, v;
-		return r?.dataKey && !r?.allowDuplicatedCategory && Array.isArray(h) && i != null && o === "axis" && (v = c(h, r.dataKey, i)), v ??= a(h, t, l, _), Array.isArray(v) ? v.forEach((t) => {
-			let n = {
-				...m,
-				name: t.name,
-				unit: t.unit,
+function combineTooltipPayload(tooltipPayloadConfigurations, activeIndex, chartDataState, tooltipAxis, activeLabel, tooltipPayloadSearcher, tooltipEventType) {
+	if (activeIndex == null || tooltipPayloadSearcher == null) return;
+	const { chartData, computedData, dataStartIndex, dataEndIndex } = chartDataState;
+	return tooltipPayloadConfigurations.reduce((agg, { dataDefinedOnItem, settings }) => {
+		const sliced = getSliced(selectFinalData(dataDefinedOnItem, chartData), dataStartIndex, dataEndIndex);
+		const finalDataKey = settings?.dataKey ?? tooltipAxis?.dataKey;
+		const finalNameKey = settings?.nameKey;
+		let tooltipPayload;
+		if (tooltipAxis?.dataKey && !tooltipAxis?.allowDuplicatedCategory && Array.isArray(sliced) && activeLabel != null && tooltipEventType === "axis") tooltipPayload = findEntryInArray(sliced, tooltipAxis.dataKey, activeLabel);
+		if (tooltipPayload == null) tooltipPayload = tooltipPayloadSearcher(sliced, activeIndex, computedData, finalNameKey);
+		if (Array.isArray(tooltipPayload)) tooltipPayload.forEach((item) => {
+			const newSettings = {
+				...settings,
+				name: item.name,
+				unit: item.unit,
 				color: void 0,
 				fill: void 0
 			};
-			e.push(d({
-				tooltipEntrySettings: n,
-				dataKey: t.dataKey,
-				payload: t.payload,
-				value: f(t.payload, t.dataKey),
-				name: t.name
+			agg.push(getTooltipEntry({
+				tooltipEntrySettings: newSettings,
+				dataKey: item.dataKey,
+				payload: item.payload,
+				value: getValueByDataKey(item.payload, item.dataKey),
+				name: item.name
 			}));
-		}) : e.push(d({
-			tooltipEntrySettings: m,
-			dataKey: g,
-			payload: v,
-			value: f(v, g),
-			name: f(v, _) ?? m?.name
-		})), e;
+		});
+		else agg.push(getTooltipEntry({
+			tooltipEntrySettings: settings,
+			dataKey: finalDataKey,
+			payload: tooltipPayload,
+			value: getValueByDataKey(tooltipPayload, finalDataKey),
+			name: getValueByDataKey(tooltipPayload, finalNameKey) ?? settings?.name
+		}));
+		return agg;
 	}, []);
 }
-function F(e) {
-	let t = u(e);
-	return t === "horizontal" ? "xAxis" : t === "vertical" ? "yAxis" : t === "centric" ? "angleAxis" : "radiusAxis";
+function selectTooltipAxisType(state) {
+	const layout = selectChartLayout(state);
+	if (layout === "horizontal") return "xAxis";
+	if (layout === "vertical") return "yAxis";
+	if (layout === "centric") return "angleAxis";
+	return "radiusAxis";
 }
-var I = (e) => e.tooltip.settings.axisId;
-function L(e) {
-	return pe(e, F(e), I(e));
+var selectTooltipAxisId = (state) => state.tooltip.settings.axisId;
+function selectTooltipAxis(state) {
+	return selectAxisSettings(state, selectTooltipAxisType(state), selectTooltipAxisId(state));
 }
-var R = M([
-	L,
-	me,
-	a
-], S), z = M([
-	M([(e) => e.graphicalItems.cartesianItems, (e) => e.graphicalItems.polarItems], (e, t) => [...e, ...t]),
-	L,
-	M([F, I], ue)
-], ie), B = M([M([z], re), t], y), V = M([
-	B,
-	L,
-	z
-], m), Se = M([L], le), Ce = M([
-	M([
-		B,
-		z,
-		o
-	], se),
-	t,
-	F
-], ee), we = M([
-	B,
-	L,
-	M([z], ce),
-	F
-], p), Te = M([M([
-	ge,
-	F,
-	I
-], C), F], te), Ee = M([M([
-	he,
-	F,
-	I
-], C), F], h), H = M([
-	L,
-	u,
-	B,
-	V,
-	o,
-	F,
-	M([
-		L,
-		Se,
-		Ce,
-		we,
-		M([
-			Te,
-			M([M([
-				_e,
-				F,
-				I
-			], C), F], ae),
-			Ee
-		], de)
-	], x)
-], g), De = M([
-	L,
-	H,
-	M([
-		H,
-		L,
-		R
-	], b),
-	F
-], _);
-function U(e) {
-	return fe(e, F(e), I(e), !1);
+var selectTooltipAxisRealScaleType = createSelector([
+	selectTooltipAxis,
+	selectHasBar,
+	selectChartName
+], combineRealScaleType);
+var selectAllGraphicalItemsSettings = createSelector([
+	createSelector([(state) => state.graphicalItems.cartesianItems, (state) => state.graphicalItems.polarItems], (cartesianItems, polarItems) => [...cartesianItems, ...polarItems]),
+	selectTooltipAxis,
+	createSelector([selectTooltipAxisType, selectTooltipAxisId], itemAxisPredicate)
+], combineGraphicalItemsSettings);
+/**
+* Data for tooltip always use the data with indexes set by a Brush,
+* and never accept the isPanorama flag:
+* because Tooltip never displays inside the panorama anyway
+* so we don't need to worry what would happen there.
+*/
+var selectTooltipDisplayedData = createSelector([createSelector([selectAllGraphicalItemsSettings], combineGraphicalItemsData), selectChartDataWithIndexes], combineDisplayedData);
+var selectAllTooltipAppliedValues = createSelector([
+	selectTooltipDisplayedData,
+	selectTooltipAxis,
+	selectAllGraphicalItemsSettings
+], combineAppliedValues);
+var selectTooltipAxisDomainDefinition = createSelector([selectTooltipAxis], getDomainDefinition);
+var selectTooltipDomainOfStackGroups = createSelector([
+	createSelector([
+		selectTooltipDisplayedData,
+		selectAllGraphicalItemsSettings,
+		selectStackOffsetType
+	], combineStackGroups),
+	selectChartDataWithIndexes,
+	selectTooltipAxisType
+], combineDomainOfStackGroups);
+var selectTooltipAllAppliedNumericalValuesIncludingErrorValues = createSelector([
+	selectTooltipDisplayedData,
+	selectTooltipAxis,
+	createSelector([selectAllGraphicalItemsSettings], filterGraphicalNotStackedItems),
+	selectTooltipAxisType
+], combineAppliedNumericalValuesIncludingErrorValues);
+var selectTooltipReferenceDotsDomain = createSelector([createSelector([
+	selectReferenceDots,
+	selectTooltipAxisType,
+	selectTooltipAxisId
+], filterReferenceElements), selectTooltipAxisType], combineDotsDomain);
+var selectTooltipReferenceAreasDomain = createSelector([createSelector([
+	selectReferenceAreas,
+	selectTooltipAxisType,
+	selectTooltipAxisId
+], filterReferenceElements), selectTooltipAxisType], combineAreasDomain);
+var selectTooltipAxisDomain = createSelector([
+	selectTooltipAxis,
+	selectChartLayout,
+	selectTooltipDisplayedData,
+	selectAllTooltipAppliedValues,
+	selectStackOffsetType,
+	selectTooltipAxisType,
+	createSelector([
+		selectTooltipAxis,
+		selectTooltipAxisDomainDefinition,
+		selectTooltipDomainOfStackGroups,
+		selectTooltipAllAppliedNumericalValuesIncludingErrorValues,
+		createSelector([
+			selectTooltipReferenceDotsDomain,
+			createSelector([createSelector([
+				selectReferenceLines,
+				selectTooltipAxisType,
+				selectTooltipAxisId
+			], filterReferenceElements), selectTooltipAxisType], combineLinesDomain),
+			selectTooltipReferenceAreasDomain
+		], mergeDomains)
+	], combineNumericalDomain)
+], combineAxisDomain);
+var selectTooltipAxisDomainIncludingNiceTicks = createSelector([
+	selectTooltipAxis,
+	selectTooltipAxisDomain,
+	createSelector([
+		selectTooltipAxisDomain,
+		selectTooltipAxis,
+		selectTooltipAxisRealScaleType
+	], combineNiceTicks),
+	selectTooltipAxisType
+], combineAxisDomainWithNiceTicks);
+function selectTooltipAxisRange(state) {
+	return selectAxisRange(state, selectTooltipAxisType(state), selectTooltipAxisId(state), false);
 }
-var W = M([L, U], s), G = M([
-	L,
-	R,
-	De,
-	W
-], oe), Oe = M([
-	u,
-	V,
-	L,
-	F
-], ne), ke = M([
-	u,
-	V,
-	L,
-	F
-], v);
-function Ae(t, n, r, i, a, o, s, c) {
-	if (!n) return null;
-	let { type: u } = n, d = e(t, c);
-	if (!i) return null;
-	let f = r === "scaleBand" && i.bandwidth ? i.bandwidth() / 2 : 2, p = u === "category" && i.bandwidth ? i.bandwidth() / f : 0;
-	return p = c === "angleAxis" && a != null && a?.length >= 2 ? l(a[0] - a[1]) * 2 * p : p, d && s ? s.map((e, t) => ({
-		coordinate: i(e) + p,
-		value: e,
-		index: t,
-		offset: p
-	})) : i.domain().map((e, t) => ({
-		coordinate: i(e) + p,
-		value: o ? o[e] : e,
-		index: t,
-		offset: p
+var selectTooltipAxisRangeWithReverse = createSelector([selectTooltipAxis, selectTooltipAxisRange], combineAxisRangeWithReverse);
+var selectTooltipAxisScale = createSelector([
+	selectTooltipAxis,
+	selectTooltipAxisRealScaleType,
+	selectTooltipAxisDomainIncludingNiceTicks,
+	selectTooltipAxisRangeWithReverse
+], combineScaleFunction);
+var selectTooltipDuplicateDomain = createSelector([
+	selectChartLayout,
+	selectAllTooltipAppliedValues,
+	selectTooltipAxis,
+	selectTooltipAxisType
+], combineDuplicateDomain);
+var selectTooltipCategoricalDomain = createSelector([
+	selectChartLayout,
+	selectAllTooltipAppliedValues,
+	selectTooltipAxis,
+	selectTooltipAxisType
+], combineCategoricalDomain);
+function combineTicksOfTooltipAxis(layout, axis, realScaleType, scale, range, duplicateDomain, categoricalDomain, axisType) {
+	if (!axis) return null;
+	const { type } = axis;
+	const isCategorical = isCategoricalAxis(layout, axisType);
+	if (!scale) return null;
+	const offsetForBand = realScaleType === "scaleBand" && scale.bandwidth ? scale.bandwidth() / 2 : 2;
+	let offset = type === "category" && scale.bandwidth ? scale.bandwidth() / offsetForBand : 0;
+	offset = axisType === "angleAxis" && range != null && range?.length >= 2 ? mathSign(range[0] - range[1]) * 2 * offset : offset;
+	if (isCategorical && categoricalDomain) return categoricalDomain.map((entry, index) => ({
+		coordinate: scale(entry) + offset,
+		value: entry,
+		index,
+		offset
+	}));
+	return scale.domain().map((entry, index) => ({
+		coordinate: scale(entry) + offset,
+		value: duplicateDomain ? duplicateDomain[entry] : entry,
+		index,
+		offset
 	}));
 }
-var K = M([
-	u,
-	L,
-	R,
-	G,
-	U,
-	Oe,
-	ke,
-	F
-], Ae), q = M([
-	ye,
-	be,
-	T
-], (e, t, n) => ve(n.shared, e, t)), J = (e) => e.tooltip.settings.trigger, Y = (e) => e.tooltip.settings.defaultIndex, X = M([
-	j,
-	q,
-	J,
-	Y
-], E), Z = M([
-	X,
-	B,
-	M([L], (e) => e?.dataKey),
-	H
-], D), Q = M([K, Z], w), je = M([X], (e) => {
-	if (e) return e.dataKey;
-}), $ = M([
-	j,
-	q,
-	J,
-	Y
-], k), Me = M([X, M([
-	r,
-	n,
-	u,
-	i,
-	K,
-	Y,
-	$,
-	A
-], O)], (e, t) => e.coordinate ?? t), Ne = M([X], (e) => e.active);
-M([M([
-	$,
-	Z,
-	t,
-	L,
-	Q,
-	A,
-	q
-], P)], (e) => {
-	if (e == null) return;
-	let t = e.map((e) => e.payload).filter((e) => e != null);
-	return Array.from(new Set(t));
+var selectTooltipAxisTicks = createSelector([
+	selectChartLayout,
+	selectTooltipAxis,
+	selectTooltipAxisRealScaleType,
+	selectTooltipAxisScale,
+	selectTooltipAxisRange,
+	selectTooltipDuplicateDomain,
+	selectTooltipCategoricalDomain,
+	selectTooltipAxisType
+], combineTicksOfTooltipAxis);
+var selectTooltipEventType = createSelector([
+	selectDefaultTooltipEventType,
+	selectValidateTooltipEventTypes,
+	selectTooltipSettings
+], (defaultTooltipEventType, validateTooltipEventType, settings) => combineTooltipEventType(settings.shared, defaultTooltipEventType, validateTooltipEventType));
+var selectTooltipTrigger = (state) => state.tooltip.settings.trigger;
+var selectDefaultIndex = (state) => state.tooltip.settings.defaultIndex;
+var selectTooltipInteractionState = createSelector([
+	selectTooltipState,
+	selectTooltipEventType,
+	selectTooltipTrigger,
+	selectDefaultIndex
+], combineTooltipInteractionState);
+var selectActiveTooltipIndex = createSelector([
+	selectTooltipInteractionState,
+	selectTooltipDisplayedData,
+	createSelector([selectTooltipAxis], (axis) => axis?.dataKey),
+	selectTooltipAxisDomain
+], combineActiveTooltipIndex);
+var selectActiveLabel = createSelector([selectTooltipAxisTicks, selectActiveTooltipIndex], combineActiveLabel);
+var selectActiveTooltipDataKey = createSelector([selectTooltipInteractionState], (tooltipInteraction) => {
+	if (!tooltipInteraction) return;
+	return tooltipInteraction.dataKey;
+});
+var selectTooltipPayloadConfigurations = createSelector([
+	selectTooltipState,
+	selectTooltipEventType,
+	selectTooltipTrigger,
+	selectDefaultIndex
+], combineTooltipPayloadConfigurations);
+var selectActiveTooltipCoordinate = createSelector([selectTooltipInteractionState, createSelector([
+	selectChartWidth,
+	selectChartHeight,
+	selectChartLayout,
+	selectChartOffset,
+	selectTooltipAxisTicks,
+	selectDefaultIndex,
+	selectTooltipPayloadConfigurations,
+	selectTooltipPayloadSearcher
+], combineCoordinateForDefaultIndex)], (tooltipInteractionState, defaultIndexCoordinate) => {
+	return tooltipInteractionState.coordinate ?? defaultIndexCoordinate;
+});
+var selectIsTooltipActive = createSelector([selectTooltipInteractionState], (tooltipInteractionState) => tooltipInteractionState.active);
+createSelector([createSelector([
+	selectTooltipPayloadConfigurations,
+	selectActiveTooltipIndex,
+	selectChartDataWithIndexes,
+	selectTooltipAxis,
+	selectActiveLabel,
+	selectTooltipPayloadSearcher,
+	selectTooltipEventType
+], combineTooltipPayload)], (payload) => {
+	if (payload == null) return;
+	const dataPoints = payload.map((p) => p.payload).filter((p) => p != null);
+	return Array.from(new Set(dataPoints));
 });
 //#endregion
-export { P as combineTooltipPayload, Q as selectActiveLabel, Me as selectActiveTooltipCoordinate, je as selectActiveTooltipDataKey, Z as selectActiveTooltipIndex, Ne as selectIsTooltipActive, L as selectTooltipAxis, H as selectTooltipAxisDomain, W as selectTooltipAxisRangeWithReverse, G as selectTooltipAxisScale, K as selectTooltipAxisTicks, F as selectTooltipAxisType, B as selectTooltipDisplayedData };
+export { combineTooltipPayload, selectActiveLabel, selectActiveTooltipCoordinate, selectActiveTooltipDataKey, selectActiveTooltipIndex, selectIsTooltipActive, selectTooltipAxis, selectTooltipAxisDomain, selectTooltipAxisRangeWithReverse, selectTooltipAxisScale, selectTooltipAxisTicks, selectTooltipAxisType, selectTooltipDisplayedData };

package/dist/es/state/selectors/touchSelectors.mjs

@@ -1,16 +1,19 @@
-import { selectTooltipPayloadSearcher as e } from "./selectTooltipPayloadSearcher.mjs";
-import { selectTooltipState as t } from "./selectTooltipState.mjs";
-import { createSelector as n } from "@reduxjs/toolkit";
-var r = n([
-	n([t], (e) => e.tooltipItemPayloads),
-	e,
-	(e, t, n) => t,
-	(e, t, n) => n
-], (e, t, n, r) => {
-	let i = e.find((e) => e.settings.dataKey === r);
-	if (i == null) return;
-	let { positions: a } = i;
-	if (a != null) return t?.(a, n);
+import { selectTooltipPayloadSearcher } from "./selectTooltipPayloadSearcher.mjs";
+import { selectTooltipState } from "./selectTooltipState.mjs";
+import { createSelector } from "@reduxjs/toolkit";
+var selectTooltipCoordinate = createSelector([
+	createSelector([selectTooltipState], (tooltipState) => tooltipState.tooltipItemPayloads),
+	selectTooltipPayloadSearcher,
+	(_state, tooltipIndex, _dataKey) => tooltipIndex,
+	(_state, _tooltipIndex, dataKey) => dataKey
+], (allTooltipConfigurations, tooltipPayloadSearcher, tooltipIndex, dataKey) => {
+	const mostRelevantTooltipConfiguration = allTooltipConfigurations.find((tooltipConfiguration) => {
+		return tooltipConfiguration.settings.dataKey === dataKey;
+	});
+	if (mostRelevantTooltipConfiguration == null) return;
+	const { positions } = mostRelevantTooltipConfiguration;
+	if (positions == null) return;
+	return tooltipPayloadSearcher?.(positions, tooltipIndex);
 });
 //#endregion
-export { r as selectTooltipCoordinate };
+export { selectTooltipCoordinate };

package/dist/es/state/store.mjs

@@ -1,55 +1,55 @@
-import { tooltipReducer as e } from "./tooltipSlice.mjs";
-import { graphicalItemsReducer as t } from "./graphicalItemsSlice.mjs";
-import { legendReducer as n } from "./legendSlice.mjs";
-import { cartesianAxisReducer as r } from "./cartesianAxisSlice.mjs";
-import { referenceElementsReducer as i } from "./referenceElementsSlice.mjs";
-import { optionsReducer as a } from "./optionsSlice.mjs";
-import { chartDataReducer as o } from "./chartDataSlice.mjs";
-import { chartLayoutReducer as s } from "./layoutSlice.mjs";
-import { mouseClickMiddleware as c, mouseMoveMiddleware as l } from "./mouseEventsMiddleware.mjs";
-import { reduxDevtoolsJsonStringifyReplacer as u } from "./reduxDevtoolsJsonStringifyReplacer.mjs";
-import { brushReducer as d } from "./brushSlice.mjs";
-import { rootPropsReducer as f } from "./rootPropsSlice.mjs";
-import { polarAxisReducer as p } from "./polarAxisSlice.mjs";
-import { polarOptionsReducer as m } from "./polarOptionsSlice.mjs";
-import { keyboardEventsMiddleware as h } from "./keyboardEventsMiddleware.mjs";
-import { externalEventsMiddleware as g } from "./externalEventsMiddleware.mjs";
-import { touchEventMiddleware as _ } from "./touchEventsMiddleware.mjs";
-import { combineReducers as v, configureStore as y } from "@reduxjs/toolkit";
+import { tooltipReducer } from "./tooltipSlice.mjs";
+import { graphicalItemsReducer } from "./graphicalItemsSlice.mjs";
+import { legendReducer } from "./legendSlice.mjs";
+import { cartesianAxisReducer } from "./cartesianAxisSlice.mjs";
+import { referenceElementsReducer } from "./referenceElementsSlice.mjs";
+import { optionsReducer } from "./optionsSlice.mjs";
+import { chartDataReducer } from "./chartDataSlice.mjs";
+import { chartLayoutReducer } from "./layoutSlice.mjs";
+import { mouseClickMiddleware, mouseMoveMiddleware } from "./mouseEventsMiddleware.mjs";
+import { reduxDevtoolsJsonStringifyReplacer } from "./reduxDevtoolsJsonStringifyReplacer.mjs";
+import { brushReducer } from "./brushSlice.mjs";
+import { rootPropsReducer } from "./rootPropsSlice.mjs";
+import { polarAxisReducer } from "./polarAxisSlice.mjs";
+import { polarOptionsReducer } from "./polarOptionsSlice.mjs";
+import { keyboardEventsMiddleware } from "./keyboardEventsMiddleware.mjs";
+import { externalEventsMiddleware } from "./externalEventsMiddleware.mjs";
+import { touchEventMiddleware } from "./touchEventsMiddleware.mjs";
+import { combineReducers, configureStore } from "@reduxjs/toolkit";
 //#region src/state/store.ts
-var b = v({
-	brush: d,
-	cartesianAxis: r,
-	chartData: o,
-	graphicalItems: t,
-	layout: s,
-	legend: n,
-	options: a,
-	polarAxis: p,
-	polarOptions: m,
-	referenceElements: i,
-	rootProps: f,
-	tooltip: e
+var rootReducer = combineReducers({
+	brush: brushReducer,
+	cartesianAxis: cartesianAxisReducer,
+	chartData: chartDataReducer,
+	graphicalItems: graphicalItemsReducer,
+	layout: chartLayoutReducer,
+	legend: legendReducer,
+	options: optionsReducer,
+	polarAxis: polarAxisReducer,
+	polarOptions: polarOptionsReducer,
+	referenceElements: referenceElementsReducer,
+	rootProps: rootPropsReducer,
+	tooltip: tooltipReducer
 });
-function x(e, t = "Chart") {
-	return y({
-		reducer: b,
-		preloadedState: e,
-		middleware: (e) => e({
-			serializableCheck: !1,
-			immutableCheck: !1
+function createRechartsStore(preloadedState, chartName = "Chart") {
+	return configureStore({
+		reducer: rootReducer,
+		preloadedState,
+		middleware: (getDefaultMiddleware) => getDefaultMiddleware({
+			serializableCheck: false,
+			immutableCheck: false
 		}).concat([
-			c.middleware,
-			l.middleware,
-			h.middleware,
-			g,
-			_.middleware
+			mouseClickMiddleware.middleware,
+			mouseMoveMiddleware.middleware,
+			keyboardEventsMiddleware.middleware,
+			externalEventsMiddleware,
+			touchEventMiddleware.middleware
 		]),
 		devTools: {
-			serialize: { replacer: u },
-			name: `v-charts-${t}`
+			serialize: { replacer: reduxDevtoolsJsonStringifyReplacer },
+			name: `v-charts-${chartName}`
 		}
 	});
 }
 //#endregion
-export { x as createRechartsStore };
+export { createRechartsStore };