@dwelle/excalidraw 0.6.0-rc.1 → 0.6.0-rc.2

package/dist/types/math/curve.d.ts

@@ -1,4 +1,4 @@
-import type { Curve, GlobalPoint, LocalPoint, Radians } from "./types";
+import type { Curve, GlobalPoint, LineSegment, LocalPoint } from "./types";
 /**
  *
  * @param a
@@ -8,25 +8,33 @@ import type { Curve, GlobalPoint, LocalPoint, Radians } from "./types";
  * @returns
  */
 export declare function curve<Point extends GlobalPoint | LocalPoint>(a: Point, b: Point, c: Point, d: Point): Curve<Point>;
-export declare const curveRotate: <Point extends GlobalPoint | LocalPoint>(curve: Curve<Point>, angle: Radians, origin: Point) => Point[];
 /**
- *
- * @param pointsIn
- * @param curveTightness
- * @returns
+ * Computes the intersection between a cubic spline and a line segment.
  */
-export declare function curveToBezier<Point extends LocalPoint | GlobalPoint>(pointsIn: readonly Point[], curveTightness?: number): Point[];
+export declare function curveIntersectLineSegment<Point extends GlobalPoint | LocalPoint>(c: Curve<Point>, l: LineSegment<Point>): Point[];
 /**
+ * Finds the closest point on the Bezier curve from another point
  *
- * @param t
- * @param controlPoints
+ * @param x
+ * @param y
+ * @param P0
+ * @param P1
+ * @param P2
+ * @param P3
+ * @param tolerance
+ * @param maxLevel
  * @returns
  */
-export declare const cubicBezierPoint: <Point extends GlobalPoint | LocalPoint>(t: number, controlPoints: Curve<Point>) => Point;
+export declare function curveClosestPoint<Point extends GlobalPoint | LocalPoint>(c: Curve<Point>, p: Point, tolerance?: number): Point | null;
 /**
+ * Determines the distance between a point and the closest point on the
+ * Bezier curve.
  *
- * @param point
- * @param controlPoints
- * @returns
+ * @param c The curve to test
+ * @param p The point to measure from
+ */
+export declare function curvePointDistance<Point extends GlobalPoint | LocalPoint>(c: Curve<Point>, p: Point): number;
+/**
+ * Determines if the parameter is a Curve
  */
-export declare const cubicBezierDistance: <Point extends GlobalPoint | LocalPoint>(point: Point, controlPoints: Curve<Point>) => number;
+export declare function isCurve<P extends GlobalPoint | LocalPoint>(v: unknown): v is Curve<P>;

package/dist/types/math/ellipse.d.ts

@@ -0,0 +1,44 @@
+import type { Ellipse, GlobalPoint, Line, LineSegment, LocalPoint } from "./types";
+/**
+ * Construct an Ellipse object from the parameters
+ *
+ * @param center The center of the ellipse
+ * @param angle The slanting of the ellipse in radians
+ * @param halfWidth Half of the width of a non-slanted version of the ellipse
+ * @param halfHeight Half of the height of a non-slanted version of the ellipse
+ * @returns The constructed Ellipse object
+ */
+export declare function ellipse<Point extends GlobalPoint | LocalPoint>(center: Point, halfWidth: number, halfHeight: number): Ellipse<Point>;
+/**
+ * Determines if a point is inside or on the ellipse outline
+ *
+ * @param p The point to test
+ * @param ellipse The ellipse to compare against
+ * @returns TRUE if the point is inside or on the outline of the ellipse
+ */
+export declare const ellipseIncludesPoint: <Point extends GlobalPoint | LocalPoint>(p: Point, ellipse: Ellipse<Point>) => boolean;
+/**
+ * Tests whether a point lies on the outline of the ellipse within a given
+ * tolerance
+ *
+ * @param point The point to test
+ * @param ellipse The ellipse to compare against
+ * @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 declare const ellipseTouchesPoint: <Point extends GlobalPoint | LocalPoint>(point: Point, ellipse: Ellipse<Point>, threshold?: number) => boolean;
+/**
+ * Determine the shortest euclidean distance from a point to the
+ * outline of the ellipse
+ *
+ * @param p The point to consider
+ * @param ellipse The ellipse to calculate the distance to
+ * @returns The eucledian distance
+ */
+export declare const ellipseDistanceFromPoint: <Point extends GlobalPoint | LocalPoint>(p: Point, ellipse: Ellipse<Point>) => number;
+/**
+ * Calculate a maximum of two intercept points for a line going throug an
+ * ellipse.
+ */
+export declare function ellipseSegmentInterceptPoints<Point extends GlobalPoint | LocalPoint>(e: Readonly<Ellipse<Point>>, s: Readonly<LineSegment<Point>>): Point[];
+export declare function ellipseLineIntersectionPoints<Point extends GlobalPoint | LocalPoint>({ center, halfWidth, halfHeight }: Ellipse<Point>, [g, h]: Line<Point>): Point[];

package/dist/types/math/index.d.ts

@@ -1,10 +1,10 @@
-export * from "./arc";
 export * from "./angle";
 export * from "./curve";
 export * from "./line";
 export * from "./point";
 export * from "./polygon";
 export * from "./range";
+export * from "./rectangle";
 export * from "./segment";
 export * from "./triangle";
 export * from "./types";

package/dist/types/math/line.d.ts

@@ -1,4 +1,4 @@
-import type { GlobalPoint, Line, LocalPoint, Radians } from "./types";
+import type { GlobalPoint, Line, LocalPoint } from "./types";
 /**
  * Create a line from two points.
  *
@@ -6,34 +6,6 @@ import type { GlobalPoint, Line, LocalPoint, Radians } from "./types";
  * @returns The line on which the points lie
  */
 export declare function line<P extends GlobalPoint | LocalPoint>(a: P, b: P): Line<P>;
-/**
- * Convenient point creation from an array of two points.
- *
- * @param param0 The array with the two points to convert to a line
- * @returns The created line
- */
-export declare function lineFromPointPair<P extends GlobalPoint | LocalPoint>([a, b]: [
-    P,
-    P
-]): Line<P>;
-/**
- * TODO
- *
- * @param pointArray
- * @returns
- */
-export declare function lineFromPointArray<P extends GlobalPoint | LocalPoint>(pointArray: P[]): Line<P> | undefined;
-/**
- * Return the coordinates resulting from rotating the given line about an
- * origin by an angle in degrees note that when the origin is not given,
- * the midpoint of the given line is used as the origin
- *
- * @param l
- * @param angle
- * @param origin
- * @returns
- */
-export declare const lineRotate: <Point extends GlobalPoint | LocalPoint>(l: Line<Point>, angle: Radians, origin?: Point | undefined) => Line<Point>;
 /**
  * Determines the intersection point (unless the lines are parallel) of two
  * lines
@@ -42,4 +14,4 @@ export declare const lineRotate: <Point extends GlobalPoint | LocalPoint>(l: Lin
  * @param b
  * @returns
  */
-export declare const linesIntersectAt: <Point extends GlobalPoint | LocalPoint>(a: Line<Point>, b: Line<Point>) => Point | null;
+export declare function linesIntersectAt<Point extends GlobalPoint | LocalPoint>(a: Line<Point>, b: Line<Point>): Point | null;

package/dist/types/math/point.d.ts

@@ -27,17 +27,7 @@ export declare function pointFromPair<Point extends GlobalPoint | LocalPoint>(pa
  * @param v The vector to convert
  * @returns The point the vector points at with origin 0,0
  */
-export declare function pointFromVector<P extends GlobalPoint | LocalPoint>(v: Vector): P;
-/**
- * Convert the coordiante object to a point.
- *
- * @param coords The coordinate object with x and y properties
- * @returns
- */
-export declare function pointFromCoords<Point extends GlobalPoint | LocalPoint>({ x, y, }: {
-    x: number;
-    y: number;
-}): Point;
+export declare function pointFromVector<P extends GlobalPoint | LocalPoint>(v: Vector, offset?: P): P;
 /**
  * Checks if the provided value has the shape of a Point.
  *
@@ -93,24 +83,6 @@ export declare function pointTranslate<From extends GlobalPoint | LocalPoint, To
  * @returns The middle point
  */
 export declare function pointCenter<P extends LocalPoint | GlobalPoint>(a: P, b: P): P;
-/**
- * Add together two points by their coordinates like you'd apply a translation
- * to a point by a vector.
- *
- * @param a One point to act as a basis
- * @param b The other point to act like the vector to translate by
- * @returns
- */
-export declare function pointAdd<Point extends LocalPoint | GlobalPoint>(a: Point, b: Point): Point;
-/**
- * Subtract a point from another point like you'd translate a point by an
- * invese vector.
- *
- * @param a The point to translate
- * @param b The point which will act like a vector
- * @returns The resulting point
- */
-export declare function pointSubtract<Point extends LocalPoint | GlobalPoint>(a: Point, b: Point): Point;
 /**
  * Calculate the distance between two points.
  *

package/dist/types/math/rectangle.d.ts

@@ -0,0 +1,3 @@
+import type { GlobalPoint, LineSegment, LocalPoint, Rectangle } from "./types";
+export declare function rectangle<P extends GlobalPoint | LocalPoint>(topLeft: P, bottomRight: P): Rectangle<P>;
+export declare function rectangleIntersectLineSegment<Point extends LocalPoint | GlobalPoint>(r: Rectangle<Point>, l: LineSegment<Point>): Point[];

package/dist/types/math/segment.d.ts

@@ -6,7 +6,6 @@ import type { GlobalPoint, LineSegment, LocalPoint, Radians } from "./types";
  * @returns The line segment delineated by the points
  */
 export declare function lineSegment<P extends GlobalPoint | LocalPoint>(a: P, b: P): LineSegment<P>;
-export declare function lineSegmentFromPointArray<P extends GlobalPoint | LocalPoint>(pointArray: P[]): LineSegment<P> | undefined;
 /**
  *
  * @param segment
@@ -30,3 +29,11 @@ export declare const lineSegmentRotate: <Point extends GlobalPoint | LocalPoint>
 export declare const segmentsIntersectAt: <Point extends GlobalPoint | LocalPoint>(a: Readonly<LineSegment<Point>>, b: Readonly<LineSegment<Point>>) => Point | null;
 export declare const pointOnLineSegment: <Point extends GlobalPoint | LocalPoint>(point: Point, line: LineSegment<Point>, threshold?: number) => boolean;
 export declare const distanceToLineSegment: <Point extends GlobalPoint | LocalPoint>(point: Point, line: LineSegment<Point>) => number;
+/**
+ * Returns the intersection point of a segment and a line
+ *
+ * @param l
+ * @param s
+ * @returns
+ */
+export declare function lineSegmentIntersectionPoints<Point extends GlobalPoint | LocalPoint>(l: LineSegment<Point>, s: LineSegment<Point>): Point | null;

package/dist/types/math/types.d.ts

@@ -62,6 +62,12 @@ export type Triangle<P extends GlobalPoint | LocalPoint> = [
 ] & {
     _brand: "excalimath__triangle";
 };
+/**
+ * A rectangular shape represented by 4 points at its corners
+ */
+export type Rectangle<P extends GlobalPoint | LocalPoint> = [a: P, b: P] & {
+    _brand: "excalimath__rectangle";
+};
 /**
  * A polygon is a closed shape by connecting the given points
  * rectangles and diamonds are modelled by polygons
@@ -86,11 +92,14 @@ export type PolarCoords = [
     angle: number
 ];
 /**
- * Angles are in radians and centered on 0, 0. Zero radians on a 1 radius circle
- * corresponds to (1, 0) cartesian coordinates (point), i.e. to the "right".
+  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 SymmetricArc = {
-    radius: number;
-    startAngle: number;
-    endAngle: number;
+export type Ellipse<Point extends GlobalPoint | LocalPoint> = {
+    center: Point;
+    halfWidth: number;
+    halfHeight: number;
+} & {
+    _brand: "excalimath_ellipse";
 };

package/dist/types/math/vector.d.ts

@@ -86,7 +86,3 @@ export declare function vectorMagnitude(v: Vector): number;
  * @returns The new normalized vector
  */
 export declare const vectorNormalize: (v: Vector) => Vector;
-/**
- * Project the first vector onto the second vector
- */
-export declare const vectorProjection: (a: Vector, b: Vector) => Vector;

package/dist/types/utils/export.d.ts

@@ -1,5 +1,5 @@
+import type { ExportToCanvasConfig, ExportToCanvasData } from "@excalidraw/excalidraw/scene/export";
 import { MIME_TYPES } from "@excalidraw/excalidraw/constants";
-import type { ExportToCanvasConfig, ExportToCanvasData } from "../excalidraw/scene/export";
 export { MIME_TYPES };
 type ExportToBlobConfig = ExportToCanvasConfig & {
     mimeType?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dwelle/excalidraw",
-  "version": "0.6.0-rc.1",
+  "version": "0.6.0-rc.2",
   "type": "module",
   "types": "./dist/types/excalidraw/index.d.ts",
   "main": "./dist/prod/index.js",
@@ -48,8 +48,8 @@
     ]
   },
   "peerDependencies": {
-    "react": "^17.0.2 || ^18.2.0",
-    "react-dom": "^17.0.2 || ^18.2.0"
+    "react": "^17.0.2 || ^18.2.0 || ^19.0.0",
+    "react-dom": "^17.0.2 || ^18.2.0 || ^19.0.0"
   },
   "dependencies": {
     "@braintree/sanitize-url": "6.0.2",
@@ -95,8 +95,8 @@
     "@babel/preset-typescript": "7.24.1",
     "@size-limit/preset-big-lib": "9.0.0",
     "@testing-library/dom": "10.4.0",
-    "@testing-library/jest-dom": "5.16.2",
-    "@testing-library/react": "16.0.0",
+    "@testing-library/jest-dom": "6.6.3",
+    "@testing-library/react": "16.2.0",
     "@types/lodash.debounce": "4.0.8",
     "@types/pako": "2.0.3",
     "@types/pica": "5.1.3",