umwd-components 0.1.756 → 0.1.758

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

@@ -0,0 +1,105 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as keyboardEventsMiddleware$1 } from '../../../../_virtual/keyboardEventsMiddleware.js';
+import require$$0 from '../../../../_virtual/redux-toolkit.modern.js';
+import './tooltipSlice.js';
+import './selectors/tooltipSelectors.js';
+import './selectors/selectors.js';
+import './selectors/axisSelectors.js';
+import './selectors/combiners/combineActiveTooltipIndex.js';
+import { __exports as combineActiveTooltipIndex } from '../../../../_virtual/combineActiveTooltipIndex.js';
+import { __exports as tooltipSelectors } from '../../../../_virtual/tooltipSelectors.js';
+import { __exports as selectors } from '../../../../_virtual/selectors.js';
+import { __exports as tooltipSlice } from '../../../../_virtual/tooltipSlice.js';
+import { __exports as axisSelectors } from '../../../../_virtual/axisSelectors.js';
+
+Object.defineProperty(keyboardEventsMiddleware$1, "__esModule", {
+  value: true
+});
+keyboardEventsMiddleware$1.keyboardEventsMiddleware = keyboardEventsMiddleware$1.keyDownAction = keyboardEventsMiddleware$1.focusAction = void 0;
+var _toolkit = require$$0;
+var _tooltipSlice = tooltipSlice;
+var _tooltipSelectors = tooltipSelectors;
+var _selectors = selectors;
+var _axisSelectors = axisSelectors;
+var _combineActiveTooltipIndex = combineActiveTooltipIndex;
+var keyDownAction = keyboardEventsMiddleware$1.keyDownAction = (0, _toolkit.createAction)('keyDown');
+var focusAction = keyboardEventsMiddleware$1.focusAction = (0, _toolkit.createAction)('focus');
+var keyboardEventsMiddleware = keyboardEventsMiddleware$1.keyboardEventsMiddleware = (0, _toolkit.createListenerMiddleware)();
+keyboardEventsMiddleware.startListening({
+  actionCreator: keyDownAction,
+  effect: (action, listenerApi) => {
+    var state = listenerApi.getState();
+    var accessibilityLayerIsActive = state.rootProps.accessibilityLayer !== false;
+    if (!accessibilityLayerIsActive) {
+      return;
+    }
+    var {
+      keyboardInteraction
+    } = state.tooltip;
+    var key = action.payload;
+    if (key !== 'ArrowRight' && key !== 'ArrowLeft' && key !== 'Enter') {
+      return;
+    }
+
+    // TODO this is lacking index for charts that do not support numeric indexes
+    var currentIndex = Number((0, _combineActiveTooltipIndex.combineActiveTooltipIndex)(keyboardInteraction, (0, _tooltipSelectors.selectTooltipDisplayedData)(state)));
+    var tooltipTicks = (0, _tooltipSelectors.selectTooltipAxisTicks)(state);
+    if (key === 'Enter') {
+      var _coordinate = (0, _selectors.selectCoordinateForDefaultIndex)(state, 'axis', 'hover', String(keyboardInteraction.index));
+      listenerApi.dispatch((0, _tooltipSlice.setKeyboardInteraction)({
+        active: !keyboardInteraction.active,
+        activeIndex: keyboardInteraction.index,
+        activeDataKey: keyboardInteraction.dataKey,
+        activeCoordinate: _coordinate
+      }));
+      return;
+    }
+    var direction = (0, _axisSelectors.selectChartDirection)(state);
+    var directionMultiplier = direction === 'left-to-right' ? 1 : -1;
+    var movement = key === 'ArrowRight' ? 1 : -1;
+    var nextIndex = currentIndex + movement * directionMultiplier;
+    if (tooltipTicks == null || nextIndex >= tooltipTicks.length || nextIndex < 0) {
+      return;
+    }
+    var coordinate = (0, _selectors.selectCoordinateForDefaultIndex)(state, 'axis', 'hover', String(nextIndex));
+    listenerApi.dispatch((0, _tooltipSlice.setKeyboardInteraction)({
+      active: true,
+      activeIndex: nextIndex.toString(),
+      activeDataKey: undefined,
+      activeCoordinate: coordinate
+    }));
+  }
+});
+keyboardEventsMiddleware.startListening({
+  actionCreator: focusAction,
+  effect: (_action, listenerApi) => {
+    var state = listenerApi.getState();
+    var accessibilityLayerIsActive = state.rootProps.accessibilityLayer !== false;
+    if (!accessibilityLayerIsActive) {
+      return;
+    }
+    var {
+      keyboardInteraction
+    } = state.tooltip;
+    if (keyboardInteraction.active) {
+      return;
+    }
+    if (keyboardInteraction.index == null) {
+      var nextIndex = '0';
+      var coordinate = (0, _selectors.selectCoordinateForDefaultIndex)(state, 'axis', 'hover', String(nextIndex));
+      listenerApi.dispatch((0, _tooltipSlice.setKeyboardInteraction)({
+        activeDataKey: undefined,
+        active: true,
+        activeIndex: nextIndex,
+        activeCoordinate: coordinate
+      }));
+    }
+  }
+});
+
+export { keyboardEventsMiddleware$1 as default };

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

@@ -0,0 +1,61 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as layoutSlice } from '../../../../_virtual/layoutSlice.js';
+import require$$0 from '../../../../_virtual/redux-toolkit.modern.js';
+
+Object.defineProperty(layoutSlice, "__esModule", {
+  value: true
+});
+layoutSlice.setScale = layoutSlice.setMargin = layoutSlice.setLayout = layoutSlice.setChartSize = layoutSlice.chartLayoutReducer = void 0;
+var _toolkit = require$$0;
+var initialState = {
+  layoutType: 'horizontal',
+  width: 0,
+  height: 0,
+  margin: {
+    top: 5,
+    right: 5,
+    bottom: 5,
+    left: 5
+  },
+  scale: 1
+};
+var chartLayoutSlice = (0, _toolkit.createSlice)({
+  name: 'chartLayout',
+  initialState,
+  reducers: {
+    setLayout(state, action) {
+      state.layoutType = action.payload;
+    },
+    setChartSize(state, action) {
+      state.width = action.payload.width;
+      state.height = action.payload.height;
+    },
+    setMargin(state, action) {
+      state.margin.top = action.payload.top;
+      state.margin.right = action.payload.right;
+      state.margin.bottom = action.payload.bottom;
+      state.margin.left = action.payload.left;
+    },
+    setScale(state, action) {
+      state.scale = action.payload;
+    }
+  }
+});
+var {
+  setMargin,
+  setLayout,
+  setChartSize,
+  setScale
+} = chartLayoutSlice.actions;
+layoutSlice.setScale = setScale;
+layoutSlice.setChartSize = setChartSize;
+layoutSlice.setLayout = setLayout;
+layoutSlice.setMargin = setMargin;
+layoutSlice.chartLayoutReducer = chartLayoutSlice.reducer;
+
+export { layoutSlice as default };

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

@@ -0,0 +1,75 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as legendSlice$1 } from '../../../../_virtual/legendSlice.js';
+import require$$0 from '../../../../_virtual/redux-toolkit.modern.js';
+import { c as cjsExports } from '../../../immer/dist/cjs/index.js';
+
+Object.defineProperty(legendSlice$1, "__esModule", {
+  value: true
+});
+legendSlice$1.setLegendSize = legendSlice$1.setLegendSettings = legendSlice$1.removeLegendPayload = legendSlice$1.legendReducer = legendSlice$1.addLegendPayload = void 0;
+var _toolkit = require$$0;
+var _immer = cjsExports;
+/**
+ * The properties inside this state update independently of each other and quite often.
+ * When selecting, never select the whole state because you are going to get
+ * unnecessary re-renders. Select only the properties you need.
+ *
+ * This is why this state type is not exported - don't use it directly.
+ */
+
+var initialState = {
+  settings: {
+    layout: 'horizontal',
+    align: 'center',
+    verticalAlign: 'middle',
+    itemSorter: 'value'
+  },
+  size: {
+    width: 0,
+    height: 0
+  },
+  payload: []
+};
+var legendSlice = (0, _toolkit.createSlice)({
+  name: 'legend',
+  initialState,
+  reducers: {
+    setLegendSize(state, action) {
+      state.size.width = action.payload.width;
+      state.size.height = action.payload.height;
+    },
+    setLegendSettings(state, action) {
+      state.settings.align = action.payload.align;
+      state.settings.layout = action.payload.layout;
+      state.settings.verticalAlign = action.payload.verticalAlign;
+      state.settings.itemSorter = action.payload.itemSorter;
+    },
+    addLegendPayload(state, action) {
+      state.payload.push((0, _immer.castDraft)(action.payload));
+    },
+    removeLegendPayload(state, action) {
+      var index = (0, _toolkit.current)(state).payload.indexOf((0, _immer.castDraft)(action.payload));
+      if (index > -1) {
+        state.payload.splice(index, 1);
+      }
+    }
+  }
+});
+var {
+  setLegendSize,
+  setLegendSettings,
+  addLegendPayload,
+  removeLegendPayload
+} = legendSlice.actions;
+legendSlice$1.removeLegendPayload = removeLegendPayload;
+legendSlice$1.addLegendPayload = addLegendPayload;
+legendSlice$1.setLegendSettings = setLegendSettings;
+legendSlice$1.setLegendSize = setLegendSize;
+legendSlice$1.legendReducer = legendSlice.reducer;
+
+export { legendSlice$1 as default };

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

@@ -0,0 +1,71 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as mouseEventsMiddleware } from '../../../../_virtual/mouseEventsMiddleware.js';
+import require$$0 from '../../../../_virtual/redux-toolkit.modern.js';
+import './tooltipSlice.js';
+import './selectors/selectActivePropsFromChartPointer.js';
+import './selectors/selectTooltipEventType.js';
+import '../util/getChartPointer.js';
+import { __exports as selectActivePropsFromChartPointer } from '../../../../_virtual/selectActivePropsFromChartPointer.js';
+import { __exports as getChartPointer } from '../../../../_virtual/getChartPointer.js';
+import { __exports as tooltipSlice } from '../../../../_virtual/tooltipSlice.js';
+import { __exports as selectTooltipEventType } from '../../../../_virtual/selectTooltipEventType.js';
+
+Object.defineProperty(mouseEventsMiddleware, "__esModule", {
+  value: true
+});
+mouseEventsMiddleware.mouseMoveMiddleware = mouseEventsMiddleware.mouseMoveAction = mouseEventsMiddleware.mouseClickMiddleware = mouseEventsMiddleware.mouseClickAction = void 0;
+var _toolkit = require$$0;
+var _tooltipSlice = tooltipSlice;
+var _selectActivePropsFromChartPointer = selectActivePropsFromChartPointer;
+var _selectTooltipEventType = selectTooltipEventType;
+var _getChartPointer = getChartPointer;
+var mouseClickAction = mouseEventsMiddleware.mouseClickAction = (0, _toolkit.createAction)('mouseClick');
+var mouseClickMiddleware = mouseEventsMiddleware.mouseClickMiddleware = (0, _toolkit.createListenerMiddleware)();
+
+// TODO: there's a bug here when you click the chart the activeIndex resets to zero
+mouseClickMiddleware.startListening({
+  actionCreator: mouseClickAction,
+  effect: (action, listenerApi) => {
+    var mousePointer = action.payload;
+    var activeProps = (0, _selectActivePropsFromChartPointer.selectActivePropsFromChartPointer)(listenerApi.getState(), (0, _getChartPointer.getChartPointer)(mousePointer));
+    if ((activeProps === null || activeProps === void 0 ? void 0 : activeProps.activeIndex) != null) {
+      listenerApi.dispatch((0, _tooltipSlice.setMouseClickAxisIndex)({
+        activeIndex: activeProps.activeIndex,
+        activeDataKey: undefined,
+        activeCoordinate: activeProps.activeCoordinate
+      }));
+    }
+  }
+});
+var mouseMoveAction = mouseEventsMiddleware.mouseMoveAction = (0, _toolkit.createAction)('mouseMove');
+var mouseMoveMiddleware = mouseEventsMiddleware.mouseMoveMiddleware = (0, _toolkit.createListenerMiddleware)();
+mouseMoveMiddleware.startListening({
+  actionCreator: mouseMoveAction,
+  effect: (action, listenerApi) => {
+    var mousePointer = action.payload;
+    var state = listenerApi.getState();
+    var tooltipEventType = (0, _selectTooltipEventType.selectTooltipEventType)(state, state.tooltip.settings.shared);
+    var activeProps = (0, _selectActivePropsFromChartPointer.selectActivePropsFromChartPointer)(state, (0, _getChartPointer.getChartPointer)(mousePointer));
+
+    // this functionality only applies to charts that have axes
+    if (tooltipEventType === 'axis') {
+      if ((activeProps === null || activeProps === void 0 ? void 0 : activeProps.activeIndex) != null) {
+        listenerApi.dispatch((0, _tooltipSlice.setMouseOverAxisIndex)({
+          activeIndex: activeProps.activeIndex,
+          activeDataKey: undefined,
+          activeCoordinate: activeProps.activeCoordinate
+        }));
+      } else {
+        // this is needed to clear tooltip state when the mouse moves out of the inRange (svg - offset) function, but not yet out of the svg
+        listenerApi.dispatch((0, _tooltipSlice.mouseLeaveChart)());
+      }
+    }
+  }
+});
+
+export { mouseEventsMiddleware as default };

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

@@ -0,0 +1,61 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as optionsSlice$1 } from '../../../../_virtual/optionsSlice.js';
+import require$$0 from '../../../../_virtual/redux-toolkit.modern.js';
+import '../util/DataUtils.js';
+import { __exports as DataUtils } from '../../../../_virtual/DataUtils.js';
+
+Object.defineProperty(optionsSlice$1, "__esModule", {
+  value: true
+});
+optionsSlice$1.arrayTooltipSearcher = arrayTooltipSearcher;
+optionsSlice$1.optionsReducer = optionsSlice$1.createEventEmitter = void 0;
+var _toolkit = require$$0;
+var _DataUtils = DataUtils;
+/**
+ * These chart options are decided internally, by Recharts,
+ * and will not change during the lifetime of the chart.
+ *
+ * Changing these options can be done by swapping the root element
+ * which will make a brand-new Redux store.
+ *
+ * If you want to store options that can be changed by the user,
+ * use UpdatableChartOptions in rootPropsSlice.ts.
+ */
+
+function arrayTooltipSearcher(data, strIndex) {
+  if (!strIndex) return undefined;
+  var numIndex = Number.parseInt(strIndex, 10);
+  if ((0, _DataUtils.isNan)(numIndex)) {
+    return undefined;
+  }
+  return data === null || data === void 0 ? void 0 : data[numIndex];
+}
+var initialState = {
+  chartName: '',
+  tooltipPayloadSearcher: undefined,
+  eventEmitter: undefined,
+  defaultTooltipEventType: 'axis'
+};
+var optionsSlice = (0, _toolkit.createSlice)({
+  name: 'options',
+  initialState,
+  reducers: {
+    createEventEmitter: state => {
+      if (state.eventEmitter == null) {
+        state.eventEmitter = Symbol('rechartsEventEmitter');
+      }
+    }
+  }
+});
+optionsSlice$1.optionsReducer = optionsSlice.reducer;
+var {
+  createEventEmitter
+} = optionsSlice.actions;
+optionsSlice$1.createEventEmitter = createEventEmitter;
+
+export { optionsSlice$1 as default };

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

@@ -0,0 +1,51 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as polarAxisSlice$1 } from '../../../../_virtual/polarAxisSlice.js';
+import require$$0 from '../../../../_virtual/redux-toolkit.modern.js';
+import { c as cjsExports } from '../../../immer/dist/cjs/index.js';
+
+Object.defineProperty(polarAxisSlice$1, "__esModule", {
+  value: true
+});
+polarAxisSlice$1.removeRadiusAxis = polarAxisSlice$1.removeAngleAxis = polarAxisSlice$1.polarAxisReducer = polarAxisSlice$1.addRadiusAxis = polarAxisSlice$1.addAngleAxis = void 0;
+var _toolkit = require$$0;
+var _immer = cjsExports;
+var initialState = {
+  radiusAxis: {},
+  angleAxis: {}
+};
+var polarAxisSlice = (0, _toolkit.createSlice)({
+  name: 'polarAxis',
+  initialState,
+  reducers: {
+    addRadiusAxis(state, action) {
+      state.radiusAxis[action.payload.id] = (0, _immer.castDraft)(action.payload);
+    },
+    removeRadiusAxis(state, action) {
+      delete state.radiusAxis[action.payload.id];
+    },
+    addAngleAxis(state, action) {
+      state.angleAxis[action.payload.id] = (0, _immer.castDraft)(action.payload);
+    },
+    removeAngleAxis(state, action) {
+      delete state.angleAxis[action.payload.id];
+    }
+  }
+});
+var {
+  addRadiusAxis,
+  removeRadiusAxis,
+  addAngleAxis,
+  removeAngleAxis
+} = polarAxisSlice.actions;
+polarAxisSlice$1.removeAngleAxis = removeAngleAxis;
+polarAxisSlice$1.addAngleAxis = addAngleAxis;
+polarAxisSlice$1.removeRadiusAxis = removeRadiusAxis;
+polarAxisSlice$1.addRadiusAxis = addRadiusAxis;
+polarAxisSlice$1.polarAxisReducer = polarAxisSlice.reducer;
+
+export { polarAxisSlice$1 as default };

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

@@ -0,0 +1,30 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as polarOptionsSlice$1 } from '../../../../_virtual/polarOptionsSlice.js';
+import require$$0 from '../../../../_virtual/redux-toolkit.modern.js';
+
+Object.defineProperty(polarOptionsSlice$1, "__esModule", {
+  value: true
+});
+polarOptionsSlice$1.updatePolarOptions = polarOptionsSlice$1.polarOptionsReducer = void 0;
+var _toolkit = require$$0;
+var polarOptionsSlice = (0, _toolkit.createSlice)({
+  name: 'polarOptions',
+  initialState: null,
+  reducers: {
+    updatePolarOptions: (_state, action) => {
+      return action.payload;
+    }
+  }
+});
+var {
+  updatePolarOptions
+} = polarOptionsSlice.actions;
+polarOptionsSlice$1.updatePolarOptions = updatePolarOptions;
+polarOptionsSlice$1.polarOptionsReducer = polarOptionsSlice.reducer;
+
+export { polarOptionsSlice$1 as default };

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

@@ -0,0 +1,23 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as reduxDevtoolsJsonStringifyReplacer$1 } from '../../../../_virtual/reduxDevtoolsJsonStringifyReplacer.js';
+
+Object.defineProperty(reduxDevtoolsJsonStringifyReplacer$1, "__esModule", {
+  value: true
+});
+reduxDevtoolsJsonStringifyReplacer$1.reduxDevtoolsJsonStringifyReplacer = reduxDevtoolsJsonStringifyReplacer;
+function reduxDevtoolsJsonStringifyReplacer(_key, value) {
+  if (value instanceof HTMLElement) {
+    return "HTMLElement <".concat(value.tagName, " class=\"").concat(value.className, "\">");
+  }
+  if (value === window) {
+    return 'global.window';
+  }
+  return value;
+}
+
+export { reduxDevtoolsJsonStringifyReplacer$1 as default };

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

@@ -0,0 +1,69 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as referenceElementsSlice$1 } from '../../../../_virtual/referenceElementsSlice.js';
+import require$$0 from '../../../../_virtual/redux-toolkit.modern.js';
+
+Object.defineProperty(referenceElementsSlice$1, "__esModule", {
+  value: true
+});
+referenceElementsSlice$1.removeLine = referenceElementsSlice$1.removeDot = referenceElementsSlice$1.removeArea = referenceElementsSlice$1.referenceElementsSlice = referenceElementsSlice$1.referenceElementsReducer = referenceElementsSlice$1.addLine = referenceElementsSlice$1.addDot = referenceElementsSlice$1.addArea = void 0;
+var _toolkit = require$$0;
+var initialState = {
+  dots: [],
+  areas: [],
+  lines: []
+};
+var referenceElementsSlice = referenceElementsSlice$1.referenceElementsSlice = (0, _toolkit.createSlice)({
+  name: 'referenceElements',
+  initialState,
+  reducers: {
+    addDot: (state, action) => {
+      state.dots.push(action.payload);
+    },
+    removeDot: (state, action) => {
+      var index = (0, _toolkit.current)(state).dots.findIndex(dot => dot === action.payload);
+      if (index !== -1) {
+        state.dots.splice(index, 1);
+      }
+    },
+    addArea: (state, action) => {
+      state.areas.push(action.payload);
+    },
+    removeArea: (state, action) => {
+      var index = (0, _toolkit.current)(state).areas.findIndex(area => area === action.payload);
+      if (index !== -1) {
+        state.areas.splice(index, 1);
+      }
+    },
+    addLine: (state, action) => {
+      state.lines.push(action.payload);
+    },
+    removeLine: (state, action) => {
+      var index = (0, _toolkit.current)(state).lines.findIndex(line => line === action.payload);
+      if (index !== -1) {
+        state.lines.splice(index, 1);
+      }
+    }
+  }
+});
+var {
+  addDot,
+  removeDot,
+  addArea,
+  removeArea,
+  addLine,
+  removeLine
+} = referenceElementsSlice.actions;
+referenceElementsSlice$1.removeLine = removeLine;
+referenceElementsSlice$1.addLine = addLine;
+referenceElementsSlice$1.removeArea = removeArea;
+referenceElementsSlice$1.addArea = addArea;
+referenceElementsSlice$1.removeDot = removeDot;
+referenceElementsSlice$1.addDot = addDot;
+referenceElementsSlice$1.referenceElementsReducer = referenceElementsSlice.reducer;
+
+export { referenceElementsSlice$1 as default };

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

@@ -0,0 +1,55 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as rootPropsSlice$1 } from '../../../../_virtual/rootPropsSlice.js';
+import require$$0 from '../../../../_virtual/redux-toolkit.modern.js';
+
+Object.defineProperty(rootPropsSlice$1, "__esModule", {
+  value: true
+});
+rootPropsSlice$1.updateOptions = rootPropsSlice$1.rootPropsReducer = rootPropsSlice$1.initialState = void 0;
+var _toolkit = require$$0;
+/**
+ * These are chart options that users can choose - which means they can also
+ * choose to change them which should trigger a re-render.
+ */
+
+var initialState = rootPropsSlice$1.initialState = {
+  accessibilityLayer: true,
+  barCategoryGap: '10%',
+  barGap: 4,
+  barSize: undefined,
+  className: undefined,
+  maxBarSize: undefined,
+  stackOffset: 'none',
+  syncId: undefined,
+  syncMethod: 'index'
+};
+var rootPropsSlice = (0, _toolkit.createSlice)({
+  name: 'rootProps',
+  initialState,
+  reducers: {
+    updateOptions: (state, action) => {
+      var _action$payload$barGa;
+      state.accessibilityLayer = action.payload.accessibilityLayer;
+      state.barCategoryGap = action.payload.barCategoryGap;
+      state.barGap = (_action$payload$barGa = action.payload.barGap) !== null && _action$payload$barGa !== void 0 ? _action$payload$barGa : initialState.barGap;
+      state.barSize = action.payload.barSize;
+      state.maxBarSize = action.payload.maxBarSize;
+      state.stackOffset = action.payload.stackOffset;
+      state.syncId = action.payload.syncId;
+      state.syncMethod = action.payload.syncMethod;
+      state.className = action.payload.className;
+    }
+  }
+});
+rootPropsSlice$1.rootPropsReducer = rootPropsSlice.reducer;
+var {
+  updateOptions
+} = rootPropsSlice.actions;
+rootPropsSlice$1.updateOptions = updateOptions;
+
+export { rootPropsSlice$1 as default };