fix(Intersection): bug causing selection edge case

CHANGELOG.md

@@ -3,6 +3,9 @@
 ## [next]
 
 - fix(Intersection): bug causing selection edge case [#8735](https://github.com/fabricjs/fabric.js/pull/8735)
+- chore(TS): class interface for options/brevity [#8674](https://github.com/fabricjs/fabric.js/issues/8674)
+- ci(): fix import autocomplete in dev mode #8725
+- chore(): remove deprecated class util [#8731](https://github.com/fabricjs/fabric.js/pull/8731)
 - lint(): fix eslint errors [#8729](https://github.com/fabricjs/fabric.js/pull/8729)
 - fix(TS): `this.constructor` types [#8675](https://github.com/fabricjs/fabric.js/issues/8675)
 - fix(DraggableText): drag image blur [#8712](https://github.com/fabricjs/fabric.js/pull/8712)

src/Intersection.ts

@@ -1,5 +1,5 @@
 import { Point } from './Point';
-import { createVector, slope } from './util/misc/vectors';
+import { createVector } from './util/misc/vectors';
 
 /* Adaptation of work of Kevin Lindsey (kevin@kevlindev.com) */
 
@@ -40,27 +40,50 @@ export class Intersection {
   }
 
   /**
-   * check if `T` is contained in `[A, B]` by comparing the direction of the vectors from `T` to `A` and `B`
-   * @param T
-   * @param A
-   * @param B
+   * check if point T is on the segment or line defined between A and B
+   *
+   * @param {Point} T the point we are checking for
+   * @param {Point} A one extremity of the segment
+   * @param {Point} B the other extremity of the segment
+   * @param [extendToLine] if true checks if `T` is on the line defined by `A` and `B`
    * @returns true if `T` is contained
    */
-  static isContainedInInterval(T: Point, A: Point, B: Point) {
-    if (T.eq(A) || T.eq(B)) {
-      return true;
-    }
-    const AB = createVector(A, B);
-    if (!AB.eq(new Point())) {
-      const s = slope(AB);
-      return s === slope(createVector(T, B)) && s === slope(createVector(T, B));
+  static isPointContained(T: Point, A: Point, B: Point, extendToLine = false) {
+    if (A.eq(B)) {
+      // Edge case: the segment is a point, we check for coincidence,
+      // extendToLine has no meaning because there are infinite lines to consider
+      return T.eq(A);
+    } else if (A.x === B.x) {
+      // Edge case: horizontal line.
+      // we first check if T.x is on the same value, and then if T.y is contained between A.y and B.y
+      return (
+        T.x === A.x &&
+        (extendToLine || (T.y >= Math.min(A.y, B.y) && T.y <= Math.max(A.y, B.y)))
+      );
+    } else if (A.y === B.y) {
+      // Edge case: vertical line.
+      // we first check if T.y is on the same value, and then if T.x is contained between A.x and B.x
+      return (
+        T.y === A.y &&
+        (extendToLine || (T.x >= Math.min(A.x, B.x) && T.x <= Math.max(A.x, B.x)))
+      );
     } else {
-      return false;
+      // generic case: we normalize AT over AB.
+      // then for the line case we just verify that AB has the same inclination than AT
+      // for the segment case we need the same direction and the length of AT needs to be less than AB
+      const AB = createVector(A, B);
+      const AT = createVector(A, T);
+      const s = AT.divide(AB);
+      return infinite
+        ? Math.abs(s.x) === Math.abs(s.y)
+        : s.x === s.y && s.x >= 0 && s.x <= 1;
     }
   }
 
   /**
    * Checks if a line intersects another
+   * @see {@link https://en.wikipedia.org/wiki/Line%E2%80%93line_intersection line intersection}
+   * @see {@link https://en.wikipedia.org/wiki/Cramer%27s_rule Cramer's rule}
    * @static
    * @param {Point} a1
    * @param {Point} a2
@@ -78,12 +101,12 @@ export class Intersection {
     aInfinite = true,
     bInfinite = true
   ): Intersection {
-    const b2xb1x = b2.x - b1.x,
-      a1yb1y = a1.y - b1.y,
+    const a2xa1x = a2.x - a1.x,
+      a2ya1y = a2.y - a1.y,
+      b2xb1x = b2.x - b1.x,
       b2yb1y = b2.y - b1.y,
       a1xb1x = a1.x - b1.x,
-      a2ya1y = a2.y - a1.y,
-      a2xa1x = a2.x - a1.x,
+      a1yb1y = a1.y - b1.y,
       uaT = b2xb1x * a1yb1y - b2yb1y * a1xb1x,
       ubT = a2xa1x * a1yb1y - a2ya1y * a1xb1x,
       uB = b2yb1y * a2xa1x - b2xb1x * a2ya1y;
@@ -105,11 +128,11 @@ export class Intersection {
         const segmentsCoincide =
           aInfinite ||
           bInfinite ||
-          Intersection.isContainedInInterval(a1, b1, b2) ||
-          Intersection.isContainedInInterval(a2, b1, b2) ||
-          Intersection.isContainedInInterval(b1, a1, a2) ||
-          Intersection.isContainedInInterval(b2, a1, a2);
-        return new this(segmentsCoincide ? 'Coincident' : undefined);
+          Intersection.isPointContained(a1, b1, b2) ||
+          Intersection.isPointContained(a2, b1, b2) ||
+          Intersection.isPointContained(b1, a1, a2) ||
+          Intersection.isPointContained(b2, a1, a2);
+        return new Intersection(segmentsCoincide ? 'Coincident' : undefined);
       } else {
         return new Intersection('Parallel');
       }

src/Point.ts

@@ -12,9 +12,10 @@ export interface IPoint {
  */
 export class Point implements IPoint {
   declare x: number;
-
   declare y: number;
 
+  static ZERO = new Point();
+
   constructor();
   constructor(x: number, y: number);
   constructor(point: IPoint);
@@ -356,7 +357,7 @@ export class Point implements IPoint {
    * @param {TRadian} radians The radians of the angle for the rotation
    * @return {Point} The new rotated point
    */
-  rotate(radians: TRadian, origin: IPoint = originZero): Point {
+  rotate(radians: TRadian, origin: IPoint = Point.ZERO): Point {
     // TODO benchmark and verify the add and subtract how much cost
     // and then in case early return if no origin is passed
     const sinus = sin(radians),
@@ -384,5 +385,3 @@ export class Point implements IPoint {
     );
   }
 }
-
-const originZero = new Point(0, 0);

src/util/misc/vectors.ts

@@ -40,13 +40,6 @@ export const calcAngleBetweenVectors = (a: Point, b: Point): TRadian => {
   return Math.atan2(det, dot) as TRadian;
 };
 
-export const slope = (v: Point) =>
-  v.x === 0 && v.y === 0
-    ? 0
-    : v.x === 0
-    ? Infinity * Math.sign(v.y)
-    : v.y / v.x;
-
 /**
  * Calculates the angle between the x axis and the vector
  * @param {Point} v