@fecp/designer 5.4.125 → 5.5.1

package/es/node_modules/zrender/lib/tool/morphPath.mjs

@@ -1,589 +0,0 @@
-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
-};