@synnaxlabs/x 0.16.1 → 0.24.0

package/src/spatial/bounds/bounds.ts

@@ -1,4 +1,4 @@
-// Copyright 2023 Synnax Labs, Inc.
+// Copyright 2024 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -7,118 +7,231 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
+import { math } from "@/math";
 import { type Bounds, bounds, type CrudeBounds } from "@/spatial/base";
 
 export { type Bounds, bounds };
 
-export type Crude = CrudeBounds;
+export type Crude<T extends number | bigint = number> = CrudeBounds<T>;
 
-export const construct = (lower: number | Crude, upper?: number): Bounds => {
-  const b = { lower: 0, upper: 0 };
-  if (typeof lower === "number") {
+export interface Construct {
+  /**
+   * Constructs a bounds object from the given crude bounds.
+   *
+   * @param bounds - The crude bounds to construct. Can either be a strict bounds object
+   * with a 'lower' and 'upper' property or an array of length 2. If the bounds are
+   * invalid i.e., the lower bound is greater than the upper bound, the bounds are
+   * swapped.
+   */ <T extends number | bigint = number>(bounds: Crude<T>): Bounds<T>;
+
+  /**
+   * Constructs a bounds object from the given lower and upper bounds.
+   * @param lower - The lower bound of the new bounds object.
+   * @param upper - The upper bound of the new bounds object.
+   *
+   * If only one argument is provided, it is assumed to be the upper bound and the lower
+   * bound is set to 0.
+   *
+   * If the lower bound is greater than the upper bound, the bounds are swapped.
+   */ <T extends number | bigint = number>(lower: number, upper?: number): Bounds<T>;
+
+  <T extends number | bigint = number>(
+    lower: number | Crude,
+    upper?: number,
+  ): Bounds<T>;
+}
+
+export const construct = <T extends bigint | number>(
+  lower: T | Crude<T>,
+  upper?: T,
+): Bounds<T> => {
+  const b: Bounds<T> = {} as const as Bounds<T>;
+  if (typeof lower === "number" || typeof lower === "bigint") {
     if (upper != null) {
       b.lower = lower;
       b.upper = upper;
     } else {
-      b.lower = 0;
+      b.lower = (typeof lower === "bigint" ? 0n : 0) as T;
       b.upper = lower;
     }
   } else if (Array.isArray(lower)) {
+    if (lower.length !== 2) throw new Error("bounds: expected array of length 2");
     [b.lower, b.upper] = lower;
-  } else {
-    b.lower = lower.lower;
-    b.upper = lower.upper;
-  }
+  } else return makeValid(lower);
   return makeValid(b);
 };
 
-export const ZERO = { lower: 0, upper: 0 };
-
-export const INFINITE = { lower: -Infinity, upper: Infinity };
-
-export const DECIMAL = { lower: 0, upper: 1 };
-
-export const CLIP = { lower: -1, upper: 1 };
+/** A lower and upper bound of 0. */
+export const ZERO: Bounds = Object.freeze({ lower: 0, upper: 0 });
+/** A lower bound of -Infinity and an upper bound of Infinity. */
+export const INFINITE: Bounds = Object.freeze({ lower: -Infinity, upper: Infinity });
+/** A lower bound of 0 and an upper bound of 1. */
+export const DECIMAL: Bounds = Object.freeze({ lower: 0, upper: 1 });
+/** Clip space bounds i.e. a lower bound of -1 and an upper bound of 1. */
+export const CLIP = Object.freeze({ lower: -1, upper: 1 });
 
-export const equals = (_a?: Bounds, _b?: Bounds): boolean => {
+/**
+ * Checks whether the given bounds are equal.
+ *
+ * @param _a - The first bounds to compare.
+ * @param _b - The second bounds to compare.
+ * @returns True if the bounds are equal, false otherwise.
+ */
+export const equals = <T extends bigint | number = number>(
+  _a?: Crude<T>,
+  _b?: Crude<T>,
+): boolean => {
   if (_a == null && _b == null) return true;
   if (_a == null || _b == null) return false;
   const a = construct(_a);
   const b = construct(_b);
   return a?.lower === b?.lower && a?.upper === b?.upper;
-}
-
-export const makeValid = (a: Bounds): Bounds => {
+};
+/**
+ * Makes the given bounds valid by swapping the lower and upper bounds if the lower bound
+ * is greater than the upper bound.
+ * @param a  - The bounds to make valid.
+ * @returns The valid bounds.
+ */
+export const makeValid = <T extends number | bigint = number>(
+  a: Bounds<T>,
+): Bounds<T> => {
   if (a.lower > a.upper) return { lower: a.upper, upper: a.lower };
   return a;
 };
 
-export const clamp = (bounds: Crude, target: number): number => {
-  const _bounds = construct(bounds);
+/**
+ * Clamps the given target value to the given bounds. If the target is less than the lower
+ * bound, the lower bound is returned. If the target is greater than or equal to the upper
+ * bound, the upper bound minus 1 is returned. Otherwise, the target is returned.
+ *
+ * @param bounds - The bounds to clamp the target to.
+ * @param target - The target value to clamp.
+ * @returns The clamped target value.
+ */
+export const clamp = <T extends number | bigint>(bounds: Crude<T>, target: T): T => {
+  const _bounds = construct<T>(bounds);
   if (target < _bounds.lower) return _bounds.lower;
-  if (target >= _bounds.upper) return _bounds.upper - 1;
+  if (target >= _bounds.upper)
+    return (_bounds.upper - ((typeof _bounds.upper === "number" ? 1 : 1n) as T)) as T;
   return target;
 };
 
-export const contains = (bounds: Crude, target: number | CrudeBounds): boolean => {
+/**
+ * Checks whether the given target value or bounds are within the given bounds.
+ *
+ * @param bounds - The bounds to check against.
+ * @param target - The target value to check. Can either be a number or a bounds object.
+ * @returns True if the target is within the bounds, false otherwise.
+ */
+export const contains = <T extends bigint | number>(
+  bounds: Crude<T>,
+  target: T | CrudeBounds<T>,
+): boolean => {
   const _bounds = construct(bounds);
-  if (typeof target === "number") return target >= _bounds.lower && target < _bounds.upper;
+  if (typeof target === "number" || typeof target === "bigint")
+    return target >= _bounds.lower && target < _bounds.upper;
   const _target = construct(target);
   return _target.lower >= _bounds.lower && _target.upper <= _bounds.upper;
-}
+};
 
-export const overlapsWith = (a: Crude, b: Crude): boolean => {
-  const _a = construct(a);
-  const _b = construct(b);
-  if (_a.lower ==_b.lower) return true;
-  if (_b.upper == _a.lower || _b.lower == _a.upper) return false;
-  return contains(_a, _b.upper) 
-  || contains(_a, _b.lower) 
-  || contains(_b, _a.upper) 
-  || contains(_b, _a.lower);
-}
+/**
+ * Checks whether the given bounds overlap with each other.
+ *
+ * @param a - The first bounds to check.
+ * @param b - The second bounds to check.
+ * @returns True if the bounds overlap, false otherwise.
+ */
+export const overlapsWith = <T extends bigint | number>(
+  a: Crude<T>,
+  b: Crude<T>,
+): boolean => {
+  const _a = construct<T>(a);
+  const _b = construct<T>(b);
+  if (_a.lower === _b.lower) return true;
+  if (_b.upper === _a.lower || _b.lower === _a.upper) return false;
+  return (
+    contains<T>(_a, _b.upper) ||
+    contains<T>(_a, _b.lower) ||
+    contains<T>(_b, _a.upper) ||
+    contains<T>(_b, _a.lower)
+  );
+};
 
-export const span = (a: Crude): number => {
-  const _a = construct(a);
-  return _a.upper - _a.lower;
-}
+/** @returns the span of the given bounds i.e. upper - lower. */
+export const span = <T extends number | bigint>(a: Crude<T>): T => {
+  const _a = construct<T>(a);
+  return (_a.upper - _a.lower) as T;
+};
 
-export const isZero = (a: Crude): boolean => {
+/** @returns true if both the lower and upper bounds are 0, false otherwise. */
+export const isZero = <T extends number | bigint>(a: Crude<T>): boolean => {
   const _a = construct(a);
+  if (typeof _a.lower === "bigint") return _a.lower === 0n && _a.upper === 0n;
   return _a.lower === 0 && _a.upper === 0;
-}
+};
 
+/**
+ * @returns true if the difference between the lower and upper bounds is 0,
+ * false otherwise.
+ */
 export const spanIsZero = (a: Crude): boolean => span(a) === 0;
 
+/**
+ * @returns true if both the upper and lower bounds are not Infinity or -Infinity,
+ * false otherwise.
+ */
 export const isFinite = (a: Crude): boolean => {
   const _a = construct(a);
   return Number.isFinite(_a.lower) && Number.isFinite(_a.upper);
-}
+};
 
+/**
+ * @returns bounds that have the maximum span of the given bounds i.e. the min of all
+ * of the lower bounds and the max of all of the upper bounds.
+ */
 export const max = (bounds: Crude[]): Bounds => ({
   lower: Math.min(...bounds.map((b) => construct(b).lower)),
   upper: Math.max(...bounds.map((b) => construct(b).upper)),
 });
 
+/**
+ * @returns bounds that have the minimum span of the given bounds i.e. the max of all
+ * of the lower bounds and the min of all of the upper bounds. Note that this function
+ * may create invalid bounds if the highest lower bound is greater than the lowest upper
+ * bound.
+ */
 export const min = (bounds: Crude[]): Bounds => ({
   lower: Math.max(...bounds.map((b) => construct(b).lower)),
   upper: Math.min(...bounds.map((b) => construct(b).upper)),
 });
 
-export const constructArray = (bounds: Crude): number[] => {
+/**
+ * @returns an array of integers from the lower bound to the upper bound of the given
+ * bounds.
+ */
+export const linspace = <T extends bigint | number = number>(bounds: Crude<T>): T[] => {
   const _bounds = construct(bounds);
-  return Array.from({ length: span(bounds) }, (_, i) => i + _bounds.lower);
-}
+  const isBigInt = typeof _bounds.lower === "bigint";
+  return Array.from({ length: Number(span(bounds)) }, (_, i) => {
+    if (isBigInt) return ((_bounds.lower as bigint) + BigInt(i)) as T;
+    return (_bounds.lower as number) + i;
+  }) as T[];
+};
 
-export const findInsertPosition = (bounds: Crude[], target: number): { index: number, position: number } => {
-  const _bounds = bounds.map(construct);
-  const index = _bounds.findIndex((b, i) => contains(b, target) || target < _bounds[i].lower);
+export const findInsertPosition = <T extends bigint | number>(
+  bounds: Array<Crude<T>>,
+  target: T,
+): { index: number; position: number } => {
+  const _bounds = bounds.map((b) => construct<T>(b));
+  const index = _bounds.findIndex(
+    (b, i) => contains<T>(b, target) || target < _bounds[i].lower,
+  );
   if (index === -1) return { index: bounds.length, position: 0 };
   const b = _bounds[index];
-  if (contains(b, target)) return { index, position: target - b.lower };
-  return {index: index, position: 0};
-}
-
+  if (contains(b, target)) return { index, position: Number(target - b.lower) };
+  return { index, position: 0 };
+};
 
 /**
  * A plan for inserting a new bound into an ordered array of bounds.
@@ -141,18 +254,18 @@ const ZERO_PLAN: InsertionPlan = {
   removeAfter: 0,
   insertInto: 0,
   deleteInBetween: 0,
-}
+};
 
 /**
  * Build a plan for inserting a new bound into an ordered array of bounds. This function
  * is particularly useful for inserting a new array into a sorted array of array of arrays
  * that may overlap. The plan is used to determine how to splice the new array into the
  * existing array. The following are important constraints:
- * 
- * 
+ *
+ *
  * 1. If the new bound is entirely contained within an existing bound, the new bound
  * is not inserted and the plan is null.
- * 
+ *
  * @param bounds - An ordered array of bounds, where each bound is valid (i.e., lower <= upper)
  * and the lower bound of each bound is less than the upper bound of the next bound.
  * @param value - The new bound to insert.
@@ -160,56 +273,58 @@ const ZERO_PLAN: InsertionPlan = {
  * new bound is entirely contained within an existing bound. See the {@link InsertionPlan}
  * type for more details.
  */
-export const buildInsertionPlan = (bounds: Crude[], value: Crude):InsertionPlan | null => {
-  const  _bounds = bounds.map(construct);
+export const buildInsertionPlan = <T extends number | bigint>(
+  bounds: Array<Crude<T>>,
+  value: Crude<T>,
+): InsertionPlan | null => {
+  const _bounds = bounds.map((b) => construct<T>(b));
   const _target = construct(value);
   // No bounds to insert into, so just insert the new bound at the beginning of the array.
   if (_bounds.length === 0) return ZERO_PLAN;
-  const lower = findInsertPosition(bounds, _target.lower);
-  const upper = findInsertPosition(bounds, _target.upper);
+  const lower = findInsertPosition<T>(_bounds, _target.lower);
+  const upper = findInsertPosition<T>(_bounds, _target.upper);
   // Greater than all bounds,
-  if (lower.index == bounds.length) return { ...ZERO_PLAN, insertInto: bounds.length };
+  if (lower.index === bounds.length) return { ...ZERO_PLAN, insertInto: bounds.length };
   // Less than all bounds,
-  if (upper.index == 0) return {
-    ...ZERO_PLAN,
-    removeAfter: upper.position
-  }
+  if (upper.index === 0) return { ...ZERO_PLAN, removeAfter: upper.position };
   if (lower.index === upper.index) {
     // The case where the bound is entirely contained within an existing bound.
-    if (lower.position !== 0 && upper.position !== 0)
-      return null;
+    if (lower.position !== 0 && upper.position !== 0) return null;
     return {
       removeAfter: upper.position,
       removeBefore: lower.position,
       insertInto: lower.index,
       deleteInBetween: 0,
-    }
+    };
   }
-  let deleteInBetween = (upper.index - lower.index)
+  let deleteInBetween = upper.index - lower.index;
   let insertInto = lower.index;
-  let removeBefore = span(_bounds[lower.index]) - lower.position;
+  let removeBefore = math.sub(Number(span(_bounds[lower.index])), lower.position);
   // If we're overlapping with the previous bound, we need to slice out one less
   // and insert one further up.
-  if (lower.position != 0) {
+  if (lower.position !== 0) {
     deleteInBetween -= 1;
     insertInto += 1;
-  // We're not overlapping with the previous bound, so don't need to remove anything
+    // We're not overlapping with the previous bound, so don't need to remove anything
   } else removeBefore = 0;
   return {
     removeBefore,
     removeAfter: upper.position,
-    insertInto, 
+    insertInto,
     deleteInBetween,
-  }
-}
-
+  };
+};
 
-export const insert = (bounds: Crude[], value: Crude): Crude[] => {
+export const insert = <T extends number | bigint = number>(
+  bounds: Array<Crude<T>>,
+  value: Crude<T>,
+): Array<Bounds<T>> => {
   const plan = buildInsertionPlan(bounds, value);
-  if (plan == null) return bounds;
+  const out = bounds.map((b) => construct(b));
+  if (plan == null) return out;
   const _target = construct(value);
-  _target.lower += plan.removeBefore;
-  _target.upper -= plan.removeAfter;
-  bounds.splice(plan.insertInto, plan.deleteInBetween, _target);
-  return bounds.map(construct);
-}
+  _target.lower = math.add(_target.lower, plan.removeBefore);
+  _target.upper = math.sub(_target.upper, plan.removeAfter);
+  out.splice(plan.insertInto, plan.deleteInBetween, _target);
+  return out;
+};

package/src/spatial/bounds/index.ts

@@ -1,4 +1,4 @@
-// Copyright 2023 Synnax Labs, Inc.
+// Copyright 2024 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -7,4 +7,4 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-export * as bounds from "@/spatial/bounds/bounds";
+export * as bounds from "@/spatial/bounds/bounds";

package/src/spatial/box/box.spec.ts

@@ -1,4 +1,4 @@
-// Copyright 2023 Synnax Labs, Inc.
+// Copyright 2024 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -7,7 +7,7 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { describe, test, expect, it } from "vitest";
+import { describe, expect, it,test } from "vitest";
 
 import * as box from "@/spatial/box/box";
 import * as location from "@/spatial/location/location";
@@ -237,4 +237,213 @@ describe("Box", () => {
       expect(box.bottomRight(b2)).toEqual({ x: 10, y: 20 });
     });
   });
+  describe("truncate", () => {
+    it("should truncte the precision of the coordinates", () => {
+      const b = box.construct(
+        { x: 0.123456, y: 0.123456 },
+        { x: 10.123456, y: 10.123456 },
+      );
+      const b2 = box.truncate(b, 2);
+      expect(box.topLeft(b2)).toEqual({ x: 0.12, y: 0.12 });
+      expect(box.topRight(b2)).toEqual({ x: 10.12, y: 0.12 });
+      expect(box.bottomLeft(b2)).toEqual({ x: 0.12, y: 10.12 });
+      expect(box.bottomRight(b2)).toEqual({ x: 10.12, y: 10.12 });
+    });
+  });
+  describe("intersection", () => {
+    it("should return the intersection of two boxes", () => {
+      const b = box.construct(0, 0, 10, 10);
+      const b2 = box.construct(5, 5, 15, 15);
+      const b3 = box.intersection(b, b2);
+      expect(box.topLeft(b3)).toEqual({ x: 5, y: 5 });
+      expect(box.topRight(b3)).toEqual({ x: 10, y: 5 });
+      expect(box.bottomLeft(b3)).toEqual({ x: 5, y: 10 });
+      expect(box.bottomRight(b3)).toEqual({ x: 10, y: 10 });
+    });
+    it("should return a zero box if there is no intersection", () => {
+      const b = box.construct(0, 0, 10, 10);
+      const b2 = box.construct(15, 15, 20, 20);
+      const b3 = box.intersection(b, b2);
+      expect(box.topLeft(b3)).toEqual({ x: 0, y: 0 });
+      expect(box.topRight(b3)).toEqual({ x: 0, y: 0 });
+      expect(box.bottomLeft(b3)).toEqual({ x: 0, y: 0 });
+      expect(box.bottomRight(b3)).toEqual({ x: 0, y: 0 });
+    });
+  });
+  describe("area", () => {
+    it("should return the area of the box", () => {
+      const b = box.construct(0, 0, 10, 10);
+      expect(box.area(b)).toBe(100);
+    });
+  });
+  describe("areaIsZero", () => {
+    it("should return true if the area is zero", () => {
+      const b = box.construct(0, 0, 0, 0);
+      expect(box.areaIsZero(b)).toBe(true);
+    });
+    it("should return false if the area is not zero", () => {
+      const b = box.construct(0, 0, 10, 10);
+      expect(box.areaIsZero(b)).toBe(false);
+    });
+  });
+  describe("isBox", () => {
+    it("should return true if the value is a box", () => {
+      const b = box.construct(0, 0, 10, 10);
+      expect(box.isBox(b)).toBe(true);
+    });
+    it("should return false if the value is not a box", () => {
+      expect(box.isBox({})).toBe(false);
+    });
+  });
+  describe("yBounds", () => {
+    it("should return the y bounds of the box", () => {
+      const b = box.construct(0, 0, 10, 10);
+      expect(box.yBounds(b)).toEqual({ lower: 0, upper: 10 });
+    });
+  });
+  describe("xBounds", () => {
+    it("should return the x bounds of the box", () => {
+      const b = box.construct(0, 0, 10, 10);
+      expect(box.xBounds(b)).toEqual({ lower: 0, upper: 10 });
+    });
+  });
+  describe("contains", () => {
+    describe("inclusive of border", () => {
+      it("should return true if the box completely contains the other box", () => {
+        const b = box.construct(0, 0, 20, 20);
+        const b2 = box.construct(5, 5, 15, 15);
+        expect(box.contains(b, b2)).toBe(true);
+      });
+      it("should return true if the box completely contains the other box", () => {
+        const b = box.construct(0, 0, 20, 20);
+        const b2 = box.construct(5, 5, 14, 14);
+        expect(box.contains(b, b2)).toBe(true);
+      });
+      it("should return false if the box does not completely contain the other box", () => {
+        const b = box.construct(0, 0, 10, 10);
+        const b2 = box.construct(5, 5, 15, 15);
+        expect(box.contains(b, b2)).toBe(false);
+      });
+      it("should return true if the two boxes are equal", () => {
+        const b = box.construct(0, 0, 10, 10);
+        expect(box.contains(b, b)).toBe(true);
+      });
+      it("should return true if the box contains the point", () => {
+        const b = box.construct(0, 0, 10, 10);
+        const p = { x: 5, y: 5 };
+        expect(box.contains(b, p)).toBe(true);
+      });
+      it("should return false if the box does not contain the point", () => {
+        const b = box.construct(0, 0, 10, 10);
+        const p = { x: 15, y: 15 };
+        expect(box.contains(b, p)).toBe(false);
+      });
+      it("should return true if the point is on the border", () => {
+        const b = box.construct(0, 0, 10, 10);
+        const p = { x: 10, y: 10 };
+        expect(box.contains(b, p)).toBe(true);
+      });
+    });
+    describe("exclusive of border", () => {
+      it("should return false if the box completely contains the other box", () => {
+        const b = box.construct(0, 0, 20, 20);
+        const b2 = box.construct(5, 5, 15, 15);
+        expect(box.contains(b, b2, false)).toBe(false);
+      });
+      it("should return true if the box completely contains the other box", () => {
+        const b = box.construct(0, 0, 20, 20);
+        const b2 = box.construct(5, 5, 14, 14);
+        expect(box.contains(b, b2, false)).toBe(true);
+      });
+      it("should return false if the box does not completely contain the other box", () => {
+        const b = box.construct(0, 0, 10, 10);
+        const b2 = box.construct(5, 5, 15, 15);
+        expect(box.contains(b, b2, false)).toBe(false);
+      });
+      it("should return false if the two boxes are equal", () => {
+        const b = box.construct(0, 0, 10, 10);
+        expect(box.contains(b, b, false)).toBe(false);
+      });
+      it("should return false if the box contains the point", () => {
+        const b = box.construct(0, 0, 10, 10);
+        const p = { x: 5, y: 5 };
+        expect(box.contains(b, p, false)).toBe(true);
+      });
+      it("should return false if the box does not contain the point", () => {
+        const b = box.construct(0, 0, 10, 10);
+        const p = { x: 15, y: 15 };
+        expect(box.contains(b, p, false)).toBe(false);
+      });
+      it("should return false if the point is on the border", () => {
+        const b = box.construct(0, 0, 10, 10);
+        const p = { x: 10, y: 10 };
+        expect(box.contains(b, p, false)).toBe(false);
+      });
+    });
+  });
+  describe("css", () => {
+    it("should return the box as an object of css properties", () => {
+      const b = box.construct(0, 0, 10, 10);
+      expect(box.css(b)).toEqual({
+        left: 0,
+        top: 0,
+        width: 10,
+        height: 10,
+      });
+    });
+  });
+  describe("copy", () => {
+    it("should return a copy of the box", () => {
+      const b = box.construct(0, 0, 10, 10);
+      const b2 = box.copy(b);
+      expect(box.equals(b, b2)).toBe(true);
+    });
+  });
+  describe("edgePoints", () => {
+    interface Spec {
+      box: box.Box;
+      loc: location.Location;
+      expected: [xy.XY, xy.XY];
+    }
+
+    const SPECS: Spec[] = [
+      {
+        box: box.construct(0, 0, 10, 10),
+        loc: "top",
+        expected: [
+          { x: 0, y: 0 },
+          { x: 10, y: 0 },
+        ],
+      },
+      {
+        box: box.construct(0, 0, 10, 10),
+        loc: "bottom",
+        expected: [
+          { x: 0, y: 10 },
+          { x: 10, y: 10 },
+        ],
+      },
+      {
+        box: box.construct(0, 0, 10, 10),
+        loc: "left",
+        expected: [
+          { x: 0, y: 0 },
+          { x: 0, y: 10 },
+        ],
+      },
+      {
+        box: box.construct(0, 0, 10, 10),
+        loc: "right",
+        expected: [
+          { x: 10, y: 0 },
+          { x: 10, y: 10 },
+        ],
+      },
+    ];
+    SPECS.forEach(({ box: b, loc, expected }) => {
+      test(`edgePoints-${loc}`, () => {
+        expect(box.edgePoints(b, loc)).toEqual(expected);
+      });
+    });
+  });
 });