@fecp/mobile 1.0.79 → 1.1.1

package/lib/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/Handler.js

@@ -0,0 +1,295 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const tslib_es6 = require("../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js");
+const util = require("./core/util.js");
+const vector = require("./core/vector.js");
+const Draggable = require("./mixin/Draggable.js");
+const Eventful = require("./core/Eventful.js");
+const event = require("./core/event.js");
+const GestureMgr = require("./core/GestureMgr.js");
+const BoundingRect = require("./core/BoundingRect.js");
+var SILENT = "silent";
+function makeEventPacket(eveType, targetInfo, event2) {
+  return {
+    type: eveType,
+    event: event2,
+    target: targetInfo.target,
+    topTarget: targetInfo.topTarget,
+    cancelBubble: false,
+    offsetX: event2.zrX,
+    offsetY: event2.zrY,
+    gestureEvent: event2.gestureEvent,
+    pinchX: event2.pinchX,
+    pinchY: event2.pinchY,
+    pinchScale: event2.pinchScale,
+    wheelDelta: event2.zrDelta,
+    zrByTouch: event2.zrByTouch,
+    which: event2.which,
+    stop: stopEvent
+  };
+}
+function stopEvent() {
+  event.stop(this.event);
+}
+var EmptyProxy = function(_super) {
+  tslib_es6.__extends(EmptyProxy2, _super);
+  function EmptyProxy2() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.handler = null;
+    return _this;
+  }
+  EmptyProxy2.prototype.dispose = function() {
+  };
+  EmptyProxy2.prototype.setCursor = function() {
+  };
+  return EmptyProxy2;
+}(Eventful.default);
+var HoveredResult = /* @__PURE__ */ function() {
+  function HoveredResult2(x, y) {
+    this.x = x;
+    this.y = y;
+  }
+  return HoveredResult2;
+}();
+var handlerNames = [
+  "click",
+  "dblclick",
+  "mousewheel",
+  "mouseout",
+  "mouseup",
+  "mousedown",
+  "mousemove",
+  "contextmenu"
+];
+var tmpRect = new BoundingRect.default(0, 0, 0, 0);
+var Handler = function(_super) {
+  tslib_es6.__extends(Handler2, _super);
+  function Handler2(storage, painter, proxy, painterRoot, pointerSize) {
+    var _this = _super.call(this) || this;
+    _this._hovered = new HoveredResult(0, 0);
+    _this.storage = storage;
+    _this.painter = painter;
+    _this.painterRoot = painterRoot;
+    _this._pointerSize = pointerSize;
+    proxy = proxy || new EmptyProxy();
+    _this.proxy = null;
+    _this.setHandlerProxy(proxy);
+    _this._draggingMgr = new Draggable.default(_this);
+    return _this;
+  }
+  Handler2.prototype.setHandlerProxy = function(proxy) {
+    if (this.proxy) {
+      this.proxy.dispose();
+    }
+    if (proxy) {
+      util.each(handlerNames, function(name) {
+        proxy.on && proxy.on(name, this[name], this);
+      }, this);
+      proxy.handler = this;
+    }
+    this.proxy = proxy;
+  };
+  Handler2.prototype.mousemove = function(event2) {
+    var x = event2.zrX;
+    var y = event2.zrY;
+    var isOutside = isOutsideBoundary(this, x, y);
+    var lastHovered = this._hovered;
+    var lastHoveredTarget = lastHovered.target;
+    if (lastHoveredTarget && !lastHoveredTarget.__zr) {
+      lastHovered = this.findHover(lastHovered.x, lastHovered.y);
+      lastHoveredTarget = lastHovered.target;
+    }
+    var hovered = this._hovered = isOutside ? new HoveredResult(x, y) : this.findHover(x, y);
+    var hoveredTarget = hovered.target;
+    var proxy = this.proxy;
+    proxy.setCursor && proxy.setCursor(hoveredTarget ? hoveredTarget.cursor : "default");
+    if (lastHoveredTarget && hoveredTarget !== lastHoveredTarget) {
+      this.dispatchToElement(lastHovered, "mouseout", event2);
+    }
+    this.dispatchToElement(hovered, "mousemove", event2);
+    if (hoveredTarget && hoveredTarget !== lastHoveredTarget) {
+      this.dispatchToElement(hovered, "mouseover", event2);
+    }
+  };
+  Handler2.prototype.mouseout = function(event2) {
+    var eventControl = event2.zrEventControl;
+    if (eventControl !== "only_globalout") {
+      this.dispatchToElement(this._hovered, "mouseout", event2);
+    }
+    if (eventControl !== "no_globalout") {
+      this.trigger("globalout", { type: "globalout", event: event2 });
+    }
+  };
+  Handler2.prototype.resize = function() {
+    this._hovered = new HoveredResult(0, 0);
+  };
+  Handler2.prototype.dispatch = function(eventName, eventArgs) {
+    var handler = this[eventName];
+    handler && handler.call(this, eventArgs);
+  };
+  Handler2.prototype.dispose = function() {
+    this.proxy.dispose();
+    this.storage = null;
+    this.proxy = null;
+    this.painter = null;
+  };
+  Handler2.prototype.setCursorStyle = function(cursorStyle) {
+    var proxy = this.proxy;
+    proxy.setCursor && proxy.setCursor(cursorStyle);
+  };
+  Handler2.prototype.dispatchToElement = function(targetInfo, eventName, event2) {
+    targetInfo = targetInfo || {};
+    var el = targetInfo.target;
+    if (el && el.silent) {
+      return;
+    }
+    var eventKey = "on" + eventName;
+    var eventPacket = makeEventPacket(eventName, targetInfo, event2);
+    while (el) {
+      el[eventKey] && (eventPacket.cancelBubble = !!el[eventKey].call(el, eventPacket));
+      el.trigger(eventName, eventPacket);
+      el = el.__hostTarget ? el.__hostTarget : el.parent;
+      if (eventPacket.cancelBubble) {
+        break;
+      }
+    }
+    if (!eventPacket.cancelBubble) {
+      this.trigger(eventName, eventPacket);
+      if (this.painter && this.painter.eachOtherLayer) {
+        this.painter.eachOtherLayer(function(layer) {
+          if (typeof layer[eventKey] === "function") {
+            layer[eventKey].call(layer, eventPacket);
+          }
+          if (layer.trigger) {
+            layer.trigger(eventName, eventPacket);
+          }
+        });
+      }
+    }
+  };
+  Handler2.prototype.findHover = function(x, y, exclude) {
+    var list = this.storage.getDisplayList();
+    var out = new HoveredResult(x, y);
+    setHoverTarget(list, out, x, y, exclude);
+    if (this._pointerSize && !out.target) {
+      var candidates = [];
+      var pointerSize = this._pointerSize;
+      var targetSizeHalf = pointerSize / 2;
+      var pointerRect = new BoundingRect.default(x - targetSizeHalf, y - targetSizeHalf, pointerSize, pointerSize);
+      for (var i = list.length - 1; i >= 0; i--) {
+        var el = list[i];
+        if (el !== exclude && !el.ignore && !el.ignoreCoarsePointer && (!el.parent || !el.parent.ignoreCoarsePointer)) {
+          tmpRect.copy(el.getBoundingRect());
+          if (el.transform) {
+            tmpRect.applyTransform(el.transform);
+          }
+          if (tmpRect.intersect(pointerRect)) {
+            candidates.push(el);
+          }
+        }
+      }
+      if (candidates.length) {
+        var rStep = 4;
+        var thetaStep = Math.PI / 12;
+        var PI2 = Math.PI * 2;
+        for (var r = 0; r < targetSizeHalf; r += rStep) {
+          for (var theta = 0; theta < PI2; theta += thetaStep) {
+            var x1 = x + r * Math.cos(theta);
+            var y1 = y + r * Math.sin(theta);
+            setHoverTarget(candidates, out, x1, y1, exclude);
+            if (out.target) {
+              return out;
+            }
+          }
+        }
+      }
+    }
+    return out;
+  };
+  Handler2.prototype.processGesture = function(event2, stage) {
+    if (!this._gestureMgr) {
+      this._gestureMgr = new GestureMgr.GestureMgr();
+    }
+    var gestureMgr = this._gestureMgr;
+    stage === "start" && gestureMgr.clear();
+    var gestureInfo = gestureMgr.recognize(event2, this.findHover(event2.zrX, event2.zrY, null).target, this.proxy.dom);
+    stage === "end" && gestureMgr.clear();
+    if (gestureInfo) {
+      var type = gestureInfo.type;
+      event2.gestureEvent = type;
+      var res = new HoveredResult();
+      res.target = gestureInfo.target;
+      this.dispatchToElement(res, type, gestureInfo.event);
+    }
+  };
+  return Handler2;
+}(Eventful.default);
+util.each(["click", "mousedown", "mouseup", "mousewheel", "dblclick", "contextmenu"], function(name) {
+  Handler.prototype[name] = function(event2) {
+    var x = event2.zrX;
+    var y = event2.zrY;
+    var isOutside = isOutsideBoundary(this, x, y);
+    var hovered;
+    var hoveredTarget;
+    if (name !== "mouseup" || !isOutside) {
+      hovered = this.findHover(x, y);
+      hoveredTarget = hovered.target;
+    }
+    if (name === "mousedown") {
+      this._downEl = hoveredTarget;
+      this._downPoint = [event2.zrX, event2.zrY];
+      this._upEl = hoveredTarget;
+    } else if (name === "mouseup") {
+      this._upEl = hoveredTarget;
+    } else if (name === "click") {
+      if (this._downEl !== this._upEl || !this._downPoint || vector.dist(this._downPoint, [event2.zrX, event2.zrY]) > 4) {
+        return;
+      }
+      this._downPoint = null;
+    }
+    this.dispatchToElement(hovered, name, event2);
+  };
+});
+function isHover(displayable, x, y) {
+  if (displayable[displayable.rectHover ? "rectContain" : "contain"](x, y)) {
+    var el = displayable;
+    var isSilent = void 0;
+    var ignoreClip = false;
+    while (el) {
+      if (el.ignoreClip) {
+        ignoreClip = true;
+      }
+      if (!ignoreClip) {
+        var clipPath = el.getClipPath();
+        if (clipPath && !clipPath.contain(x, y)) {
+          return false;
+        }
+      }
+      if (el.silent) {
+        isSilent = true;
+      }
+      var hostEl = el.__hostTarget;
+      el = hostEl ? hostEl : el.parent;
+    }
+    return isSilent ? SILENT : true;
+  }
+  return false;
+}
+function setHoverTarget(list, out, x, y, exclude) {
+  for (var i = list.length - 1; i >= 0; i--) {
+    var el = list[i];
+    var hoverCheckResult = void 0;
+    if (el !== exclude && !el.ignore && (hoverCheckResult = isHover(el, x, y))) {
+      !out.topTarget && (out.topTarget = el);
+      if (hoverCheckResult !== SILENT) {
+        out.target = el;
+        break;
+      }
+    }
+  }
+}
+function isOutsideBoundary(handlerInstance, x, y) {
+  var painter = handlerInstance.painter;
+  return x < 0 || x > painter.getWidth() || y < 0 || y > painter.getHeight();
+}
+exports.default = Handler;

package/lib/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/Storage.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const util = require("./core/util.js");
+const timsort = require("./core/timsort.js");
+const constants = require("./graphic/constants.js");
+var invalidZErrorLogged = false;
+function logInvalidZError() {
+  if (invalidZErrorLogged) {
+    return;
+  }
+  invalidZErrorLogged = true;
+  console.warn("z / z2 / zlevel of displayable is invalid, which may cause unexpected errors");
+}
+function shapeCompareFunc(a, b) {
+  if (a.zlevel === b.zlevel) {
+    if (a.z === b.z) {
+      return a.z2 - b.z2;
+    }
+    return a.z - b.z;
+  }
+  return a.zlevel - b.zlevel;
+}
+var Storage = function() {
+  function Storage2() {
+    this._roots = [];
+    this._displayList = [];
+    this._displayListLen = 0;
+    this.displayableSortFunc = shapeCompareFunc;
+  }
+  Storage2.prototype.traverse = function(cb, context) {
+    for (var i = 0; i < this._roots.length; i++) {
+      this._roots[i].traverse(cb, context);
+    }
+  };
+  Storage2.prototype.getDisplayList = function(update, includeIgnore) {
+    includeIgnore = includeIgnore || false;
+    var displayList = this._displayList;
+    if (update || !displayList.length) {
+      this.updateDisplayList(includeIgnore);
+    }
+    return displayList;
+  };
+  Storage2.prototype.updateDisplayList = function(includeIgnore) {
+    this._displayListLen = 0;
+    var roots = this._roots;
+    var displayList = this._displayList;
+    for (var i = 0, len = roots.length; i < len; i++) {
+      this._updateAndAddDisplayable(roots[i], null, includeIgnore);
+    }
+    displayList.length = this._displayListLen;
+    timsort.default(displayList, shapeCompareFunc);
+  };
+  Storage2.prototype._updateAndAddDisplayable = function(el, clipPaths, includeIgnore) {
+    if (el.ignore && !includeIgnore) {
+      return;
+    }
+    el.beforeUpdate();
+    el.update();
+    el.afterUpdate();
+    var userSetClipPath = el.getClipPath();
+    if (el.ignoreClip) {
+      clipPaths = null;
+    } else if (userSetClipPath) {
+      if (clipPaths) {
+        clipPaths = clipPaths.slice();
+      } else {
+        clipPaths = [];
+      }
+      var currentClipPath = userSetClipPath;
+      var parentClipPath = el;
+      while (currentClipPath) {
+        currentClipPath.parent = parentClipPath;
+        currentClipPath.updateTransform();
+        clipPaths.push(currentClipPath);
+        parentClipPath = currentClipPath;
+        currentClipPath = currentClipPath.getClipPath();
+      }
+    }
+    if (el.childrenRef) {
+      var children = el.childrenRef();
+      for (var i = 0; i < children.length; i++) {
+        var child = children[i];
+        if (el.__dirty) {
+          child.__dirty |= constants.REDRAW_BIT;
+        }
+        this._updateAndAddDisplayable(child, clipPaths, includeIgnore);
+      }
+      el.__dirty = 0;
+    } else {
+      var disp = el;
+      if (clipPaths && clipPaths.length) {
+        disp.__clipPaths = clipPaths;
+      } else if (disp.__clipPaths && disp.__clipPaths.length > 0) {
+        disp.__clipPaths = [];
+      }
+      if (isNaN(disp.z)) {
+        logInvalidZError();
+        disp.z = 0;
+      }
+      if (isNaN(disp.z2)) {
+        logInvalidZError();
+        disp.z2 = 0;
+      }
+      if (isNaN(disp.zlevel)) {
+        logInvalidZError();
+        disp.zlevel = 0;
+      }
+      this._displayList[this._displayListLen++] = disp;
+    }
+    var decalEl = el.getDecalElement && el.getDecalElement();
+    if (decalEl) {
+      this._updateAndAddDisplayable(decalEl, clipPaths, includeIgnore);
+    }
+    var textGuide = el.getTextGuideLine();
+    if (textGuide) {
+      this._updateAndAddDisplayable(textGuide, clipPaths, includeIgnore);
+    }
+    var textEl = el.getTextContent();
+    if (textEl) {
+      this._updateAndAddDisplayable(textEl, clipPaths, includeIgnore);
+    }
+  };
+  Storage2.prototype.addRoot = function(el) {
+    if (el.__zr && el.__zr.storage === this) {
+      return;
+    }
+    this._roots.push(el);
+  };
+  Storage2.prototype.delRoot = function(el) {
+    if (el instanceof Array) {
+      for (var i = 0, l = el.length; i < l; i++) {
+        this.delRoot(el[i]);
+      }
+      return;
+    }
+    var idx = util.indexOf(this._roots, el);
+    if (idx >= 0) {
+      this._roots.splice(idx, 1);
+    }
+  };
+  Storage2.prototype.delAllRoots = function() {
+    this._roots = [];
+    this._displayList = [];
+    this._displayListLen = 0;
+    return;
+  };
+  Storage2.prototype.getRoots = function() {
+    return this._roots;
+  };
+  Storage2.prototype.dispose = function() {
+    this._displayList = null;
+    this._roots = null;
+  };
+  return Storage2;
+}();
+exports.default = Storage;

package/lib/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/animation/Animation.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const tslib_es6 = require("../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js");
+const Eventful = require("../core/Eventful.js");
+const requestAnimationFrame = require("./requestAnimationFrame.js");
+const Animator = require("./Animator.js");
+function getTime() {
+  return (/* @__PURE__ */ new Date()).getTime();
+}
+var Animation = function(_super) {
+  tslib_es6.__extends(Animation2, _super);
+  function Animation2(opts) {
+    var _this = _super.call(this) || this;
+    _this._running = false;
+    _this._time = 0;
+    _this._pausedTime = 0;
+    _this._pauseStart = 0;
+    _this._paused = false;
+    opts = opts || {};
+    _this.stage = opts.stage || {};
+    return _this;
+  }
+  Animation2.prototype.addClip = function(clip) {
+    if (clip.animation) {
+      this.removeClip(clip);
+    }
+    if (!this._head) {
+      this._head = this._tail = clip;
+    } else {
+      this._tail.next = clip;
+      clip.prev = this._tail;
+      clip.next = null;
+      this._tail = clip;
+    }
+    clip.animation = this;
+  };
+  Animation2.prototype.addAnimator = function(animator) {
+    animator.animation = this;
+    var clip = animator.getClip();
+    if (clip) {
+      this.addClip(clip);
+    }
+  };
+  Animation2.prototype.removeClip = function(clip) {
+    if (!clip.animation) {
+      return;
+    }
+    var prev = clip.prev;
+    var next = clip.next;
+    if (prev) {
+      prev.next = next;
+    } else {
+      this._head = next;
+    }
+    if (next) {
+      next.prev = prev;
+    } else {
+      this._tail = prev;
+    }
+    clip.next = clip.prev = clip.animation = null;
+  };
+  Animation2.prototype.removeAnimator = function(animator) {
+    var clip = animator.getClip();
+    if (clip) {
+      this.removeClip(clip);
+    }
+    animator.animation = null;
+  };
+  Animation2.prototype.update = function(notTriggerFrameAndStageUpdate) {
+    var time = getTime() - this._pausedTime;
+    var delta = time - this._time;
+    var clip = this._head;
+    while (clip) {
+      var nextClip = clip.next;
+      var finished = clip.step(time, delta);
+      if (finished) {
+        clip.ondestroy();
+        this.removeClip(clip);
+        clip = nextClip;
+      } else {
+        clip = nextClip;
+      }
+    }
+    this._time = time;
+    if (!notTriggerFrameAndStageUpdate) {
+      this.trigger("frame", delta);
+      this.stage.update && this.stage.update();
+    }
+  };
+  Animation2.prototype._startLoop = function() {
+    var self = this;
+    this._running = true;
+    function step() {
+      if (self._running) {
+        requestAnimationFrame.default(step);
+        !self._paused && self.update();
+      }
+    }
+    requestAnimationFrame.default(step);
+  };
+  Animation2.prototype.start = function() {
+    if (this._running) {
+      return;
+    }
+    this._time = getTime();
+    this._pausedTime = 0;
+    this._startLoop();
+  };
+  Animation2.prototype.stop = function() {
+    this._running = false;
+  };
+  Animation2.prototype.pause = function() {
+    if (!this._paused) {
+      this._pauseStart = getTime();
+      this._paused = true;
+    }
+  };
+  Animation2.prototype.resume = function() {
+    if (this._paused) {
+      this._pausedTime += getTime() - this._pauseStart;
+      this._paused = false;
+    }
+  };
+  Animation2.prototype.clear = function() {
+    var clip = this._head;
+    while (clip) {
+      var nextClip = clip.next;
+      clip.prev = clip.next = clip.animation = null;
+      clip = nextClip;
+    }
+    this._head = this._tail = null;
+  };
+  Animation2.prototype.isFinished = function() {
+    return this._head == null;
+  };
+  Animation2.prototype.animate = function(target, options) {
+    options = options || {};
+    this.start();
+    var animator = new Animator.default(target, options.loop);
+    this.addAnimator(animator);
+    return animator;
+  };
+  return Animation2;
+}(Eventful.default);
+exports.default = Animation;
+exports.getTime = getTime;