@qy_better_lib/hooks 0.0.15 → 0.1.1

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

@@ -0,0 +1,319 @@
+import { GeometryUtil as f } from "./util.js";
+import { Angle as x } from "./angle.js";
+import { Geometry as D } from "./geometry.js";
+class s extends D {
+  constructor(t, e) {
+    super(), this.x = t ?? 0, this.y = e ?? 0;
+  }
+  /**
+   * Rounds the point to the given precision.
+   */
+  round(t = 0) {
+    return this.x = f.round(this.x, t), this.y = f.round(this.y, t), this;
+  }
+  add(t, e) {
+    const r = s.create(t, e);
+    return this.x += r.x, this.y += r.y, this;
+  }
+  update(t, e) {
+    const r = s.create(t, e);
+    return this.x = r.x, this.y = r.y, this;
+  }
+  translate(t, e) {
+    const r = s.create(t, e);
+    return this.x += r.x, this.y += r.y, this;
+  }
+  /**
+   * Rotate the point by `degree` around `center`.
+   */
+  rotate(t, e) {
+    const r = s.rotate(this, t, e);
+    return this.x = r.x, this.y = r.y, this;
+  }
+  /**
+   * Scale point by `sx` and `sy` around the given `origin`. If origin is
+   * not specified, the point is scaled around `0, 0`.
+   */
+  scale(t, e, r = new s()) {
+    const h = s.create(r);
+    return this.x = h.x + t * (this.x - h.x), this.y = h.y + e * (this.y - h.y), this;
+  }
+  /**
+   * Chooses the point closest to this point from among `points`. If `points`
+   * is an empty array, `null` is returned.
+   */
+  closest(t) {
+    if (t.length === 1)
+      return s.create(t[0]);
+    let e = null, r = 1 / 0;
+    return t.forEach((h) => {
+      const y = this.squaredDistance(h);
+      y < r && (e = h, r = y);
+    }), e ? s.create(e) : null;
+  }
+  /**
+   * Returns the distance between the point and another point `p`.
+   */
+  distance(t) {
+    return Math.sqrt(this.squaredDistance(t));
+  }
+  /**
+   * Returns the squared distance between the point and another point `p`.
+   *
+   * Useful for distance comparisons in which real distance is not necessary
+   * (saves one `Math.sqrt()` operation).
+   */
+  squaredDistance(t) {
+    const e = s.create(t), r = this.x - e.x, h = this.y - e.y;
+    return r * r + h * h;
+  }
+  manhattanDistance(t) {
+    const e = s.create(t);
+    return Math.abs(e.x - this.x) + Math.abs(e.y - this.y);
+  }
+  /**
+   * Returns the magnitude of the point vector.
+   *
+   * @see http://en.wikipedia.org/wiki/Magnitude_(mathematics)
+   */
+  magnitude() {
+    return Math.sqrt(this.x * this.x + this.y * this.y) || 0.01;
+  }
+  /**
+   * Returns the angle(in degrees) between vector from this point to `p` and
+   * the x-axis.
+   */
+  theta(t = new s()) {
+    const e = s.create(t), r = -(e.y - this.y), h = e.x - this.x;
+    let y = Math.atan2(r, h);
+    return y < 0 && (y = 2 * Math.PI + y), 180 * y / Math.PI;
+  }
+  /**
+   * Returns the angle(in degrees) between vector from this point to `p1` and
+   * the vector from this point to `p2`.
+   *
+   * The ordering of points `p1` and `p2` is important.
+   *
+   * The function returns a value between `0` and `180` when the angle (in the
+   * direction from `p1` to `p2`) is clockwise, and a value between `180` and
+   * `360` when the angle is counterclockwise.
+   *
+   * Returns `NaN` if either of the points `p1` and `p2` is equal with this point.
+   */
+  angleBetween(t, e) {
+    if (this.equals(t) || this.equals(e))
+      return NaN;
+    let r = this.theta(e) - this.theta(t);
+    return r < 0 && (r += 360), r;
+  }
+  /**
+   * Returns the angle(in degrees) between the line from `(0,0)` and this point
+   * and the line from `(0,0)` to `p`.
+   *
+   * The function returns a value between `0` and `180` when the angle (in the
+   * direction from this point to `p`) is clockwise, and a value between `180`
+   * and `360` when the angle is counterclockwise. Returns `NaN` if called from
+   * point `(0,0)` or if `p` is `(0,0)`.
+   */
+  vectorAngle(t) {
+    return new s(0, 0).angleBetween(this, t);
+  }
+  /**
+   * Converts rectangular to polar coordinates.
+   */
+  toPolar(t) {
+    return this.update(s.toPolar(this, t)), this;
+  }
+  /**
+   * Returns the change in angle(in degrees) that is the result of moving the
+   * point from its previous position to its current position.
+   *
+   * More specifically, this function computes the angle between the line from
+   * the ref point to the previous position of this point(i.e. current position
+   * `-dx`, `-dy`) and the line from the `ref` point to the current position of
+   * this point.
+   *
+   * The function returns a positive value between `0` and `180` when the angle
+   * (in the direction from previous position of this point to its current
+   * position) is clockwise, and a negative value between `0` and `-180` when
+   * the angle is counterclockwise.
+   *
+   * The function returns `0` if the previous and current positions of this
+   * point are the same (i.e. both `dx` and `dy` are `0`).
+   */
+  changeInAngle(t, e, r = new s()) {
+    return this.clone().translate(-t, -e).theta(r) - this.theta(r);
+  }
+  /**
+   * If the point lies outside the rectangle `rect`, adjust the point so that
+   * it becomes the nearest point on the boundary of `rect`.
+   */
+  adhereToRect(t) {
+    return f.containsPoint(t, this) || (this.x = Math.min(Math.max(this.x, t.x), t.x + t.width), this.y = Math.min(Math.max(this.y, t.y), t.y + t.height)), this;
+  }
+  /**
+   * Returns the bearing(cardinal direction) between me and the given point.
+   *
+   * @see https://en.wikipedia.org/wiki/Cardinal_direction
+   */
+  bearing(t) {
+    const e = s.create(t), r = x.toRad(this.y), h = x.toRad(e.y), y = this.x, m = e.x, M = x.toRad(m - y), w = Math.sin(M) * Math.cos(h), b = Math.cos(r) * Math.sin(h) - Math.sin(r) * Math.cos(h) * Math.cos(M), g = x.toDeg(Math.atan2(w, b)), n = ["NE", "E", "SE", "S", "SW", "W", "NW", "N"];
+    let a = g - 22.5;
+    return a < 0 && (a += 360), a = parseInt(a / 45, 10), n[a];
+  }
+  /**
+   * Returns the cross product of the vector from me to `p1` and the vector
+   * from me to `p2`.
+   *
+   * The left-hand rule is used because the coordinate system is left-handed.
+   */
+  cross(t, e) {
+    if (t != null && e != null) {
+      const r = s.create(t), h = s.create(e);
+      return (h.x - this.x) * (r.y - this.y) - (h.y - this.y) * (r.x - this.x);
+    }
+    return NaN;
+  }
+  /**
+   * Returns the dot product of this point with given other point.
+   */
+  dot(t) {
+    const e = s.create(t);
+    return this.x * e.x + this.y * e.y;
+  }
+  diff(t, e) {
+    if (typeof t == "number")
+      return new s(this.x - t, this.y - e);
+    const r = s.create(t);
+    return new s(this.x - r.x, this.y - r.y);
+  }
+  /**
+   * Returns an interpolation between me and point `p` for a parametert in
+   * the closed interval `[0, 1]`.
+   */
+  lerp(t, e) {
+    const r = s.create(t);
+    return new s((1 - e) * this.x + e * r.x, (1 - e) * this.y + e * r.y);
+  }
+  /**
+   * Normalize the point vector, scale the line segment between `(0, 0)`
+   * and the point in order for it to have the given length. If length is
+   * not specified, it is considered to be `1`; in that case, a unit vector
+   * is computed.
+   */
+  normalize(t = 1) {
+    const e = t / this.magnitude();
+    return this.scale(e, e);
+  }
+  /**
+   * Moves this point along the line starting from `ref` to this point by a
+   * certain `distance`.
+   */
+  move(t, e) {
+    const r = s.create(t), h = x.toRad(r.theta(this));
+    return this.translate(Math.cos(h) * e, -Math.sin(h) * e);
+  }
+  /**
+   * Returns a point that is the reflection of me with the center of inversion
+   * in `ref` point.
+   */
+  reflection(t) {
+    return s.create(t).move(this, this.distance(t));
+  }
+  snapToGrid(t, e) {
+    return this.x = f.snapToGrid(this.x, t), this.y = f.snapToGrid(this.y, e ?? t), this;
+  }
+  equals(t) {
+    const e = s.create(t);
+    return e != null && e.x === this.x && e.y === this.y;
+  }
+  clone() {
+    return s.clone(this);
+  }
+  /**
+   * Returns the point as a simple JSON object. For example: `{ x: 0, y: 0 }`.
+   */
+  toJSON() {
+    return s.toJSON(this);
+  }
+  serialize() {
+    return `${this.x} ${this.y}`;
+  }
+}
+(function(i) {
+  function t(e) {
+    return e != null && e instanceof i;
+  }
+  i.isPoint = t;
+})(s || (s = {}));
+(function(i) {
+  function t(r) {
+    return r != null && typeof r == "object" && typeof r.x == "number" && typeof r.y == "number";
+  }
+  i.isPointLike = t;
+  function e(r) {
+    return r != null && Array.isArray(r) && r.length === 2 && typeof r[0] == "number" && typeof r[1] == "number";
+  }
+  i.isPointData = e;
+})(s || (s = {}));
+(function(i) {
+  function t(n, a) {
+    return n == null || typeof n == "number" ? new i(n, a) : e(n);
+  }
+  i.create = t;
+  function e(n) {
+    return i.isPoint(n) ? new i(n.x, n.y) : Array.isArray(n) ? new i(n[0], n[1]) : new i(n.x, n.y);
+  }
+  i.clone = e;
+  function r(n) {
+    return i.isPoint(n) ? { x: n.x, y: n.y } : Array.isArray(n) ? { x: n[0], y: n[1] } : { x: n.x, y: n.y };
+  }
+  i.toJSON = r;
+  function h(n, a, o = new i()) {
+    let u = Math.abs(n * Math.cos(a)), c = Math.abs(n * Math.sin(a));
+    const l = e(o), d = x.normalize(x.toDeg(a));
+    return d < 90 ? c = -c : d < 180 ? (u = -u, c = -c) : d < 270 && (u = -u), new i(l.x + u, l.y + c);
+  }
+  i.fromPolar = h;
+  function y(n, a = new i()) {
+    const o = e(n), u = e(a), c = o.x - u.x, l = o.y - u.y;
+    return new i(
+      Math.sqrt(c * c + l * l),
+      // r
+      x.toRad(u.theta(o))
+    );
+  }
+  i.toPolar = y;
+  function m(n, a) {
+    return n === a ? !0 : n != null && a != null ? n.x === a.x && n.y === a.y : !1;
+  }
+  i.equals = m;
+  function M(n, a) {
+    if (n == null && a != null || n != null && a == null || n != null && a != null && n.length !== a.length)
+      return !1;
+    if (n != null && a != null) {
+      for (let o = 0, u = n.length; o < u; o += 1)
+        if (!m(n[o], a[o]))
+          return !1;
+    }
+    return !0;
+  }
+  i.equalPoints = M;
+  function w(n, a, o, u) {
+    return new i(f.random(n, a), f.random(o, u));
+  }
+  i.random = w;
+  function b(n, a, o) {
+    const u = x.toRad(x.normalize(-a)), c = Math.sin(u), l = Math.cos(u);
+    return g(n, l, c, o);
+  }
+  i.rotate = b;
+  function g(n, a, o, u = new i()) {
+    const c = e(n), l = e(u), d = c.x - l.x, q = c.y - l.y, N = d * a - q * o, A = q * a + d * o;
+    return new i(N + l.x, A + l.y);
+  }
+  i.rotateEx = g;
+})(s || (s = {}));
+export {
+  s as Point
+};

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

@@ -0,0 +1,273 @@
+import { Line as L } from "./line.js";
+import { Point as P } from "./point.js";
+import { Rectangle as b } from "./rectangle.js";
+import { Geometry as A } from "./geometry.js";
+class g extends A {
+  get start() {
+    return this.points[0] || null;
+  }
+  get end() {
+    return this.points[this.points.length - 1] || null;
+  }
+  constructor(t) {
+    if (super(), t != null) {
+      if (typeof t == "string")
+        return g.parse(t);
+      this.points = t.map((n) => P.create(n));
+    } else
+      this.points = [];
+  }
+  scale(t, n, e = new P()) {
+    return this.points.forEach((s) => s.scale(t, n, e)), this;
+  }
+  rotate(t, n) {
+    return this.points.forEach((e) => e.rotate(t, n)), this;
+  }
+  translate(t, n) {
+    const e = P.create(t, n);
+    return this.points.forEach((s) => s.translate(e.x, e.y)), this;
+  }
+  round(t = 0) {
+    return this.points.forEach((n) => n.round(t)), this;
+  }
+  bbox() {
+    if (this.points.length === 0)
+      return new b();
+    let t = 1 / 0, n = -1 / 0, e = 1 / 0, s = -1 / 0;
+    const r = this.points;
+    for (let o = 0, l = r.length; o < l; o += 1) {
+      const f = r[o], h = f.x, u = f.y;
+      h < t && (t = h), h > n && (n = h), u < e && (e = u), u > s && (s = u);
+    }
+    return new b(t, e, n - t, s - e);
+  }
+  closestPoint(t) {
+    const n = this.closestPointLength(t);
+    return this.pointAtLength(n);
+  }
+  closestPointLength(t) {
+    const n = this.points, e = n.length;
+    if (e === 0 || e === 1)
+      return 0;
+    let s = 0, r = 0, o = 1 / 0;
+    for (let l = 0, f = e - 1; l < f; l += 1) {
+      const h = new L(n[l], n[l + 1]), u = h.length(), a = h.closestPointNormalizedLength(t), c = h.pointAt(a).squaredDistance(t);
+      c < o && (o = c, r = s + a * u), s += u;
+    }
+    return r;
+  }
+  closestPointNormalizedLength(t) {
+    const n = this.length();
+    return n === 0 ? 0 : this.closestPointLength(t) / n;
+  }
+  closestPointTangent(t) {
+    const n = this.closestPointLength(t);
+    return this.tangentAtLength(n);
+  }
+  containsPoint(t) {
+    if (this.points.length === 0)
+      return !1;
+    const n = P.clone(t), e = n.x, s = n.y, r = this.points, o = r.length;
+    let l = o - 1, f = 0;
+    for (let h = 0; h < o; h += 1) {
+      const u = r[l], a = r[h];
+      if (n.equals(u))
+        return !0;
+      const i = new L(u, a);
+      if (i.containsPoint(t))
+        return !0;
+      if (s <= u.y && s > a.y || s > u.y && s <= a.y) {
+        const c = u.x - e > a.x - e ? u.x - e : a.x - e;
+        if (c >= 0) {
+          const p = new P(e + c, s), d = new L(t, p);
+          i.intersectsWithLine(d) && (f += 1);
+        }
+      }
+      l = h;
+    }
+    return f % 2 === 1;
+  }
+  intersectsWithLine(t) {
+    const n = [];
+    for (let e = 0, s = this.points.length - 1; e < s; e += 1) {
+      const r = this.points[e], o = this.points[e + 1], l = t.intersectsWithLine(new L(r, o));
+      l && n.push(l);
+    }
+    return n.length > 0 ? n : null;
+  }
+  isDifferentiable() {
+    for (let t = 0, n = this.points.length - 1; t < n; t += 1) {
+      const e = this.points[t], s = this.points[t + 1];
+      if (new L(e, s).isDifferentiable())
+        return !0;
+    }
+    return !1;
+  }
+  length() {
+    let t = 0;
+    for (let n = 0, e = this.points.length - 1; n < e; n += 1) {
+      const s = this.points[n], r = this.points[n + 1];
+      t += s.distance(r);
+    }
+    return t;
+  }
+  pointAt(t) {
+    const n = this.points, e = n.length;
+    if (e === 0)
+      return null;
+    if (e === 1 || t <= 0)
+      return n[0].clone();
+    if (t >= 1)
+      return n[e - 1].clone();
+    const r = this.length() * t;
+    return this.pointAtLength(r);
+  }
+  pointAtLength(t) {
+    const n = this.points, e = n.length;
+    if (e === 0)
+      return null;
+    if (e === 1)
+      return n[0].clone();
+    let s = !0;
+    t < 0 && (s = !1, t = -t);
+    let r = 0;
+    for (let l = 0, f = e - 1; l < f; l += 1) {
+      const h = s ? l : f - 1 - l, u = n[h], a = n[h + 1], i = new L(u, a), c = u.distance(a);
+      if (t <= r + c)
+        return i.pointAtLength((s ? 1 : -1) * (t - r));
+      r += c;
+    }
+    return (s ? n[e - 1] : n[0]).clone();
+  }
+  tangentAt(t) {
+    const e = this.points.length;
+    if (e === 0 || e === 1)
+      return null;
+    t < 0 && (t = 0), t > 1 && (t = 1);
+    const r = this.length() * t;
+    return this.tangentAtLength(r);
+  }
+  tangentAtLength(t) {
+    const n = this.points, e = n.length;
+    if (e === 0 || e === 1)
+      return null;
+    let s = !0;
+    t < 0 && (s = !1, t = -t);
+    let r, o = 0;
+    for (let l = 0, f = e - 1; l < f; l += 1) {
+      const h = s ? l : f - 1 - l, u = n[h], a = n[h + 1], i = new L(u, a), c = u.distance(a);
+      if (i.isDifferentiable()) {
+        if (t <= o + c)
+          return i.tangentAtLength((s ? 1 : -1) * (t - o));
+        r = i;
+      }
+      o += c;
+    }
+    if (r) {
+      const l = s ? 1 : 0;
+      return r.tangentAt(l);
+    }
+    return null;
+  }
+  simplify(t = {}) {
+    const n = this.points;
+    if (n.length < 3)
+      return this;
+    const e = t.threshold || 0;
+    let s = 0;
+    for (; n[s + 2]; ) {
+      const r = s, o = s + 1, l = s + 2, f = n[r], h = n[o], u = n[l];
+      new L(f, u).closestPoint(h).distance(h) <= e ? n.splice(o, 1) : s += 1;
+    }
+    return this;
+  }
+  toHull() {
+    const t = this.points, n = t.length;
+    if (n === 0)
+      return new g();
+    let e = t[0];
+    for (let i = 1; i < n; i += 1)
+      (t[i].y < e.y || t[i].y === e.y && t[i].x > e.x) && (e = t[i]);
+    const s = [];
+    for (let i = 0; i < n; i += 1) {
+      let c = e.theta(t[i]);
+      c === 0 && (c = 360), s.push([t[i], i, c]);
+    }
+    if (s.sort((i, c) => {
+      let p = i[2] - c[2];
+      return p === 0 && (p = c[1] - i[1]), p;
+    }), s.length > 2) {
+      const i = s[s.length - 1];
+      s.unshift(i);
+    }
+    const r = {}, o = [], l = (i) => `${i[0].toString()}@${i[1]}`;
+    for (; s.length !== 0; ) {
+      const i = s.pop(), c = i[0];
+      if (r[l(i)])
+        continue;
+      let p = !1;
+      for (; !p; )
+        if (o.length < 2)
+          o.push(i), p = !0;
+        else {
+          const d = o.pop(), x = d[0], w = o.pop(), y = w[0], H = y.cross(x, c);
+          if (H < 0)
+            o.push(w), o.push(d), o.push(i), p = !0;
+          else if (H === 0) {
+            const I = x.angleBetween(y, c);
+            Math.abs(I - 180) < 1e-10 || x.equals(c) || y.equals(x) ? (r[l(d)] = x, o.push(w)) : Math.abs((I + 1) % 360 - 1) < 1e-10 && (o.push(w), s.push(d));
+          } else
+            r[l(d)] = x, o.push(w);
+        }
+    }
+    o.length > 2 && o.pop();
+    let f, h = -1;
+    for (let i = 0, c = o.length; i < c; i += 1) {
+      const p = o[i][1];
+      (f === void 0 || p < f) && (f = p, h = i);
+    }
+    let u = [];
+    if (h > 0) {
+      const i = o.slice(h), c = o.slice(0, h);
+      u = i.concat(c);
+    } else
+      u = o;
+    const a = [];
+    for (let i = 0, c = u.length; i < c; i += 1)
+      a.push(u[i][0]);
+    return new g(a);
+  }
+  equals(t) {
+    return t == null || t.points.length !== this.points.length ? !1 : t.points.every((n, e) => n.equals(this.points[e]));
+  }
+  clone() {
+    return new g(this.points.map((t) => t.clone()));
+  }
+  toJSON() {
+    return this.points.map((t) => t.toJSON());
+  }
+  serialize() {
+    return this.points.map((t) => `${t.serialize()}`).join(" ");
+  }
+}
+(function(m) {
+  function t(n) {
+    return n != null && n instanceof m;
+  }
+  m.isPolyline = t;
+})(g || (g = {}));
+(function(m) {
+  function t(n) {
+    const e = n.trim();
+    if (e === "")
+      return new m();
+    const s = [], r = e.split(/\s*,\s*|\s+/);
+    for (let o = 0, l = r.length; o < l; o += 2)
+      s.push({ x: +r[o], y: +r[o + 1] });
+    return new m(s);
+  }
+  m.parse = t;
+})(g || (g = {}));
+export {
+  g as Polyline
+};