@sveltery/recharts 0.0.0-stage → 0.1.0

package/dist/state/selectors/selectTooltipState.d.ts

@@ -0,0 +1,3 @@
+import { RechartsRootState } from '../store.js';
+import { TooltipState } from '../tooltipSlice.js';
+export declare const selectTooltipState: (state: RechartsRootState) => TooltipState;

package/dist/state/selectors/selectTooltipState.js

@@ -0,0 +1 @@
+export const selectTooltipState = (state) => state.tooltip;

package/dist/state/selectors/selectors.d.ts

@@ -0,0 +1,39 @@
+import { RechartsRootState } from '../store.js';
+import { ActiveTooltipProps, TooltipIndex, TooltipInteractionState, TooltipPayload, TooltipPayloadConfiguration } from '../tooltipSlice.js';
+import { AxisType, CartesianLayout, ChartOffsetInternal, RelativePointer, Coordinate, DataKey, PolarLayout, PolarViewBoxRequired, TickItem, TooltipEventType } from '../../util/types.js';
+import { TooltipTrigger } from '../../chart/types.js';
+import { AxisRange } from './axisSelectors.js';
+export declare const selectOrderedTooltipTicks: ((state: RechartsRootState) => TickItem[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: readonly TickItem[] | undefined) => TickItem[];
+    memoizedResultFunc: ((resultFuncArgs_0: readonly TickItem[] | undefined) => TickItem[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => TickItem[];
+    dependencies: [(state: RechartsRootState) => ReadonlyArray<TickItem> | undefined];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectTooltipInteractionState: (state: RechartsRootState, tooltipEventType: TooltipEventType | undefined, trigger: TooltipTrigger, defaultIndex: TooltipIndex | undefined) => TooltipInteractionState;
+export declare const selectActiveIndex: (state: RechartsRootState, tooltipEventType: TooltipEventType | undefined, trigger: TooltipTrigger, defaultIndex: TooltipIndex | undefined) => TooltipIndex | null;
+export declare const selectTooltipDataKey: (state: RechartsRootState, tooltipEventType: TooltipEventType | undefined, trigger: TooltipTrigger) => DataKey<any> | undefined;
+export declare const selectTooltipPayloadConfigurations: (state: RechartsRootState, tooltipEventType: TooltipEventType | undefined, trigger: TooltipTrigger, defaultIndex: TooltipIndex | undefined) => ReadonlyArray<TooltipPayloadConfiguration>;
+export declare const selectCoordinateForDefaultIndex: (state: RechartsRootState, tooltipEventType: TooltipEventType | undefined, trigger: TooltipTrigger, defaultIndex: TooltipIndex | undefined) => Coordinate | undefined;
+export declare const selectActiveCoordinate: (state: RechartsRootState, tooltipEventType: TooltipEventType | undefined, trigger: TooltipTrigger, defaultIndex: TooltipIndex | undefined) => Coordinate | undefined;
+export declare const selectActiveLabel: (state: RechartsRootState, tooltipEventType: TooltipEventType | undefined, trigger: TooltipTrigger, defaultIndex: TooltipIndex | undefined) => string | number | undefined;
+export declare const selectTooltipPayload: (state: RechartsRootState, tooltipEventType: TooltipEventType | undefined, trigger: TooltipTrigger, defaultIndex: TooltipIndex | undefined) => TooltipPayload | undefined;
+export declare const selectIsTooltipActive: (state: RechartsRootState, tooltipEventType: TooltipEventType | undefined, trigger: TooltipTrigger, defaultIndex: TooltipIndex | undefined) => {
+    isActive: boolean;
+    activeIndex: TooltipIndex | null;
+};
+export declare const combineActiveProps: (chartEvent: RelativePointer | undefined, layout: CartesianLayout | PolarLayout | undefined, polarViewBox: PolarViewBoxRequired | undefined, tooltipAxisType: AxisType | undefined, tooltipAxisRange: AxisRange | undefined, tooltipTicks: ReadonlyArray<TickItem> | undefined, orderedTooltipTicks: ReadonlyArray<TickItem> | undefined, offset: ChartOffsetInternal) => ActiveTooltipProps | undefined;

package/dist/state/selectors/selectors.hooks.d.ts

@@ -0,0 +1,2 @@
+import { type Box } from '../hooks.svelte.js';
+export declare const useChartName: () => Box<string | undefined>;

package/dist/state/selectors/selectors.hooks.js

@@ -0,0 +1,3 @@
+import { useAppSelector } from '../hooks.svelte.js';
+import { selectChartName } from './rootPropsSelectors.js';
+export const useChartName = () => useAppSelector(selectChartName);

package/dist/state/selectors/selectors.js

@@ -0,0 +1,101 @@
+import { createSelector } from 'reselect';
+import sortBy from 'es-toolkit/compat/sortBy';
+import { calculateCartesianTooltipPos, calculatePolarTooltipPos } from '../../util/ChartUtils.js';
+import { selectChartDataWithIndexes } from './dataSelectors.js';
+import { selectTooltipAxisDomain, selectTooltipAxisTicks, selectTooltipDisplayedData } from './tooltipSelectors.js';
+import { selectTooltipAxisDataKey } from './axisSelectors.js';
+import { selectChartLayout } from '../../context/chartLayoutContext.js';
+import { selectChartOffsetInternal } from './selectChartOffsetInternal.js';
+import { selectChartHeight, selectChartWidth } from './containerSelectors.js';
+import { combineActiveLabel } from './combiners/combineActiveLabel.js';
+import { combineTooltipInteractionState } from './combiners/combineTooltipInteractionState.js';
+import { combineActiveTooltipIndex } from './combiners/combineActiveTooltipIndex.js';
+import { combineCoordinateForDefaultIndex } from './combiners/combineCoordinateForDefaultIndex.js';
+import { combineTooltipPayloadConfigurations } from './combiners/combineTooltipPayloadConfigurations.js';
+import { selectTooltipPayloadSearcher } from './selectTooltipPayloadSearcher.js';
+import { selectTooltipState } from './selectTooltipState.js';
+import { combineTooltipPayload } from './combiners/combineTooltipPayload.js';
+import { calculateActiveTickIndex, getActiveCartesianCoordinate, getActivePolarCoordinate, isInCartesianRange, } from '../../util/getActiveCoordinate.js';
+import { inRangeOfSector } from '../../util/PolarUtils.js';
+const pickTooltipEventType = (_state, tooltipEventType) => tooltipEventType;
+const pickTrigger = (_state, _tooltipEventType, trigger) => trigger;
+const pickDefaultIndex = (_state, _tooltipEventType, _trigger, defaultIndex) => defaultIndex;
+export const selectOrderedTooltipTicks = createSelector(selectTooltipAxisTicks, (ticks) => sortBy(ticks, o => o.coordinate));
+export const selectTooltipInteractionState = createSelector([selectTooltipState, pickTooltipEventType, pickTrigger, pickDefaultIndex], combineTooltipInteractionState);
+export const selectActiveIndex = createSelector([selectTooltipInteractionState, selectTooltipDisplayedData, selectTooltipAxisDataKey, selectTooltipAxisDomain], combineActiveTooltipIndex);
+export const selectTooltipDataKey = (state, tooltipEventType, trigger) => {
+    if (tooltipEventType == null) {
+        return undefined;
+    }
+    const tooltipState = selectTooltipState(state);
+    if (tooltipEventType === 'axis') {
+        if (trigger === 'hover') {
+            return tooltipState.axisInteraction.hover.dataKey;
+        }
+        return tooltipState.axisInteraction.click.dataKey;
+    }
+    if (trigger === 'hover') {
+        return tooltipState.itemInteraction.hover.dataKey;
+    }
+    return tooltipState.itemInteraction.click.dataKey;
+};
+export const selectTooltipPayloadConfigurations = createSelector([selectTooltipState, pickTooltipEventType, pickTrigger, pickDefaultIndex], combineTooltipPayloadConfigurations);
+export const selectCoordinateForDefaultIndex = createSelector([
+    selectChartWidth,
+    selectChartHeight,
+    selectChartLayout,
+    selectChartOffsetInternal,
+    selectTooltipAxisTicks,
+    pickDefaultIndex,
+    selectTooltipPayloadConfigurations,
+], combineCoordinateForDefaultIndex);
+export const selectActiveCoordinate = createSelector([selectTooltipInteractionState, selectCoordinateForDefaultIndex], (tooltipInteractionState, defaultIndexCoordinate) => {
+    return tooltipInteractionState.coordinate ?? defaultIndexCoordinate;
+});
+export const selectActiveLabel = createSelector([selectTooltipAxisTicks, selectActiveIndex], combineActiveLabel);
+export const selectTooltipPayload = createSelector([
+    selectTooltipPayloadConfigurations,
+    selectActiveIndex,
+    selectChartDataWithIndexes,
+    selectTooltipAxisDataKey,
+    selectActiveLabel,
+    selectTooltipPayloadSearcher,
+    pickTooltipEventType,
+], combineTooltipPayload);
+export const selectIsTooltipActive = createSelector([selectTooltipInteractionState, selectActiveIndex], (tooltipInteractionState, activeIndex) => {
+    return { isActive: tooltipInteractionState.active && activeIndex != null, activeIndex };
+});
+const combineActiveCartesianProps = (chartEvent, layout, tooltipAxisType, tooltipAxisRange, tooltipTicks, orderedTooltipTicks, offset) => {
+    if (!chartEvent || !tooltipAxisType || !tooltipAxisRange || !tooltipTicks) {
+        return undefined;
+    }
+    if (!isInCartesianRange(chartEvent, offset)) {
+        return undefined;
+    }
+    const pos = calculateCartesianTooltipPos(chartEvent, layout);
+    const activeIndex = calculateActiveTickIndex(pos, orderedTooltipTicks, tooltipTicks, tooltipAxisType, tooltipAxisRange);
+    const activeCoordinate = getActiveCartesianCoordinate(layout, tooltipTicks, activeIndex, chartEvent);
+    return { activeIndex: String(activeIndex), activeCoordinate };
+};
+const combineActivePolarProps = (chartEvent, layout, polarViewBox, tooltipAxisType, tooltipAxisRange, tooltipTicks, orderedTooltipTicks) => {
+    if (!chartEvent || !tooltipAxisType || !tooltipAxisRange || !tooltipTicks || !polarViewBox) {
+        return undefined;
+    }
+    const rangeObj = inRangeOfSector(chartEvent, polarViewBox);
+    if (!rangeObj) {
+        return undefined;
+    }
+    const pos = calculatePolarTooltipPos(rangeObj, layout);
+    const activeIndex = calculateActiveTickIndex(pos, orderedTooltipTicks, tooltipTicks, tooltipAxisType, tooltipAxisRange);
+    const activeCoordinate = getActivePolarCoordinate(layout, tooltipTicks, activeIndex, rangeObj);
+    return { activeIndex: String(activeIndex), activeCoordinate };
+};
+export const combineActiveProps = (chartEvent, layout, polarViewBox, tooltipAxisType, tooltipAxisRange, tooltipTicks, orderedTooltipTicks, offset) => {
+    if (!chartEvent || !layout || !tooltipAxisType || !tooltipAxisRange || !tooltipTicks) {
+        return undefined;
+    }
+    if (layout === 'horizontal' || layout === 'vertical') {
+        return combineActiveCartesianProps(chartEvent, layout, tooltipAxisType, tooltipAxisRange, tooltipTicks, orderedTooltipTicks, offset);
+    }
+    return combineActivePolarProps(chartEvent, layout, polarViewBox, tooltipAxisType, tooltipAxisRange, tooltipTicks, orderedTooltipTicks);
+};

package/dist/state/selectors/tooltipSelectors.d.ts

@@ -0,0 +1,81 @@
+import { RechartsRootState } from '../store.js';
+import { AxisRange } from './axisSelectors.js';
+import { CategoricalDomain, Coordinate, RechartsScaleType, DataKey, NumberDomain, TickItem } from '../../util/types.js';
+import { ChartData } from '../chartDataSlice.js';
+import { CartesianGraphicalItemSettings, GraphicalItemSettings, PolarGraphicalItemSettings } from '../graphicalItemsSlice.js';
+import { TooltipIndex, TooltipPayload } from '../tooltipSlice.js';
+import { ActiveLabel } from '../../synchronisation/types.js';
+import { RechartsScale } from '../../util/scale/RechartsScale.js';
+export declare const selectTooltipAxisRealScaleType: (state: RechartsRootState) => RechartsScaleType | undefined;
+export declare const selectAllUnfilteredGraphicalItems: (state: RechartsRootState) => ReadonlyArray<CartesianGraphicalItemSettings | PolarGraphicalItemSettings>;
+export declare const selectAllGraphicalItemsSettings: (state: RechartsRootState) => ReadonlyArray<GraphicalItemSettings>;
+export declare const selectTooltipGraphicalItemsData: ((state: RechartsRootState) => unknown[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: readonly GraphicalItemSettings[]) => unknown[];
+    memoizedResultFunc: ((resultFuncArgs_0: readonly GraphicalItemSettings[]) => unknown[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => unknown[];
+    dependencies: [(state: RechartsRootState) => ReadonlyArray<GraphicalItemSettings>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * 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.
+ */
+export declare const selectTooltipDisplayedData: (state: RechartsRootState) => ChartData;
+export declare const selectTooltipAxisDomain: (state: RechartsRootState) => NumberDomain | CategoricalDomain | undefined;
+export declare const selectTooltipAxisDomainIncludingNiceTicks: (state: RechartsRootState) => NumberDomain | CategoricalDomain | undefined;
+export declare const selectTooltipAxisRangeWithReverse: (state: RechartsRootState) => AxisRange | undefined;
+export declare const selectTooltipAxisScale: (state: RechartsRootState) => RechartsScale | undefined;
+export declare const selectTooltipCategoricalDomain: (state: RechartsRootState) => ReadonlyArray<unknown> | undefined;
+/**
+ * Of on four almost identical implementations of tick generation.
+ * The four horsemen of tick generation are:
+ * - {@link selectTooltipAxisTicks}
+ * - {@link combineAxisTicks}
+ * - {@link getTicksOfAxis}.
+ * - {@link combineGraphicalItemTicks}
+ */
+export declare const selectTooltipAxisTicks: (state: RechartsRootState) => ReadonlyArray<TickItem> | undefined;
+export declare const selectActiveTooltipIndex: (state: RechartsRootState) => TooltipIndex | null;
+export declare const selectActiveLabel: (state: RechartsRootState) => ActiveLabel;
+export declare const selectActiveTooltipDataKey: (state: RechartsRootState) => DataKey<any> | undefined;
+export declare const selectActiveTooltipGraphicalItemId: (state: RechartsRootState) => string | undefined;
+export declare const selectActiveTooltipCoordinate: (state: RechartsRootState) => Coordinate | undefined;
+export declare const selectIsTooltipActive: (state: RechartsRootState) => boolean;
+export declare const selectActiveTooltipPayload: (state: RechartsRootState) => TooltipPayload | undefined;
+export declare const selectActiveTooltipDataPoints: ((state: RechartsRootState) => any[] | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: TooltipPayload | undefined) => any[] | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: TooltipPayload | undefined) => any[] | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => any[] | undefined;
+    dependencies: [(state: RechartsRootState) => TooltipPayload | undefined];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};

package/dist/state/selectors/tooltipSelectors.js

@@ -0,0 +1,238 @@
+import { createSelector } from 'reselect';
+import { combineAppliedValues, combineAreasDomain, combineAxisDomain, combineAxisDomainWithNiceTicks, combineCategoricalDomain, combineDisplayedData, combineDomainOfAllAppliedNumericalValuesIncludingErrorValues, combineDomainOfStackGroups, combineDotsDomain, combineDuplicateDomain, combineGraphicalItemsData, combineGraphicalItemsSettings, combineLinesDomain, combineNiceTicks, combineNumericalDomain, combineStackGroups, filterGraphicalNotStackedItems, filterReferenceElements, getDomainDefinition, itemAxisPredicate, mergeDomains, selectAllErrorBarSettings, selectAxisRange, selectHasBar, selectReferenceAreas, selectReferenceDots, selectReferenceLines, selectTooltipAxis, selectTooltipAxisDataKey, } from './axisSelectors.js';
+import { selectChartLayout } from '../../context/chartLayoutContext.js';
+import { isCategoricalAxis } from '../../util/ChartUtils.js';
+import { selectChartDataWithIndexes } from './dataSelectors.js';
+import { selectChartName, selectReverseStackOrder, selectStackOffsetType } from './rootPropsSelectors.js';
+import { isNotNil, mathSign } from '../../util/DataUtils.js';
+import { combineAxisRangeWithReverse } from './combiners/combineAxisRangeWithReverse.js';
+import { combineTooltipEventType, selectDefaultTooltipEventType, selectValidateTooltipEventTypes, } from './selectTooltipEventType.js';
+import { combineActiveLabel } from './combiners/combineActiveLabel.js';
+import { selectTooltipSettings } from './selectTooltipSettings.js';
+import { combineTooltipInteractionState } from './combiners/combineTooltipInteractionState.js';
+import { combineActiveTooltipIndex } from './combiners/combineActiveTooltipIndex.js';
+import { combineCoordinateForDefaultIndex } from './combiners/combineCoordinateForDefaultIndex.js';
+import { selectChartHeight, selectChartWidth } from './containerSelectors.js';
+import { selectChartOffsetInternal } from './selectChartOffsetInternal.js';
+import { combineTooltipPayloadConfigurations } from './combiners/combineTooltipPayloadConfigurations.js';
+import { selectTooltipPayloadSearcher } from './selectTooltipPayloadSearcher.js';
+import { selectTooltipState } from './selectTooltipState.js';
+import { combineTooltipPayload } from './combiners/combineTooltipPayload.js';
+import { selectTooltipAxisId } from './selectTooltipAxisId.js';
+import { selectTooltipAxisType } from './selectTooltipAxisType.js';
+import { combineDisplayedStackedData } from './combiners/combineDisplayedStackedData.js';
+import { isStacked } from '../types/StackedGraphicalItem.js';
+import { numericalDomainSpecifiedWithoutRequiringData } from '../../util/isDomainSpecifiedByUser.js';
+import { numberDomainEqualityCheck } from './numberDomainEqualityCheck.js';
+import { emptyArraysAreEqualCheck } from './arrayEqualityCheck.js';
+import { rechartsScaleFactory } from '../../util/scale/RechartsScale.js';
+import { isWellBehavedNumber } from '../../util/isWellBehavedNumber.js';
+import { combineRealScaleType } from './combiners/combineRealScaleType.js';
+import { combineConfiguredScale } from './combiners/combineConfiguredScale.js';
+export const selectTooltipAxisRealScaleType = createSelector([selectTooltipAxis, selectHasBar, selectChartName], combineRealScaleType);
+export const selectAllUnfilteredGraphicalItems = createSelector([
+    (state) => state.graphicalItems.cartesianItems,
+    (state) => state.graphicalItems.polarItems,
+], (cartesianItems, polarItems) => [...cartesianItems, ...polarItems]);
+const selectTooltipAxisPredicate = createSelector([selectTooltipAxisType, selectTooltipAxisId], itemAxisPredicate);
+export const selectAllGraphicalItemsSettings = createSelector([selectAllUnfilteredGraphicalItems, selectTooltipAxis, selectTooltipAxisPredicate], combineGraphicalItemsSettings, {
+    memoizeOptions: {
+        resultEqualityCheck: emptyArraysAreEqualCheck,
+    },
+});
+const selectAllStackedGraphicalItemsSettings = createSelector([selectAllGraphicalItemsSettings], (graphicalItems) => graphicalItems.filter(isStacked));
+export const selectTooltipGraphicalItemsData = createSelector([selectAllGraphicalItemsSettings], combineGraphicalItemsData, {
+    memoizeOptions: {
+        resultEqualityCheck: emptyArraysAreEqualCheck,
+    },
+});
+/**
+ * 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.
+ */
+export const selectTooltipDisplayedData = createSelector([selectTooltipGraphicalItemsData, selectChartDataWithIndexes], combineDisplayedData);
+const selectTooltipStackedData = createSelector([selectAllStackedGraphicalItemsSettings, selectChartDataWithIndexes, selectTooltipAxis], combineDisplayedStackedData);
+const selectAllTooltipAppliedValues = createSelector([selectTooltipDisplayedData, selectTooltipAxis, selectAllGraphicalItemsSettings], combineAppliedValues);
+const selectTooltipAxisDomainDefinition = createSelector([selectTooltipAxis], getDomainDefinition);
+const selectTooltipDataOverflow = createSelector([selectTooltipAxis], axisSettings => axisSettings.allowDataOverflow);
+const selectTooltipDomainFromUserPreferences = createSelector([selectTooltipAxisDomainDefinition, selectTooltipDataOverflow], numericalDomainSpecifiedWithoutRequiringData);
+const selectAllStackedGraphicalItems = createSelector([selectAllGraphicalItemsSettings], (graphicalItems) => graphicalItems.filter(isStacked));
+const selectTooltipStackGroups = createSelector([selectTooltipStackedData, selectAllStackedGraphicalItems, selectStackOffsetType, selectReverseStackOrder], combineStackGroups);
+const selectTooltipDomainOfStackGroups = createSelector([selectTooltipStackGroups, selectChartDataWithIndexes, selectTooltipAxisType, selectTooltipDomainFromUserPreferences], combineDomainOfStackGroups);
+const selectTooltipItemsSettingsExceptStacked = createSelector([selectAllGraphicalItemsSettings], filterGraphicalNotStackedItems);
+const selectDomainOfAllAppliedNumericalValuesIncludingErrorValues = createSelector([
+    selectTooltipDisplayedData,
+    selectTooltipAxis,
+    selectTooltipItemsSettingsExceptStacked,
+    selectAllErrorBarSettings,
+    selectTooltipAxisType,
+], combineDomainOfAllAppliedNumericalValuesIncludingErrorValues, {
+    memoizeOptions: {
+        resultEqualityCheck: numberDomainEqualityCheck,
+    },
+});
+const selectReferenceDotsByTooltipAxis = createSelector([selectReferenceDots, selectTooltipAxisType, selectTooltipAxisId], filterReferenceElements);
+const selectTooltipReferenceDotsDomain = createSelector([selectReferenceDotsByTooltipAxis, selectTooltipAxisType], combineDotsDomain);
+const selectReferenceAreasByTooltipAxis = createSelector([selectReferenceAreas, selectTooltipAxisType, selectTooltipAxisId], filterReferenceElements);
+const selectTooltipReferenceAreasDomain = createSelector([selectReferenceAreasByTooltipAxis, selectTooltipAxisType], combineAreasDomain);
+const selectReferenceLinesByTooltipAxis = createSelector([selectReferenceLines, selectTooltipAxisType, selectTooltipAxisId], filterReferenceElements);
+const selectTooltipReferenceLinesDomain = createSelector([selectReferenceLinesByTooltipAxis, selectTooltipAxisType], combineLinesDomain);
+const selectTooltipReferenceElementsDomain = createSelector([selectTooltipReferenceDotsDomain, selectTooltipReferenceLinesDomain, selectTooltipReferenceAreasDomain], mergeDomains);
+const selectTooltipNumericalDomain = createSelector([
+    selectTooltipAxis,
+    selectTooltipAxisDomainDefinition,
+    selectTooltipDomainFromUserPreferences,
+    selectTooltipDomainOfStackGroups,
+    selectDomainOfAllAppliedNumericalValuesIncludingErrorValues,
+    selectTooltipReferenceElementsDomain,
+    selectChartLayout,
+    selectTooltipAxisType,
+], combineNumericalDomain);
+export const selectTooltipAxisDomain = createSelector([
+    selectTooltipAxis,
+    selectChartLayout,
+    selectTooltipDisplayedData,
+    selectAllTooltipAppliedValues,
+    selectStackOffsetType,
+    selectTooltipAxisType,
+    selectTooltipNumericalDomain,
+], combineAxisDomain);
+const selectTooltipNiceTicks = createSelector([selectTooltipAxisDomain, selectTooltipAxis, selectTooltipAxisRealScaleType], combineNiceTicks);
+export const selectTooltipAxisDomainIncludingNiceTicks = createSelector([selectTooltipAxis, selectTooltipAxisDomain, selectTooltipNiceTicks, selectTooltipAxisType], combineAxisDomainWithNiceTicks);
+const selectTooltipAxisRange = (state) => {
+    const axisType = selectTooltipAxisType(state);
+    const axisId = selectTooltipAxisId(state);
+    const isPanorama = false; // Tooltip never displays in panorama so this is safe to assume
+    return selectAxisRange(state, axisType, axisId, isPanorama);
+};
+export const selectTooltipAxisRangeWithReverse = createSelector([selectTooltipAxis, selectTooltipAxisRange], combineAxisRangeWithReverse);
+const selectTooltipConfiguredScale = createSelector([
+    selectTooltipAxis,
+    selectTooltipAxisRealScaleType,
+    selectTooltipAxisDomainIncludingNiceTicks,
+    selectTooltipAxisRangeWithReverse,
+], combineConfiguredScale);
+export const selectTooltipAxisScale = createSelector([selectTooltipConfiguredScale], rechartsScaleFactory);
+const selectTooltipDuplicateDomain = createSelector([selectChartLayout, selectAllTooltipAppliedValues, selectTooltipAxis, selectTooltipAxisType], combineDuplicateDomain);
+export const selectTooltipCategoricalDomain = createSelector([selectChartLayout, selectAllTooltipAppliedValues, selectTooltipAxis, selectTooltipAxisType], combineCategoricalDomain);
+const combineTicksOfTooltipAxis = (layout, axis, realScaleType, scale, range, duplicateDomain, categoricalDomain, axisType) => {
+    if (!axis) {
+        return undefined;
+    }
+    const { type } = axis;
+    const isCategorical = isCategoricalAxis(layout, axisType);
+    if (!scale) {
+        return undefined;
+    }
+    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;
+    // 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) => {
+            const 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) => {
+        const scaled = scale.map(entry);
+        if (!isWellBehavedNumber(scaled)) {
+            return null;
+        }
+        return {
+            coordinate: scaled + offset,
+            // @ts-expect-error can't use Date as an index
+            value: duplicateDomain ? duplicateDomain[entry] : entry,
+            index,
+            offset,
+        };
+    })
+        .filter(isNotNil);
+};
+/**
+ * Of on four almost identical implementations of tick generation.
+ * The four horsemen of tick generation are:
+ * - {@link selectTooltipAxisTicks}
+ * - {@link combineAxisTicks}
+ * - {@link getTicksOfAxis}.
+ * - {@link combineGraphicalItemTicks}
+ */
+export const selectTooltipAxisTicks = createSelector([
+    selectChartLayout,
+    selectTooltipAxis,
+    selectTooltipAxisRealScaleType,
+    selectTooltipAxisScale,
+    selectTooltipAxisRange,
+    selectTooltipDuplicateDomain,
+    selectTooltipCategoricalDomain,
+    selectTooltipAxisType,
+], combineTicksOfTooltipAxis);
+const selectTooltipEventType = createSelector([selectDefaultTooltipEventType, selectValidateTooltipEventTypes, selectTooltipSettings], (defaultTooltipEventType, validateTooltipEventType, settings) => combineTooltipEventType(settings.shared, defaultTooltipEventType, validateTooltipEventType));
+const selectTooltipTrigger = (state) => state.tooltip.settings.trigger;
+const selectDefaultIndex = state => state.tooltip.settings.defaultIndex;
+const selectTooltipInteractionState = createSelector([selectTooltipState, selectTooltipEventType, selectTooltipTrigger, selectDefaultIndex], combineTooltipInteractionState);
+export const selectActiveTooltipIndex = createSelector([selectTooltipInteractionState, selectTooltipDisplayedData, selectTooltipAxisDataKey, selectTooltipAxisDomain], combineActiveTooltipIndex);
+export const selectActiveLabel = createSelector([selectTooltipAxisTicks, selectActiveTooltipIndex], combineActiveLabel);
+export const selectActiveTooltipDataKey = createSelector([selectTooltipInteractionState], (tooltipInteraction) => {
+    if (!tooltipInteraction) {
+        return undefined;
+    }
+    return tooltipInteraction.dataKey;
+});
+export const selectActiveTooltipGraphicalItemId = createSelector([selectTooltipInteractionState], (tooltipInteraction) => {
+    if (!tooltipInteraction) {
+        return undefined;
+    }
+    return tooltipInteraction.graphicalItemId;
+});
+const selectTooltipPayloadConfigurations = createSelector([selectTooltipState, selectTooltipEventType, selectTooltipTrigger, selectDefaultIndex], combineTooltipPayloadConfigurations);
+const selectTooltipCoordinateForDefaultIndex = createSelector([
+    selectChartWidth,
+    selectChartHeight,
+    selectChartLayout,
+    selectChartOffsetInternal,
+    selectTooltipAxisTicks,
+    selectDefaultIndex,
+    selectTooltipPayloadConfigurations,
+], combineCoordinateForDefaultIndex);
+export const selectActiveTooltipCoordinate = createSelector([selectTooltipInteractionState, selectTooltipCoordinateForDefaultIndex], (tooltipInteractionState, defaultIndexCoordinate) => {
+    if (tooltipInteractionState?.coordinate) {
+        return tooltipInteractionState.coordinate;
+    }
+    return defaultIndexCoordinate;
+});
+export const selectIsTooltipActive = createSelector([selectTooltipInteractionState], (tooltipInteractionState) => tooltipInteractionState?.active ?? false);
+export const selectActiveTooltipPayload = createSelector([
+    selectTooltipPayloadConfigurations,
+    selectActiveTooltipIndex,
+    selectChartDataWithIndexes,
+    selectTooltipAxisDataKey,
+    selectActiveLabel,
+    selectTooltipPayloadSearcher,
+    selectTooltipEventType,
+], combineTooltipPayload);
+export const selectActiveTooltipDataPoints = createSelector([selectActiveTooltipPayload], payload => {
+    if (payload == null) {
+        return undefined;
+    }
+    const dataPoints = payload.map(p => p.payload).filter(p => p != null);
+    return Array.from(new Set(dataPoints));
+});

package/dist/state/selectors/touchSelectors.d.ts

@@ -0,0 +1,5 @@
+import { RechartsRootState } from '../store.js';
+import { TooltipIndex } from '../tooltipSlice.js';
+import { Coordinate } from '../../util/types.js';
+import { GraphicalItemId } from '../graphicalItemsSlice.js';
+export declare const selectTooltipCoordinate: (state: RechartsRootState, tooltipIndex: TooltipIndex, graphicalItemId: GraphicalItemId) => Coordinate | undefined;

package/dist/state/selectors/touchSelectors.js

@@ -0,0 +1,23 @@
+import { createSelector } from 'reselect';
+import { selectTooltipState } from './selectTooltipState.js';
+const selectAllTooltipPayloadConfiguration = createSelector([selectTooltipState], tooltipState => tooltipState.tooltipItemPayloads);
+export const selectTooltipCoordinate = createSelector([
+    selectAllTooltipPayloadConfiguration,
+    (_state, tooltipIndex) => tooltipIndex,
+    (_state, _tooltipIndex, graphicalItemId) => graphicalItemId,
+], (allTooltipConfigurations, tooltipIndex, graphicalItemId) => {
+    if (tooltipIndex == null) {
+        return undefined;
+    }
+    const mostRelevantTooltipConfiguration = allTooltipConfigurations.find(tooltipConfiguration => {
+        return tooltipConfiguration.settings.graphicalItemId === graphicalItemId;
+    });
+    if (mostRelevantTooltipConfiguration == null) {
+        return undefined;
+    }
+    const { getPosition } = mostRelevantTooltipConfiguration;
+    if (getPosition == null) {
+        return undefined;
+    }
+    return getPosition(tooltipIndex);
+});

package/dist/state/store.d.ts

@@ -0,0 +1,37 @@
+import { Action, Dispatch, Store } from '@reduxjs/toolkit';
+import { optionsReducer } from './optionsSlice.js';
+import { tooltipReducer } from './tooltipSlice.js';
+import { chartDataReducer } from './chartDataSlice.js';
+import { chartLayoutReducer } from './layoutSlice.js';
+import { cartesianAxisReducer } from './cartesianAxisSlice.js';
+import { graphicalItemsReducer } from './graphicalItemsSlice.js';
+import { referenceElementsReducer } from './referenceElementsSlice.js';
+import { brushReducer } from './brushSlice.js';
+import { legendReducer } from './legendSlice.js';
+import { rootPropsReducer } from './rootPropsSlice.js';
+import { polarAxisReducer } from './polarAxisSlice.js';
+import { polarOptionsReducer } from './polarOptionsSlice.js';
+import { errorBarReducer } from './errorBarSlice.js';
+import { zIndexReducer } from './zIndexSlice.js';
+import { eventSettingsReducer } from './eventSettingsSlice.js';
+import { renderedTicksReducer } from './renderedTicksSlice.js';
+export type RechartsRootState = {
+    brush: ReturnType<typeof brushReducer>;
+    cartesianAxis: ReturnType<typeof cartesianAxisReducer>;
+    chartData: ReturnType<typeof chartDataReducer>;
+    errorBars: ReturnType<typeof errorBarReducer>;
+    eventSettings: ReturnType<typeof eventSettingsReducer>;
+    graphicalItems: ReturnType<typeof graphicalItemsReducer>;
+    layout: ReturnType<typeof chartLayoutReducer>;
+    legend: ReturnType<typeof legendReducer>;
+    options: ReturnType<typeof optionsReducer>;
+    polarAxis: ReturnType<typeof polarAxisReducer>;
+    polarOptions: ReturnType<typeof polarOptionsReducer>;
+    referenceElements: ReturnType<typeof referenceElementsReducer>;
+    renderedTicks: ReturnType<typeof renderedTicksReducer>;
+    rootProps: ReturnType<typeof rootPropsReducer>;
+    tooltip: ReturnType<typeof tooltipReducer>;
+    zIndex: ReturnType<typeof zIndexReducer>;
+};
+export declare const createRechartsStore: (preloadedState?: Partial<RechartsRootState>, chartName?: string) => Store<RechartsRootState>;
+export type AppDispatch = Dispatch<Action>;

package/dist/state/store.js

@@ -0,0 +1,89 @@
+import { autoBatchEnhancer, combineReducers, configureStore } from '@reduxjs/toolkit';
+import { optionsReducer } from './optionsSlice.js';
+import { tooltipReducer } from './tooltipSlice.js';
+import { chartDataReducer } from './chartDataSlice.js';
+import { chartLayoutReducer } from './layoutSlice.js';
+import { mouseClickMiddleware, mouseMoveMiddleware } from './mouseEventsMiddleware.js';
+import { reduxDevtoolsJsonStringifyReplacer } from './reduxDevtoolsJsonStringifyReplacer.js';
+import { cartesianAxisReducer } from './cartesianAxisSlice.js';
+import { graphicalItemsReducer } from './graphicalItemsSlice.js';
+import { referenceElementsReducer } from './referenceElementsSlice.js';
+import { brushReducer } from './brushSlice.js';
+import { legendReducer } from './legendSlice.js';
+import { rootPropsReducer } from './rootPropsSlice.js';
+import { polarAxisReducer } from './polarAxisSlice.js';
+import { polarOptionsReducer } from './polarOptionsSlice.js';
+import { keyboardEventsMiddleware } from './keyboardEventsMiddleware.js';
+import { externalEventsMiddleware } from './externalEventsMiddleware.js';
+import { touchEventMiddleware } from './touchEventsMiddleware.js';
+import { errorBarReducer } from './errorBarSlice.js';
+import { Global } from '../util/Global.js';
+import { zIndexReducer } from './zIndexSlice.js';
+import { eventSettingsReducer } from './eventSettingsSlice.js';
+import { renderedTicksReducer } from './renderedTicksSlice.js';
+const rootReducer = combineReducers({
+    brush: brushReducer,
+    cartesianAxis: cartesianAxisReducer,
+    chartData: chartDataReducer,
+    errorBars: errorBarReducer,
+    eventSettings: eventSettingsReducer,
+    graphicalItems: graphicalItemsReducer,
+    layout: chartLayoutReducer,
+    legend: legendReducer,
+    options: optionsReducer,
+    polarAxis: polarAxisReducer,
+    polarOptions: polarOptionsReducer,
+    referenceElements: referenceElementsReducer,
+    renderedTicks: renderedTicksReducer,
+    rootProps: rootPropsReducer,
+    tooltip: tooltipReducer,
+    zIndex: zIndexReducer,
+});
+export const createRechartsStore = (preloadedState, chartName = 'Chart') => {
+    return configureStore({
+        reducer: rootReducer,
+        // redux-toolkit v1 types are unhappy with the preloadedState type. Remove the `as any` when bumping to v2
+        preloadedState: preloadedState,
+        // @ts-expect-error redux-toolkit v1 types are unhappy with the middleware array. Remove this comment when bumping to v2
+        middleware: getDefaultMiddleware => getDefaultMiddleware({
+            serializableCheck: false,
+            immutableCheck: !['commonjs', 'es6', 'production'].includes(process.env.NODE_ENV ?? ''),
+        }).concat([
+            mouseClickMiddleware.middleware,
+            mouseMoveMiddleware.middleware,
+            keyboardEventsMiddleware.middleware,
+            externalEventsMiddleware.middleware,
+            touchEventMiddleware.middleware,
+        ]),
+        /*
+         * I can't find out how to satisfy typescript here.
+         * We return `EnhancerArray<[StoreEnhancer<{}, {}>, StoreEnhancer]>` from this function,
+         * but the types say we should return `EnhancerArray<StoreEnhancer<{}, {}>`.
+         * Looks like it's badly inferred generics, but it won't allow me to provide the correct type manually either.
+         * So let's just ignore the error for now.
+         */
+        // @ts-expect-error mismatched generics
+        enhancers: getDefaultEnhancers => {
+            let enhancers = getDefaultEnhancers;
+            if (typeof getDefaultEnhancers === 'function') {
+                /*
+                 * In RTK v2 this is always a function, but in v1 it is an array.
+                 * Because we have @types/redux-toolkit v1 as a dependency, typescript is going to flag this as an error.
+                 * We support both RTK v1 and v2, so we need to do this check.
+                 * https://redux-toolkit.js.org/usage/migrating-rtk-2#configurestoreenhancers-must-be-a-callback
+                 */
+                // @ts-expect-error RTK v2 behaviour on RTK v1 types
+                enhancers = getDefaultEnhancers();
+            }
+            return enhancers.concat(autoBatchEnhancer({
+                type: 'raf',
+            }));
+        },
+        devTools: Global.devToolsEnabled && {
+            serialize: {
+                replacer: reduxDevtoolsJsonStringifyReplacer,
+            },
+            name: `recharts-${chartName}`,
+        },
+    });
+};

package/dist/state/toStoreValue.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Copies the plain objects and arrays of a value that is about to enter the store. Immer freezes what enters the
+ * state, and freezing a Svelte $state proxy throws. Read inside an effect, the copy also subscribes that effect to
+ * every nested field, so mutating the caller's $state dispatches again. Functions, DOM nodes, class instances and
+ * frozen values (already store-owned) are kept by reference.
+ */
+export declare function toStoreValue<T>(value: T, copies?: Map<object, unknown>): T;