@fecp/mobile 1.0.79 → 1.1.0

package/es/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/tool/path.mjs

@@ -0,0 +1,362 @@
+import { __extends } from "../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs";
+import Path from "../graphic/Path.mjs";
+import PathProxy from "../core/PathProxy.mjs";
+import transformPath from "./transformPath.mjs";
+import { extend } from "../core/util.mjs";
+var mathSqrt = Math.sqrt;
+var mathSin = Math.sin;
+var mathCos = Math.cos;
+var PI = Math.PI;
+function vMag(v) {
+  return Math.sqrt(v[0] * v[0] + v[1] * v[1]);
+}
+function vRatio(u, v) {
+  return (u[0] * v[0] + u[1] * v[1]) / (vMag(u) * vMag(v));
+}
+function vAngle(u, v) {
+  return (u[0] * v[1] < u[1] * v[0] ? -1 : 1) * Math.acos(vRatio(u, v));
+}
+function processArc(x1, y1, x2, y2, fa, fs, rx, ry, psiDeg, cmd, path) {
+  var psi = psiDeg * (PI / 180);
+  var xp = mathCos(psi) * (x1 - x2) / 2 + mathSin(psi) * (y1 - y2) / 2;
+  var yp = -1 * mathSin(psi) * (x1 - x2) / 2 + mathCos(psi) * (y1 - y2) / 2;
+  var lambda = xp * xp / (rx * rx) + yp * yp / (ry * ry);
+  if (lambda > 1) {
+    rx *= mathSqrt(lambda);
+    ry *= mathSqrt(lambda);
+  }
+  var f = (fa === fs ? -1 : 1) * mathSqrt((rx * rx * (ry * ry) - rx * rx * (yp * yp) - ry * ry * (xp * xp)) / (rx * rx * (yp * yp) + ry * ry * (xp * xp))) || 0;
+  var cxp = f * rx * yp / ry;
+  var cyp = f * -ry * xp / rx;
+  var cx = (x1 + x2) / 2 + mathCos(psi) * cxp - mathSin(psi) * cyp;
+  var cy = (y1 + y2) / 2 + mathSin(psi) * cxp + mathCos(psi) * cyp;
+  var theta = vAngle([1, 0], [(xp - cxp) / rx, (yp - cyp) / ry]);
+  var u = [(xp - cxp) / rx, (yp - cyp) / ry];
+  var v = [(-1 * xp - cxp) / rx, (-1 * yp - cyp) / ry];
+  var dTheta = vAngle(u, v);
+  if (vRatio(u, v) <= -1) {
+    dTheta = PI;
+  }
+  if (vRatio(u, v) >= 1) {
+    dTheta = 0;
+  }
+  if (dTheta < 0) {
+    var n = Math.round(dTheta / PI * 1e6) / 1e6;
+    dTheta = PI * 2 + n % 2 * PI;
+  }
+  path.addData(cmd, cx, cy, rx, ry, theta, dTheta, psi, fs);
+}
+var commandReg = /([mlvhzcqtsa])([^mlvhzcqtsa]*)/ig;
+var numberReg = /-?([0-9]*\.)?[0-9]+([eE]-?[0-9]+)?/g;
+function createPathProxyFromString(data) {
+  var path = new PathProxy();
+  if (!data) {
+    return path;
+  }
+  var cpx = 0;
+  var cpy = 0;
+  var subpathX = cpx;
+  var subpathY = cpy;
+  var prevCmd;
+  var CMD = PathProxy.CMD;
+  var cmdList = data.match(commandReg);
+  if (!cmdList) {
+    return path;
+  }
+  for (var l = 0; l < cmdList.length; l++) {
+    var cmdText = cmdList[l];
+    var cmdStr = cmdText.charAt(0);
+    var cmd = void 0;
+    var p = cmdText.match(numberReg) || [];
+    var pLen = p.length;
+    for (var i = 0; i < pLen; i++) {
+      p[i] = parseFloat(p[i]);
+    }
+    var off = 0;
+    while (off < pLen) {
+      var ctlPtx = void 0;
+      var ctlPty = void 0;
+      var rx = void 0;
+      var ry = void 0;
+      var psi = void 0;
+      var fa = void 0;
+      var fs = void 0;
+      var x1 = cpx;
+      var y1 = cpy;
+      var len = void 0;
+      var pathData = void 0;
+      switch (cmdStr) {
+        case "l":
+          cpx += p[off++];
+          cpy += p[off++];
+          cmd = CMD.L;
+          path.addData(cmd, cpx, cpy);
+          break;
+        case "L":
+          cpx = p[off++];
+          cpy = p[off++];
+          cmd = CMD.L;
+          path.addData(cmd, cpx, cpy);
+          break;
+        case "m":
+          cpx += p[off++];
+          cpy += p[off++];
+          cmd = CMD.M;
+          path.addData(cmd, cpx, cpy);
+          subpathX = cpx;
+          subpathY = cpy;
+          cmdStr = "l";
+          break;
+        case "M":
+          cpx = p[off++];
+          cpy = p[off++];
+          cmd = CMD.M;
+          path.addData(cmd, cpx, cpy);
+          subpathX = cpx;
+          subpathY = cpy;
+          cmdStr = "L";
+          break;
+        case "h":
+          cpx += p[off++];
+          cmd = CMD.L;
+          path.addData(cmd, cpx, cpy);
+          break;
+        case "H":
+          cpx = p[off++];
+          cmd = CMD.L;
+          path.addData(cmd, cpx, cpy);
+          break;
+        case "v":
+          cpy += p[off++];
+          cmd = CMD.L;
+          path.addData(cmd, cpx, cpy);
+          break;
+        case "V":
+          cpy = p[off++];
+          cmd = CMD.L;
+          path.addData(cmd, cpx, cpy);
+          break;
+        case "C":
+          cmd = CMD.C;
+          path.addData(cmd, p[off++], p[off++], p[off++], p[off++], p[off++], p[off++]);
+          cpx = p[off - 2];
+          cpy = p[off - 1];
+          break;
+        case "c":
+          cmd = CMD.C;
+          path.addData(cmd, p[off++] + cpx, p[off++] + cpy, p[off++] + cpx, p[off++] + cpy, p[off++] + cpx, p[off++] + cpy);
+          cpx += p[off - 2];
+          cpy += p[off - 1];
+          break;
+        case "S":
+          ctlPtx = cpx;
+          ctlPty = cpy;
+          len = path.len();
+          pathData = path.data;
+          if (prevCmd === CMD.C) {
+            ctlPtx += cpx - pathData[len - 4];
+            ctlPty += cpy - pathData[len - 3];
+          }
+          cmd = CMD.C;
+          x1 = p[off++];
+          y1 = p[off++];
+          cpx = p[off++];
+          cpy = p[off++];
+          path.addData(cmd, ctlPtx, ctlPty, x1, y1, cpx, cpy);
+          break;
+        case "s":
+          ctlPtx = cpx;
+          ctlPty = cpy;
+          len = path.len();
+          pathData = path.data;
+          if (prevCmd === CMD.C) {
+            ctlPtx += cpx - pathData[len - 4];
+            ctlPty += cpy - pathData[len - 3];
+          }
+          cmd = CMD.C;
+          x1 = cpx + p[off++];
+          y1 = cpy + p[off++];
+          cpx += p[off++];
+          cpy += p[off++];
+          path.addData(cmd, ctlPtx, ctlPty, x1, y1, cpx, cpy);
+          break;
+        case "Q":
+          x1 = p[off++];
+          y1 = p[off++];
+          cpx = p[off++];
+          cpy = p[off++];
+          cmd = CMD.Q;
+          path.addData(cmd, x1, y1, cpx, cpy);
+          break;
+        case "q":
+          x1 = p[off++] + cpx;
+          y1 = p[off++] + cpy;
+          cpx += p[off++];
+          cpy += p[off++];
+          cmd = CMD.Q;
+          path.addData(cmd, x1, y1, cpx, cpy);
+          break;
+        case "T":
+          ctlPtx = cpx;
+          ctlPty = cpy;
+          len = path.len();
+          pathData = path.data;
+          if (prevCmd === CMD.Q) {
+            ctlPtx += cpx - pathData[len - 4];
+            ctlPty += cpy - pathData[len - 3];
+          }
+          cpx = p[off++];
+          cpy = p[off++];
+          cmd = CMD.Q;
+          path.addData(cmd, ctlPtx, ctlPty, cpx, cpy);
+          break;
+        case "t":
+          ctlPtx = cpx;
+          ctlPty = cpy;
+          len = path.len();
+          pathData = path.data;
+          if (prevCmd === CMD.Q) {
+            ctlPtx += cpx - pathData[len - 4];
+            ctlPty += cpy - pathData[len - 3];
+          }
+          cpx += p[off++];
+          cpy += p[off++];
+          cmd = CMD.Q;
+          path.addData(cmd, ctlPtx, ctlPty, cpx, cpy);
+          break;
+        case "A":
+          rx = p[off++];
+          ry = p[off++];
+          psi = p[off++];
+          fa = p[off++];
+          fs = p[off++];
+          x1 = cpx, y1 = cpy;
+          cpx = p[off++];
+          cpy = p[off++];
+          cmd = CMD.A;
+          processArc(x1, y1, cpx, cpy, fa, fs, rx, ry, psi, cmd, path);
+          break;
+        case "a":
+          rx = p[off++];
+          ry = p[off++];
+          psi = p[off++];
+          fa = p[off++];
+          fs = p[off++];
+          x1 = cpx, y1 = cpy;
+          cpx += p[off++];
+          cpy += p[off++];
+          cmd = CMD.A;
+          processArc(x1, y1, cpx, cpy, fa, fs, rx, ry, psi, cmd, path);
+          break;
+      }
+    }
+    if (cmdStr === "z" || cmdStr === "Z") {
+      cmd = CMD.Z;
+      path.addData(cmd);
+      cpx = subpathX;
+      cpy = subpathY;
+    }
+    prevCmd = cmd;
+  }
+  path.toStatic();
+  return path;
+}
+var SVGPath = function(_super) {
+  __extends(SVGPath2, _super);
+  function SVGPath2() {
+    return _super !== null && _super.apply(this, arguments) || this;
+  }
+  SVGPath2.prototype.applyTransform = function(m) {
+  };
+  return SVGPath2;
+}(Path);
+function isPathProxy(path) {
+  return path.setData != null;
+}
+function createPathOptions(str, opts) {
+  var pathProxy = createPathProxyFromString(str);
+  var innerOpts = extend({}, opts);
+  innerOpts.buildPath = function(path) {
+    if (isPathProxy(path)) {
+      path.setData(pathProxy.data);
+      var ctx = path.getContext();
+      if (ctx) {
+        path.rebuildPath(ctx, 1);
+      }
+    } else {
+      var ctx = path;
+      pathProxy.rebuildPath(ctx, 1);
+    }
+  };
+  innerOpts.applyTransform = function(m) {
+    transformPath(pathProxy, m);
+    this.dirtyShape();
+  };
+  return innerOpts;
+}
+function createFromString(str, opts) {
+  return new SVGPath(createPathOptions(str, opts));
+}
+function extendFromString(str, defaultOpts) {
+  var innerOpts = createPathOptions(str, defaultOpts);
+  var Sub = function(_super) {
+    __extends(Sub2, _super);
+    function Sub2(opts) {
+      var _this = _super.call(this, opts) || this;
+      _this.applyTransform = innerOpts.applyTransform;
+      _this.buildPath = innerOpts.buildPath;
+      return _this;
+    }
+    return Sub2;
+  }(SVGPath);
+  return Sub;
+}
+function mergePath(pathEls, opts) {
+  var pathList = [];
+  var len = pathEls.length;
+  for (var i = 0; i < len; i++) {
+    var pathEl = pathEls[i];
+    pathList.push(pathEl.getUpdatedPathProxy(true));
+  }
+  var pathBundle = new Path(opts);
+  pathBundle.createPathProxy();
+  pathBundle.buildPath = function(path) {
+    if (isPathProxy(path)) {
+      path.appendPath(pathList);
+      var ctx = path.getContext();
+      if (ctx) {
+        path.rebuildPath(ctx, 1);
+      }
+    }
+  };
+  return pathBundle;
+}
+function clonePath(sourcePath, opts) {
+  opts = opts || {};
+  var path = new Path();
+  if (sourcePath.shape) {
+    path.setShape(sourcePath.shape);
+  }
+  path.setStyle(sourcePath.style);
+  if (opts.bakeTransform) {
+    transformPath(path.path, sourcePath.getComputedTransform());
+  } else {
+    if (opts.toLocal) {
+      path.setLocalTransform(sourcePath.getComputedTransform());
+    } else {
+      path.copyTransform(sourcePath);
+    }
+  }
+  path.buildPath = sourcePath.buildPath;
+  path.applyTransform = path.applyTransform;
+  path.z = sourcePath.z;
+  path.z2 = sourcePath.z2;
+  path.zlevel = sourcePath.zlevel;
+  return path;
+}
+export {
+  clonePath,
+  createFromString,
+  extendFromString,
+  mergePath
+};

package/es/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/tool/transformPath.mjs

@@ -0,0 +1,84 @@
+import PathProxy from "../core/PathProxy.mjs";
+import { applyTransform } from "../core/vector.mjs";
+var CMD = PathProxy.CMD;
+var points = [[], [], []];
+var mathSqrt = Math.sqrt;
+var mathAtan2 = Math.atan2;
+function transformPath(path, m) {
+  if (!m) {
+    return;
+  }
+  var data = path.data;
+  var len = path.len();
+  var cmd;
+  var nPoint;
+  var i;
+  var j;
+  var k;
+  var p;
+  var M = CMD.M;
+  var C = CMD.C;
+  var L = CMD.L;
+  var R = CMD.R;
+  var A = CMD.A;
+  var Q = CMD.Q;
+  for (i = 0, j = 0; i < len; ) {
+    cmd = data[i++];
+    j = i;
+    nPoint = 0;
+    switch (cmd) {
+      case M:
+        nPoint = 1;
+        break;
+      case L:
+        nPoint = 1;
+        break;
+      case C:
+        nPoint = 3;
+        break;
+      case Q:
+        nPoint = 2;
+        break;
+      case A:
+        var x = m[4];
+        var y = m[5];
+        var sx = mathSqrt(m[0] * m[0] + m[1] * m[1]);
+        var sy = mathSqrt(m[2] * m[2] + m[3] * m[3]);
+        var angle = mathAtan2(-m[1] / sy, m[0] / sx);
+        data[i] *= sx;
+        data[i++] += x;
+        data[i] *= sy;
+        data[i++] += y;
+        data[i++] *= sx;
+        data[i++] *= sy;
+        data[i++] += angle;
+        data[i++] += angle;
+        i += 2;
+        j = i;
+        break;
+      case R:
+        p[0] = data[i++];
+        p[1] = data[i++];
+        applyTransform(p, p, m);
+        data[j++] = p[0];
+        data[j++] = p[1];
+        p[0] += data[i++];
+        p[1] += data[i++];
+        applyTransform(p, p, m);
+        data[j++] = p[0];
+        data[j++] = p[1];
+    }
+    for (k = 0; k < nPoint; k++) {
+      var p_1 = points[k];
+      p_1[0] = data[i++];
+      p_1[1] = data[i++];
+      applyTransform(p_1, p_1, m);
+      data[j++] = p_1[0];
+      data[j++] = p_1[1];
+    }
+  }
+  path.increaseVersion();
+}
+export {
+  transformPath as default
+};