umwd-components 0.1.756 → 0.1.758

package/dist/esm/node_modules/recharts/lib/chart/BarChart.js

@@ -0,0 +1,35 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as BarChart } from '../../../../_virtual/BarChart.js';
+import require$$0 from 'react';
+import '../state/optionsSlice.js';
+import './CartesianChart.js';
+import { __exports as CartesianChart } from '../../../../_virtual/CartesianChart.js';
+import { __exports as optionsSlice } from '../../../../_virtual/optionsSlice.js';
+
+Object.defineProperty(BarChart, "__esModule", {
+  value: true
+});
+BarChart.BarChart = void 0;
+var _react = _interopRequireWildcard(require$$0);
+var React = _react;
+var _optionsSlice = optionsSlice;
+var _CartesianChart = CartesianChart;
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+var allowedTooltipTypes = ['axis', 'item'];
+BarChart.BarChart = /*#__PURE__*/(0, _react.forwardRef)((props, ref) => {
+  return /*#__PURE__*/React.createElement(_CartesianChart.CartesianChart, {
+    chartName: "BarChart",
+    defaultTooltipEventType: "axis",
+    validateTooltipEventTypes: allowedTooltipTypes,
+    tooltipPayloadSearcher: _optionsSlice.arrayTooltipSearcher,
+    categoricalChartProps: props,
+    ref: ref
+  });
+});
+
+export { BarChart as default };

package/dist/esm/node_modules/recharts/lib/chart/CartesianChart.js

@@ -0,0 +1,119 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as CartesianChart } from '../../../../_virtual/CartesianChart.js';
+import require$$0 from 'react';
+import '../state/RechartsStoreProvider.js';
+import '../context/chartDataContext.js';
+import '../state/ReportMainChartProps.js';
+import '../state/ReportChartProps.js';
+import './CategoricalChart.js';
+import '../util/resolveDefaultProps.js';
+import '../util/isWellBehavedNumber.js';
+import { __exports as resolveDefaultProps } from '../../../../_virtual/resolveDefaultProps.js';
+import { __exports as isWellBehavedNumber } from '../../../../_virtual/isWellBehavedNumber.js';
+import { __exports as RechartsStoreProvider } from '../../../../_virtual/RechartsStoreProvider.js';
+import { __exports as chartDataContext } from '../../../../_virtual/chartDataContext.js';
+import { __exports as ReportMainChartProps } from '../../../../_virtual/ReportMainChartProps.js';
+import { __exports as ReportChartProps } from '../../../../_virtual/ReportChartProps.js';
+import { __exports as CategoricalChart } from '../../../../_virtual/CategoricalChart.js';
+
+Object.defineProperty(CartesianChart, "__esModule", {
+  value: true
+});
+CartesianChart.CartesianChart = void 0;
+var _react = _interopRequireWildcard(require$$0);
+var React = _react;
+var _RechartsStoreProvider = RechartsStoreProvider;
+var _chartDataContext = chartDataContext;
+var _ReportMainChartProps = ReportMainChartProps;
+var _ReportChartProps = ReportChartProps;
+var _CategoricalChart = CategoricalChart;
+var _resolveDefaultProps = resolveDefaultProps;
+var _isWellBehavedNumber = isWellBehavedNumber;
+var _excluded = ["width", "height"];
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; }
+function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
+var defaultMargin = {
+  top: 5,
+  right: 5,
+  bottom: 5,
+  left: 5
+};
+var defaultProps = {
+  accessibilityLayer: true,
+  layout: 'horizontal',
+  stackOffset: 'none',
+  barCategoryGap: '10%',
+  barGap: 4,
+  margin: defaultMargin,
+  reverseStackOrder: false,
+  syncMethod: 'index'
+};
+
+/**
+ * These are one-time, immutable options that decide the chart's behavior.
+ * Users who wish to call CartesianChart may decide to pass these options explicitly,
+ * but usually we would expect that they use one of the convenience components like BarChart, LineChart, etc.
+ */
+
+CartesianChart.CartesianChart = /*#__PURE__*/(0, _react.forwardRef)(function CartesianChart(props, ref) {
+  var _categoricalChartProp;
+  var rootChartProps = (0, _resolveDefaultProps.resolveDefaultProps)(props.categoricalChartProps, defaultProps);
+  var {
+      width,
+      height
+    } = rootChartProps,
+    otherCategoricalProps = _objectWithoutProperties(rootChartProps, _excluded);
+  if (!(0, _isWellBehavedNumber.isPositiveNumber)(width) || !(0, _isWellBehavedNumber.isPositiveNumber)(height)) {
+    return null;
+  }
+  var {
+    chartName,
+    defaultTooltipEventType,
+    validateTooltipEventTypes,
+    tooltipPayloadSearcher,
+    categoricalChartProps
+  } = props;
+  var options = {
+    chartName,
+    defaultTooltipEventType,
+    validateTooltipEventTypes,
+    tooltipPayloadSearcher,
+    eventEmitter: undefined
+  };
+  return /*#__PURE__*/React.createElement(_RechartsStoreProvider.RechartsStoreProvider, {
+    preloadedState: {
+      options
+    },
+    reduxStoreName: (_categoricalChartProp = categoricalChartProps.id) !== null && _categoricalChartProp !== void 0 ? _categoricalChartProp : chartName
+  }, /*#__PURE__*/React.createElement(_chartDataContext.ChartDataContextProvider, {
+    chartData: categoricalChartProps.data
+  }), /*#__PURE__*/React.createElement(_ReportMainChartProps.ReportMainChartProps, {
+    width: width,
+    height: height,
+    layout: rootChartProps.layout,
+    margin: rootChartProps.margin
+  }), /*#__PURE__*/React.createElement(_ReportChartProps.ReportChartProps, {
+    accessibilityLayer: rootChartProps.accessibilityLayer,
+    barCategoryGap: rootChartProps.barCategoryGap,
+    maxBarSize: rootChartProps.maxBarSize,
+    stackOffset: rootChartProps.stackOffset,
+    barGap: rootChartProps.barGap,
+    barSize: rootChartProps.barSize,
+    syncId: rootChartProps.syncId,
+    syncMethod: rootChartProps.syncMethod,
+    className: rootChartProps.className
+  }), /*#__PURE__*/React.createElement(_CategoricalChart.CategoricalChart, _extends({}, otherCategoricalProps, {
+    width: width,
+    height: height,
+    ref: ref
+  })));
+});
+
+export { CartesianChart as default };

package/dist/esm/node_modules/recharts/lib/chart/CategoricalChart.js

@@ -0,0 +1,78 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as CategoricalChart } from '../../../../_virtual/CategoricalChart.js';
+import require$$0 from 'react';
+import '../util/ReactUtils.js';
+import '../container/RootSurface.js';
+import './RechartsWrapper.js';
+import '../container/ClipPathProvider.js';
+import { __exports as ReactUtils } from '../../../../_virtual/ReactUtils.js';
+import { __exports as RootSurface } from '../../../../_virtual/RootSurface.js';
+import { __exports as RechartsWrapper } from '../../../../_virtual/RechartsWrapper.js';
+import { __exports as ClipPathProvider } from '../../../../_virtual/ClipPathProvider.js';
+
+Object.defineProperty(CategoricalChart, "__esModule", {
+  value: true
+});
+CategoricalChart.CategoricalChart = void 0;
+var _react = _interopRequireWildcard(require$$0);
+var React = _react;
+var _ReactUtils = ReactUtils;
+var _RootSurface = RootSurface;
+var _RechartsWrapper = RechartsWrapper;
+var _ClipPathProvider = ClipPathProvider;
+var _excluded = ["children", "className", "width", "height", "style", "compact", "title", "desc"];
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; }
+function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
+CategoricalChart.CategoricalChart = /*#__PURE__*/(0, _react.forwardRef)((props, ref) => {
+  var {
+      children,
+      className,
+      width,
+      height,
+      style,
+      compact,
+      title,
+      desc
+    } = props,
+    others = _objectWithoutProperties(props, _excluded);
+  var attrs = (0, _ReactUtils.filterProps)(others, false);
+
+  // The "compact" mode is used as the panorama within Brush
+  if (compact) {
+    return /*#__PURE__*/React.createElement(_RootSurface.RootSurface, {
+      otherAttributes: attrs,
+      title: title,
+      desc: desc
+    }, children);
+  }
+  return /*#__PURE__*/React.createElement(_RechartsWrapper.RechartsWrapper, {
+    className: className,
+    style: style,
+    width: width,
+    height: height,
+    onClick: props.onClick,
+    onMouseLeave: props.onMouseLeave,
+    onMouseEnter: props.onMouseEnter,
+    onMouseMove: props.onMouseMove,
+    onMouseDown: props.onMouseDown,
+    onMouseUp: props.onMouseUp,
+    onContextMenu: props.onContextMenu,
+    onDoubleClick: props.onDoubleClick,
+    onTouchStart: props.onTouchStart,
+    onTouchMove: props.onTouchMove,
+    onTouchEnd: props.onTouchEnd
+  }, /*#__PURE__*/React.createElement(_RootSurface.RootSurface, {
+    otherAttributes: attrs,
+    title: title,
+    desc: desc,
+    ref: ref
+  }, /*#__PURE__*/React.createElement(_ClipPathProvider.ClipPathProvider, null, children)));
+});
+
+export { CategoricalChart as default };

package/dist/esm/node_modules/recharts/lib/chart/RechartsWrapper.js

@@ -0,0 +1,202 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as RechartsWrapper } from '../../../../_virtual/RechartsWrapper.js';
+import require$$0 from 'react';
+import { c as clsxExports } from '../../../clsx/dist/clsx.js';
+import '../state/tooltipSlice.js';
+import '../state/hooks.js';
+import '../state/mouseEventsMiddleware.js';
+import '../synchronisation/useChartSynchronisation.js';
+import '../state/keyboardEventsMiddleware.js';
+import '../util/useReportScale.js';
+import '../state/externalEventsMiddleware.js';
+import '../state/touchEventsMiddleware.js';
+import '../context/tooltipPortalContext.js';
+import '../context/legendPortalContext.js';
+import { __exports as hooks } from '../../../../_virtual/hooks.js';
+import { __exports as useChartSynchronisation } from '../../../../_virtual/useChartSynchronisation.js';
+import { __exports as useReportScale } from '../../../../_virtual/useReportScale.js';
+import { __exports as mouseEventsMiddleware } from '../../../../_virtual/mouseEventsMiddleware.js';
+import { __exports as externalEventsMiddleware } from '../../../../_virtual/externalEventsMiddleware.js';
+import { __exports as tooltipSlice } from '../../../../_virtual/tooltipSlice.js';
+import { __exports as keyboardEventsMiddleware } from '../../../../_virtual/keyboardEventsMiddleware.js';
+import { __exports as touchEventsMiddleware } from '../../../../_virtual/touchEventsMiddleware.js';
+import { __exports as tooltipPortalContext } from '../../../../_virtual/tooltipPortalContext.js';
+import { __exports as legendPortalContext } from '../../../../_virtual/legendPortalContext.js';
+
+Object.defineProperty(RechartsWrapper, "__esModule", {
+  value: true
+});
+RechartsWrapper.RechartsWrapper = void 0;
+var _react = _interopRequireWildcard(require$$0);
+var React = _react;
+var _clsx = clsxExports;
+var _tooltipSlice = tooltipSlice;
+var _hooks = hooks;
+var _mouseEventsMiddleware = mouseEventsMiddleware;
+var _useChartSynchronisation = useChartSynchronisation;
+var _keyboardEventsMiddleware = keyboardEventsMiddleware;
+var _useReportScale = useReportScale;
+var _externalEventsMiddleware = externalEventsMiddleware;
+var _touchEventsMiddleware = touchEventsMiddleware;
+var _tooltipPortalContext = tooltipPortalContext;
+var _legendPortalContext = legendPortalContext;
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+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); }
+RechartsWrapper.RechartsWrapper = /*#__PURE__*/(0, _react.forwardRef)((_ref, ref) => {
+  var {
+    children,
+    className,
+    height,
+    onClick,
+    onContextMenu,
+    onDoubleClick,
+    onMouseDown,
+    onMouseEnter,
+    onMouseLeave,
+    onMouseMove,
+    onMouseUp,
+    onTouchEnd,
+    onTouchMove,
+    onTouchStart,
+    style,
+    width
+  } = _ref;
+  var dispatch = (0, _hooks.useAppDispatch)();
+  var [tooltipPortal, setTooltipPortal] = (0, _react.useState)(null);
+  var [legendPortal, setLegendPortal] = (0, _react.useState)(null);
+  (0, _useChartSynchronisation.useSynchronisedEventsFromOtherCharts)();
+  var setScaleRef = (0, _useReportScale.useReportScale)();
+  var innerRef = (0, _react.useCallback)(node => {
+    setScaleRef(node);
+    if (typeof ref === 'function') {
+      ref(node);
+    }
+    setTooltipPortal(node);
+    setLegendPortal(node);
+  }, [setScaleRef, ref, setTooltipPortal, setLegendPortal]);
+  var myOnClick = (0, _react.useCallback)(e => {
+    dispatch((0, _mouseEventsMiddleware.mouseClickAction)(e));
+    dispatch((0, _externalEventsMiddleware.externalEventAction)({
+      handler: onClick,
+      reactEvent: e
+    }));
+  }, [dispatch, onClick]);
+  var myOnMouseEnter = (0, _react.useCallback)(e => {
+    dispatch((0, _mouseEventsMiddleware.mouseMoveAction)(e));
+    dispatch((0, _externalEventsMiddleware.externalEventAction)({
+      handler: onMouseEnter,
+      reactEvent: e
+    }));
+  }, [dispatch, onMouseEnter]);
+  var myOnMouseLeave = (0, _react.useCallback)(e => {
+    dispatch((0, _tooltipSlice.mouseLeaveChart)());
+    dispatch((0, _externalEventsMiddleware.externalEventAction)({
+      handler: onMouseLeave,
+      reactEvent: e
+    }));
+  }, [dispatch, onMouseLeave]);
+  var myOnMouseMove = (0, _react.useCallback)(e => {
+    dispatch((0, _mouseEventsMiddleware.mouseMoveAction)(e));
+    dispatch((0, _externalEventsMiddleware.externalEventAction)({
+      handler: onMouseMove,
+      reactEvent: e
+    }));
+  }, [dispatch, onMouseMove]);
+  var onFocus = (0, _react.useCallback)(() => {
+    dispatch((0, _keyboardEventsMiddleware.focusAction)());
+  }, [dispatch]);
+  var onKeyDown = (0, _react.useCallback)(e => {
+    dispatch((0, _keyboardEventsMiddleware.keyDownAction)(e.key));
+  }, [dispatch]);
+  var myOnContextMenu = (0, _react.useCallback)(e => {
+    dispatch((0, _externalEventsMiddleware.externalEventAction)({
+      handler: onContextMenu,
+      reactEvent: e
+    }));
+  }, [dispatch, onContextMenu]);
+  var myOnDoubleClick = (0, _react.useCallback)(e => {
+    dispatch((0, _externalEventsMiddleware.externalEventAction)({
+      handler: onDoubleClick,
+      reactEvent: e
+    }));
+  }, [dispatch, onDoubleClick]);
+  var myOnMouseDown = (0, _react.useCallback)(e => {
+    dispatch((0, _externalEventsMiddleware.externalEventAction)({
+      handler: onMouseDown,
+      reactEvent: e
+    }));
+  }, [dispatch, onMouseDown]);
+  var myOnMouseUp = (0, _react.useCallback)(e => {
+    dispatch((0, _externalEventsMiddleware.externalEventAction)({
+      handler: onMouseUp,
+      reactEvent: e
+    }));
+  }, [dispatch, onMouseUp]);
+  var myOnTouchStart = (0, _react.useCallback)(e => {
+    dispatch((0, _externalEventsMiddleware.externalEventAction)({
+      handler: onTouchStart,
+      reactEvent: e
+    }));
+  }, [dispatch, onTouchStart]);
+
+  /*
+   * onTouchMove is special because it behaves different from mouse events.
+   * Mouse events have enter + leave combo that notify us when the mouse is over
+   * a certain element. Touch events don't have that; touch only gives us
+   * start (finger down), end (finger up) and move (finger moving).
+   * So we need to figure out which element the user is touching
+   * ourselves. Fortunately, there's a convenient method for that:
+   * https://developer.mozilla.org/en-US/docs/Web/API/Document/elementFromPoint
+   */
+  var myOnTouchMove = (0, _react.useCallback)(e => {
+    dispatch((0, _touchEventsMiddleware.touchEventAction)(e));
+    dispatch((0, _externalEventsMiddleware.externalEventAction)({
+      handler: onTouchMove,
+      reactEvent: e
+    }));
+  }, [dispatch, onTouchMove]);
+  var myOnTouchEnd = (0, _react.useCallback)(e => {
+    dispatch((0, _externalEventsMiddleware.externalEventAction)({
+      handler: onTouchEnd,
+      reactEvent: e
+    }));
+  }, [dispatch, onTouchEnd]);
+  return /*#__PURE__*/React.createElement(_tooltipPortalContext.TooltipPortalContext.Provider, {
+    value: tooltipPortal
+  }, /*#__PURE__*/React.createElement(_legendPortalContext.LegendPortalContext.Provider, {
+    value: legendPortal
+  }, /*#__PURE__*/React.createElement("div", {
+    className: (0, _clsx.clsx)('recharts-wrapper', className),
+    style: _objectSpread({
+      position: 'relative',
+      cursor: 'default',
+      width,
+      height
+    }, style),
+    onClick: myOnClick,
+    onContextMenu: myOnContextMenu,
+    onDoubleClick: myOnDoubleClick,
+    onFocus: onFocus,
+    onKeyDown: onKeyDown,
+    onMouseDown: myOnMouseDown,
+    onMouseEnter: myOnMouseEnter,
+    onMouseLeave: myOnMouseLeave,
+    onMouseMove: myOnMouseMove,
+    onMouseUp: myOnMouseUp,
+    onTouchEnd: myOnTouchEnd,
+    onTouchMove: myOnTouchMove,
+    onTouchStart: myOnTouchStart,
+    ref: innerRef
+  }, children)));
+});
+
+export { RechartsWrapper as default };

package/dist/esm/node_modules/recharts/lib/component/Cell.js

@@ -0,0 +1,21 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as Cell$1 } from '../../../../_virtual/Cell.js';
+
+Object.defineProperty(Cell$1, "__esModule", {
+  value: true
+});
+Cell$1.Cell = void 0;
+/**
+ * @fileOverview Cross
+ */
+
+var Cell = _props => null;
+Cell$1.Cell = Cell;
+Cell.displayName = 'Cell';
+
+export { Cell$1 as default };

package/dist/esm/node_modules/recharts/lib/component/Cursor.js

@@ -0,0 +1,152 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as Cursor$1 } from '../../../../_virtual/Cursor.js';
+import require$$0 from 'react';
+import { c as clsxExports } from '../../../clsx/dist/clsx.js';
+import '../shape/Curve.js';
+import '../shape/Cross.js';
+import '../util/cursor/getCursorRectangle.js';
+import '../shape/Rectangle.js';
+import '../util/cursor/getRadialCursorPoints.js';
+import '../shape/Sector.js';
+import '../util/cursor/getCursorPoints.js';
+import '../util/ReactUtils.js';
+import '../context/chartLayoutContext.js';
+import '../context/useTooltipAxis.js';
+import '../state/selectors/selectors.js';
+import { __exports as getCursorRectangle } from '../../../../_virtual/getCursorRectangle.js';
+import { __exports as getRadialCursorPoints } from '../../../../_virtual/getRadialCursorPoints.js';
+import { __exports as getCursorPoints } from '../../../../_virtual/getCursorPoints.js';
+import { __exports as ReactUtils } from '../../../../_virtual/ReactUtils.js';
+import { __exports as useTooltipAxis } from '../../../../_virtual/useTooltipAxis.js';
+import { __exports as chartLayoutContext } from '../../../../_virtual/chartLayoutContext.js';
+import { __exports as selectors } from '../../../../_virtual/selectors.js';
+import { __exports as Cross } from '../../../../_virtual/Cross.js';
+import { __exports as Rectangle } from '../../../../_virtual/Rectangle.js';
+import { __exports as Sector } from '../../../../_virtual/Sector.js';
+import { __exports as Curve } from '../../../../_virtual/Curve.js';
+
+Object.defineProperty(Cursor$1, "__esModule", {
+  value: true
+});
+Cursor$1.Cursor = Cursor;
+Cursor$1.CursorInternal = CursorInternal;
+var _react = _interopRequireWildcard(require$$0);
+var React = _react;
+var _clsx = clsxExports;
+var _Curve = Curve;
+var _Cross = Cross;
+var _getCursorRectangle = getCursorRectangle;
+var _Rectangle = Rectangle;
+var _getRadialCursorPoints = getRadialCursorPoints;
+var _Sector = Sector;
+var _getCursorPoints = getCursorPoints;
+var _ReactUtils = ReactUtils;
+var _chartLayoutContext = chartLayoutContext;
+var _useTooltipAxis = useTooltipAxis;
+var _selectors = selectors;
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+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); }
+/**
+ * If set false, no cursor will be drawn when tooltip is active.
+ * If set an object, the option is the configuration of cursor.
+ * If set a React element, the option is the custom react element of drawing cursor
+ */
+
+function CursorInternal(props) {
+  var {
+    coordinate,
+    payload,
+    index,
+    offset,
+    tooltipAxisBandSize,
+    layout,
+    cursor,
+    tooltipEventType,
+    chartName
+  } = props;
+
+  // The cursor is a part of the Tooltip, and it should be shown (by default) when the Tooltip is active.
+  var activeCoordinate = coordinate;
+  var activePayload = payload;
+  var activeTooltipIndex = index;
+  if (!cursor || !activeCoordinate || chartName !== 'ScatterChart' && tooltipEventType !== 'axis') {
+    return null;
+  }
+  var restProps, cursorComp;
+  if (chartName === 'ScatterChart') {
+    restProps = activeCoordinate;
+    cursorComp = _Cross.Cross;
+  } else if (chartName === 'BarChart') {
+    restProps = (0, _getCursorRectangle.getCursorRectangle)(layout, activeCoordinate, offset, tooltipAxisBandSize);
+    cursorComp = _Rectangle.Rectangle;
+  } else if (layout === 'radial') {
+    // @ts-expect-error TODO the state is marked as containing Coordinate but actually in polar charts it contains PolarCoordinate, we should keep the polar state separate
+    var {
+      cx,
+      cy,
+      radius,
+      startAngle,
+      endAngle
+    } = (0, _getRadialCursorPoints.getRadialCursorPoints)(activeCoordinate);
+    restProps = {
+      cx,
+      cy,
+      startAngle,
+      endAngle,
+      innerRadius: radius,
+      outerRadius: radius
+    };
+    cursorComp = _Sector.Sector;
+  } else {
+    restProps = {
+      points: (0, _getCursorPoints.getCursorPoints)(layout, activeCoordinate, offset)
+    };
+    cursorComp = _Curve.Curve;
+  }
+  var extraClassName = typeof cursor === 'object' && 'className' in cursor ? cursor.className : undefined;
+  var cursorProps = _objectSpread(_objectSpread(_objectSpread(_objectSpread({
+    stroke: '#ccc',
+    pointerEvents: 'none'
+  }, offset), restProps), (0, _ReactUtils.filterProps)(cursor, false)), {}, {
+    payload: activePayload,
+    payloadIndex: activeTooltipIndex,
+    className: (0, _clsx.clsx)('recharts-tooltip-cursor', extraClassName)
+  });
+  return /*#__PURE__*/(0, _react.isValidElement)(cursor) ? /*#__PURE__*/(0, _react.cloneElement)(cursor, cursorProps) : /*#__PURE__*/(0, _react.createElement)(cursorComp, cursorProps);
+}
+
+/*
+ * Cursor is the background, or a highlight,
+ * that shows when user mouses over or activates
+ * an area.
+ *
+ * It usually shows together with a tooltip
+ * to emphasise which part of the chart does the tooltip refer to.
+ */
+function Cursor(props) {
+  var tooltipAxisBandSize = (0, _useTooltipAxis.useTooltipAxisBandSize)();
+  var offset = (0, _chartLayoutContext.useOffsetInternal)();
+  var layout = (0, _chartLayoutContext.useChartLayout)();
+  var chartName = (0, _selectors.useChartName)();
+  return /*#__PURE__*/React.createElement(CursorInternal, _extends({}, props, {
+    coordinate: props.coordinate,
+    index: props.index,
+    payload: props.payload,
+    offset: offset,
+    layout: layout,
+    tooltipAxisBandSize: tooltipAxisBandSize,
+    chartName: chartName
+  }));
+}
+
+export { Cursor$1 as default };