mixdashboards 1.0.32 → 1.0.39

package/dist/install-9_V0b6vf.js

@@ -0,0 +1,497 @@
+import { A as ne, I as H, u as oe } from "./installCanvasRenderer-CLT2hquJ.js";
+import { h as M, eb as se, f as B, _ as P, cF as O, d2 as ee, c1 as $, G as q, c2 as W, Q, u as V, c9 as U, dg as le, x as ce, P as te, z as ue, c6 as de, c8 as pe, aS as he, o as L, bk as ve, ec as me, H as ge, O as X, ed as fe, bD as Y, aT as ye, m as Z, j as ae, B as xe, M as Se, cc as Ae, C as Ie, cs as Me, dn as be, dm as j, b as we, ak as R, q as Te } from "./echarts-BVht3HHb.js";
+import { L as Le, d as Ce } from "./LegendVisualProvider-BP9kA8co.js";
+import { c as De } from "./createSeriesDataSimply-Bsly4zZA.js";
+import { a as Ne, A as Ve, b as ke, c as _e } from "./axisAlignTicks-BqVUa467.js";
+function Ee(r) {
+  r.eachSeriesByType("radar", function(e) {
+    var t = e.getData(), a = [], n = e.coordinateSystem;
+    if (n) {
+      var l = n.getIndicatorAxes();
+      M(l, function(o, i) {
+        t.each(t.mapDimension(l[i].dim), function(p, m) {
+          a[m] = a[m] || [];
+          var v = n.dataToPoint(p, i);
+          a[m][i] = J(v) ? v : K(n);
+        });
+      }), t.each(function(o) {
+        var i = se(a[o], function(p) {
+          return J(p);
+        }) || K(n);
+        a[o].push(i.slice()), t.setItemLayout(o, a[o]);
+      });
+    }
+  });
+}
+function J(r) {
+  return !isNaN(r[0]) && !isNaN(r[1]);
+}
+function K(r) {
+  return [r.cx, r.cy];
+}
+function Ge(r) {
+  var e = r.polar;
+  if (e) {
+    B(e) || (e = [e]);
+    var t = [];
+    M(e, function(a, n) {
+      a.indicator ? (a.type && !a.shape && (a.shape = a.type), r.radar = r.radar || [], B(r.radar) || (r.radar = [r.radar]), r.radar.push(a)) : t.push(a);
+    }), r.polar = t;
+  }
+  M(r.series, function(a) {
+    a && a.type === "radar" && a.polarIndex && (a.radarIndex = a.polarIndex);
+  });
+}
+var Pe = (
+  /** @class */
+  (function(r) {
+    P(e, r);
+    function e() {
+      var t = r !== null && r.apply(this, arguments) || this;
+      return t.type = e.type, t;
+    }
+    return e.prototype.render = function(t, a, n) {
+      var l = t.coordinateSystem, o = this.group, i = t.getData(), p = this._data;
+      function m(c, h) {
+        var s = c.getItemVisual(h, "symbol") || "circle";
+        if (s !== "none") {
+          var g = me(c.getItemVisual(h, "symbolSize")), d = ge(s, -1, -1, 2, 2), f = c.getItemVisual(h, "symbolRotate") || 0;
+          return d.attr({
+            style: {
+              strokeNoScale: !0
+            },
+            z2: 100,
+            scaleX: g[0] / 2,
+            scaleY: g[1] / 2,
+            rotation: f * Math.PI / 180 || 0
+          }), d;
+        }
+      }
+      function v(c, h, s, g, d, f) {
+        s.removeAll();
+        for (var u = 0; u < h.length - 1; u++) {
+          var S = m(g, d);
+          S && (S.__dimIdx = u, c[u] ? (S.setPosition(c[u]), ve[f ? "initProps" : "updateProps"](S, {
+            x: h[u][0],
+            y: h[u][1]
+          }, t, d)) : S.setPosition(h[u]), s.add(S));
+        }
+      }
+      function A(c) {
+        return L(c, function(h) {
+          return [l.cx, l.cy];
+        });
+      }
+      i.diff(p).add(function(c) {
+        var h = i.getItemLayout(c);
+        if (h) {
+          var s = new O(), g = new ee(), d = {
+            shape: {
+              points: h
+            }
+          };
+          s.shape.points = A(h), g.shape.points = A(h), $(s, d, t, c), $(g, d, t, c);
+          var f = new q(), u = new q();
+          f.add(g), f.add(s), f.add(u), v(g.shape.points, h, u, i, c, !0), i.setItemGraphicEl(c, f);
+        }
+      }).update(function(c, h) {
+        var s = p.getItemGraphicEl(h), g = s.childAt(0), d = s.childAt(1), f = s.childAt(2), u = {
+          shape: {
+            points: i.getItemLayout(c)
+          }
+        };
+        u.shape.points && (v(g.shape.points, u.shape.points, f, i, c, !1), W(d), W(g), Q(g, u, t), Q(d, u, t), i.setItemGraphicEl(c, s));
+      }).remove(function(c) {
+        o.remove(p.getItemGraphicEl(c));
+      }).execute(), i.eachItemGraphicEl(function(c, h) {
+        var s = i.getItemModel(h), g = c.childAt(0), d = c.childAt(1), f = c.childAt(2), u = i.getItemVisual(h, "style"), S = u.fill;
+        o.add(c), g.useStyle(V(s.getModel("lineStyle").getLineStyle(), {
+          fill: "none",
+          stroke: S
+        })), U(g, s, "lineStyle"), U(d, s, "areaStyle");
+        var N = s.getModel("areaStyle"), k = N.isEmpty() && N.parentModel.isEmpty();
+        d.ignore = k, M(["emphasis", "select", "blur"], function(x) {
+          var b = s.getModel([x, "areaStyle"]), C = b.isEmpty() && b.parentModel.isEmpty();
+          d.ensureState(x).ignore = C && k;
+        }), d.useStyle(V(N.getAreaStyle(), {
+          fill: S,
+          opacity: 0.7,
+          decal: u.decal
+        }));
+        var y = s.getModel("emphasis"), w = y.getModel("itemStyle").getItemStyle();
+        f.eachChild(function(x) {
+          if (x instanceof le) {
+            var b = x.style;
+            x.useStyle(ce({
+              // TODO other properties like x, y ?
+              image: b.image,
+              x: b.x,
+              y: b.y,
+              width: b.width,
+              height: b.height
+            }, u));
+          } else
+            x.useStyle(u), x.setColor(S), x.style.strokeNoScale = !0;
+          var C = x.ensureState("emphasis");
+          C.style = te(w);
+          var I = i.getStore().get(i.getDimensionIndex(x.__dimIdx), h);
+          (I == null || isNaN(I)) && (I = ""), ue(x, de(s), {
+            labelFetcher: i.hostModel,
+            labelDataIndex: h,
+            labelDimIndex: x.__dimIdx,
+            defaultText: I,
+            inheritColor: S,
+            defaultOpacity: u.opacity
+          });
+        }), pe(c, y.get("focus"), y.get("blurScope"), y.get("disabled"));
+      }), this._data = i;
+    }, e.prototype.remove = function() {
+      this.group.removeAll(), this._data = null;
+    }, e.type = "radar", e;
+  })(he)
+), Re = (
+  /** @class */
+  (function(r) {
+    P(e, r);
+    function e() {
+      var t = r !== null && r.apply(this, arguments) || this;
+      return t.type = e.type, t.hasSymbolVisual = !0, t;
+    }
+    return e.prototype.init = function(t) {
+      r.prototype.init.apply(this, arguments), this.legendVisualProvider = new Le(X(this.getData, this), X(this.getRawData, this));
+    }, e.prototype.getInitialData = function(t, a) {
+      return De(this, {
+        generateCoord: "indicator_",
+        generateCoordCount: 1 / 0
+      });
+    }, e.prototype.formatTooltip = function(t, a, n) {
+      var l = this.getData(), o = this.coordinateSystem, i = o.getIndicatorAxes(), p = this.getData().getName(t), m = p === "" ? this.name : p, v = fe(this, t);
+      return Y("section", {
+        header: m,
+        sortBlocks: !0,
+        blocks: L(i, function(A) {
+          var c = l.get(l.mapDimension(A.dim), t);
+          return Y("nameValue", {
+            markerType: "subItem",
+            markerColor: v,
+            name: A.name,
+            value: c,
+            sortParam: c
+          });
+        })
+      });
+    }, e.prototype.getTooltipPosition = function(t) {
+      if (t != null) {
+        for (var a = this.getData(), n = this.coordinateSystem, l = a.getValues(L(n.dimensions, function(m) {
+          return a.mapDimension(m);
+        }), t), o = 0, i = l.length; o < i; o++)
+          if (!isNaN(l[o])) {
+            var p = n.getIndicatorAxes();
+            return n.coordToPoint(p[o].dataToCoord(l[o]), o);
+          }
+      }
+    }, e.type = "series.radar", e.dependencies = ["radar"], e.defaultOption = {
+      // zlevel: 0,
+      z: 2,
+      colorBy: "data",
+      coordinateSystem: "radar",
+      legendHoverLink: !0,
+      radarIndex: 0,
+      lineStyle: {
+        width: 2,
+        type: "solid",
+        join: "round"
+      },
+      label: {
+        position: "top"
+      },
+      // areaStyle: {
+      // },
+      // itemStyle: {}
+      symbolSize: 8
+      // symbolRotate: null
+    }, e;
+  })(ye)
+), G = Ne.value;
+function z(r, e) {
+  return V({
+    show: e
+  }, r);
+}
+var ze = (
+  /** @class */
+  (function(r) {
+    P(e, r);
+    function e() {
+      var t = r !== null && r.apply(this, arguments) || this;
+      return t.type = e.type, t;
+    }
+    return e.prototype.optionUpdated = function() {
+      var t = this.get("boundaryGap"), a = this.get("splitNumber"), n = this.get("scale"), l = this.get("axisLine"), o = this.get("axisTick"), i = this.get("axisLabel"), p = this.get("axisName"), m = this.get(["axisName", "show"]), v = this.get(["axisName", "formatter"]), A = this.get("axisNameGap"), c = this.get("triggerEvent"), h = L(this.get("indicator") || [], function(s) {
+        s.max != null && s.max > 0 && !s.min ? s.min = 0 : s.min != null && s.min < 0 && !s.max && (s.max = 0);
+        var g = p;
+        s.color != null && (g = V({
+          color: s.color
+        }, p));
+        var d = Z(te(s), {
+          boundaryGap: t,
+          splitNumber: a,
+          scale: n,
+          axisLine: l,
+          axisTick: o,
+          // axisType: axisType,
+          axisLabel: i,
+          // Compatible with 2 and use text
+          name: s.text,
+          showName: m,
+          nameLocation: "end",
+          nameGap: A,
+          // min: 0,
+          nameTextStyle: g,
+          triggerEvent: c
+        }, !1);
+        if (ae(v)) {
+          var f = d.name;
+          d.name = v.replace("{value}", f != null ? f : "");
+        } else xe(v) && (d.name = v(d.name, d));
+        var u = new Se(d, null, this.ecModel);
+        return Ae(u, Ve.prototype), u.mainType = "radar", u.componentIndex = this.componentIndex, u;
+      }, this);
+      this._indicatorModels = h;
+    }, e.prototype.getIndicatorModels = function() {
+      return this._indicatorModels;
+    }, e.type = "radar", e.defaultOption = {
+      // zlevel: 0,
+      z: 0,
+      center: ["50%", "50%"],
+      radius: "75%",
+      startAngle: 90,
+      axisName: {
+        show: !0
+        // formatter: null
+        // textStyle: {}
+      },
+      boundaryGap: [0, 0],
+      splitNumber: 5,
+      axisNameGap: 15,
+      scale: !1,
+      // Polygon or circle
+      shape: "polygon",
+      axisLine: Z({
+        lineStyle: {
+          color: "#bbb"
+        }
+      }, G.axisLine),
+      axisLabel: z(G.axisLabel, !1),
+      axisTick: z(G.axisTick, !1),
+      // axisType: 'value',
+      splitLine: z(G.splitLine, !0),
+      splitArea: z(G.splitArea, !0),
+      // {text, min, max}
+      indicator: []
+    }, e;
+  })(Ie)
+), Be = ["axisLine", "axisTickLabel", "axisName"], Fe = (
+  /** @class */
+  (function(r) {
+    P(e, r);
+    function e() {
+      var t = r !== null && r.apply(this, arguments) || this;
+      return t.type = e.type, t;
+    }
+    return e.prototype.render = function(t, a, n) {
+      var l = this.group;
+      l.removeAll(), this._buildAxes(t), this._buildSplitLineAndArea(t);
+    }, e.prototype._buildAxes = function(t) {
+      var a = t.coordinateSystem, n = a.getIndicatorAxes(), l = L(n, function(o) {
+        var i = o.model.get("showName") ? o.name : "", p = new ne(o.model, {
+          axisName: i,
+          position: [a.cx, a.cy],
+          rotation: o.angle,
+          labelDirection: -1,
+          tickDirection: -1,
+          nameDirection: 1
+        });
+        return p;
+      });
+      M(l, function(o) {
+        M(Be, o.add, o), this.group.add(o.getGroup());
+      }, this);
+    }, e.prototype._buildSplitLineAndArea = function(t) {
+      var a = t.coordinateSystem, n = a.getIndicatorAxes();
+      if (!n.length)
+        return;
+      var l = t.get("shape"), o = t.getModel("splitLine"), i = t.getModel("splitArea"), p = o.getModel("lineStyle"), m = i.getModel("areaStyle"), v = o.get("show"), A = i.get("show"), c = p.get("color"), h = m.get("color"), s = B(c) ? c : [c], g = B(h) ? h : [h], d = [], f = [];
+      function u(T, D, _) {
+        var E = _ % D.length;
+        return T[E] = T[E] || [], E;
+      }
+      if (l === "circle")
+        for (var S = n[0].getTicksCoords(), N = a.cx, k = a.cy, y = 0; y < S.length; y++) {
+          if (v) {
+            var w = u(d, s, y);
+            d[w].push(new Me({
+              shape: {
+                cx: N,
+                cy: k,
+                r: S[y].coord
+              }
+            }));
+          }
+          if (A && y < S.length - 1) {
+            var w = u(f, g, y);
+            f[w].push(new be({
+              shape: {
+                cx: N,
+                cy: k,
+                r0: S[y].coord,
+                r: S[y + 1].coord
+              }
+            }));
+          }
+        }
+      else
+        for (var x, b = L(n, function(T, D) {
+          var _ = T.getTicksCoords();
+          return x = x == null ? _.length - 1 : Math.min(_.length - 1, x), L(_, function(E) {
+            return a.coordToPoint(E.coord, D);
+          });
+        }), C = [], y = 0; y <= x; y++) {
+          for (var I = [], F = 0; F < n.length; F++)
+            I.push(b[F][y]);
+          if (I[0] ? I.push(I[0].slice()) : process.env.NODE_ENV !== "production" && console.error("Can't draw value axis " + y), v) {
+            var w = u(d, s, y);
+            d[w].push(new ee({
+              shape: {
+                points: I
+              }
+            }));
+          }
+          if (A && C) {
+            var w = u(f, g, y - 1);
+            f[w].push(new O({
+              shape: {
+                points: I.concat(C)
+              }
+            }));
+          }
+          C = I.slice().reverse();
+        }
+      var re = p.getLineStyle(), ie = m.getAreaStyle();
+      M(f, function(T, D) {
+        this.group.add(j(T, {
+          style: V({
+            stroke: "none",
+            fill: g[D % g.length]
+          }, ie),
+          silent: !0
+        }));
+      }, this), M(d, function(T, D) {
+        this.group.add(j(T, {
+          style: V({
+            fill: "none",
+            stroke: s[D % s.length]
+          }, re),
+          silent: !0
+        }));
+      }, this);
+    }, e.type = "radar", e;
+  })(we)
+), He = (
+  /** @class */
+  (function(r) {
+    P(e, r);
+    function e(t, a, n) {
+      var l = r.call(this, t, a, n) || this;
+      return l.type = "value", l.angle = 0, l.name = "", l;
+    }
+    return e;
+  })(ke)
+), $e = (
+  /** @class */
+  (function() {
+    function r(e, t, a) {
+      this.dimensions = [], this._model = e, this._indicatorAxes = L(e.getIndicatorModels(), function(n, l) {
+        var o = "indicator_" + l, i = new He(
+          o,
+          new H()
+          // (indicatorModel.get('axisType') === 'log') ? new LogScale() : new IntervalScale()
+        );
+        return i.name = n.get("name"), i.model = n, n.axis = i, this.dimensions.push(o), i;
+      }, this), this.resize(e, a);
+    }
+    return r.prototype.getIndicatorAxes = function() {
+      return this._indicatorAxes;
+    }, r.prototype.dataToPoint = function(e, t) {
+      var a = this._indicatorAxes[t];
+      return this.coordToPoint(a.dataToCoord(e), t);
+    }, r.prototype.coordToPoint = function(e, t) {
+      var a = this._indicatorAxes[t], n = a.angle, l = this.cx + e * Math.cos(n), o = this.cy - e * Math.sin(n);
+      return [l, o];
+    }, r.prototype.pointToData = function(e) {
+      var t = e[0] - this.cx, a = e[1] - this.cy, n = Math.sqrt(t * t + a * a);
+      t /= n, a /= n;
+      for (var l = Math.atan2(-a, t), o = 1 / 0, i, p = -1, m = 0; m < this._indicatorAxes.length; m++) {
+        var v = this._indicatorAxes[m], A = Math.abs(l - v.angle);
+        A < o && (i = v, p = m, o = A);
+      }
+      return [p, +(i && i.coordToData(n))];
+    }, r.prototype.resize = function(e, t) {
+      var a = e.get("center"), n = t.getWidth(), l = t.getHeight(), o = Math.min(n, l) / 2;
+      this.cx = R(a[0], n), this.cy = R(a[1], l), this.startAngle = e.get("startAngle") * Math.PI / 180;
+      var i = e.get("radius");
+      (ae(i) || Te(i)) && (i = [0, i]), this.r0 = R(i[0], o), this.r = R(i[1], o), M(this._indicatorAxes, function(p, m) {
+        p.setExtent(this.r0, this.r);
+        var v = this.startAngle + m * Math.PI * 2 / this._indicatorAxes.length;
+        v = Math.atan2(Math.sin(v), Math.cos(v)), p.angle = v;
+      }, this);
+    }, r.prototype.update = function(e, t) {
+      var a = this._indicatorAxes, n = this._model;
+      M(a, function(i) {
+        i.scale.setExtent(1 / 0, -1 / 0);
+      }), e.eachSeriesByType("radar", function(i, p) {
+        if (!(i.get("coordinateSystem") !== "radar" || e.getComponent("radar", i.get("radarIndex")) !== n)) {
+          var m = i.getData();
+          M(a, function(v) {
+            v.scale.unionExtentFromData(m, m.mapDimension(v.dim));
+          });
+        }
+      }, this);
+      var l = n.get("splitNumber"), o = new H();
+      o.setExtent(0, l), o.setInterval(1), M(a, function(i, p) {
+        _e(i.scale, i.model, o);
+      });
+    }, r.prototype.convertToPixel = function(e, t, a) {
+      return console.warn("Not implemented."), null;
+    }, r.prototype.convertFromPixel = function(e, t, a) {
+      return console.warn("Not implemented."), null;
+    }, r.prototype.containPoint = function(e) {
+      return console.warn("Not implemented."), !1;
+    }, r.create = function(e, t) {
+      var a = [];
+      return e.eachComponent("radar", function(n) {
+        var l = new r(n, e, t);
+        a.push(l), n.coordinateSystem = l;
+      }), e.eachSeriesByType("radar", function(n) {
+        n.get("coordinateSystem") === "radar" && (n.coordinateSystem = a[n.get("radarIndex") || 0]);
+      }), a;
+    }, r.dimensions = [], r;
+  })()
+);
+function qe(r) {
+  r.registerCoordinateSystem("radar", $e), r.registerComponentModel(ze), r.registerComponentView(Fe), r.registerVisual({
+    seriesType: "radar",
+    reset: function(e) {
+      var t = e.getData();
+      t.each(function(a) {
+        t.setItemVisual(a, "legendIcon", "roundRect");
+      }), t.setVisual("legendIcon", "roundRect");
+    }
+  });
+}
+function Ze(r) {
+  oe(qe), r.registerChartView(Pe), r.registerSeriesModel(Re), r.registerLayout(Ee), r.registerProcessor(Ce("radar")), r.registerPreprocessor(Ge);
+}
+export {
+  Ze as i
+};