qaema-ui 0.0.1

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

@@ -0,0 +1,238 @@
+import _ from "react";
+import z from "../../../tiny-invariant/dist/esm/tiny-invariant.js";
+import { Layer as K } from "../container/Layer.js";
+import { filterProps as X } from "../util/ReactUtils.js";
+var Y = ["offset", "layout", "width", "dataKey", "data", "dataPointFormatter", "xAxis", "yAxis"];
+function c(t) {
+  "@babel/helpers - typeof";
+  return c = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(r) {
+    return typeof r;
+  } : function(r) {
+    return r && typeof Symbol == "function" && r.constructor === Symbol && r !== Symbol.prototype ? "symbol" : typeof r;
+  }, c(t);
+}
+function g() {
+  return g = Object.assign ? Object.assign.bind() : function(t) {
+    for (var r = 1; r < arguments.length; r++) {
+      var e = arguments[r];
+      for (var n in e)
+        Object.prototype.hasOwnProperty.call(e, n) && (t[n] = e[n]);
+    }
+    return t;
+  }, g.apply(this, arguments);
+}
+function Z(t, r) {
+  return et(t) || rt(t, r) || tt(t, r) || M();
+}
+function M() {
+  throw new TypeError(`Invalid attempt to destructure non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+}
+function tt(t, r) {
+  if (t) {
+    if (typeof t == "string") return L(t, r);
+    var e = Object.prototype.toString.call(t).slice(8, -1);
+    if (e === "Object" && t.constructor && (e = t.constructor.name), e === "Map" || e === "Set") return Array.from(t);
+    if (e === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(e)) return L(t, r);
+  }
+}
+function L(t, r) {
+  (r == null || r > t.length) && (r = t.length);
+  for (var e = 0, n = new Array(r); e < r; e++) n[e] = t[e];
+  return n;
+}
+function rt(t, r) {
+  var e = t == null ? null : typeof Symbol < "u" && t[Symbol.iterator] || t["@@iterator"];
+  if (e != null) {
+    var n, o, i, u, l = [], y = !0, p = !1;
+    try {
+      if (i = (e = e.call(t)).next, r !== 0) for (; !(y = (n = i.call(e)).done) && (l.push(n.value), l.length !== r); y = !0) ;
+    } catch (s) {
+      p = !0, o = s;
+    } finally {
+      try {
+        if (!y && e.return != null && (u = e.return(), Object(u) !== u)) return;
+      } finally {
+        if (p) throw o;
+      }
+    }
+    return l;
+  }
+}
+function et(t) {
+  if (Array.isArray(t)) return t;
+}
+function nt(t, r) {
+  if (t == null) return {};
+  var e = ot(t, r), n, o;
+  if (Object.getOwnPropertySymbols) {
+    var i = Object.getOwnPropertySymbols(t);
+    for (o = 0; o < i.length; o++)
+      n = i[o], !(r.indexOf(n) >= 0) && Object.prototype.propertyIsEnumerable.call(t, n) && (e[n] = t[n]);
+  }
+  return e;
+}
+function ot(t, r) {
+  if (t == null) return {};
+  var e = {};
+  for (var n in t)
+    if (Object.prototype.hasOwnProperty.call(t, n)) {
+      if (r.indexOf(n) >= 0) continue;
+      e[n] = t[n];
+    }
+  return e;
+}
+function at(t, r) {
+  if (!(t instanceof r))
+    throw new TypeError("Cannot call a class as a function");
+}
+function it(t, r) {
+  for (var e = 0; e < r.length; e++) {
+    var n = r[e];
+    n.enumerable = n.enumerable || !1, n.configurable = !0, "value" in n && (n.writable = !0), Object.defineProperty(t, $(n.key), n);
+  }
+}
+function ut(t, r, e) {
+  return r && it(t.prototype, r), Object.defineProperty(t, "prototype", { writable: !1 }), t;
+}
+function ft(t, r, e) {
+  return r = w(r), ct(t, D() ? Reflect.construct(r, e || [], w(t).constructor) : r.apply(t, e));
+}
+function ct(t, r) {
+  if (r && (c(r) === "object" || typeof r == "function"))
+    return r;
+  if (r !== void 0)
+    throw new TypeError("Derived constructors may only return object or undefined");
+  return lt(t);
+}
+function lt(t) {
+  if (t === void 0)
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return t;
+}
+function D() {
+  try {
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+    }));
+  } catch {
+  }
+  return (D = function() {
+    return !!t;
+  })();
+}
+function w(t) {
+  return w = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(e) {
+    return e.__proto__ || Object.getPrototypeOf(e);
+  }, w(t);
+}
+function yt(t, r) {
+  if (typeof r != "function" && r !== null)
+    throw new TypeError("Super expression must either be null or a function");
+  t.prototype = Object.create(r && r.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), r && S(t, r);
+}
+function S(t, r) {
+  return S = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(n, o) {
+    return n.__proto__ = o, n;
+  }, S(t, r);
+}
+function V(t, r, e) {
+  return r = $(r), r in t ? Object.defineProperty(t, r, { value: e, enumerable: !0, configurable: !0, writable: !0 }) : t[r] = e, t;
+}
+function $(t) {
+  var r = pt(t, "string");
+  return c(r) == "symbol" ? r : r + "";
+}
+function pt(t, r) {
+  if (c(t) != "object" || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (e !== void 0) {
+    var n = e.call(t, r);
+    if (c(n) != "object") return n;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return String(t);
+}
+var k = /* @__PURE__ */ (function(t) {
+  function r() {
+    return at(this, r), ft(this, r, arguments);
+  }
+  return yt(r, t), ut(r, [{
+    key: "render",
+    value: function() {
+      var n = this.props, o = n.offset, i = n.layout, u = n.width, l = n.dataKey, y = n.data, p = n.dataPointFormatter, s = n.xAxis, q = n.yAxis, H = nt(n, Y), U = X(H, !1);
+      this.props.direction === "x" && s.type !== "number" && (process.env.NODE_ENV !== "production" ? z(!1, 'ErrorBar requires Axis type property to be "number".') : z());
+      var C = y.map(function(G) {
+        var b = p(G, l), J = b.x, Q = b.y, v = b.value, m = b.errorVal;
+        if (!m)
+          return null;
+        var f = [], h, d;
+        if (Array.isArray(m)) {
+          var B = Z(m, 2);
+          h = B[0], d = B[1];
+        } else
+          h = d = m;
+        if (i === "vertical") {
+          var T = s.scale, O = Q + o, R = O + u, I = O - u, j = T(v - h), x = T(v + d);
+          f.push({
+            x1: x,
+            y1: R,
+            x2: x,
+            y2: I
+          }), f.push({
+            x1: j,
+            y1: O,
+            x2: x,
+            y2: O
+          }), f.push({
+            x1: j,
+            y1: R,
+            x2: j,
+            y2: I
+          });
+        } else if (i === "horizontal") {
+          var N = q.scale, P = J + o, F = P - u, W = P + u, A = N(v - h), E = N(v + d);
+          f.push({
+            x1: F,
+            y1: E,
+            x2: W,
+            y2: E
+          }), f.push({
+            x1: P,
+            y1: A,
+            x2: P,
+            y2: E
+          }), f.push({
+            x1: F,
+            y1: A,
+            x2: W,
+            y2: A
+          });
+        }
+        return /* @__PURE__ */ _.createElement(K, g({
+          className: "recharts-errorBar",
+          key: "bar-".concat(f.map(function(a) {
+            return "".concat(a.x1, "-").concat(a.x2, "-").concat(a.y1, "-").concat(a.y2);
+          }))
+        }, U), f.map(function(a) {
+          return /* @__PURE__ */ _.createElement("line", g({}, a, {
+            key: "line-".concat(a.x1, "-").concat(a.x2, "-").concat(a.y1, "-").concat(a.y2)
+          }));
+        }));
+      });
+      return /* @__PURE__ */ _.createElement(K, {
+        className: "recharts-errorBars"
+      }, C);
+    }
+  }]);
+})(_.Component);
+V(k, "defaultProps", {
+  stroke: "black",
+  strokeWidth: 1.5,
+  width: 5,
+  offset: 0,
+  layout: "horizontal"
+});
+V(k, "displayName", "ErrorBar");
+export {
+  k as ErrorBar
+};