web-core-tcm 0.0.54 → 0.0.61

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

@@ -0,0 +1,21 @@
+import { __extends as s } from "../../../../tslib/tslib.es6.js";
+import u from "../Axis.js";
+var c = (
+  /** @class */
+  (function(n) {
+    s(o, n);
+    function o(t, r, e, a, p) {
+      var i = n.call(this, t, r, e) || this;
+      return i.type = a || "value", i.position = p || "bottom", i;
+    }
+    return o.prototype.isHorizontal = function() {
+      var t = this.position;
+      return t === "top" || t === "bottom";
+    }, o.prototype.pointToData = function(t, r) {
+      return this.coordinateSystem.pointToData(t)[0];
+    }, o;
+  })(u)
+);
+export {
+  c as default
+};

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

@@ -0,0 +1,26 @@
+import { bind as a } from "../../../../zrender/lib/core/util.js";
+function n(r, t) {
+  var i = this.getAxis(), o = t instanceof Array ? t[0] : t, e = (r instanceof Array ? r[0] : r) / 2;
+  return i.type === "category" ? i.getBandWidth() : Math.abs(i.dataToCoord(o - e) - i.dataToCoord(o + e));
+}
+function h(r) {
+  var t = r.getRect();
+  return {
+    coordSys: {
+      type: "singleAxis",
+      x: t.x,
+      y: t.y,
+      width: t.width,
+      height: t.height
+    },
+    api: {
+      coord: function(i) {
+        return r.dataToPoint(i);
+      },
+      size: a(n, r)
+    }
+  };
+}
+export {
+  h as default
+};

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

@@ -0,0 +1,32 @@
+import { retrieve as g } from "../../../../zrender/lib/core/util.js";
+function D(o, e) {
+  e = e || {};
+  var s = o.coordinateSystem, c = o.axis, t = {}, a = c.position, l = c.orient, i = s.getRect(), r = [i.x, i.x + i.width, i.y, i.y + i.height], v = {
+    horizontal: {
+      top: r[2],
+      bottom: r[3]
+    },
+    vertical: {
+      left: r[0],
+      right: r[1]
+    }
+  };
+  t.position = [l === "vertical" ? v.vertical[a] : r[0], l === "horizontal" ? v.horizontal[a] : r[3]];
+  var b = {
+    horizontal: 0,
+    vertical: 1
+  };
+  t.rotation = Math.PI / 2 * b[l];
+  var h = {
+    top: -1,
+    bottom: 1,
+    right: 1,
+    left: -1
+  };
+  t.labelDirection = t.tickDirection = t.nameDirection = h[a], o.get(["axisTick", "inside"]) && (t.tickDirection = -t.tickDirection), g(e.labelInside, o.get(["axisLabel", "inside"])) && (t.labelDirection = -t.labelDirection);
+  var n = e.rotate;
+  return n == null && (n = o.get(["axisLabel", "rotate"])), t.labelRotation = a === "top" ? -n : n, t.z2 = 1, t;
+}
+export {
+  D as layout
+};

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

@@ -0,0 +1,21 @@
+import o, { singleDimensions as m } from "./Single.js";
+import { SINGLE_REFERRING as a } from "../../util/model.js";
+function g(i, r) {
+  var s = [];
+  return i.eachComponent("singleAxis", function(n, e) {
+    var t = new o(n, i, r);
+    t.name = "single_" + e, t.resize(n, r), n.coordinateSystem = t, s.push(t);
+  }), i.eachSeries(function(n) {
+    if (n.get("coordinateSystem") === "singleAxis") {
+      var e = n.getReferringComponents("singleAxis", a).models[0];
+      n.coordinateSystem = e && e.coordinateSystem;
+    }
+  }), s;
+}
+var S = {
+  create: g,
+  dimensions: m
+};
+export {
+  S as default
+};

package/dist/node_modules/echarts/lib/core/CoordinateSystem.js

@@ -0,0 +1,29 @@
+import { each as a } from "../../../zrender/lib/core/util.js";
+var r = {}, d = (
+  /** @class */
+  (function() {
+    function e() {
+      this._coordinateSystems = [];
+    }
+    return e.prototype.create = function(t, n) {
+      var o = [];
+      a(r, function(i, c) {
+        var s = i.create(t, n);
+        o = o.concat(s || []);
+      }), this._coordinateSystems = o;
+    }, e.prototype.update = function(t, n) {
+      a(this._coordinateSystems, function(o) {
+        o.update && o.update(t, n);
+      });
+    }, e.prototype.getCoordinateSystems = function() {
+      return this._coordinateSystems.slice();
+    }, e.register = function(t, n) {
+      r[t] = n;
+    }, e.get = function(t) {
+      return r[t];
+    }, e;
+  })()
+);
+export {
+  d as default
+};

package/dist/node_modules/echarts/lib/core/ExtensionAPI.js

@@ -0,0 +1,34 @@
+import { each as o, bind as a } from "../../../zrender/lib/core/util.js";
+var n = [
+  "getDom",
+  "getZr",
+  "getWidth",
+  "getHeight",
+  "getDevicePixelRatio",
+  "dispatchAction",
+  "isSSR",
+  "isDisposed",
+  "on",
+  "off",
+  "getDataURL",
+  "getConnectedDataURL",
+  // 'getModel',
+  "getOption",
+  // 'getViewOfComponentModel',
+  // 'getViewOfSeriesModel',
+  "getId",
+  "updateLabelLayout"
+], s = (
+  /** @class */
+  /* @__PURE__ */ (function() {
+    function i(t) {
+      o(n, function(e) {
+        this[e] = a(t[e], t);
+      }, this);
+    }
+    return i;
+  })()
+);
+export {
+  s as default
+};

package/dist/node_modules/echarts/lib/core/Scheduler.js

@@ -0,0 +1,226 @@
+import { createHashMap as m, each as _, assert as P, isFunction as I, map as w, noop as A } from "../../../zrender/lib/core/util.js";
+import { createTask as S } from "./task.js";
+import { getUID as C } from "../util/component.js";
+import E from "../model/Global.js";
+import O from "./ExtensionAPI.js";
+import { normalizeToArray as V } from "../util/model.js";
+var Z = (
+  /** @class */
+  (function() {
+    function a(e, t, i, r) {
+      this._stageTaskMap = m(), this.ecInstance = e, this.api = t, i = this._dataProcessorHandlers = i.slice(), r = this._visualHandlers = r.slice(), this._allHandlers = i.concat(r);
+    }
+    return a.prototype.restoreData = function(e, t) {
+      e.restoreData(t), this._stageTaskMap.each(function(i) {
+        var r = i.overallTask;
+        r && r.dirty();
+      });
+    }, a.prototype.getPerformArgs = function(e, t) {
+      if (e.__pipeline) {
+        var i = this._pipelineMap.get(e.__pipeline.id), r = i.context, s = !t && i.progressiveEnabled && (!r || r.progressiveRender) && e.__idxInPipeline > i.blockIndex, n = s ? i.step : null, l = r && r.modDataCount, p = l != null ? Math.ceil(l / n) : null;
+        return {
+          step: n,
+          modBy: p,
+          modDataCount: l
+        };
+      }
+    }, a.prototype.getPipeline = function(e) {
+      return this._pipelineMap.get(e);
+    }, a.prototype.updateStreamModes = function(e, t) {
+      var i = this._pipelineMap.get(e.uid), r = e.getData(), s = r.count(), n = i.progressiveEnabled && t.incrementalPrepareRender && s >= i.threshold, l = e.get("large") && s >= e.get("largeThreshold"), p = e.get("progressiveChunkMode") === "mod" ? s : null;
+      e.pipelineContext = i.context = {
+        progressiveRender: n,
+        modDataCount: p,
+        large: l
+      };
+    }, a.prototype.restorePipelines = function(e) {
+      var t = this, i = t._pipelineMap = m();
+      e.eachSeries(function(r) {
+        var s = r.getProgressive(), n = r.uid;
+        i.set(n, {
+          id: n,
+          head: null,
+          tail: null,
+          threshold: r.getProgressiveThreshold(),
+          progressiveEnabled: s && !(r.preventIncremental && r.preventIncremental()),
+          blockIndex: -1,
+          step: Math.round(s || 700),
+          count: 0
+        }), t._pipe(r, r.dataTask);
+      });
+    }, a.prototype.prepareStageTasks = function() {
+      var e = this._stageTaskMap, t = this.api.getModel(), i = this.api;
+      _(this._allHandlers, function(r) {
+        var s = e.get(r.uid) || e.set(r.uid, {}), n = "";
+        P(!(r.reset && r.overallReset), n), r.reset && this._createSeriesStageTask(r, s, t, i), r.overallReset && this._createOverallStageTask(r, s, t, i);
+      }, this);
+    }, a.prototype.prepareView = function(e, t, i, r) {
+      var s = e.renderTask, n = s.context;
+      n.model = t, n.ecModel = i, n.api = r, s.__block = !e.incrementalPrepareRender, this._pipe(t, s);
+    }, a.prototype.performDataProcessorTasks = function(e, t) {
+      this._performStageTasks(this._dataProcessorHandlers, e, t, {
+        block: !0
+      });
+    }, a.prototype.performVisualTasks = function(e, t, i) {
+      this._performStageTasks(this._visualHandlers, e, t, i);
+    }, a.prototype._performStageTasks = function(e, t, i, r) {
+      r = r || {};
+      var s = !1, n = this;
+      _(e, function(p, v) {
+        if (!(r.visualType && r.visualType !== p.visualType)) {
+          var f = n._stageTaskMap.get(p.uid), c = f.seriesTaskMap, u = f.overallTask;
+          if (u) {
+            var h, d = u.agentStubMap;
+            d.each(function(o) {
+              l(r, o) && (o.dirty(), h = !0);
+            }), h && u.dirty(), n.updatePayload(u, i);
+            var T = n.getPerformArgs(u, r.block);
+            d.each(function(o) {
+              o.perform(T);
+            }), u.perform(T) && (s = !0);
+          } else c && c.each(function(o, g) {
+            l(r, o) && o.dirty();
+            var b = n.getPerformArgs(o, r.block);
+            b.skip = !p.performRawSeries && t.isSeriesFiltered(o.context.model), n.updatePayload(o, i), o.perform(b) && (s = !0);
+          });
+        }
+      });
+      function l(p, v) {
+        return p.setDirty && (!p.dirtyMap || p.dirtyMap.get(v.__pipeline.id));
+      }
+      this.unfinished = s || this.unfinished;
+    }, a.prototype.performSeriesTasks = function(e) {
+      var t;
+      e.eachSeries(function(i) {
+        t = i.dataTask.perform() || t;
+      }), this.unfinished = t || this.unfinished;
+    }, a.prototype.plan = function() {
+      this._pipelineMap.each(function(e) {
+        var t = e.tail;
+        do {
+          if (t.__block) {
+            e.blockIndex = t.__idxInPipeline;
+            break;
+          }
+          t = t.getUpstream();
+        } while (t);
+      });
+    }, a.prototype.updatePayload = function(e, t) {
+      t !== "remain" && (e.context.payload = t);
+    }, a.prototype._createSeriesStageTask = function(e, t, i, r) {
+      var s = this, n = t.seriesTaskMap, l = t.seriesTaskMap = m(), p = e.seriesType, v = e.getTargetSeries;
+      e.createOnAllSeries ? i.eachRawSeries(f) : p ? i.eachRawSeriesByType(p, f) : v && v(i, r).each(f);
+      function f(c) {
+        var u = c.uid, h = l.set(u, n && n.get(u) || S({
+          plan: U,
+          reset: z,
+          count: j
+        }));
+        h.context = {
+          model: c,
+          ecModel: i,
+          api: r,
+          // PENDING: `useClearVisual` not used?
+          useClearVisual: e.isVisual && !e.isLayout,
+          plan: e.plan,
+          reset: e.reset,
+          scheduler: s
+        }, s._pipe(c, h);
+      }
+    }, a.prototype._createOverallStageTask = function(e, t, i, r) {
+      var s = this, n = t.overallTask = t.overallTask || S({
+        reset: B
+      });
+      n.context = {
+        ecModel: i,
+        api: r,
+        overallReset: e.overallReset,
+        scheduler: s
+      };
+      var l = n.agentStubMap, p = n.agentStubMap = m(), v = e.seriesType, f = e.getTargetSeries, c = !0, u = !1, h = "";
+      P(!e.createOnAllSeries, h), v ? i.eachRawSeriesByType(v, d) : f ? f(i, r).each(d) : (c = !1, _(i.getSeries(), d));
+      function d(T) {
+        var o = T.uid, g = p.set(o, l && l.get(o) || // When the result of `getTargetSeries` changed, the overallTask
+        // should be set as dirty and re-performed.
+        (u = !0, S({
+          reset: x,
+          onDirty: L
+        })));
+        g.context = {
+          model: T,
+          overallProgress: c
+          // FIXME:TS never used, so comment it
+          // modifyOutputEnd: modifyOutputEnd
+        }, g.agent = n, g.__block = c, s._pipe(T, g);
+      }
+      u && n.dirty();
+    }, a.prototype._pipe = function(e, t) {
+      var i = e.uid, r = this._pipelineMap.get(i);
+      !r.head && (r.head = t), r.tail && r.tail.pipe(t), r.tail = t, t.__idxInPipeline = r.count++, t.__pipeline = r;
+    }, a.wrapStageHandler = function(e, t) {
+      return I(e) && (e = {
+        overallReset: e,
+        seriesType: q(e)
+      }), e.uid = C("stageHandler"), t && (e.visualType = t), e;
+    }, a;
+  })()
+);
+function B(a) {
+  a.overallReset(a.ecModel, a.api, a.payload);
+}
+function x(a) {
+  return a.overallProgress && F;
+}
+function F() {
+  this.agent.dirty(), this.getDownstream().dirty();
+}
+function L() {
+  this.agent && this.agent.dirty();
+}
+function U(a) {
+  return a.plan ? a.plan(a.model, a.ecModel, a.api, a.payload) : null;
+}
+function z(a) {
+  a.useClearVisual && a.data.clearAllVisual();
+  var e = a.resetDefines = V(a.reset(a.model, a.ecModel, a.api, a.payload));
+  return e.length > 1 ? w(e, function(t, i) {
+    return M(i);
+  }) : G;
+}
+var G = M(0);
+function M(a) {
+  return function(e, t) {
+    var i = t.data, r = t.resetDefines[a];
+    if (r && r.dataEach)
+      for (var s = e.start; s < e.end; s++)
+        r.dataEach(i, s);
+    else r && r.progress && r.progress(e, i);
+  };
+}
+function j(a) {
+  return a.data.count();
+}
+function q(a) {
+  k = null;
+  try {
+    a(y, D);
+  } catch {
+  }
+  return k;
+}
+var y = {}, D = {}, k;
+R(y, E);
+R(D, O);
+y.eachSeriesByType = y.eachRawSeriesByType = function(a) {
+  k = a;
+};
+y.eachComponent = function(a) {
+  a.mainType === "series" && a.subType && (k = a.subType);
+};
+function R(a, e) {
+  for (var t in e.prototype)
+    a[t] = A;
+}
+export {
+  Z as default
+};