umwd-components 0.1.756 → 0.1.758

package/dist/esm/node_modules/recharts/lib/shape/Sector.js

@@ -0,0 +1,242 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as Sector$1 } from '../../../../_virtual/Sector.js';
+import require$$0 from 'react';
+import { c as clsxExports } from '../../../clsx/dist/clsx.js';
+import '../util/ReactUtils.js';
+import '../util/PolarUtils.js';
+import '../util/DataUtils.js';
+import '../util/resolveDefaultProps.js';
+import { __exports as resolveDefaultProps } from '../../../../_virtual/resolveDefaultProps.js';
+import { __exports as DataUtils } from '../../../../_virtual/DataUtils.js';
+import { __exports as ReactUtils } from '../../../../_virtual/ReactUtils.js';
+import { __exports as PolarUtils } from '../../../../_virtual/PolarUtils.js';
+
+Object.defineProperty(Sector$1, "__esModule", {
+  value: true
+});
+Sector$1.Sector = void 0;
+var React = _interopRequireWildcard(require$$0);
+var _clsx = clsxExports;
+var _ReactUtils = ReactUtils;
+var _PolarUtils = PolarUtils;
+var _DataUtils = DataUtils;
+var _resolveDefaultProps = resolveDefaultProps;
+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); }
+var getDeltaAngle = (startAngle, endAngle) => {
+  var sign = (0, _DataUtils.mathSign)(endAngle - startAngle);
+  var deltaAngle = Math.min(Math.abs(endAngle - startAngle), 359.999);
+  return sign * deltaAngle;
+};
+var getTangentCircle = _ref => {
+  var {
+    cx,
+    cy,
+    radius,
+    angle,
+    sign,
+    isExternal,
+    cornerRadius,
+    cornerIsExternal
+  } = _ref;
+  var centerRadius = cornerRadius * (isExternal ? 1 : -1) + radius;
+  var theta = Math.asin(cornerRadius / centerRadius) / _PolarUtils.RADIAN;
+  var centerAngle = cornerIsExternal ? angle : angle + sign * theta;
+  var center = (0, _PolarUtils.polarToCartesian)(cx, cy, centerRadius, centerAngle);
+  // The coordinate of point which is tangent to the circle
+  var circleTangency = (0, _PolarUtils.polarToCartesian)(cx, cy, radius, centerAngle);
+  // The coordinate of point which is tangent to the radius line
+  var lineTangencyAngle = cornerIsExternal ? angle - sign * theta : angle;
+  var lineTangency = (0, _PolarUtils.polarToCartesian)(cx, cy, centerRadius * Math.cos(theta * _PolarUtils.RADIAN), lineTangencyAngle);
+  return {
+    center,
+    circleTangency,
+    lineTangency,
+    theta
+  };
+};
+var getSectorPath = _ref2 => {
+  var {
+    cx,
+    cy,
+    innerRadius,
+    outerRadius,
+    startAngle,
+    endAngle
+  } = _ref2;
+  var angle = getDeltaAngle(startAngle, endAngle);
+
+  // When the angle of sector equals to 360, star point and end point coincide
+  var tempEndAngle = startAngle + angle;
+  var outerStartPoint = (0, _PolarUtils.polarToCartesian)(cx, cy, outerRadius, startAngle);
+  var outerEndPoint = (0, _PolarUtils.polarToCartesian)(cx, cy, outerRadius, tempEndAngle);
+  var path = "M ".concat(outerStartPoint.x, ",").concat(outerStartPoint.y, "\n    A ").concat(outerRadius, ",").concat(outerRadius, ",0,\n    ").concat(+(Math.abs(angle) > 180), ",").concat(+(startAngle > tempEndAngle), ",\n    ").concat(outerEndPoint.x, ",").concat(outerEndPoint.y, "\n  ");
+  if (innerRadius > 0) {
+    var innerStartPoint = (0, _PolarUtils.polarToCartesian)(cx, cy, innerRadius, startAngle);
+    var innerEndPoint = (0, _PolarUtils.polarToCartesian)(cx, cy, innerRadius, tempEndAngle);
+    path += "L ".concat(innerEndPoint.x, ",").concat(innerEndPoint.y, "\n            A ").concat(innerRadius, ",").concat(innerRadius, ",0,\n            ").concat(+(Math.abs(angle) > 180), ",").concat(+(startAngle <= tempEndAngle), ",\n            ").concat(innerStartPoint.x, ",").concat(innerStartPoint.y, " Z");
+  } else {
+    path += "L ".concat(cx, ",").concat(cy, " Z");
+  }
+  return path;
+};
+var getSectorWithCorner = _ref3 => {
+  var {
+    cx,
+    cy,
+    innerRadius,
+    outerRadius,
+    cornerRadius,
+    forceCornerRadius,
+    cornerIsExternal,
+    startAngle,
+    endAngle
+  } = _ref3;
+  var sign = (0, _DataUtils.mathSign)(endAngle - startAngle);
+  var {
+    circleTangency: soct,
+    lineTangency: solt,
+    theta: sot
+  } = getTangentCircle({
+    cx,
+    cy,
+    radius: outerRadius,
+    angle: startAngle,
+    sign,
+    cornerRadius,
+    cornerIsExternal
+  });
+  var {
+    circleTangency: eoct,
+    lineTangency: eolt,
+    theta: eot
+  } = getTangentCircle({
+    cx,
+    cy,
+    radius: outerRadius,
+    angle: endAngle,
+    sign: -sign,
+    cornerRadius,
+    cornerIsExternal
+  });
+  var outerArcAngle = cornerIsExternal ? Math.abs(startAngle - endAngle) : Math.abs(startAngle - endAngle) - sot - eot;
+  if (outerArcAngle < 0) {
+    if (forceCornerRadius) {
+      return "M ".concat(solt.x, ",").concat(solt.y, "\n        a").concat(cornerRadius, ",").concat(cornerRadius, ",0,0,1,").concat(cornerRadius * 2, ",0\n        a").concat(cornerRadius, ",").concat(cornerRadius, ",0,0,1,").concat(-cornerRadius * 2, ",0\n      ");
+    }
+    return getSectorPath({
+      cx,
+      cy,
+      innerRadius,
+      outerRadius,
+      startAngle,
+      endAngle
+    });
+  }
+  var path = "M ".concat(solt.x, ",").concat(solt.y, "\n    A").concat(cornerRadius, ",").concat(cornerRadius, ",0,0,").concat(+(sign < 0), ",").concat(soct.x, ",").concat(soct.y, "\n    A").concat(outerRadius, ",").concat(outerRadius, ",0,").concat(+(outerArcAngle > 180), ",").concat(+(sign < 0), ",").concat(eoct.x, ",").concat(eoct.y, "\n    A").concat(cornerRadius, ",").concat(cornerRadius, ",0,0,").concat(+(sign < 0), ",").concat(eolt.x, ",").concat(eolt.y, "\n  ");
+  if (innerRadius > 0) {
+    var {
+      circleTangency: sict,
+      lineTangency: silt,
+      theta: sit
+    } = getTangentCircle({
+      cx,
+      cy,
+      radius: innerRadius,
+      angle: startAngle,
+      sign,
+      isExternal: true,
+      cornerRadius,
+      cornerIsExternal
+    });
+    var {
+      circleTangency: eict,
+      lineTangency: eilt,
+      theta: eit
+    } = getTangentCircle({
+      cx,
+      cy,
+      radius: innerRadius,
+      angle: endAngle,
+      sign: -sign,
+      isExternal: true,
+      cornerRadius,
+      cornerIsExternal
+    });
+    var innerArcAngle = cornerIsExternal ? Math.abs(startAngle - endAngle) : Math.abs(startAngle - endAngle) - sit - eit;
+    if (innerArcAngle < 0 && cornerRadius === 0) {
+      return "".concat(path, "L").concat(cx, ",").concat(cy, "Z");
+    }
+    path += "L".concat(eilt.x, ",").concat(eilt.y, "\n      A").concat(cornerRadius, ",").concat(cornerRadius, ",0,0,").concat(+(sign < 0), ",").concat(eict.x, ",").concat(eict.y, "\n      A").concat(innerRadius, ",").concat(innerRadius, ",0,").concat(+(innerArcAngle > 180), ",").concat(+(sign > 0), ",").concat(sict.x, ",").concat(sict.y, "\n      A").concat(cornerRadius, ",").concat(cornerRadius, ",0,0,").concat(+(sign < 0), ",").concat(silt.x, ",").concat(silt.y, "Z");
+  } else {
+    path += "L".concat(cx, ",").concat(cy, "Z");
+  }
+  return path;
+};
+var defaultProps = {
+  cx: 0,
+  cy: 0,
+  innerRadius: 0,
+  outerRadius: 0,
+  startAngle: 0,
+  endAngle: 0,
+  cornerRadius: 0,
+  forceCornerRadius: false,
+  cornerIsExternal: false
+};
+var Sector = sectorProps => {
+  var props = (0, _resolveDefaultProps.resolveDefaultProps)(sectorProps, defaultProps);
+  var {
+    cx,
+    cy,
+    innerRadius,
+    outerRadius,
+    cornerRadius,
+    forceCornerRadius,
+    cornerIsExternal,
+    startAngle,
+    endAngle,
+    className
+  } = props;
+  if (outerRadius < innerRadius || startAngle === endAngle) {
+    return null;
+  }
+  var layerClass = (0, _clsx.clsx)('recharts-sector', className);
+  var deltaRadius = outerRadius - innerRadius;
+  var cr = (0, _DataUtils.getPercentValue)(cornerRadius, deltaRadius, 0, true);
+  var path;
+  if (cr > 0 && Math.abs(startAngle - endAngle) < 360) {
+    path = getSectorWithCorner({
+      cx,
+      cy,
+      innerRadius,
+      outerRadius,
+      cornerRadius: Math.min(cr, deltaRadius / 2),
+      forceCornerRadius,
+      cornerIsExternal,
+      startAngle,
+      endAngle
+    });
+  } else {
+    path = getSectorPath({
+      cx,
+      cy,
+      innerRadius,
+      outerRadius,
+      startAngle,
+      endAngle
+    });
+  }
+  return /*#__PURE__*/React.createElement("path", _extends({}, (0, _ReactUtils.filterProps)(props, true), {
+    className: layerClass,
+    d: path
+  }));
+};
+Sector$1.Sector = Sector;
+
+export { Sector$1 as default };

package/dist/esm/node_modules/recharts/lib/shape/Symbols.js

@@ -0,0 +1,119 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as Symbols$1 } from '../../../../_virtual/Symbols.js';
+import require$$0 from 'react';
+import { d as d3Shape } from '../../../victory-vendor/lib/d3-shape.js';
+import { c as clsxExports } from '../../../clsx/dist/clsx.js';
+import '../util/ReactUtils.js';
+import '../util/DataUtils.js';
+import { __exports as ReactUtils } from '../../../../_virtual/ReactUtils.js';
+import { __exports as DataUtils } from '../../../../_virtual/DataUtils.js';
+
+Object.defineProperty(Symbols$1, "__esModule", {
+  value: true
+});
+Symbols$1.Symbols = void 0;
+var React = _interopRequireWildcard(require$$0);
+var _d3Shape = d3Shape;
+var _clsx = clsxExports;
+var _ReactUtils = ReactUtils;
+var _DataUtils = DataUtils;
+var _excluded = ["type", "size", "sizeType"];
+/**
+ * @fileOverview Curve
+ */
+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); }
+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 symbolFactories = {
+  symbolCircle: _d3Shape.symbolCircle,
+  symbolCross: _d3Shape.symbolCross,
+  symbolDiamond: _d3Shape.symbolDiamond,
+  symbolSquare: _d3Shape.symbolSquare,
+  symbolStar: _d3Shape.symbolStar,
+  symbolTriangle: _d3Shape.symbolTriangle,
+  symbolWye: _d3Shape.symbolWye
+};
+var RADIAN = Math.PI / 180;
+var getSymbolFactory = type => {
+  var name = "symbol".concat((0, _DataUtils.upperFirst)(type));
+  return symbolFactories[name] || _d3Shape.symbolCircle;
+};
+var calculateAreaSize = (size, sizeType, type) => {
+  if (sizeType === 'area') {
+    return size;
+  }
+  switch (type) {
+    case 'cross':
+      return 5 * size * size / 9;
+    case 'diamond':
+      return 0.5 * size * size / Math.sqrt(3);
+    case 'square':
+      return size * size;
+    case 'star':
+      {
+        var angle = 18 * RADIAN;
+        return 1.25 * size * size * (Math.tan(angle) - Math.tan(angle * 2) * Math.tan(angle) ** 2);
+      }
+    case 'triangle':
+      return Math.sqrt(3) * size * size / 4;
+    case 'wye':
+      return (21 - 10 * Math.sqrt(3)) * size * size / 8;
+    default:
+      return Math.PI * size * size / 4;
+  }
+};
+var registerSymbol = (key, factory) => {
+  symbolFactories["symbol".concat((0, _DataUtils.upperFirst)(key))] = factory;
+};
+var Symbols = _ref => {
+  var {
+      type = 'circle',
+      size = 64,
+      sizeType = 'area'
+    } = _ref,
+    rest = _objectWithoutProperties(_ref, _excluded);
+  var props = _objectSpread(_objectSpread({}, rest), {}, {
+    type,
+    size,
+    sizeType
+  });
+
+  /**
+   * Calculate the path of curve
+   * @return {String} path
+   */
+  var getPath = () => {
+    var symbolFactory = getSymbolFactory(type);
+    var symbol = (0, _d3Shape.symbol)().type(symbolFactory).size(calculateAreaSize(size, sizeType, type));
+    return symbol();
+  };
+  var {
+    className,
+    cx,
+    cy
+  } = props;
+  var filteredProps = (0, _ReactUtils.filterProps)(props, true);
+  if (cx === +cx && cy === +cy && size === +size) {
+    return /*#__PURE__*/React.createElement("path", _extends({}, filteredProps, {
+      className: (0, _clsx.clsx)('recharts-symbols', className),
+      transform: "translate(".concat(cx, ", ").concat(cy, ")"),
+      d: getPath()
+    }));
+  }
+  return null;
+};
+Symbols$1.Symbols = Symbols;
+Symbols.registerSymbol = registerSymbol;
+
+export { Symbols$1 as default };

package/dist/esm/node_modules/recharts/lib/shape/Trapezoid.js

@@ -0,0 +1,142 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as Trapezoid$1 } from '../../../../_virtual/Trapezoid.js';
+import require$$0 from 'react';
+import { c as clsxExports } from '../../../clsx/dist/clsx.js';
+import '../util/ReactUtils.js';
+import '../util/resolveDefaultProps.js';
+import '../animation/Animate.js';
+import { __exports as resolveDefaultProps } from '../../../../_virtual/resolveDefaultProps.js';
+import { __exports as ReactUtils } from '../../../../_virtual/ReactUtils.js';
+import { __exports as Animate } from '../../../../_virtual/Animate.js';
+
+Object.defineProperty(Trapezoid$1, "__esModule", {
+  value: true
+});
+Trapezoid$1.Trapezoid = void 0;
+var _react = _interopRequireWildcard(require$$0);
+var React = _react;
+var _clsx = clsxExports;
+var _ReactUtils = ReactUtils;
+var _resolveDefaultProps = resolveDefaultProps;
+var _Animate = Animate;
+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); } /**
+ * @fileOverview Rectangle
+ */
+var getTrapezoidPath = (x, y, upperWidth, lowerWidth, height) => {
+  var widthGap = upperWidth - lowerWidth;
+  var path;
+  path = "M ".concat(x, ",").concat(y);
+  path += "L ".concat(x + upperWidth, ",").concat(y);
+  path += "L ".concat(x + upperWidth - widthGap / 2, ",").concat(y + height);
+  path += "L ".concat(x + upperWidth - widthGap / 2 - lowerWidth, ",").concat(y + height);
+  path += "L ".concat(x, ",").concat(y, " Z");
+  return path;
+};
+var defaultProps = {
+  x: 0,
+  y: 0,
+  upperWidth: 0,
+  lowerWidth: 0,
+  height: 0,
+  isUpdateAnimationActive: false,
+  animationBegin: 0,
+  animationDuration: 1500,
+  animationEasing: 'ease'
+};
+var Trapezoid = props => {
+  var trapezoidProps = (0, _resolveDefaultProps.resolveDefaultProps)(props, defaultProps);
+  var pathRef = (0, _react.useRef)();
+  var [totalLength, setTotalLength] = (0, _react.useState)(-1);
+  (0, _react.useEffect)(() => {
+    if (pathRef.current && pathRef.current.getTotalLength) {
+      try {
+        var pathTotalLength = pathRef.current.getTotalLength();
+        if (pathTotalLength) {
+          setTotalLength(pathTotalLength);
+        }
+      } catch (_unused) {
+        // calculate total length error
+      }
+    }
+  }, []);
+  var {
+    x,
+    y,
+    upperWidth,
+    lowerWidth,
+    height,
+    className
+  } = trapezoidProps;
+  var {
+    animationEasing,
+    animationDuration,
+    animationBegin,
+    isUpdateAnimationActive
+  } = trapezoidProps;
+  if (x !== +x || y !== +y || upperWidth !== +upperWidth || lowerWidth !== +lowerWidth || height !== +height || upperWidth === 0 && lowerWidth === 0 || height === 0) {
+    return null;
+  }
+  var layerClass = (0, _clsx.clsx)('recharts-trapezoid', className);
+  if (!isUpdateAnimationActive) {
+    return /*#__PURE__*/React.createElement("g", null, /*#__PURE__*/React.createElement("path", _extends({}, (0, _ReactUtils.filterProps)(trapezoidProps, true), {
+      className: layerClass,
+      d: getTrapezoidPath(x, y, upperWidth, lowerWidth, height)
+    })));
+  }
+  return /*#__PURE__*/React.createElement(_Animate.Animate, {
+    canBegin: totalLength > 0,
+    from: {
+      upperWidth: 0,
+      lowerWidth: 0,
+      height,
+      x,
+      y
+    },
+    to: {
+      upperWidth,
+      lowerWidth,
+      height,
+      x,
+      y
+    },
+    duration: animationDuration
+    // @ts-expect-error TODO - fix the type error
+    ,
+    animationEasing: animationEasing,
+    isActive: isUpdateAnimationActive
+  }, _ref => {
+    var {
+      upperWidth: currUpperWidth,
+      lowerWidth: currLowerWidth,
+      height: currHeight,
+      x: currX,
+      y: currY
+    } = _ref;
+    return /*#__PURE__*/React.createElement(_Animate.Animate, {
+      canBegin: totalLength > 0
+      // @ts-expect-error TODO - fix the type error
+      ,
+      from: "0px ".concat(totalLength === -1 ? 1 : totalLength, "px")
+      // @ts-expect-error TODO - fix the type error
+      ,
+      to: "".concat(totalLength, "px 0px"),
+      attributeName: "strokeDasharray",
+      begin: animationBegin,
+      duration: animationDuration,
+      easing: animationEasing
+    }, /*#__PURE__*/React.createElement("path", _extends({}, (0, _ReactUtils.filterProps)(trapezoidProps, true), {
+      className: layerClass,
+      d: getTrapezoidPath(currX, currY, currUpperWidth, currLowerWidth, currHeight),
+      ref: pathRef
+    })));
+  });
+};
+Trapezoid$1.Trapezoid = Trapezoid;
+
+export { Trapezoid$1 as default };

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

@@ -0,0 +1,31 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as RechartsReduxContext } from '../../../../_virtual/RechartsReduxContext.js';
+import require$$0 from 'react';
+
+Object.defineProperty(RechartsReduxContext, "__esModule", {
+  value: true
+});
+RechartsReduxContext.RechartsReduxContext = void 0;
+var _react = require$$0;
+/*
+ * This is a copy of the React-Redux context type, but with our own store type.
+ * We could import directly from react-redux like this:
+ * import { ReactReduxContextValue } from 'react-redux/src/components/Context';
+ * but that makes typescript angry with some errors I am not sure how to resolve
+ * so copy it is.
+ */
+
+/**
+ * We need to use our own independent Redux context because we need to avoid interfering with other people's Redux stores
+ * in case they decide to install and use Recharts in another Redux app which is likely to happen.
+ *
+ * https://react-redux.js.org/using-react-redux/accessing-store#providing-custom-context
+ */
+RechartsReduxContext.RechartsReduxContext = /*#__PURE__*/(0, _react.createContext)(null);
+
+export { RechartsReduxContext as default };

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

@@ -0,0 +1,70 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as RechartsStoreProvider$1 } from '../../../../_virtual/RechartsStoreProvider.js';
+import require$$0 from 'react';
+import { c as cjsExports } from '../../../react-redux/dist/cjs/index.js';
+import './store.js';
+import '../context/PanoramaContext.js';
+import './RechartsReduxContext.js';
+import { __exports as PanoramaContext } from '../../../../_virtual/PanoramaContext.js';
+import { __exports as store } from '../../../../_virtual/store.js';
+import { __exports as RechartsReduxContext } from '../../../../_virtual/RechartsReduxContext.js';
+
+Object.defineProperty(RechartsStoreProvider$1, "__esModule", {
+  value: true
+});
+RechartsStoreProvider$1.RechartsStoreProvider = RechartsStoreProvider;
+var _react = _interopRequireWildcard(require$$0);
+var React = _react;
+var _reactRedux = cjsExports;
+var _store = store;
+var _PanoramaContext = PanoramaContext;
+var _RechartsReduxContext = RechartsReduxContext;
+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 RechartsStoreProvider(_ref) {
+  var {
+    preloadedState,
+    children,
+    reduxStoreName
+  } = _ref;
+  var isPanorama = (0, _PanoramaContext.useIsPanorama)();
+  /*
+   * Why the ref? Redux official documentation recommends to use store as a singleton,
+   * and reuse that everywhere: https://redux-toolkit.js.org/api/configureStore#basic-example
+   *
+   * Which is correct! Except that is considering deploying Redux in an app.
+   * Recharts as a library supports multiple charts on the same page.
+   * And each of these charts needs its own store independent of others!
+   *
+   * The alternative is to have everything in the store keyed by the chart id.
+   * Which would make working with everything a little bit more painful because we need the chart id everywhere.
+   */
+  var storeRef = (0, _react.useRef)(null);
+
+  /*
+   * Panorama means that this chart is not its own chart, it's only a "preview"
+   * being rendered as a child of Brush.
+   * In such case, it should not have a store on its own - it should implicitly inherit
+   * whatever data is in the "parent" or "root" chart.
+   * Which here is represented by not having a Provider at all. All selectors will use the root store by default.
+   */
+  if (isPanorama) {
+    return children;
+  }
+  if (storeRef.current == null) {
+    storeRef.current = (0, _store.createRechartsStore)(preloadedState, reduxStoreName);
+  }
+
+  // ts-expect-error React-Redux types demand that the context internal value is not null, but we have that as default.
+  var nonNullContext = _RechartsReduxContext.RechartsReduxContext;
+  return /*#__PURE__*/React.createElement(_reactRedux.Provider, {
+    context: nonNullContext,
+    store: storeRef.current
+  }, children);
+}
+
+export { RechartsStoreProvider$1 as default };

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

@@ -0,0 +1,33 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as ReportBar$1 } from '../../../../_virtual/ReportBar.js';
+import require$$0 from 'react';
+import './hooks.js';
+import './graphicalItemsSlice.js';
+import { __exports as hooks } from '../../../../_virtual/hooks.js';
+import { __exports as graphicalItemsSlice } from '../../../../_virtual/graphicalItemsSlice.js';
+
+Object.defineProperty(ReportBar$1, "__esModule", {
+  value: true
+});
+ReportBar$1.ReportBar = void 0;
+var _react = require$$0;
+var _hooks = hooks;
+var _graphicalItemsSlice = graphicalItemsSlice;
+var ReportBar = () => {
+  var dispatch = (0, _hooks.useAppDispatch)();
+  (0, _react.useEffect)(() => {
+    dispatch((0, _graphicalItemsSlice.addBar)());
+    return () => {
+      dispatch((0, _graphicalItemsSlice.removeBar)());
+    };
+  });
+  return null;
+};
+ReportBar$1.ReportBar = ReportBar;
+
+export { ReportBar$1 as default };

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

@@ -0,0 +1,29 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as ReportChartProps$1 } from '../../../../_virtual/ReportChartProps.js';
+import require$$0 from 'react';
+import './rootPropsSlice.js';
+import './hooks.js';
+import { __exports as hooks } from '../../../../_virtual/hooks.js';
+import { __exports as rootPropsSlice } from '../../../../_virtual/rootPropsSlice.js';
+
+Object.defineProperty(ReportChartProps$1, "__esModule", {
+  value: true
+});
+ReportChartProps$1.ReportChartProps = ReportChartProps;
+var _react = require$$0;
+var _rootPropsSlice = rootPropsSlice;
+var _hooks = hooks;
+function ReportChartProps(props) {
+  var dispatch = (0, _hooks.useAppDispatch)();
+  (0, _react.useEffect)(() => {
+    dispatch((0, _rootPropsSlice.updateOptions)(props));
+  }, [dispatch, props]);
+  return null;
+}
+
+export { ReportChartProps$1 as default };