@qy_better_lib/hooks 0.1.1 → 0.1.3

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

@@ -1,319 +0,0 @@
-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

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