@octanejs/recharts 0.1.0

package/src/state/SetTooltipEntrySettings.ts

@@ -0,0 +1,40 @@
+// Port of state/SetTooltipEntrySettings.tsx — graphical items register their
+// tooltip payload settings (panorama items never contribute).
+import { useLayoutEffect, useRef } from 'octane';
+import { useAppDispatch } from './hooks';
+import {
+	addTooltipEntrySettings,
+	removeTooltipEntrySettings,
+	replaceTooltipEntrySettings,
+} from './tooltipSlice';
+import { useIsPanorama } from '../context/PanoramaContext';
+
+export function SetTooltipEntrySettings(props: { tooltipEntrySettings: unknown }): null {
+	const { tooltipEntrySettings } = props;
+	const dispatch = useAppDispatch();
+	const isPanorama = useIsPanorama();
+	const prevSettingsRef = useRef<unknown>(null);
+	useLayoutEffect(() => {
+		if (isPanorama) {
+			// Panorama graphical items should never contribute to Tooltip payload.
+			return;
+		}
+		if (prevSettingsRef.current === null) {
+			dispatch(addTooltipEntrySettings(tooltipEntrySettings));
+		} else if (prevSettingsRef.current !== tooltipEntrySettings) {
+			dispatch(
+				replaceTooltipEntrySettings({ prev: prevSettingsRef.current, next: tooltipEntrySettings }),
+			);
+		}
+		prevSettingsRef.current = tooltipEntrySettings;
+	}, [tooltipEntrySettings, dispatch, isPanorama]);
+	useLayoutEffect(() => {
+		return () => {
+			if (prevSettingsRef.current) {
+				dispatch(removeTooltipEntrySettings(prevSettingsRef.current));
+				prevSettingsRef.current = null;
+			}
+		};
+	}, [dispatch]);
+	return null;
+}

package/src/state/brushSlice.js

@@ -0,0 +1,36 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/brushSlice.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+import { createSlice } from '@reduxjs/toolkit';
+
+/**
+ * From all Brush properties, only height has a default value and will always be defined.
+ * Other properties are nullable and will be computed from offsets and margins if they are not set.
+ */
+
+var initialState = {
+	x: 0,
+	y: 0,
+	width: 0,
+	height: 0,
+	padding: {
+		top: 0,
+		right: 0,
+		bottom: 0,
+		left: 0,
+	},
+};
+export var brushSlice = createSlice({
+	name: 'brush',
+	initialState,
+	reducers: {
+		setBrushSettings(_state, action) {
+			if (action.payload == null) {
+				return initialState;
+			}
+			return action.payload;
+		},
+	},
+});
+var setBrushSettings = brushSlice.actions.setBrushSettings;
+export { setBrushSettings };
+export var brushReducer = brushSlice.reducer;

package/src/state/cartesianAxisSlice.js

@@ -0,0 +1,256 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/cartesianAxisSlice.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 { createSlice, prepareAutoBatched } from '@reduxjs/toolkit';
+import { castDraft } from 'immer';
+
+/**
+ * @inline
+ */
+
+export var defaultAxisId = 0;
+
+/**
+ * Properties shared in X, Y, and Z axes.
+ * User defined axis settings, coming from props.
+ */
+
+/**
+ * Controls how Recharts calculates "nice" tick values for numerical axes.
+ *
+ * - `'none'`: Recharts does not apply any tick-rounding algorithm; tick positions are
+ *   determined entirely by d3, evenly spaced but not rounded to human-friendly numbers.
+ *   There is no domain-extension logic applied in this mode.
+ *
+ * - `'auto'` *(default)*: Recharts automatically decides whether and how to apply tick
+ *   niceties based on the domain definition. When the domain contains an `'auto'` keyword,
+ *   Recharts uses the `'adaptive'` algorithm and may extend the domain slightly to
+ *   produce clean tick labels. Otherwise, it applies the same algorithm while keeping
+ *   ticks within the fixed domain. This mirrors the default behavior from Recharts v2.
+ *
+ * - `'adaptive'`: Always applies the space-efficient algorithm (`getAdaptiveStep`),
+ *   which fills the available range as densely as possible while still rounding steps
+ *   to reasonable numbers (e.g. 10, 20, 25). May produce less "round-looking" labels
+ *   than `'snap125'`, but wastes less space. The domain-extension logic still applies
+ *   when the domain contains an `'auto'` keyword.
+ *
+ * - `'snap125'`: Always applies the round-numbers algorithm (`getSnap125Step`), which
+ *   snaps step sizes to values from the set {1, 2, 2.5, 5} × 10ⁿ. Produces very
+ *   human-friendly labels (e.g. 0, 5, 10, 15, 20) but may leave blank space at the
+ *   edges of the chart. The domain-extension logic still applies when the domain
+ *   contains an `'auto'` keyword.
+ *
+ * @see {@link https://recharts.github.io/guide/axisTicks/}
+ * @inline
+ */
+
+/**
+ * These are the external props, visible for users as they set them using our public API.
+ * There is all sorts of internal computed things based on these, but they will come through selectors.
+ *
+ * Properties shared between X and Y axes
+ */
+
+/**
+ * Z axis is special because it's never displayed. It controls the size of Scatter dots,
+ * but it never displays ticks anywhere.
+ */
+
+var initialState = {
+	xAxis: {},
+	yAxis: {},
+	zAxis: {},
+};
+
+/**
+ * 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,
+	reducers: {
+		addXAxis: {
+			reducer(state, action) {
+				state.xAxis[action.payload.id] = castDraft(action.payload);
+			},
+			prepare: prepareAutoBatched(),
+		},
+		replaceXAxis: {
+			reducer(state, action) {
+				var _action$payload = action.payload,
+					prev = _action$payload.prev,
+					next = _action$payload.next;
+				if (state.xAxis[prev.id] !== undefined) {
+					if (prev.id !== next.id) {
+						delete state.xAxis[prev.id];
+					}
+					state.xAxis[next.id] = castDraft(next);
+				}
+			},
+			prepare: prepareAutoBatched(),
+		},
+		removeXAxis: {
+			reducer(state, action) {
+				delete state.xAxis[action.payload.id];
+			},
+			prepare: prepareAutoBatched(),
+		},
+		addYAxis: {
+			reducer(state, action) {
+				state.yAxis[action.payload.id] = castDraft(action.payload);
+			},
+			prepare: prepareAutoBatched(),
+		},
+		replaceYAxis: {
+			reducer(state, action) {
+				var _action$payload2 = action.payload,
+					prev = _action$payload2.prev,
+					next = _action$payload2.next;
+				if (state.yAxis[prev.id] !== undefined) {
+					if (prev.id !== next.id) {
+						delete state.yAxis[prev.id];
+					}
+					state.yAxis[next.id] = castDraft(next);
+				}
+			},
+			prepare: prepareAutoBatched(),
+		},
+		removeYAxis: {
+			reducer(state, action) {
+				delete state.yAxis[action.payload.id];
+			},
+			prepare: prepareAutoBatched(),
+		},
+		addZAxis: {
+			reducer(state, action) {
+				state.zAxis[action.payload.id] = castDraft(action.payload);
+			},
+			prepare: prepareAutoBatched(),
+		},
+		replaceZAxis: {
+			reducer(state, action) {
+				var _action$payload3 = action.payload,
+					prev = _action$payload3.prev,
+					next = _action$payload3.next;
+				if (state.zAxis[prev.id] !== undefined) {
+					if (prev.id !== next.id) {
+						delete state.zAxis[prev.id];
+					}
+					state.zAxis[next.id] = castDraft(next);
+				}
+			},
+			prepare: prepareAutoBatched(),
+		},
+		removeZAxis: {
+			reducer(state, action) {
+				delete state.zAxis[action.payload.id];
+			},
+			prepare: prepareAutoBatched(),
+		},
+		updateYAxisWidth(state, action) {
+			var _action$payload4 = action.payload,
+				id = _action$payload4.id,
+				width = _action$payload4.width;
+			var axis = state.yAxis[id];
+			if (axis) {
+				var _history$;
+				var history = axis.widthHistory || [];
+				// An oscillation is detected when the new width is the same as the width before the last one.
+				// This is a simple A -> B -> A pattern. If the next width is B, and the difference is less than 1 pixel, we ignore it.
+				if (
+					history.length === 3 &&
+					history[0] === history[2] &&
+					width === history[1] &&
+					width !== axis.width &&
+					Math.abs(
+						width - ((_history$ = history[0]) !== null && _history$ !== void 0 ? _history$ : 0),
+					) <= 1
+				) {
+					return;
+				}
+				var newHistory = [...history, width].slice(-3);
+				state.yAxis[id] = _objectSpread(
+					_objectSpread({}, axis),
+					{},
+					{
+						width,
+						widthHistory: newHistory,
+					},
+				);
+			}
+		},
+	},
+});
+var _cartesianAxisSlice$a = cartesianAxisSlice.actions,
+	addXAxis = _cartesianAxisSlice$a.addXAxis,
+	replaceXAxis = _cartesianAxisSlice$a.replaceXAxis,
+	removeXAxis = _cartesianAxisSlice$a.removeXAxis,
+	addYAxis = _cartesianAxisSlice$a.addYAxis,
+	replaceYAxis = _cartesianAxisSlice$a.replaceYAxis,
+	removeYAxis = _cartesianAxisSlice$a.removeYAxis,
+	addZAxis = _cartesianAxisSlice$a.addZAxis,
+	replaceZAxis = _cartesianAxisSlice$a.replaceZAxis,
+	removeZAxis = _cartesianAxisSlice$a.removeZAxis,
+	updateYAxisWidth = _cartesianAxisSlice$a.updateYAxisWidth;
+export {
+	addXAxis,
+	replaceXAxis,
+	removeXAxis,
+	addYAxis,
+	replaceYAxis,
+	removeYAxis,
+	addZAxis,
+	replaceZAxis,
+	removeZAxis,
+	updateYAxisWidth,
+};
+export var cartesianAxisReducer = cartesianAxisSlice.reducer;

package/src/state/chartDataSlice.js

@@ -0,0 +1,67 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/chartDataSlice.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+import { createSlice } from '@reduxjs/toolkit';
+import { castDraft } from 'immer';
+
+/**
+ * This is the data that's coming through main chart `data` prop
+ * Recharts is very flexible in what it accepts so the type is very flexible too.
+ * This will typically be an object, and various components will provide various `dataKey`
+ * that dictates how to pull data from that object.
+ *
+ * TL;DR: before dataKey
+ *
+ * @inline
+ */
+
+/**
+ * So this is the same unknown type as ChartData but this is after the dataKey has been applied.
+ * We still don't know what the type is - that depends on what exactly it was before the dataKey application,
+ * and the dataKey can return whatever anyway - but let's keep it separate as a form of documentation.
+ *
+ * TL;DR: ChartData after dataKey.
+ */
+
+export var initialChartDataState = {
+	chartData: undefined,
+	computedData: undefined,
+	dataStartIndex: 0,
+	dataEndIndex: 0,
+};
+var chartDataSlice = createSlice({
+	name: 'chartData',
+	initialState: initialChartDataState,
+	reducers: {
+		setChartData(state, action) {
+			state.chartData = castDraft(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) {
+			var _action$payload = action.payload,
+				startIndex = _action$payload.startIndex,
+				endIndex = _action$payload.endIndex;
+			if (startIndex != null) {
+				state.dataStartIndex = startIndex;
+			}
+			if (endIndex != null) {
+				state.dataEndIndex = endIndex;
+			}
+		},
+	},
+});
+var _chartDataSlice$actio = chartDataSlice.actions,
+	setChartData = _chartDataSlice$actio.setChartData,
+	setDataStartEndIndexes = _chartDataSlice$actio.setDataStartEndIndexes,
+	setComputedData = _chartDataSlice$actio.setComputedData;
+export { setChartData, setDataStartEndIndexes, setComputedData };
+export var chartDataReducer = chartDataSlice.reducer;

package/src/state/errorBarSlice.js

@@ -0,0 +1,53 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/errorBarSlice.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+import { createSlice } from '@reduxjs/toolkit';
+
+/**
+ * ErrorBars have lot more settings but all the others are scoped to the component itself.
+ * Only some of them required to be reported to the global store because XAxis and YAxis need to know
+ * if the error bar is contributing to extending the axis domain.
+ */
+
+var initialState = {};
+var errorBarSlice = createSlice({
+	name: 'errorBars',
+	initialState,
+	reducers: {
+		addErrorBar: (state, action) => {
+			var _action$payload = action.payload,
+				itemId = _action$payload.itemId,
+				errorBar = _action$payload.errorBar;
+			if (!state[itemId]) {
+				state[itemId] = [];
+			}
+			state[itemId].push(errorBar);
+		},
+		replaceErrorBar: (state, action) => {
+			var _action$payload2 = action.payload,
+				itemId = _action$payload2.itemId,
+				prev = _action$payload2.prev,
+				next = _action$payload2.next;
+			if (state[itemId]) {
+				state[itemId] = state[itemId].map((e) =>
+					e.dataKey === prev.dataKey && e.direction === prev.direction ? next : e,
+				);
+			}
+		},
+		removeErrorBar: (state, action) => {
+			var _action$payload3 = action.payload,
+				itemId = _action$payload3.itemId,
+				errorBar = _action$payload3.errorBar;
+			if (state[itemId]) {
+				state[itemId] = state[itemId].filter(
+					(e) => e.dataKey !== errorBar.dataKey || e.direction !== errorBar.direction,
+				);
+			}
+		},
+	},
+});
+var _errorBarSlice$action = errorBarSlice.actions,
+	addErrorBar = _errorBarSlice$action.addErrorBar,
+	replaceErrorBar = _errorBarSlice$action.replaceErrorBar,
+	removeErrorBar = _errorBarSlice$action.removeErrorBar;
+export { addErrorBar, replaceErrorBar, removeErrorBar };
+export var errorBarReducer = errorBarSlice.reducer;

package/src/state/eventSettingsSlice.js

@@ -0,0 +1,25 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/eventSettingsSlice.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+import { createSlice } from '@reduxjs/toolkit';
+import { castDraft } from 'immer';
+export var initialEventSettingsState = {
+	throttleDelay: 'raf',
+	throttledEvents: ['mousemove', 'touchmove', 'pointermove', 'scroll', 'wheel'],
+};
+var eventSettingsSlice = createSlice({
+	name: 'eventSettings',
+	initialState: initialEventSettingsState,
+	reducers: {
+		setEventSettings: (state, action) => {
+			if (action.payload.throttleDelay != null) {
+				state.throttleDelay = action.payload.throttleDelay;
+			}
+			if (action.payload.throttledEvents != null) {
+				state.throttledEvents = castDraft(action.payload.throttledEvents);
+			}
+		},
+	},
+});
+var setEventSettings = eventSettingsSlice.actions.setEventSettings;
+export { setEventSettings };
+export var eventSettingsReducer = eventSettingsSlice.reducer;

package/src/state/externalEventsMiddleware.js

@@ -0,0 +1,127 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/externalEventsMiddleware.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+import { createAction, createListenerMiddleware } from '@reduxjs/toolkit';
+import {
+	selectActiveLabel,
+	selectActiveTooltipCoordinate,
+	selectActiveTooltipDataKey,
+	selectActiveTooltipIndex,
+	selectIsTooltipActive,
+} from './selectors/tooltipSelectors';
+import { createEventProxy } from '../util/createEventProxy';
+export var externalEventAction = createAction('externalEvent');
+export var externalEventsMiddleware = createListenerMiddleware();
+
+/*
+ * We need a Map keyed by event type because this middleware handles MULTIPLE different event types
+ * (click, mouseenter, mouseleave, mousedown, mouseup, contextmenu, dblclick, touchstart, touchmove, touchend)
+ * from the same DOM element. Different event types should NOT cancel each other's animation frames.
+ * For example, a click event and a mousemove event can happen in quick succession and both should be processed.
+ * This is different from mouseMoveMiddleware which only handles one event type and uses a single rafId.
+ */
+var rafIdMap = new Map();
+var timeoutIdMap = new Map();
+var latestEventMap = new Map();
+externalEventsMiddleware.startListening({
+	actionCreator: externalEventAction,
+	effect: (action, listenerApi) => {
+		var _action$payload = action.payload,
+			handler = _action$payload.handler,
+			reactEvent = _action$payload.reactEvent;
+		if (handler == null) {
+			return;
+		}
+		var eventType = reactEvent.type;
+		var eventProxy = createEventProxy(reactEvent);
+		latestEventMap.set(eventType, {
+			handler,
+			reactEvent: eventProxy,
+		});
+
+		// Cancel any pending execution for this event type
+		var existingRafId = rafIdMap.get(eventType);
+		if (existingRafId !== undefined) {
+			cancelAnimationFrame(existingRafId);
+			rafIdMap.delete(eventType);
+		}
+		var state = listenerApi.getState();
+		var _state$eventSettings = state.eventSettings,
+			throttleDelay = _state$eventSettings.throttleDelay,
+			throttledEvents = _state$eventSettings.throttledEvents;
+
+		/*
+		 * reactEvent.type gives us the event type as a string, e.g., 'click', 'mousemove', etc.
+		 * which is the same as the names used in throttledEvents array
+		 * but that array is strictly typed as ReadonlyArray<keyof GlobalEventHandlersEventMap> | 'all' | undefined
+		 * so that we can have relevant autocomplete and type checking elsewhere.
+		 * This makes TypeScript panic because it refuses to call .includes() on ReadonlyArray<keyof GlobalEventHandlersEventMap>
+		 * with a string argument.
+		 * To satisfy TypeScript, we need to explicitly typecast throttledEvents here.
+		 */
+		var eventListAsString = throttledEvents;
+
+		// Check if this event type should be throttled
+		// throttledEvents can be 'all' or an array of event names
+		var isThrottled =
+			eventListAsString === 'all' ||
+			(eventListAsString === null || eventListAsString === void 0
+				? void 0
+				: eventListAsString.includes(eventType));
+		var existingTimeoutId = timeoutIdMap.get(eventType);
+		if (existingTimeoutId !== undefined && (typeof throttleDelay !== 'number' || !isThrottled)) {
+			clearTimeout(existingTimeoutId);
+			timeoutIdMap.delete(eventType);
+		}
+		var callback = () => {
+			var latestAction = latestEventMap.get(eventType);
+			try {
+				if (!latestAction) {
+					// This happens if the event was consumed by the leading edge and no new event came in
+					return;
+				}
+				var latestHandler = latestAction.handler,
+					latestEvent = latestAction.reactEvent;
+				var currentState = listenerApi.getState();
+				var nextState = {
+					activeCoordinate: selectActiveTooltipCoordinate(currentState),
+					activeDataKey: selectActiveTooltipDataKey(currentState),
+					activeIndex: selectActiveTooltipIndex(currentState),
+					activeLabel: selectActiveLabel(currentState),
+					activeTooltipIndex: selectActiveTooltipIndex(currentState),
+					isTooltipActive: selectIsTooltipActive(currentState),
+				};
+				if (latestHandler) {
+					latestHandler(nextState, latestEvent);
+				}
+			} finally {
+				rafIdMap.delete(eventType);
+				timeoutIdMap.delete(eventType);
+				latestEventMap.delete(eventType);
+			}
+		};
+		if (!isThrottled) {
+			// Execute immediately
+			callback();
+			return;
+		}
+		if (throttleDelay === 'raf') {
+			var rafId = requestAnimationFrame(callback);
+			rafIdMap.set(eventType, rafId);
+		} else if (typeof throttleDelay === 'number') {
+			if (!timeoutIdMap.has(eventType)) {
+				/*
+				 * Leading edge execution - execute immediately on the first event
+				 * and then start the cooldown period to throttle subsequent events.
+				 */
+				callback();
+
+				// Start cooldown
+				var timeoutId = setTimeout(callback, throttleDelay);
+				timeoutIdMap.set(eventType, timeoutId);
+			}
+		} else {
+			// Should not happen based on type, but fallback to immediate
+			callback();
+		}
+	},
+});

package/src/state/graphicalItemsSlice.js

@@ -0,0 +1,91 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/graphicalItemsSlice.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+import { createSlice, current, prepareAutoBatched } from '@reduxjs/toolkit';
+import { castDraft } from 'immer';
+
+/**
+ * Unique ID of the graphical item.
+ * This is used to identify the graphical item in the state and in the React tree.
+ * This is required for every graphical item - it's either provided by the user or generated automatically.
+ */
+
+var initialState = {
+	cartesianItems: [],
+	polarItems: [],
+};
+var graphicalItemsSlice = createSlice({
+	name: 'graphicalItems',
+	initialState,
+	reducers: {
+		addCartesianGraphicalItem: {
+			reducer(state, action) {
+				state.cartesianItems.push(castDraft(action.payload));
+			},
+			prepare: prepareAutoBatched(),
+		},
+		replaceCartesianGraphicalItem: {
+			reducer(state, action) {
+				var _action$payload = action.payload,
+					prev = _action$payload.prev,
+					next = _action$payload.next;
+				var index = current(state).cartesianItems.indexOf(castDraft(prev));
+				if (index > -1) {
+					state.cartesianItems[index] = castDraft(next);
+				}
+			},
+			prepare: prepareAutoBatched(),
+		},
+		removeCartesianGraphicalItem: {
+			reducer(state, action) {
+				var index = current(state).cartesianItems.indexOf(castDraft(action.payload));
+				if (index > -1) {
+					state.cartesianItems.splice(index, 1);
+				}
+			},
+			prepare: prepareAutoBatched(),
+		},
+		addPolarGraphicalItem: {
+			reducer(state, action) {
+				state.polarItems.push(castDraft(action.payload));
+			},
+			prepare: prepareAutoBatched(),
+		},
+		removePolarGraphicalItem: {
+			reducer(state, action) {
+				var index = current(state).polarItems.indexOf(castDraft(action.payload));
+				if (index > -1) {
+					state.polarItems.splice(index, 1);
+				}
+			},
+			prepare: prepareAutoBatched(),
+		},
+		replacePolarGraphicalItem: {
+			reducer(state, action) {
+				var _action$payload2 = action.payload,
+					prev = _action$payload2.prev,
+					next = _action$payload2.next;
+				var index = current(state).polarItems.indexOf(castDraft(prev));
+				if (index > -1) {
+					state.polarItems[index] = castDraft(next);
+				}
+			},
+			prepare: prepareAutoBatched(),
+		},
+	},
+});
+var _graphicalItemsSlice$ = graphicalItemsSlice.actions,
+	addCartesianGraphicalItem = _graphicalItemsSlice$.addCartesianGraphicalItem,
+	replaceCartesianGraphicalItem = _graphicalItemsSlice$.replaceCartesianGraphicalItem,
+	removeCartesianGraphicalItem = _graphicalItemsSlice$.removeCartesianGraphicalItem,
+	addPolarGraphicalItem = _graphicalItemsSlice$.addPolarGraphicalItem,
+	removePolarGraphicalItem = _graphicalItemsSlice$.removePolarGraphicalItem,
+	replacePolarGraphicalItem = _graphicalItemsSlice$.replacePolarGraphicalItem;
+export {
+	addCartesianGraphicalItem,
+	replaceCartesianGraphicalItem,
+	removeCartesianGraphicalItem,
+	addPolarGraphicalItem,
+	removePolarGraphicalItem,
+	replacePolarGraphicalItem,
+};
+export var graphicalItemsReducer = graphicalItemsSlice.reducer;