yahee-components 0.0.70 → 0.0.71

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/core/CoordinateSystem.js

@@ -0,0 +1,105 @@
+import { each as S, assert as f, createHashMap as g } from "../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js";
+import { SINGLE_REFERRING as N } from "../util/model.js";
+import { error as l } from "../util/log.js";
+var u = {}, p = {}, D = (
+  /** @class */
+  function() {
+    function o() {
+      this._normalMasterList = [], this._nonSeriesBoxMasterList = [];
+    }
+    return o.prototype.create = function(e, r) {
+      this._nonSeriesBoxMasterList = t(u, !0), this._normalMasterList = t(p, !1);
+      function t(i, a) {
+        var n = [];
+        return S(i, function(d, y) {
+          var c = d.create(e, r);
+          n = n.concat(c || []), process.env.NODE_ENV !== "production" && a && S(c, function(v) {
+            return f(!v.update);
+          });
+        }), n;
+      }
+    }, o.prototype.update = function(e, r) {
+      S(this._normalMasterList, function(t) {
+        t.update && t.update(e, r);
+      });
+    }, o.prototype.getCoordinateSystems = function() {
+      return this._normalMasterList.concat(this._nonSeriesBoxMasterList);
+    }, o.register = function(e, r) {
+      if (e === "matrix" || e === "calendar") {
+        u[e] = r;
+        return;
+      }
+      p[e] = r;
+    }, o.get = function(e) {
+      return p[e] || u[e];
+    }, o;
+  }()
+);
+function x(o) {
+  return !!u[o];
+}
+var m = {
+  // By default fetch coord from `model.get('coord')`.
+  coord: 1,
+  // Some model/series, such as pie, is allowed to also get coord from `model.get('center')`,
+  // if cannot get from `model.get('coord')`. But historically pie use `center` option, but
+  // geo use `layoutCenter` option to specify layout center; they are not able to be unified.
+  // Therefor it is not recommended.
+  coord2: 2
+};
+function O(o) {
+  process.env.NODE_ENV !== "production" && f(!C.get(o.fullType)), C.set(o.fullType, {
+    getCoord2: void 0
+  }).getCoord2 = o.getCoord2;
+}
+var C = g();
+function T(o) {
+  var e = o.getShallow("coord", !0), r = m.coord;
+  if (e == null) {
+    var t = C.get(o.type);
+    t && t.getCoord2 && (r = m.coord2, e = t.getCoord2(o));
+  }
+  return {
+    coord: e,
+    from: r
+  };
+}
+var s = {
+  none: 0,
+  dataCoordSys: 1,
+  boxCoordSys: 2
+};
+function E(o, e) {
+  var r = o.getShallow("coordinateSystem"), t = o.getShallow("coordinateSystemUsage", !0), i = t != null, a = s.none;
+  if (r) {
+    var n = o.mainType === "series";
+    t == null && (t = n ? "data" : "box"), t === "data" ? (a = s.dataCoordSys, n || (process.env.NODE_ENV !== "production" && i && e && l('coordinateSystemUsage "data" is not supported in non-series components.'), a = s.none)) : t === "box" && (a = s.boxCoordSys, !n && !x(r) && (process.env.NODE_ENV !== "production" && i && e && l('coordinateSystem "' + r + '" cannot be used' + (' as coordinateSystemUsage "box" for "' + o.type + '" yet.')), a = s.none));
+  }
+  return {
+    coordSysType: r,
+    kind: a
+  };
+}
+function B(o) {
+  var e = o.targetModel, r = o.coordSysType, t = o.coordSysProvider, i = o.isDefaultDataCoordSys, a = o.allowNotFound;
+  process.env.NODE_ENV !== "production" && f(!!r);
+  var n = E(e, !0), d = n.kind, y = n.coordSysType;
+  if (i && d !== s.dataCoordSys && (d = s.dataCoordSys, y = r), d === s.none || y !== r)
+    return !1;
+  var c = t(r, e);
+  return c ? (d === s.dataCoordSys ? (process.env.NODE_ENV !== "production" && f(e.mainType === "series"), e.coordinateSystem = c) : e.boxCoordinateSystem = c, !0) : (process.env.NODE_ENV !== "production" && (a || l(r + " cannot be found for" + (" " + e.type + " (index: " + e.componentIndex + ")."))), !1);
+}
+var L = function(o, e) {
+  var r = e.getReferringComponents(o, N).models[0];
+  return r && r.coordinateSystem;
+};
+export {
+  m as BoxCoordinateSystemCoordFrom,
+  s as CoordinateSystemUsageKind,
+  E as decideCoordSysUsageKind,
+  D as default,
+  T as getCoordForBoxCoordSys,
+  B as injectCoordSysByOption,
+  O as registerLayOutOnCoordSysUsage,
+  L as simpleCoordSysInjectionProvider
+};

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/core/ExtensionAPI.js

@@ -0,0 +1,34 @@
+import { each as o, bind as a } from "../../../../../zrender@6.0.0/node_modules/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/es/node_modules/.pnpm/echarts@6.0.0/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 C, noop as w } from "../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js";
+import { createTask as S } from "./task.js";
+import { getUID as A } from "../util/component.js";
+import E from "../model/Global.js";
+import O from "./ExtensionAPI.js";
+import { normalizeToArray as V } from "../util/model.js";
+var Y = (
+  /** @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, o = l != null ? Math.ceil(l / n) : null;
+        return {
+          step: n,
+          modBy: o,
+          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"), o = e.get("progressiveChunkMode") === "mod" ? s : null;
+      e.pipelineContext = i.context = {
+        progressiveRender: n,
+        modDataCount: o,
+        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 = "";
+        process.env.NODE_ENV !== "production" && (n = '"reset" and "overallReset" must not be both specified.'), 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(o, v) {
+        if (!(r.visualType && r.visualType !== o.visualType)) {
+          var f = n._stageTaskMap.get(o.uid), c = f.seriesTaskMap, u = f.overallTask;
+          if (u) {
+            var h, d = u.agentStubMap;
+            d.each(function(p) {
+              l(r, p) && (p.dirty(), h = !0);
+            }), h && u.dirty(), n.updatePayload(u, i);
+            var g = n.getPerformArgs(u, r.block);
+            d.each(function(p) {
+              p.perform(g);
+            }), u.perform(g) && (s = !0);
+          } else c && c.each(function(p, T) {
+            l(r, p) && p.dirty();
+            var b = n.getPerformArgs(p, r.block);
+            b.skip = !o.performRawSeries && t.isSeriesFiltered(p.context.model), n.updatePayload(p, i), p.perform(b) && (s = !0);
+          });
+        }
+      });
+      function l(o, v) {
+        return o.setDirty && (!o.dirtyMap || o.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(), o = e.seriesType, v = e.getTargetSeries;
+      e.createOnAllSeries ? i.eachRawSeries(f) : o ? i.eachRawSeriesByType(o, f) : v && v(i, r).each(f);
+      function f(c) {
+        var u = c.uid, h = l.set(u, n && n.get(u) || S({
+          plan: L,
+          reset: U,
+          count: G
+        }));
+        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, o = n.agentStubMap = m(), v = e.seriesType, f = e.getTargetSeries, c = !0, u = !1, h = "";
+      process.env.NODE_ENV !== "production" && (h = '"createOnAllSeries" is not supported for "overallReset", because it will block all streams.'), P(!e.createOnAllSeries, h), v ? i.eachRawSeriesByType(v, d) : f ? f(i, r).each(d) : (c = !1, _(i.getSeries(), d));
+      function d(g) {
+        var p = g.uid, T = o.set(p, l && l.get(p) || // When the result of `getTargetSeries` changed, the overallTask
+        // should be set as dirty and re-performed.
+        (u = !0, S({
+          reset: x,
+          onDirty: F
+        })));
+        T.context = {
+          model: g,
+          overallProgress: c
+          // FIXME:TS never used, so comment it
+          // modifyOutputEnd: modifyOutputEnd
+        }, T.agent = n, T.__block = c, s._pipe(g, T);
+      }
+      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: j(e)
+      }), e.uid = A("stageHandler"), t && (e.visualType = t), e;
+    }, a;
+  }()
+);
+function B(a) {
+  a.overallReset(a.ecModel, a.api, a.payload);
+}
+function x(a) {
+  return a.overallProgress && N;
+}
+function N() {
+  this.agent.dirty(), this.getDownstream().dirty();
+}
+function F() {
+  this.agent && this.agent.dirty();
+}
+function L(a) {
+  return a.plan ? a.plan(a.model, a.ecModel, a.api, a.payload) : null;
+}
+function U(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 ? C(e, function(t, i) {
+    return M(i);
+  }) : z;
+}
+var z = 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 G(a) {
+  return a.data.count();
+}
+function j(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] = w;
+}
+export {
+  Y as default
+};