refactor: Update generic constraint Point to use GenericPoint

- Changed existing generic constraints that used LocalPoint | GlobalPoint as Point to now use the unified GenericPoint type.
2025-05-03 10:00:07 -04:00 · 2025-04-17 13:16:35 +09:00 · 2025-04-17 13:16:35 +09:00 · 85cb973936
commit 85cb973936
parent 71e55dba9f
21 changed files with 153 additions and 211 deletions
--- a/packages/common/src/points.ts
+++ b/packages/common/src/points.ts
@ -1,14 +1,9 @@
-import {
-  pointFromPair,
-  type GlobalPoint,
-  type LocalPoint,
-} from "@excalidraw/math";
+import { type GenericPoint, pointFromPair } from "@excalidraw/math";
+import { pointFrom } from "@excalidraw/math";

 import type { NullableGridSize } from "@excalidraw/excalidraw/types";

-export const getSizeFromPoints = (
-  points: readonly (GlobalPoint | LocalPoint)[],
-) => {
+export const getSizeFromPoints = (points: readonly GenericPoint[]) => {
  const xs = points.map((point) => point[0]);
  const ys = points.map((point) => point[1]);
  return {
@ -18,7 +13,7 @@ export const getSizeFromPoints = (
 };

 /** @arg dimension, 0 for rescaling only x, 1 for y */
-export const rescalePoints = <Point extends GlobalPoint | LocalPoint>(
+export const rescalePoints = <Point extends GenericPoint>(
  dimension: 0 | 1,
  newSize: number,
  points: readonly Point[],
@ -65,16 +60,16 @@ export const rescalePoints = <Point extends GlobalPoint | LocalPoint>(
 };

 // TODO: Rounding this point causes some shake when free drawing
-export const getGridPoint = (
+export const getGridPoint = <Point extends GenericPoint>(
  x: number,
  y: number,
  gridSize: NullableGridSize,
-): [number, number] => {
+): Point => {
  if (gridSize) {
-    return [
+    return pointFrom(
      Math.round(x / gridSize) * gridSize,
      Math.round(y / gridSize) * gridSize,
-    ];
+    );
  }
-  return [x, y];
+  return pointFrom(x, y);
 };
--- a/packages/element/src/collision.ts
+++ b/packages/element/src/collision.ts
@ -19,9 +19,9 @@ import { isPointInShape, isPointOnShape } from "@excalidraw/utils/collision";
 import { type GeometricShape, getPolygonShape } from "@excalidraw/utils/shape";

 import type {
+  GenericPoint,
  GlobalPoint,
  LineSegment,
-  LocalPoint,
  Polygon,
  Radians,
 } from "@excalidraw/math";
@ -72,7 +72,7 @@ export const shouldTestInside = (element: ExcalidrawElement) => {
  return isDraggableFromInside || isImageElement(element);
 };

-export type HitTestArgs<Point extends GlobalPoint | LocalPoint> = {
+export type HitTestArgs<Point extends GenericPoint> = {
  x: number;
  y: number;
  element: ExcalidrawElement;
@ -81,7 +81,7 @@ export type HitTestArgs<Point extends GlobalPoint | LocalPoint> = {
  frameNameBound?: FrameNameBounds | null;
 };

-export const hitElementItself = <Point extends GlobalPoint | LocalPoint>({
+export const hitElementItself = <Point extends GenericPoint>({
  x,
  y,
  element,
@ -127,9 +127,7 @@ export const hitElementBoundingBox = (
  );
 };

-export const hitElementBoundingBoxOnly = <
-  Point extends GlobalPoint | LocalPoint,
->(
+export const hitElementBoundingBoxOnly = <Point extends GenericPoint>(
  hitArgs: HitTestArgs<Point>,
  elementsMap: ElementsMap,
 ) => {
@ -145,7 +143,7 @@ export const hitElementBoundingBoxOnly = <
  );
 };

-export const hitElementBoundText = <Point extends GlobalPoint | LocalPoint>(
+export const hitElementBoundText = <Point extends GenericPoint>(
  x: number,
  y: number,
  textShape: GeometricShape<Point> | null,
--- a/packages/element/src/elbowArrow.ts
+++ b/packages/element/src/elbowArrow.ts
@ -9,6 +9,7 @@ import {
  vectorCross,
  vectorFromPoint,
  vectorScale,
+  type GenericPoint,
  type GlobalPoint,
  type LocalPoint,
 } from "@excalidraw/math";
@ -1642,7 +1643,7 @@ const pathTo = (start: Node, node: Node) => {
  return path;
 };

-const m_dist = (a: GlobalPoint | LocalPoint, b: GlobalPoint | LocalPoint) =>
+const m_dist = (a: GenericPoint, b: GenericPoint) =>
  Math.abs(a[0] - b[0]) + Math.abs(a[1] - b[1]);

 /**
@ -2291,7 +2292,7 @@ const getHoveredElement = (
 const gridAddressesEqual = (a: GridAddress, b: GridAddress): boolean =>
  a[0] === b[0] && a[1] === b[1];

-export const validateElbowPoints = <P extends GlobalPoint | LocalPoint>(
+export const validateElbowPoints = <P extends GenericPoint>(
  points: readonly P[],
  tolerance: number = DEDUP_TRESHOLD,
 ) =>
--- a/packages/element/src/heading.ts
+++ b/packages/element/src/heading.ts
@ -13,10 +13,10 @@ import {
 } from "@excalidraw/math";

 import type {
-  LocalPoint,
  GlobalPoint,
  Triangle,
  Vector,
+  GenericPoint,
 } from "@excalidraw/math";

 import { getCenterForBounds, type Bounds } from "./bounds";
@ -43,12 +43,10 @@ export const vectorToHeading = (vec: Vector): Heading => {
  return HEADING_UP;
 };

-export const headingForPoint = <P extends GlobalPoint | LocalPoint>(
-  p: P,
-  o: P,
-) => vectorToHeading(vectorFromPoint<P>(p, o));
+export const headingForPoint = <P extends GenericPoint>(p: P, o: P) =>
+  vectorToHeading(vectorFromPoint<P>(p, o));

-export const headingForPointIsHorizontal = <P extends GlobalPoint | LocalPoint>(
+export const headingForPointIsHorizontal = <P extends GenericPoint>(
  p: P,
  o: P,
 ) => headingIsHorizontal(headingForPoint<P>(p, o));
--- a/packages/element/src/resizeTest.ts
+++ b/packages/element/src/resizeTest.ts
@ -7,7 +7,7 @@ import {

 import { SIDE_RESIZING_THRESHOLD } from "@excalidraw/common";

-import type { GlobalPoint, LineSegment, LocalPoint } from "@excalidraw/math";
+import type { GenericPoint, LineSegment } from "@excalidraw/math";

 import type { AppState, Device, Zoom } from "@excalidraw/excalidraw/types";

@ -43,7 +43,7 @@ const isInsideTransformHandle = (
  y >= transformHandle[1] &&
  y <= transformHandle[1] + transformHandle[3];

-export const resizeTest = <Point extends GlobalPoint | LocalPoint>(
+export const resizeTest = <Point extends GenericPoint>(
  element: NonDeletedExcalidrawElement,
  elementsMap: ElementsMap,
  appState: AppState,
@ -152,9 +152,7 @@ export const getElementWithTransformHandleType = (
  }, null as { element: NonDeletedExcalidrawElement; transformHandleType: MaybeTransformHandleType } | null);
 };

-export const getTransformHandleTypeFromCoords = <
-  Point extends GlobalPoint | LocalPoint,
->(
+export const getTransformHandleTypeFromCoords = <Point extends GenericPoint>(
  [x1, y1, x2, y2]: Bounds,
  scenePointerX: number,
  scenePointerY: number,
@ -271,7 +269,7 @@ export const getCursorForResizingElement = (resizingElement: {
  return cursor ? `${cursor}-resize` : "";
 };

-const getSelectionBorders = <Point extends LocalPoint | GlobalPoint>(
+const getSelectionBorders = <Point extends GenericPoint>(
  [x1, y1]: Point,
  [x2, y2]: Point,
  center: Point,
--- a/packages/element/src/shapes.ts
+++ b/packages/element/src/shapes.ts
@ -13,8 +13,7 @@ import {
  pointFromPair,
  pointRotateRads,
  pointsEqual,
-  type GlobalPoint,
-  type LocalPoint,
+  type GenericPoint,
 } from "@excalidraw/math";
 import {
  getClosedCurveShape,
@ -46,7 +45,7 @@ import type {
 * get the pure geometric shape of an excalidraw elementw
 * which is then used for hit detection
 */
-export const getElementShape = <Point extends GlobalPoint | LocalPoint>(
+export const getElementShape = <Point extends GenericPoint>(
  element: ExcalidrawElement,
  elementsMap: ElementsMap,
 ): GeometricShape<Point> => {
@ -98,7 +97,7 @@ export const getElementShape = <Point extends GlobalPoint | LocalPoint>(
  }
 };

-export const getBoundTextShape = <Point extends GlobalPoint | LocalPoint>(
+export const getBoundTextShape = <Point extends GenericPoint>(
  element: ExcalidrawElement,
  elementsMap: ElementsMap,
 ): GeometricShape<Point> | null => {
@ -126,9 +125,7 @@ export const getBoundTextShape = <Point extends GlobalPoint | LocalPoint>(
  return null;
 };

-export const getControlPointsForBezierCurve = <
-  P extends GlobalPoint | LocalPoint,
->(
+export const getControlPointsForBezierCurve = <P extends GenericPoint>(
  element: NonDeleted<ExcalidrawLinearElement>,
  endPoint: P,
 ) => {
@ -170,7 +167,7 @@ export const getControlPointsForBezierCurve = <
  return controlPoints;
 };

-export const getBezierXY = <P extends GlobalPoint | LocalPoint>(
+export const getBezierXY = <P extends GenericPoint>(
  p0: P,
  p1: P,
  p2: P,
@ -187,7 +184,7 @@ export const getBezierXY = <P extends GlobalPoint | LocalPoint>(
  return pointFrom(tx, ty);
 };

-const getPointsInBezierCurve = <P extends GlobalPoint | LocalPoint>(
+const getPointsInBezierCurve = <P extends GenericPoint>(
  element: NonDeleted<ExcalidrawLinearElement>,
  endPoint: P,
 ) => {
@ -217,7 +214,7 @@ const getPointsInBezierCurve = <P extends GlobalPoint | LocalPoint>(
  return pointsOnCurve;
 };

-const getBezierCurveArcLengths = <P extends GlobalPoint | LocalPoint>(
+const getBezierCurveArcLengths = <P extends GenericPoint>(
  element: NonDeleted<ExcalidrawLinearElement>,
  endPoint: P,
 ) => {
@ -236,7 +233,7 @@ const getBezierCurveArcLengths = <P extends GlobalPoint | LocalPoint>(
  return arcLengths;
 };

-export const getBezierCurveLength = <P extends GlobalPoint | LocalPoint>(
+export const getBezierCurveLength = <P extends GenericPoint>(
  element: NonDeleted<ExcalidrawLinearElement>,
  endPoint: P,
 ) => {
@ -245,7 +242,7 @@ export const getBezierCurveLength = <P extends GlobalPoint | LocalPoint>(
 };

 // This maps interval to actual interval t on the curve so that when t = 0.5, its actually the point at 50% of the length
-export const mapIntervalToBezierT = <P extends GlobalPoint | LocalPoint>(
+export const mapIntervalToBezierT = <P extends GenericPoint>(
  element: NonDeleted<ExcalidrawLinearElement>,
  endPoint: P,
  interval: number, // The interval between 0 to 1 for which you want to find the point on the curve,
@ -340,7 +337,7 @@ export const aabbForElement = (
  return bounds;
 };

-export const pointInsideBounds = <P extends GlobalPoint | LocalPoint>(
+export const pointInsideBounds = <P extends GenericPoint>(
  p: P,
  bounds: Bounds,
 ): boolean =>
--- a/packages/excalidraw/renderer/interactiveScene.ts
+++ b/packages/excalidraw/renderer/interactiveScene.ts
@ -2,8 +2,8 @@ import oc from "open-color";
 import {
  pointFrom,
  type GlobalPoint,
-  type LocalPoint,
  type Radians,
+  type GenericPoint,
 } from "@excalidraw/math";

 import {
@ -144,7 +144,7 @@ const renderLinearElementPointHighlight = (
  context.restore();
 };

-const highlightPoint = <Point extends LocalPoint | GlobalPoint>(
+const highlightPoint = <Point extends GenericPoint>(
  point: Point,
  context: CanvasRenderingContext2D,
  appState: InteractiveCanvasAppState,
@ -211,7 +211,7 @@ const strokeDiamondWithRotation = (
  context.restore();
 };

-const renderSingleLinearPoint = <Point extends GlobalPoint | LocalPoint>(
+const renderSingleLinearPoint = <Point extends GenericPoint>(
  context: CanvasRenderingContext2D,
  appState: InteractiveCanvasAppState,
  point: Point,
--- a/packages/excalidraw/renderer/renderSnaps.ts
+++ b/packages/excalidraw/renderer/renderSnaps.ts
@ -1,4 +1,4 @@
-import { pointFrom, type GlobalPoint, type LocalPoint } from "@excalidraw/math";
+import { pointFrom, type GenericPoint } from "@excalidraw/math";

 import { THEME } from "@excalidraw/common";

@ -88,7 +88,7 @@ const drawPointerSnapLine = (
  }
 };

-const drawCross = <Point extends LocalPoint | GlobalPoint>(
+const drawCross = <Point extends GenericPoint>(
  [x, y]: Point,
  appState: InteractiveCanvasAppState,
  context: CanvasRenderingContext2D,
@ -109,7 +109,7 @@ const drawCross = <Point extends LocalPoint | GlobalPoint>(
  context.restore();
 };

-const drawLine = <Point extends LocalPoint | GlobalPoint>(
+const drawLine = <Point extends GenericPoint>(
  from: Point,
  to: Point,
  context: CanvasRenderingContext2D,
@ -120,7 +120,7 @@ const drawLine = <Point extends LocalPoint | GlobalPoint>(
  context.stroke();
 };

-const drawGapLine = <Point extends LocalPoint | GlobalPoint>(
+const drawGapLine = <Point extends GenericPoint>(
  from: Point,
  to: Point,
  direction: "horizontal" | "vertical",
--- a/packages/math/src/angle.ts
+++ b/packages/math/src/angle.ts
@ -1,12 +1,6 @@
 import { PRECISION } from "./utils";

-import type {
-  Degrees,
-  GlobalPoint,
-  LocalPoint,
-  PolarCoords,
-  Radians,
-} from "./types";
+import type { Degrees, GenericPoint, PolarCoords, Radians } from "./types";

 // TODO: Simplify with modulo and fix for angles beyond 4*Math.PI and - 4*Math.PI
 export const normalizeRadians = (angle: Radians): Radians => {
@ -24,7 +18,7 @@ export const normalizeRadians = (angle: Radians): Radians => {
 * (x, y) for the center point 0,0 where the first number returned is the radius,
 * the second is the angle in radians.
 */
-export const cartesian2Polar = <P extends GlobalPoint | LocalPoint>([
+export const cartesian2Polar = <P extends GenericPoint>([
  x,
  y,
 ]: P): PolarCoords => [
--- a/packages/math/src/curve.ts
+++ b/packages/math/src/curve.ts
@ -3,7 +3,7 @@ import type { Bounds } from "@excalidraw/element/bounds";
 import { isPoint, pointDistance, pointFrom } from "./point";
 import { rectangle, rectangleIntersectLineSegment } from "./rectangle";

-import type { Curve, GlobalPoint, LineSegment, LocalPoint } from "./types";
+import type { Curve, GenericPoint, LineSegment } from "./types";

 /**
 *
@ -13,7 +13,7 @@ import type { Curve, GlobalPoint, LineSegment, LocalPoint } from "./types";
 * @param d
 * @returns
 */
-export function curve<Point extends GlobalPoint | LocalPoint>(
+export function curve<Point extends GenericPoint>(
  a: Point,
  b: Point,
  c: Point,
@ -82,7 +82,7 @@ function solve(
  return [t0, s0];
 }

-const bezierEquation = <Point extends GlobalPoint | LocalPoint>(
+const bezierEquation = <Point extends GenericPoint>(
  c: Curve<Point>,
  t: number,
 ) =>
@ -100,9 +100,10 @@ const bezierEquation = <Point extends GlobalPoint | LocalPoint>(
 /**
 * Computes the intersection between a cubic spline and a line segment.
 */
-export function curveIntersectLineSegment<
-  Point extends GlobalPoint | LocalPoint,
->(c: Curve<Point>, l: LineSegment<Point>): Point[] {
+export function curveIntersectLineSegment<Point extends GenericPoint>(
+  c: Curve<Point>,
+  l: LineSegment<Point>,
+): Point[] {
  // Optimize by doing a cheap bounding box check first
  const bounds = curveBounds(c);
  if (
@ -188,7 +189,7 @@ export function curveIntersectLineSegment<
 * @param maxLevel
 * @returns
 */
-export function curveClosestPoint<Point extends GlobalPoint | LocalPoint>(
+export function curveClosestPoint<Point extends GenericPoint>(
  c: Curve<Point>,
  p: Point,
  tolerance: number = 1e-3,
@ -245,7 +246,7 @@ export function curveClosestPoint<Point extends GlobalPoint | LocalPoint>(
 * @param c The curve to test
 * @param p The point to measure from
 */
-export function curvePointDistance<Point extends GlobalPoint | LocalPoint>(
+export function curvePointDistance<Point extends GenericPoint>(
  c: Curve<Point>,
  p: Point,
 ) {
@ -261,9 +262,7 @@ export function curvePointDistance<Point extends GlobalPoint | LocalPoint>(
 /**
 * Determines if the parameter is a Curve
 */
-export function isCurve<P extends GlobalPoint | LocalPoint>(
-  v: unknown,
-): v is Curve<P> {
+export function isCurve<P extends GenericPoint>(v: unknown): v is Curve<P> {
  return (
    Array.isArray(v) &&
    v.length === 4 &&
@ -274,9 +273,7 @@ export function isCurve<P extends GlobalPoint | LocalPoint>(
  );
 }

-function curveBounds<Point extends GlobalPoint | LocalPoint>(
-  c: Curve<Point>,
-): Bounds {
+function curveBounds<Point extends GenericPoint>(c: Curve<Point>): Bounds {
  const [P0, P1, P2, P3] = c;
  const x = [P0[0], P1[0], P2[0], P3[0]];
  const y = [P0[1], P1[1], P2[1], P3[1]];
--- a/packages/math/src/ellipse.ts
+++ b/packages/math/src/ellipse.ts
@ -13,13 +13,7 @@ import {
  vectorScale,
 } from "./vector";

-import type {
-  Ellipse,
-  GlobalPoint,
-  Line,
-  LineSegment,
-  LocalPoint,
-} from "./types";
+import type { Ellipse, GenericPoint, Line, LineSegment } from "./types";

 /**
 * Construct an Ellipse object from the parameters
@ -30,7 +24,7 @@ import type {
 * @param halfHeight Half of the height of a non-slanted version of the ellipse
 * @returns The constructed Ellipse object
 */
-export function ellipse<Point extends GlobalPoint | LocalPoint>(
+export function ellipse<Point extends GenericPoint>(
  center: Point,
  halfWidth: number,
  halfHeight: number,
@ -49,7 +43,7 @@ export function ellipse<Point extends GlobalPoint | LocalPoint>(
 * @param ellipse The ellipse to compare against
 * @returns TRUE if the point is inside or on the outline of the ellipse
 */
-export const ellipseIncludesPoint = <Point extends GlobalPoint | LocalPoint>(
+export const ellipseIncludesPoint = <Point extends GenericPoint>(
  p: Point,
  ellipse: Ellipse<Point>,
 ) => {
@ -69,7 +63,7 @@ export const ellipseIncludesPoint = <Point extends GlobalPoint | LocalPoint>(
 * @param threshold The distance to consider a point close enough to be "on" the outline
 * @returns TRUE if the point is on the ellise outline
 */
-export const ellipseTouchesPoint = <Point extends GlobalPoint | LocalPoint>(
+export const ellipseTouchesPoint = <Point extends GenericPoint>(
  point: Point,
  ellipse: Ellipse<Point>,
  threshold = PRECISION,
@ -85,9 +79,7 @@ export const ellipseTouchesPoint = <Point extends GlobalPoint | LocalPoint>(
 * @param ellipse The ellipse to calculate the distance to
 * @returns The eucledian distance
 */
-export const ellipseDistanceFromPoint = <
-  Point extends GlobalPoint | LocalPoint,
->(
+export const ellipseDistanceFromPoint = <Point extends GenericPoint>(
  p: Point,
  ellipse: Ellipse<Point>,
 ): number => {
@ -140,9 +132,10 @@ export const ellipseDistanceFromPoint = <
 * Calculate a maximum of two intercept points for a line going throug an
 * ellipse.
 */
-export function ellipseSegmentInterceptPoints<
-  Point extends GlobalPoint | LocalPoint,
->(e: Readonly<Ellipse<Point>>, s: Readonly<LineSegment<Point>>): Point[] {
+export function ellipseSegmentInterceptPoints<Point extends GenericPoint>(
+  e: Readonly<Ellipse<Point>>,
+  s: Readonly<LineSegment<Point>>,
+): Point[] {
  const rx = e.halfWidth;
  const ry = e.halfHeight;

@ -194,9 +187,7 @@ export function ellipseSegmentInterceptPoints<
  return intersections;
 }

-export function ellipseLineIntersectionPoints<
-  Point extends GlobalPoint | LocalPoint,
->(
+export function ellipseLineIntersectionPoints<Point extends GenericPoint>(
  { center, halfWidth, halfHeight }: Ellipse<Point>,
  [g, h]: Line<Point>,
 ): Point[] {
--- a/packages/math/src/line.ts
+++ b/packages/math/src/line.ts
@ -1,6 +1,6 @@
 import { pointFrom } from "./point";

-import type { GlobalPoint, Line, LocalPoint } from "./types";
+import type { GenericPoint, Line } from "./types";

 /**
 * Create a line from two points.
@ -8,7 +8,7 @@ import type { GlobalPoint, Line, LocalPoint } from "./types";
 * @param points The two points lying on the line
 * @returns The line on which the points lie
 */
-export function line<P extends GlobalPoint | LocalPoint>(a: P, b: P): Line<P> {
+export function line<P extends GenericPoint>(a: P, b: P): Line<P> {
  return [a, b] as Line<P>;
 }

@ -20,7 +20,7 @@ export function line<P extends GlobalPoint | LocalPoint>(a: P, b: P): Line<P> {
 * @param b
 * @returns
 */
-export function linesIntersectAt<Point extends GlobalPoint | LocalPoint>(
+export function linesIntersectAt<Point extends GenericPoint>(
  a: Line<Point>,
  b: Line<Point>,
 ): Point | null {
--- a/packages/math/src/point.ts
+++ b/packages/math/src/point.ts
@ -2,13 +2,7 @@ import { degreesToRadians } from "./angle";
 import { PRECISION } from "./utils";
 import { vectorFromPoint, vectorScale } from "./vector";

-import type {
-  LocalPoint,
-  GlobalPoint,
-  Radians,
-  Degrees,
-  Vector,
-} from "./types";
+import type { Radians, Degrees, Vector, GenericPoint } from "./types";

 /**
 * Create a properly typed Point instance from the X and Y coordinates.
@ -17,7 +11,7 @@ import type {
 * @param y The Y coordinate
 * @returns The branded and created point
 */
-export function pointFrom<Point extends GlobalPoint | LocalPoint>(
+export function pointFrom<Point extends GenericPoint>(
  x: number,
  y: number,
 ): Point {
@ -30,7 +24,7 @@ export function pointFrom<Point extends GlobalPoint | LocalPoint>(
 * @param numberArray The number array to check and to convert to Point
 * @returns The point instance
 */
-export function pointFromArray<Point extends GlobalPoint | LocalPoint>(
+export function pointFromArray<Point extends GenericPoint>(
  numberArray: number[],
 ): Point | undefined {
  return numberArray.length === 2
@ -44,7 +38,7 @@ export function pointFromArray<Point extends GlobalPoint | LocalPoint>(
 * @param pair A number pair to convert to Point
 * @returns The point instance
 */
-export function pointFromPair<Point extends GlobalPoint | LocalPoint>(
+export function pointFromPair<Point extends GenericPoint>(
  pair: [number, number],
 ): Point {
  return pair as Point;
@ -56,7 +50,7 @@ export function pointFromPair<Point extends GlobalPoint | LocalPoint>(
 * @param v The vector to convert
 * @returns The point the vector points at with origin 0,0
 */
-export function pointFromVector<P extends GlobalPoint | LocalPoint>(
+export function pointFromVector<P extends GenericPoint>(
  v: Vector,
  offset: P = pointFrom(0, 0),
 ): P {
@ -69,7 +63,7 @@ export function pointFromVector<P extends GlobalPoint | LocalPoint>(
 * @param p The value to attempt verification on
 * @returns TRUE if the provided value has the shape of a local or global point
 */
-export function isPoint(p: unknown): p is LocalPoint | GlobalPoint {
+export function isPoint(p: unknown): p is GenericPoint {
  return (
    Array.isArray(p) &&
    p.length === 2 &&
@ -88,7 +82,7 @@ export function isPoint(p: unknown): p is LocalPoint | GlobalPoint {
 * @param b Point The second point to compare
 * @returns TRUE if the points are sufficiently close to each other
 */
-export function pointsEqual<Point extends GlobalPoint | LocalPoint>(
+export function pointsEqual<Point extends GenericPoint>(
  a: Point,
  b: Point,
 ): boolean {
@ -104,7 +98,7 @@ export function pointsEqual<Point extends GlobalPoint | LocalPoint>(
 * @param angle The radians to rotate the point by
 * @returns The rotated point
 */
-export function pointRotateRads<Point extends GlobalPoint | LocalPoint>(
+export function pointRotateRads<Point extends GenericPoint>(
  [x, y]: Point,
  [cx, cy]: Point,
  angle: Radians,
@ -123,7 +117,7 @@ export function pointRotateRads<Point extends GlobalPoint | LocalPoint>(
 * @param angle The degree to rotate the point by
 * @returns The rotated point
 */
-export function pointRotateDegs<Point extends GlobalPoint | LocalPoint>(
+export function pointRotateDegs<Point extends GenericPoint>(
  point: Point,
  center: Point,
  angle: Degrees,
@ -145,8 +139,8 @@ export function pointRotateDegs<Point extends GlobalPoint | LocalPoint>(
 */
 // TODO 99% of use is translating between global and local coords, which need to be formalized
 export function pointTranslate<
-  From extends GlobalPoint | LocalPoint,
-  To extends GlobalPoint | LocalPoint,
+  From extends GenericPoint,
+  To extends GenericPoint,
 >(p: From, v: Vector = [0, 0] as Vector): To {
  return pointFrom(p[0] + v[0], p[1] + v[1]);
 }
@ -158,7 +152,7 @@ export function pointTranslate<
 * @param b The other point to create the middle point for
 * @returns The middle point
 */
-export function pointCenter<P extends LocalPoint | GlobalPoint>(a: P, b: P): P {
+export function pointCenter<P extends GenericPoint>(a: P, b: P): P {
  return pointFrom((a[0] + b[0]) / 2, (a[1] + b[1]) / 2);
 }

@ -169,10 +163,7 @@ export function pointCenter<P extends LocalPoint | GlobalPoint>(a: P, b: P): P {
 * @param b Second point
 * @returns The euclidean distance between the two points.
 */
-export function pointDistance<P extends LocalPoint | GlobalPoint>(
-  a: P,
-  b: P,
-): number {
+export function pointDistance<P extends GenericPoint>(a: P, b: P): number {
  return Math.hypot(b[0] - a[0], b[1] - a[1]);
 }

@ -185,10 +176,7 @@ export function pointDistance<P extends LocalPoint | GlobalPoint>(
 * @param b Second point
 * @returns The euclidean distance between the two points.
 */
-export function pointDistanceSq<P extends LocalPoint | GlobalPoint>(
-  a: P,
-  b: P,
-): number {
+export function pointDistanceSq<P extends GenericPoint>(a: P, b: P): number {
  const xDiff = b[0] - a[0];
  const yDiff = b[1] - a[1];

@ -203,7 +191,7 @@ export function pointDistanceSq<P extends LocalPoint | GlobalPoint>(
 * @param multiplier The scaling factor
 * @returns
 */
-export const pointScaleFromOrigin = <P extends GlobalPoint | LocalPoint>(
+export const pointScaleFromOrigin = <P extends GenericPoint>(
  p: P,
  mid: P,
  multiplier: number,
@ -218,7 +206,7 @@ export const pointScaleFromOrigin = <P extends GlobalPoint | LocalPoint>(
 * @param r The other point to compare against
 * @returns TRUE if q is indeed between p and r
 */
-export const isPointWithinBounds = <P extends GlobalPoint | LocalPoint>(
+export const isPointWithinBounds = <P extends GenericPoint>(
  p: P,
  q: P,
  r: P,
--- a/packages/math/src/polygon.ts
+++ b/packages/math/src/polygon.ts
@ -2,21 +2,17 @@ import { pointsEqual } from "./point";
 import { lineSegment, pointOnLineSegment } from "./segment";
 import { PRECISION } from "./utils";

-import type { GlobalPoint, LocalPoint, Polygon } from "./types";
+import type { GenericPoint, Polygon } from "./types";

-export function polygon<Point extends GlobalPoint | LocalPoint>(
-  ...points: Point[]
-) {
+export function polygon<Point extends GenericPoint>(...points: Point[]) {
  return polygonClose(points) as Polygon<Point>;
 }

-export function polygonFromPoints<Point extends GlobalPoint | LocalPoint>(
-  points: Point[],
-) {
+export function polygonFromPoints<Point extends GenericPoint>(points: Point[]) {
  return polygonClose(points) as Polygon<Point>;
 }

-export const polygonIncludesPoint = <Point extends LocalPoint | GlobalPoint>(
+export const polygonIncludesPoint = <Point extends GenericPoint>(
  point: Point,
  polygon: Polygon<Point>,
 ) => {
@ -69,7 +65,7 @@ export const polygonIncludesPointNonZero = <Point extends [number, number]>(
  return windingNumber !== 0;
 };

-export const pointOnPolygon = <Point extends LocalPoint | GlobalPoint>(
+export const pointOnPolygon = <Point extends GenericPoint>(
  p: Point,
  poly: Polygon<Point>,
  threshold = PRECISION,
@ -86,16 +82,12 @@ export const pointOnPolygon = <Point extends LocalPoint | GlobalPoint>(
  return on;
 };

-function polygonClose<Point extends LocalPoint | GlobalPoint>(
-  polygon: Point[],
-) {
+function polygonClose<Point extends GenericPoint>(polygon: Point[]) {
  return polygonIsClosed(polygon)
    ? polygon
    : ([...polygon, polygon[0]] as Polygon<Point>);
 }

-function polygonIsClosed<Point extends LocalPoint | GlobalPoint>(
-  polygon: Point[],
-) {
+function polygonIsClosed<Point extends GenericPoint>(polygon: Point[]) {
  return pointsEqual(polygon[0], polygon[polygon.length - 1]);
 }
--- a/packages/math/src/rectangle.ts
+++ b/packages/math/src/rectangle.ts
@ -1,18 +1,19 @@
 import { pointFrom } from "./point";
 import { lineSegment, lineSegmentIntersectionPoints } from "./segment";

-import type { GlobalPoint, LineSegment, LocalPoint, Rectangle } from "./types";
+import type { GenericPoint, LineSegment, Rectangle } from "./types";

-export function rectangle<P extends GlobalPoint | LocalPoint>(
+export function rectangle<P extends GenericPoint>(
  topLeft: P,
  bottomRight: P,
 ): Rectangle<P> {
  return [topLeft, bottomRight] as Rectangle<P>;
 }

-export function rectangleIntersectLineSegment<
-  Point extends LocalPoint | GlobalPoint,
->(r: Rectangle<Point>, l: LineSegment<Point>): Point[] {
+export function rectangleIntersectLineSegment<Point extends GenericPoint>(
+  r: Rectangle<Point>,
+  l: LineSegment<Point>,
+): Point[] {
  return [
    lineSegment(r[0], pointFrom(r[1][0], r[0][1])),
    lineSegment(pointFrom(r[1][0], r[0][1]), r[1]),
--- a/packages/math/src/segment.ts
+++ b/packages/math/src/segment.ts
@ -14,7 +14,7 @@ import {
  vectorSubtract,
 } from "./vector";

-import type { GlobalPoint, LineSegment, LocalPoint, Radians } from "./types";
+import type { GenericPoint, LineSegment, Radians } from "./types";

 /**
 * Create a line segment from two points.
@ -22,7 +22,7 @@ import type { GlobalPoint, LineSegment, LocalPoint, Radians } from "./types";
 * @param points The two points delimiting the line segment on each end
 * @returns The line segment delineated by the points
 */
-export function lineSegment<P extends GlobalPoint | LocalPoint>(
+export function lineSegment<P extends GenericPoint>(
  a: P,
  b: P,
 ): LineSegment<P> {
@ -34,7 +34,7 @@ export function lineSegment<P extends GlobalPoint | LocalPoint>(
 * @param segment
 * @returns
 */
-export const isLineSegment = <Point extends GlobalPoint | LocalPoint>(
+export const isLineSegment = <Point extends GenericPoint>(
  segment: unknown,
 ): segment is LineSegment<Point> =>
  Array.isArray(segment) &&
@ -51,7 +51,7 @@ export const isLineSegment = <Point extends GlobalPoint | LocalPoint>(
 * @param origin
 * @returns
 */
-export const lineSegmentRotate = <Point extends LocalPoint | GlobalPoint>(
+export const lineSegmentRotate = <Point extends GenericPoint>(
  l: LineSegment<Point>,
  angle: Radians,
  origin?: Point,
@ -66,7 +66,7 @@ export const lineSegmentRotate = <Point extends LocalPoint | GlobalPoint>(
 * Calculates the point two line segments with a definite start and end point
 * intersect at.
 */
-export const segmentsIntersectAt = <Point extends GlobalPoint | LocalPoint>(
+export const segmentsIntersectAt = <Point extends GenericPoint>(
  a: Readonly<LineSegment<Point>>,
  b: Readonly<LineSegment<Point>>,
 ): Point | null => {
@ -99,7 +99,7 @@ export const segmentsIntersectAt = <Point extends GlobalPoint | LocalPoint>(
  return null;
 };

-export const pointOnLineSegment = <Point extends LocalPoint | GlobalPoint>(
+export const pointOnLineSegment = <Point extends GenericPoint>(
  point: Point,
  line: LineSegment<Point>,
  threshold = PRECISION,
@ -113,7 +113,7 @@ export const pointOnLineSegment = <Point extends LocalPoint | GlobalPoint>(
  return distance < threshold;
 };

-export const distanceToLineSegment = <Point extends LocalPoint | GlobalPoint>(
+export const distanceToLineSegment = <Point extends GenericPoint>(
  point: Point,
  line: LineSegment<Point>,
 ) => {
@ -158,9 +158,7 @@ export const distanceToLineSegment = <Point extends LocalPoint | GlobalPoint>(
 * @param s
 * @returns
 */
-export function lineSegmentIntersectionPoints<
-  Point extends GlobalPoint | LocalPoint,
->(
+export function lineSegmentIntersectionPoints<Point extends GenericPoint>(
  l: LineSegment<Point>,
  s: LineSegment<Point>,
  threshold?: number,
--- a/packages/math/src/triangle.ts
+++ b/packages/math/src/triangle.ts
@ -1,4 +1,4 @@
-import type { GlobalPoint, LocalPoint, Triangle } from "./types";
+import type { GenericPoint, Triangle } from "./types";

 // Types

@ -11,7 +11,7 @@ import type { GlobalPoint, LocalPoint, Triangle } from "./types";
 * @param p The point to test whether is in the triangle
 * @returns TRUE if the point is inside of the triangle
 */
-export function triangleIncludesPoint<P extends GlobalPoint | LocalPoint>(
+export function triangleIncludesPoint<P extends GenericPoint>(
  [a, b, c]: Triangle<P>,
  p: P,
 ): boolean {
--- a/packages/math/src/vector.ts
+++ b/packages/math/src/vector.ts
@ -1,4 +1,4 @@
-import type { GlobalPoint, LocalPoint, Vector } from "./types";
+import type { GenericPoint, Vector } from "./types";

 /**
 * Create a vector from the x and y coordiante elements.
@ -23,7 +23,7 @@ export function vector(
 * @param origin The origin point in a given coordiante system
 * @returns The created vector from the point and the origin
 */
-export function vectorFromPoint<Point extends GlobalPoint | LocalPoint>(
+export function vectorFromPoint<Point extends GenericPoint>(
  p: Point,
  origin: Point = [0, 0] as Point,
 ): Vector {
--- a/packages/utils/src/bbox.ts
+++ b/packages/utils/src/bbox.ts
@ -1,17 +1,14 @@
 import {
  vectorCross,
  vectorFromPoint,
-  type GlobalPoint,
-  type LocalPoint,
+  type GenericPoint,
 } from "@excalidraw/math";

 import type { Bounds } from "@excalidraw/element/bounds";

-export type LineSegment<P extends LocalPoint | GlobalPoint> = [P, P];
+export type LineSegment<P extends GenericPoint> = [P, P];

-export function getBBox<P extends LocalPoint | GlobalPoint>(
-  line: LineSegment<P>,
-): Bounds {
+export function getBBox<P extends GenericPoint>(line: LineSegment<P>): Bounds {
  return [
    Math.min(line[0][0], line[1][0]),
    Math.min(line[0][1], line[1][1]),
@ -26,10 +23,7 @@ export function doBBoxesIntersect(a: Bounds, b: Bounds) {

 const EPSILON = 0.000001;

-export function isPointOnLine<P extends GlobalPoint | LocalPoint>(
-  l: LineSegment<P>,
-  p: P,
-) {
+export function isPointOnLine<P extends GenericPoint>(l: LineSegment<P>, p: P) {
  const p1 = vectorFromPoint(l[1], l[0]);
  const p2 = vectorFromPoint(p, l[0]);

@ -38,7 +32,7 @@ export function isPointOnLine<P extends GlobalPoint | LocalPoint>(
  return Math.abs(r) < EPSILON;
 }

-export function isPointRightOfLine<P extends GlobalPoint | LocalPoint>(
+export function isPointRightOfLine<P extends GenericPoint>(
  l: LineSegment<P>,
  p: P,
 ) {
@ -48,9 +42,10 @@ export function isPointRightOfLine<P extends GlobalPoint | LocalPoint>(
  return vectorCross(p1, p2) < 0;
 }

-export function isLineSegmentTouchingOrCrossingLine<
-  P extends GlobalPoint | LocalPoint,
->(a: LineSegment<P>, b: LineSegment<P>) {
+export function isLineSegmentTouchingOrCrossingLine<P extends GenericPoint>(
+  a: LineSegment<P>,
+  b: LineSegment<P>,
+) {
  return (
    isPointOnLine(a, b[0]) ||
    isPointOnLine(a, b[1]) ||
@ -61,7 +56,7 @@ export function isLineSegmentTouchingOrCrossingLine<
 }

 // https://martin-thoma.com/how-to-check-if-two-line-segments-intersect/
-export function doLineSegmentsIntersect<P extends GlobalPoint | LocalPoint>(
+export function doLineSegmentsIntersect<P extends GenericPoint>(
  a: LineSegment<P>,
  b: LineSegment<P>,
 ) {
--- a/packages/utils/src/collision.ts
+++ b/packages/utils/src/collision.ts
@ -5,19 +5,17 @@ import {
  pointOnLineSegment,
  pointOnPolygon,
  polygonFromPoints,
-  type GlobalPoint,
-  type LocalPoint,
  type Polygon,
 } from "@excalidraw/math";

-import type { Curve } from "@excalidraw/math";
+import type { Curve, GenericPoint } from "@excalidraw/math";

 import { pointInEllipse, pointOnEllipse } from "./shape";

 import type { Polycurve, Polyline, GeometricShape } from "./shape";

 // check if the given point is considered on the given shape's border
-export const isPointOnShape = <Point extends GlobalPoint | LocalPoint>(
+export const isPointOnShape = <Point extends GenericPoint>(
  point: Point,
  shape: GeometricShape<Point>,
  tolerance = 0,
@ -43,7 +41,7 @@ export const isPointOnShape = <Point extends GlobalPoint | LocalPoint>(
 };

 // check if the given point is considered inside the element's border
-export const isPointInShape = <Point extends GlobalPoint | LocalPoint>(
+export const isPointInShape = <Point extends GenericPoint>(
  point: Point,
  shape: GeometricShape<Point>,
 ) => {
@ -69,14 +67,14 @@ export const isPointInShape = <Point extends GlobalPoint | LocalPoint>(
 };

 // check if the given element is in the given bounds
-export const isPointInBounds = <Point extends GlobalPoint | LocalPoint>(
+export const isPointInBounds = <Point extends GenericPoint>(
  point: Point,
  bounds: Polygon<Point>,
 ) => {
  return polygonIncludesPoint(point, bounds);
 };

-const pointOnPolycurve = <Point extends LocalPoint | GlobalPoint>(
+const pointOnPolycurve = <Point extends GenericPoint>(
  point: Point,
  polycurve: Polycurve<Point>,
  tolerance: number,
@ -84,7 +82,7 @@ const pointOnPolycurve = <Point extends LocalPoint | GlobalPoint>(
  return polycurve.some((curve) => pointOnCurve(point, curve, tolerance));
 };

-const cubicBezierEquation = <Point extends LocalPoint | GlobalPoint>(
+const cubicBezierEquation = <Point extends GenericPoint>(
  curve: Curve<Point>,
 ) => {
  const [p0, p1, p2, p3] = curve;
@ -96,7 +94,7 @@ const cubicBezierEquation = <Point extends LocalPoint | GlobalPoint>(
    p0[idx] * Math.pow(t, 3);
 };

-const polyLineFromCurve = <Point extends LocalPoint | GlobalPoint>(
+const polyLineFromCurve = <Point extends GenericPoint>(
  curve: Curve<Point>,
  segments = 10,
 ): Polyline<Point> => {
@ -118,7 +116,7 @@ const polyLineFromCurve = <Point extends LocalPoint | GlobalPoint>(
  return lineSegments;
 };

-export const pointOnCurve = <Point extends LocalPoint | GlobalPoint>(
+export const pointOnCurve = <Point extends GenericPoint>(
  point: Point,
  curve: Curve<Point>,
  threshold: number,
@ -126,7 +124,7 @@ export const pointOnCurve = <Point extends LocalPoint | GlobalPoint>(
  return pointOnPolyline(point, polyLineFromCurve(curve), threshold);
 };

-export const pointOnPolyline = <Point extends LocalPoint | GlobalPoint>(
+export const pointOnPolyline = <Point extends GenericPoint>(
  point: Point,
  polyline: Polyline<Point>,
  threshold = 10e-5,
--- a/packages/utils/src/shape.ts
+++ b/packages/utils/src/shape.ts
@ -30,8 +30,6 @@ import {
  vectorAdd,
  vectorFromPoint,
  vectorScale,
-  type GlobalPoint,
-  type LocalPoint,
 } from "@excalidraw/math";

 import { getElementAbsoluteCoords } from "@excalidraw/element/bounds";
@ -52,31 +50,36 @@ import type {
  ExcalidrawSelectionElement,
  ExcalidrawTextElement,
 } from "@excalidraw/element/types";
-import type { Curve, LineSegment, Polygon, Radians } from "@excalidraw/math";
+import type {
+  Curve,
+  GenericPoint,
+  LineSegment,
+  Polygon,
+  Radians,
+} from "@excalidraw/math";

 import type { Drawable, Op } from "roughjs/bin/core";

 // a polyline (made up term here) is a line consisting of other line segments
 // this corresponds to a straight line element in the editor but it could also
 // be used to model other elements
-export type Polyline<Point extends GlobalPoint | LocalPoint> =
-  LineSegment<Point>[];
+export type Polyline<Point extends GenericPoint> = LineSegment<Point>[];

 // a polycurve is a curve consisting of ther curves, this corresponds to a complex
 // curve on the canvas
-export type Polycurve<Point extends GlobalPoint | LocalPoint> = Curve<Point>[];
+export type Polycurve<Point extends GenericPoint> = Curve<Point>[];

 // an ellipse is specified by its center, angle, and its major and minor axes
 // but for the sake of simplicity, we've used halfWidth and halfHeight instead
 // in replace of semi major and semi minor axes
-export type Ellipse<Point extends GlobalPoint | LocalPoint> = {
+export type Ellipse<Point extends GenericPoint> = {
  center: Point;
  angle: Radians;
  halfWidth: number;
  halfHeight: number;
 };

-export type GeometricShape<Point extends GlobalPoint | LocalPoint> =
+export type GeometricShape<Point extends GenericPoint> =
  | {
      type: "line";
      data: LineSegment<Point>;
@ -113,7 +116,7 @@ type RectangularElement =
  | ExcalidrawSelectionElement;

 // polygon
-export const getPolygonShape = <Point extends GlobalPoint | LocalPoint>(
+export const getPolygonShape = <Point extends GenericPoint>(
  element: RectangularElement,
 ): GeometricShape<Point> => {
  const { angle, width, height, x, y } = element;
@ -148,7 +151,7 @@ export const getPolygonShape = <Point extends GlobalPoint | LocalPoint>(
 };

 // return the selection box for an element, possibly rotated as well
-export const getSelectionBoxShape = <Point extends GlobalPoint | LocalPoint>(
+export const getSelectionBoxShape = <Point extends GenericPoint>(
  element: ExcalidrawElement,
  elementsMap: ElementsMap,
  padding = 10,
@ -178,7 +181,7 @@ export const getSelectionBoxShape = <Point extends GlobalPoint | LocalPoint>(
 };

 // ellipse
-export const getEllipseShape = <Point extends GlobalPoint | LocalPoint>(
+export const getEllipseShape = <Point extends GenericPoint>(
  element: ExcalidrawEllipseElement,
 ): GeometricShape<Point> => {
  const { width, height, angle, x, y } = element;
@ -209,7 +212,7 @@ export const getCurvePathOps = (shape: Drawable): Op[] => {
 };

 // linear
-export const getCurveShape = <Point extends GlobalPoint | LocalPoint>(
+export const getCurveShape = <Point extends GenericPoint>(
  roughShape: Drawable,
  startingPoint: Point = pointFrom(0, 0),
  angleInRadian: Radians,
@ -247,7 +250,7 @@ export const getCurveShape = <Point extends GlobalPoint | LocalPoint>(
  };
 };

-const polylineFromPoints = <Point extends GlobalPoint | LocalPoint>(
+const polylineFromPoints = <Point extends GenericPoint>(
  points: Point[],
 ): Polyline<Point> => {
  let previousPoint: Point = points[0];
@ -262,7 +265,7 @@ const polylineFromPoints = <Point extends GlobalPoint | LocalPoint>(
  return polyline;
 };

-export const getFreedrawShape = <Point extends GlobalPoint | LocalPoint>(
+export const getFreedrawShape = <Point extends GenericPoint>(
  element: ExcalidrawFreeDrawElement,
  center: Point,
  isClosed: boolean = false,
@ -293,7 +296,7 @@ export const getFreedrawShape = <Point extends GlobalPoint | LocalPoint>(
  ) as GeometricShape<Point>;
 };

-export const getClosedCurveShape = <Point extends GlobalPoint | LocalPoint>(
+export const getClosedCurveShape = <Point extends GenericPoint>(
  element: ExcalidrawLinearElement,
  roughShape: Drawable,
  startingPoint: Point = pointFrom<Point>(0, 0),
@ -359,9 +362,7 @@ export const getClosedCurveShape = <Point extends GlobalPoint | LocalPoint>(
 * @returns An array of intersections
 */
 // TODO: Replace with final rounded rectangle code
-export const segmentIntersectRectangleElement = <
-  Point extends LocalPoint | GlobalPoint,
->(
+export const segmentIntersectRectangleElement = <Point extends GenericPoint>(
  element: ExcalidrawBindableElement,
  segment: LineSegment<Point>,
  gap: number = 0,
@ -399,7 +400,7 @@ export const segmentIntersectRectangleElement = <
    .filter((i): i is Point => !!i);
 };

-const distanceToEllipse = <Point extends LocalPoint | GlobalPoint>(
+const distanceToEllipse = <Point extends GenericPoint>(
  p: Point,
  ellipse: Ellipse<Point>,
 ) => {
@ -456,7 +457,7 @@ const distanceToEllipse = <Point extends LocalPoint | GlobalPoint>(
  );
 };

-export const pointOnEllipse = <Point extends LocalPoint | GlobalPoint>(
+export const pointOnEllipse = <Point extends GenericPoint>(
  point: Point,
  ellipse: Ellipse<Point>,
  threshold = PRECISION,
@ -464,7 +465,7 @@ export const pointOnEllipse = <Point extends LocalPoint | GlobalPoint>(
  return distanceToEllipse(point, ellipse) <= threshold;
 };

-export const pointInEllipse = <Point extends LocalPoint | GlobalPoint>(
+export const pointInEllipse = <Point extends GenericPoint>(
  p: Point,
  ellipse: Ellipse<Point>,
 ) => {
@ -486,7 +487,7 @@ export const pointInEllipse = <Point extends LocalPoint | GlobalPoint>(
  );
 };

-export const ellipseAxes = <Point extends LocalPoint | GlobalPoint>(
+export const ellipseAxes = <Point extends GenericPoint>(
  ellipse: Ellipse<Point>,
 ) => {
  const widthGreaterThanHeight = ellipse.halfWidth > ellipse.halfHeight;
@ -504,7 +505,7 @@ export const ellipseAxes = <Point extends LocalPoint | GlobalPoint>(
  };
 };

-export const ellipseFocusToCenter = <Point extends LocalPoint | GlobalPoint>(
+export const ellipseFocusToCenter = <Point extends GenericPoint>(
  ellipse: Ellipse<Point>,
 ) => {
  const { majorAxis, minorAxis } = ellipseAxes(ellipse);
@ -512,7 +513,7 @@ export const ellipseFocusToCenter = <Point extends LocalPoint | GlobalPoint>(
  return Math.sqrt(majorAxis ** 2 - minorAxis ** 2);
 };

-export const ellipseExtremes = <Point extends LocalPoint | GlobalPoint>(
+export const ellipseExtremes = <Point extends GenericPoint>(
  ellipse: Ellipse<Point>,
 ) => {
  const { center, angle } = ellipse;