qaema-ui 0.0.1

package/dist/node_modules/recharts/es6/cartesian/Bar.js

@@ -0,0 +1,417 @@
+import A, { PureComponent as ft } from "react";
+import { clsx as dt } from "../../../clsx/dist/clsx.js";
+import mt from "../../../react-smooth/es6/Animate.js";
+import ht from "../../../../_virtual/isEqual.js";
+import vt from "../../../../_virtual/isNil.js";
+import { Layer as T } from "../container/Layer.js";
+import { ErrorBar as yt } from "./ErrorBar.js";
+import { Cell as bt } from "../component/Cell.js";
+import { LabelList as gt } from "../component/LabelList.js";
+import { interpolateNumber as I, uniqueId as At, mathSign as H } from "../util/DataUtils.js";
+import { filterProps as V, findAllByType as nt } from "../util/ReactUtils.js";
+import { Global as Ot } from "../util/Global.js";
+import { getValueByDataKey as ot, findPositionOfBar as Pt, getBaseValueOfBar as xt, truncateByDomain as wt, getCateCoordinateOfBar as tt, getTooltipItem as Et } from "../util/ChartUtils.js";
+import { adaptEventsOfChild as et } from "../util/types.js";
+import { BarRectangle as at, minPointSizeCallback as St } from "../util/BarUtils.js";
+var jt = ["value", "background"], st;
+function R(t) {
+  "@babel/helpers - typeof";
+  return R = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(a) {
+    return typeof a;
+  } : function(a) {
+    return a && typeof Symbol == "function" && a.constructor === Symbol && a !== Symbol.prototype ? "symbol" : typeof a;
+  }, R(t);
+}
+function Dt(t, a) {
+  if (t == null) return {};
+  var r = Bt(t, a), e, i;
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(t);
+    for (i = 0; i < n.length; i++)
+      e = n[i], !(a.indexOf(e) >= 0) && Object.prototype.propertyIsEnumerable.call(t, e) && (r[e] = t[e]);
+  }
+  return r;
+}
+function Bt(t, a) {
+  if (t == null) return {};
+  var r = {};
+  for (var e in t)
+    if (Object.prototype.hasOwnProperty.call(t, e)) {
+      if (a.indexOf(e) >= 0) continue;
+      r[e] = t[e];
+    }
+  return r;
+}
+function M() {
+  return M = Object.assign ? Object.assign.bind() : function(t) {
+    for (var a = 1; a < arguments.length; a++) {
+      var r = arguments[a];
+      for (var e in r)
+        Object.prototype.hasOwnProperty.call(r, e) && (t[e] = r[e]);
+    }
+    return t;
+  }, M.apply(this, arguments);
+}
+function rt(t, a) {
+  var r = Object.keys(t);
+  if (Object.getOwnPropertySymbols) {
+    var e = Object.getOwnPropertySymbols(t);
+    a && (e = e.filter(function(i) {
+      return Object.getOwnPropertyDescriptor(t, i).enumerable;
+    })), r.push.apply(r, e);
+  }
+  return r;
+}
+function c(t) {
+  for (var a = 1; a < arguments.length; a++) {
+    var r = arguments[a] != null ? arguments[a] : {};
+    a % 2 ? rt(Object(r), !0).forEach(function(e) {
+      j(t, e, r[e]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(t, Object.getOwnPropertyDescriptors(r)) : rt(Object(r)).forEach(function(e) {
+      Object.defineProperty(t, e, Object.getOwnPropertyDescriptor(r, e));
+    });
+  }
+  return t;
+}
+function kt(t, a) {
+  if (!(t instanceof a))
+    throw new TypeError("Cannot call a class as a function");
+}
+function it(t, a) {
+  for (var r = 0; r < a.length; r++) {
+    var e = a[r];
+    e.enumerable = e.enumerable || !1, e.configurable = !0, "value" in e && (e.writable = !0), Object.defineProperty(t, ct(e.key), e);
+  }
+}
+function _t(t, a, r) {
+  return a && it(t.prototype, a), r && it(t, r), Object.defineProperty(t, "prototype", { writable: !1 }), t;
+}
+function It(t, a, r) {
+  return a = C(a), Rt(t, lt() ? Reflect.construct(a, r || [], C(t).constructor) : a.apply(t, r));
+}
+function Rt(t, a) {
+  if (a && (R(a) === "object" || typeof a == "function"))
+    return a;
+  if (a !== void 0)
+    throw new TypeError("Derived constructors may only return object or undefined");
+  return zt(t);
+}
+function zt(t) {
+  if (t === void 0)
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return t;
+}
+function lt() {
+  try {
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+    }));
+  } catch {
+  }
+  return (lt = function() {
+    return !!t;
+  })();
+}
+function C(t) {
+  return C = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(r) {
+    return r.__proto__ || Object.getPrototypeOf(r);
+  }, C(t);
+}
+function Nt(t, a) {
+  if (typeof a != "function" && a !== null)
+    throw new TypeError("Super expression must either be null or a function");
+  t.prototype = Object.create(a && a.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), a && G(t, a);
+}
+function G(t, a) {
+  return G = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(e, i) {
+    return e.__proto__ = i, e;
+  }, G(t, a);
+}
+function j(t, a, r) {
+  return a = ct(a), a in t ? Object.defineProperty(t, a, { value: r, enumerable: !0, configurable: !0, writable: !0 }) : t[a] = r, t;
+}
+function ct(t) {
+  var a = Tt(t, "string");
+  return R(a) == "symbol" ? a : a + "";
+}
+function Tt(t, a) {
+  if (R(t) != "object" || !t) return t;
+  var r = t[Symbol.toPrimitive];
+  if (r !== void 0) {
+    var e = r.call(t, a);
+    if (R(e) != "object") return e;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return String(t);
+}
+var $ = /* @__PURE__ */ (function(t) {
+  function a() {
+    var r;
+    kt(this, a);
+    for (var e = arguments.length, i = new Array(e), n = 0; n < e; n++)
+      i[n] = arguments[n];
+    return r = It(this, a, [].concat(i)), j(r, "state", {
+      isAnimationFinished: !1
+    }), j(r, "id", At("recharts-bar-")), j(r, "handleAnimationEnd", function() {
+      var o = r.props.onAnimationEnd;
+      r.setState({
+        isAnimationFinished: !0
+      }), o && o();
+    }), j(r, "handleAnimationStart", function() {
+      var o = r.props.onAnimationStart;
+      r.setState({
+        isAnimationFinished: !1
+      }), o && o();
+    }), r;
+  }
+  return Nt(a, t), _t(a, [{
+    key: "renderRectanglesStatically",
+    value: function(e) {
+      var i = this, n = this.props, o = n.shape, y = n.dataKey, b = n.activeIndex, u = n.activeBar, m = V(this.props, !1);
+      return e && e.map(function(s, p) {
+        var f = p === b, d = f ? u : o, v = c(c(c({}, m), s), {}, {
+          isActive: f,
+          option: d,
+          index: p,
+          dataKey: y,
+          onAnimationStart: i.handleAnimationStart,
+          onAnimationEnd: i.handleAnimationEnd
+        });
+        return /* @__PURE__ */ A.createElement(T, M({
+          className: "recharts-bar-rectangle"
+        }, et(i.props, s, p), {
+          // https://github.com/recharts/recharts/issues/5415
+          // eslint-disable-next-line react/no-array-index-key
+          key: "rectangle-".concat(s == null ? void 0 : s.x, "-").concat(s == null ? void 0 : s.y, "-").concat(s == null ? void 0 : s.value, "-").concat(p)
+        }), /* @__PURE__ */ A.createElement(at, v));
+      });
+    }
+  }, {
+    key: "renderRectanglesWithAnimation",
+    value: function() {
+      var e = this, i = this.props, n = i.data, o = i.layout, y = i.isAnimationActive, b = i.animationBegin, u = i.animationDuration, m = i.animationEasing, s = i.animationId, p = this.state.prevData;
+      return /* @__PURE__ */ A.createElement(mt, {
+        begin: b,
+        duration: u,
+        isActive: y,
+        easing: m,
+        from: {
+          t: 0
+        },
+        to: {
+          t: 1
+        },
+        key: "bar-".concat(s),
+        onAnimationEnd: this.handleAnimationEnd,
+        onAnimationStart: this.handleAnimationStart
+      }, function(f) {
+        var d = f.t, v = n.map(function(l, D) {
+          var h = p && p[D];
+          if (h) {
+            var x = I(h.x, l.x), B = I(h.y, l.y), k = I(h.width, l.width), W = I(h.height, l.height);
+            return c(c({}, l), {}, {
+              x: x(d),
+              y: B(d),
+              width: k(d),
+              height: W(d)
+            });
+          }
+          if (o === "horizontal") {
+            var z = I(0, l.height), F = z(d);
+            return c(c({}, l), {}, {
+              y: l.y + l.height - F,
+              height: F
+            });
+          }
+          var w = I(0, l.width), E = w(d);
+          return c(c({}, l), {}, {
+            width: E
+          });
+        });
+        return /* @__PURE__ */ A.createElement(T, null, e.renderRectanglesStatically(v));
+      });
+    }
+  }, {
+    key: "renderRectangles",
+    value: function() {
+      var e = this.props, i = e.data, n = e.isAnimationActive, o = this.state.prevData;
+      return n && i && i.length && (!o || !ht(o, i)) ? this.renderRectanglesWithAnimation() : this.renderRectanglesStatically(i);
+    }
+  }, {
+    key: "renderBackground",
+    value: function() {
+      var e = this, i = this.props, n = i.data, o = i.dataKey, y = i.activeIndex, b = V(this.props.background, !1);
+      return n.map(function(u, m) {
+        u.value;
+        var s = u.background, p = Dt(u, jt);
+        if (!s)
+          return null;
+        var f = c(c(c(c(c({}, p), {}, {
+          fill: "#eee"
+        }, s), b), et(e.props, u, m)), {}, {
+          onAnimationStart: e.handleAnimationStart,
+          onAnimationEnd: e.handleAnimationEnd,
+          dataKey: o,
+          index: m,
+          className: "recharts-bar-background-rectangle"
+        });
+        return /* @__PURE__ */ A.createElement(at, M({
+          key: "background-bar-".concat(m),
+          option: e.props.background,
+          isActive: m === y
+        }, f));
+      });
+    }
+  }, {
+    key: "renderErrorBar",
+    value: function(e, i) {
+      if (this.props.isAnimationActive && !this.state.isAnimationFinished)
+        return null;
+      var n = this.props, o = n.data, y = n.xAxis, b = n.yAxis, u = n.layout, m = n.children, s = nt(m, yt);
+      if (!s)
+        return null;
+      var p = u === "vertical" ? o[0].height / 2 : o[0].width / 2, f = function(l, D) {
+        var h = Array.isArray(l.value) ? l.value[1] : l.value;
+        return {
+          x: l.x,
+          y: l.y,
+          value: h,
+          errorVal: ot(l, D)
+        };
+      }, d = {
+        clipPath: e ? "url(#clipPath-".concat(i, ")") : null
+      };
+      return /* @__PURE__ */ A.createElement(T, d, s.map(function(v) {
+        return /* @__PURE__ */ A.cloneElement(v, {
+          key: "error-bar-".concat(i, "-").concat(v.props.dataKey),
+          data: o,
+          xAxis: y,
+          yAxis: b,
+          layout: u,
+          offset: p,
+          dataPointFormatter: f
+        });
+      }));
+    }
+  }, {
+    key: "render",
+    value: function() {
+      var e = this.props, i = e.hide, n = e.data, o = e.className, y = e.xAxis, b = e.yAxis, u = e.left, m = e.top, s = e.width, p = e.height, f = e.isAnimationActive, d = e.background, v = e.id;
+      if (i || !n || !n.length)
+        return null;
+      var l = this.state.isAnimationFinished, D = dt("recharts-bar", o), h = y && y.allowDataOverflow, x = b && b.allowDataOverflow, B = h || x, k = vt(v) ? this.id : v;
+      return /* @__PURE__ */ A.createElement(T, {
+        className: D
+      }, h || x ? /* @__PURE__ */ A.createElement("defs", null, /* @__PURE__ */ A.createElement("clipPath", {
+        id: "clipPath-".concat(k)
+      }, /* @__PURE__ */ A.createElement("rect", {
+        x: h ? u : u - s / 2,
+        y: x ? m : m - p / 2,
+        width: h ? s : s * 2,
+        height: x ? p : p * 2
+      }))) : null, /* @__PURE__ */ A.createElement(T, {
+        className: "recharts-bar-rectangles",
+        clipPath: B ? "url(#clipPath-".concat(k, ")") : null
+      }, d ? this.renderBackground() : null, this.renderRectangles()), this.renderErrorBar(B, k), (!f || l) && gt.renderCallByParent(this.props, n));
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function(e, i) {
+      return e.animationId !== i.prevAnimationId ? {
+        prevAnimationId: e.animationId,
+        curData: e.data,
+        prevData: i.curData
+      } : e.data !== i.curData ? {
+        curData: e.data
+      } : null;
+    }
+  }]);
+})(ft);
+st = $;
+j($, "displayName", "Bar");
+j($, "defaultProps", {
+  xAxisId: 0,
+  yAxisId: 0,
+  legendType: "rect",
+  minPointSize: 0,
+  hide: !1,
+  data: [],
+  layout: "vertical",
+  activeBar: !1,
+  isAnimationActive: !Ot.isSsr,
+  animationBegin: 0,
+  animationDuration: 400,
+  animationEasing: "ease"
+});
+j($, "getComposedData", function(t) {
+  var a = t.props, r = t.item, e = t.barPosition, i = t.bandSize, n = t.xAxis, o = t.yAxis, y = t.xAxisTicks, b = t.yAxisTicks, u = t.stackedData, m = t.dataStartIndex, s = t.displayedData, p = t.offset, f = Pt(e, r);
+  if (!f)
+    return null;
+  var d = a.layout, v = r.type.defaultProps, l = v !== void 0 ? c(c({}, v), r.props) : r.props, D = l.dataKey, h = l.children, x = l.minPointSize, B = d === "horizontal" ? o : n, k = u ? B.scale.domain() : null, W = xt({
+    numericAxis: B
+  }), z = nt(h, bt), F = s.map(function(w, E) {
+    var g, N, _, O, P, L;
+    u ? g = wt(u[m + E], k) : (g = ot(w, D), Array.isArray(g) || (g = [W, g]));
+    var S = St(x, st.defaultProps.minPointSize)(g[1], E);
+    if (d === "horizontal") {
+      var q, X = [o.scale(g[0]), o.scale(g[1])], Y = X[0], K = X[1];
+      N = tt({
+        axis: n,
+        ticks: y,
+        bandSize: i,
+        offset: f.offset,
+        entry: w,
+        index: E
+      }), _ = (q = K ?? Y) !== null && q !== void 0 ? q : void 0, O = f.size;
+      var J = Y - K;
+      if (P = Number.isNaN(J) ? 0 : J, L = {
+        x: N,
+        y: o.y,
+        width: O,
+        height: o.height
+      }, Math.abs(S) > 0 && Math.abs(P) < Math.abs(S)) {
+        var Q = H(P || S) * (Math.abs(S) - Math.abs(P));
+        _ -= Q, P += Q;
+      }
+    } else {
+      var U = [n.scale(g[0]), n.scale(g[1])], Z = U[0], ut = U[1];
+      if (N = Z, _ = tt({
+        axis: o,
+        ticks: b,
+        bandSize: i,
+        offset: f.offset,
+        entry: w,
+        index: E
+      }), O = ut - Z, P = f.size, L = {
+        x: n.x,
+        y: _,
+        width: n.width,
+        height: P
+      }, Math.abs(S) > 0 && Math.abs(O) < Math.abs(S)) {
+        var pt = H(O || S) * (Math.abs(S) - Math.abs(O));
+        O += pt;
+      }
+    }
+    return c(c(c({}, w), {}, {
+      x: N,
+      y: _,
+      width: O,
+      height: P,
+      value: u ? g : g[1],
+      payload: w,
+      background: L
+    }, z && z[E] && z[E].props), {}, {
+      tooltipPayload: [Et(r, w)],
+      tooltipPosition: {
+        x: N + O / 2,
+        y: _ + P / 2
+      }
+    });
+  });
+  return c({
+    data: F,
+    layout: d
+  }, p);
+});
+export {
+  $ as Bar
+};