@octanejs/recharts 0.1.0

package/src/state/selectors/touchSelectors.js

@@ -0,0 +1,31 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/selectors/touchSelectors.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+import { createSelector } from 'reselect';
+import { selectTooltipState } from './selectTooltipState';
+var selectAllTooltipPayloadConfiguration = createSelector(
+	[selectTooltipState],
+	(tooltipState) => tooltipState.tooltipItemPayloads,
+);
+export var selectTooltipCoordinate = createSelector(
+	[
+		selectAllTooltipPayloadConfiguration,
+		(_state, tooltipIndex) => tooltipIndex,
+		(_state, _tooltipIndex, graphicalItemId) => graphicalItemId,
+	],
+	(allTooltipConfigurations, tooltipIndex, graphicalItemId) => {
+		if (tooltipIndex == null) {
+			return undefined;
+		}
+		var mostRelevantTooltipConfiguration = allTooltipConfigurations.find((tooltipConfiguration) => {
+			return tooltipConfiguration.settings.graphicalItemId === graphicalItemId;
+		});
+		if (mostRelevantTooltipConfiguration == null) {
+			return undefined;
+		}
+		var getPosition = mostRelevantTooltipConfiguration.getPosition;
+		if (getPosition == null) {
+			return undefined;
+		}
+		return getPosition(tooltipIndex);
+	},
+);

package/src/state/store.js

@@ -0,0 +1,101 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/store.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+import { autoBatchEnhancer, combineReducers, configureStore } from '@reduxjs/toolkit';
+import { optionsReducer } from './optionsSlice';
+import { tooltipReducer } from './tooltipSlice';
+import { chartDataReducer } from './chartDataSlice';
+import { chartLayoutReducer } from './layoutSlice';
+import { mouseClickMiddleware, mouseMoveMiddleware } from './mouseEventsMiddleware';
+import { reduxDevtoolsJsonStringifyReplacer } from './reduxDevtoolsJsonStringifyReplacer';
+import { cartesianAxisReducer } from './cartesianAxisSlice';
+import { graphicalItemsReducer } from './graphicalItemsSlice';
+import { referenceElementsReducer } from './referenceElementsSlice';
+import { brushReducer } from './brushSlice';
+import { legendReducer } from './legendSlice';
+import { rootPropsReducer } from './rootPropsSlice';
+import { polarAxisReducer } from './polarAxisSlice';
+import { polarOptionsReducer } from './polarOptionsSlice';
+import { keyboardEventsMiddleware } from './keyboardEventsMiddleware';
+import { externalEventsMiddleware } from './externalEventsMiddleware';
+import { touchEventMiddleware } from './touchEventsMiddleware';
+import { errorBarReducer } from './errorBarSlice';
+import { Global } from '../util/Global';
+import { zIndexReducer } from './zIndexSlice';
+import { eventSettingsReducer } from './eventSettingsSlice';
+import { renderedTicksReducer } from './renderedTicksSlice';
+var 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 var createRechartsStore = function createRechartsStore(preloadedState) {
+	var chartName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '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) => {
+			var _process$env$NODE_ENV;
+			return getDefaultMiddleware({
+				serializableCheck: false,
+				immutableCheck: !['commonjs', 'es6', 'production'].includes(
+					(_process$env$NODE_ENV = 'es6') !== null && _process$env$NODE_ENV !== void 0
+						? _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) => {
+			var 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-'.concat(chartName),
+		},
+	});
+};

package/src/state/tooltipSlice.js

@@ -0,0 +1,237 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/tooltipSlice.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';
+
+/**
+ * One Tooltip can display multiple TooltipPayloadEntries at a time.
+ */
+
+/**
+ * So what happens is that the tooltip payload is decided based on the available data, and the dataKey.
+ * The dataKey can either be defined on the graphical element (like Line, or Bar)
+ * or on the tooltip itself.
+ *
+ * The data can be defined in the chart element, or in the graphical item.
+ *
+ * So this type is all the settings, other than the data + dataKey complications.
+ */
+
+/**
+ * This is what Tooltip renders.
+ */
+
+/**
+ * null means no active index
+ * string means: whichever index from the chart data it is.
+ * Different charts have different requirements on data shapes,
+ * and are also responsible for providing a function that will accept this index
+ * and return data.
+ */
+
+/**
+ * Different items have different data shapes so the state has no opinion on what the data shape should be;
+ * the only requirement is that the chart also provides a searcher function
+ * that accepts the data, and a key, and returns whatever the payload in Tooltip should be.
+ */
+
+/**
+ * So this informs the "tooltip event type". Tooltip event type can be either "axis" or "item"
+ * and it is used for two things:
+ * 1. Sets the active area
+ * 2. Sets the background and cursor highlights
+ *
+ * Some charts only allow to have one type of tooltip event type, some allow both.
+ * Those charts that allow both will have one default, and the "shared" prop will be used to switch between them.
+ * Undefined means "use the chart default".
+ *
+ * Charts that only allow one tooltip event type, will ignore the shared prop.
+ */
+
+/**
+ * A generic state for user interaction with the chart.
+ * User interaction can come through multiple channels: mouse events, keyboard events, or hardcoded in props, or synchronised from other charts.
+ *
+ * Each of the interaction states is represented as TooltipInteractionState,
+ * and then the selectors and Tooltip will decide which of the interaction states to use.
+ */
+
+export var noInteraction = {
+	active: false,
+	index: null,
+	dataKey: undefined,
+	graphicalItemId: undefined,
+	coordinate: undefined,
+};
+
+/**
+ * The tooltip interaction state stores:
+ *
+ * - Which graphical item is user interacting with at the moment,
+ * - which axis (or, which part of chart background) is user interacting with at the moment
+ * - The data that individual graphical items wish to be displayed in case the tooltip gets activated
+ */
+
+export var initialState = {
+	itemInteraction: {
+		click: noInteraction,
+		hover: noInteraction,
+	},
+	axisInteraction: {
+		click: noInteraction,
+		hover: noInteraction,
+	},
+	keyboardInteraction: noInteraction,
+	syncInteraction: {
+		active: false,
+		index: null,
+		dataKey: undefined,
+		label: undefined,
+		coordinate: undefined,
+		sourceViewBox: undefined,
+		graphicalItemId: undefined,
+	},
+	tooltipItemPayloads: [],
+	settings: {
+		shared: undefined,
+		trigger: 'hover',
+		axisId: 0,
+		active: false,
+		defaultIndex: undefined,
+	},
+};
+
+/**
+ * This is the event we get when user is interacting with a specific graphical item.
+ */
+
+/**
+ * Keyboard interaction payload has no graphical item ID,
+ * and no dataKey, because keyboard interaction is always
+ * with the whole chart, not with a specific graphical item.
+ */
+
+var tooltipSlice = createSlice({
+	name: 'tooltip',
+	initialState,
+	reducers: {
+		addTooltipEntrySettings: {
+			reducer(state, action) {
+				state.tooltipItemPayloads.push(castDraft(action.payload));
+			},
+			prepare: prepareAutoBatched(),
+		},
+		replaceTooltipEntrySettings: {
+			reducer(state, action) {
+				var _action$payload = action.payload,
+					prev = _action$payload.prev,
+					next = _action$payload.next;
+				var index = current(state).tooltipItemPayloads.indexOf(castDraft(prev));
+				if (index > -1) {
+					state.tooltipItemPayloads[index] = castDraft(next);
+				}
+			},
+			prepare: prepareAutoBatched(),
+		},
+		removeTooltipEntrySettings: {
+			reducer(state, action) {
+				var index = current(state).tooltipItemPayloads.indexOf(castDraft(action.payload));
+				if (index > -1) {
+					state.tooltipItemPayloads.splice(index, 1);
+				}
+			},
+			prepare: prepareAutoBatched(),
+		},
+		setTooltipSettingsState(state, action) {
+			state.settings = action.payload;
+		},
+		setActiveMouseOverItemIndex(state, action) {
+			state.syncInteraction.active = false;
+			state.syncInteraction.sourceViewBox = undefined;
+			state.keyboardInteraction.active = false;
+			state.itemInteraction.hover.active = true;
+			state.itemInteraction.hover.index = action.payload.activeIndex;
+			state.itemInteraction.hover.dataKey = action.payload.activeDataKey;
+			state.itemInteraction.hover.graphicalItemId = action.payload.activeGraphicalItemId;
+			state.itemInteraction.hover.coordinate = action.payload.activeCoordinate;
+		},
+		mouseLeaveChart(state) {
+			/*
+			 * Clear only the active flags. Why?
+			 * 1. Keep Coordinate to preserve animation - next time the Tooltip appears, we want to render it from
+			 * the last place where it was when it disappeared.
+			 * 2. We want to keep all the properties anyway just in case the tooltip has `active=true` prop
+			 * and continues being visible even after the mouse has left the chart.
+			 */
+			state.itemInteraction.hover.active = false;
+			state.axisInteraction.hover.active = false;
+		},
+		mouseLeaveItem(state) {
+			state.itemInteraction.hover.active = false;
+		},
+		setActiveClickItemIndex(state, action) {
+			state.syncInteraction.active = false;
+			state.syncInteraction.sourceViewBox = undefined;
+			state.itemInteraction.click.active = true;
+			state.keyboardInteraction.active = false;
+			state.itemInteraction.click.index = action.payload.activeIndex;
+			state.itemInteraction.click.dataKey = action.payload.activeDataKey;
+			state.itemInteraction.click.graphicalItemId = action.payload.activeGraphicalItemId;
+			state.itemInteraction.click.coordinate = action.payload.activeCoordinate;
+		},
+		setMouseOverAxisIndex(state, action) {
+			state.syncInteraction.active = false;
+			state.syncInteraction.sourceViewBox = undefined;
+			state.axisInteraction.hover.active = true;
+			state.keyboardInteraction.active = false;
+			state.axisInteraction.hover.index = action.payload.activeIndex;
+			state.axisInteraction.hover.dataKey = action.payload.activeDataKey;
+			state.axisInteraction.hover.coordinate = action.payload.activeCoordinate;
+		},
+		setMouseClickAxisIndex(state, action) {
+			state.syncInteraction.active = false;
+			state.syncInteraction.sourceViewBox = undefined;
+			state.keyboardInteraction.active = false;
+			state.axisInteraction.click.active = true;
+			state.axisInteraction.click.index = action.payload.activeIndex;
+			state.axisInteraction.click.dataKey = action.payload.activeDataKey;
+			state.axisInteraction.click.coordinate = action.payload.activeCoordinate;
+		},
+		setSyncInteraction(state, action) {
+			state.syncInteraction = action.payload;
+		},
+		setKeyboardInteraction(state, action) {
+			state.keyboardInteraction.active = action.payload.active;
+			state.keyboardInteraction.index = action.payload.activeIndex;
+			state.keyboardInteraction.coordinate = action.payload.activeCoordinate;
+		},
+	},
+});
+var _tooltipSlice$actions = tooltipSlice.actions,
+	addTooltipEntrySettings = _tooltipSlice$actions.addTooltipEntrySettings,
+	replaceTooltipEntrySettings = _tooltipSlice$actions.replaceTooltipEntrySettings,
+	removeTooltipEntrySettings = _tooltipSlice$actions.removeTooltipEntrySettings,
+	setTooltipSettingsState = _tooltipSlice$actions.setTooltipSettingsState,
+	setActiveMouseOverItemIndex = _tooltipSlice$actions.setActiveMouseOverItemIndex,
+	mouseLeaveItem = _tooltipSlice$actions.mouseLeaveItem,
+	mouseLeaveChart = _tooltipSlice$actions.mouseLeaveChart,
+	setActiveClickItemIndex = _tooltipSlice$actions.setActiveClickItemIndex,
+	setMouseOverAxisIndex = _tooltipSlice$actions.setMouseOverAxisIndex,
+	setMouseClickAxisIndex = _tooltipSlice$actions.setMouseClickAxisIndex,
+	setSyncInteraction = _tooltipSlice$actions.setSyncInteraction,
+	setKeyboardInteraction = _tooltipSlice$actions.setKeyboardInteraction;
+export {
+	addTooltipEntrySettings,
+	replaceTooltipEntrySettings,
+	removeTooltipEntrySettings,
+	setTooltipSettingsState,
+	setActiveMouseOverItemIndex,
+	mouseLeaveItem,
+	mouseLeaveChart,
+	setActiveClickItemIndex,
+	setMouseOverAxisIndex,
+	setMouseClickAxisIndex,
+	setSyncInteraction,
+	setKeyboardInteraction,
+};
+export var tooltipReducer = tooltipSlice.reducer;

package/src/state/touchEventsMiddleware.js

@@ -0,0 +1,140 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/touchEventsMiddleware.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+import { createAction, createListenerMiddleware } from '@reduxjs/toolkit';
+import { setActiveMouseOverItemIndex, setMouseOverAxisIndex } from './tooltipSlice';
+import { selectActivePropsFromChartPointer } from './selectors/selectActivePropsFromChartPointer';
+import { getRelativeCoordinate } from '../util/getRelativeCoordinate';
+import { selectTooltipEventType } from './selectors/selectTooltipEventType';
+import {
+	DATA_ITEM_GRAPHICAL_ITEM_ID_ATTRIBUTE_NAME,
+	DATA_ITEM_INDEX_ATTRIBUTE_NAME,
+} from '../util/Constants';
+import { selectTooltipCoordinate } from './selectors/touchSelectors';
+import { selectAllGraphicalItemsSettings } from './selectors/tooltipSelectors';
+import { createEventProxy } from '../util/createEventProxy';
+export var touchEventAction = createAction('touchMove');
+export var touchEventMiddleware = createListenerMiddleware();
+var rafId = null;
+var timeoutId = null;
+var latestChartPointers = null;
+var latestTouchEvent = null;
+touchEventMiddleware.startListening({
+	actionCreator: touchEventAction,
+	effect: (action, listenerApi) => {
+		var touchEvent = action.payload;
+		if (touchEvent.touches == null || touchEvent.touches.length === 0) {
+			return;
+		}
+		latestTouchEvent = createEventProxy(touchEvent);
+		var state = listenerApi.getState();
+		var _state$eventSettings = state.eventSettings,
+			throttleDelay = _state$eventSettings.throttleDelay,
+			throttledEvents = _state$eventSettings.throttledEvents;
+		var isThrottled = throttledEvents === 'all' || throttledEvents.includes('touchmove');
+		if (rafId !== null) {
+			cancelAnimationFrame(rafId);
+			rafId = null;
+		}
+		if (timeoutId !== null && (typeof throttleDelay !== 'number' || !isThrottled)) {
+			clearTimeout(timeoutId);
+			timeoutId = null;
+		}
+		latestChartPointers = Array.from(touchEvent.touches).map((touch) =>
+			getRelativeCoordinate({
+				clientX: touch.clientX,
+				clientY: touch.clientY,
+				currentTarget: touchEvent.currentTarget,
+			}),
+		);
+		var callback = () => {
+			if (latestTouchEvent == null) {
+				return;
+			}
+			var currentState = listenerApi.getState();
+			var tooltipEventType = selectTooltipEventType(
+				currentState,
+				currentState.tooltip.settings.shared,
+			);
+			if (tooltipEventType === 'axis') {
+				var _latestChartPointers;
+				var latestTouchPointer =
+					(_latestChartPointers = latestChartPointers) === null || _latestChartPointers === void 0
+						? void 0
+						: _latestChartPointers[0];
+				if (latestTouchPointer == null) {
+					rafId = null;
+					timeoutId = null;
+					return;
+				}
+				var activeProps = selectActivePropsFromChartPointer(currentState, latestTouchPointer);
+				if (
+					(activeProps === null || activeProps === void 0 ? void 0 : activeProps.activeIndex) !=
+					null
+				) {
+					listenerApi.dispatch(
+						setMouseOverAxisIndex({
+							activeIndex: activeProps.activeIndex,
+							activeDataKey: undefined,
+							activeCoordinate: activeProps.activeCoordinate,
+						}),
+					);
+				}
+			} else if (tooltipEventType === 'item') {
+				var _target$getAttribute;
+				var touch = latestTouchEvent.touches[0];
+				if (document.elementFromPoint == null || touch == null) {
+					return;
+				}
+				var target = document.elementFromPoint(touch.clientX, touch.clientY);
+				if (!target || !target.getAttribute) {
+					return;
+				}
+				var itemIndex = target.getAttribute(DATA_ITEM_INDEX_ATTRIBUTE_NAME);
+				var graphicalItemId =
+					(_target$getAttribute = target.getAttribute(
+						DATA_ITEM_GRAPHICAL_ITEM_ID_ATTRIBUTE_NAME,
+					)) !== null && _target$getAttribute !== void 0
+						? _target$getAttribute
+						: undefined;
+				var settings = selectAllGraphicalItemsSettings(currentState).find(
+					(item) => item.id === graphicalItemId,
+				);
+				if (itemIndex == null || settings == null || graphicalItemId == null) {
+					return;
+				}
+				var dataKey = settings.dataKey;
+				var coordinate = selectTooltipCoordinate(currentState, itemIndex, graphicalItemId);
+				listenerApi.dispatch(
+					setActiveMouseOverItemIndex({
+						activeDataKey: dataKey,
+						activeIndex: itemIndex,
+						activeCoordinate: coordinate,
+						activeGraphicalItemId: graphicalItemId,
+					}),
+				);
+			}
+			rafId = null;
+			timeoutId = null;
+		};
+		if (!isThrottled) {
+			callback();
+			return;
+		}
+		if (throttleDelay === 'raf') {
+			rafId = requestAnimationFrame(callback);
+		} else if (typeof throttleDelay === 'number') {
+			if (timeoutId === null) {
+				callback();
+				latestTouchEvent = null;
+				timeoutId = setTimeout(() => {
+					if (latestTouchEvent) {
+						callback();
+					} else {
+						timeoutId = null;
+						rafId = null;
+					}
+				}, throttleDelay);
+			}
+		}
+	},
+});

package/src/state/types/StackedGraphicalItem.js

@@ -0,0 +1,18 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/types/StackedGraphicalItem.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+/**
+ * Some graphical items allow data stacking. The stacks are optional,
+ * so all props here are optional too.
+ */
+
+/**
+ * Some graphical items allow data stacking.
+ * This interface is used to represent the items that are stacked
+ * because the user has provided the stackId and dataKey properties.
+ */
+
+export function isStacked(graphicalItem) {
+	return (
+		'stackId' in graphicalItem && graphicalItem.stackId != null && graphicalItem.dataKey != null
+	);
+}

package/src/state/zIndexSlice.js

@@ -0,0 +1,167 @@
+// Vendored verbatim from recharts@3.9.2 es6/state/zIndexSlice.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);
+}
+/**
+ * This slice contains a registry of z-index values for various components.
+ * The state is a map from z-index numbers to element references.
+ */
+import { createSlice, prepareAutoBatched } from '@reduxjs/toolkit';
+import { castDraft } from 'immer';
+import { DefaultZIndexes } from '../zIndex/DefaultZIndexes';
+var seed = {};
+var initialState = {
+	zIndexMap: Object.values(DefaultZIndexes).reduce(
+		(acc, current) =>
+			_objectSpread(
+				_objectSpread({}, acc),
+				{},
+				{
+					[current]: {
+						element: undefined,
+						panoramaElement: undefined,
+						consumers: 0,
+					},
+				},
+			),
+		seed,
+	),
+};
+var defaultZIndexSet = new Set(Object.values(DefaultZIndexes));
+function isDefaultZIndex(zIndex) {
+	return defaultZIndexSet.has(zIndex);
+}
+var zIndexSlice = createSlice({
+	name: 'zIndex',
+	initialState,
+	reducers: {
+		registerZIndexPortal: {
+			reducer: (state, action) => {
+				var zIndex = action.payload.zIndex;
+				if (state.zIndexMap[zIndex]) {
+					state.zIndexMap[zIndex].consumers += 1;
+				} else {
+					state.zIndexMap[zIndex] = {
+						consumers: 1,
+						element: undefined,
+						panoramaElement: undefined,
+					};
+				}
+			},
+			prepare: prepareAutoBatched(),
+		},
+		unregisterZIndexPortal: {
+			reducer: (state, action) => {
+				var zIndex = action.payload.zIndex;
+				if (state.zIndexMap[zIndex]) {
+					state.zIndexMap[zIndex].consumers -= 1;
+					/*
+					 * Garbage collect unused z-index entries, except for default z-indexes.
+					 * Default z-indexes are always rendered, regardless of whether there are consumers or not.
+					 * And because of that, even if we delete this entry, the ZIndexPortal provider will still be rendered
+					 * and React is not going to re-create it, and it won't re-register the element ID.
+					 * So let's not delete default z-index entries.
+					 */
+					if (state.zIndexMap[zIndex].consumers <= 0 && !isDefaultZIndex(zIndex)) {
+						delete state.zIndexMap[zIndex];
+					}
+				}
+			},
+			prepare: prepareAutoBatched(),
+		},
+		registerZIndexPortalElement: {
+			reducer: (state, action) => {
+				var _action$payload = action.payload,
+					zIndex = _action$payload.zIndex,
+					element = _action$payload.element,
+					isPanorama = _action$payload.isPanorama;
+				if (state.zIndexMap[zIndex]) {
+					if (isPanorama) {
+						state.zIndexMap[zIndex].panoramaElement = castDraft(element);
+					} else {
+						state.zIndexMap[zIndex].element = castDraft(element);
+					}
+				} else {
+					state.zIndexMap[zIndex] = {
+						consumers: 0,
+						element: isPanorama ? undefined : castDraft(element),
+						panoramaElement: isPanorama ? castDraft(element) : undefined,
+					};
+				}
+			},
+			prepare: prepareAutoBatched(),
+		},
+		unregisterZIndexPortalElement: {
+			reducer: (state, action) => {
+				var zIndex = action.payload.zIndex;
+				if (state.zIndexMap[zIndex]) {
+					if (action.payload.isPanorama) {
+						state.zIndexMap[zIndex].panoramaElement = undefined;
+					} else {
+						state.zIndexMap[zIndex].element = undefined;
+					}
+				}
+			},
+			prepare: prepareAutoBatched(),
+		},
+	},
+});
+var _zIndexSlice$actions = zIndexSlice.actions,
+	registerZIndexPortal = _zIndexSlice$actions.registerZIndexPortal,
+	unregisterZIndexPortal = _zIndexSlice$actions.unregisterZIndexPortal,
+	registerZIndexPortalElement = _zIndexSlice$actions.registerZIndexPortalElement,
+	unregisterZIndexPortalElement = _zIndexSlice$actions.unregisterZIndexPortalElement;
+export {
+	registerZIndexPortal,
+	unregisterZIndexPortal,
+	registerZIndexPortalElement,
+	unregisterZIndexPortalElement,
+};
+export var zIndexReducer = zIndexSlice.reducer;