vccs 0.6.0 → 1.0.0-beta.2

package/dist/es/events/useChartSynchronisation.mjs

@@ -1,113 +0,0 @@
-import { selectEventEmitter, selectSyncId, selectSyncMethod } from "../state/selectors/rootPropsSelectors.mjs";
-import { setSyncInteraction } from "../state/tooltipSlice.mjs";
-import { selectTooltipAxisTicks } from "../state/selectors/tooltipSelectors.mjs";
-import { useAppDispatch, useAppSelector } from "../state/hooks.mjs";
-import { useChartLayout, useViewBox } from "../context/chartLayoutContext.mjs";
-import { createEventEmitter } from "../state/optionsSlice.mjs";
-import { setDataStartEndIndexes } from "../state/chartDataSlice.mjs";
-import { BRUSH_SYNC_EVENT, TOOLTIP_SYNC_EVENT, eventCenter } from "../utils/events.mjs";
-import { onMounted, watch } from "vue";
-//#region src/events/useChartSynchronisation.tsx
-function useTooltipSyncEventsListener() {
-	const mySyncId = useAppSelector(selectSyncId);
-	const myEventEmitter = useAppSelector(selectEventEmitter);
-	const dispatch = useAppDispatch();
-	const syncMethod = useAppSelector(selectSyncMethod);
-	const tooltipTicks = useAppSelector(selectTooltipAxisTicks);
-	const layout = useChartLayout();
-	const viewBox = useViewBox();
-	watch([
-		useAppSelector((state) => state.rootProps.class),
-		myEventEmitter,
-		mySyncId,
-		syncMethod,
-		tooltipTicks,
-		layout,
-		viewBox
-	], (v, o, onCleanup) => {
-		if (mySyncId.value == null) return;
-		const listener = (incomingSyncId, action, emitter) => {
-			if (myEventEmitter.value === emitter) return;
-			if (mySyncId.value !== incomingSyncId) return;
-			if (syncMethod.value === "index") {
-				dispatch(action);
-				return;
-			}
-			if (tooltipTicks.value == null) return;
-			let activeTick;
-			if (typeof syncMethod.value === "function") {
-				const syncMethodParam = {
-					activeTooltipIndex: action.payload.index == null ? void 0 : Number(action.payload.index),
-					isTooltipActive: action.payload.active,
-					activeIndex: action.payload.index == null ? void 0 : Number(action.payload.index),
-					activeLabel: action.payload.label,
-					activeDataKey: action.payload.dataKey,
-					activeCoordinate: action.payload.coordinate
-				};
-				const activeTooltipIndex = syncMethod.value(tooltipTicks.value, syncMethodParam);
-				activeTick = tooltipTicks.value[activeTooltipIndex];
-			} else if (syncMethod.value === "value") activeTick = tooltipTicks.value.find((tick) => String(tick.value) === action.payload.label);
-			if (activeTick == null || action.payload.active === false) {
-				dispatch(setSyncInteraction({
-					active: false,
-					coordinate: void 0,
-					dataKey: void 0,
-					index: null,
-					label: void 0
-				}));
-				return;
-			}
-			const { x, y } = action.payload.coordinate;
-			const validateChartX = Math.min(x, viewBox.value?.x + viewBox.value?.width);
-			const validateChartY = Math.min(y, viewBox.value?.y + viewBox.value?.height);
-			const activeCoordinate = {
-				x: layout.value === "horizontal" ? activeTick.coordinate : validateChartX,
-				y: layout.value === "horizontal" ? validateChartY : activeTick.coordinate
-			};
-			dispatch(setSyncInteraction({
-				active: action.payload.active,
-				coordinate: activeCoordinate,
-				dataKey: action.payload.dataKey,
-				index: String(activeTick.index),
-				label: action.payload.label
-			}));
-		};
-		eventCenter.on(TOOLTIP_SYNC_EVENT, listener);
-		onCleanup(() => {
-			eventCenter.off(TOOLTIP_SYNC_EVENT, listener);
-		});
-	});
-}
-function useBrushSyncEventsListener() {
-	const mySyncId = useAppSelector(selectSyncId);
-	const myEventEmitter = useAppSelector(selectEventEmitter);
-	const dispatch = useAppDispatch();
-	watch([mySyncId, myEventEmitter], (v, o, onCleanup) => {
-		if (mySyncId == null) return;
-		const listener = (incomingSyncId, action, emitter) => {
-			if (myEventEmitter.value === emitter) return;
-			if (mySyncId.value === incomingSyncId) dispatch(setDataStartEndIndexes(action));
-		};
-		eventCenter.on(BRUSH_SYNC_EVENT, listener);
-		onCleanup(() => {
-			eventCenter.off(BRUSH_SYNC_EVENT, listener);
-		});
-	});
-}
-/**
-* Will receive synchronisation events from other charts.
-*
-* Reads syncMethod from state and decides how to synchronise the tooltip based on that.
-*
-* @returns void
-*/
-function useSynchronisedEventsFromOtherCharts() {
-	const dispatch = useAppDispatch();
-	onMounted(() => {
-		dispatch(createEventEmitter());
-	});
-	useTooltipSyncEventsListener();
-	useBrushSyncEventsListener();
-}
-//#endregion
-export { useSynchronisedEventsFromOtherCharts };

package/dist/es/hooks/useIsAnimating.mjs

@@ -1,28 +0,0 @@
-import { computed, ref, watch } from "vue";
-//#region src/hooks/useIsAnimating.ts
-/**
-* Tracks whether a component is currently animating.
-*
-* When `isAnimationActive` is `false`, always returns `false` regardless of
-* internal state — this ensures `isAnimationActive={false}` immediately
-* disables all animation-gated rendering (e.g. deferred LabelList).
-*
-* When `isAnimationActive` is `true`, starts as `true` and can be set to
-* `false` via the returned ref (typically on animation end).
-*
-* Re-entering `isAnimationActive=true` resets internal state to `true`.
-*/
-function useIsAnimating(isAnimationActive) {
-	const internal = ref(isAnimationActive());
-	watch(isAnimationActive, (active) => {
-		if (active) internal.value = true;
-	});
-	return computed({
-		get: () => isAnimationActive() && internal.value,
-		set: (val) => {
-			internal.value = val;
-		}
-	});
-}
-//#endregion
-export { useIsAnimating };

package/dist/es/state/ReportChartProps.mjs

@@ -1,62 +0,0 @@
-import { classProp } from "../types/common.mjs";
-import { useAppDispatch } from "./hooks.mjs";
-import { updateOptions } from "./rootPropsSlice.mjs";
-import { defineComponent, watchEffect } from "vue";
-//#region src/state/ReportChartProps.tsx
-var ReportChartProps_default = /* @__PURE__ */ defineComponent({
-	name: "ReportChartProps",
-	props: {
-		accessibilityLayer: {
-			type: Boolean,
-			default: true
-		},
-		barCategoryGap: {
-			type: [Number, String],
-			default: "10%"
-		},
-		barGap: {
-			type: Number,
-			default: 4
-		},
-		barSize: {
-			type: [String, Number],
-			default: void 0
-		},
-		class: classProp,
-		maxBarSize: {
-			type: Number,
-			default: void 0
-		},
-		stackOffset: {
-			type: String,
-			default: "none"
-		},
-		syncId: {
-			type: [Number, String],
-			default: void 0
-		},
-		syncMethod: {
-			type: [String, Function],
-			default: "index"
-		}
-	},
-	setup(props) {
-		const dispatch = useAppDispatch();
-		watchEffect(() => {
-			dispatch(updateOptions({
-				accessibilityLayer: props.accessibilityLayer,
-				barCategoryGap: props.barCategoryGap,
-				barGap: props.barGap,
-				barSize: props.barSize,
-				class: props.class,
-				maxBarSize: props.maxBarSize,
-				stackOffset: props.stackOffset,
-				syncId: props.syncId,
-				syncMethod: props.syncMethod
-			}));
-		});
-		return () => null;
-	}
-});
-//#endregion
-export { ReportChartProps_default as default };

package/dist/es/state/ReportMainChartProps.mjs

@@ -1,46 +0,0 @@
-import { useAppDispatch } from "./hooks.mjs";
-import { setChartSize, setLayout, setMargin } from "./layoutSlice.mjs";
-import { defineComponent, watch } from "vue";
-//#region src/state/ReportMainChartProps.ts
-var ReportMainChartProps = defineComponent({
-	name: "ReportMainChartProps",
-	props: {
-		width: {
-			type: Number,
-			required: true
-		},
-		height: {
-			type: Number,
-			required: true
-		},
-		layout: {
-			type: String,
-			required: true
-		},
-		margin: {
-			type: Object,
-			required: true
-		}
-	},
-	setup(props) {
-		const dispatch = useAppDispatch();
-		watch([
-			() => props.width,
-			() => props.height,
-			() => props.layout,
-			() => props.margin
-		], () => {
-			dispatch(setLayout(props.layout));
-			dispatch(setChartSize({
-				width: props.width,
-				height: props.height
-			}));
-			dispatch(setMargin(props.margin));
-		}, { immediate: true });
-		return () => {
-			return null;
-		};
-	}
-});
-//#endregion
-export { ReportMainChartProps };

package/dist/es/state/ReportPolarOptions.mjs

@@ -1,56 +0,0 @@
-import { useAppDispatch } from "./hooks.mjs";
-import { updatePolarOptions } from "./polarOptionsSlice.mjs";
-import { defineComponent, watch } from "vue";
-//#region src/state/ReportPolarOptions.tsx
-var ReportPolarOptions = /* @__PURE__ */ defineComponent({
-	name: "ReportPolarOptions",
-	props: {
-		cx: {
-			type: [Number, String],
-			default: "50%"
-		},
-		cy: {
-			type: [Number, String],
-			default: "50%"
-		},
-		startAngle: {
-			type: Number,
-			default: 90
-		},
-		endAngle: {
-			type: Number,
-			default: -270
-		},
-		innerRadius: {
-			type: [Number, String],
-			default: 0
-		},
-		outerRadius: {
-			type: [Number, String],
-			default: "80%"
-		}
-	},
-	setup(props) {
-		const dispatch = useAppDispatch();
-		watch([
-			() => props.cx,
-			() => props.cy,
-			() => props.startAngle,
-			() => props.endAngle,
-			() => props.innerRadius,
-			() => props.outerRadius
-		], () => {
-			dispatch(updatePolarOptions({
-				cx: props.cx,
-				cy: props.cy,
-				startAngle: props.startAngle,
-				endAngle: props.endAngle,
-				innerRadius: props.innerRadius,
-				outerRadius: props.outerRadius
-			}));
-		}, { immediate: true });
-		return () => null;
-	}
-});
-//#endregion
-export { ReportPolarOptions };

package/dist/es/state/SetGraphicalItem.mjs

@@ -1,49 +0,0 @@
-import { getNormalizedStackId } from "../utils/chart.mjs";
-import { useAppDispatch } from "./hooks.mjs";
-import { addCartesianGraphicalItem, addPolarGraphicalItem, removeCartesianGraphicalItem, removePolarGraphicalItem, replaceCartesianGraphicalItem, replacePolarGraphicalItem } from "./graphicalItemsSlice.mjs";
-import { onUnmounted, unref, watchEffect } from "vue";
-//#region src/state/SetGraphicalItem.ts
-function SetCartesianGraphicalItem(_props) {
-	const dispatch = useAppDispatch();
-	let preSetting = null;
-	watchEffect(() => {
-		const props = unref(_props);
-		const settings = {
-			...props,
-			stackId: getNormalizedStackId(props.stackId)
-		};
-		if (preSetting === null) dispatch(addCartesianGraphicalItem(settings));
-		else if (preSetting !== settings) dispatch(replaceCartesianGraphicalItem({
-			prev: preSetting,
-			next: settings
-		}));
-		preSetting = settings;
-	});
-	onUnmounted(() => {
-		if (preSetting) {
-			dispatch(removeCartesianGraphicalItem(preSetting));
-			preSetting = null;
-		}
-	});
-}
-function SetPolarGraphicalItem(_props) {
-	const dispatch = useAppDispatch();
-	let preSetting = null;
-	watchEffect(() => {
-		const settings = unref(_props);
-		if (preSetting === null) dispatch(addPolarGraphicalItem(settings));
-		else if (preSetting !== settings) dispatch(replacePolarGraphicalItem({
-			prev: preSetting,
-			next: settings
-		}));
-		preSetting = settings;
-	});
-	onUnmounted(() => {
-		if (preSetting) {
-			dispatch(removePolarGraphicalItem(preSetting));
-			preSetting = null;
-		}
-	});
-}
-//#endregion
-export { SetCartesianGraphicalItem, SetPolarGraphicalItem };

package/dist/es/state/SetLegendPayload.mjs

@@ -1,20 +0,0 @@
-import { useIsPanorama } from "../context/PanoramaContextProvider.mjs";
-import { useAppDispatch } from "./hooks.mjs";
-import { addLegendPayload, removeLegendPayload } from "./legendSlice.mjs";
-import { unref, watchEffect } from "vue";
-//#region src/state/SetLegendPayload.ts
-function SetLegendPayload(_legendPayload) {
-	const dispatch = useAppDispatch();
-	const isPanorama = useIsPanorama();
-	watchEffect((onCleanup) => {
-		const legendPayload = unref(_legendPayload);
-		if (isPanorama) return;
-		dispatch(addLegendPayload(legendPayload));
-		onCleanup(() => {
-			dispatch(removeLegendPayload(legendPayload));
-		});
-	});
-	return null;
-}
-//#endregion
-export { SetLegendPayload };

package/dist/es/state/SetTooltipEntrySettings.mjs

@@ -1,19 +0,0 @@
-import { useIsPanorama } from "../context/PanoramaContextProvider.mjs";
-import { addTooltipEntrySettings, removeTooltipEntrySettings } from "./tooltipSlice.mjs";
-import { useAppDispatch } from "./hooks.mjs";
-import { watchEffect } from "vue";
-//#region src/state/SetTooltipEntrySettings.tsx
-function SetTooltipEntrySettings({ fn, args }) {
-	const dispatch = useAppDispatch();
-	const isPanorama = useIsPanorama();
-	watchEffect((onCleanup) => {
-		if (isPanorama) return;
-		const tooltipEntrySettings = fn(args.value);
-		dispatch(addTooltipEntrySettings(tooltipEntrySettings));
-		onCleanup(() => {
-			dispatch(removeTooltipEntrySettings(tooltipEntrySettings));
-		});
-	});
-}
-//#endregion
-export { SetTooltipEntrySettings };

package/dist/es/state/brushSlice.mjs

@@ -1,26 +0,0 @@
-import { createSlice } from "@reduxjs/toolkit";
-//#region src/state/brushSlice.ts
-var initialState = {
-	x: 0,
-	y: 0,
-	width: 0,
-	height: 0,
-	padding: {
-		top: 0,
-		right: 0,
-		bottom: 0,
-		left: 0
-	}
-};
-var brushSlice = createSlice({
-	name: "brush",
-	initialState,
-	reducers: { setBrushSettings(_state, action) {
-		if (action.payload == null) return initialState;
-		return action.payload;
-	} }
-});
-var { setBrushSettings } = brushSlice.actions;
-var brushReducer = brushSlice.reducer;
-//#endregion
-export { brushReducer };

package/dist/es/state/cartesianAxisSlice.mjs

@@ -1,50 +0,0 @@
-import { createSlice } from "@reduxjs/toolkit";
-import { castDraft } from "immer";
-//#region src/state/cartesianAxisSlice.ts
-/**
-* This is the slice where each individual Axis element pushes its own configuration.
-* Prefer to use this one instead of axisSlice.
-*/
-var cartesianAxisSlice = createSlice({
-	name: "cartesianAxis",
-	initialState: {
-		xAxis: {},
-		yAxis: {},
-		zAxis: {}
-	},
-	reducers: {
-		addXAxis(state, action) {
-			state.xAxis[action.payload.id] = castDraft(action.payload);
-		},
-		removeXAxis(state, action) {
-			delete state.xAxis[action.payload.id];
-		},
-		addYAxis(state, action) {
-			state.yAxis[action.payload.id] = castDraft(action.payload);
-		},
-		removeYAxis(state, action) {
-			delete state.yAxis[action.payload.id];
-		},
-		updateYAxisWidth(state, action) {
-			const { id, width } = action.payload;
-			const axis = state.yAxis[id];
-			if (axis) {
-				const history = axis.widthHistory || [];
-				if (history.length === 3 && history[0] === history[2] && width === history[1] && width !== axis.width && Math.abs(width - (history[0] ?? 0)) <= 1) return;
-				const newHistory = [...history, width].slice(-3);
-				axis.width = width;
-				axis.widthHistory = newHistory;
-			}
-		},
-		addZAxis(state, action) {
-			state.zAxis[action.payload.id] = castDraft(action.payload);
-		},
-		removeZAxis(state, action) {
-			delete state.zAxis[action.payload.id];
-		}
-	}
-});
-var { addXAxis, removeXAxis, addYAxis, removeYAxis, addZAxis, removeZAxis, updateYAxisWidth } = cartesianAxisSlice.actions;
-var cartesianAxisReducer = cartesianAxisSlice.reducer;
-//#endregion
-export { addXAxis, addYAxis, addZAxis, cartesianAxisReducer, removeXAxis, removeYAxis, removeZAxis, updateYAxisWidth };

package/dist/es/state/chartDataSlice.mjs

@@ -1,33 +0,0 @@
-import { createSlice } from "@reduxjs/toolkit";
-var chartDataSlice = createSlice({
-	name: "chartData",
-	initialState: {
-		chartData: void 0,
-		computedData: void 0,
-		dataStartIndex: 0,
-		dataEndIndex: 0
-	},
-	reducers: {
-		setChartData(state, action) {
-			state.chartData = action.payload;
-			if (action.payload == null) {
-				state.dataStartIndex = 0;
-				state.dataEndIndex = 0;
-				return;
-			}
-			if (action.payload.length > 0 && state.dataEndIndex !== action.payload.length - 1) state.dataEndIndex = action.payload.length - 1;
-		},
-		setComputedData(state, action) {
-			state.computedData = action.payload;
-		},
-		setDataStartEndIndexes(state, action) {
-			const { startIndex, endIndex } = action.payload;
-			if (startIndex != null) state.dataStartIndex = startIndex;
-			if (endIndex != null) state.dataEndIndex = endIndex;
-		}
-	}
-});
-var { setChartData, setDataStartEndIndexes, setComputedData } = chartDataSlice.actions;
-var chartDataReducer = chartDataSlice.reducer;
-//#endregion
-export { chartDataReducer, setChartData, setDataStartEndIndexes };

package/dist/es/state/externalEventsMiddleware.mjs

@@ -1,30 +0,0 @@
-import { selectActiveLabel, selectActiveTooltipCoordinate, selectActiveTooltipDataKey, selectActiveTooltipIndex, selectIsTooltipActive } from "./selectors/tooltipSelectors.mjs";
-import { createAction } from "@reduxjs/toolkit";
-//#region src/state/externalEventsMiddleware.ts
-var externalEventAction = createAction("externalEvent");
-/**
-* Calls external event handlers (onMouseMove, onClick, etc.) synchronously within the dispatch
-* call stack, while the native event's `currentTarget` is still valid.
-*
-* Using createListenerMiddleware would defer the call to a microtask, at which point the browser
-* has already cleared `e.currentTarget` per the DOM spec, breaking coordinate-based handlers like
-* DraggablePie that rely on `getRelativeCoordinate(e)`.
-*/
-var externalEventsMiddleware = (api) => (next) => (action) => {
-	const result = next(action);
-	if (externalEventAction.match(action) && action.payload.handler != null) {
-		const state = api.getState();
-		const nextState = {
-			activeCoordinate: selectActiveTooltipCoordinate(state),
-			activeDataKey: selectActiveTooltipDataKey(state),
-			activeIndex: selectActiveTooltipIndex(state),
-			activeLabel: selectActiveLabel(state),
-			activeTooltipIndex: selectActiveTooltipIndex(state),
-			isTooltipActive: selectIsTooltipActive(state)
-		};
-		action.payload.handler(nextState, action.payload.event);
-	}
-	return result;
-};
-//#endregion
-export { externalEventAction, externalEventsMiddleware };

package/dist/es/state/graphicalItemsSlice.mjs

@@ -1,47 +0,0 @@
-import { createSlice, current } from "@reduxjs/toolkit";
-import { castDraft } from "immer";
-//#region src/state/graphicalItemsSlice.ts
-var graphicalItemsSlice = createSlice({
-	name: "graphicalItems",
-	initialState: {
-		countOfBars: 0,
-		cartesianItems: [],
-		polarItems: []
-	},
-	reducers: {
-		addBar(state) {
-			state.countOfBars += 1;
-		},
-		removeBar(state) {
-			state.countOfBars -= 1;
-		},
-		addCartesianGraphicalItem(state, action) {
-			state.cartesianItems.push(castDraft(action.payload));
-		},
-		replaceCartesianGraphicalItem(state, action) {
-			const { prev, next } = action.payload;
-			const index = current(state).cartesianItems.indexOf(castDraft(prev));
-			if (index > -1) state.cartesianItems[index] = castDraft(next);
-		},
-		removeCartesianGraphicalItem(state, action) {
-			const index = current(state).cartesianItems.indexOf(castDraft(action.payload));
-			if (index > -1) state.cartesianItems.splice(index, 1);
-		},
-		addPolarGraphicalItem(state, action) {
-			state.polarItems.push(castDraft(action.payload));
-		},
-		removePolarGraphicalItem(state, action) {
-			const index = current(state).polarItems.indexOf(castDraft(action.payload));
-			if (index > -1) state.polarItems.splice(index, 1);
-		},
-		replacePolarGraphicalItem(state, action) {
-			const { prev, next } = action.payload;
-			const index = current(state).polarItems.indexOf(castDraft(prev));
-			if (index > -1) state.polarItems[index] = castDraft(next);
-		}
-	}
-});
-var { addBar, removeBar, addCartesianGraphicalItem, removeCartesianGraphicalItem, addPolarGraphicalItem, replaceCartesianGraphicalItem, removePolarGraphicalItem, replacePolarGraphicalItem } = graphicalItemsSlice.actions;
-var graphicalItemsReducer = graphicalItemsSlice.reducer;
-//#endregion
-export { addCartesianGraphicalItem, addPolarGraphicalItem, graphicalItemsReducer, removeCartesianGraphicalItem, removePolarGraphicalItem, replaceCartesianGraphicalItem, replacePolarGraphicalItem };

package/dist/es/state/hooks.mjs

@@ -1,26 +0,0 @@
-import { selectActiveTooltipDataPoints } from "./selectors/tooltipSelectors.mjs";
-import { useDispatch, useSelector } from "@reduxjs/vue-redux";
-//#region src/state/hooks.ts
-var useAppDispatch = useDispatch.withTypes();
-var useAppSelector = useSelector.withTypes();
-/**
-* Returns the currently active data points being displayed in the Tooltip.
-* Active means that it is currently visible; this hook will return `undefined` if there is no current interaction.
-*
-* This follows the `<Tooltip />` props, if the Tooltip element is present in the chart.
-* If there is no `<Tooltip />` then this hook will follow the default Tooltip props.
-*
-* Data point is whatever you pass as an input to the chart using the `data={}` prop.
-*
-* This returns an array because a chart can have multiple graphical items in it (multiple Lines for example)
-* and tooltip with `shared={true}` will display all items at the same time.
-*
-* Returns undefined when used outside a chart context.
-*
-* @returns Data points that are currently visible in a Tooltip
-*/
-function useActiveTooltipDataPoints() {
-	return useAppSelector(selectActiveTooltipDataPoints);
-}
-//#endregion
-export { useActiveTooltipDataPoints, useAppDispatch, useAppSelector };

package/dist/es/state/keyboardEventsMiddleware.mjs

@@ -1,63 +0,0 @@
-import { selectChartDirection } from "./selectors/axisSelectors.mjs";
-import { setKeyboardInteraction } from "./tooltipSlice.mjs";
-import { combineActiveTooltipIndex } from "./selectors/combiners/combineActiveTooltipIndex.mjs";
-import { selectTooltipAxisTicks, selectTooltipDisplayedData } from "./selectors/tooltipSelectors.mjs";
-import { selectCoordinateForDefaultIndex } from "./selectors/selectors.mjs";
-import { createAction, createListenerMiddleware } from "@reduxjs/toolkit";
-//#region src/state/keyboardEventsMiddleware.ts
-var keyDownAction = createAction("keyDown");
-var focusAction = createAction("focus");
-var keyboardEventsMiddleware = createListenerMiddleware();
-keyboardEventsMiddleware.startListening({
-	actionCreator: keyDownAction,
-	effect: (action, listenerApi) => {
-		const state = listenerApi.getState();
-		if (!(state.rootProps.accessibilityLayer !== false)) return;
-		const { keyboardInteraction } = state.tooltip;
-		const key = action.payload;
-		if (key !== "ArrowRight" && key !== "ArrowLeft" && key !== "Enter") return;
-		const currentIndex = Number(combineActiveTooltipIndex(keyboardInteraction, selectTooltipDisplayedData(state)));
-		const tooltipTicks = selectTooltipAxisTicks(state);
-		if (key === "Enter") {
-			const coordinate = selectCoordinateForDefaultIndex(state, "axis", "hover", String(keyboardInteraction.index));
-			listenerApi.dispatch(setKeyboardInteraction({
-				active: !keyboardInteraction.active,
-				activeIndex: keyboardInteraction.index,
-				activeDataKey: keyboardInteraction.dataKey,
-				activeCoordinate: coordinate
-			}));
-			return;
-		}
-		const directionMultiplier = selectChartDirection(state) === "left-to-right" ? 1 : -1;
-		const nextIndex = currentIndex + (key === "ArrowRight" ? 1 : -1) * directionMultiplier;
-		if (nextIndex >= tooltipTicks.length || nextIndex < 0) return;
-		const coordinate = selectCoordinateForDefaultIndex(state, "axis", "hover", String(nextIndex));
-		listenerApi.dispatch(setKeyboardInteraction({
-			active: true,
-			activeIndex: nextIndex.toString(),
-			activeDataKey: void 0,
-			activeCoordinate: coordinate
-		}));
-	}
-});
-keyboardEventsMiddleware.startListening({
-	actionCreator: focusAction,
-	effect: (_, listenerApi) => {
-		const state = listenerApi.getState();
-		if (!(state.rootProps.accessibilityLayer !== false)) return;
-		const { keyboardInteraction } = state.tooltip;
-		if (keyboardInteraction.active) return;
-		if (keyboardInteraction.index == null) {
-			const nextIndex = "0";
-			const coordinate = selectCoordinateForDefaultIndex(state, "axis", "hover", String(nextIndex));
-			listenerApi.dispatch(setKeyboardInteraction({
-				activeDataKey: void 0,
-				active: true,
-				activeIndex: nextIndex,
-				activeCoordinate: coordinate
-			}));
-		}
-	}
-});
-//#endregion
-export { focusAction, keyDownAction, keyboardEventsMiddleware };