@qy_better_lib/hooks 0.0.15 → 0.1.1

package/lib/packages/hooks/node_modules/@antv/x6-geometry/es/curve.js

@@ -0,0 +1,341 @@
+import { Line as x } from "./line.js";
+import { Point as y } from "./point.js";
+import { Polyline as F } from "./polyline.js";
+import { Rectangle as z } from "./rectangle.js";
+import { Geometry as I } from "./geometry.js";
+class D extends I {
+  constructor(t, n, o, e) {
+    super(), this.PRECISION = 3, this.start = y.create(t), this.controlPoint1 = y.create(n), this.controlPoint2 = y.create(o), this.end = y.create(e);
+  }
+  bbox() {
+    const t = this.start, n = this.controlPoint1, o = this.controlPoint2, e = this.end, i = t.x, c = t.y, l = n.x, r = n.y, s = o.x, a = o.y, u = e.x, h = e.y, g = [], P = [[], []];
+    let p, v, f, d, b, m, w, T;
+    for (let q = 0; q < 2; q += 1) {
+      if (q === 0 ? (v = 6 * i - 12 * l + 6 * s, p = -3 * i + 9 * l - 9 * s + 3 * u, f = 3 * l - 3 * i) : (v = 6 * c - 12 * r + 6 * a, p = -3 * c + 9 * r - 9 * a + 3 * h, f = 3 * r - 3 * c), Math.abs(p) < 1e-12) {
+        if (Math.abs(v) < 1e-12)
+          continue;
+        d = -f / v, d > 0 && d < 1 && g.push(d);
+        continue;
+      }
+      w = v * v - 4 * f * p, T = Math.sqrt(w), !(w < 0) && (b = (-v + T) / (2 * p), b > 0 && b < 1 && g.push(b), m = (-v - T) / (2 * p), m > 0 && m < 1 && g.push(m));
+    }
+    let M, E, A, C = g.length;
+    const S = C;
+    for (; C; )
+      C -= 1, d = g[C], A = 1 - d, M = A * A * A * i + 3 * A * A * d * l + 3 * A * d * d * s + d * d * d * u, P[0][C] = M, E = A * A * A * c + 3 * A * A * d * r + 3 * A * d * d * a + d * d * d * h, P[1][C] = E;
+    g[S] = 0, g[S + 1] = 1, P[0][S] = i, P[1][S] = c, P[0][S + 1] = u, P[1][S + 1] = h, g.length = S + 2, P[0].length = S + 2, P[1].length = S + 2;
+    const O = Math.min.apply(null, P[0]), R = Math.min.apply(null, P[1]), N = Math.max.apply(null, P[0]), k = Math.max.apply(null, P[1]);
+    return new z(O, R, N - O, k - R);
+  }
+  closestPoint(t, n = {}) {
+    return this.pointAtT(this.closestPointT(t, n));
+  }
+  closestPointLength(t, n = {}) {
+    const o = this.getOptions(n);
+    return this.lengthAtT(this.closestPointT(t, o), o);
+  }
+  closestPointNormalizedLength(t, n = {}) {
+    const o = this.getOptions(n), e = this.closestPointLength(t, o);
+    if (!e)
+      return 0;
+    const i = this.length(o);
+    return i === 0 ? 0 : e / i;
+  }
+  closestPointT(t, n = {}) {
+    const o = this.getPrecision(n), e = this.getDivisions(n), i = Math.pow(10, -o);
+    let c = null, l = 0, r = 0, s = 0, a = 0, u = 0, h = null;
+    const g = e.length;
+    let P = g > 0 ? 1 / g : 0;
+    for (e.forEach((p, v) => {
+      const f = p.start.distance(t), d = p.end.distance(t), b = f + d;
+      (h == null || b < h) && (c = p, l = v * P, r = (v + 1) * P, s = f, a = d, h = b, u = p.endpointDistance());
+    }); ; ) {
+      const p = s ? Math.abs(s - a) / s : 0, v = a != null ? Math.abs(s - a) / a : 0, f = p < i || v < i, d = s ? s < u * i : !0, b = a ? a < u * i : !0;
+      if (f || (d || b))
+        return s <= a ? l : r;
+      const w = c.divide(0.5);
+      P /= 2;
+      const T = w[0].start.distance(t), M = w[0].end.distance(t), E = T + M, A = w[1].start.distance(t), C = w[1].end.distance(t), S = A + C;
+      E <= S ? (c = w[0], r -= P, s = T, a = M) : (c = w[1], l += P, s = A, a = C);
+    }
+  }
+  closestPointTangent(t, n = {}) {
+    return this.tangentAtT(this.closestPointT(t, n));
+  }
+  containsPoint(t, n = {}) {
+    return this.toPolyline(n).containsPoint(t);
+  }
+  divideAt(t, n = {}) {
+    if (t <= 0)
+      return this.divideAtT(0);
+    if (t >= 1)
+      return this.divideAtT(1);
+    const o = this.tAt(t, n);
+    return this.divideAtT(o);
+  }
+  divideAtLength(t, n = {}) {
+    const o = this.tAtLength(t, n);
+    return this.divideAtT(o);
+  }
+  divide(t) {
+    return this.divideAtT(t);
+  }
+  divideAtT(t) {
+    const n = this.start, o = this.controlPoint1, e = this.controlPoint2, i = this.end;
+    if (t <= 0)
+      return [
+        new D(n, n, n, n),
+        new D(n, o, e, i)
+      ];
+    if (t >= 1)
+      return [
+        new D(n, o, e, i),
+        new D(i, i, i, i)
+      ];
+    const c = this.getSkeletonPoints(t), l = c.startControlPoint1, r = c.startControlPoint2, s = c.divider, a = c.dividerControlPoint1, u = c.dividerControlPoint2;
+    return [
+      new D(n, l, r, s),
+      new D(s, a, u, i)
+    ];
+  }
+  endpointDistance() {
+    return this.start.distance(this.end);
+  }
+  getSkeletonPoints(t) {
+    const n = this.start, o = this.controlPoint1, e = this.controlPoint2, i = this.end;
+    if (t <= 0)
+      return {
+        startControlPoint1: n.clone(),
+        startControlPoint2: n.clone(),
+        divider: n.clone(),
+        dividerControlPoint1: o.clone(),
+        dividerControlPoint2: e.clone()
+      };
+    if (t >= 1)
+      return {
+        startControlPoint1: o.clone(),
+        startControlPoint2: e.clone(),
+        divider: i.clone(),
+        dividerControlPoint1: i.clone(),
+        dividerControlPoint2: i.clone()
+      };
+    const c = new x(n, o).pointAt(t), l = new x(o, e).pointAt(t), r = new x(e, i).pointAt(t), s = new x(c, l).pointAt(t), a = new x(l, r).pointAt(t), u = new x(s, a).pointAt(t);
+    return {
+      startControlPoint1: c,
+      startControlPoint2: s,
+      divider: u,
+      dividerControlPoint1: a,
+      dividerControlPoint2: r
+    };
+  }
+  getSubdivisions(t = {}) {
+    const n = this.getPrecision(t);
+    let o = [
+      new D(this.start, this.controlPoint1, this.controlPoint2, this.end)
+    ];
+    if (n === 0)
+      return o;
+    let e = this.endpointDistance();
+    const i = Math.pow(10, -n);
+    let c = 0;
+    for (; ; ) {
+      c += 1;
+      const l = [];
+      o.forEach((a) => {
+        const u = a.divide(0.5);
+        l.push(u[0], u[1]);
+      });
+      const r = l.reduce((a, u) => a + u.endpointDistance(), 0), s = r !== 0 ? (r - e) / r : 0;
+      if (c > 1 && s < i)
+        return l;
+      o = l, e = r;
+    }
+  }
+  length(t = {}) {
+    return this.getDivisions(t).reduce((o, e) => o + e.endpointDistance(), 0);
+  }
+  lengthAtT(t, n = {}) {
+    if (t <= 0)
+      return 0;
+    const o = n.precision === void 0 ? this.PRECISION : n.precision;
+    return this.divide(t)[0].length({ precision: o });
+  }
+  pointAt(t, n = {}) {
+    if (t <= 0)
+      return this.start.clone();
+    if (t >= 1)
+      return this.end.clone();
+    const o = this.tAt(t, n);
+    return this.pointAtT(o);
+  }
+  pointAtLength(t, n = {}) {
+    const o = this.tAtLength(t, n);
+    return this.pointAtT(o);
+  }
+  pointAtT(t) {
+    return t <= 0 ? this.start.clone() : t >= 1 ? this.end.clone() : this.getSkeletonPoints(t).divider;
+  }
+  isDifferentiable() {
+    const t = this.start, n = this.controlPoint1, o = this.controlPoint2, e = this.end;
+    return !(t.equals(n) && n.equals(o) && o.equals(e));
+  }
+  tangentAt(t, n = {}) {
+    if (!this.isDifferentiable())
+      return null;
+    t < 0 ? t = 0 : t > 1 && (t = 1);
+    const o = this.tAt(t, n);
+    return this.tangentAtT(o);
+  }
+  tangentAtLength(t, n = {}) {
+    if (!this.isDifferentiable())
+      return null;
+    const o = this.tAtLength(t, n);
+    return this.tangentAtT(o);
+  }
+  tangentAtT(t) {
+    if (!this.isDifferentiable())
+      return null;
+    t < 0 && (t = 0), t > 1 && (t = 1);
+    const n = this.getSkeletonPoints(t), o = n.startControlPoint2, e = n.dividerControlPoint1, i = n.divider, c = new x(o, e);
+    return c.translate(i.x - o.x, i.y - o.y), c;
+  }
+  getPrecision(t = {}) {
+    return t.precision == null ? this.PRECISION : t.precision;
+  }
+  getDivisions(t = {}) {
+    if (t.subdivisions != null)
+      return t.subdivisions;
+    const n = this.getPrecision(t);
+    return this.getSubdivisions({ precision: n });
+  }
+  getOptions(t = {}) {
+    const n = this.getPrecision(t), o = this.getDivisions(t);
+    return { precision: n, subdivisions: o };
+  }
+  tAt(t, n = {}) {
+    if (t <= 0)
+      return 0;
+    if (t >= 1)
+      return 1;
+    const o = this.getOptions(n), i = this.length(o) * t;
+    return this.tAtLength(i, o);
+  }
+  tAtLength(t, n = {}) {
+    let o = !0;
+    t < 0 && (o = !1, t = -t);
+    const e = this.getPrecision(n), i = this.getDivisions(n), c = { precision: e, subdivisions: i };
+    let l = null, r, s, a = 0, u = 0, h = 0;
+    const g = i.length;
+    let P = g > 0 ? 1 / g : 0;
+    for (let f = 0; f < g; f += 1) {
+      const d = o ? f : g - 1 - f, b = i[f], m = b.endpointDistance();
+      if (t <= h + m) {
+        l = b, r = d * P, s = (d + 1) * P, a = o ? t - h : m + h - t, u = o ? m + h - t : t - h;
+        break;
+      }
+      h += m;
+    }
+    if (l == null)
+      return o ? 1 : 0;
+    const p = this.length(c), v = Math.pow(10, -e);
+    for (; ; ) {
+      let f;
+      if (f = p !== 0 ? a / p : 0, f < v)
+        return r;
+      if (f = p !== 0 ? u / p : 0, f < v)
+        return s;
+      let d, b;
+      const m = l.divide(0.5);
+      P /= 2;
+      const w = m[0].endpointDistance(), T = m[1].endpointDistance();
+      a <= w ? (l = m[0], s -= P, d = a, b = w - d) : (l = m[1], r += P, d = a - w, b = T - d), a = d, u = b;
+    }
+  }
+  toPoints(t = {}) {
+    const n = this.getDivisions(t), o = [n[0].start.clone()];
+    return n.forEach((e) => o.push(e.end.clone())), o;
+  }
+  toPolyline(t = {}) {
+    return new F(this.toPoints(t));
+  }
+  scale(t, n, o) {
+    return this.start.scale(t, n, o), this.controlPoint1.scale(t, n, o), this.controlPoint2.scale(t, n, o), this.end.scale(t, n, o), this;
+  }
+  rotate(t, n) {
+    return this.start.rotate(t, n), this.controlPoint1.rotate(t, n), this.controlPoint2.rotate(t, n), this.end.rotate(t, n), this;
+  }
+  translate(t, n) {
+    return typeof t == "number" ? (this.start.translate(t, n), this.controlPoint1.translate(t, n), this.controlPoint2.translate(t, n), this.end.translate(t, n)) : (this.start.translate(t), this.controlPoint1.translate(t), this.controlPoint2.translate(t), this.end.translate(t)), this;
+  }
+  equals(t) {
+    return t != null && this.start.equals(t.start) && this.controlPoint1.equals(t.controlPoint1) && this.controlPoint2.equals(t.controlPoint2) && this.end.equals(t.end);
+  }
+  clone() {
+    return new D(this.start, this.controlPoint1, this.controlPoint2, this.end);
+  }
+  toJSON() {
+    return {
+      start: this.start.toJSON(),
+      controlPoint1: this.controlPoint1.toJSON(),
+      controlPoint2: this.controlPoint2.toJSON(),
+      end: this.end.toJSON()
+    };
+  }
+  serialize() {
+    return [
+      this.start.serialize(),
+      this.controlPoint1.serialize(),
+      this.controlPoint2.serialize(),
+      this.end.serialize()
+    ].join(" ");
+  }
+}
+(function(L) {
+  function t(n) {
+    return n != null && n instanceof L;
+  }
+  L.isCurve = t;
+})(D || (D = {}));
+(function(L) {
+  function t(e) {
+    const i = e.length, c = [], l = [];
+    let r = 2;
+    c[0] = e[0] / r;
+    for (let s = 1; s < i; s += 1)
+      l[s] = 1 / r, r = (s < i - 1 ? 4 : 3.5) - l[s], c[s] = (e[s] - c[s - 1]) / r;
+    for (let s = 1; s < i; s += 1)
+      c[i - s - 1] -= l[i - s] * c[i - s];
+    return c;
+  }
+  function n(e) {
+    const i = e.map((h) => y.clone(h)), c = [], l = [], r = i.length - 1;
+    if (r === 1)
+      return c[0] = new y((2 * i[0].x + i[1].x) / 3, (2 * i[0].y + i[1].y) / 3), l[0] = new y(2 * c[0].x - i[0].x, 2 * c[0].y - i[0].y), [c, l];
+    const s = [];
+    for (let h = 1; h < r - 1; h += 1)
+      s[h] = 4 * i[h].x + 2 * i[h + 1].x;
+    s[0] = i[0].x + 2 * i[1].x, s[r - 1] = (8 * i[r - 1].x + i[r].x) / 2;
+    const a = t(s);
+    for (let h = 1; h < r - 1; h += 1)
+      s[h] = 4 * i[h].y + 2 * i[h + 1].y;
+    s[0] = i[0].y + 2 * i[1].y, s[r - 1] = (8 * i[r - 1].y + i[r].y) / 2;
+    const u = t(s);
+    for (let h = 0; h < r; h += 1)
+      c.push(new y(a[h], u[h])), h < r - 1 ? l.push(new y(2 * i[h + 1].x - a[h + 1], 2 * i[h + 1].y - u[h + 1])) : l.push(new y((i[r].x + a[r - 1]) / 2, (i[r].y + u[r - 1]) / 2));
+    return [c, l];
+  }
+  function o(e) {
+    if (e == null || Array.isArray(e) && e.length < 2)
+      throw new Error("At least 2 points are required");
+    const i = n(e), c = [];
+    for (let l = 0, r = i[0].length; l < r; l += 1) {
+      const s = new y(i[0][l].x, i[0][l].y), a = new y(i[1][l].x, i[1][l].y);
+      c.push(new L(e[l], s, a, e[l + 1]));
+    }
+    return c;
+  }
+  L.throughPoints = o;
+})(D || (D = {}));
+export {
+  D as Curve
+};

package/lib/packages/hooks/node_modules/@antv/x6-geometry/es/ellipse.js

@@ -0,0 +1,135 @@
+import { Point as a } from "./point.js";
+import { Rectangle as q } from "./rectangle.js";
+import { Geometry as P } from "./geometry.js";
+class l extends P {
+  get center() {
+    return new a(this.x, this.y);
+  }
+  constructor(r, n, s, t) {
+    super(), this.x = r ?? 0, this.y = n ?? 0, this.a = s ?? 0, this.b = t ?? 0;
+  }
+  /**
+   * Returns a rectangle that is the bounding box of the ellipse.
+   */
+  bbox() {
+    return q.fromEllipse(this);
+  }
+  /**
+   * Returns a point that is the center of the ellipse.
+   */
+  getCenter() {
+    return this.center;
+  }
+  inflate(r, n) {
+    const s = r, t = n ?? r;
+    return this.a += 2 * s, this.b += 2 * t, this;
+  }
+  normalizedDistance(r, n) {
+    const s = a.create(r, n), t = s.x - this.x, e = s.y - this.y, i = this.a, o = this.b;
+    return t * t / (i * i) + e * e / (o * o);
+  }
+  containsPoint(r, n) {
+    return this.normalizedDistance(r, n) <= 1;
+  }
+  /**
+   * Returns an array of the intersection points of the ellipse and the line.
+   * Returns `null` if no intersection exists.
+   */
+  intersectsWithLine(r) {
+    const n = [], s = this.a, t = this.b, e = r.start, i = r.end, o = r.vector(), u = e.diff(new a(this.x, this.y)), f = new a(o.x / (s * s), o.y / (t * t)), x = new a(u.x / (s * s), u.y / (t * t)), c = o.dot(f), y = o.dot(x), m = u.dot(x) - 1, b = y * y - c * m;
+    if (b < 0)
+      return null;
+    if (b > 0) {
+      const d = Math.sqrt(b), w = (-y - d) / c, p = (-y + d) / c;
+      if ((w < 0 || w > 1) && (p < 0 || p > 1))
+        return null;
+      w >= 0 && w <= 1 && n.push(e.lerp(i, w)), p >= 0 && p <= 1 && n.push(e.lerp(i, p));
+    } else {
+      const d = -y / c;
+      if (d >= 0 && d <= 1)
+        n.push(e.lerp(i, d));
+      else
+        return null;
+    }
+    return n;
+  }
+  /**
+   * Returns the point on the boundary of the ellipse that is the
+   * intersection of the ellipse with a line starting in the center
+   * of the ellipse ending in the point `p`.
+   *
+   * If angle is specified, the intersection will take into account
+   * the rotation of the ellipse by angle degrees around its center.
+   */
+  intersectsWithLineFromCenterToPoint(r, n = 0) {
+    const s = a.clone(r);
+    n && s.rotate(n, this.getCenter());
+    const t = s.x - this.x, e = s.y - this.y;
+    let i;
+    if (t === 0)
+      return i = this.bbox().getNearestPointToPoint(s), n ? i.rotate(-n, this.getCenter()) : i;
+    const o = e / t, u = o * o, f = this.a * this.a, x = this.b * this.b;
+    let c = Math.sqrt(1 / (1 / f + u / x));
+    c = t < 0 ? -c : c;
+    const y = o * c;
+    return i = new a(this.x + c, this.y + y), n ? i.rotate(-n, this.getCenter()) : i;
+  }
+  /**
+   * Returns the angle between the x-axis and the tangent from a point. It is
+   * valid for points lying on the ellipse boundary only.
+   */
+  tangentTheta(r) {
+    const n = a.clone(r), s = n.x, t = n.y, e = this.a, i = this.b, o = this.bbox().center, u = o.x, f = o.y, x = 30, c = s > o.x + e / 2, y = s < o.x - e / 2;
+    let m, b;
+    return c || y ? (b = s > o.x ? t - x : t + x, m = e * e / (s - u) - e * e * (t - f) * (b - f) / (i * i * (s - u)) + u) : (m = t > o.y ? s + x : s - x, b = i * i / (t - f) - i * i * (s - u) * (m - u) / (e * e * (t - f)) + f), new a(m, b).theta(n);
+  }
+  scale(r, n) {
+    return this.a *= r, this.b *= n, this;
+  }
+  rotate(r, n) {
+    const s = q.fromEllipse(this);
+    s.rotate(r, n);
+    const t = l.fromRect(s);
+    return this.a = t.a, this.b = t.b, this.x = t.x, this.y = t.y, this;
+  }
+  translate(r, n) {
+    const s = a.create(r, n);
+    return this.x += s.x, this.y += s.y, this;
+  }
+  equals(r) {
+    return r != null && r.x === this.x && r.y === this.y && r.a === this.a && r.b === this.b;
+  }
+  clone() {
+    return new l(this.x, this.y, this.a, this.b);
+  }
+  toJSON() {
+    return { x: this.x, y: this.y, a: this.a, b: this.b };
+  }
+  serialize() {
+    return `${this.x} ${this.y} ${this.a} ${this.b}`;
+  }
+}
+(function(h) {
+  function r(n) {
+    return n != null && n instanceof h;
+  }
+  h.isEllipse = r;
+})(l || (l = {}));
+(function(h) {
+  function r(t, e, i, o) {
+    return t == null || typeof t == "number" ? new h(t, e, i, o) : n(t);
+  }
+  h.create = r;
+  function n(t) {
+    return h.isEllipse(t) ? t.clone() : Array.isArray(t) ? new h(t[0], t[1], t[2], t[3]) : new h(t.x, t.y, t.a, t.b);
+  }
+  h.parse = n;
+  function s(t) {
+    const e = t.center;
+    return new h(e.x, e.y, t.width / 2, t.height / 2);
+  }
+  h.fromRect = s;
+})(l || (l = {}));
+export {
+  l as Ellipse
+};

package/lib/packages/hooks/node_modules/@antv/x6-geometry/es/geometry.js

@@ -0,0 +1,11 @@
+class r {
+  valueOf() {
+    return this.toJSON();
+  }
+  toString() {
+    return JSON.stringify(this.toJSON());
+  }
+}
+export {
+  r as Geometry
+};