@fecp/mobile 1.0.79 → 1.1.0

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

@@ -0,0 +1,589 @@
+import { cubicSubdivide } from "../core/curve.mjs";
+import Path from "../graphic/Path.mjs";
+import { defaults, map } from "../core/util.mjs";
+import { lerp } from "../core/vector.mjs";
+import { clonePath } from "./path.mjs";
+import Transformable from "../core/Transformable.mjs";
+import { split } from "./dividePath.mjs";
+import { pathToBezierCurves } from "./convertPath.mjs";
+function alignSubpath(subpath1, subpath2) {
+  var len1 = subpath1.length;
+  var len2 = subpath2.length;
+  if (len1 === len2) {
+    return [subpath1, subpath2];
+  }
+  var tmpSegX = [];
+  var tmpSegY = [];
+  var shorterPath = len1 < len2 ? subpath1 : subpath2;
+  var shorterLen = Math.min(len1, len2);
+  var diff = Math.abs(len2 - len1) / 6;
+  var shorterBezierCount = (shorterLen - 2) / 6;
+  var eachCurveSubDivCount = Math.ceil(diff / shorterBezierCount) + 1;
+  var newSubpath = [shorterPath[0], shorterPath[1]];
+  var remained = diff;
+  for (var i = 2; i < shorterLen; ) {
+    var x0 = shorterPath[i - 2];
+    var y0 = shorterPath[i - 1];
+    var x1 = shorterPath[i++];
+    var y1 = shorterPath[i++];
+    var x2 = shorterPath[i++];
+    var y2 = shorterPath[i++];
+    var x3 = shorterPath[i++];
+    var y3 = shorterPath[i++];
+    if (remained <= 0) {
+      newSubpath.push(x1, y1, x2, y2, x3, y3);
+      continue;
+    }
+    var actualSubDivCount = Math.min(remained, eachCurveSubDivCount - 1) + 1;
+    for (var k = 1; k <= actualSubDivCount; k++) {
+      var p = k / actualSubDivCount;
+      cubicSubdivide(x0, x1, x2, x3, p, tmpSegX);
+      cubicSubdivide(y0, y1, y2, y3, p, tmpSegY);
+      x0 = tmpSegX[3];
+      y0 = tmpSegY[3];
+      newSubpath.push(tmpSegX[1], tmpSegY[1], tmpSegX[2], tmpSegY[2], x0, y0);
+      x1 = tmpSegX[5];
+      y1 = tmpSegY[5];
+      x2 = tmpSegX[6];
+      y2 = tmpSegY[6];
+    }
+    remained -= actualSubDivCount - 1;
+  }
+  return shorterPath === subpath1 ? [newSubpath, subpath2] : [subpath1, newSubpath];
+}
+function createSubpath(lastSubpathSubpath, otherSubpath) {
+  var len = lastSubpathSubpath.length;
+  var lastX = lastSubpathSubpath[len - 2];
+  var lastY = lastSubpathSubpath[len - 1];
+  var newSubpath = [];
+  for (var i = 0; i < otherSubpath.length; ) {
+    newSubpath[i++] = lastX;
+    newSubpath[i++] = lastY;
+  }
+  return newSubpath;
+}
+function alignBezierCurves(array1, array2) {
+  var _a;
+  var lastSubpath1;
+  var lastSubpath2;
+  var newArray1 = [];
+  var newArray2 = [];
+  for (var i = 0; i < Math.max(array1.length, array2.length); i++) {
+    var subpath1 = array1[i];
+    var subpath2 = array2[i];
+    var newSubpath1 = void 0;
+    var newSubpath2 = void 0;
+    if (!subpath1) {
+      newSubpath1 = createSubpath(lastSubpath1 || subpath2, subpath2);
+      newSubpath2 = subpath2;
+    } else if (!subpath2) {
+      newSubpath2 = createSubpath(lastSubpath2 || subpath1, subpath1);
+      newSubpath1 = subpath1;
+    } else {
+      _a = alignSubpath(subpath1, subpath2), newSubpath1 = _a[0], newSubpath2 = _a[1];
+      lastSubpath1 = newSubpath1;
+      lastSubpath2 = newSubpath2;
+    }
+    newArray1.push(newSubpath1);
+    newArray2.push(newSubpath2);
+  }
+  return [newArray1, newArray2];
+}
+function centroid(array) {
+  var signedArea = 0;
+  var cx = 0;
+  var cy = 0;
+  var len = array.length;
+  for (var i = 0, j = len - 2; i < len; j = i, i += 2) {
+    var x0 = array[j];
+    var y0 = array[j + 1];
+    var x1 = array[i];
+    var y1 = array[i + 1];
+    var a = x0 * y1 - x1 * y0;
+    signedArea += a;
+    cx += (x0 + x1) * a;
+    cy += (y0 + y1) * a;
+  }
+  if (signedArea === 0) {
+    return [array[0] || 0, array[1] || 0];
+  }
+  return [cx / signedArea / 3, cy / signedArea / 3, signedArea];
+}
+function findBestRingOffset(fromSubBeziers, toSubBeziers, fromCp, toCp) {
+  var bezierCount = (fromSubBeziers.length - 2) / 6;
+  var bestScore = Infinity;
+  var bestOffset = 0;
+  var len = fromSubBeziers.length;
+  var len2 = len - 2;
+  for (var offset = 0; offset < bezierCount; offset++) {
+    var cursorOffset = offset * 6;
+    var score = 0;
+    for (var k = 0; k < len; k += 2) {
+      var idx = k === 0 ? cursorOffset : (cursorOffset + k - 2) % len2 + 2;
+      var x0 = fromSubBeziers[idx] - fromCp[0];
+      var y0 = fromSubBeziers[idx + 1] - fromCp[1];
+      var x1 = toSubBeziers[k] - toCp[0];
+      var y1 = toSubBeziers[k + 1] - toCp[1];
+      var dx = x1 - x0;
+      var dy = y1 - y0;
+      score += dx * dx + dy * dy;
+    }
+    if (score < bestScore) {
+      bestScore = score;
+      bestOffset = offset;
+    }
+  }
+  return bestOffset;
+}
+function reverse(array) {
+  var newArr = [];
+  var len = array.length;
+  for (var i = 0; i < len; i += 2) {
+    newArr[i] = array[len - i - 2];
+    newArr[i + 1] = array[len - i - 1];
+  }
+  return newArr;
+}
+function findBestMorphingRotation(fromArr, toArr, searchAngleIteration, searchAngleRange) {
+  var result = [];
+  var fromNeedsReverse;
+  for (var i = 0; i < fromArr.length; i++) {
+    var fromSubpathBezier = fromArr[i];
+    var toSubpathBezier = toArr[i];
+    var fromCp = centroid(fromSubpathBezier);
+    var toCp = centroid(toSubpathBezier);
+    if (fromNeedsReverse == null) {
+      fromNeedsReverse = fromCp[2] < 0 !== toCp[2] < 0;
+    }
+    var newFromSubpathBezier = [];
+    var newToSubpathBezier = [];
+    var bestAngle = 0;
+    var bestScore = Infinity;
+    var tmpArr = [];
+    var len = fromSubpathBezier.length;
+    if (fromNeedsReverse) {
+      fromSubpathBezier = reverse(fromSubpathBezier);
+    }
+    var offset = findBestRingOffset(fromSubpathBezier, toSubpathBezier, fromCp, toCp) * 6;
+    var len2 = len - 2;
+    for (var k = 0; k < len2; k += 2) {
+      var idx = (offset + k) % len2 + 2;
+      newFromSubpathBezier[k + 2] = fromSubpathBezier[idx] - fromCp[0];
+      newFromSubpathBezier[k + 3] = fromSubpathBezier[idx + 1] - fromCp[1];
+    }
+    newFromSubpathBezier[0] = fromSubpathBezier[offset] - fromCp[0];
+    newFromSubpathBezier[1] = fromSubpathBezier[offset + 1] - fromCp[1];
+    {
+      var step = searchAngleRange / searchAngleIteration;
+      for (var angle = -searchAngleRange / 2; angle <= searchAngleRange / 2; angle += step) {
+        var sa = Math.sin(angle);
+        var ca = Math.cos(angle);
+        var score = 0;
+        for (var k = 0; k < fromSubpathBezier.length; k += 2) {
+          var x0 = newFromSubpathBezier[k];
+          var y0 = newFromSubpathBezier[k + 1];
+          var x1 = toSubpathBezier[k] - toCp[0];
+          var y1 = toSubpathBezier[k + 1] - toCp[1];
+          var newX1 = x1 * ca - y1 * sa;
+          var newY1 = x1 * sa + y1 * ca;
+          tmpArr[k] = newX1;
+          tmpArr[k + 1] = newY1;
+          var dx = newX1 - x0;
+          var dy = newY1 - y0;
+          score += dx * dx + dy * dy;
+        }
+        if (score < bestScore) {
+          bestScore = score;
+          bestAngle = angle;
+          for (var m = 0; m < tmpArr.length; m++) {
+            newToSubpathBezier[m] = tmpArr[m];
+          }
+        }
+      }
+    }
+    result.push({
+      from: newFromSubpathBezier,
+      to: newToSubpathBezier,
+      fromCp,
+      toCp,
+      rotation: -bestAngle
+    });
+  }
+  return result;
+}
+function isCombineMorphing(path) {
+  return path.__isCombineMorphing;
+}
+var SAVED_METHOD_PREFIX = "__mOriginal_";
+function saveAndModifyMethod(obj, methodName, modifiers) {
+  var savedMethodName = SAVED_METHOD_PREFIX + methodName;
+  var originalMethod = obj[savedMethodName] || obj[methodName];
+  if (!obj[savedMethodName]) {
+    obj[savedMethodName] = obj[methodName];
+  }
+  var replace = modifiers.replace;
+  var after = modifiers.after;
+  var before = modifiers.before;
+  obj[methodName] = function() {
+    var args = arguments;
+    var res;
+    before && before.apply(this, args);
+    if (replace) {
+      res = replace.apply(this, args);
+    } else {
+      res = originalMethod.apply(this, args);
+    }
+    after && after.apply(this, args);
+    return res;
+  };
+}
+function restoreMethod(obj, methodName) {
+  var savedMethodName = SAVED_METHOD_PREFIX + methodName;
+  if (obj[savedMethodName]) {
+    obj[methodName] = obj[savedMethodName];
+    obj[savedMethodName] = null;
+  }
+}
+function applyTransformOnBeziers(bezierCurves, mm) {
+  for (var i = 0; i < bezierCurves.length; i++) {
+    var subBeziers = bezierCurves[i];
+    for (var k = 0; k < subBeziers.length; ) {
+      var x = subBeziers[k];
+      var y = subBeziers[k + 1];
+      subBeziers[k++] = mm[0] * x + mm[2] * y + mm[4];
+      subBeziers[k++] = mm[1] * x + mm[3] * y + mm[5];
+    }
+  }
+}
+function prepareMorphPath(fromPath, toPath) {
+  var fromPathProxy = fromPath.getUpdatedPathProxy();
+  var toPathProxy = toPath.getUpdatedPathProxy();
+  var _a = alignBezierCurves(pathToBezierCurves(fromPathProxy), pathToBezierCurves(toPathProxy)), fromBezierCurves = _a[0], toBezierCurves = _a[1];
+  var fromPathTransform = fromPath.getComputedTransform();
+  var toPathTransform = toPath.getComputedTransform();
+  function updateIdentityTransform() {
+    this.transform = null;
+  }
+  fromPathTransform && applyTransformOnBeziers(fromBezierCurves, fromPathTransform);
+  toPathTransform && applyTransformOnBeziers(toBezierCurves, toPathTransform);
+  saveAndModifyMethod(toPath, "updateTransform", { replace: updateIdentityTransform });
+  toPath.transform = null;
+  var morphingData = findBestMorphingRotation(fromBezierCurves, toBezierCurves, 10, Math.PI);
+  var tmpArr = [];
+  saveAndModifyMethod(toPath, "buildPath", { replace: function(path) {
+    var t = toPath.__morphT;
+    var onet = 1 - t;
+    var newCp = [];
+    for (var i = 0; i < morphingData.length; i++) {
+      var item = morphingData[i];
+      var from = item.from;
+      var to = item.to;
+      var angle = item.rotation * t;
+      var fromCp = item.fromCp;
+      var toCp = item.toCp;
+      var sa = Math.sin(angle);
+      var ca = Math.cos(angle);
+      lerp(newCp, fromCp, toCp, t);
+      for (var m = 0; m < from.length; m += 2) {
+        var x0_1 = from[m];
+        var y0_1 = from[m + 1];
+        var x1 = to[m];
+        var y1 = to[m + 1];
+        var x = x0_1 * onet + x1 * t;
+        var y = y0_1 * onet + y1 * t;
+        tmpArr[m] = x * ca - y * sa + newCp[0];
+        tmpArr[m + 1] = x * sa + y * ca + newCp[1];
+      }
+      var x0 = tmpArr[0];
+      var y0 = tmpArr[1];
+      path.moveTo(x0, y0);
+      for (var m = 2; m < from.length; ) {
+        var x1 = tmpArr[m++];
+        var y1 = tmpArr[m++];
+        var x2 = tmpArr[m++];
+        var y2 = tmpArr[m++];
+        var x3 = tmpArr[m++];
+        var y3 = tmpArr[m++];
+        if (x0 === x1 && y0 === y1 && x2 === x3 && y2 === y3) {
+          path.lineTo(x3, y3);
+        } else {
+          path.bezierCurveTo(x1, y1, x2, y2, x3, y3);
+        }
+        x0 = x3;
+        y0 = y3;
+      }
+    }
+  } });
+}
+function morphPath(fromPath, toPath, animationOpts) {
+  if (!fromPath || !toPath) {
+    return toPath;
+  }
+  var oldDone = animationOpts.done;
+  var oldDuring = animationOpts.during;
+  prepareMorphPath(fromPath, toPath);
+  toPath.__morphT = 0;
+  function restoreToPath() {
+    restoreMethod(toPath, "buildPath");
+    restoreMethod(toPath, "updateTransform");
+    toPath.__morphT = -1;
+    toPath.createPathProxy();
+    toPath.dirtyShape();
+  }
+  toPath.animateTo({
+    __morphT: 1
+  }, defaults({
+    during: function(p) {
+      toPath.dirtyShape();
+      oldDuring && oldDuring(p);
+    },
+    done: function() {
+      restoreToPath();
+      oldDone && oldDone();
+    }
+  }, animationOpts));
+  return toPath;
+}
+function hilbert(x, y, minX, minY, maxX, maxY) {
+  var bits = 16;
+  x = maxX === minX ? 0 : Math.round(32767 * (x - minX) / (maxX - minX));
+  y = maxY === minY ? 0 : Math.round(32767 * (y - minY) / (maxY - minY));
+  var d = 0;
+  var tmp;
+  for (var s = (1 << bits) / 2; s > 0; s /= 2) {
+    var rx = 0;
+    var ry = 0;
+    if ((x & s) > 0) {
+      rx = 1;
+    }
+    if ((y & s) > 0) {
+      ry = 1;
+    }
+    d += s * s * (3 * rx ^ ry);
+    if (ry === 0) {
+      if (rx === 1) {
+        x = s - 1 - x;
+        y = s - 1 - y;
+      }
+      tmp = x;
+      x = y;
+      y = tmp;
+    }
+  }
+  return d;
+}
+function sortPaths(pathList) {
+  var xMin = Infinity;
+  var yMin = Infinity;
+  var xMax = -Infinity;
+  var yMax = -Infinity;
+  var cps = map(pathList, function(path) {
+    var rect = path.getBoundingRect();
+    var m = path.getComputedTransform();
+    var x = rect.x + rect.width / 2 + (m ? m[4] : 0);
+    var y = rect.y + rect.height / 2 + (m ? m[5] : 0);
+    xMin = Math.min(x, xMin);
+    yMin = Math.min(y, yMin);
+    xMax = Math.max(x, xMax);
+    yMax = Math.max(y, yMax);
+    return [x, y];
+  });
+  var items = map(cps, function(cp, idx) {
+    return {
+      cp,
+      z: hilbert(cp[0], cp[1], xMin, yMin, xMax, yMax),
+      path: pathList[idx]
+    };
+  });
+  return items.sort(function(a, b) {
+    return a.z - b.z;
+  }).map(function(item) {
+    return item.path;
+  });
+}
+function defaultDividePath(param) {
+  return split(param.path, param.count);
+}
+function createEmptyReturn() {
+  return {
+    fromIndividuals: [],
+    toIndividuals: [],
+    count: 0
+  };
+}
+function combineMorph(fromList, toPath, animationOpts) {
+  var fromPathList = [];
+  function addFromPath(fromList2) {
+    for (var i2 = 0; i2 < fromList2.length; i2++) {
+      var from2 = fromList2[i2];
+      if (isCombineMorphing(from2)) {
+        addFromPath(from2.childrenRef());
+      } else if (from2 instanceof Path) {
+        fromPathList.push(from2);
+      }
+    }
+  }
+  addFromPath(fromList);
+  var separateCount = fromPathList.length;
+  if (!separateCount) {
+    return createEmptyReturn();
+  }
+  var dividePath = animationOpts.dividePath || defaultDividePath;
+  var toSubPathList = dividePath({
+    path: toPath,
+    count: separateCount
+  });
+  if (toSubPathList.length !== separateCount) {
+    console.error("Invalid morphing: unmatched splitted path");
+    return createEmptyReturn();
+  }
+  fromPathList = sortPaths(fromPathList);
+  toSubPathList = sortPaths(toSubPathList);
+  var oldDone = animationOpts.done;
+  var oldDuring = animationOpts.during;
+  var individualDelay = animationOpts.individualDelay;
+  var identityTransform = new Transformable();
+  for (var i = 0; i < separateCount; i++) {
+    var from = fromPathList[i];
+    var to = toSubPathList[i];
+    to.parent = toPath;
+    to.copyTransform(identityTransform);
+    if (!individualDelay) {
+      prepareMorphPath(from, to);
+    }
+  }
+  toPath.__isCombineMorphing = true;
+  toPath.childrenRef = function() {
+    return toSubPathList;
+  };
+  function addToSubPathListToZr(zr) {
+    for (var i2 = 0; i2 < toSubPathList.length; i2++) {
+      toSubPathList[i2].addSelfToZr(zr);
+    }
+  }
+  saveAndModifyMethod(toPath, "addSelfToZr", {
+    after: function(zr) {
+      addToSubPathListToZr(zr);
+    }
+  });
+  saveAndModifyMethod(toPath, "removeSelfFromZr", {
+    after: function(zr) {
+      for (var i2 = 0; i2 < toSubPathList.length; i2++) {
+        toSubPathList[i2].removeSelfFromZr(zr);
+      }
+    }
+  });
+  function restoreToPath() {
+    toPath.__isCombineMorphing = false;
+    toPath.__morphT = -1;
+    toPath.childrenRef = null;
+    restoreMethod(toPath, "addSelfToZr");
+    restoreMethod(toPath, "removeSelfFromZr");
+  }
+  var toLen = toSubPathList.length;
+  if (individualDelay) {
+    var animating_1 = toLen;
+    var eachDone = function() {
+      animating_1--;
+      if (animating_1 === 0) {
+        restoreToPath();
+        oldDone && oldDone();
+      }
+    };
+    for (var i = 0; i < toLen; i++) {
+      var indivdualAnimationOpts = individualDelay ? defaults({
+        delay: (animationOpts.delay || 0) + individualDelay(i, toLen, fromPathList[i], toSubPathList[i]),
+        done: eachDone
+      }, animationOpts) : animationOpts;
+      morphPath(fromPathList[i], toSubPathList[i], indivdualAnimationOpts);
+    }
+  } else {
+    toPath.__morphT = 0;
+    toPath.animateTo({
+      __morphT: 1
+    }, defaults({
+      during: function(p) {
+        for (var i2 = 0; i2 < toLen; i2++) {
+          var child = toSubPathList[i2];
+          child.__morphT = toPath.__morphT;
+          child.dirtyShape();
+        }
+        oldDuring && oldDuring(p);
+      },
+      done: function() {
+        restoreToPath();
+        for (var i2 = 0; i2 < fromList.length; i2++) {
+          restoreMethod(fromList[i2], "updateTransform");
+        }
+        oldDone && oldDone();
+      }
+    }, animationOpts));
+  }
+  if (toPath.__zr) {
+    addToSubPathListToZr(toPath.__zr);
+  }
+  return {
+    fromIndividuals: fromPathList,
+    toIndividuals: toSubPathList,
+    count: toLen
+  };
+}
+function separateMorph(fromPath, toPathList, animationOpts) {
+  var toLen = toPathList.length;
+  var fromPathList = [];
+  var dividePath = animationOpts.dividePath || defaultDividePath;
+  function addFromPath(fromList) {
+    for (var i2 = 0; i2 < fromList.length; i2++) {
+      var from = fromList[i2];
+      if (isCombineMorphing(from)) {
+        addFromPath(from.childrenRef());
+      } else if (from instanceof Path) {
+        fromPathList.push(from);
+      }
+    }
+  }
+  if (isCombineMorphing(fromPath)) {
+    addFromPath(fromPath.childrenRef());
+    var fromLen = fromPathList.length;
+    if (fromLen < toLen) {
+      var k = 0;
+      for (var i = fromLen; i < toLen; i++) {
+        fromPathList.push(clonePath(fromPathList[k++ % fromLen]));
+      }
+    }
+    fromPathList.length = toLen;
+  } else {
+    fromPathList = dividePath({ path: fromPath, count: toLen });
+    var fromPathTransform = fromPath.getComputedTransform();
+    for (var i = 0; i < fromPathList.length; i++) {
+      fromPathList[i].setLocalTransform(fromPathTransform);
+    }
+    if (fromPathList.length !== toLen) {
+      console.error("Invalid morphing: unmatched splitted path");
+      return createEmptyReturn();
+    }
+  }
+  fromPathList = sortPaths(fromPathList);
+  toPathList = sortPaths(toPathList);
+  var individualDelay = animationOpts.individualDelay;
+  for (var i = 0; i < toLen; i++) {
+    var indivdualAnimationOpts = individualDelay ? defaults({
+      delay: (animationOpts.delay || 0) + individualDelay(i, toLen, fromPathList[i], toPathList[i])
+    }, animationOpts) : animationOpts;
+    morphPath(fromPathList[i], toPathList[i], indivdualAnimationOpts);
+  }
+  return {
+    fromIndividuals: fromPathList,
+    toIndividuals: toPathList,
+    count: toPathList.length
+  };
+}
+export {
+  alignBezierCurves,
+  centroid,
+  combineMorph,
+  split as defaultDividePath,
+  isCombineMorphing,
+  morphPath,
+  separateMorph
+};