dishui 0.0.45 → 0.0.46

package/dist/components/pro/Flow/edges/edgePaths.js

@@ -1,4 +1,4 @@
-import { getHandlePositions as g } from "../nodes/NodeHandles.js";
+import { getHandlePositions as M } from "../nodes/NodeHandles.js";
 var p = {
   top: {
     dx: 0,
@@ -16,338 +16,356 @@ var p = {
     dx: 1,
     dy: 0
   }
-}, E = 20, H = 30, _ = 0.3;
-function I(n, c, t, o) {
-  const x = {
-    x: c.sx,
-    y: c.sy
-  }, s = {
-    x: c.tx,
-    y: c.ty
-  }, y = t ?? [];
-  switch (n) {
+}, w = 20, _ = 30, E = 0.3;
+function D(o, x, t, s) {
+  const y = {
+    x: x.sx,
+    y: x.sy
+  }, c = {
+    x: x.tx,
+    y: x.ty
+  }, n = t ?? [];
+  switch (o) {
     case "straight":
-      return b([
-        x,
-        ...y,
-        s
+      return m([
+        y,
+        ...n,
+        c
       ]);
     case "step":
     case "smoothstep":
-      return P(x, s, y, c, n === "smoothstep" ? 8 : 0);
+      return P(y, c, n, x, o === "smoothstep" ? 8 : 0);
     case "simplebezier":
-      return D([
-        x,
-        ...y,
-        s
-      ], o, c);
+      return O([
+        y,
+        ...n,
+        c
+      ], s, x);
     default:
-      return b([
-        x,
-        ...y,
-        s
+      return m([
+        y,
+        ...n,
+        c
       ]);
   }
 }
-function b(n) {
-  const c = [{
+function m(o) {
+  const x = [{
     type: "M",
-    x: n[0].x,
-    y: n[0].y
+    x: o[0].x,
+    y: o[0].y
   }];
-  for (let t = 1; t < n.length; t++) c.push({
+  for (let t = 1; t < o.length; t++) x.push({
     type: "L",
-    x: n[t].x,
-    y: n[t].y
+    x: o[t].x,
+    y: o[t].y
   });
-  return c;
+  return x;
 }
-function P(n, c, t, o, x) {
-  const s = Math.hypot(c.x - n.x, c.y - n.y), y = Math.min(E, s / 4), i = {
-    x: n.x + o.snx * y,
-    y: n.y + o.sny * y
-  }, a = {
-    x: c.x + o.tnx * y,
-    y: c.y + o.tny * y
-  }, u = Math.abs(o.sny) > Math.abs(o.snx), e = Math.abs(o.tny) > Math.abs(o.tnx), h = [{
-    x: n.x,
-    y: n.y
-  }, i], d = [
-    i,
+function P(o, x, t, s, y) {
+  const c = Math.hypot(x.x - o.x, x.y - o.y), n = Math.min(w, c / 4), e = {
+    x: o.x + s.snx * n,
+    y: o.y + s.sny * n
+  }, i = {
+    x: x.x + s.tnx * n,
+    y: x.y + s.tny * n
+  }, h = Math.abs(s.sny) > Math.abs(s.snx), a = Math.abs(s.tny) > Math.abs(s.tnx), r = [{
+    x: o.x,
+    y: o.y
+  }, e], f = [
+    e,
     ...t,
-    a
+    i
   ];
-  for (let r = 0; r < d.length - 1; r++) {
-    const l = d[r], f = d[r + 1];
-    if (r === 0 ? u : r === d.length - 2 ? e : u) {
-      const M = (l.y + f.y) / 2;
-      h.push({
-        x: l.x,
-        y: M
+  for (let l = 0; l < f.length - 1; l++) {
+    const u = f[l], d = f[l + 1];
+    if (l === 0 ? h : l === f.length - 2 ? a : h) {
+      const g = (u.y + d.y) / 2;
+      r.push({
+        x: u.x,
+        y: g
       }, {
-        x: f.x,
-        y: M
+        x: d.x,
+        y: g
       });
     } else {
-      const M = (l.x + f.x) / 2;
-      h.push({
-        x: M,
-        y: l.y
+      const g = (u.x + d.x) / 2;
+      r.push({
+        x: g,
+        y: u.y
       }, {
-        x: M,
-        y: f.y
+        x: g,
+        y: d.y
       });
     }
-    h.push({
-      x: f.x,
-      y: f.y
+    r.push({
+      x: d.x,
+      y: d.y
     });
   }
-  return h.push({
-    x: c.x,
-    y: c.y
-  }), C(k(h), x);
+  return r.push({
+    x: x.x,
+    y: x.y
+  }), k(S(r), y);
 }
-function k(n) {
-  const c = [];
-  for (const o of n) {
-    const x = c[c.length - 1];
-    x && Math.abs(x.x - o.x) < 0.01 && Math.abs(x.y - o.y) < 0.01 || c.push({
-      x: o.x,
-      y: o.y
+function S(o) {
+  const x = [];
+  for (const s of o) {
+    const y = x[x.length - 1];
+    y && Math.abs(y.x - s.x) < 0.01 && Math.abs(y.y - s.y) < 0.01 || x.push({
+      x: s.x,
+      y: s.y
     });
   }
   const t = [];
-  for (let o = 0; o < c.length; o++) {
-    const x = t[t.length - 1], s = c[o], y = c[o + 1];
-    if (x && y) {
-      const i = Math.abs(x.x - s.x) < 0.01 && Math.abs(s.x - y.x) < 0.01, a = Math.abs(x.y - s.y) < 0.01 && Math.abs(s.y - y.y) < 0.01;
-      if (i || a) continue;
+  for (let s = 0; s < x.length; s++) {
+    const y = t[t.length - 1], c = x[s], n = x[s + 1];
+    if (y && n) {
+      const e = Math.abs(y.x - c.x) < 0.01 && Math.abs(c.x - n.x) < 0.01, i = Math.abs(y.y - c.y) < 0.01 && Math.abs(c.y - n.y) < 0.01;
+      if (e || i) continue;
     }
-    t.push(s);
+    t.push(c);
   }
   return t;
 }
-function C(n, c) {
-  if (n.length === 0) return [];
+function k(o, x) {
+  if (o.length === 0) return [];
   const t = [{
     type: "M",
-    x: n[0].x,
-    y: n[0].y
+    x: o[0].x,
+    y: o[0].y
   }];
-  if (n.length === 1) return t;
-  if (c <= 0.5) {
-    for (let x = 1; x < n.length; x++) t.push({
+  if (o.length === 1) return t;
+  if (x <= 0.5) {
+    for (let y = 1; y < o.length; y++) t.push({
       type: "L",
-      x: n[x].x,
-      y: n[x].y
+      x: o[y].x,
+      y: o[y].y
     });
     return t;
   }
-  for (let x = 1; x < n.length - 1; x++) {
-    const s = n[x - 1], y = n[x], i = n[x + 1], a = Math.hypot(y.x - s.x, y.y - s.y), u = Math.hypot(i.x - y.x, i.y - y.y), e = Math.min(c, a / 2, u / 2);
-    if (e < 0.5) {
+  for (let y = 1; y < o.length - 1; y++) {
+    const c = o[y - 1], n = o[y], e = o[y + 1], i = Math.hypot(n.x - c.x, n.y - c.y), h = Math.hypot(e.x - n.x, e.y - n.y), a = Math.min(x, i / 2, h / 2);
+    if (a < 0.5) {
       t.push({
         type: "L",
-        x: y.x,
-        y: y.y
+        x: n.x,
+        y: n.y
       });
       continue;
     }
-    const h = Math.sign(y.x - s.x), d = Math.sign(y.y - s.y), r = Math.sign(i.x - y.x), l = Math.sign(i.y - y.y);
+    const r = Math.sign(n.x - c.x), f = Math.sign(n.y - c.y), l = Math.sign(e.x - n.x), u = Math.sign(e.y - n.y);
     t.push({
       type: "L",
-      x: y.x - h * e,
-      y: y.y - d * e
+      x: n.x - r * a,
+      y: n.y - f * a
     }), t.push({
       type: "Q",
-      x: y.x + r * e,
-      y: y.y + l * e,
-      cp1x: y.x,
-      cp1y: y.y
+      x: n.x + l * a,
+      y: n.y + u * a,
+      cp1x: n.x,
+      cp1y: n.y
     });
   }
-  const o = n[n.length - 1];
+  const s = o[o.length - 1];
   return t.push({
     type: "L",
-    x: o.x,
-    y: o.y
+    x: s.x,
+    y: s.y
   }), t;
 }
-function D(n, c, t) {
-  const o = [{
+function O(o, x, t) {
+  const s = [{
     type: "M",
-    x: n[0].x,
-    y: n[0].y
-  }], x = n.length - 2;
-  for (let s = 0; s <= x; s++) {
-    const y = n[s], i = n[s + 1], a = c?.[s];
-    if (a) o.push({
+    x: o[0].x,
+    y: o[0].y
+  }], y = o.length - 2;
+  for (let c = 0; c <= y; c++) {
+    const n = o[c], e = o[c + 1], i = x?.[c];
+    if (i) s.push({
       type: "C",
-      x: i.x,
-      y: i.y,
-      cp1x: a.c1x,
-      cp1y: a.c1y,
-      cp2x: a.c2x,
-      cp2y: a.c2y
+      x: e.x,
+      y: e.y,
+      cp1x: i.c1x,
+      cp1y: i.c1y,
+      cp2x: i.c2x,
+      cp2y: i.c2y
     });
     else {
-      const u = Math.hypot(i.x - y.x, i.y - y.y), e = Math.max(H, u * _);
-      let h, d;
-      s === 0 && t ? (h = y.x + t.snx * e, d = y.y + t.sny * e) : (h = y.x + (i.x - y.x) * 0.4, d = y.y);
-      let r, l;
-      s === x && t ? (r = i.x + t.tnx * e, l = i.y + t.tny * e) : (r = i.x - (i.x - y.x) * 0.4, l = i.y), o.push({
+      const h = Math.hypot(e.x - n.x, e.y - n.y), a = Math.max(_, h * E);
+      let r, f;
+      c === 0 && t ? (r = n.x + t.snx * a, f = n.y + t.sny * a) : (r = n.x + (e.x - n.x) * 0.4, f = n.y);
+      let l, u;
+      c === y && t ? (l = e.x + t.tnx * a, u = e.y + t.tny * a) : (l = e.x - (e.x - n.x) * 0.4, u = e.y), s.push({
         type: "C",
-        x: i.x,
-        y: i.y,
-        cp1x: h,
-        cp1y: d,
-        cp2x: r,
-        cp2y: l
+        x: e.x,
+        y: e.y,
+        cp1x: r,
+        cp1y: f,
+        cp2x: l,
+        cp2y: u
       });
     }
   }
-  return o;
+  return s;
 }
-function N(n) {
-  if (n.length < 2) return {
-    x: n[0]?.x ?? 0,
-    y: n[0]?.y ?? 0
+function z(o) {
+  if (o.length < 2) return {
+    x: o[0]?.x ?? 0,
+    y: o[0]?.y ?? 0
   };
-  const c = Math.floor(n.length / 2), t = n[c - 1], o = n[c];
+  const x = Math.floor(o.length / 2), t = o[x - 1], s = o[x];
   return {
-    x: (t.x + o.x) / 2,
-    y: (t.y + o.y) / 2
+    x: (t.x + s.x) / 2,
+    y: (t.y + s.y) / 2
   };
 }
-function m(n, c, t) {
-  const o = t.data.rotation ?? 0;
-  if (o === 0) return {
-    x: t.position.x + n,
-    y: t.position.y + c
+function b(o, x, t) {
+  const s = t.data.rotation ?? 0;
+  if (s === 0) return {
+    x: t.position.x + o,
+    y: t.position.y + x
   };
-  const x = o * Math.PI / 180, s = t.width / 2, y = t.height / 2, i = n - s, a = c - y, u = Math.cos(x), e = Math.sin(x);
+  const y = s * Math.PI / 180, c = t.width / 2, n = t.height / 2, e = o - c, i = x - n, h = Math.cos(y), a = Math.sin(y);
   return {
-    x: t.position.x + s + i * u - a * e,
-    y: t.position.y + y + i * e + a * u
+    x: t.position.x + c + e * h - i * a,
+    y: t.position.y + n + e * a + i * h
   };
 }
-function L(n, c) {
-  const t = p[n?.side ?? "right"] ?? p.right, o = c.data.rotation ?? 0;
-  if (o === 0) return {
+function H(o, x) {
+  const t = p[o?.side ?? "right"] ?? p.right, s = x.data.rotation ?? 0;
+  if (s === 0) return {
     nx: t.dx,
     ny: t.dy
   };
-  const x = o * Math.PI / 180, s = Math.cos(x), y = Math.sin(x);
+  const y = s * Math.PI / 180, c = Math.cos(y), n = Math.sin(y);
   return {
-    nx: t.dx * s - t.dy * y,
-    ny: t.dx * y + t.dy * s
+    nx: t.dx * c - t.dy * n,
+    ny: t.dx * n + t.dy * c
   };
 }
-function O(n, c) {
-  const t = c.get(n.source), o = c.get(n.target);
-  if (!t || !o) return null;
-  const x = g(t.width, t.height), s = g(o.width, o.height);
-  let y, i, a;
-  if (n.sourceHandle) {
-    a = x.find((f) => f.id === n.sourceHandle) ?? null;
-    const l = m(a ? a.x : t.width / 2, a ? a.y : t.height / 2, t);
-    y = l.x, i = l.y;
+function A(o, x) {
+  const t = x.get(o.source), s = x.get(o.target);
+  if (!t || !s) return null;
+  const y = M(t.width, t.height), c = M(s.width, s.height);
+  let n, e, i;
+  if (o.sourceHandle) {
+    i = y.find((d) => d.id === o.sourceHandle) ?? null;
+    const u = b(i ? i.x : t.width / 2, i ? i.y : t.height / 2, t);
+    n = u.x, e = u.y;
   } else {
-    const l = w(t, o);
-    y = l.x, i = l.y, a = l.handleLike;
+    const u = L(t, s);
+    n = u.x, e = u.y, i = u.handleLike;
   }
-  let u, e, h;
-  if (n.targetHandle) {
-    h = s.find((f) => f.id === n.targetHandle) ?? null;
-    const l = m(h ? h.x : o.width / 2, h ? h.y : o.height / 2, o);
-    u = l.x, e = l.y;
+  let h, a, r;
+  if (o.targetHandle) {
+    r = c.find((d) => d.id === o.targetHandle) ?? null;
+    const u = b(r ? r.x : s.width / 2, r ? r.y : s.height / 2, s);
+    h = u.x, a = u.y;
   } else {
-    const l = w(o, t);
-    u = l.x, e = l.y, h = l.handleLike;
+    const u = L(s, t);
+    h = u.x, a = u.y, r = u.handleLike;
   }
-  const d = L(a, t), r = L(h, o);
+  const f = H(i, t), l = H(r, s);
   return {
-    sx: y,
-    sy: i,
-    tx: u,
-    ty: e,
-    snx: d.nx,
-    sny: d.ny,
-    tnx: r.nx,
-    tny: r.ny
+    sx: n,
+    sy: e,
+    tx: h,
+    ty: a,
+    snx: f.nx,
+    sny: f.ny,
+    tnx: l.nx,
+    tny: l.ny
   };
 }
-function w(n, c) {
-  const t = n.position.x, o = n.position.y, x = n.width, s = n.height, y = t + x / 2, i = o + s / 2, a = c.position.x + c.width / 2, u = c.position.y + c.height / 2, e = a - y, h = u - i, d = Math.min(12, x / 2 - 1, s / 2 - 1);
-  let r, l, f;
-  return Math.abs(e) >= Math.abs(h) ? (r = e >= 0 ? "right" : "left", l = r === "right" ? t + x : t, f = Math.max(o + d, Math.min(o + s - d, u))) : (r = h >= 0 ? "bottom" : "top", f = r === "bottom" ? o + s : o, l = Math.max(t + d, Math.min(t + x - d, a))), (n.data.rotation ?? 0) !== 0 ? {
-    x: r === "right" ? t + x : r === "left" ? t : y,
-    y: r === "bottom" ? o + s : r === "top" ? o : i,
+function L(o, x) {
+  const t = o.position.x, s = o.position.y, y = o.width, c = o.height, n = t + y / 2, e = s + c / 2, i = x.position.x + x.width / 2, h = x.position.y + x.height / 2, a = i - n, r = h - e, f = Math.min(12, y / 2 - 1, c / 2 - 1);
+  let l, u, d;
+  return Math.abs(a) >= Math.abs(r) ? (l = a >= 0 ? "right" : "left", u = l === "right" ? t + y : t, d = Math.max(s + f, Math.min(s + c - f, h))) : (l = r >= 0 ? "bottom" : "top", d = l === "bottom" ? s + c : s, u = Math.max(t + f, Math.min(t + y - f, i))), (o.data.rotation ?? 0) !== 0 ? {
+    x: l === "right" ? t + y : l === "left" ? t : n,
+    y: l === "bottom" ? s + c : l === "top" ? s : e,
     handleLike: {
-      id: `float_${r}`,
+      id: `float_${l}`,
       x: 0,
       y: 0,
-      side: r
+      side: l
     }
   } : {
-    x: l,
-    y: f,
+    x: u,
+    y: d,
     handleLike: {
-      id: `float_${r}`,
+      id: `float_${l}`,
       x: 0,
       y: 0,
-      side: r
+      side: l
     }
   };
 }
-function S(n, c) {
-  return n;
+function I(o, x) {
+  const t = /* @__PURE__ */ new Map([
+    ["0.25", String(0.3333333333333333)],
+    ["0.5", String(0.5)],
+    ["0.75", String(0.6666666666666666)]
+  ]);
+  let s = !1;
+  const y = (n) => {
+    if (!n) return n;
+    const [e, i] = n.split("_"), h = t.get(i);
+    return !h || !e ? n : (s = !0, `${e}_${h}`);
+  }, c = o.map((n) => {
+    const e = y(n.sourceHandle), i = y(n.targetHandle);
+    return e === n.sourceHandle && i === n.targetHandle ? n : {
+      ...n,
+      sourceHandle: e,
+      targetHandle: i
+    };
+  });
+  return s ? c : o;
 }
-function v(n, c = 8) {
+function N(o, x = 8) {
   const t = [];
-  let o = 0, x = 0;
-  for (const s of n) switch (s.type) {
+  let s = 0, y = 0;
+  for (const c of o) switch (c.type) {
     case "M":
     case "L":
-      o = s.x, x = s.y, t.push({
-        x: o,
-        y: x
+      s = c.x, y = c.y, t.push({
+        x: s,
+        y
       });
       break;
     case "Q": {
-      const y = s.cp1x, i = s.cp1y;
-      for (let a = 1; a <= c; a++) {
-        const u = a / c, e = 1 - u;
+      const n = c.cp1x, e = c.cp1y;
+      for (let i = 1; i <= x; i++) {
+        const h = i / x, a = 1 - h;
         t.push({
-          x: e * e * o + 2 * e * u * y + u * u * s.x,
-          y: e * e * x + 2 * e * u * i + u * u * s.y
+          x: a * a * s + 2 * a * h * n + h * h * c.x,
+          y: a * a * y + 2 * a * h * e + h * h * c.y
         });
       }
-      o = s.x, x = s.y;
+      s = c.x, y = c.y;
       break;
     }
     case "C": {
-      const y = s.cp1x, i = s.cp1y, a = s.cp2x, u = s.cp2y;
-      for (let e = 1; e <= c; e++) {
-        const h = e / c, d = 1 - h;
+      const n = c.cp1x, e = c.cp1y, i = c.cp2x, h = c.cp2y;
+      for (let a = 1; a <= x; a++) {
+        const r = a / x, f = 1 - r;
         t.push({
-          x: d ** 3 * o + 3 * d ** 2 * h * y + 3 * d * h ** 2 * a + h ** 3 * s.x,
-          y: d ** 3 * x + 3 * d ** 2 * h * i + 3 * d * h ** 2 * u + h ** 3 * s.y
+          x: f ** 3 * s + 3 * f ** 2 * r * n + 3 * f * r ** 2 * i + r ** 3 * c.x,
+          y: f ** 3 * y + 3 * f ** 2 * r * e + 3 * f * r ** 2 * h + r ** 3 * c.y
         });
       }
-      o = s.x, x = s.y;
+      s = c.x, y = c.y;
       break;
     }
   }
   return t;
 }
 export {
-  I as buildEdgePath,
-  N as getPathCenter,
-  v as linearizeSegments,
-  S as normalizeEdgeHandles,
-  O as resolveEdgeEndpoints
+  D as buildEdgePath,
+  z as getPathCenter,
+  N as linearizeSegments,
+  I as normalizeEdgeHandles,
+  A as resolveEdgeEndpoints
 };
 
 //# sourceMappingURL=edgePaths.js.map