web-core-tcm 0.0.59 → 0.0.62

package/dist/node_modules/echarts/lib/coord/polar/AxisModel.js

@@ -0,0 +1,44 @@
+import { __extends as n } from "../../../../tslib/tslib.es6.js";
+import { mixin as e } from "../../../../zrender/lib/core/util.js";
+import l from "../../model/Component.js";
+import { AxisModelCommonMixin as s } from "../axisModelCommonMixin.js";
+import { SINGLE_REFERRING as a } from "../../util/model.js";
+var r = (
+  /** @class */
+  (function(o) {
+    n(t, o);
+    function t() {
+      return o !== null && o.apply(this, arguments) || this;
+    }
+    return t.prototype.getCoordSysModel = function() {
+      return this.getReferringComponents("polar", a).models[0];
+    }, t.type = "polarAxis", t;
+  })(l)
+);
+e(r, s);
+var f = (
+  /** @class */
+  (function(o) {
+    n(t, o);
+    function t() {
+      var i = o !== null && o.apply(this, arguments) || this;
+      return i.type = t.type, i;
+    }
+    return t.type = "angleAxis", t;
+  })(r)
+), y = (
+  /** @class */
+  (function(o) {
+    n(t, o);
+    function t() {
+      var i = o !== null && o.apply(this, arguments) || this;
+      return i.type = t.type, i;
+    }
+    return t.type = "radiusAxis", t;
+  })(r)
+);
+export {
+  f as AngleAxisModel,
+  r as PolarAxisModel,
+  y as RadiusAxisModel
+};

package/dist/node_modules/echarts/lib/coord/polar/Polar.js

@@ -0,0 +1,86 @@
+import p from "./RadiusAxis.js";
+import g from "./AngleAxis.js";
+var v = ["radius", "angle"], _ = (
+  /** @class */
+  (function() {
+    function e(i) {
+      this.dimensions = v, this.type = "polar", this.cx = 0, this.cy = 0, this._radiusAxis = new p(), this._angleAxis = new g(), this.axisPointerEnabled = !0, this.name = i || "", this._radiusAxis.polar = this._angleAxis.polar = this;
+    }
+    return e.prototype.containPoint = function(i) {
+      var t = this.pointToCoord(i);
+      return this._radiusAxis.contain(t[0]) && this._angleAxis.contain(t[1]);
+    }, e.prototype.containData = function(i) {
+      return this._radiusAxis.containData(i[0]) && this._angleAxis.containData(i[1]);
+    }, e.prototype.getAxis = function(i) {
+      var t = "_" + i + "Axis";
+      return this[t];
+    }, e.prototype.getAxes = function() {
+      return [this._radiusAxis, this._angleAxis];
+    }, e.prototype.getAxesByScale = function(i) {
+      var t = [], r = this._angleAxis, s = this._radiusAxis;
+      return r.scale.type === i && t.push(r), s.scale.type === i && t.push(s), t;
+    }, e.prototype.getAngleAxis = function() {
+      return this._angleAxis;
+    }, e.prototype.getRadiusAxis = function() {
+      return this._radiusAxis;
+    }, e.prototype.getOtherAxis = function(i) {
+      var t = this._angleAxis;
+      return i === t ? this._radiusAxis : t;
+    }, e.prototype.getBaseAxis = function() {
+      return this.getAxesByScale("ordinal")[0] || this.getAxesByScale("time")[0] || this.getAngleAxis();
+    }, e.prototype.getTooltipAxes = function(i) {
+      var t = i != null && i !== "auto" ? this.getAxis(i) : this.getBaseAxis();
+      return {
+        baseAxes: [t],
+        otherAxes: [this.getOtherAxis(t)]
+      };
+    }, e.prototype.dataToPoint = function(i, t) {
+      return this.coordToPoint([this._radiusAxis.dataToRadius(i[0], t), this._angleAxis.dataToAngle(i[1], t)]);
+    }, e.prototype.pointToData = function(i, t) {
+      var r = this.pointToCoord(i);
+      return [this._radiusAxis.radiusToData(r[0], t), this._angleAxis.angleToData(r[1], t)];
+    }, e.prototype.pointToCoord = function(i) {
+      var t = i[0] - this.cx, r = i[1] - this.cy, s = this.getAngleAxis(), a = s.getExtent(), o = Math.min(a[0], a[1]), x = Math.max(a[0], a[1]);
+      s.inverse ? o = x - 360 : x = o + 360;
+      var u = Math.sqrt(t * t + r * r);
+      t /= u, r /= u;
+      for (var n = Math.atan2(-r, t) / Math.PI * 180, h = n < o ? 1 : -1; n < o || n > x; )
+        n += h * 360;
+      return [u, n];
+    }, e.prototype.coordToPoint = function(i) {
+      var t = i[0], r = i[1] / 180 * Math.PI, s = Math.cos(r) * t + this.cx, a = -Math.sin(r) * t + this.cy;
+      return [s, a];
+    }, e.prototype.getArea = function() {
+      var i = this.getAngleAxis(), t = this.getRadiusAxis(), r = t.getExtent().slice();
+      r[0] > r[1] && r.reverse();
+      var s = i.getExtent(), a = Math.PI / 180, o = 1e-4;
+      return {
+        cx: this.cx,
+        cy: this.cy,
+        r0: r[0],
+        r: r[1],
+        startAngle: -s[0] * a,
+        endAngle: -s[1] * a,
+        clockwise: i.inverse,
+        contain: function(x, u) {
+          var n = x - this.cx, h = u - this.cy, c = n * n + h * h, A = this.r, l = this.r0;
+          return A !== l && c - o <= A * A && c + o >= l * l;
+        }
+      };
+    }, e.prototype.convertToPixel = function(i, t, r) {
+      var s = d(t);
+      return s === this ? this.dataToPoint(r) : null;
+    }, e.prototype.convertFromPixel = function(i, t, r) {
+      var s = d(t);
+      return s === this ? this.pointToData(r) : null;
+    }, e;
+  })()
+);
+function d(e) {
+  var i = e.seriesModel, t = e.polarModel;
+  return t && t.coordinateSystem || i && i.coordinateSystem;
+}
+export {
+  _ as default,
+  v as polarDimensions
+};

package/dist/node_modules/echarts/lib/coord/polar/PolarModel.js

@@ -0,0 +1,26 @@
+import { __extends as d } from "../../../../tslib/tslib.es6.js";
+import l from "../../model/Component.js";
+var p = (
+  /** @class */
+  (function(o) {
+    d(e, o);
+    function e() {
+      var t = o !== null && o.apply(this, arguments) || this;
+      return t.type = e.type, t;
+    }
+    return e.prototype.findAxisModel = function(t) {
+      var n, i = this.ecModel;
+      return i.eachComponent(t, function(r) {
+        r.getCoordSysModel() === this && (n = r);
+      }, this), n;
+    }, e.type = "polar", e.dependencies = ["radiusAxis", "angleAxis"], e.defaultOption = {
+      // zlevel: 0,
+      z: 0,
+      center: ["50%", "50%"],
+      radius: "80%"
+    }, e;
+  })(l)
+);
+export {
+  p as default
+};

package/dist/node_modules/echarts/lib/coord/polar/RadiusAxis.js

@@ -0,0 +1,19 @@
+import { __extends as s } from "../../../../tslib/tslib.es6.js";
+import r from "../Axis.js";
+var p = (
+  /** @class */
+  (function(i) {
+    s(t, i);
+    function t(o, a) {
+      return i.call(this, "radius", o, a) || this;
+    }
+    return t.prototype.pointToData = function(o, a) {
+      return this.polar.pointToData(o, a)[this.dim === "radius" ? 0 : 1];
+    }, t;
+  })(r)
+);
+p.prototype.dataToRadius = r.prototype.dataToCoord;
+p.prototype.radiusToData = r.prototype.coordToData;
+export {
+  p as default
+};

package/dist/node_modules/echarts/lib/coord/polar/polarCreator.js

@@ -0,0 +1,61 @@
+import { each as v, isArray as A } from "../../../../zrender/lib/core/util.js";
+import d, { polarDimensions as p } from "./Polar.js";
+import { parsePercent as u } from "../../util/number.js";
+import { getDataDimensionsOnAxis as m, niceScaleExtent as f, createScaleByModel as y } from "../axisHelper.js";
+import { SINGLE_REFERRING as E } from "../../util/model.js";
+function h(t, n, a) {
+  var e = n.get("center"), s = a.getWidth(), r = a.getHeight();
+  t.cx = u(e[0], s), t.cy = u(e[1], r);
+  var c = t.getRadiusAxis(), g = Math.min(s, r) / 2, i = n.get("radius");
+  i == null ? i = [0, "100%"] : A(i) || (i = [0, i]);
+  var o = [u(i[0], g), u(i[1], g)];
+  c.inverse ? c.setExtent(o[1], o[0]) : c.setExtent(o[0], o[1]);
+}
+function x(t, n) {
+  var a = this, e = a.getAngleAxis(), s = a.getRadiusAxis();
+  if (e.scale.setExtent(1 / 0, -1 / 0), s.scale.setExtent(1 / 0, -1 / 0), t.eachSeries(function(g) {
+    if (g.coordinateSystem === a) {
+      var i = g.getData();
+      v(m(i, "radius"), function(o) {
+        s.scale.unionExtentFromData(i, o);
+      }), v(m(i, "angle"), function(o) {
+        e.scale.unionExtentFromData(i, o);
+      });
+    }
+  }), f(e.scale, e.model), f(s.scale, s.model), e.type === "category" && !e.onBand) {
+    var r = e.getExtent(), c = 360 / e.scale.count();
+    e.inverse ? r[1] += c : r[1] -= c, e.setExtent(r[0], r[1]);
+  }
+}
+function S(t) {
+  return t.mainType === "angleAxis";
+}
+function l(t, n) {
+  var a;
+  if (t.type = n.get("type"), t.scale = y(n), t.onBand = n.get("boundaryGap") && t.type === "category", t.inverse = n.get("inverse"), S(n)) {
+    t.inverse = t.inverse !== n.get("clockwise");
+    var e = n.get("startAngle"), s = (a = n.get("endAngle")) !== null && a !== void 0 ? a : e + (t.inverse ? -360 : 360);
+    t.setExtent(e, s);
+  }
+  n.axis = t, t.model = n;
+}
+var B = {
+  dimensions: p,
+  create: function(t, n) {
+    var a = [];
+    return t.eachComponent("polar", function(e, s) {
+      var r = new d(s + "");
+      r.update = x;
+      var c = r.getRadiusAxis(), g = r.getAngleAxis(), i = e.findAxisModel("radiusAxis"), o = e.findAxisModel("angleAxis");
+      l(c, i), l(g, o), h(r, e, n), a.push(r), e.coordinateSystem = r, r.model = e;
+    }), t.eachSeries(function(e) {
+      if (e.get("coordinateSystem") === "polar") {
+        var s = e.getReferringComponents("polar", E).models[0];
+        e.coordinateSystem = s.coordinateSystem;
+      }
+    }), a;
+  }
+};
+export {
+  B as default
+};

package/dist/node_modules/echarts/lib/coord/polar/prepareCustom.js

@@ -0,0 +1,29 @@
+import { bind as g, map as v } from "../../../../zrender/lib/core/util.js";
+function l(a, e) {
+  return e = e || [0, 0], v(["Radius", "Angle"], function(o, r) {
+    var u = "get" + o + "Axis", t = this[u](), i = e[r], n = a[r] / 2, s = t.type === "category" ? t.getBandWidth() : Math.abs(t.dataToCoord(i - n) - t.dataToCoord(i + n));
+    return o === "Angle" && (s = s * Math.PI / 180), s;
+  }, this);
+}
+function p(a) {
+  var e = a.getRadiusAxis(), o = a.getAngleAxis(), r = e.getExtent();
+  return r[0] > r[1] && r.reverse(), {
+    coordSys: {
+      type: "polar",
+      cx: a.cx,
+      cy: a.cy,
+      r: r[1],
+      r0: r[0]
+    },
+    api: {
+      coord: function(u) {
+        var t = e.dataToRadius(u[0]), i = o.dataToAngle(u[1]), n = a.coordToPoint([t, i]);
+        return n.push(t, i * Math.PI / 180), n;
+      },
+      size: g(l, a)
+    }
+  };
+}
+export {
+  p as default
+};

package/dist/node_modules/echarts/lib/coord/radar/IndicatorAxis.js

@@ -0,0 +1,16 @@
+import { __extends as o } from "../../../../tslib/tslib.es6.js";
+import s from "../Axis.js";
+var l = (
+  /** @class */
+  (function(i) {
+    o(r, i);
+    function r(n, a, e) {
+      var t = i.call(this, n, a, e) || this;
+      return t.type = "value", t.angle = 0, t.name = "", t;
+    }
+    return r;
+  })(s)
+);
+export {
+  l as default
+};

package/dist/node_modules/echarts/lib/coord/radar/Radar.js

@@ -0,0 +1,79 @@
+import l from "./IndicatorAxis.js";
+import v from "../../scale/Interval.js";
+import { parsePercent as u } from "../../util/number.js";
+import { each as m, map as f, isString as x, isNumber as g } from "../../../../zrender/lib/core/util.js";
+import { alignScaleTicks as y } from "../axisAlignTicks.js";
+var P = (
+  /** @class */
+  (function() {
+    function o(t, r, e) {
+      this.dimensions = [], this._model = t, this._indicatorAxes = f(t.getIndicatorModels(), function(i, s) {
+        var a = "indicator_" + s, n = new l(
+          a,
+          new v()
+          // (indicatorModel.get('axisType') === 'log') ? new LogScale() : new IntervalScale()
+        );
+        return n.name = i.get("name"), n.model = i, i.axis = n, this.dimensions.push(a), n;
+      }, this), this.resize(t, e);
+    }
+    return o.prototype.getIndicatorAxes = function() {
+      return this._indicatorAxes;
+    }, o.prototype.dataToPoint = function(t, r) {
+      var e = this._indicatorAxes[r];
+      return this.coordToPoint(e.dataToCoord(t), r);
+    }, o.prototype.coordToPoint = function(t, r) {
+      var e = this._indicatorAxes[r], i = e.angle, s = this.cx + t * Math.cos(i), a = this.cy - t * Math.sin(i);
+      return [s, a];
+    }, o.prototype.pointToData = function(t) {
+      var r = t[0] - this.cx, e = t[1] - this.cy, i = Math.sqrt(r * r + e * e);
+      r /= i, e /= i;
+      for (var s = Math.atan2(-e, r), a = 1 / 0, n, d = -1, h = 0; h < this._indicatorAxes.length; h++) {
+        var c = this._indicatorAxes[h], p = Math.abs(s - c.angle);
+        p < a && (n = c, d = h, a = p);
+      }
+      return [d, +(n && n.coordToData(i))];
+    }, o.prototype.resize = function(t, r) {
+      var e = t.get("center"), i = r.getWidth(), s = r.getHeight(), a = Math.min(i, s) / 2;
+      this.cx = u(e[0], i), this.cy = u(e[1], s), this.startAngle = t.get("startAngle") * Math.PI / 180;
+      var n = t.get("radius");
+      (x(n) || g(n)) && (n = [0, n]), this.r0 = u(n[0], a), this.r = u(n[1], a), m(this._indicatorAxes, function(d, h) {
+        d.setExtent(this.r0, this.r);
+        var c = this.startAngle + h * Math.PI * 2 / this._indicatorAxes.length;
+        c = Math.atan2(Math.sin(c), Math.cos(c)), d.angle = c;
+      }, this);
+    }, o.prototype.update = function(t, r) {
+      var e = this._indicatorAxes, i = this._model;
+      m(e, function(n) {
+        n.scale.setExtent(1 / 0, -1 / 0);
+      }), t.eachSeriesByType("radar", function(n, d) {
+        if (!(n.get("coordinateSystem") !== "radar" || t.getComponent("radar", n.get("radarIndex")) !== i)) {
+          var h = n.getData();
+          m(e, function(c) {
+            c.scale.unionExtentFromData(h, h.mapDimension(c.dim));
+          });
+        }
+      }, this);
+      var s = i.get("splitNumber"), a = new v();
+      a.setExtent(0, s), a.setInterval(1), m(e, function(n, d) {
+        y(n.scale, n.model, a);
+      });
+    }, o.prototype.convertToPixel = function(t, r, e) {
+      return console.warn("Not implemented."), null;
+    }, o.prototype.convertFromPixel = function(t, r, e) {
+      return console.warn("Not implemented."), null;
+    }, o.prototype.containPoint = function(t) {
+      return console.warn("Not implemented."), !1;
+    }, o.create = function(t, r) {
+      var e = [];
+      return t.eachComponent("radar", function(i) {
+        var s = new o(i, t, r);
+        e.push(s), i.coordinateSystem = s;
+      }), t.eachSeriesByType("radar", function(i) {
+        i.get("coordinateSystem") === "radar" && (i.coordinateSystem = e[i.get("radarIndex") || 0]);
+      }), e;
+    }, o.dimensions = [], o;
+  })()
+);
+export {
+  P as default
+};

package/dist/node_modules/echarts/lib/coord/radar/RadarModel.js

@@ -0,0 +1,89 @@
+import { __extends as M } from "../../../../tslib/tslib.es6.js";
+import { map as T, defaults as f, merge as p, clone as G, isString as w, isFunction as S, mixin as k } from "../../../../zrender/lib/core/util.js";
+import A from "../axisDefault.js";
+import I from "../../model/Model.js";
+import { AxisModelCommonMixin as E } from "../axisModelCommonMixin.js";
+import _ from "../../model/Component.js";
+var r = A.value;
+function o(i, a) {
+  return f({
+    show: a
+  }, i);
+}
+var j = (
+  /** @class */
+  (function(i) {
+    M(a, i);
+    function a() {
+      var s = i !== null && i.apply(this, arguments) || this;
+      return s.type = a.type, s;
+    }
+    return a.prototype.optionUpdated = function() {
+      var s = this.get("boundaryGap"), h = this.get("splitNumber"), d = this.get("scale"), v = this.get("axisLine"), g = this.get("axisTick"), c = this.get("axisLabel"), m = this.get("axisName"), y = this.get(["axisName", "show"]), n = this.get(["axisName", "formatter"]), b = this.get("axisNameGap"), L = this.get("triggerEvent"), N = T(this.get("indicator") || [], function(e) {
+        e.max != null && e.max > 0 && !e.min ? e.min = 0 : e.min != null && e.min < 0 && !e.max && (e.max = 0);
+        var u = m;
+        e.color != null && (u = f({
+          color: e.color
+        }, m));
+        var t = p(G(e), {
+          boundaryGap: s,
+          splitNumber: h,
+          scale: d,
+          axisLine: v,
+          axisTick: g,
+          // axisType: axisType,
+          axisLabel: c,
+          // Compatible with 2 and use text
+          name: e.text,
+          showName: y,
+          nameLocation: "end",
+          nameGap: b,
+          // min: 0,
+          nameTextStyle: u,
+          triggerEvent: L
+        }, !1);
+        if (w(n)) {
+          var x = t.name;
+          t.name = n.replace("{value}", x ?? "");
+        } else S(n) && (t.name = n(t.name, t));
+        var l = new I(t, null, this.ecModel);
+        return k(l, E.prototype), l.mainType = "radar", l.componentIndex = this.componentIndex, l;
+      }, this);
+      this._indicatorModels = N;
+    }, a.prototype.getIndicatorModels = function() {
+      return this._indicatorModels;
+    }, a.type = "radar", a.defaultOption = {
+      // zlevel: 0,
+      z: 0,
+      center: ["50%", "50%"],
+      radius: "75%",
+      startAngle: 90,
+      axisName: {
+        show: !0
+        // formatter: null
+        // textStyle: {}
+      },
+      boundaryGap: [0, 0],
+      splitNumber: 5,
+      axisNameGap: 15,
+      scale: !1,
+      // Polygon or circle
+      shape: "polygon",
+      axisLine: p({
+        lineStyle: {
+          color: "#bbb"
+        }
+      }, r.axisLine),
+      axisLabel: o(r.axisLabel, !1),
+      axisTick: o(r.axisTick, !1),
+      // axisType: 'value',
+      splitLine: o(r.splitLine, !0),
+      splitArea: o(r.splitArea, !0),
+      // {text, min, max}
+      indicator: []
+    }, a;
+  })(_)
+);
+export {
+  j as default
+};

package/dist/node_modules/echarts/lib/coord/scaleRawExtentInfo.js

@@ -0,0 +1,70 @@
+import { isFunction as h, isArray as v, eqNaN as m } from "../../../zrender/lib/core/util.js";
+import { parsePercent as x } from "../../../zrender/lib/contain/text.js";
+var p = (
+  /** @class */
+  (function() {
+    function r(i, e, a) {
+      this._prepareParams(i, e, a);
+    }
+    return r.prototype._prepareParams = function(i, e, a) {
+      a[1] < a[0] && (a = [NaN, NaN]), this._dataMin = a[0], this._dataMax = a[1];
+      var l = this._isOrdinal = i.type === "ordinal";
+      this._needCrossZero = i.type === "interval" && e.getNeedCrossZero && e.getNeedCrossZero();
+      var u = e.get("min", !0);
+      u == null && (u = e.get("startValue", !0));
+      var o = this._modelMinRaw = u;
+      h(o) ? this._modelMinNum = M(i, o({
+        min: a[0],
+        max: a[1]
+      })) : o !== "dataMin" && (this._modelMinNum = M(i, o));
+      var n = this._modelMaxRaw = e.get("max", !0);
+      if (h(n) ? this._modelMaxNum = M(i, n({
+        min: a[0],
+        max: a[1]
+      })) : n !== "dataMax" && (this._modelMaxNum = M(i, n)), l)
+        this._axisDataLen = e.getCategories().length;
+      else {
+        var t = e.get("boundaryGap"), s = v(t) ? t : [t || 0, t || 0];
+        typeof s[0] == "boolean" || typeof s[1] == "boolean" ? this._boundaryGapInner = [0, 0] : this._boundaryGapInner = [x(s[0], 1), x(s[1], 1)];
+      }
+    }, r.prototype.calculate = function() {
+      var i = this._isOrdinal, e = this._dataMin, a = this._dataMax, l = this._axisDataLen, u = this._boundaryGapInner, o = i ? null : a - e || Math.abs(e), n = this._modelMinRaw === "dataMin" ? e : this._modelMinNum, t = this._modelMaxRaw === "dataMax" ? a : this._modelMaxNum, s = n != null, f = t != null;
+      n == null && (n = i ? l ? 0 : NaN : e - u[0] * o), t == null && (t = i ? l ? l - 1 : NaN : a + u[1] * o), (n == null || !isFinite(n)) && (n = NaN), (t == null || !isFinite(t)) && (t = NaN);
+      var N = m(n) || m(t) || i && !l;
+      this._needCrossZero && (n > 0 && t > 0 && !s && (n = 0), n < 0 && t < 0 && !f && (t = 0));
+      var _ = this._determinedMin, d = this._determinedMax;
+      return _ != null && (n = _, s = !0), d != null && (t = d, f = !0), {
+        min: n,
+        max: t,
+        minFixed: s,
+        maxFixed: f,
+        isBlank: N
+      };
+    }, r.prototype.modifyDataMinMax = function(i, e) {
+      this[I[i]] = e;
+    }, r.prototype.setDeterminedMinMax = function(i, e) {
+      var a = w[i];
+      this[a] = e;
+    }, r.prototype.freeze = function() {
+      this.frozen = !0;
+    }, r;
+  })()
+), w = {
+  min: "_determinedMin",
+  max: "_determinedMax"
+}, I = {
+  min: "_dataMin",
+  max: "_dataMax"
+};
+function c(r, i, e) {
+  var a = r.rawExtentInfo;
+  return a || (a = new p(r, i, e), r.rawExtentInfo = a, a);
+}
+function M(r, i) {
+  return i == null ? null : m(i) ? NaN : r.parse(i);
+}
+export {
+  p as ScaleRawExtentInfo,
+  c as ensureScaleRawExtentInfo,
+  M as parseAxisModelMinMax
+};

package/dist/node_modules/echarts/lib/coord/single/AxisModel.js

@@ -0,0 +1,60 @@
+import { __extends as i } from "../../../../tslib/tslib.es6.js";
+import n from "../../model/Component.js";
+import { AxisModelCommonMixin as l } from "../axisModelCommonMixin.js";
+import { mixin as r } from "../../../../zrender/lib/core/util.js";
+var s = (
+  /** @class */
+  (function(o) {
+    i(t, o);
+    function t() {
+      var e = o !== null && o.apply(this, arguments) || this;
+      return e.type = t.type, e;
+    }
+    return t.prototype.getCoordSysModel = function() {
+      return this;
+    }, t.type = "singleAxis", t.layoutMode = "box", t.defaultOption = {
+      left: "5%",
+      top: "5%",
+      right: "5%",
+      bottom: "5%",
+      type: "value",
+      position: "bottom",
+      orient: "horizontal",
+      axisLine: {
+        show: !0,
+        lineStyle: {
+          width: 1,
+          type: "solid"
+        }
+      },
+      // Single coordinate system and single axis is the,
+      // which is used as the parent tooltip model.
+      // same model, so we set default tooltip show as true.
+      tooltip: {
+        show: !0
+      },
+      axisTick: {
+        show: !0,
+        length: 6,
+        lineStyle: {
+          width: 1
+        }
+      },
+      axisLabel: {
+        show: !0,
+        interval: "auto"
+      },
+      splitLine: {
+        show: !0,
+        lineStyle: {
+          type: "dashed",
+          opacity: 0.2
+        }
+      }
+    }, t;
+  })(n)
+);
+r(s, l.prototype);
+export {
+  s as default
+};

package/dist/node_modules/echarts/lib/coord/single/Single.js

@@ -0,0 +1,88 @@
+import h from "./SingleAxis.js";
+import { createScaleByModel as c, niceScaleExtent as u } from "../axisHelper.js";
+import { getLayoutRect as g } from "../../util/layout.js";
+import { each as p } from "../../../../zrender/lib/core/util.js";
+var y = ["single"], x = (
+  /** @class */
+  (function() {
+    function n(t, e, i) {
+      this.type = "single", this.dimension = "single", this.dimensions = y, this.axisPointerEnabled = !0, this.model = t, this._init(t, e, i);
+    }
+    return n.prototype._init = function(t, e, i) {
+      var o = this.dimension, r = new h(o, c(t), [0, 0], t.get("type"), t.get("position")), s = r.type === "category";
+      r.onBand = s && t.get("boundaryGap"), r.inverse = t.get("inverse"), r.orient = t.get("orient"), t.axis = r, r.model = t, r.coordinateSystem = this, this._axis = r;
+    }, n.prototype.update = function(t, e) {
+      t.eachSeries(function(i) {
+        if (i.coordinateSystem === this) {
+          var o = i.getData();
+          p(o.mapDimensionsAll(this.dimension), function(r) {
+            this._axis.scale.unionExtentFromData(o, r);
+          }, this), u(this._axis.scale, this._axis.model);
+        }
+      }, this);
+    }, n.prototype.resize = function(t, e) {
+      this._rect = g({
+        left: t.get("left"),
+        top: t.get("top"),
+        right: t.get("right"),
+        bottom: t.get("bottom"),
+        width: t.get("width"),
+        height: t.get("height")
+      }, {
+        width: e.getWidth(),
+        height: e.getHeight()
+      }), this._adjustAxis();
+    }, n.prototype.getRect = function() {
+      return this._rect;
+    }, n.prototype._adjustAxis = function() {
+      var t = this._rect, e = this._axis, i = e.isHorizontal(), o = i ? [0, t.width] : [0, t.height], r = e.inverse ? 1 : 0;
+      e.setExtent(o[r], o[1 - r]), this._updateAxisTransform(e, i ? t.x : t.y);
+    }, n.prototype._updateAxisTransform = function(t, e) {
+      var i = t.getExtent(), o = i[0] + i[1], r = t.isHorizontal();
+      t.toGlobalCoord = r ? function(s) {
+        return s + e;
+      } : function(s) {
+        return o - s + e;
+      }, t.toLocalCoord = r ? function(s) {
+        return s - e;
+      } : function(s) {
+        return o - s + e;
+      };
+    }, n.prototype.getAxis = function() {
+      return this._axis;
+    }, n.prototype.getBaseAxis = function() {
+      return this._axis;
+    }, n.prototype.getAxes = function() {
+      return [this._axis];
+    }, n.prototype.getTooltipAxes = function() {
+      return {
+        baseAxes: [this.getAxis()],
+        // Empty otherAxes
+        otherAxes: []
+      };
+    }, n.prototype.containPoint = function(t) {
+      var e = this.getRect(), i = this.getAxis(), o = i.orient;
+      return o === "horizontal" ? i.contain(i.toLocalCoord(t[0])) && t[1] >= e.y && t[1] <= e.y + e.height : i.contain(i.toLocalCoord(t[1])) && t[0] >= e.y && t[0] <= e.y + e.height;
+    }, n.prototype.pointToData = function(t) {
+      var e = this.getAxis();
+      return [e.coordToData(e.toLocalCoord(t[e.orient === "horizontal" ? 0 : 1]))];
+    }, n.prototype.dataToPoint = function(t) {
+      var e = this.getAxis(), i = this.getRect(), o = [], r = e.orient === "horizontal" ? 0 : 1;
+      return t instanceof Array && (t = t[0]), o[r] = e.toGlobalCoord(e.dataToCoord(+t)), o[1 - r] = r === 0 ? i.y + i.height / 2 : i.x + i.width / 2, o;
+    }, n.prototype.convertToPixel = function(t, e, i) {
+      var o = a(e);
+      return o === this ? this.dataToPoint(i) : null;
+    }, n.prototype.convertFromPixel = function(t, e, i) {
+      var o = a(e);
+      return o === this ? this.pointToData(i) : null;
+    }, n;
+  })()
+);
+function a(n) {
+  var t = n.seriesModel, e = n.singleAxisModel;
+  return e && e.coordinateSystem || t && t.coordinateSystem;
+}
+export {
+  x as default,
+  y as singleDimensions
+};