web-core-tcm 0.0.54 → 0.0.61

package/dist/node_modules/echarts/lib/component/helper/BrushController.js

@@ -0,0 +1,464 @@
+import { __extends as ar } from "../../../../tslib/tslib.es6.js";
+import { each as d, bind as ir, merge as H, clone as l, map as I, curry as c, defaults as ur } from "../../../../zrender/lib/core/util.js";
+import sr from "../../../../zrender/lib/core/Eventful.js";
+import { transformDirection as fr, getTransform as or } from "../../util/graphic.js";
+import { take as hr, release as vr } from "./interactionMutex.js";
+import gr from "../../data/DataDiffer.js";
+import P from "../../../../zrender/lib/graphic/Group.js";
+import dr from "../../../../zrender/lib/graphic/shape/Polygon.js";
+import pr from "../../../../zrender/lib/graphic/shape/Polyline.js";
+import N from "../../../../zrender/lib/graphic/shape/Rect.js";
+var _ = !0, y = Math.min, b = Math.max, _r = Math.pow, mr = 1e4, cr = 6, lr = 6, X = "globalPan", br = {
+  w: [0, 0],
+  e: [0, 1],
+  n: [1, 0],
+  s: [1, 1]
+}, Cr = {
+  w: "ew",
+  e: "ew",
+  n: "ns",
+  s: "ns",
+  ne: "nesw",
+  sw: "nesw",
+  nw: "nwse",
+  se: "nwse"
+}, Y = {
+  brushStyle: {
+    lineWidth: 2,
+    stroke: "rgba(210,219,238,0.3)",
+    fill: "#D2DBEE"
+  },
+  transformable: !0,
+  brushMode: "single",
+  removeOnClick: !1
+}, yr = 0, Xr = (
+  /** @class */
+  (function(r) {
+    ar(e, r);
+    function e(t) {
+      var n = r.call(this) || this;
+      return n._track = [], n._covers = [], n._handlers = {}, n._zr = t, n.group = new P(), n._uid = "brushController_" + yr++, d(Dr, function(a, i) {
+        this._handlers[i] = ir(a, this);
+      }, n), n;
+    }
+    return e.prototype.enableBrush = function(t) {
+      return this._brushType && this._doDisableBrush(), t.brushType && this._doEnableBrush(t), this;
+    }, e.prototype._doEnableBrush = function(t) {
+      var n = this._zr;
+      this._enableGlobalPan || hr(n, X, this._uid), d(this._handlers, function(a, i) {
+        n.on(i, a);
+      }), this._brushType = t.brushType, this._brushOption = H(l(Y), t, !0);
+    }, e.prototype._doDisableBrush = function() {
+      var t = this._zr;
+      vr(t, X, this._uid), d(this._handlers, function(n, a) {
+        t.off(a, n);
+      }), this._brushType = this._brushOption = null;
+    }, e.prototype.setPanels = function(t) {
+      if (t && t.length) {
+        var n = this._panels = {};
+        d(t, function(a) {
+          n[a.panelId] = l(a);
+        });
+      } else
+        this._panels = null;
+      return this;
+    }, e.prototype.mount = function(t) {
+      t = t || {}, this._enableGlobalPan = t.enableGlobalPan;
+      var n = this.group;
+      return this._zr.add(n), n.attr({
+        x: t.x || 0,
+        y: t.y || 0,
+        rotation: t.rotation || 0,
+        scaleX: t.scaleX || 1,
+        scaleY: t.scaleY || 1
+      }), this._transform = n.getLocalTransform(), this;
+    }, e.prototype.updateCovers = function(t) {
+      t = I(t, function(o) {
+        return H(l(Y), o, !0);
+      });
+      var n = "\0-brush-index-", a = this._covers, i = this._covers = [], u = this, s = this._creatingCover;
+      return new gr(a, t, v, f).add(g).update(g).remove(w).execute(), this;
+      function f(o, h) {
+        return (o.id != null ? o.id : n + h) + "-" + o.brushType;
+      }
+      function v(o, h) {
+        return f(o.__brushOption, h);
+      }
+      function g(o, h) {
+        var C = t[o];
+        if (h != null && a[h] === s)
+          i[o] = a[h];
+        else {
+          var R = i[o] = h != null ? (a[h].__brushOption = C, a[h]) : V(u, F(u, C));
+          z(u, R);
+        }
+      }
+      function w(o) {
+        a[o] !== s && u.group.remove(a[o]);
+      }
+    }, e.prototype.unmount = function() {
+      return this.enableBrush(!1), E(this), this._zr.remove(this.group), this;
+    }, e.prototype.dispose = function() {
+      this.unmount(), this.off();
+    }, e;
+  })(sr)
+);
+function F(r, e) {
+  var t = T[e.brushType].createCover(r, e);
+  return t.__brushOption = e, J(t, e), r.group.add(t), t;
+}
+function V(r, e) {
+  var t = k(e);
+  return t.endCreating && (t.endCreating(r, e), J(e, e.__brushOption)), e;
+}
+function $(r, e) {
+  var t = e.__brushOption;
+  k(e).updateCoverShape(r, e, t.range, t);
+}
+function J(r, e) {
+  var t = e.z;
+  t == null && (t = mr), r.traverse(function(n) {
+    n.z = t, n.z2 = t;
+  });
+}
+function z(r, e) {
+  k(e).updateCommon(r, e), $(r, e);
+}
+function k(r) {
+  return T[r.__brushOption.brushType];
+}
+function L(r, e, t) {
+  var n = r._panels;
+  if (!n)
+    return _;
+  var a, i = r._transform;
+  return d(n, function(u) {
+    u.isTargetByCursor(e, t, i) && (a = u);
+  }), a;
+}
+function Q(r, e) {
+  var t = r._panels;
+  if (!t)
+    return _;
+  var n = e.__brushOption.panelId;
+  return n != null ? t[n] : _;
+}
+function E(r) {
+  var e = r._covers, t = e.length;
+  return d(e, function(n) {
+    r.group.remove(n);
+  }, r), e.length = 0, !!t;
+}
+function m(r, e) {
+  var t = I(r._covers, function(n) {
+    var a = n.__brushOption, i = l(a.range);
+    return {
+      brushType: a.brushType,
+      panelId: a.panelId,
+      range: i
+    };
+  });
+  r.trigger("brush", {
+    areas: t,
+    isEnd: !!e.isEnd,
+    removeOnClick: !!e.removeOnClick
+  });
+}
+function wr(r) {
+  var e = r._track;
+  if (!e.length)
+    return !1;
+  var t = e[e.length - 1], n = e[0], a = t[0] - n[0], i = t[1] - n[1], u = _r(a * a + i * i, 0.5);
+  return u > cr;
+}
+function q(r) {
+  var e = r.length - 1;
+  return e < 0 && (e = 0), [r[0], r[e]];
+}
+function x(r, e, t, n) {
+  var a = new P();
+  return a.add(new N({
+    name: "main",
+    style: M(t),
+    silent: !0,
+    draggable: !0,
+    cursor: "move",
+    drift: c(W, r, e, a, ["n", "s", "w", "e"]),
+    ondragend: c(m, e, {
+      isEnd: !0
+    })
+  })), d(n, function(i) {
+    a.add(new N({
+      name: i.join(""),
+      style: {
+        opacity: 0
+      },
+      draggable: !0,
+      silent: !0,
+      invisible: !0,
+      drift: c(W, r, e, a, i),
+      ondragend: c(m, e, {
+        isEnd: !0
+      })
+    }));
+  }), a;
+}
+function rr(r, e, t, n) {
+  var a = n.brushStyle.lineWidth || 0, i = b(a, lr), u = t[0][0], s = t[1][0], f = u - a / 2, v = s - a / 2, g = t[0][1], w = t[1][1], o = g - i + a / 2, h = w - i + a / 2, C = g - u, R = w - s, G = C + a, U = R + a;
+  p(r, e, "main", u, s, C, R), n.transformable && (p(r, e, "w", f, v, i, U), p(r, e, "e", o, v, i, U), p(r, e, "n", f, v, G, i), p(r, e, "s", f, h, G, i), p(r, e, "nw", f, v, i, i), p(r, e, "ne", o, v, i, i), p(r, e, "sw", f, h, i, i), p(r, e, "se", o, h, i, i));
+}
+function O(r, e) {
+  var t = e.__brushOption, n = t.transformable, a = e.childAt(0);
+  a.useStyle(M(t)), a.attr({
+    silent: !n,
+    cursor: n ? "move" : "default"
+  }), d([["w"], ["e"], ["n"], ["s"], ["s", "e"], ["s", "w"], ["n", "e"], ["n", "w"]], function(i) {
+    var u = e.childOfName(i.join("")), s = i.length === 1 ? B(r, i[0]) : Tr(r, i);
+    u && u.attr({
+      silent: !n,
+      invisible: !n,
+      cursor: n ? Cr[s] + "-resize" : null
+    });
+  });
+}
+function p(r, e, t, n, a, i, u) {
+  var s = e.childOfName(t);
+  s && s.setShape(Or(A(r, e, [[n, a], [n + i, a + u]])));
+}
+function M(r) {
+  return ur({
+    strokeNoScale: !0
+  }, r.brushStyle);
+}
+function er(r, e, t, n) {
+  var a = [y(r, t), y(e, n)], i = [b(r, t), b(e, n)];
+  return [
+    [a[0], i[0]],
+    [a[1], i[1]]
+    // y range
+  ];
+}
+function Rr(r) {
+  return or(r.group);
+}
+function B(r, e) {
+  var t = {
+    w: "left",
+    e: "right",
+    n: "top",
+    s: "bottom"
+  }, n = {
+    left: "w",
+    right: "e",
+    top: "n",
+    bottom: "s"
+  }, a = fr(t[e], Rr(r));
+  return n[a];
+}
+function Tr(r, e) {
+  var t = [B(r, e[0]), B(r, e[1])];
+  return (t[0] === "e" || t[0] === "w") && t.reverse(), t.join("");
+}
+function W(r, e, t, n, a, i) {
+  var u = t.__brushOption, s = r.toRectRange(u.range), f = tr(e, a, i);
+  d(n, function(v) {
+    var g = br[v];
+    s[g[0]][g[1]] += f[g[0]];
+  }), u.range = r.fromRectRange(er(s[0][0], s[1][0], s[0][1], s[1][1])), z(e, t), m(e, {
+    isEnd: !1
+  });
+}
+function Er(r, e, t, n) {
+  var a = e.__brushOption.range, i = tr(r, t, n);
+  d(a, function(u) {
+    u[0] += i[0], u[1] += i[1];
+  }), z(r, e), m(r, {
+    isEnd: !1
+  });
+}
+function tr(r, e, t) {
+  var n = r.group, a = n.transformCoordToLocal(e, t), i = n.transformCoordToLocal(0, 0);
+  return [a[0] - i[0], a[1] - i[1]];
+}
+function A(r, e, t) {
+  var n = Q(r, e);
+  return n && n !== _ ? n.clipPath(t, r._transform) : l(t);
+}
+function Or(r) {
+  var e = y(r[0][0], r[1][0]), t = y(r[0][1], r[1][1]), n = b(r[0][0], r[1][0]), a = b(r[0][1], r[1][1]);
+  return {
+    x: e,
+    y: t,
+    width: n - e,
+    height: a - t
+  };
+}
+function Br(r, e, t) {
+  if (
+    // Check active
+    !(!r._brushType || Sr(r, e.offsetX, e.offsetY))
+  ) {
+    var n = r._zr, a = r._covers, i = L(r, e, t);
+    if (!r._dragging)
+      for (var u = 0; u < a.length; u++) {
+        var s = a[u].__brushOption;
+        if (i && (i === _ || s.panelId === i.panelId) && T[s.brushType].contain(a[u], t[0], t[1]))
+          return;
+      }
+    i && n.setCursorStyle("crosshair");
+  }
+}
+function D(r) {
+  var e = r.event;
+  e.preventDefault && e.preventDefault();
+}
+function S(r, e, t) {
+  return r.childOfName("main").contain(e, t);
+}
+function nr(r, e, t, n) {
+  var a = r._creatingCover, i = r._creatingPanel, u = r._brushOption, s;
+  if (r._track.push(t.slice()), wr(r) || a) {
+    if (i && !a) {
+      u.brushMode === "single" && E(r);
+      var f = l(u);
+      f.brushType = Z(f.brushType, i), f.panelId = i === _ ? null : i.panelId, a = r._creatingCover = F(r, f), r._covers.push(a);
+    }
+    if (a) {
+      var v = T[Z(r._brushType, i)], g = a.__brushOption;
+      g.range = v.getCreatingRange(A(r, a, r._track)), n && (V(r, a), v.updateCommon(r, a)), $(r, a), s = {
+        isEnd: n
+      };
+    }
+  } else n && u.brushMode === "single" && u.removeOnClick && L(r, e, t) && E(r) && (s = {
+    isEnd: n,
+    removeOnClick: !0
+  });
+  return s;
+}
+function Z(r, e) {
+  return r === "auto" ? e.defaultBrushType : r;
+}
+var Dr = {
+  mousedown: function(r) {
+    if (this._dragging)
+      j(this, r);
+    else if (!r.target || !r.target.draggable) {
+      D(r);
+      var e = this.group.transformCoordToLocal(r.offsetX, r.offsetY);
+      this._creatingCover = null;
+      var t = this._creatingPanel = L(this, r, e);
+      t && (this._dragging = !0, this._track = [e.slice()]);
+    }
+  },
+  mousemove: function(r) {
+    var e = r.offsetX, t = r.offsetY, n = this.group.transformCoordToLocal(e, t);
+    if (Br(this, r, n), this._dragging) {
+      D(r);
+      var a = nr(this, r, n, !1);
+      a && m(this, a);
+    }
+  },
+  mouseup: function(r) {
+    j(this, r);
+  }
+};
+function j(r, e) {
+  if (r._dragging) {
+    D(e);
+    var t = e.offsetX, n = e.offsetY, a = r.group.transformCoordToLocal(t, n), i = nr(r, e, a, !0);
+    r._dragging = !1, r._track = [], r._creatingCover = null, i && m(r, i);
+  }
+}
+function Sr(r, e, t) {
+  var n = r._zr;
+  return e < 0 || e > n.getWidth() || t < 0 || t > n.getHeight();
+}
+var T = {
+  lineX: K(0),
+  lineY: K(1),
+  rect: {
+    createCover: function(r, e) {
+      function t(n) {
+        return n;
+      }
+      return x({
+        toRectRange: t,
+        fromRectRange: t
+      }, r, e, [["w"], ["e"], ["n"], ["s"], ["s", "e"], ["s", "w"], ["n", "e"], ["n", "w"]]);
+    },
+    getCreatingRange: function(r) {
+      var e = q(r);
+      return er(e[1][0], e[1][1], e[0][0], e[0][1]);
+    },
+    updateCoverShape: function(r, e, t, n) {
+      rr(r, e, t, n);
+    },
+    updateCommon: O,
+    contain: S
+  },
+  polygon: {
+    createCover: function(r, e) {
+      var t = new P();
+      return t.add(new pr({
+        name: "main",
+        style: M(e),
+        silent: !0
+      })), t;
+    },
+    getCreatingRange: function(r) {
+      return r;
+    },
+    endCreating: function(r, e) {
+      e.remove(e.childAt(0)), e.add(new dr({
+        name: "main",
+        draggable: !0,
+        drift: c(Er, r, e),
+        ondragend: c(m, r, {
+          isEnd: !0
+        })
+      }));
+    },
+    updateCoverShape: function(r, e, t, n) {
+      e.childAt(0).setShape({
+        points: A(r, e, t)
+      });
+    },
+    updateCommon: O,
+    contain: S
+  }
+};
+function K(r) {
+  return {
+    createCover: function(e, t) {
+      return x({
+        toRectRange: function(n) {
+          var a = [n, [0, 100]];
+          return r && a.reverse(), a;
+        },
+        fromRectRange: function(n) {
+          return n[r];
+        }
+      }, e, t, [[["w"], ["e"]], [["n"], ["s"]]][r]);
+    },
+    getCreatingRange: function(e) {
+      var t = q(e), n = y(t[0][r], t[1][r]), a = b(t[0][r], t[1][r]);
+      return [n, a];
+    },
+    updateCoverShape: function(e, t, n, a) {
+      var i, u = Q(e, t);
+      if (u !== _ && u.getLinearBrushOtherExtent)
+        i = u.getLinearBrushOtherExtent(r);
+      else {
+        var s = e._zr;
+        i = [0, [s.getWidth(), s.getHeight()][1 - r]];
+      }
+      var f = [n, i];
+      r && f.reverse(), rr(e, t, f, a);
+    },
+    updateCommon: O,
+    contain: S
+  };
+}
+export {
+  Xr as default
+};

package/dist/node_modules/echarts/lib/component/helper/BrushTargetManager.js

@@ -0,0 +1,195 @@
+import { each as f, indexOf as d, createHashMap as N, curry as v, map as l } from "../../../../zrender/lib/core/util.js";
+import { getTransform as P } from "../../util/graphic.js";
+import { makeLinearBrushOtherExtent as _, makeRectIsTargetByCursor as B, makeRectPanelClipPath as L } from "./brushHelper.js";
+import { parseFinder as D } from "../../util/model.js";
+var R = ["grid", "xAxis", "yAxis", "geo", "graph", "polar", "radiusAxis", "angleAxis", "bmap"], X = (
+  /** @class */
+  (function() {
+    function i(e, n, t) {
+      var r = this;
+      this._targetInfoList = [];
+      var s = x(n, e);
+      f(b, function(o, a) {
+        (!t || !t.include || d(t.include, a) >= 0) && o(s, r._targetInfoList);
+      });
+    }
+    return i.prototype.setOutputRanges = function(e, n) {
+      return this.matchOutputRanges(e, n, function(t, r, s) {
+        if ((t.coordRanges || (t.coordRanges = [])).push(r), !t.coordRange) {
+          t.coordRange = r;
+          var o = g[t.brushType](0, s, r);
+          t.__rangeOffset = {
+            offset: I[t.brushType](o.values, t.range, [1, 1]),
+            xyMinMax: o.xyMinMax
+          };
+        }
+      }), e;
+    }, i.prototype.matchOutputRanges = function(e, n, t) {
+      f(e, function(r) {
+        var s = this.findTargetInfo(r, n);
+        s && s !== !0 && f(s.coordSyses, function(o) {
+          var a = g[r.brushType](1, o, r.range, !0);
+          t(r, a.values, o, n);
+        });
+      }, this);
+    }, i.prototype.setInputRanges = function(e, n) {
+      f(e, function(t) {
+        var r = this.findTargetInfo(t, n);
+        if (t.range = t.range || [], r && r !== !0) {
+          t.panelId = r.panelId;
+          var s = g[t.brushType](0, r.coordSys, t.coordRange), o = t.__rangeOffset;
+          t.range = o ? I[t.brushType](s.values, o.offset, E(s.xyMinMax, o.xyMinMax)) : s.values;
+        }
+      }, this);
+    }, i.prototype.makePanelOpts = function(e, n) {
+      return l(this._targetInfoList, function(t) {
+        var r = t.getPanelRect();
+        return {
+          panelId: t.panelId,
+          defaultBrushType: n ? n(t) : null,
+          clipPath: L(r),
+          isTargetByCursor: B(r, e, t.coordSysModel),
+          getLinearBrushOtherExtent: _(r)
+        };
+      });
+    }, i.prototype.controlSeries = function(e, n, t) {
+      var r = this.findTargetInfo(e, t);
+      return r === !0 || r && d(r.coordSyses, n.coordinateSystem) >= 0;
+    }, i.prototype.findTargetInfo = function(e, n) {
+      for (var t = this._targetInfoList, r = x(n, e), s = 0; s < t.length; s++) {
+        var o = t[s], a = e.panelId;
+        if (a) {
+          if (o.panelId === a)
+            return o;
+        } else
+          for (var u = 0; u < M.length; u++)
+            if (M[u](r, o))
+              return o;
+      }
+      return !0;
+    }, i;
+  })()
+);
+function h(i) {
+  return i[0] > i[1] && i.reverse(), i;
+}
+function x(i, e) {
+  return D(i, e, {
+    includeMainTypes: R
+  });
+}
+var b = {
+  grid: function(i, e) {
+    var n = i.xAxisModels, t = i.yAxisModels, r = i.gridModels, s = N(), o = {}, a = {};
+    !n && !t && !r || (f(n, function(u) {
+      var c = u.axis.grid.model;
+      s.set(c.id, c), o[c.id] = !0;
+    }), f(t, function(u) {
+      var c = u.axis.grid.model;
+      s.set(c.id, c), a[c.id] = !0;
+    }), f(r, function(u) {
+      s.set(u.id, u), o[u.id] = !0, a[u.id] = !0;
+    }), s.each(function(u) {
+      var c = u.coordinateSystem, p = [];
+      f(c.getCartesians(), function(y, k) {
+        (d(n, y.getAxis("x").model) >= 0 || d(t, y.getAxis("y").model) >= 0) && p.push(y);
+      }), e.push({
+        panelId: "grid--" + u.id,
+        gridModel: u,
+        coordSysModel: u,
+        // Use the first one as the representitive coordSys.
+        coordSys: p[0],
+        coordSyses: p,
+        getPanelRect: m.grid,
+        xAxisDeclared: o[u.id],
+        yAxisDeclared: a[u.id]
+      });
+    }));
+  },
+  geo: function(i, e) {
+    f(i.geoModels, function(n) {
+      var t = n.coordinateSystem;
+      e.push({
+        panelId: "geo--" + n.id,
+        geoModel: n,
+        coordSysModel: n,
+        coordSys: t,
+        coordSyses: [t],
+        getPanelRect: m.geo
+      });
+    });
+  }
+}, M = [
+  // grid
+  function(i, e) {
+    var n = i.xAxisModel, t = i.yAxisModel, r = i.gridModel;
+    return !r && n && (r = n.axis.grid.model), !r && t && (r = t.axis.grid.model), r && r === e.gridModel;
+  },
+  // geo
+  function(i, e) {
+    var n = i.geoModel;
+    return n && n === e.geoModel;
+  }
+], m = {
+  grid: function() {
+    return this.coordSys.master.getRect().clone();
+  },
+  geo: function() {
+    var i = this.coordSys, e = i.getBoundingRect().clone();
+    return e.applyTransform(P(i)), e;
+  }
+}, g = {
+  lineX: v(T, 0),
+  lineY: v(T, 1),
+  rect: function(i, e, n, t) {
+    var r = i ? e.pointToData([n[0][0], n[1][0]], t) : e.dataToPoint([n[0][0], n[1][0]], t), s = i ? e.pointToData([n[0][1], n[1][1]], t) : e.dataToPoint([n[0][1], n[1][1]], t), o = [h([r[0], s[0]]), h([r[1], s[1]])];
+    return {
+      values: o,
+      xyMinMax: o
+    };
+  },
+  polygon: function(i, e, n, t) {
+    var r = [[1 / 0, -1 / 0], [1 / 0, -1 / 0]], s = l(n, function(o) {
+      var a = i ? e.pointToData(o, t) : e.dataToPoint(o, t);
+      return r[0][0] = Math.min(r[0][0], a[0]), r[1][0] = Math.min(r[1][0], a[1]), r[0][1] = Math.max(r[0][1], a[0]), r[1][1] = Math.max(r[1][1], a[1]), a;
+    });
+    return {
+      values: s,
+      xyMinMax: r
+    };
+  }
+};
+function T(i, e, n, t) {
+  var r = n.getAxis(["x", "y"][i]), s = h(l([0, 1], function(a) {
+    return e ? r.coordToData(r.toLocalCoord(t[a]), !0) : r.toGlobalCoord(r.dataToCoord(t[a]));
+  })), o = [];
+  return o[i] = s, o[1 - i] = [NaN, NaN], {
+    values: s,
+    xyMinMax: o
+  };
+}
+var I = {
+  lineX: v(A, 0),
+  lineY: v(A, 1),
+  rect: function(i, e, n) {
+    return [[i[0][0] - n[0] * e[0][0], i[0][1] - n[0] * e[0][1]], [i[1][0] - n[1] * e[1][0], i[1][1] - n[1] * e[1][1]]];
+  },
+  polygon: function(i, e, n) {
+    return l(i, function(t, r) {
+      return [t[0] - n[0] * e[r][0], t[1] - n[1] * e[r][1]];
+    });
+  }
+};
+function A(i, e, n, t) {
+  return [e[0] - t[i] * n[0], e[1] - t[i] * n[1]];
+}
+function E(i, e) {
+  var n = S(i), t = S(e), r = [n[0] / t[0], n[1] / t[1]];
+  return isNaN(r[0]) && (r[0] = 1), isNaN(r[1]) && (r[1] = 1), r;
+}
+function S(i) {
+  return i ? [i[0][1] - i[0][0], i[1][1] - i[1][0]] : [NaN, NaN];
+}
+export {
+  X as default
+};