umwd-components 0.1.756 → 0.1.758

package/dist/esm/node_modules/recharts/lib/state/ReportMainChartProps.js

@@ -0,0 +1,64 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as ReportMainChartProps$1 } from '../../../../_virtual/ReportMainChartProps.js';
+import require$$0 from 'react';
+import '../context/PanoramaContext.js';
+import './layoutSlice.js';
+import './hooks.js';
+import { __exports as hooks } from '../../../../_virtual/hooks.js';
+import { __exports as PanoramaContext } from '../../../../_virtual/PanoramaContext.js';
+import { __exports as layoutSlice } from '../../../../_virtual/layoutSlice.js';
+
+Object.defineProperty(ReportMainChartProps$1, "__esModule", {
+  value: true
+});
+ReportMainChartProps$1.ReportMainChartProps = ReportMainChartProps;
+var _react = require$$0;
+var _PanoramaContext = PanoramaContext;
+var _layoutSlice = layoutSlice;
+var _hooks = hooks;
+/**
+ * "Main" props are props that are only accepted on the main chart,
+ * as opposed to the small panorama chart inside a Brush.
+ */
+
+function ReportMainChartProps(_ref) {
+  var {
+    layout,
+    width,
+    height,
+    margin
+  } = _ref;
+  var dispatch = (0, _hooks.useAppDispatch)();
+
+  /*
+   * Skip dispatching properties in panorama chart for two reasons:
+   * 1. The root chart should be deciding on these properties, and
+   * 2. Brush reads these properties from redux store, and so they must remain stable
+   *      to avoid circular dependency and infinite re-rendering.
+   */
+  var isPanorama = (0, _PanoramaContext.useIsPanorama)();
+  /*
+   * useEffect here is required to avoid the "Cannot update a component while rendering a different component" error.
+   * https://github.com/facebook/react/issues/18178
+   *
+   * Reported in https://github.com/recharts/recharts/issues/5514
+   */
+  (0, _react.useEffect)(() => {
+    if (!isPanorama) {
+      dispatch((0, _layoutSlice.setLayout)(layout));
+      dispatch((0, _layoutSlice.setChartSize)({
+        width,
+        height
+      }));
+      dispatch((0, _layoutSlice.setMargin)(margin));
+    }
+  }, [dispatch, isPanorama, layout, width, height, margin]);
+  return null;
+}
+
+export { ReportMainChartProps$1 as default };

package/dist/esm/node_modules/recharts/lib/state/SetGraphicalItem.js

@@ -0,0 +1,81 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as SetGraphicalItem } from '../../../../_virtual/SetGraphicalItem.js';
+import require$$0 from 'react';
+import './hooks.js';
+import './graphicalItemsSlice.js';
+import '../util/ChartUtils.js';
+import { __exports as hooks } from '../../../../_virtual/hooks.js';
+import { __exports as ChartUtils } from '../../../../_virtual/ChartUtils.js';
+import { __exports as graphicalItemsSlice } from '../../../../_virtual/graphicalItemsSlice.js';
+
+Object.defineProperty(SetGraphicalItem, "__esModule", {
+  value: true
+});
+SetGraphicalItem.SetCartesianGraphicalItem = SetCartesianGraphicalItem;
+SetGraphicalItem.SetPolarGraphicalItem = SetPolarGraphicalItem;
+var _react = require$$0;
+var _hooks = hooks;
+var _graphicalItemsSlice = graphicalItemsSlice;
+var _ChartUtils = ChartUtils;
+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), true).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: true, configurable: true, writable: true }) : 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); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function SetCartesianGraphicalItem(props) {
+  var dispatch = (0, _hooks.useAppDispatch)();
+  var prevPropsRef = (0, _react.useRef)(null);
+  (0, _react.useEffect)(() => {
+    var settings = _objectSpread(_objectSpread({}, props), {}, {
+      stackId: (0, _ChartUtils.getNormalizedStackId)(props.stackId)
+    });
+    if (prevPropsRef.current === null) {
+      dispatch((0, _graphicalItemsSlice.addCartesianGraphicalItem)(settings));
+    } else if (prevPropsRef.current !== settings) {
+      dispatch((0, _graphicalItemsSlice.replaceCartesianGraphicalItem)({
+        prev: prevPropsRef.current,
+        next: settings
+      }));
+    }
+    prevPropsRef.current = settings;
+  }, [dispatch, props]);
+  (0, _react.useEffect)(() => {
+    return () => {
+      if (prevPropsRef.current) {
+        dispatch((0, _graphicalItemsSlice.removeCartesianGraphicalItem)(prevPropsRef.current));
+        /*
+         * Here we have to reset the ref to null because in StrictMode, the effect will run twice,
+         * but it will keep the same ref value from the first render.
+         *
+         * In browser, React will clear the ref after the first effect cleanup,
+         * so that wouldn't be an issue.
+         *
+         * In StrictMode, however, the ref is kept,
+         * and in the hook above the code checks for `prevPropsRef.current === null`
+         * which would be false so it would not dispatch the `addCartesianGraphicalItem` action again.
+         *
+         * https://github.com/recharts/recharts/issues/6022
+         */
+        prevPropsRef.current = null;
+      }
+    };
+  }, [dispatch]);
+  return null;
+}
+function SetPolarGraphicalItem(props) {
+  var dispatch = (0, _hooks.useAppDispatch)();
+  (0, _react.useEffect)(() => {
+    dispatch((0, _graphicalItemsSlice.addPolarGraphicalItem)(props));
+    return () => {
+      dispatch((0, _graphicalItemsSlice.removePolarGraphicalItem)(props));
+    };
+  }, [dispatch, props]);
+  return null;
+}
+
+export { SetGraphicalItem as default };

package/dist/esm/node_modules/recharts/lib/state/SetLegendPayload.js

@@ -0,0 +1,64 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as SetLegendPayload$1 } from '../../../../_virtual/SetLegendPayload.js';
+import require$$0 from 'react';
+import '../context/PanoramaContext.js';
+import '../context/chartLayoutContext.js';
+import './hooks.js';
+import './legendSlice.js';
+import { __exports as hooks } from '../../../../_virtual/hooks.js';
+import { __exports as PanoramaContext } from '../../../../_virtual/PanoramaContext.js';
+import { __exports as legendSlice } from '../../../../_virtual/legendSlice.js';
+import { __exports as chartLayoutContext } from '../../../../_virtual/chartLayoutContext.js';
+
+Object.defineProperty(SetLegendPayload$1, "__esModule", {
+  value: true
+});
+SetLegendPayload$1.SetLegendPayload = SetLegendPayload;
+SetLegendPayload$1.SetPolarLegendPayload = SetPolarLegendPayload;
+var _react = require$$0;
+var _PanoramaContext = PanoramaContext;
+var _chartLayoutContext = chartLayoutContext;
+var _hooks = hooks;
+var _legendSlice = legendSlice;
+var noop = () => {};
+function SetLegendPayload(_ref) {
+  var {
+    legendPayload
+  } = _ref;
+  var dispatch = (0, _hooks.useAppDispatch)();
+  var isPanorama = (0, _PanoramaContext.useIsPanorama)();
+  (0, _react.useEffect)(() => {
+    if (isPanorama) {
+      return noop;
+    }
+    dispatch((0, _legendSlice.addLegendPayload)(legendPayload));
+    return () => {
+      dispatch((0, _legendSlice.removeLegendPayload)(legendPayload));
+    };
+  }, [dispatch, isPanorama, legendPayload]);
+  return null;
+}
+function SetPolarLegendPayload(_ref2) {
+  var {
+    legendPayload
+  } = _ref2;
+  var dispatch = (0, _hooks.useAppDispatch)();
+  var layout = (0, _hooks.useAppSelector)(_chartLayoutContext.selectChartLayout);
+  (0, _react.useEffect)(() => {
+    if (layout !== 'centric' && layout !== 'radial') {
+      return noop;
+    }
+    dispatch((0, _legendSlice.addLegendPayload)(legendPayload));
+    return () => {
+      dispatch((0, _legendSlice.removeLegendPayload)(legendPayload));
+    };
+  }, [dispatch, layout, legendPayload]);
+  return null;
+}
+
+export { SetLegendPayload$1 as default };

package/dist/esm/node_modules/recharts/lib/state/SetTooltipEntrySettings.js

@@ -0,0 +1,45 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as SetTooltipEntrySettings$1 } from '../../../../_virtual/SetTooltipEntrySettings.js';
+import require$$0 from 'react';
+import './hooks.js';
+import './tooltipSlice.js';
+import '../context/PanoramaContext.js';
+import { __exports as hooks } from '../../../../_virtual/hooks.js';
+import { __exports as PanoramaContext } from '../../../../_virtual/PanoramaContext.js';
+import { __exports as tooltipSlice } from '../../../../_virtual/tooltipSlice.js';
+
+Object.defineProperty(SetTooltipEntrySettings$1, "__esModule", {
+  value: true
+});
+SetTooltipEntrySettings$1.SetTooltipEntrySettings = SetTooltipEntrySettings;
+var _react = require$$0;
+var _hooks = hooks;
+var _tooltipSlice = tooltipSlice;
+var _PanoramaContext = PanoramaContext;
+function SetTooltipEntrySettings(_ref) {
+  var {
+    fn,
+    args
+  } = _ref;
+  var dispatch = (0, _hooks.useAppDispatch)();
+  var isPanorama = (0, _PanoramaContext.useIsPanorama)();
+  (0, _react.useEffect)(() => {
+    if (isPanorama) {
+      // Panorama graphical items should never contribute to Tooltip payload.
+      return undefined;
+    }
+    var tooltipEntrySettings = fn(args);
+    dispatch((0, _tooltipSlice.addTooltipEntrySettings)(tooltipEntrySettings));
+    return () => {
+      dispatch((0, _tooltipSlice.removeTooltipEntrySettings)(tooltipEntrySettings));
+    };
+  }, [fn, args, dispatch, isPanorama]);
+  return null;
+}
+
+export { SetTooltipEntrySettings$1 as default };

package/dist/esm/node_modules/recharts/lib/state/brushSlice.js

@@ -0,0 +1,50 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as brushSlice$1 } from '../../../../_virtual/brushSlice.js';
+import require$$0 from '../../../../_virtual/redux-toolkit.modern.js';
+
+Object.defineProperty(brushSlice$1, "__esModule", {
+  value: true
+});
+brushSlice$1.setBrushSettings = brushSlice$1.brushSlice = brushSlice$1.brushReducer = void 0;
+var _toolkit = require$$0;
+/**
+ * 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
+  }
+};
+var brushSlice = brushSlice$1.brushSlice = (0, _toolkit.createSlice)({
+  name: 'brush',
+  initialState,
+  reducers: {
+    setBrushSettings(_state, action) {
+      if (action.payload == null) {
+        return initialState;
+      }
+      return action.payload;
+    }
+  }
+});
+var {
+  setBrushSettings
+} = brushSlice.actions;
+brushSlice$1.setBrushSettings = setBrushSettings;
+brushSlice$1.brushReducer = brushSlice.reducer;
+
+export { brushSlice$1 as default };

package/dist/esm/node_modules/recharts/lib/state/cartesianAxisSlice.js

@@ -0,0 +1,101 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as cartesianAxisSlice$1 } from '../../../../_virtual/cartesianAxisSlice.js';
+import require$$0 from '../../../../_virtual/redux-toolkit.modern.js';
+import { c as cjsExports } from '../../../immer/dist/cjs/index.js';
+
+Object.defineProperty(cartesianAxisSlice$1, "__esModule", {
+  value: true
+});
+cartesianAxisSlice$1.updateYAxisWidth = cartesianAxisSlice$1.removeZAxis = cartesianAxisSlice$1.removeYAxis = cartesianAxisSlice$1.removeXAxis = cartesianAxisSlice$1.cartesianAxisReducer = cartesianAxisSlice$1.addZAxis = cartesianAxisSlice$1.addYAxis = cartesianAxisSlice$1.addXAxis = void 0;
+var _toolkit = require$$0;
+var _immer = cjsExports;
+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), true).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: true, configurable: true, writable: true }) : 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); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/**
+ * Properties shared in X, Y, and Z axes
+ */
+
+/**
+ * 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 = (0, _toolkit.createSlice)({
+  name: 'cartesianAxis',
+  initialState,
+  reducers: {
+    addXAxis(state, action) {
+      state.xAxis[action.payload.id] = (0, _immer.castDraft)(action.payload);
+    },
+    removeXAxis(state, action) {
+      delete state.xAxis[action.payload.id];
+    },
+    addYAxis(state, action) {
+      state.yAxis[action.payload.id] = (0, _immer.castDraft)(action.payload);
+    },
+    removeYAxis(state, action) {
+      delete state.yAxis[action.payload.id];
+    },
+    addZAxis(state, action) {
+      state.zAxis[action.payload.id] = (0, _immer.castDraft)(action.payload);
+    },
+    removeZAxis(state, action) {
+      delete state.zAxis[action.payload.id];
+    },
+    updateYAxisWidth(state, action) {
+      var {
+        id,
+        width
+      } = action.payload;
+      if (state.yAxis[id]) {
+        state.yAxis[id] = _objectSpread(_objectSpread({}, state.yAxis[id]), {}, {
+          width
+        });
+      }
+    }
+  }
+});
+var {
+  addXAxis,
+  removeXAxis,
+  addYAxis,
+  removeYAxis,
+  addZAxis,
+  removeZAxis,
+  updateYAxisWidth
+} = cartesianAxisSlice.actions;
+cartesianAxisSlice$1.updateYAxisWidth = updateYAxisWidth;
+cartesianAxisSlice$1.removeZAxis = removeZAxis;
+cartesianAxisSlice$1.addZAxis = addZAxis;
+cartesianAxisSlice$1.removeYAxis = removeYAxis;
+cartesianAxisSlice$1.addYAxis = addYAxis;
+cartesianAxisSlice$1.removeXAxis = removeXAxis;
+cartesianAxisSlice$1.addXAxis = addXAxis;
+cartesianAxisSlice$1.cartesianAxisReducer = cartesianAxisSlice.reducer;
+
+export { cartesianAxisSlice$1 as default };

package/dist/esm/node_modules/recharts/lib/state/chartDataSlice.js

@@ -0,0 +1,80 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as chartDataSlice$1 } from '../../../../_virtual/chartDataSlice.js';
+import require$$0 from '../../../../_virtual/redux-toolkit.modern.js';
+
+Object.defineProperty(chartDataSlice$1, "__esModule", {
+  value: true
+});
+chartDataSlice$1.setDataStartEndIndexes = chartDataSlice$1.setComputedData = chartDataSlice$1.setChartData = chartDataSlice$1.initialChartDataState = chartDataSlice$1.chartDataReducer = void 0;
+var _toolkit = require$$0;
+/**
+ * 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
+ */
+
+/**
+ * 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.
+ */
+
+var initialChartDataState = chartDataSlice$1.initialChartDataState = {
+  chartData: undefined,
+  computedData: undefined,
+  dataStartIndex: 0,
+  dataEndIndex: 0
+};
+var chartDataSlice = (0, _toolkit.createSlice)({
+  name: 'chartData',
+  initialState: initialChartDataState,
+  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) {
+      var {
+        startIndex,
+        endIndex
+      } = action.payload;
+      if (startIndex != null) {
+        state.dataStartIndex = startIndex;
+      }
+      if (endIndex != null) {
+        state.dataEndIndex = endIndex;
+      }
+    }
+  }
+});
+var {
+  setChartData,
+  setDataStartEndIndexes,
+  setComputedData
+} = chartDataSlice.actions;
+chartDataSlice$1.setComputedData = setComputedData;
+chartDataSlice$1.setDataStartEndIndexes = setDataStartEndIndexes;
+chartDataSlice$1.setChartData = setChartData;
+chartDataSlice$1.chartDataReducer = chartDataSlice.reducer;
+
+export { chartDataSlice$1 as default };

package/dist/esm/node_modules/recharts/lib/state/externalEventsMiddleware.js

@@ -0,0 +1,39 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as externalEventsMiddleware$1 } from '../../../../_virtual/externalEventsMiddleware.js';
+import require$$0 from '../../../../_virtual/redux-toolkit.modern.js';
+import './selectors/tooltipSelectors.js';
+import { __exports as tooltipSelectors } from '../../../../_virtual/tooltipSelectors.js';
+
+Object.defineProperty(externalEventsMiddleware$1, "__esModule", {
+  value: true
+});
+externalEventsMiddleware$1.externalEventsMiddleware = externalEventsMiddleware$1.externalEventAction = void 0;
+var _toolkit = require$$0;
+var _tooltipSelectors = tooltipSelectors;
+var externalEventAction = externalEventsMiddleware$1.externalEventAction = (0, _toolkit.createAction)('externalEvent');
+var externalEventsMiddleware = externalEventsMiddleware$1.externalEventsMiddleware = (0, _toolkit.createListenerMiddleware)();
+externalEventsMiddleware.startListening({
+  actionCreator: externalEventAction,
+  effect: (action, listenerApi) => {
+    if (action.payload.handler == null) {
+      return;
+    }
+    var state = listenerApi.getState();
+    var nextState = {
+      activeCoordinate: (0, _tooltipSelectors.selectActiveTooltipCoordinate)(state),
+      activeDataKey: (0, _tooltipSelectors.selectActiveTooltipDataKey)(state),
+      activeIndex: (0, _tooltipSelectors.selectActiveTooltipIndex)(state),
+      activeLabel: (0, _tooltipSelectors.selectActiveLabel)(state),
+      activeTooltipIndex: (0, _tooltipSelectors.selectActiveTooltipIndex)(state),
+      isTooltipActive: (0, _tooltipSelectors.selectIsTooltipActive)(state)
+    };
+    action.payload.handler(nextState, action.payload.reactEvent);
+  }
+});
+
+export { externalEventsMiddleware$1 as default };

package/dist/esm/node_modules/recharts/lib/state/graphicalItemsSlice.js

@@ -0,0 +1,86 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as graphicalItemsSlice$1 } from '../../../../_virtual/graphicalItemsSlice.js';
+import require$$0 from '../../../../_virtual/redux-toolkit.modern.js';
+import { c as cjsExports } from '../../../immer/dist/cjs/index.js';
+
+Object.defineProperty(graphicalItemsSlice$1, "__esModule", {
+  value: true
+});
+graphicalItemsSlice$1.replaceCartesianGraphicalItem = graphicalItemsSlice$1.removePolarGraphicalItem = graphicalItemsSlice$1.removeCartesianGraphicalItem = graphicalItemsSlice$1.removeBar = graphicalItemsSlice$1.graphicalItemsReducer = graphicalItemsSlice$1.addPolarGraphicalItem = graphicalItemsSlice$1.addCartesianGraphicalItem = graphicalItemsSlice$1.addBar = void 0;
+var _toolkit = require$$0;
+var _immer = cjsExports;
+/**
+ * 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 = {
+  countOfBars: 0,
+  cartesianItems: [],
+  polarItems: []
+};
+var graphicalItemsSlice = (0, _toolkit.createSlice)({
+  name: 'graphicalItems',
+  initialState,
+  reducers: {
+    addBar(state) {
+      state.countOfBars += 1;
+    },
+    removeBar(state) {
+      state.countOfBars -= 1;
+    },
+    addCartesianGraphicalItem(state, action) {
+      state.cartesianItems.push((0, _immer.castDraft)(action.payload));
+    },
+    replaceCartesianGraphicalItem(state, action) {
+      var {
+        prev,
+        next
+      } = action.payload;
+      var index = (0, _toolkit.current)(state).cartesianItems.indexOf((0, _immer.castDraft)(prev));
+      if (index > -1) {
+        state.cartesianItems[index] = (0, _immer.castDraft)(next);
+      }
+    },
+    removeCartesianGraphicalItem(state, action) {
+      var index = (0, _toolkit.current)(state).cartesianItems.indexOf((0, _immer.castDraft)(action.payload));
+      if (index > -1) {
+        state.cartesianItems.splice(index, 1);
+      }
+    },
+    addPolarGraphicalItem(state, action) {
+      state.polarItems.push((0, _immer.castDraft)(action.payload));
+    },
+    removePolarGraphicalItem(state, action) {
+      var index = (0, _toolkit.current)(state).polarItems.indexOf((0, _immer.castDraft)(action.payload));
+      if (index > -1) {
+        state.polarItems.splice(index, 1);
+      }
+    }
+  }
+});
+var {
+  addBar,
+  removeBar,
+  addCartesianGraphicalItem,
+  replaceCartesianGraphicalItem,
+  removeCartesianGraphicalItem,
+  addPolarGraphicalItem,
+  removePolarGraphicalItem
+} = graphicalItemsSlice.actions;
+graphicalItemsSlice$1.removePolarGraphicalItem = removePolarGraphicalItem;
+graphicalItemsSlice$1.addPolarGraphicalItem = addPolarGraphicalItem;
+graphicalItemsSlice$1.removeCartesianGraphicalItem = removeCartesianGraphicalItem;
+graphicalItemsSlice$1.replaceCartesianGraphicalItem = replaceCartesianGraphicalItem;
+graphicalItemsSlice$1.addCartesianGraphicalItem = addCartesianGraphicalItem;
+graphicalItemsSlice$1.removeBar = removeBar;
+graphicalItemsSlice$1.addBar = addBar;
+graphicalItemsSlice$1.graphicalItemsReducer = graphicalItemsSlice.reducer;
+
+export { graphicalItemsSlice$1 as default };

package/dist/esm/node_modules/recharts/lib/state/hooks.js

@@ -0,0 +1,55 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as hooks } from '../../../../_virtual/hooks.js';
+import { w as withSelectorExports } from '../../../use-sync-external-store/shim/with-selector.js';
+import require$$0 from 'react';
+import './RechartsReduxContext.js';
+import { __exports as RechartsReduxContext } from '../../../../_virtual/RechartsReduxContext.js';
+
+Object.defineProperty(hooks, "__esModule", {
+  value: true
+});
+hooks.useAppDispatch = void 0;
+hooks.useAppSelector = useAppSelector;
+var _withSelector = withSelectorExports;
+var _react = require$$0;
+var _RechartsReduxContext = RechartsReduxContext;
+var noopDispatch = a => a;
+var useAppDispatch = () => {
+  var context = (0, _react.useContext)(_RechartsReduxContext.RechartsReduxContext);
+  if (context) {
+    return context.store.dispatch;
+  }
+  return noopDispatch;
+};
+hooks.useAppDispatch = useAppDispatch;
+var noop = () => {};
+var addNestedSubNoop = () => noop;
+var refEquality = (a, b) => a === b;
+
+/**
+ * This is a recharts variant of `useSelector` from 'react-redux' package.
+ *
+ * The difference is that react-redux version will throw an Error when used outside of Redux context.
+ *
+ * This, recharts version, will return undefined instead.
+ *
+ * This is because we want to allow using our components outside the Chart wrapper,
+ * and have people provide all props explicitly.
+ *
+ * If however they use the component inside a chart wrapper then those props become optional,
+ * and we read them from Redux state instead.
+ *
+ * @param selector for pulling things out of Redux store; will not be called if the store is not accessible
+ * @return whatever the selector returned; or undefined when outside of Redux store
+ */
+function useAppSelector(selector) {
+  var context = (0, _react.useContext)(_RechartsReduxContext.RechartsReduxContext);
+  return (0, _withSelector.useSyncExternalStoreWithSelector)(context ? context.subscription.addNestedSub : addNestedSubNoop, context ? context.store.getState : noop, context ? context.store.getState : noop, context ? selector : noop, refEquality);
+}
+
+export { hooks as default };