yahee-components 0.0.70 → 0.0.71

package/es/node_modules/.pnpm/zrender@6.0.0/node_modules/zrender/lib/tool/morphPath.js

@@ -0,0 +1,319 @@
+import { cubicSubdivide as P } from "../core/curve.js";
+import z from "../graphic/Path.js";
+import { defaults as Q, map as w } from "../core/util.js";
+import { lerp as vr } from "../core/vector.js";
+import { clonePath as nr } from "./path.js";
+import ar from "../core/Transformable.js";
+import { split as er } from "./dividePath.js";
+import { pathToBezierCurves as O } from "./convertPath.js";
+function fr(v, r) {
+  var a = v.length, n = r.length;
+  if (a === n)
+    return [v, r];
+  for (var o = [], i = [], l = a < n ? v : r, e = Math.min(a, n), t = Math.abs(n - a) / 6, f = (e - 2) / 6, u = Math.ceil(t / f) + 1, d = [l[0], l[1]], c = t, h = 2; h < e; ) {
+    var I = l[h - 2], M = l[h - 1], C = l[h++], _ = l[h++], D = l[h++], T = l[h++], Z = l[h++], s = l[h++];
+    if (c <= 0) {
+      d.push(C, _, D, T, Z, s);
+      continue;
+    }
+    for (var g = Math.min(c, u - 1) + 1, R = 1; R <= g; R++) {
+      var E = R / g;
+      P(I, C, D, Z, E, o), P(M, _, T, s, E, i), I = o[3], M = i[3], d.push(o[1], i[1], o[2], i[2], I, M), C = o[5], _ = i[5], D = o[6], T = i[6];
+    }
+    c -= g - 1;
+  }
+  return l === v ? [d, r] : [v, d];
+}
+function j(v, r) {
+  for (var a = v.length, n = v[a - 2], o = v[a - 1], i = [], l = 0; l < r.length; )
+    i[l++] = n, i[l++] = o;
+  return i;
+}
+function or(v, r) {
+  for (var a, n, o, i = [], l = [], e = 0; e < Math.max(v.length, r.length); e++) {
+    var t = v[e], f = r[e], u = void 0, d = void 0;
+    t ? f ? (a = fr(t, f), u = a[0], d = a[1], n = u, o = d) : (d = j(o || t, t), u = t) : (u = j(n || f, f), d = f), i.push(u), l.push(d);
+  }
+  return [i, l];
+}
+function k(v) {
+  for (var r = 0, a = 0, n = 0, o = v.length, i = 0, l = o - 2; i < o; l = i, i += 2) {
+    var e = v[l], t = v[l + 1], f = v[i], u = v[i + 1], d = e * u - f * t;
+    r += d, a += (e + f) * d, n += (t + u) * d;
+  }
+  return r === 0 ? [v[0] || 0, v[1] || 0] : [a / r / 3, n / r / 3, r];
+}
+function lr(v, r, a, n) {
+  for (var o = (v.length - 2) / 6, i = 1 / 0, l = 0, e = v.length, t = e - 2, f = 0; f < o; f++) {
+    for (var u = f * 6, d = 0, c = 0; c < e; c += 2) {
+      var h = c === 0 ? u : (u + c - 2) % t + 2, I = v[h] - a[0], M = v[h + 1] - a[1], C = r[c] - n[0], _ = r[c + 1] - n[1], D = C - I, T = _ - M;
+      d += D * D + T * T;
+    }
+    d < i && (i = d, l = f);
+  }
+  return l;
+}
+function dr(v) {
+  for (var r = [], a = v.length, n = 0; n < a; n += 2)
+    r[n] = v[a - n - 2], r[n + 1] = v[a - n - 1];
+  return r;
+}
+function ir(v, r, a, n) {
+  for (var o = [], i, l = 0; l < v.length; l++) {
+    var e = v[l], t = r[l], f = k(e), u = k(t);
+    i == null && (i = f[2] < 0 != u[2] < 0);
+    var d = [], c = [], h = 0, I = 1 / 0, M = [], C = e.length;
+    i && (e = dr(e));
+    for (var _ = lr(e, t, f, u) * 6, D = C - 2, T = 0; T < D; T += 2) {
+      var Z = (_ + T) % D + 2;
+      d[T + 2] = e[Z] - f[0], d[T + 3] = e[Z + 1] - f[1];
+    }
+    d[0] = e[_] - f[0], d[1] = e[_ + 1] - f[1];
+    for (var s = n / a, g = -n / 2; g <= n / 2; g += s) {
+      for (var R = Math.sin(g), E = Math.cos(g), p = 0, T = 0; T < e.length; T += 2) {
+        var m = d[T], N = d[T + 1], y = t[T] - u[0], U = t[T + 1] - u[1], A = y * E - U * R, F = y * R + U * E;
+        M[T] = A, M[T + 1] = F;
+        var V = A - m, q = F - N;
+        p += V * V + q * q;
+      }
+      if (p < I) {
+        I = p, h = g;
+        for (var H = 0; H < M.length; H++)
+          c[H] = M[H];
+      }
+    }
+    o.push({
+      from: d,
+      to: c,
+      fromCp: f,
+      toCp: u,
+      rotation: -h
+    });
+  }
+  return o;
+}
+function X(v) {
+  return v.__isCombineMorphing;
+}
+var S = "__mOriginal_";
+function W(v, r, a) {
+  var n = S + r, o = v[n] || v[r];
+  v[n] || (v[n] = v[r]);
+  var i = a.replace, l = a.after, e = a.before;
+  v[r] = function() {
+    var t = arguments, f;
+    return e && e.apply(this, t), i ? f = i.apply(this, t) : f = o.apply(this, t), l && l.apply(this, t), f;
+  };
+}
+function G(v, r) {
+  var a = S + r;
+  v[a] && (v[r] = v[a], v[a] = null);
+}
+function x(v, r) {
+  for (var a = 0; a < v.length; a++)
+    for (var n = v[a], o = 0; o < n.length; ) {
+      var i = n[o], l = n[o + 1];
+      n[o++] = r[0] * i + r[2] * l + r[4], n[o++] = r[1] * i + r[3] * l + r[5];
+    }
+}
+function B(v, r) {
+  var a = v.getUpdatedPathProxy(), n = r.getUpdatedPathProxy(), o = or(O(a), O(n)), i = o[0], l = o[1], e = v.getComputedTransform(), t = r.getComputedTransform();
+  function f() {
+    this.transform = null;
+  }
+  e && x(i, e), t && x(l, t), W(r, "updateTransform", { replace: f }), r.transform = null;
+  var u = ir(i, l, 10, Math.PI), d = [];
+  W(r, "buildPath", { replace: function(c) {
+    for (var h = r.__morphT, I = 1 - h, M = [], C = 0; C < u.length; C++) {
+      var _ = u[C], D = _.from, T = _.to, Z = _.rotation * h, s = _.fromCp, g = _.toCp, R = Math.sin(Z), E = Math.cos(Z);
+      vr(M, s, g, h);
+      for (var p = 0; p < D.length; p += 2) {
+        var m = D[p], N = D[p + 1], y = T[p], U = T[p + 1], A = m * I + y * h, F = N * I + U * h;
+        d[p] = A * E - F * R + M[0], d[p + 1] = A * R + F * E + M[1];
+      }
+      var V = d[0], q = d[1];
+      c.moveTo(V, q);
+      for (var p = 2; p < D.length; ) {
+        var y = d[p++], U = d[p++], H = d[p++], L = d[p++], J = d[p++], K = d[p++];
+        V === y && q === U && H === J && L === K ? c.lineTo(J, K) : c.bezierCurveTo(y, U, H, L, J, K), V = J, q = K;
+      }
+    }
+  } });
+}
+function b(v, r, a) {
+  if (!v || !r)
+    return r;
+  var n = a.done, o = a.during;
+  B(v, r), r.__morphT = 0;
+  function i() {
+    G(r, "buildPath"), G(r, "updateTransform"), r.__morphT = -1, r.createPathProxy(), r.dirtyShape();
+  }
+  return r.animateTo({
+    __morphT: 1
+  }, Q({
+    during: function(l) {
+      r.dirtyShape(), o && o(l);
+    },
+    done: function() {
+      i(), n && n();
+    }
+  }, a)), r;
+}
+function tr(v, r, a, n, o, i) {
+  var l = 16;
+  v = o === a ? 0 : Math.round(32767 * (v - a) / (o - a)), r = i === n ? 0 : Math.round(32767 * (r - n) / (i - n));
+  for (var e = 0, t, f = (1 << l) / 2; f > 0; f /= 2) {
+    var u = 0, d = 0;
+    (v & f) > 0 && (u = 1), (r & f) > 0 && (d = 1), e += f * f * (3 * u ^ d), d === 0 && (u === 1 && (v = f - 1 - v, r = f - 1 - r), t = v, v = r, r = t);
+  }
+  return e;
+}
+function $(v) {
+  var r = 1 / 0, a = 1 / 0, n = -1 / 0, o = -1 / 0, i = w(v, function(e) {
+    var t = e.getBoundingRect(), f = e.getComputedTransform(), u = t.x + t.width / 2 + (f ? f[4] : 0), d = t.y + t.height / 2 + (f ? f[5] : 0);
+    return r = Math.min(u, r), a = Math.min(d, a), n = Math.max(u, n), o = Math.max(d, o), [u, d];
+  }), l = w(i, function(e, t) {
+    return {
+      cp: e,
+      z: tr(e[0], e[1], r, a, n, o),
+      path: v[t]
+    };
+  });
+  return l.sort(function(e, t) {
+    return e.z - t.z;
+  }).map(function(e) {
+    return e.path;
+  });
+}
+function rr(v) {
+  return er(v.path, v.count);
+}
+function Y() {
+  return {
+    fromIndividuals: [],
+    toIndividuals: [],
+    count: 0
+  };
+}
+function pr(v, r, a) {
+  var n = [];
+  function o(s) {
+    for (var g = 0; g < s.length; g++) {
+      var R = s[g];
+      X(R) ? o(R.childrenRef()) : R instanceof z && n.push(R);
+    }
+  }
+  o(v);
+  var i = n.length;
+  if (!i)
+    return Y();
+  var l = a.dividePath || rr, e = l({
+    path: r,
+    count: i
+  });
+  if (e.length !== i)
+    return console.error("Invalid morphing: unmatched splitted path"), Y();
+  n = $(n), e = $(e);
+  for (var t = a.done, f = a.during, u = a.individualDelay, d = new ar(), c = 0; c < i; c++) {
+    var h = n[c], I = e[c];
+    I.parent = r, I.copyTransform(d), u || B(h, I);
+  }
+  r.__isCombineMorphing = !0, r.childrenRef = function() {
+    return e;
+  };
+  function M(s) {
+    for (var g = 0; g < e.length; g++)
+      e[g].addSelfToZr(s);
+  }
+  W(r, "addSelfToZr", {
+    after: function(s) {
+      M(s);
+    }
+  }), W(r, "removeSelfFromZr", {
+    after: function(s) {
+      for (var g = 0; g < e.length; g++)
+        e[g].removeSelfFromZr(s);
+    }
+  });
+  function C() {
+    r.__isCombineMorphing = !1, r.__morphT = -1, r.childrenRef = null, G(r, "addSelfToZr"), G(r, "removeSelfFromZr");
+  }
+  var _ = e.length;
+  if (u)
+    for (var D = _, T = function() {
+      D--, D === 0 && (C(), t && t());
+    }, c = 0; c < _; c++) {
+      var Z = u ? Q({
+        delay: (a.delay || 0) + u(c, _, n[c], e[c]),
+        done: T
+      }, a) : a;
+      b(n[c], e[c], Z);
+    }
+  else
+    r.__morphT = 0, r.animateTo({
+      __morphT: 1
+    }, Q({
+      during: function(s) {
+        for (var g = 0; g < _; g++) {
+          var R = e[g];
+          R.__morphT = r.__morphT, R.dirtyShape();
+        }
+        f && f(s);
+      },
+      done: function() {
+        C();
+        for (var s = 0; s < v.length; s++)
+          G(v[s], "updateTransform");
+        t && t();
+      }
+    }, a));
+  return r.__zr && M(r.__zr), {
+    fromIndividuals: n,
+    toIndividuals: e,
+    count: _
+  };
+}
+function Ir(v, r, a) {
+  var n = r.length, o = [], i = a.dividePath || rr;
+  function l(h) {
+    for (var I = 0; I < h.length; I++) {
+      var M = h[I];
+      X(M) ? l(M.childrenRef()) : M instanceof z && o.push(M);
+    }
+  }
+  if (X(v)) {
+    l(v.childrenRef());
+    var e = o.length;
+    if (e < n)
+      for (var t = 0, f = e; f < n; f++)
+        o.push(nr(o[t++ % e]));
+    o.length = n;
+  } else {
+    o = i({ path: v, count: n });
+    for (var u = v.getComputedTransform(), f = 0; f < o.length; f++)
+      o[f].setLocalTransform(u);
+    if (o.length !== n)
+      return console.error("Invalid morphing: unmatched splitted path"), Y();
+  }
+  o = $(o), r = $(r);
+  for (var d = a.individualDelay, f = 0; f < n; f++) {
+    var c = d ? Q({
+      delay: (a.delay || 0) + d(f, n, o[f], r[f])
+    }, a) : a;
+    b(o[f], r[f], c);
+  }
+  return {
+    fromIndividuals: o,
+    toIndividuals: r,
+    count: r.length
+  };
+}
+export {
+  or as alignBezierCurves,
+  k as centroid,
+  pr as combineMorph,
+  er as defaultDividePath,
+  X as isCombineMorphing,
+  b as morphPath,
+  Ir as separateMorph
+};