@fecp/mobile 1.0.78 → 1.1.0

package/es/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/animation/Clip.mjs

@@ -0,0 +1,63 @@
+import easingFuncs from "./easing.mjs";
+import { noop, isFunction } from "../core/util.mjs";
+import { createCubicEasingFunc } from "./cubicEasing.mjs";
+var Clip = function() {
+  function Clip2(opts) {
+    this._inited = false;
+    this._startTime = 0;
+    this._pausedTime = 0;
+    this._paused = false;
+    this._life = opts.life || 1e3;
+    this._delay = opts.delay || 0;
+    this.loop = opts.loop || false;
+    this.onframe = opts.onframe || noop;
+    this.ondestroy = opts.ondestroy || noop;
+    this.onrestart = opts.onrestart || noop;
+    opts.easing && this.setEasing(opts.easing);
+  }
+  Clip2.prototype.step = function(globalTime, deltaTime) {
+    if (!this._inited) {
+      this._startTime = globalTime + this._delay;
+      this._inited = true;
+    }
+    if (this._paused) {
+      this._pausedTime += deltaTime;
+      return;
+    }
+    var life = this._life;
+    var elapsedTime = globalTime - this._startTime - this._pausedTime;
+    var percent = elapsedTime / life;
+    if (percent < 0) {
+      percent = 0;
+    }
+    percent = Math.min(percent, 1);
+    var easingFunc = this.easingFunc;
+    var schedule = easingFunc ? easingFunc(percent) : percent;
+    this.onframe(schedule);
+    if (percent === 1) {
+      if (this.loop) {
+        var remainder = elapsedTime % life;
+        this._startTime = globalTime - remainder;
+        this._pausedTime = 0;
+        this.onrestart();
+      } else {
+        return true;
+      }
+    }
+    return false;
+  };
+  Clip2.prototype.pause = function() {
+    this._paused = true;
+  };
+  Clip2.prototype.resume = function() {
+    this._paused = false;
+  };
+  Clip2.prototype.setEasing = function(easing) {
+    this.easing = easing;
+    this.easingFunc = isFunction(easing) ? easing : easingFuncs[easing] || createCubicEasingFunc(easing);
+  };
+  return Clip2;
+}();
+export {
+  Clip as default
+};

package/es/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/animation/cubicEasing.mjs

@@ -0,0 +1,23 @@
+import { cubicRootAt, cubicAt } from "../core/curve.mjs";
+import { trim } from "../core/util.mjs";
+var regexp = /cubic-bezier\(([0-9,\.e ]+)\)/;
+function createCubicEasingFunc(cubicEasingStr) {
+  var cubic = cubicEasingStr && regexp.exec(cubicEasingStr);
+  if (cubic) {
+    var points = cubic[1].split(",");
+    var a_1 = +trim(points[0]);
+    var b_1 = +trim(points[1]);
+    var c_1 = +trim(points[2]);
+    var d_1 = +trim(points[3]);
+    if (isNaN(a_1 + b_1 + c_1 + d_1)) {
+      return;
+    }
+    var roots_1 = [];
+    return function(p) {
+      return p <= 0 ? 0 : p >= 1 ? 1 : cubicRootAt(0, a_1, c_1, 1, p, roots_1) && cubicAt(0, b_1, d_1, 1, roots_1[0]);
+    };
+  }
+}
+export {
+  createCubicEasingFunc
+};

package/es/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/animation/easing.mjs

@@ -0,0 +1,187 @@
+var easingFuncs = {
+  linear: function(k) {
+    return k;
+  },
+  quadraticIn: function(k) {
+    return k * k;
+  },
+  quadraticOut: function(k) {
+    return k * (2 - k);
+  },
+  quadraticInOut: function(k) {
+    if ((k *= 2) < 1) {
+      return 0.5 * k * k;
+    }
+    return -0.5 * (--k * (k - 2) - 1);
+  },
+  cubicIn: function(k) {
+    return k * k * k;
+  },
+  cubicOut: function(k) {
+    return --k * k * k + 1;
+  },
+  cubicInOut: function(k) {
+    if ((k *= 2) < 1) {
+      return 0.5 * k * k * k;
+    }
+    return 0.5 * ((k -= 2) * k * k + 2);
+  },
+  quarticIn: function(k) {
+    return k * k * k * k;
+  },
+  quarticOut: function(k) {
+    return 1 - --k * k * k * k;
+  },
+  quarticInOut: function(k) {
+    if ((k *= 2) < 1) {
+      return 0.5 * k * k * k * k;
+    }
+    return -0.5 * ((k -= 2) * k * k * k - 2);
+  },
+  quinticIn: function(k) {
+    return k * k * k * k * k;
+  },
+  quinticOut: function(k) {
+    return --k * k * k * k * k + 1;
+  },
+  quinticInOut: function(k) {
+    if ((k *= 2) < 1) {
+      return 0.5 * k * k * k * k * k;
+    }
+    return 0.5 * ((k -= 2) * k * k * k * k + 2);
+  },
+  sinusoidalIn: function(k) {
+    return 1 - Math.cos(k * Math.PI / 2);
+  },
+  sinusoidalOut: function(k) {
+    return Math.sin(k * Math.PI / 2);
+  },
+  sinusoidalInOut: function(k) {
+    return 0.5 * (1 - Math.cos(Math.PI * k));
+  },
+  exponentialIn: function(k) {
+    return k === 0 ? 0 : Math.pow(1024, k - 1);
+  },
+  exponentialOut: function(k) {
+    return k === 1 ? 1 : 1 - Math.pow(2, -10 * k);
+  },
+  exponentialInOut: function(k) {
+    if (k === 0) {
+      return 0;
+    }
+    if (k === 1) {
+      return 1;
+    }
+    if ((k *= 2) < 1) {
+      return 0.5 * Math.pow(1024, k - 1);
+    }
+    return 0.5 * (-Math.pow(2, -10 * (k - 1)) + 2);
+  },
+  circularIn: function(k) {
+    return 1 - Math.sqrt(1 - k * k);
+  },
+  circularOut: function(k) {
+    return Math.sqrt(1 - --k * k);
+  },
+  circularInOut: function(k) {
+    if ((k *= 2) < 1) {
+      return -0.5 * (Math.sqrt(1 - k * k) - 1);
+    }
+    return 0.5 * (Math.sqrt(1 - (k -= 2) * k) + 1);
+  },
+  elasticIn: function(k) {
+    var s;
+    var a = 0.1;
+    var p = 0.4;
+    if (k === 0) {
+      return 0;
+    }
+    if (k === 1) {
+      return 1;
+    }
+    if (!a || a < 1) {
+      a = 1;
+      s = p / 4;
+    } else {
+      s = p * Math.asin(1 / a) / (2 * Math.PI);
+    }
+    return -(a * Math.pow(2, 10 * (k -= 1)) * Math.sin((k - s) * (2 * Math.PI) / p));
+  },
+  elasticOut: function(k) {
+    var s;
+    var a = 0.1;
+    var p = 0.4;
+    if (k === 0) {
+      return 0;
+    }
+    if (k === 1) {
+      return 1;
+    }
+    if (!a || a < 1) {
+      a = 1;
+      s = p / 4;
+    } else {
+      s = p * Math.asin(1 / a) / (2 * Math.PI);
+    }
+    return a * Math.pow(2, -10 * k) * Math.sin((k - s) * (2 * Math.PI) / p) + 1;
+  },
+  elasticInOut: function(k) {
+    var s;
+    var a = 0.1;
+    var p = 0.4;
+    if (k === 0) {
+      return 0;
+    }
+    if (k === 1) {
+      return 1;
+    }
+    if (!a || a < 1) {
+      a = 1;
+      s = p / 4;
+    } else {
+      s = p * Math.asin(1 / a) / (2 * Math.PI);
+    }
+    if ((k *= 2) < 1) {
+      return -0.5 * (a * Math.pow(2, 10 * (k -= 1)) * Math.sin((k - s) * (2 * Math.PI) / p));
+    }
+    return a * Math.pow(2, -10 * (k -= 1)) * Math.sin((k - s) * (2 * Math.PI) / p) * 0.5 + 1;
+  },
+  backIn: function(k) {
+    var s = 1.70158;
+    return k * k * ((s + 1) * k - s);
+  },
+  backOut: function(k) {
+    var s = 1.70158;
+    return --k * k * ((s + 1) * k + s) + 1;
+  },
+  backInOut: function(k) {
+    var s = 1.70158 * 1.525;
+    if ((k *= 2) < 1) {
+      return 0.5 * (k * k * ((s + 1) * k - s));
+    }
+    return 0.5 * ((k -= 2) * k * ((s + 1) * k + s) + 2);
+  },
+  bounceIn: function(k) {
+    return 1 - easingFuncs.bounceOut(1 - k);
+  },
+  bounceOut: function(k) {
+    if (k < 1 / 2.75) {
+      return 7.5625 * k * k;
+    } else if (k < 2 / 2.75) {
+      return 7.5625 * (k -= 1.5 / 2.75) * k + 0.75;
+    } else if (k < 2.5 / 2.75) {
+      return 7.5625 * (k -= 2.25 / 2.75) * k + 0.9375;
+    } else {
+      return 7.5625 * (k -= 2.625 / 2.75) * k + 0.984375;
+    }
+  },
+  bounceInOut: function(k) {
+    if (k < 0.5) {
+      return easingFuncs.bounceIn(k * 2) * 0.5;
+    }
+    return easingFuncs.bounceOut(k * 2 - 1) * 0.5 + 0.5;
+  }
+};
+export {
+  easingFuncs as default
+};

package/es/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/animation/requestAnimationFrame.mjs

@@ -0,0 +1,8 @@
+import env from "../core/env.mjs";
+var requestAnimationFrame;
+requestAnimationFrame = env.hasGlobalWindow && (window.requestAnimationFrame && window.requestAnimationFrame.bind(window) || window.msRequestAnimationFrame && window.msRequestAnimationFrame.bind(window) || window.mozRequestAnimationFrame || window.webkitRequestAnimationFrame) || function(func) {
+  return setTimeout(func, 16);
+};
+export {
+  requestAnimationFrame as default
+};

package/es/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/canvas/Layer.mjs

@@ -0,0 +1,286 @@
+import { __extends } from "../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs";
+import { isObject, disableUserSelect, each, isGradientObject, isImagePatternObject } from "../core/util.mjs";
+import { devicePixelRatio } from "../config.mjs";
+import Eventful from "../core/Eventful.mjs";
+import { getCanvasGradient } from "./helper.mjs";
+import { createCanvasPattern } from "./graphic.mjs";
+import BoundingRect from "../core/BoundingRect.mjs";
+import { REDRAW_BIT } from "../graphic/constants.mjs";
+import { platformApi } from "../core/platform.mjs";
+function createDom(id, painter, dpr) {
+  var newDom = platformApi.createCanvas();
+  var width = painter.getWidth();
+  var height = painter.getHeight();
+  var newDomStyle = newDom.style;
+  if (newDomStyle) {
+    newDomStyle.position = "absolute";
+    newDomStyle.left = "0";
+    newDomStyle.top = "0";
+    newDomStyle.width = width + "px";
+    newDomStyle.height = height + "px";
+    newDom.setAttribute("data-zr-dom-id", id);
+  }
+  newDom.width = width * dpr;
+  newDom.height = height * dpr;
+  return newDom;
+}
+var Layer = function(_super) {
+  __extends(Layer2, _super);
+  function Layer2(id, painter, dpr) {
+    var _this = _super.call(this) || this;
+    _this.motionBlur = false;
+    _this.lastFrameAlpha = 0.7;
+    _this.dpr = 1;
+    _this.virtual = false;
+    _this.config = {};
+    _this.incremental = false;
+    _this.zlevel = 0;
+    _this.maxRepaintRectCount = 5;
+    _this.__dirty = true;
+    _this.__firstTimePaint = true;
+    _this.__used = false;
+    _this.__drawIndex = 0;
+    _this.__startIndex = 0;
+    _this.__endIndex = 0;
+    _this.__prevStartIndex = null;
+    _this.__prevEndIndex = null;
+    var dom;
+    dpr = dpr || devicePixelRatio;
+    if (typeof id === "string") {
+      dom = createDom(id, painter, dpr);
+    } else if (isObject(id)) {
+      dom = id;
+      id = dom.id;
+    }
+    _this.id = id;
+    _this.dom = dom;
+    var domStyle = dom.style;
+    if (domStyle) {
+      disableUserSelect(dom);
+      dom.onselectstart = function() {
+        return false;
+      };
+      domStyle.padding = "0";
+      domStyle.margin = "0";
+      domStyle.borderWidth = "0";
+    }
+    _this.painter = painter;
+    _this.dpr = dpr;
+    return _this;
+  }
+  Layer2.prototype.getElementCount = function() {
+    return this.__endIndex - this.__startIndex;
+  };
+  Layer2.prototype.afterBrush = function() {
+    this.__prevStartIndex = this.__startIndex;
+    this.__prevEndIndex = this.__endIndex;
+  };
+  Layer2.prototype.initContext = function() {
+    this.ctx = this.dom.getContext("2d");
+    this.ctx.dpr = this.dpr;
+  };
+  Layer2.prototype.setUnpainted = function() {
+    this.__firstTimePaint = true;
+  };
+  Layer2.prototype.createBackBuffer = function() {
+    var dpr = this.dpr;
+    this.domBack = createDom("back-" + this.id, this.painter, dpr);
+    this.ctxBack = this.domBack.getContext("2d");
+    if (dpr !== 1) {
+      this.ctxBack.scale(dpr, dpr);
+    }
+  };
+  Layer2.prototype.createRepaintRects = function(displayList, prevList, viewWidth, viewHeight) {
+    if (this.__firstTimePaint) {
+      this.__firstTimePaint = false;
+      return null;
+    }
+    var mergedRepaintRects = [];
+    var maxRepaintRectCount = this.maxRepaintRectCount;
+    var full = false;
+    var pendingRect = new BoundingRect(0, 0, 0, 0);
+    function addRectToMergePool(rect) {
+      if (!rect.isFinite() || rect.isZero()) {
+        return;
+      }
+      if (mergedRepaintRects.length === 0) {
+        var boundingRect = new BoundingRect(0, 0, 0, 0);
+        boundingRect.copy(rect);
+        mergedRepaintRects.push(boundingRect);
+      } else {
+        var isMerged = false;
+        var minDeltaArea = Infinity;
+        var bestRectToMergeIdx = 0;
+        for (var i2 = 0; i2 < mergedRepaintRects.length; ++i2) {
+          var mergedRect = mergedRepaintRects[i2];
+          if (mergedRect.intersect(rect)) {
+            var pendingRect_1 = new BoundingRect(0, 0, 0, 0);
+            pendingRect_1.copy(mergedRect);
+            pendingRect_1.union(rect);
+            mergedRepaintRects[i2] = pendingRect_1;
+            isMerged = true;
+            break;
+          } else if (full) {
+            pendingRect.copy(rect);
+            pendingRect.union(mergedRect);
+            var aArea = rect.width * rect.height;
+            var bArea = mergedRect.width * mergedRect.height;
+            var pendingArea = pendingRect.width * pendingRect.height;
+            var deltaArea = pendingArea - aArea - bArea;
+            if (deltaArea < minDeltaArea) {
+              minDeltaArea = deltaArea;
+              bestRectToMergeIdx = i2;
+            }
+          }
+        }
+        if (full) {
+          mergedRepaintRects[bestRectToMergeIdx].union(rect);
+          isMerged = true;
+        }
+        if (!isMerged) {
+          var boundingRect = new BoundingRect(0, 0, 0, 0);
+          boundingRect.copy(rect);
+          mergedRepaintRects.push(boundingRect);
+        }
+        if (!full) {
+          full = mergedRepaintRects.length >= maxRepaintRectCount;
+        }
+      }
+    }
+    for (var i = this.__startIndex; i < this.__endIndex; ++i) {
+      var el = displayList[i];
+      if (el) {
+        var shouldPaint = el.shouldBePainted(viewWidth, viewHeight, true, true);
+        var prevRect = el.__isRendered && (el.__dirty & REDRAW_BIT || !shouldPaint) ? el.getPrevPaintRect() : null;
+        if (prevRect) {
+          addRectToMergePool(prevRect);
+        }
+        var curRect = shouldPaint && (el.__dirty & REDRAW_BIT || !el.__isRendered) ? el.getPaintRect() : null;
+        if (curRect) {
+          addRectToMergePool(curRect);
+        }
+      }
+    }
+    for (var i = this.__prevStartIndex; i < this.__prevEndIndex; ++i) {
+      var el = prevList[i];
+      var shouldPaint = el && el.shouldBePainted(viewWidth, viewHeight, true, true);
+      if (el && (!shouldPaint || !el.__zr) && el.__isRendered) {
+        var prevRect = el.getPrevPaintRect();
+        if (prevRect) {
+          addRectToMergePool(prevRect);
+        }
+      }
+    }
+    var hasIntersections;
+    do {
+      hasIntersections = false;
+      for (var i = 0; i < mergedRepaintRects.length; ) {
+        if (mergedRepaintRects[i].isZero()) {
+          mergedRepaintRects.splice(i, 1);
+          continue;
+        }
+        for (var j = i + 1; j < mergedRepaintRects.length; ) {
+          if (mergedRepaintRects[i].intersect(mergedRepaintRects[j])) {
+            hasIntersections = true;
+            mergedRepaintRects[i].union(mergedRepaintRects[j]);
+            mergedRepaintRects.splice(j, 1);
+          } else {
+            j++;
+          }
+        }
+        i++;
+      }
+    } while (hasIntersections);
+    this._paintRects = mergedRepaintRects;
+    return mergedRepaintRects;
+  };
+  Layer2.prototype.debugGetPaintRects = function() {
+    return (this._paintRects || []).slice();
+  };
+  Layer2.prototype.resize = function(width, height) {
+    var dpr = this.dpr;
+    var dom = this.dom;
+    var domStyle = dom.style;
+    var domBack = this.domBack;
+    if (domStyle) {
+      domStyle.width = width + "px";
+      domStyle.height = height + "px";
+    }
+    dom.width = width * dpr;
+    dom.height = height * dpr;
+    if (domBack) {
+      domBack.width = width * dpr;
+      domBack.height = height * dpr;
+      if (dpr !== 1) {
+        this.ctxBack.scale(dpr, dpr);
+      }
+    }
+  };
+  Layer2.prototype.clear = function(clearAll, clearColor, repaintRects) {
+    var dom = this.dom;
+    var ctx = this.ctx;
+    var width = dom.width;
+    var height = dom.height;
+    clearColor = clearColor || this.clearColor;
+    var haveMotionBLur = this.motionBlur && !clearAll;
+    var lastFrameAlpha = this.lastFrameAlpha;
+    var dpr = this.dpr;
+    var self = this;
+    if (haveMotionBLur) {
+      if (!this.domBack) {
+        this.createBackBuffer();
+      }
+      this.ctxBack.globalCompositeOperation = "copy";
+      this.ctxBack.drawImage(dom, 0, 0, width / dpr, height / dpr);
+    }
+    var domBack = this.domBack;
+    function doClear(x, y, width2, height2) {
+      ctx.clearRect(x, y, width2, height2);
+      if (clearColor && clearColor !== "transparent") {
+        var clearColorGradientOrPattern = void 0;
+        if (isGradientObject(clearColor)) {
+          var shouldCache = clearColor.global || clearColor.__width === width2 && clearColor.__height === height2;
+          clearColorGradientOrPattern = shouldCache && clearColor.__canvasGradient || getCanvasGradient(ctx, clearColor, {
+            x: 0,
+            y: 0,
+            width: width2,
+            height: height2
+          });
+          clearColor.__canvasGradient = clearColorGradientOrPattern;
+          clearColor.__width = width2;
+          clearColor.__height = height2;
+        } else if (isImagePatternObject(clearColor)) {
+          clearColor.scaleX = clearColor.scaleX || dpr;
+          clearColor.scaleY = clearColor.scaleY || dpr;
+          clearColorGradientOrPattern = createCanvasPattern(ctx, clearColor, {
+            dirty: function() {
+              self.setUnpainted();
+              self.painter.refresh();
+            }
+          });
+        }
+        ctx.save();
+        ctx.fillStyle = clearColorGradientOrPattern || clearColor;
+        ctx.fillRect(x, y, width2, height2);
+        ctx.restore();
+      }
+      if (haveMotionBLur) {
+        ctx.save();
+        ctx.globalAlpha = lastFrameAlpha;
+        ctx.drawImage(domBack, x, y, width2, height2);
+        ctx.restore();
+      }
+    }
+    if (!repaintRects || haveMotionBLur) {
+      doClear(0, 0, width, height);
+    } else if (repaintRects.length) {
+      each(repaintRects, function(rect) {
+        doClear(rect.x * dpr, rect.y * dpr, rect.width * dpr, rect.height * dpr);
+      });
+    }
+  };
+  return Layer2;
+}(Eventful);
+export {
+  Layer as default
+};