@qy_better_lib/hooks 0.0.15 → 0.1.1

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

@@ -0,0 +1,286 @@
+import { Point as i } from "./point.js";
+import { Geometry as u } from "./geometry.js";
+import { Rectangle as l } from "./rectangle.js";
+class h extends u {
+  get center() {
+    return new i((this.start.x + this.end.x) / 2, (this.start.y + this.end.y) / 2);
+  }
+  constructor(t, e, s, n) {
+    super(), typeof t == "number" && typeof e == "number" ? (this.start = new i(t, e), this.end = new i(s, n)) : (this.start = i.create(t), this.end = i.create(e));
+  }
+  getCenter() {
+    return this.center;
+  }
+  /**
+   * Rounds the line to the given `precision`.
+   */
+  round(t = 0) {
+    return this.start.round(t), this.end.round(t), this;
+  }
+  translate(t, e) {
+    return typeof t == "number" ? (this.start.translate(t, e), this.end.translate(t, e)) : (this.start.translate(t), this.end.translate(t)), this;
+  }
+  /**
+   * Rotate the line by `angle` around `origin`.
+   */
+  rotate(t, e) {
+    return this.start.rotate(t, e), this.end.rotate(t, e), this;
+  }
+  /**
+   * Scale the line by `sx` and `sy` about the given `origin`. If origin is not
+   * specified, the line is scaled around `0,0`.
+   */
+  scale(t, e, s) {
+    return this.start.scale(t, e, s), this.end.scale(t, e, s), this;
+  }
+  /**
+   * Returns the length of the line.
+   */
+  length() {
+    return Math.sqrt(this.squaredLength());
+  }
+  /**
+   * Useful for distance comparisons in which real length is not necessary
+   * (saves one `Math.sqrt()` operation).
+   */
+  squaredLength() {
+    const t = this.start.x - this.end.x, e = this.start.y - this.end.y;
+    return t * t + e * e;
+  }
+  /**
+   * Scale the line so that it has the requested length. The start point of
+   * the line is preserved.
+   */
+  setLength(t) {
+    const e = this.length();
+    if (!e)
+      return this;
+    const s = t / e;
+    return this.scale(s, s, this.start);
+  }
+  parallel(t) {
+    const e = this.clone();
+    if (!e.isDifferentiable())
+      return e;
+    const { start: s, end: n } = e, r = s.clone().rotate(270, n), a = n.clone().rotate(90, s);
+    return s.move(a, t), n.move(r, t), e;
+  }
+  /**
+   * Returns the vector of the line with length equal to length of the line.
+   */
+  vector() {
+    return new i(this.end.x - this.start.x, this.end.y - this.start.y);
+  }
+  /**
+   * Returns the angle of incline of the line.
+   *
+   * The function returns `NaN` if the start and end endpoints of the line
+   * both lie at the same coordinates(it is impossible to determine the angle
+   * of incline of a line that appears to be a point). The
+   * `line.isDifferentiable()` function may be used in advance to determine
+   * whether the angle of incline can be computed for a given line.
+   */
+  angle() {
+    const t = new i(this.start.x + 1, this.start.y);
+    return this.start.angleBetween(this.end, t);
+  }
+  /**
+   * Returns a rectangle that is the bounding box of the line.
+   */
+  bbox() {
+    const t = Math.min(this.start.x, this.end.x), e = Math.min(this.start.y, this.end.y), s = Math.max(this.start.x, this.end.x), n = Math.max(this.start.y, this.end.y);
+    return new l(t, e, s - t, n - e);
+  }
+  /**
+   * Returns the bearing (cardinal direction) of the line.
+   *
+   * The return value is one of the following strings:
+   * 'NE', 'E', 'SE', 'S', 'SW', 'W', 'NW' and 'N'.
+   *
+   * The function returns 'N' if the two endpoints of the line are coincident.
+   */
+  bearing() {
+    return this.start.bearing(this.end);
+  }
+  /**
+   * Returns the point on the line that lies closest to point `p`.
+   */
+  closestPoint(t) {
+    return this.pointAt(this.closestPointNormalizedLength(t));
+  }
+  /**
+   * Returns the length of the line up to the point that lies closest to point `p`.
+   */
+  closestPointLength(t) {
+    return this.closestPointNormalizedLength(t) * this.length();
+  }
+  /**
+   * Returns a line that is tangent to the line at the point that lies closest
+   * to point `p`.
+   */
+  closestPointTangent(t) {
+    return this.tangentAt(this.closestPointNormalizedLength(t));
+  }
+  /**
+   * Returns the normalized length (distance from the start of the line / total
+   * line length) of the line up to the point that lies closest to point.
+   */
+  closestPointNormalizedLength(t) {
+    const e = this.vector().dot(new h(this.start, t).vector()), s = Math.min(1, Math.max(0, e / this.squaredLength()));
+    return Number.isNaN(s) ? 0 : s;
+  }
+  /**
+   * Returns a point on the line that lies `rate` (normalized length) away from
+   * the beginning of the line.
+   */
+  pointAt(t) {
+    const e = this.start, s = this.end;
+    return t <= 0 ? e.clone() : t >= 1 ? s.clone() : e.lerp(s, t);
+  }
+  /**
+   * Returns a point on the line that lies length away from the beginning of
+   * the line.
+   */
+  pointAtLength(t) {
+    const e = this.start, s = this.end;
+    let n = !0;
+    t < 0 && (n = !1, t = -t);
+    const r = this.length();
+    if (t >= r)
+      return n ? s.clone() : e.clone();
+    const a = (n ? t : r - t) / r;
+    return this.pointAt(a);
+  }
+  /**
+   * Divides the line into two lines at the point that lies `rate` (normalized
+   * length) away from the beginning of the line.
+   */
+  divideAt(t) {
+    const e = this.pointAt(t);
+    return [
+      new h(this.start, e),
+      new h(e, this.end)
+    ];
+  }
+  /**
+   * Divides the line into two lines at the point that lies length away from
+   * the beginning of the line.
+   */
+  divideAtLength(t) {
+    const e = this.pointAtLength(t);
+    return [
+      new h(this.start, e),
+      new h(e, this.end)
+    ];
+  }
+  /**
+   * Returns `true` if the point `p` lies on the line. Return `false` otherwise.
+   */
+  containsPoint(t) {
+    const e = this.start, s = this.end;
+    if (e.cross(t, s) !== 0)
+      return !1;
+    const n = this.length();
+    return !(new h(e, t).length() > n || new h(t, s).length() > n);
+  }
+  intersect(t, e) {
+    const s = t.intersectsWithLine(this, e);
+    return s ? Array.isArray(s) ? s : [s] : null;
+  }
+  /**
+   * Returns the intersection point of the line with another line. Returns
+   * `null` if no intersection exists.
+   */
+  intersectsWithLine(t) {
+    const e = new i(this.end.x - this.start.x, this.end.y - this.start.y), s = new i(t.end.x - t.start.x, t.end.y - t.start.y), n = e.x * s.y - e.y * s.x, r = new i(t.start.x - this.start.x, t.start.y - this.start.y), a = r.x * s.y - r.y * s.x, o = r.x * e.y - r.y * e.x;
+    if (n === 0 || a * n < 0 || o * n < 0)
+      return null;
+    if (n > 0) {
+      if (a > n || o > n)
+        return null;
+    } else if (a < n || o < n)
+      return null;
+    return new i(this.start.x + a * e.x / n, this.start.y + a * e.y / n);
+  }
+  /**
+   * Returns `true` if a tangent line can be found for the line.
+   *
+   * Tangents cannot be found if both of the line endpoints are coincident
+   * (the line appears to be a point).
+   */
+  isDifferentiable() {
+    return !this.start.equals(this.end);
+  }
+  /**
+   * Returns the perpendicular distance between the line and point. The
+   * distance is positive if the point lies to the right of the line, negative
+   * if the point lies to the left of the line, and `0` if the point lies on
+   * the line.
+   */
+  pointOffset(t) {
+    const e = i.clone(t), s = this.start, n = this.end;
+    return ((n.x - s.x) * (e.y - s.y) - (n.y - s.y) * (e.x - s.x)) / this.length();
+  }
+  pointSquaredDistance(t, e) {
+    const s = i.create(t, e);
+    return this.closestPoint(s).squaredDistance(s);
+  }
+  pointDistance(t, e) {
+    const s = i.create(t, e);
+    return this.closestPoint(s).distance(s);
+  }
+  /**
+   * Returns a line tangent to the line at point that lies `rate` (normalized
+   * length) away from the beginning of the line.
+   */
+  tangentAt(t) {
+    if (!this.isDifferentiable())
+      return null;
+    const e = this.start, s = this.end, n = this.pointAt(t), r = new h(e, s);
+    return r.translate(n.x - e.x, n.y - e.y), r;
+  }
+  /**
+   * Returns a line tangent to the line at point that lies `length` away from
+   * the beginning of the line.
+   */
+  tangentAtLength(t) {
+    if (!this.isDifferentiable())
+      return null;
+    const e = this.start, s = this.end, n = this.pointAtLength(t), r = new h(e, s);
+    return r.translate(n.x - e.x, n.y - e.y), r;
+  }
+  relativeCcw(t, e) {
+    const s = i.create(t, e);
+    let n = s.x - this.start.x, r = s.y - this.start.y;
+    const a = this.end.x - this.start.x, o = this.end.y - this.start.y;
+    let c = n * o - r * a;
+    return c === 0 && (c = n * a + r * o, c > 0 && (n -= a, r -= o, c = n * a + r * o, c < 0 && (c = 0))), c < 0 ? -1 : c > 0 ? 1 : 0;
+  }
+  /**
+   * Return `true` if the line equals the other line.
+   */
+  equals(t) {
+    return t != null && this.start.x === t.start.x && this.start.y === t.start.y && this.end.x === t.end.x && this.end.y === t.end.y;
+  }
+  /**
+   * Returns another line which is a clone of the line.
+   */
+  clone() {
+    return new h(this.start, this.end);
+  }
+  toJSON() {
+    return { start: this.start.toJSON(), end: this.end.toJSON() };
+  }
+  serialize() {
+    return [this.start.serialize(), this.end.serialize()].join(" ");
+  }
+}
+(function(d) {
+  function t(e) {
+    return e != null && e instanceof d;
+  }
+  d.isLine = t;
+})(h || (h = {}));
+export {
+  h as Line
+};

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

@@ -0,0 +1,101 @@
+import { Line as s } from "../line.js";
+import { LineTo as n } from "./lineto.js";
+import { Segment as h } from "./segment.js";
+class i extends h {
+  get end() {
+    if (!this.subpathStartSegment)
+      throw new Error("Missing subpath start segment. (This segment needs a subpath start segment (e.g. MoveTo), or segment has not yet been added to a path.)");
+    return this.subpathStartSegment.end;
+  }
+  get type() {
+    return "Z";
+  }
+  get line() {
+    return new s(this.start, this.end);
+  }
+  bbox() {
+    return this.line.bbox();
+  }
+  closestPoint(t) {
+    return this.line.closestPoint(t);
+  }
+  closestPointLength(t) {
+    return this.line.closestPointLength(t);
+  }
+  closestPointNormalizedLength(t) {
+    return this.line.closestPointNormalizedLength(t);
+  }
+  closestPointTangent(t) {
+    return this.line.closestPointTangent(t);
+  }
+  length() {
+    return this.line.length();
+  }
+  divideAt(t) {
+    const e = this.line.divideAt(t);
+    return [
+      // do not actually cut into the segment, first divided part can stay as Z
+      e[1].isDifferentiable() ? new n(e[0]) : this.clone(),
+      new n(e[1])
+    ];
+  }
+  divideAtLength(t) {
+    const e = this.line.divideAtLength(t);
+    return [
+      e[1].isDifferentiable() ? new n(e[0]) : this.clone(),
+      new n(e[1])
+    ];
+  }
+  getSubdivisions() {
+    return [];
+  }
+  pointAt(t) {
+    return this.line.pointAt(t);
+  }
+  pointAtLength(t) {
+    return this.line.pointAtLength(t);
+  }
+  tangentAt(t) {
+    return this.line.tangentAt(t);
+  }
+  tangentAtLength(t) {
+    return this.line.tangentAtLength(t);
+  }
+  isDifferentiable() {
+    return !this.previousSegment || !this.subpathStartSegment ? !1 : !this.start.equals(this.end);
+  }
+  scale() {
+    return this;
+  }
+  rotate() {
+    return this;
+  }
+  translate() {
+    return this;
+  }
+  equals(t) {
+    return this.type === t.type && this.start.equals(t.start) && this.end.equals(t.end);
+  }
+  clone() {
+    return new i();
+  }
+  toJSON() {
+    return {
+      type: this.type,
+      start: this.start.toJSON(),
+      end: this.end.toJSON()
+    };
+  }
+  serialize() {
+    return this.type;
+  }
+}
+(function(r) {
+  function t() {
+    return new r();
+  }
+  r.create = t;
+})(i || (i = {}));
+export {
+  i as Close
+};

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

@@ -0,0 +1,118 @@
+import { Curve as u } from "../curve.js";
+import { Point as s } from "../point.js";
+import { Segment as d } from "./segment.js";
+class i extends d {
+  constructor(t, n, e, r, h, o) {
+    super(), u.isCurve(t) ? (this.controlPoint1 = t.controlPoint1.clone().round(2), this.controlPoint2 = t.controlPoint2.clone().round(2), this.endPoint = t.end.clone().round(2)) : typeof t == "number" ? (this.controlPoint1 = new s(t, n).round(2), this.controlPoint2 = new s(e, r).round(2), this.endPoint = new s(h, o).round(2)) : (this.controlPoint1 = s.create(t).round(2), this.controlPoint2 = s.create(n).round(2), this.endPoint = s.create(e).round(2));
+  }
+  get type() {
+    return "C";
+  }
+  get curve() {
+    return new u(this.start, this.controlPoint1, this.controlPoint2, this.end);
+  }
+  bbox() {
+    return this.curve.bbox();
+  }
+  closestPoint(t) {
+    return this.curve.closestPoint(t);
+  }
+  closestPointLength(t) {
+    return this.curve.closestPointLength(t);
+  }
+  closestPointNormalizedLength(t) {
+    return this.curve.closestPointNormalizedLength(t);
+  }
+  closestPointTangent(t) {
+    return this.curve.closestPointTangent(t);
+  }
+  length() {
+    return this.curve.length();
+  }
+  divideAt(t, n = {}) {
+    const e = this.curve.divideAt(t, n);
+    return [new i(e[0]), new i(e[1])];
+  }
+  divideAtLength(t, n = {}) {
+    const e = this.curve.divideAtLength(t, n);
+    return [new i(e[0]), new i(e[1])];
+  }
+  divideAtT(t) {
+    const n = this.curve.divideAtT(t);
+    return [new i(n[0]), new i(n[1])];
+  }
+  getSubdivisions() {
+    return [];
+  }
+  pointAt(t) {
+    return this.curve.pointAt(t);
+  }
+  pointAtLength(t) {
+    return this.curve.pointAtLength(t);
+  }
+  tangentAt(t) {
+    return this.curve.tangentAt(t);
+  }
+  tangentAtLength(t) {
+    return this.curve.tangentAtLength(t);
+  }
+  isDifferentiable() {
+    if (!this.previousSegment)
+      return !1;
+    const t = this.start, n = this.controlPoint1, e = this.controlPoint2, r = this.end;
+    return !(t.equals(n) && n.equals(e) && e.equals(r));
+  }
+  scale(t, n, e) {
+    return this.controlPoint1.scale(t, n, e), this.controlPoint2.scale(t, n, e), this.end.scale(t, n, e), this;
+  }
+  rotate(t, n) {
+    return this.controlPoint1.rotate(t, n), this.controlPoint2.rotate(t, n), this.end.rotate(t, n), this;
+  }
+  translate(t, n) {
+    return typeof t == "number" ? (this.controlPoint1.translate(t, n), this.controlPoint2.translate(t, n), this.end.translate(t, n)) : (this.controlPoint1.translate(t), this.controlPoint2.translate(t), this.end.translate(t)), this;
+  }
+  equals(t) {
+    return this.start.equals(t.start) && this.end.equals(t.end) && this.controlPoint1.equals(t.controlPoint1) && this.controlPoint2.equals(t.controlPoint2);
+  }
+  clone() {
+    return new i(this.controlPoint1, this.controlPoint2, this.end);
+  }
+  toJSON() {
+    return {
+      type: this.type,
+      start: this.start.toJSON(),
+      controlPoint1: this.controlPoint1.toJSON(),
+      controlPoint2: this.controlPoint2.toJSON(),
+      end: this.end.toJSON()
+    };
+  }
+  serialize() {
+    const t = this.controlPoint1, n = this.controlPoint2, e = this.end;
+    return [this.type, t.x, t.y, n.x, n.y, e.x, e.y].join(" ");
+  }
+}
+(function(c) {
+  function t(...n) {
+    const e = n.length, r = n[0];
+    if (u.isCurve(r))
+      return new c(r);
+    if (s.isPointLike(r)) {
+      if (e === 3)
+        return new c(n[0], n[1], n[2]);
+      const o = [];
+      for (let l = 0; l < e; l += 3)
+        o.push(new c(n[l], n[l + 1], n[l + 2]));
+      return o;
+    }
+    if (e === 6)
+      return new c(n[0], n[1], n[2], n[3], n[4], n[5]);
+    const h = [];
+    for (let o = 0; o < e; o += 6)
+      h.push(new c(n[o], n[o + 1], n[o + 2], n[o + 3], n[o + 4], n[o + 5]));
+    return h;
+  }
+  c.create = t;
+})(i || (i = {}));
+export {
+  i as CurveTo
+};

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

@@ -0,0 +1,105 @@
+import { Line as h } from "../line.js";
+import { Point as u } from "../point.js";
+import { Segment as c } from "./segment.js";
+class n extends c {
+  constructor(t, e) {
+    super(), h.isLine(t) ? this.endPoint = t.end.clone().round(2) : this.endPoint = u.create(t, e).round(2);
+  }
+  get type() {
+    return "L";
+  }
+  get line() {
+    return new h(this.start, this.end);
+  }
+  bbox() {
+    return this.line.bbox();
+  }
+  closestPoint(t) {
+    return this.line.closestPoint(t);
+  }
+  closestPointLength(t) {
+    return this.line.closestPointLength(t);
+  }
+  closestPointNormalizedLength(t) {
+    return this.line.closestPointNormalizedLength(t);
+  }
+  closestPointTangent(t) {
+    return this.line.closestPointTangent(t);
+  }
+  length() {
+    return this.line.length();
+  }
+  divideAt(t) {
+    const e = this.line.divideAt(t);
+    return [new n(e[0]), new n(e[1])];
+  }
+  divideAtLength(t) {
+    const e = this.line.divideAtLength(t);
+    return [new n(e[0]), new n(e[1])];
+  }
+  getSubdivisions() {
+    return [];
+  }
+  pointAt(t) {
+    return this.line.pointAt(t);
+  }
+  pointAtLength(t) {
+    return this.line.pointAtLength(t);
+  }
+  tangentAt(t) {
+    return this.line.tangentAt(t);
+  }
+  tangentAtLength(t) {
+    return this.line.tangentAtLength(t);
+  }
+  isDifferentiable() {
+    return this.previousSegment == null ? !1 : !this.start.equals(this.end);
+  }
+  clone() {
+    return new n(this.end);
+  }
+  scale(t, e, s) {
+    return this.end.scale(t, e, s), this;
+  }
+  rotate(t, e) {
+    return this.end.rotate(t, e), this;
+  }
+  translate(t, e) {
+    return typeof t == "number" ? this.end.translate(t, e) : this.end.translate(t), this;
+  }
+  equals(t) {
+    return this.type === t.type && this.start.equals(t.start) && this.end.equals(t.end);
+  }
+  toJSON() {
+    return {
+      type: this.type,
+      start: this.start.toJSON(),
+      end: this.end.toJSON()
+    };
+  }
+  serialize() {
+    const t = this.end;
+    return `${this.type} ${t.x} ${t.y}`;
+  }
+}
+(function(i) {
+  function t(...e) {
+    const s = e.length, o = e[0];
+    if (h.isLine(o))
+      return new i(o);
+    if (u.isPointLike(o))
+      return s === 1 ? new i(o) : e.map((r) => new i(r));
+    if (s === 2)
+      return new i(+e[0], +e[1]);
+    const l = [];
+    for (let r = 0; r < s; r += 2) {
+      const d = +e[r], a = +e[r + 1];
+      l.push(new i(d, a));
+    }
+    return l;
+  }
+  i.create = t;
+})(n || (n = {}));
+export {
+  n as LineTo
+};