web-core-tcm 0.0.54 → 0.0.61

package/dist/node_modules/echarts/lib/component/axis/AxisBuilder.js

@@ -0,0 +1,294 @@
+import { defaults as B, retrieve as D, map as et, extend as at, isString as W, each as E, isObject as rt, retrieve2 as C, isFunction as nt, isNumber as it } from "../../../../zrender/lib/core/util.js";
+import { setTooltipConfig as j, subPixelOptimizeLine as z } from "../../util/graphic.js";
+import { getECData as Z } from "../../util/innerStore.js";
+import { createTextStyle as q } from "../../label/labelStyle.js";
+import lt from "../../model/Model.js";
+import { remRadian as J, isRadianAroundZero as R } from "../../util/number.js";
+import { normalizeSymbolOffset as ot, createSymbol as st } from "../../util/symbol.js";
+import { identity as vt, rotate as gt, mul as I } from "../../../../zrender/lib/core/matrix.js";
+import { applyTransform as O } from "../../../../zrender/lib/core/vector.js";
+import { shouldShowAllLabels as ft } from "../../coord/axisHelper.js";
+import { prepareLayoutList as ut, hideOverlap as ct } from "../../label/labelLayoutHelper.js";
+import P from "../../../../zrender/lib/graphic/Group.js";
+import K from "../../../../zrender/lib/graphic/Text.js";
+import Q from "../../../../zrender/lib/graphic/shape/Line.js";
+var A = Math.PI, w = (
+  /** @class */
+  (function() {
+    function a(t, e) {
+      this.group = new P(), this.opt = e, this.axisModel = t, B(e, {
+        labelOffset: 0,
+        nameDirection: 1,
+        tickDirection: 1,
+        labelDirection: 1,
+        silent: !0,
+        handleAutoShown: function() {
+          return !0;
+        }
+      });
+      var i = new P({
+        x: e.position[0],
+        y: e.position[1],
+        rotation: e.rotation
+      });
+      i.updateTransform(), this._transformGroup = i;
+    }
+    return a.prototype.hasBuilder = function(t) {
+      return !!_[t];
+    }, a.prototype.add = function(t) {
+      _[t](this.opt, this.axisModel, this.group, this._transformGroup);
+    }, a.prototype.getGroup = function() {
+      return this.group;
+    }, a.innerTextLayout = function(t, e, i) {
+      var r = J(e - t), l, n;
+      return R(r) ? (n = i > 0 ? "top" : "bottom", l = "center") : R(r - A) ? (n = i > 0 ? "bottom" : "top", l = "center") : (n = "middle", r > 0 && r < A ? l = i > 0 ? "right" : "left" : l = i > 0 ? "left" : "right"), {
+        rotation: r,
+        textAlign: l,
+        textVerticalAlign: n
+      };
+    }, a.makeAxisEventDataBase = function(t) {
+      var e = {
+        componentType: t.mainType,
+        componentIndex: t.componentIndex
+      };
+      return e[t.mainType + "Index"] = t.componentIndex, e;
+    }, a.isLabelSilent = function(t) {
+      var e = t.get("tooltip");
+      return t.get("silent") || !(t.get("triggerEvent") || e && e.show);
+    }, a;
+  })()
+), _ = {
+  axisLine: function(a, t, e, i) {
+    var r = t.get(["axisLine", "show"]);
+    if (r === "auto" && a.handleAutoShown && (r = a.handleAutoShown("axisLine")), !!r) {
+      var l = t.axis.getExtent(), n = i.transform, o = [l[0], 0], s = [l[1], 0], f = o[0] > s[0];
+      n && (O(o, o, n), O(s, s, n));
+      var v = at({
+        lineCap: "round"
+      }, t.getModel(["axisLine", "lineStyle"]).getLineStyle()), u = new Q({
+        shape: {
+          x1: o[0],
+          y1: o[1],
+          x2: s[0],
+          y2: s[1]
+        },
+        style: v,
+        strokeContainThreshold: a.strokeContainThreshold || 5,
+        silent: !0,
+        z2: 1
+      });
+      z(u.shape, u.style.lineWidth), u.anid = "line", e.add(u);
+      var g = t.get(["axisLine", "symbol"]);
+      if (g != null) {
+        var c = t.get(["axisLine", "symbolSize"]);
+        W(g) && (g = [g, g]), (W(c) || it(c)) && (c = [c, c]);
+        var d = ot(t.get(["axisLine", "symbolOffset"]) || 0, c), y = c[0], L = c[1];
+        E([{
+          rotate: a.rotation + Math.PI / 2,
+          offset: d[0],
+          r: 0
+        }, {
+          rotate: a.rotation - Math.PI / 2,
+          offset: d[1],
+          r: Math.sqrt((o[0] - s[0]) * (o[0] - s[0]) + (o[1] - s[1]) * (o[1] - s[1]))
+        }], function(p, T) {
+          if (g[T] !== "none" && g[T] != null) {
+            var h = st(g[T], -y / 2, -L / 2, y, L, v.stroke, !0), m = p.r + p.offset, S = f ? s : o;
+            h.attr({
+              rotation: p.rotate,
+              x: S[0] + m * Math.cos(a.rotation),
+              y: S[1] - m * Math.sin(a.rotation),
+              silent: !0,
+              z2: 11
+            }), e.add(h);
+          }
+        });
+      }
+    }
+  },
+  axisTickLabel: function(a, t, e, i) {
+    var r = Lt(e, i, t, a), l = dt(e, i, t, a);
+    if (ht(t, l, r), pt(e, i, t, a.tickDirection), t.get(["axisLabel", "hideOverlap"])) {
+      var n = ut(et(l, function(o) {
+        return {
+          label: o,
+          priority: o.z2,
+          defaultAttr: {
+            ignore: o.ignore
+          }
+        };
+      }));
+      ct(n);
+    }
+  },
+  axisName: function(a, t, e, i) {
+    var r = D(a.axisName, t.get("name"));
+    if (r) {
+      var l = t.get("nameLocation"), n = a.nameDirection, o = t.getModel("nameTextStyle"), s = t.get("nameGap") || 0, f = t.axis.getExtent(), v = f[0] > f[1] ? -1 : 1, u = [
+        l === "start" ? f[0] - v * s : l === "end" ? f[1] + v * s : (f[0] + f[1]) / 2,
+        // Reuse labelOffset.
+        G(l) ? a.labelOffset + n * s : 0
+      ], g, c = t.get("nameRotate");
+      c != null && (c = c * A / 180);
+      var d;
+      G(l) ? g = w.innerTextLayout(
+        a.rotation,
+        c ?? a.rotation,
+        // Adapt to axis.
+        n
+      ) : (g = mt(a.rotation, l, c || 0, f), d = a.axisNameAvailableWidth, d != null && (d = Math.abs(d / Math.sin(g.rotation)), !isFinite(d) && (d = null)));
+      var y = o.getFont(), L = t.get("nameTruncate", !0) || {}, p = L.ellipsis, T = D(a.nameTruncateMaxWidth, L.maxWidth, d), h = new K({
+        x: u[0],
+        y: u[1],
+        rotation: g.rotation,
+        silent: w.isLabelSilent(t),
+        style: q(o, {
+          text: r,
+          font: y,
+          overflow: "truncate",
+          width: T,
+          ellipsis: p,
+          fill: o.getTextColor() || t.get(["axisLine", "lineStyle", "color"]),
+          align: o.get("align") || g.textAlign,
+          verticalAlign: o.get("verticalAlign") || g.textVerticalAlign
+        }),
+        z2: 1
+      });
+      if (j({
+        el: h,
+        componentModel: t,
+        itemName: r
+      }), h.__fullText = r, h.anid = "name", t.get("triggerEvent")) {
+        var m = w.makeAxisEventDataBase(t);
+        m.targetType = "axisName", m.name = r, Z(h).eventData = m;
+      }
+      i.add(h), h.updateTransform(), e.add(h), h.decomposeTransform();
+    }
+  }
+};
+function mt(a, t, e, i) {
+  var r = J(e - a), l, n, o = i[0] > i[1], s = t === "start" && !o || t !== "start" && o;
+  return R(r - A / 2) ? (n = s ? "bottom" : "top", l = "center") : R(r - A * 1.5) ? (n = s ? "top" : "bottom", l = "center") : (n = "middle", r < A * 1.5 && r > A / 2 ? l = s ? "left" : "right" : l = s ? "right" : "left"), {
+    rotation: r,
+    textAlign: l,
+    textVerticalAlign: n
+  };
+}
+function ht(a, t, e) {
+  if (!ft(a.axis)) {
+    var i = a.get(["axisLabel", "showMinLabel"]), r = a.get(["axisLabel", "showMaxLabel"]);
+    t = t || [], e = e || [];
+    var l = t[0], n = t[1], o = t[t.length - 1], s = t[t.length - 2], f = e[0], v = e[1], u = e[e.length - 1], g = e[e.length - 2];
+    i === !1 ? (x(l), x(f)) : F(l, n) && (i ? (x(n), x(v)) : (x(l), x(f))), r === !1 ? (x(o), x(u)) : F(s, o) && (r ? (x(s), x(g)) : (x(o), x(u)));
+  }
+}
+function x(a) {
+  a && (a.ignore = !0);
+}
+function F(a, t) {
+  var e = a && a.getBoundingRect().clone(), i = t && t.getBoundingRect().clone();
+  if (!(!e || !i)) {
+    var r = vt([]);
+    return gt(r, r, -a.rotation), e.applyTransform(I([], r, a.getLocalTransform())), i.applyTransform(I([], r, t.getLocalTransform())), e.intersect(i);
+  }
+}
+function G(a) {
+  return a === "middle" || a === "center";
+}
+function U(a, t, e, i, r) {
+  for (var l = [], n = [], o = [], s = 0; s < a.length; s++) {
+    var f = a[s].coord;
+    n[0] = f, n[1] = 0, o[0] = f, o[1] = e, t && (O(n, n, t), O(o, o, t));
+    var v = new Q({
+      shape: {
+        x1: n[0],
+        y1: n[1],
+        x2: o[0],
+        y2: o[1]
+      },
+      style: i,
+      z2: 2,
+      autoBatch: !0,
+      silent: !0
+    });
+    z(v.shape, v.style.lineWidth), v.anid = r + "_" + a[s].tickValue, l.push(v);
+  }
+  return l;
+}
+function Lt(a, t, e, i) {
+  var r = e.axis, l = e.getModel("axisTick"), n = l.get("show");
+  if (n === "auto" && i.handleAutoShown && (n = i.handleAutoShown("axisTick")), !(!n || r.scale.isBlank())) {
+    for (var o = l.getModel("lineStyle"), s = i.tickDirection * l.get("length"), f = r.getTicksCoords(), v = U(f, t.transform, s, B(o.getLineStyle(), {
+      stroke: e.get(["axisLine", "lineStyle", "color"])
+    }), "ticks"), u = 0; u < v.length; u++)
+      a.add(v[u]);
+    return v;
+  }
+}
+function pt(a, t, e, i) {
+  var r = e.axis, l = e.getModel("minorTick");
+  if (!(!l.get("show") || r.scale.isBlank())) {
+    var n = r.getMinorTicksCoords();
+    if (n.length)
+      for (var o = l.getModel("lineStyle"), s = i * l.get("length"), f = B(o.getLineStyle(), B(e.getModel("axisTick").getLineStyle(), {
+        stroke: e.get(["axisLine", "lineStyle", "color"])
+      })), v = 0; v < n.length; v++)
+        for (var u = U(n[v], t.transform, s, f, "minorticks_" + v), g = 0; g < u.length; g++)
+          a.add(u[g]);
+  }
+}
+function dt(a, t, e, i) {
+  var r = e.axis, l = D(i.axisLabelShow, e.get(["axisLabel", "show"]));
+  if (!(!l || r.scale.isBlank())) {
+    var n = e.getModel("axisLabel"), o = n.get("margin"), s = r.getViewLabels(), f = (D(i.labelRotate, n.get("rotate")) || 0) * A / 180, v = w.innerTextLayout(i.rotation, f, i.labelDirection), u = e.getCategories && e.getCategories(!0), g = [], c = w.isLabelSilent(e), d = e.get("triggerEvent");
+    return E(s, function(y, L) {
+      var p = r.scale.type === "ordinal" ? r.scale.getRawOrdinalNumber(y.tickValue) : y.tickValue, T = y.formattedLabel, h = y.rawLabel, m = n;
+      if (u && u[p]) {
+        var S = u[p];
+        rt(S) && S.textStyle && (m = new lt(S.textStyle, n, e.ecModel));
+      }
+      var V = m.getTextColor() || e.get(["axisLine", "lineStyle", "color"]), X = r.dataToCoord(p), N = m.getShallow("align", !0) || v.textAlign, Y = C(m.getShallow("alignMinLabel", !0), N), $ = C(m.getShallow("alignMaxLabel", !0), N), M = m.getShallow("verticalAlign", !0) || m.getShallow("baseline", !0) || v.textVerticalAlign, H = C(m.getShallow("verticalAlignMinLabel", !0), M), tt = C(m.getShallow("verticalAlignMaxLabel", !0), M), b = new K({
+        x: X,
+        y: i.labelOffset + i.labelDirection * o,
+        rotation: v.rotation,
+        silent: c,
+        z2: 10 + (y.level || 0),
+        style: q(m, {
+          text: T,
+          align: L === 0 ? Y : L === s.length - 1 ? $ : N,
+          verticalAlign: L === 0 ? H : L === s.length - 1 ? tt : M,
+          fill: nt(V) ? V(
+            // (1) In category axis with data zoom, tick is not the original
+            // index of axis.data. So tick should not be exposed to user
+            // in category axis.
+            // (2) Compatible with previous version, which always use formatted label as
+            // input. But in interval scale the formatted label is like '223,445', which
+            // maked user replace ','. So we modify it to return original val but remain
+            // it as 'string' to avoid error in replacing.
+            r.type === "category" ? h : r.type === "value" ? p + "" : p,
+            L
+          ) : V
+        })
+      });
+      if (b.anid = "label_" + p, j({
+        el: b,
+        componentModel: e,
+        itemName: T,
+        formatterParamsExtra: {
+          isTruncated: function() {
+            return b.isTruncated;
+          },
+          value: h,
+          tickIndex: L
+        }
+      }), d) {
+        var k = w.makeAxisEventDataBase(e);
+        k.targetType = "axisLabel", k.value = h, k.tickIndex = L, r.type === "category" && (k.dataIndex = p), Z(b).eventData = k;
+      }
+      t.add(b), b.updateTransform(), g.push(b), a.add(b), b.decomposeTransform();
+    }), g;
+  }
+}
+export {
+  w as default
+};

package/dist/node_modules/echarts/lib/component/axis/AxisView.js

@@ -0,0 +1,38 @@
+import { __extends as p } from "../../../../tslib/tslib.es6.js";
+import { fixValue as l, getAxisPointerModel as x } from "../axisPointer/modelHelper.js";
+import d from "../../view/Component.js";
+var a = {}, h = (
+  /** @class */
+  (function(s) {
+    p(i, s);
+    function i() {
+      var t = s !== null && s.apply(this, arguments) || this;
+      return t.type = i.type, t;
+    }
+    return i.prototype.render = function(t, e, o, r) {
+      this.axisPointerClass && l(t), s.prototype.render.apply(this, arguments), this._doUpdateAxisPointerClass(t, o, !0);
+    }, i.prototype.updateAxisPointer = function(t, e, o, r) {
+      this._doUpdateAxisPointerClass(t, o, !1);
+    }, i.prototype.remove = function(t, e) {
+      var o = this._axisPointer;
+      o && o.remove(e);
+    }, i.prototype.dispose = function(t, e) {
+      this._disposeAxisPointer(e), s.prototype.dispose.apply(this, arguments);
+    }, i.prototype._doUpdateAxisPointerClass = function(t, e, o) {
+      var r = i.getAxisPointerClass(this.axisPointerClass);
+      if (r) {
+        var n = x(t);
+        n ? (this._axisPointer || (this._axisPointer = new r())).render(t, n, e, o) : this._disposeAxisPointer(e);
+      }
+    }, i.prototype._disposeAxisPointer = function(t) {
+      this._axisPointer && this._axisPointer.dispose(t), this._axisPointer = null;
+    }, i.registerAxisPointerClass = function(t, e) {
+      a[t] = e;
+    }, i.getAxisPointerClass = function(t) {
+      return t && a[t];
+    }, i.type = "axis", i;
+  })(d)
+);
+export {
+  h as default
+};

package/dist/node_modules/echarts/lib/component/axis/CartesianAxisView.js

@@ -0,0 +1,123 @@
+import { __extends as c } from "../../../../tslib/tslib.es6.js";
+import { extend as V, each as S, isArray as _, defaults as M } from "../../../../zrender/lib/core/util.js";
+import { groupTransition as R, subPixelOptimizeLine as L } from "../../util/graphic.js";
+import T from "./AxisBuilder.js";
+import z from "./AxisView.js";
+import { layout as H } from "../../coord/cartesian/cartesianAxisHelper.js";
+import { rectCoordAxisHandleRemove as b, rectCoordAxisBuildSplitArea as O } from "./axisSplitHelper.js";
+import { isIntervalOrLogScale as I } from "../../scale/helper.js";
+import P from "../../../../zrender/lib/graphic/Group.js";
+import C from "../../../../zrender/lib/graphic/shape/Line.js";
+var W = ["axisLine", "axisTickLabel", "axisName"], X = ["splitArea", "splitLine", "minorSplitLine"], G = (
+  /** @class */
+  (function(r) {
+    c(e, r);
+    function e() {
+      var t = r !== null && r.apply(this, arguments) || this;
+      return t.type = e.type, t.axisPointerClass = "CartesianAxisPointer", t;
+    }
+    return e.prototype.render = function(t, v, h, s) {
+      this.group.removeAll();
+      var x = this._axisGroup;
+      if (this._axisGroup = new P(), this.group.add(this._axisGroup), !!t.get("show")) {
+        var i = t.getCoordSysModel(), g = H(i, t), l = new T(t, V({
+          handleAutoShown: function(o) {
+            for (var f = i.coordinateSystem.getCartesians(), a = 0; a < f.length; a++)
+              if (I(f[a].getOtherAxis(t.axis).scale))
+                return !0;
+            return !1;
+          }
+        }, g));
+        S(W, l.add, l), this._axisGroup.add(l.getGroup()), S(X, function(o) {
+          t.get([o, "show"]) && Y[o](this, this._axisGroup, t, i);
+        }, this);
+        var n = s && s.type === "changeAxisOrder" && s.isInitSort;
+        n || R(x, this._axisGroup, t), r.prototype.render.call(this, t, v, h, s);
+      }
+    }, e.prototype.remove = function() {
+      b(this);
+    }, e.type = "cartesianAxis", e;
+  })(z)
+), Y = {
+  splitLine: function(r, e, t, v) {
+    var h = t.axis;
+    if (!h.scale.isBlank()) {
+      var s = t.getModel("splitLine"), x = s.getModel("lineStyle"), i = x.get("color"), g = s.get("showMinLine") !== !1, l = s.get("showMaxLine") !== !1;
+      i = _(i) ? i : [i];
+      for (var n = v.coordinateSystem.getRect(), o = h.isHorizontal(), f = 0, a = h.getTicksCoords({
+        tickModel: s
+      }), u = [], p = [], y = x.getLineStyle(), d = 0; d < a.length; d++) {
+        var m = h.toGlobalCoord(a[d].coord);
+        if (!(d === 0 && !g || d === a.length - 1 && !l)) {
+          var A = a[d].tickValue;
+          o ? (u[0] = m, u[1] = n.y, p[0] = m, p[1] = n.y + n.height) : (u[0] = n.x, u[1] = m, p[0] = n.x + n.width, p[1] = m);
+          var B = f++ % i.length, w = new C({
+            anid: A != null ? "line_" + A : null,
+            autoBatch: !0,
+            shape: {
+              x1: u[0],
+              y1: u[1],
+              x2: p[0],
+              y2: p[1]
+            },
+            style: M({
+              stroke: i[B]
+            }, y),
+            silent: !0
+          });
+          L(w.shape, y.lineWidth), e.add(w);
+        }
+      }
+    }
+  },
+  minorSplitLine: function(r, e, t, v) {
+    var h = t.axis, s = t.getModel("minorSplitLine"), x = s.getModel("lineStyle"), i = v.coordinateSystem.getRect(), g = h.isHorizontal(), l = h.getMinorTicksCoords();
+    if (l.length)
+      for (var n = [], o = [], f = x.getLineStyle(), a = 0; a < l.length; a++)
+        for (var u = 0; u < l[a].length; u++) {
+          var p = h.toGlobalCoord(l[a][u].coord);
+          g ? (n[0] = p, n[1] = i.y, o[0] = p, o[1] = i.y + i.height) : (n[0] = i.x, n[1] = p, o[0] = i.x + i.width, o[1] = p);
+          var y = new C({
+            anid: "minor_line_" + l[a][u].tickValue,
+            autoBatch: !0,
+            shape: {
+              x1: n[0],
+              y1: n[1],
+              x2: o[0],
+              y2: o[1]
+            },
+            style: f,
+            silent: !0
+          });
+          L(y.shape, f.lineWidth), e.add(y);
+        }
+  },
+  splitArea: function(r, e, t, v) {
+    O(r, e, t, v);
+  }
+}, E = (
+  /** @class */
+  (function(r) {
+    c(e, r);
+    function e() {
+      var t = r !== null && r.apply(this, arguments) || this;
+      return t.type = e.type, t;
+    }
+    return e.type = "xAxis", e;
+  })(G)
+), U = (
+  /** @class */
+  (function(r) {
+    c(e, r);
+    function e() {
+      var t = r !== null && r.apply(this, arguments) || this;
+      return t.type = E.type, t;
+    }
+    return e.type = "yAxis", e;
+  })(G)
+);
+export {
+  E as CartesianXAxisView,
+  U as CartesianYAxisView,
+  G as default
+};

package/dist/node_modules/echarts/lib/component/axis/ParallelAxisView.js

@@ -0,0 +1,88 @@
+import { __extends as f } from "../../../../tslib/tslib.es6.js";
+import { bind as y, extend as v, each as g, map as d } from "../../../../zrender/lib/core/util.js";
+import C from "./AxisBuilder.js";
+import A from "../helper/BrushController.js";
+import { makeLinearBrushOtherExtent as B, makeRectIsTargetByCursor as b, makeRectPanelClipPath as S } from "../helper/brushHelper.js";
+import { groupTransition as T } from "../../util/graphic.js";
+import _ from "../../view/Component.js";
+import w from "../../../../zrender/lib/graphic/Group.js";
+import L from "../../../../zrender/lib/core/BoundingRect.js";
+var G = ["axisLine", "axisTickLabel", "axisName"], j = (
+  /** @class */
+  (function(e) {
+    f(r, e);
+    function r() {
+      var t = e !== null && e.apply(this, arguments) || this;
+      return t.type = r.type, t;
+    }
+    return r.prototype.init = function(t, i) {
+      e.prototype.init.apply(this, arguments), (this._brushController = new A(i.getZr())).on("brush", y(this._onBrush, this));
+    }, r.prototype.render = function(t, i, o, s) {
+      if (!k(t, i, s)) {
+        this.axisModel = t, this.api = o, this.group.removeAll();
+        var l = this._axisGroup;
+        if (this._axisGroup = new w(), this.group.add(this._axisGroup), !!t.get("show")) {
+          var a = P(t, i), u = a.coordinateSystem, p = t.getAreaSelectStyle(), h = p.width, n = t.axis.dim, x = u.getAxisLayout(n), c = v({
+            strokeContainThreshold: h
+          }, x), m = new C(t, c);
+          g(G, m.add, m), this._axisGroup.add(m.getGroup()), this._refreshBrushController(c, p, t, a, h, o), T(l, this._axisGroup, t);
+        }
+      }
+    }, r.prototype._refreshBrushController = function(t, i, o, s, l, a) {
+      var u = o.axis.getExtent(), p = u[1] - u[0], h = Math.min(30, Math.abs(p) * 0.1), n = L.create({
+        x: u[0],
+        y: -l / 2,
+        width: p,
+        height: l
+      });
+      n.x -= h, n.width += 2 * h, this._brushController.mount({
+        enableGlobalPan: !0,
+        rotation: t.rotation,
+        x: t.position[0],
+        y: t.position[1]
+      }).setPanels([{
+        panelId: "pl",
+        clipPath: S(n),
+        isTargetByCursor: b(n, a, s),
+        getLinearBrushOtherExtent: B(n, 0)
+      }]).enableBrush({
+        brushType: "lineX",
+        brushStyle: i,
+        removeOnClick: !0
+      }).updateCovers(I(o));
+    }, r.prototype._onBrush = function(t) {
+      var i = t.areas, o = this.axisModel, s = o.axis, l = d(i, function(a) {
+        return [s.coordToData(a.range[0], !0), s.coordToData(a.range[1], !0)];
+      });
+      (!o.option.realtime === t.isEnd || t.removeOnClick) && this.api.dispatchAction({
+        type: "axisAreaSelect",
+        parallelAxisId: o.id,
+        intervals: l
+      });
+    }, r.prototype.dispose = function() {
+      this._brushController.dispose();
+    }, r.type = "parallelAxis", r;
+  })(_)
+);
+function k(e, r, t) {
+  return t && t.type === "axisAreaSelect" && r.findComponents({
+    mainType: "parallelAxis",
+    query: t
+  })[0] === e;
+}
+function I(e) {
+  var r = e.axis;
+  return d(e.activeIntervals, function(t) {
+    return {
+      brushType: "lineX",
+      panelId: "pl",
+      range: [r.dataToCoord(t[0], !0), r.dataToCoord(t[1], !0)]
+    };
+  });
+}
+function P(e, r) {
+  return r.getComponent("parallel", e.get("parallelIndex"));
+}
+export {
+  j as default
+};

package/dist/node_modules/echarts/lib/component/axis/RadiusAxisView.js

@@ -0,0 +1,117 @@
+import { __extends as m } from "../../../../tslib/tslib.es6.js";
+import { each as y, defaults as d } from "../../../../zrender/lib/core/util.js";
+import * as L from "../../util/graphic.js";
+import { groupTransition as M, mergePath as A } from "../../util/graphic.js";
+import S from "./AxisBuilder.js";
+import w from "./AxisView.js";
+import E from "../../../../zrender/lib/graphic/Group.js";
+import P from "../../../../zrender/lib/graphic/shape/Sector.js";
+import B from "../../../../zrender/lib/graphic/shape/Circle.js";
+var G = ["axisLine", "axisTickLabel", "axisName"], b = ["splitLine", "splitArea", "minorSplitLine"], q = (
+  /** @class */
+  (function(o) {
+    m(n, o);
+    function n() {
+      var e = o !== null && o.apply(this, arguments) || this;
+      return e.type = n.type, e.axisPointerClass = "PolarAxisPointer", e;
+    }
+    return n.prototype.render = function(e, x) {
+      if (this.group.removeAll(), !!e.get("show")) {
+        var h = this._axisGroup, l = this._axisGroup = new E();
+        this.group.add(l);
+        var a = e.axis, g = a.polar, t = g.getAngleAxis(), v = a.getTicksCoords(), i = a.getMinorTicksCoords(), s = t.getExtent()[0], r = a.getExtent(), c = C(g, e, s), u = new S(e, c);
+        y(G, u.add, u), l.add(u.getGroup()), M(h, l, e), y(b, function(p) {
+          e.get([p, "show"]) && !a.scale.isBlank() && R[p](this.group, e, g, s, r, v, i);
+        }, this);
+      }
+    }, n.type = "radiusAxis", n;
+  })(w)
+), R = {
+  splitLine: function(o, n, e, x, h, l) {
+    var a = n.getModel("splitLine"), g = a.getModel("lineStyle"), t = g.get("color"), v = 0, i = e.getAngleAxis(), s = Math.PI / 180, r = i.getExtent(), c = Math.abs(r[1] - r[0]) === 360 ? "Circle" : "Arc";
+    t = t instanceof Array ? t : [t];
+    for (var u = [], p = 0; p < l.length; p++) {
+      var f = v++ % t.length;
+      u[f] = u[f] || [], u[f].push(new L[c]({
+        shape: {
+          cx: e.cx,
+          cy: e.cy,
+          // ensure circle radius >= 0
+          r: Math.max(l[p].coord, 0),
+          startAngle: -r[0] * s,
+          endAngle: -r[1] * s,
+          clockwise: i.inverse
+        }
+      }));
+    }
+    for (var p = 0; p < u.length; p++)
+      o.add(A(u[p], {
+        style: d({
+          stroke: t[p % t.length],
+          fill: null
+        }, g.getLineStyle()),
+        silent: !0
+      }));
+  },
+  minorSplitLine: function(o, n, e, x, h, l, a) {
+    if (a.length) {
+      for (var g = n.getModel("minorSplitLine"), t = g.getModel("lineStyle"), v = [], i = 0; i < a.length; i++)
+        for (var s = 0; s < a[i].length; s++)
+          v.push(new B({
+            shape: {
+              cx: e.cx,
+              cy: e.cy,
+              r: a[i][s].coord
+            }
+          }));
+      o.add(A(v, {
+        style: d({
+          fill: null
+        }, t.getLineStyle()),
+        silent: !0
+      }));
+    }
+  },
+  splitArea: function(o, n, e, x, h, l) {
+    if (l.length) {
+      var a = n.getModel("splitArea"), g = a.getModel("areaStyle"), t = g.get("color"), v = 0;
+      t = t instanceof Array ? t : [t];
+      for (var i = [], s = l[0].coord, r = 1; r < l.length; r++) {
+        var c = v++ % t.length;
+        i[c] = i[c] || [], i[c].push(new P({
+          shape: {
+            cx: e.cx,
+            cy: e.cy,
+            r0: s,
+            r: l[r].coord,
+            startAngle: 0,
+            endAngle: Math.PI * 2
+          },
+          silent: !0
+        })), s = l[r].coord;
+      }
+      for (var r = 0; r < i.length; r++)
+        o.add(A(i[r], {
+          style: d({
+            fill: t[r % t.length]
+          }, g.getAreaStyle()),
+          silent: !0
+        }));
+    }
+  }
+};
+function C(o, n, e) {
+  return {
+    position: [o.cx, o.cy],
+    rotation: e / 180 * Math.PI,
+    labelDirection: -1,
+    tickDirection: -1,
+    nameDirection: 1,
+    labelRotate: n.getModel("axisLabel").get("rotate"),
+    // Over splitLine and splitArea
+    z2: 1
+  };
+}
+export {
+  q as default
+};