mixdashboards 1.0.32 → 1.0.39

package/dist/windLin-B7V4NUV8.js

@@ -0,0 +1,1226 @@
+var yn = Object.defineProperty, Mn = Object.defineProperties;
+var Sn = Object.getOwnPropertyDescriptors;
+var cn = Object.getOwnPropertySymbols;
+var An = Object.prototype.hasOwnProperty, Nn = Object.prototype.propertyIsEnumerable;
+var hn = (V, W, o) => W in V ? yn(V, W, { enumerable: !0, configurable: !0, writable: !0, value: o }) : V[W] = o, mn = (V, W) => {
+  for (var o in W || (W = {}))
+    An.call(W, o) && hn(V, o, W[o]);
+  if (cn)
+    for (var o of cn(W))
+      Nn.call(W, o) && hn(V, o, W[o]);
+  return V;
+}, dn = (V, W) => Mn(V, Sn(W));
+import { defineComponent as Cn, ref as Tn, inject as Pn, getCurrentInstance as In, computed as Ln, watchEffect as zn, openBlock as Fn, createElementBlock as Rn, normalizeStyle as gn, unref as $, createElementVNode as an, toDisplayString as Un, renderSlot as On, nextTick as Bn } from "vue";
+import { B as Kn, e as Wn, h as on, f as bn, u as Vn, p as Xn, j as Yn } from "./element-resize-detector-DJcsrJ8s.js";
+import { g as Hn } from "./titleStyle-BT5GlpAb.js";
+import { b as Gn, _ as Jn } from "./index-kShjySl9.js";
+import { A as Zn, D as Qn } from "./ele-aqi-icon-DsYfU5th.js";
+import { u as qn, i as wn, a as $n } from "./installCanvasRenderer-CLT2hquJ.js";
+import { i as jn } from "./install-BBrAry2m.js";
+import { i as kn } from "./install-B0x4IqQr.js";
+import { i as _n } from "./install-Cx1i_m0k.js";
+import { i as nr } from "./install-8XfFtnlL.js";
+import { i as rr } from "./install-oGjJ0_bF.js";
+import { i as er } from "./universalTransition-Bv7ibBUh.js";
+import { i as tr, d as ar } from "./echarts-BVht3HHb.js";
+var j = { exports: {} }, ir = j.exports, pn;
+function or() {
+  return pn || (pn = 1, (function(V, W) {
+    (function(f, n) {
+      V.exports = n();
+    })(ir, function() {
+      return (
+        /******/
+        (function(o) {
+          var f = {};
+          function n(t) {
+            if (f[t])
+              return f[t].exports;
+            var C = f[t] = {
+              /******/
+              exports: {},
+              /******/
+              id: t,
+              /******/
+              loaded: !1
+              /******/
+            };
+            return o[t].call(C.exports, C, C.exports, n), C.loaded = !0, C.exports;
+          }
+          return n.m = o, n.c = f, n.p = "", n(0);
+        })([
+          /* 0 */
+          /***/
+          (function(o, f, n) {
+            var t;
+            t = function(C) {
+              return {
+                clustering: n(1),
+                regression: n(5),
+                statistics: n(6),
+                histogram: n(15),
+                transform: {
+                  regression: n(18),
+                  histogram: n(21),
+                  clustering: n(22)
+                }
+              };
+            }.call(f, n, f, o), t !== void 0 && (o.exports = t);
+          }),
+          /* 1 */
+          /***/
+          (function(o, f, n) {
+            var t;
+            t = function(C) {
+              var d = n(2), A = d.dataPreprocess, E = d.normalizeDimensions, c = n(3), e = n(4), g = c.size, D = c.sumOfColumn, a = c.sum, y = c.zeros, e = n(4), l = e.isNumber, v = Math.pow, i = {
+                /**
+                 * Data are all in one. Cluster info are added as an attribute of data.
+                 * ```ts
+                 * type OutputDataSingle = {
+                 *     // Each index of `data` is the index of the input data.
+                 *     data: OutputDataItem[];
+                 *     // The index of `centroids` is the cluster index.
+                 *     centroids: [ValueOnX, ValueOnY][];
+                 * };
+                 * type InputDataItem = (ValueOnX | ValueOnY | OtherValue)[];
+                 * type OutputDataItem = (...InputDataItem | ClusterIndex | SquareDistanceToCentroid)[];
+                 * ```
+                 */
+                SINGLE: "single",
+                /**
+                 * Data are separated by cluster. Suitable for retrieving data form each cluster.
+                 * ```ts
+                 * type OutputDataMultiple = {
+                 *     // Each index of `clusterAssment` is the index of the input data.
+                 *     clusterAssment: [ClusterIndex, SquareDistanceToCentroid][];
+                 *     // The index of `centroids` is the cluster index.
+                 *     centroids: [ValueOnX, ValueOnY][];
+                 *     // The index of `pointsInCluster` is the cluster index.
+                 *     pointsInCluster: DataItemListInOneCluster[];
+                 * }
+                 * type DataItemListInOneCluster = InputDataItem[];
+                 * type InputDataItem = (ValueOnX | ValueOnY | OtherValue)[];
+                 * type SquareDistanceToCentroid = number;
+                 * type ClusterIndex = number;
+                 * type ValueOnX = number;
+                 * type ValueOnY = number;
+                 * type OtherValue = unknown;
+                 * ```
+                 */
+                MULTIPLE: "multiple"
+              };
+              function h(x, M, S) {
+                for (var L = y(x.length, 2), I = m(M, F(x, S.dimensions)), N = !0, z, P, U, O; N; ) {
+                  N = !1;
+                  for (var T = 0; T < x.length; T++) {
+                    z = 1 / 0, P = -1;
+                    for (var K = 0; K < M; K++)
+                      U = p(x[T], I[K], S), U < z && (z = U, P = K);
+                    L[T][0] !== P && (N = !0), L[T][0] = P, L[T][1] = z;
+                  }
+                  for (var T = 0; T < M; T++) {
+                    O = [];
+                    for (var K = 0; K < L.length; K++)
+                      L[K][0] === T && O.push(x[K]);
+                    I[T] = u(O, S);
+                  }
+                }
+                var Q = {
+                  centroids: I,
+                  clusterAssigned: L
+                };
+                return Q;
+              }
+              function u(x, M) {
+                for (var S = [], L, I, N = 0; N < M.dimensions.length; N++) {
+                  var z = M.dimensions[N];
+                  L = 0;
+                  for (var P = 0; P < x.length; P++)
+                    L += x[P][z];
+                  I = L / x.length, S.push(I);
+                }
+                return S;
+              }
+              function r(x, M, S) {
+                var L = (l(M) ? { clusterCount: M, stepByStep: S } : M) || { clusterCount: 2 }, I = L.clusterCount;
+                if (I < 2)
+                  return;
+                var N = R(x, L), z = N.outputType === i.SINGLE, P = A(x, { dimensions: N.dimensions }), U = y(P.length, 2), O, T, K;
+                function Q(b, J) {
+                  U[b][1] = J;
+                }
+                function X(b) {
+                  return U[b][1];
+                }
+                if (z) {
+                  O = [];
+                  var un = N.outputClusterIndexDimension;
+                  T = function(b, J) {
+                    O[b][un] = J;
+                  }, K = function(b) {
+                    return O[b][un];
+                  };
+                  for (var H = 0; H < P.length; H++)
+                    O.push(P[H].slice()), Q(H, 0), T(H, 0);
+                } else
+                  T = function(b, J) {
+                    U[b][0] = J;
+                  }, K = function(b) {
+                    return U[b][0];
+                  };
+                for (var ln = u(P, N), q = [ln], H = 0; H < P.length; H++) {
+                  var xn = p(P[H], ln, N);
+                  Q(H, xn);
+                }
+                var k, _, nn, w, rn, en, vn = 1, G = {
+                  data: O,
+                  centroids: q,
+                  isEnd: !1
+                };
+                z || (G.clusterAssment = U);
+                function fn() {
+                  if (vn < I) {
+                    k = 1 / 0;
+                    for (var b, J, Z, Y = 0; Y < q.length; Y++) {
+                      _ = [], nn = [];
+                      for (var B = 0; B < P.length; B++)
+                        K(B) === Y ? _.push(P[B]) : nn.push(X(B));
+                      w = h(_, 2, N), rn = D(w.clusterAssigned, 1), en = a(nn), rn + en < k && (k = en + rn, b = Y, J = w.centroids, Z = w.clusterAssigned);
+                    }
+                    for (var B = 0; B < Z.length; B++)
+                      Z[B][0] === 0 ? Z[B][0] = b : Z[B][0] === 1 && (Z[B][0] = q.length);
+                    q[b] = J[0], q.push(J[1]);
+                    for (var B = 0, Y = 0; B < P.length && Y < Z.length; B++)
+                      K(B) === b && (T(B, Z[Y][0]), Q(B, Z[Y++][1]));
+                    var tn = [];
+                    if (!z) {
+                      for (var B = 0; B < q.length; B++) {
+                        tn[B] = [];
+                        for (var Y = 0; Y < P.length; Y++)
+                          K(Y) === B && tn[B].push(P[Y]);
+                      }
+                      G.pointsInCluster = tn;
+                    }
+                    vn++;
+                  } else
+                    G.isEnd = !0;
+                }
+                if (L.stepByStep)
+                  G.next = function() {
+                    return fn(), s(G, N), G;
+                  };
+                else
+                  for (; fn(), !G.isEnd; ) ;
+                return s(G, N), G;
+              }
+              function s(x, M) {
+                var S = M.outputCentroidDimensions;
+                if (!(M.outputType !== i.SINGLE || S == null))
+                  for (var L = x.data, I = x.centroids, N = 0; N < L.length; N++)
+                    for (var z = L[N], P = z[M.outputClusterIndexDimension], U = I[P], O = Math.min(U.length, S.length), T = 0; T < O; T++)
+                      z[S[T]] = U[T];
+              }
+              function m(x, M) {
+                for (var S = y(x, M.length), L = 0; L < M.length; L++)
+                  for (var I = M[L], N = 0; N < x; N++)
+                    S[N][L] = I.min + I.span * Math.random();
+                return S;
+              }
+              function p(x, M, S) {
+                for (var L = 0, I = S.dimensions, N = S.rawExtents, z = 0; z < I.length; z++) {
+                  var P = N[z].span;
+                  if (P) {
+                    var U = I[z], O = (x[U] - M[z]) / P;
+                    L += v(O, 2);
+                  }
+                }
+                return L;
+              }
+              function R(x, M) {
+                var S = g(x);
+                if (S.length < 1)
+                  throw new Error("The input data of clustering should be two-dimension array.");
+                for (var L = S[1], I = [], N = 0; N < L; N++)
+                  I.push(N);
+                var z = E(M.dimensions, I), P = M.outputType || i.MULTIPLE, U = M.outputClusterIndexDimension;
+                if (P === i.SINGLE && !e.isNumber(U))
+                  throw new Error("outputClusterIndexDimension is required as a number.");
+                var O = F(x, z);
+                return {
+                  dimensions: z,
+                  rawExtents: O,
+                  outputType: P,
+                  outputClusterIndexDimension: U,
+                  outputCentroidDimensions: M.outputCentroidDimensions
+                };
+              }
+              function F(x, M) {
+                for (var S = [], L = M.length, I = 0; I < L; I++)
+                  S.push({ min: 1 / 0, max: -1 / 0 });
+                for (var I = 0; I < x.length; I++)
+                  for (var N = x[I], z = 0; z < L; z++) {
+                    var P = S[z], U = N[M[z]];
+                    P.min > U && (P.min = U), P.max < U && (P.max = U);
+                  }
+                for (var I = 0; I < L; I++)
+                  S[I].span = S[I].max - S[I].min;
+                return S;
+              }
+              return {
+                OutputType: i,
+                hierarchicalKMeans: r
+              };
+            }.call(f, n, f, o), t !== void 0 && (o.exports = t);
+          }),
+          /* 2 */
+          /***/
+          (function(o, f, n) {
+            var t;
+            t = function(C) {
+              var d = n(3), A = d.isArray, E = d.size, c = n(4), g = c.isNumber;
+              function D(e, l) {
+                return typeof e == "number" ? [e] : e == null ? l : e;
+              }
+              function a(e, l) {
+                l = l || {};
+                var v = l.dimensions, i = {};
+                if (v != null)
+                  for (var h = 0; h < v.length; h++)
+                    i[v[h]] = !0;
+                var u = l.toOneDimensionArray ? v ? v[0] : 0 : null;
+                function r(x) {
+                  return !v || i.hasOwnProperty(x);
+                }
+                if (!A(e))
+                  throw new Error("Invalid data type, you should input an array");
+                var s = [], m = E(e);
+                if (m.length === 1)
+                  for (var h = 0; h < m[0]; h++) {
+                    var p = e[h];
+                    g(p) && s.push(p);
+                  }
+                else if (m.length === 2)
+                  for (var h = 0; h < m[0]; h++) {
+                    for (var R = !0, p = e[h], F = 0; F < m[1]; F++)
+                      r(F) && !g(p[F]) && (R = !1);
+                    R && s.push(
+                      u != null ? p[u] : p
+                    );
+                  }
+                return s;
+              }
+              function y(e) {
+                var l = e.toString(), v = l.indexOf(".");
+                return v < 0 ? 0 : l.length - 1 - v;
+              }
+              return {
+                normalizeDimensions: D,
+                dataPreprocess: a,
+                getPrecision: y
+              };
+            }.call(f, n, f, o), t !== void 0 && (o.exports = t);
+          }),
+          /* 3 */
+          /***/
+          (function(o, f, n) {
+            var t;
+            t = function(C) {
+              var d = Object.prototype.toString, A = Array.prototype, E = A.map;
+              function c(i) {
+                for (var h = []; g(i); )
+                  h.push(i.length), i = i[0];
+                return h;
+              }
+              function g(i) {
+                return d.call(i) === "[object Array]";
+              }
+              function D(i, h) {
+                for (var u = [], r = 0; r < i; r++) {
+                  u[r] = [];
+                  for (var s = 0; s < h; s++)
+                    u[r][s] = 0;
+                }
+                return u;
+              }
+              function a(i) {
+                for (var h = 0, u = 0; u < i.length; u++)
+                  h += i[u];
+                return h;
+              }
+              function y(i, h) {
+                for (var u = 0, r = 0; r < i.length; r++)
+                  u += i[r][h];
+                return u;
+              }
+              function e(i, h) {
+                return i > h ? 1 : i < h ? -1 : i === h ? 0 : NaN;
+              }
+              function l(i, h, u, r) {
+                for (u == null && (u = 0), r == null && (r = i.length); u < r; ) {
+                  var s = Math.floor((u + r) / 2), m = e(i[s], h);
+                  if (m > 0)
+                    r = s;
+                  else if (m < 0)
+                    u = s + 1;
+                  else
+                    return s + 1;
+                }
+                return u;
+              }
+              function v(i, h, u) {
+                if (i && h) {
+                  if (i.map && i.map === E)
+                    return i.map(h, u);
+                  for (var r = [], s = 0, m = i.length; s < m; s++)
+                    r.push(h.call(u, i[s], s, i));
+                  return r;
+                }
+              }
+              return {
+                size: c,
+                isArray: g,
+                zeros: D,
+                sum: a,
+                sumOfColumn: y,
+                ascending: e,
+                bisect: l,
+                map: v
+              };
+            }.call(f, n, f, o), t !== void 0 && (o.exports = t);
+          }),
+          /* 4 */
+          /***/
+          (function(o, f, n) {
+            var t;
+            t = function(C) {
+              function d(c) {
+                return c = c === null ? NaN : +c, typeof c == "number" && !isNaN(c);
+              }
+              function A(c) {
+                return isFinite(c) && c === Math.round(c);
+              }
+              function E(c) {
+                if (c === 0)
+                  return 0;
+                var g = Math.floor(Math.log(c) / Math.LN10);
+                return c / Math.pow(10, g) >= 10 && g++, g;
+              }
+              return {
+                isNumber: d,
+                isInteger: A,
+                quantityExponent: E
+              };
+            }.call(f, n, f, o), t !== void 0 && (o.exports = t);
+          }),
+          /* 5 */
+          /***/
+          (function(o, f, n) {
+            var t;
+            t = function(C) {
+              var d = n(2), A = d.dataPreprocess, E = d.normalizeDimensions, c = {
+                /**
+                 * Common linear regression algorithm
+                 */
+                linear: function(a, y) {
+                  for (var e = y.dimensions[0], l = y.dimensions[1], v = 0, i = 0, h = 0, u = 0, r = a.length, s = 0; s < r; s++) {
+                    var m = a[s];
+                    v += m[e], i += m[l], h += m[e] * m[l], u += m[e] * m[e];
+                  }
+                  for (var p = (r * h - v * i) / (r * u - v * v), R = i / r - p * v / r, F = [], x = 0; x < a.length; x++) {
+                    var m = a[x], M = m.slice();
+                    M[e] = m[e], M[l] = p * m[e] + R, F.push(M);
+                  }
+                  var S = "y = " + Math.round(p * 100) / 100 + "x + " + Math.round(R * 100) / 100;
+                  return {
+                    points: F,
+                    parameter: {
+                      gradient: p,
+                      intercept: R
+                    },
+                    expression: S
+                  };
+                },
+                /**
+                 * If the raw data include [0,0] point, we should choose linearThroughOrigin
+                 *   instead of linear.
+                 */
+                linearThroughOrigin: function(a, y) {
+                  for (var e = y.dimensions[0], l = y.dimensions[1], v = 0, i = 0, h = 0; h < a.length; h++) {
+                    var u = a[h];
+                    v += u[e] * u[e], i += u[e] * u[l];
+                  }
+                  for (var r = i / v, s = [], m = 0; m < a.length; m++) {
+                    var u = a[m], p = u.slice();
+                    p[e] = u[e], p[l] = u[e] * r, s.push(p);
+                  }
+                  var R = "y = " + Math.round(r * 100) / 100 + "x";
+                  return {
+                    points: s,
+                    parameter: {
+                      gradient: r
+                    },
+                    expression: R
+                  };
+                },
+                /**
+                 * Exponential regression
+                 */
+                exponential: function(a, y) {
+                  for (var e = y.dimensions[0], l = y.dimensions[1], v = 0, i = 0, h = 0, u = 0, r = 0, s = 0, m = 0; m < a.length; m++) {
+                    var p = a[m];
+                    v += p[e], i += p[l], s += p[e] * p[l], h += p[e] * p[e] * p[l], u += p[l] * Math.log(p[l]), r += p[e] * p[l] * Math.log(p[l]);
+                  }
+                  for (var R = i * h - s * s, F = Math.pow(Math.E, (h * u - s * r) / R), x = (i * r - s * u) / R, M = [], S = 0; S < a.length; S++) {
+                    var p = a[S], L = p.slice();
+                    L[e] = p[e], L[l] = F * Math.pow(Math.E, x * p[e]), M.push(L);
+                  }
+                  var I = "y = " + Math.round(F * 100) / 100 + "e^(" + Math.round(x * 100) / 100 + "x)";
+                  return {
+                    points: M,
+                    parameter: {
+                      coefficient: F,
+                      index: x
+                    },
+                    expression: I
+                  };
+                },
+                /**
+                 * Logarithmic regression
+                 */
+                logarithmic: function(a, y) {
+                  for (var e = y.dimensions[0], l = y.dimensions[1], v = 0, i = 0, h = 0, u = 0, r = 0; r < a.length; r++) {
+                    var s = a[r];
+                    v += Math.log(s[e]), i += s[l] * Math.log(s[e]), h += s[l], u += Math.pow(Math.log(s[e]), 2);
+                  }
+                  for (var m = (r * i - h * v) / (r * u - v * v), p = (h - m * v) / r, R = [], F = 0; F < a.length; F++) {
+                    var s = a[F], x = s.slice();
+                    x[e] = s[e], x[l] = m * Math.log(s[e]) + p, R.push(x);
+                  }
+                  var M = "y = " + Math.round(p * 100) / 100 + " + " + Math.round(m * 100) / 100 + "ln(x)";
+                  return {
+                    points: R,
+                    parameter: {
+                      gradient: m,
+                      intercept: p
+                    },
+                    expression: M
+                  };
+                },
+                /**
+                 * Polynomial regression
+                 */
+                polynomial: function(a, y) {
+                  var e = y.dimensions[0], l = y.dimensions[1], v = y.order;
+                  v == null && (v = 2);
+                  for (var i = [], h = [], u = v + 1, r = 0; r < u; r++) {
+                    for (var s = 0, m = 0; m < a.length; m++) {
+                      var p = a[m];
+                      s += p[l] * Math.pow(p[e], r);
+                    }
+                    h.push(s);
+                    for (var R = [], F = 0; F < u; F++) {
+                      for (var x = 0, M = 0; M < a.length; M++)
+                        x += Math.pow(a[M][e], r + F);
+                      R.push(x);
+                    }
+                    i.push(R);
+                  }
+                  i.push(h);
+                  for (var S = g(i, u), L = [], r = 0; r < a.length; r++) {
+                    for (var I = 0, p = a[r], m = 0; m < S.length; m++)
+                      I += S[m] * Math.pow(p[e], m);
+                    var N = p.slice();
+                    N[e] = p[e], N[l] = I, L.push(N);
+                  }
+                  for (var z = "y = ", r = S.length - 1; r >= 0; r--)
+                    r > 1 ? z += Math.round(S[r] * Math.pow(10, r + 1)) / Math.pow(10, r + 1) + "x^" + r + " + " : r === 1 ? z += Math.round(S[r] * 100) / 100 + "x + " : z += Math.round(S[r] * 100) / 100;
+                  return {
+                    points: L,
+                    parameter: S,
+                    expression: z
+                  };
+                }
+              };
+              function g(a, y) {
+                for (var e = 0; e < a.length - 1; e++) {
+                  for (var l = e, v = e + 1; v < a.length - 1; v++)
+                    Math.abs(a[e][v]) > Math.abs(a[e][l]) && (l = v);
+                  for (var i = e; i < a.length; i++) {
+                    var h = a[i][e];
+                    a[i][e] = a[i][l], a[i][l] = h;
+                  }
+                  for (var u = e + 1; u < a.length - 1; u++)
+                    for (var r = a.length - 1; r >= e; r--)
+                      a[r][u] -= a[r][e] / a[e][e] * a[e][u];
+                }
+                for (var s = new Array(y), m = a.length - 1, v = a.length - 2; v >= 0; v--) {
+                  for (var h = 0, e = v + 1; e < a.length - 1; e++)
+                    h += a[e][v] * s[e];
+                  s[v] = (a[m][v] - h) / a[v][v];
+                }
+                return s;
+              }
+              var D = function(a, y, e) {
+                var l = typeof e == "number" ? { order: e } : e || {}, v = E(l.dimensions, [0, 1]), i = A(y, { dimensions: v }), h = c[a](i, {
+                  order: l.order,
+                  dimensions: v
+                }), u = v[0];
+                return h.points.sort(function(r, s) {
+                  return r[u] - s[u];
+                }), h;
+              };
+              return D;
+            }.call(f, n, f, o), t !== void 0 && (o.exports = t);
+          }),
+          /* 6 */
+          /***/
+          (function(o, f, n) {
+            var t;
+            t = function(C) {
+              var d = {};
+              return d.max = n(7), d.deviation = n(8), d.mean = n(10), d.median = n(12), d.min = n(14), d.quantile = n(13), d.sampleVariance = n(9), d.sum = n(11), d;
+            }.call(f, n, f, o), t !== void 0 && (o.exports = t);
+          }),
+          /* 7 */
+          /***/
+          (function(o, f, n) {
+            var t;
+            t = function(C) {
+              var d = n(4), A = d.isNumber;
+              function E(c) {
+                for (var g = -1 / 0, D = 0; D < c.length; D++)
+                  A(c[D]) && c[D] > g && (g = c[D]);
+                return g;
+              }
+              return E;
+            }.call(f, n, f, o), t !== void 0 && (o.exports = t);
+          }),
+          /* 8 */
+          /***/
+          (function(o, f, n) {
+            var t;
+            t = function(C) {
+              var d = n(9);
+              return function(A) {
+                var E = d(A);
+                return E && Math.sqrt(E);
+              };
+            }.call(f, n, f, o), t !== void 0 && (o.exports = t);
+          }),
+          /* 9 */
+          /***/
+          (function(o, f, n) {
+            var t;
+            t = function(C) {
+              var d = n(4), A = d.isNumber, E = n(10);
+              function c(g) {
+                var D = g.length;
+                if (!D || D < 2)
+                  return 0;
+                if (g.length >= 2) {
+                  for (var a = E(g), y = 0, e, l = 0; l < g.length; l++)
+                    A(g[l]) && (e = g[l] - a, y += e * e);
+                  return y / (g.length - 1);
+                }
+              }
+              return c;
+            }.call(f, n, f, o), t !== void 0 && (o.exports = t);
+          }),
+          /* 10 */
+          /***/
+          (function(o, f, n) {
+            var t;
+            t = function(C) {
+              var d = n(11);
+              function A(E) {
+                var c = E.length;
+                return c ? d(E) / E.length : 0;
+              }
+              return A;
+            }.call(f, n, f, o), t !== void 0 && (o.exports = t);
+          }),
+          /* 11 */
+          /***/
+          (function(o, f, n) {
+            var t;
+            t = function(C) {
+              var d = n(4), A = d.isNumber;
+              function E(c) {
+                var g = c.length;
+                if (!g)
+                  return 0;
+                for (var D = 0, a = 0; a < g; a++)
+                  A(c[a]) && (D += c[a]);
+                return D;
+              }
+              return E;
+            }.call(f, n, f, o), t !== void 0 && (o.exports = t);
+          }),
+          /* 12 */
+          /***/
+          (function(o, f, n) {
+            var t;
+            t = function(C) {
+              var d = n(13);
+              function A(E) {
+                return d(E, 0.5);
+              }
+              return A;
+            }.call(f, n, f, o), t !== void 0 && (o.exports = t);
+          }),
+          /* 13 */
+          /***/
+          (function(o, f, n) {
+            var t;
+            t = function(C) {
+              return function(d, A) {
+                var E = d.length;
+                if (!E)
+                  return 0;
+                if (A <= 0 || E < 2)
+                  return d[0];
+                if (A >= 1)
+                  return d[E - 1];
+                var c = (E - 1) * A, g = Math.floor(c), D = d[g], a = d[g + 1];
+                return D + (a - D) * (c - g);
+              };
+            }.call(f, n, f, o), t !== void 0 && (o.exports = t);
+          }),
+          /* 14 */
+          /***/
+          (function(o, f, n) {
+            var t;
+            t = function(C) {
+              var d = n(4), A = d.isNumber;
+              function E(c) {
+                for (var g = 1 / 0, D = 0; D < c.length; D++)
+                  A(c[D]) && c[D] < g && (g = c[D]);
+                return g;
+              }
+              return E;
+            }.call(f, n, f, o), t !== void 0 && (o.exports = t);
+          }),
+          /* 15 */
+          /***/
+          (function(o, f, n) {
+            var t;
+            t = function(C) {
+              var d = n(7), A = n(14), E = n(13), c = n(8), g = n(2), D = g.dataPreprocess, a = g.normalizeDimensions, y = n(3), e = y.ascending, l = y.map, v = n(16), i = y.bisect, h = n(17);
+              function u(K, m) {
+                for (var p = typeof m == "string" ? { method: m } : m || {}, R = p.method == null ? r.squareRoot : r[p.method], F = a(p.dimensions), x = D(K, {
+                  dimensions: F,
+                  toOneDimensionArray: !0
+                }), M = d(x), S = A(x), L = R(x, S, M), I = h(S, M, L), N = I.step, z = I.toFixedPrecision, P = v(
+                  // use function toFixed() to avoid data like '0.700000001'
+                  +(Math.ceil(S / N) * N).toFixed(z),
+                  +(Math.floor(M / N) * N).toFixed(z),
+                  N,
+                  z
+                ), U = P.length, O = new Array(U + 1), T = 0; T <= U; T++)
+                  O[T] = {}, O[T].sample = [], O[T].x0 = T > 0 ? P[T - 1] : P[T] - S === N ? S : P[T] - N, O[T].x1 = T < U ? P[T] : M - P[T - 1] === N ? M : P[T - 1] + N;
+                for (var T = 0; T < x.length; T++)
+                  S <= x[T] && x[T] <= M && O[i(P, x[T], 0, U)].sample.push(x[T]);
+                var K = l(O, function(X) {
+                  return [
+                    +((X.x0 + X.x1) / 2).toFixed(z),
+                    X.sample.length,
+                    X.x0,
+                    X.x1,
+                    X.x0 + " - " + X.x1
+                  ];
+                }), Q = l(O, function(X) {
+                  return [X.x0, X.x1, X.sample.length];
+                });
+                return {
+                  bins: O,
+                  data: K,
+                  customData: Q
+                };
+              }
+              var r = {
+                squareRoot: function(s) {
+                  var m = Math.ceil(Math.sqrt(s.length));
+                  return m > 50 ? 50 : m;
+                },
+                scott: function(s, m, p) {
+                  return Math.ceil((p - m) / (3.5 * c(s) * Math.pow(s.length, -1 / 3)));
+                },
+                freedmanDiaconis: function(s, m, p) {
+                  return s.sort(e), Math.ceil(
+                    (p - m) / (2 * (E(s, 0.75) - E(s, 0.25)) * Math.pow(s.length, -1 / 3))
+                  );
+                },
+                sturges: function(s) {
+                  return Math.ceil(Math.log(s.length) / Math.LN2) + 1;
+                }
+              };
+              return u;
+            }.call(f, n, f, o), t !== void 0 && (o.exports = t);
+          }),
+          /* 16 */
+          /***/
+          (function(o, f, n) {
+            var t;
+            t = function(C) {
+              var d = n(2), A = d.getPrecision;
+              return function(E, c, g, D) {
+                var a = arguments.length;
+                a < 2 ? (c = E, E = 0, g = 1) : a < 3 ? g = 1 : a < 4 ? (g = +g, D = A(g)) : D = +D;
+                for (var y = Math.ceil(((c - E) / g).toFixed(D)), e = new Array(y + 1), l = 0; l < y + 1; l++)
+                  e[l] = +(E + l * g).toFixed(D);
+                return e;
+              };
+            }.call(f, n, f, o), t !== void 0 && (o.exports = t);
+          }),
+          /* 17 */
+          /***/
+          (function(o, f, n) {
+            var t;
+            t = function(C) {
+              var d = n(4);
+              return function(A, E, c) {
+                var g = Math.abs(E - A) / c, D = d.quantityExponent(g), a = Math.pow(10, D), y = g / a;
+                y >= Math.sqrt(50) ? a *= 10 : y >= Math.sqrt(10) ? a *= 5 : y >= Math.sqrt(2) && (a *= 2);
+                var e = D < 0 ? -D : 0, l = +(E >= A ? a : -a).toFixed(e);
+                return {
+                  step: l,
+                  toFixedPrecision: e
+                };
+              };
+            }.call(f, n, f, o), t !== void 0 && (o.exports = t);
+          }),
+          /* 18 */
+          /***/
+          (function(o, f, n) {
+            var t;
+            t = function(C) {
+              var d = n(5), A = n(19), E = 2;
+              return {
+                type: "ecStat:regression",
+                /**
+                 * @param {Paramter<typeof regression>[0]} [params.config.method='linear'] 'linear' by default
+                 * @param {Paramter<typeof regression>[2]} [params.config.order=2] Only work when method is `polynomial`.
+                 * @param {DimensionLoose[]|DimensionLoose} [params.config.dimensions=[0, 1]] dimensions that used to calculate regression.
+                 *        By default [0, 1].
+                 * @param {'start' | 'end' | 'all'} params.config.formulaOn Include formula on the last (third) dimension of the:
+                 *        'start': first data item.
+                 *        'end': last data item (by default).
+                 *        'all': all data items.
+                 *        'none': no data item.
+                 */
+                transform: function(g) {
+                  var D = g.upstream, a = g.config || {}, y = a.method || "linear", e = d(y, D.cloneRawData(), {
+                    order: a.order,
+                    dimensions: A.normalizeExistingDimensions(g, a.dimensions)
+                  }), l = e.points, v = a.formulaOn;
+                  v == null && (v = "end");
+                  var i;
+                  if (v !== "none") {
+                    for (var h = 0; h < l.length; h++)
+                      l[h][E] = v === "start" && h === 0 || v === "all" || v === "end" && h === l.length - 1 ? e.expression : "";
+                    i = D.cloneAllDimensionInfo(), i[E] = {};
+                  }
+                  return [{
+                    dimensions: i,
+                    data: l
+                  }];
+                }
+              };
+            }.call(f, n, f, o), t !== void 0 && (o.exports = t);
+          }),
+          /* 19 */
+          /***/
+          (function(o, f, n) {
+            var t;
+            t = function(C) {
+              var d = n(3), A = n(4), E = n(20);
+              function c(D, a) {
+                if (a == null)
+                  return;
+                var y = D.upstream;
+                if (d.isArray(a)) {
+                  for (var e = [], l = 0; l < a.length; l++) {
+                    var v = y.getDimensionInfo(a[l]);
+                    i(v, a[l]), e[l] = v.index;
+                  }
+                  return e;
+                } else {
+                  var v = y.getDimensionInfo(a);
+                  return i(v, a), v.index;
+                }
+                function i(h, u) {
+                  if (!h)
+                    throw new Error("Can not find dimension by " + u);
+                }
+              }
+              function g(D) {
+                if (d.isArray(D)) {
+                  for (var a = [], y = [], e = 0; e < D.length; e++) {
+                    var l = v(D[e]);
+                    a.push(l.name), y.push(l.index);
+                  }
+                  return { name: a, index: y };
+                } else if (D != null)
+                  return v(D);
+                function v(i) {
+                  if (A.isNumber(i))
+                    return { index: i };
+                  if (E.isObject(i) && A.isNumber(i.index))
+                    return i;
+                  throw new Error("Illegle new dimensions config. Expect `{ name: string, index: number }`.");
+                }
+              }
+              return {
+                normalizeExistingDimensions: c,
+                normalizeNewDimensions: g
+              };
+            }.call(f, n, f, o), t !== void 0 && (o.exports = t);
+          }),
+          /* 20 */
+          /***/
+          (function(o, f, n) {
+            var t;
+            t = function(C) {
+              function d(E, c) {
+                if (Object.assign)
+                  Object.assign(E, c);
+                else
+                  for (var g in c)
+                    c.hasOwnProperty(g) && (E[g] = c[g]);
+                return E;
+              }
+              function A(E) {
+                const c = typeof E;
+                return c === "function" || !!E && c === "object";
+              }
+              return {
+                extend: d,
+                isObject: A
+              };
+            }.call(f, n, f, o), t !== void 0 && (o.exports = t);
+          }),
+          /* 21 */
+          /***/
+          (function(o, f, n) {
+            var t;
+            t = function(C) {
+              var d = n(15), A = n(19);
+              return {
+                type: "ecStat:histogram",
+                /**
+                 * @param {'squareRoot' | 'scott' | 'freedmanDiaconis' | 'sturges'} [params.config.method='squareRoot']
+                 * @param {DimnensionLoose[]} [params.config.dimensions=[0, 1]] dimensions that used to calculate histogram.
+                 *        By default [0].
+                 */
+                transform: function(c) {
+                  var g = c.upstream, D = c.config || {}, a = d(g.cloneRawData(), {
+                    method: D.method,
+                    dimensions: A.normalizeExistingDimensions(c, D.dimensions)
+                  });
+                  return [{
+                    dimensions: ["MeanOfV0V1", "VCount", "V0", "V1", "DisplayableName"],
+                    data: a.data
+                  }, {
+                    data: a.customData
+                  }];
+                }
+              };
+            }.call(f, n, f, o), t !== void 0 && (o.exports = t);
+          }),
+          /* 22 */
+          /***/
+          (function(o, f, n) {
+            var t;
+            t = function(C) {
+              var d = n(1), A = n(4), E = n(19), c = A.isNumber;
+              return {
+                type: "ecStat:clustering",
+                /**
+                 * @param {number} params.config.clusterCount Mandatory.
+                 *        The number of clusters in a dataset. It has to be greater than 1.
+                 * @param {(DimensionName | DimensionIndex)[]} [params.config.dimensions] Optional.
+                 *        Target dimensions to calculate the regression.
+                 *        By default: use all of the data.
+                 * @param {(DimensionIndex | {name?: DimensionName, index: DimensionIndex})} [params.config.outputClusterIndexDimension] Mandatory.
+                 * @param {(DimensionIndex | {name?: DimensionName, index: DimensionIndex})[]} [params.config.outputCentroidDimensions] Optional.
+                 *        If specified, the centroid will be set to those dimensions of the result data one by one.
+                 *        By default not set centroid to result.
+                 */
+                transform: function(D) {
+                  var a = D.upstream, y = D.config || {}, e = y.clusterCount;
+                  if (!c(e) || e <= 0)
+                    throw new Error('config param "clusterCount" need to be specified as an interger greater than 1.');
+                  if (e === 1)
+                    return [{}, {
+                      data: []
+                    }];
+                  var l = E.normalizeNewDimensions(
+                    y.outputClusterIndexDimension
+                  ), v = E.normalizeNewDimensions(
+                    y.outputCentroidDimensions
+                  );
+                  if (l == null)
+                    throw new Error("outputClusterIndexDimension is required as a number.");
+                  for (var i = d.hierarchicalKMeans(a.cloneRawData(), {
+                    clusterCount: e,
+                    stepByStep: !1,
+                    dimensions: E.normalizeExistingDimensions(D, y.dimensions),
+                    outputType: d.OutputType.SINGLE,
+                    outputClusterIndexDimension: l.index,
+                    outputCentroidDimensions: (v || {}).index
+                  }), h = a.cloneAllDimensionInfo(), u = [], r = 0; r < h.length; r++) {
+                    var s = h[r];
+                    u.push(s.name);
+                  }
+                  if (u[l.index] = l.name, v)
+                    for (var r = 0; r < v.index.length; r++)
+                      v.name[r] != null && (u[v.index[r]] = v.name[r]);
+                  return [{
+                    dimensions: u,
+                    data: i.data
+                  }, {
+                    data: i.centroids
+                  }];
+                }
+              };
+            }.call(f, n, f, o), t !== void 0 && (o.exports = t);
+          })
+          /******/
+        ])
+      );
+    });
+  })(j)), j.exports;
+}
+var sn, En;
+function sr() {
+  return En || (En = 1, sn = or()), sn;
+}
+var ur = sr();
+const lr = /* @__PURE__ */ Gn(ur), vr = {
+  DEFAULT_ICON: Qn,
+  ACTIVE_ICON: Zn,
+  NAME_CN: "风向图",
+  NAME_EN: "Wind Line",
+  ORDER: 5
+}, fr = {
+  titleColor: "#111",
+  bgColor: "#fff",
+  textColor: "#111",
+  lineColor: "#314656",
+  top: 30,
+  bottom: 40,
+  left: 20,
+  right: 20,
+  radiusSize: 8,
+  textSize: 12,
+  points: 30,
+  isHideTitle: !1,
+  isSmooth: !1
+}, Dn = [{ name: "参数一", 项目编号: "", object_id: "" }], cr = ["name", "项目编号"], hr = ["index", "deviation", "stability", "balance", "increment", "risk"], mr = 1, dr = {
+  useAlias: !1,
+  null: { type: "0", value: "" },
+  multiObject: !1,
+  hideMultiObject: !0,
+  source: "index"
+}, gr = { DEFAULT: vr, OPTIONS: fr, DATA: Dn, PARAMS: cr, SOURCE: hr, ITEMS: mr, COMMON: dr }, pr = /* @__PURE__ */ Cn(dn(mn({}, gr), {
+  __name: "windLin",
+  props: {
+    conf: { type: Object, default: () => ({ data: [] }) },
+    uid: { type: String, default: "" },
+    mode: { type: String, default: "edit" },
+    theme: { type: String, default: "light" }
+  },
+  setup(V) {
+    qn([wn, jn, kn, _n, nr, rr, $n, er]);
+    const W = Tn(Pn("session", null)), { proxy: o } = In(), f = "windlin_" + Math.random().toString(16).substring(4, 12);
+    let n = null, t = null;
+    const C = V;
+    let d = [];
+    class A extends Kn {
+      extractStyles() {
+        return {
+          bgColor: this.getOptionValue("bgColor", "#fff"),
+          titleColor: this.getOptionValue("titleColor", "#111"),
+          textColor: this.getOptionValue("textColor", "#111"),
+          lineColor: this.getOptionValue("lineColor", "#314656"),
+          radiusSize: this.getOptionValue("radiusSize", 4),
+          textSize: this.getOptionValue("textSize", 12),
+          isHideTitle: this.getOptionValue("isHideTitle", !1),
+          isSmooth: this.getOptionValue("isSmooth", !1)
+        };
+      }
+      init() {
+        super.init(), this.props.conf.data = this.props.conf.data.length ? this.props.conf.data : Dn, C.mode === "edit" && a(), Bn(() => {
+          let r = document.querySelector("#" + f);
+          r && (n || (n = tr(r), t = Wn({ strategy: "scroll" }), t.listenTo(r, () => n == null ? void 0 : n.resize())), n.setOption(D(), !0));
+        });
+      }
+      onPreview() {
+        i.preview();
+      }
+      cleanup() {
+        t && t.uninstall(document.querySelector("#" + f)), n && n.clear(), n && ar(n), n = null, i.unregister();
+      }
+    }
+    const E = new A(C, "windLin");
+    E.setupLifecycle();
+    const c = E.getStyle(), g = Ln(() => Hn(C.conf.options)), D = () => {
+      var m, p, R, F;
+      const { data: u, options: r } = C.conf;
+      let s = u[0] || {};
+      return {
+        tooltip: {
+          trigger: "axis",
+          formatter: function(x) {
+            return [x[0].value[0], `${s == null ? void 0 : s.name}: ` + x[0].value[1], `${o.$t("setting.gradient")}: ` + x[0].value[2]].join("<br>");
+          }
+        },
+        grid: {
+          top: ((m = r == null ? void 0 : r.top) == null ? void 0 : m.value) || 30,
+          bottom: ((p = r == null ? void 0 : r.bottom) == null ? void 0 : p.value) || 40,
+          left: ((R = r == null ? void 0 : r.left) == null ? void 0 : R.value) || 20,
+          right: ((F = r == null ? void 0 : r.right) == null ? void 0 : F.value) || 20,
+          containLabel: !0
+        },
+        xAxis: {
+          type: "time",
+          splitLine: { lineStyle: { color: "#ddd" } }
+        },
+        yAxis: [{
+          axisLine: { lineStyle: { color: "#666" } },
+          splitNumber: 4
+        }],
+        visualMap: {
+          type: "piecewise",
+          show: !1,
+          orient: "horizontal",
+          left: "center",
+          bottom: 10,
+          pieces: [
+            { lt: 0, color: "#18BF12" },
+            { gte: 0, lte: 0, color: "#f4e9a3" },
+            { gte: 0, color: "#D33C3E" }
+          ],
+          seriesIndex: 1,
+          dimension: 2
+        },
+        dataZoom: [
+          { type: "slider", xAxisIndex: 0, start: 80, end: 100, height: 15, bottom: 15 },
+          { type: "inside" }
+        ],
+        series: [
+          {
+            type: "line",
+            yAxisIndex: 0,
+            showSymbol: !1,
+            emphasis: { scale: !1 },
+            symbolSize: 10,
+            areaStyle: {
+              color: {
+                type: "linear",
+                x: 0,
+                y: 0,
+                x2: 0,
+                y2: 1,
+                global: !1,
+                colorStops: [
+                  { offset: 0, color: c.value.lineColor },
+                  { offset: 1, color: c.value.lineColor + "00" }
+                ]
+              }
+            },
+            lineStyle: { color: c.value.lineColor },
+            itemStyle: { color: c.value.lineColor },
+            encode: { x: 0 },
+            data: d,
+            z: 2,
+            smooth: c.value.isSmooth
+          },
+          {
+            type: "custom",
+            renderItem: e,
+            data: d,
+            z: 10
+          }
+        ]
+      };
+    }, a = () => {
+      var R, F;
+      const u = on(C.conf);
+      d = [];
+      let r = [];
+      const { options: s } = C.conf;
+      let m = (F = (R = s == null ? void 0 : s.points) == null ? void 0 : R.value) != null ? F : 30, p = bn(m, C.mode, u);
+      for (let x = 0; x < m; x++) {
+        let M = Math.floor(Math.random() * 200);
+        r.push([p[x], M]);
+      }
+      d = y(r);
+    }, y = (u) => u.map((r, s) => {
+      var m;
+      if (s === u.length - 1)
+        r[2] = 0;
+      else {
+        let p = lr.regression("linear", [
+          [s + 1, r[1]],
+          [s + 2, u[s + 1][1]]
+        ], 0);
+        r[2] = Math.atan(((m = p.parameter) == null ? void 0 : m.gradient) || 0).toFixed(4);
+      }
+      return r;
+    }), e = (u, r) => {
+      const s = r.coord([r.value(0), 0]), m = 16;
+      return {
+        type: "path",
+        shape: {
+          pathData: "M31 16l-15-15v9h-26v12h26v9z",
+          x: -m / 2,
+          y: -m / 2,
+          width: m,
+          height: m
+        },
+        rotation: r.value(2),
+        position: s,
+        style: r.style({ stroke: "#555", lineWidth: 1 })
+      };
+    }, l = (u) => {
+      if (!on(C.conf)) return;
+      const { data: r } = C.conf;
+      let s = Yn(u, C, "history");
+      if (!s.history.length) return;
+      let m = s.history[0], p = [];
+      m.forEach((R) => {
+        let F = R[r[0].fv] || 0;
+        p.push([R.time, F]);
+      }), d = y(p), n == null || n.setOption(D());
+    }, v = (u) => {
+      on(C.conf);
+    }, i = {
+      preview: () => Xn(C, W.value, l, v, "windLin"),
+      unregister: () => Vn(C, W.value)
+    };
+    zn(() => {
+      C.conf.socketData && v(C.conf.socketData);
+    });
+    const h = C.conf;
+    return (u, r) => (Fn(), Rn("div", {
+      class: "mix-component",
+      style: gn({ background: $(c).bgColor, borderRadius: `${$(c).radiusSize}px` })
+    }, [
+      an("div", {
+        class: "mix-title",
+        style: gn(g.value)
+      }, Un($(h).caption || $(h).name), 5),
+      an("div", { class: "mix-body" }, [
+        an("div", {
+          class: "w-full h-full",
+          id: f
+        })
+      ]),
+      On(u.$slots, "default", {}, void 0, !0)
+    ], 4));
+  }
+})), Fr = /* @__PURE__ */ Jn(pr, [["__scopeId", "data-v-a9a859ce"]]);
+export {
+  Fr as default
+};