@zsviczian/excalidraw 0.17.6-27 → 0.17.6-29

package/types/math/point.d.ts

@@ -1,150 +1,150 @@
-import type { LocalPoint, GlobalPoint, Radians, Degrees, Vector } from "./types";
-/**
- * Create a properly typed Point instance from the X and Y coordinates.
- *
- * @param x The X coordinate
- * @param y The Y coordinate
- * @returns The branded and created point
- */
-export declare function pointFrom<Point extends GlobalPoint | LocalPoint>(x: number, y: number): Point;
-/**
- * Converts and remaps an array containing a pair of numbers to Point.
- *
- * @param numberArray The number array to check and to convert to Point
- * @returns The point instance
- */
-export declare function pointFromArray<Point extends GlobalPoint | LocalPoint>(numberArray: number[]): Point | undefined;
-/**
- * Converts and remaps a pair of numbers to Point.
- *
- * @param pair A number pair to convert to Point
- * @returns The point instance
- */
-export declare function pointFromPair<Point extends GlobalPoint | LocalPoint>(pair: [number, number]): Point;
-/**
- * Convert a vector to a point.
- *
- * @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;
-/**
- * Checks if the provided value has the shape of a Point.
- *
- * @param p The value to attempt verification on
- * @returns TRUE if the provided value has the shape of a local or global point
- */
-export declare function isPoint(p: unknown): p is LocalPoint | GlobalPoint;
-/**
- * Compare two points coordinate-by-coordinate and if
- * they are closer than INVERSE_PRECISION it returns TRUE.
- *
- * @param a Point The first point to compare
- * @param b Point The second point to compare
- * @returns TRUE if the points are sufficiently close to each other
- */
-export declare function pointsEqual<Point extends GlobalPoint | LocalPoint>(a: Point, b: Point): boolean;
-/**
- * Roate a point by [angle] radians.
- *
- * @param point The point to rotate
- * @param center The point to rotate around, the center point
- * @param angle The radians to rotate the point by
- * @returns The rotated point
- */
-export declare function pointRotateRads<Point extends GlobalPoint | LocalPoint>([x, y]: Point, [cx, cy]: Point, angle: Radians): Point;
-/**
- * Roate a point by [angle] degree.
- *
- * @param point The point to rotate
- * @param center The point to rotate around, the center point
- * @param angle The degree to rotate the point by
- * @returns The rotated point
- */
-export declare function pointRotateDegs<Point extends GlobalPoint | LocalPoint>(point: Point, center: Point, angle: Degrees): Point;
-/**
- * Translate a point by a vector.
- *
- * WARNING: This is not for translating Excalidraw element points!
- *          You need to account for rotation on base coordinates
- *          on your own.
- *          CONSIDER USING AN APPROPRIATE ELEMENT-AWARE TRANSLATE!
- *
- * @param p The point to apply the translation on
- * @param v The vector to translate by
- * @returns
- */
-export declare function pointTranslate<From extends GlobalPoint | LocalPoint, To extends GlobalPoint | LocalPoint>(p: From, v?: Vector): To;
-/**
- * Find the center point at equal distance from both points.
- *
- * @param a One of the points to create the middle point for
- * @param b The other point to create the middle point for
- * @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.
- *
- * @param a First point
- * @param b Second point
- * @returns The euclidean distance between the two points.
- */
-export declare function pointDistance<P extends LocalPoint | GlobalPoint>(a: P, b: P): number;
-/**
- * Calculate the squared distance between two points.
- *
- * Note: Use this if you only compare distances, it saves a square root.
- *
- * @param a First point
- * @param b Second point
- * @returns The euclidean distance between the two points.
- */
-export declare function pointDistanceSq<P extends LocalPoint | GlobalPoint>(a: P, b: P): number;
-/**
- * Scale a point from a given origin by the multiplier.
- *
- * @param p The point to scale
- * @param mid The origin to scale from
- * @param multiplier The scaling factor
- * @returns
- */
-export declare const pointScaleFromOrigin: <P extends GlobalPoint | LocalPoint>(p: P, mid: P, multiplier: number) => GlobalPoint | LocalPoint;
-/**
- * Returns whether `q` lies inside the segment/rectangle defined by `p` and `r`.
- * This is an approximation to "does `q` lie on a segment `pr`" check.
- *
- * @param p The first point to compare against
- * @param q The actual point this function checks whether is in between
- * @param r The other point to compare against
- * @returns TRUE if q is indeed between p and r
- */
-export declare const isPointWithinBounds: <P extends GlobalPoint | LocalPoint>(p: P, q: P, r: P) => boolean;
+import type { LocalPoint, GlobalPoint, Radians, Degrees, Vector } from "./types";
+/**
+ * Create a properly typed Point instance from the X and Y coordinates.
+ *
+ * @param x The X coordinate
+ * @param y The Y coordinate
+ * @returns The branded and created point
+ */
+export declare function pointFrom<Point extends GlobalPoint | LocalPoint>(x: number, y: number): Point;
+/**
+ * Converts and remaps an array containing a pair of numbers to Point.
+ *
+ * @param numberArray The number array to check and to convert to Point
+ * @returns The point instance
+ */
+export declare function pointFromArray<Point extends GlobalPoint | LocalPoint>(numberArray: number[]): Point | undefined;
+/**
+ * Converts and remaps a pair of numbers to Point.
+ *
+ * @param pair A number pair to convert to Point
+ * @returns The point instance
+ */
+export declare function pointFromPair<Point extends GlobalPoint | LocalPoint>(pair: [number, number]): Point;
+/**
+ * Convert a vector to a point.
+ *
+ * @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;
+/**
+ * Checks if the provided value has the shape of a Point.
+ *
+ * @param p The value to attempt verification on
+ * @returns TRUE if the provided value has the shape of a local or global point
+ */
+export declare function isPoint(p: unknown): p is LocalPoint | GlobalPoint;
+/**
+ * Compare two points coordinate-by-coordinate and if
+ * they are closer than INVERSE_PRECISION it returns TRUE.
+ *
+ * @param a Point The first point to compare
+ * @param b Point The second point to compare
+ * @returns TRUE if the points are sufficiently close to each other
+ */
+export declare function pointsEqual<Point extends GlobalPoint | LocalPoint>(a: Point, b: Point): boolean;
+/**
+ * Roate a point by [angle] radians.
+ *
+ * @param point The point to rotate
+ * @param center The point to rotate around, the center point
+ * @param angle The radians to rotate the point by
+ * @returns The rotated point
+ */
+export declare function pointRotateRads<Point extends GlobalPoint | LocalPoint>([x, y]: Point, [cx, cy]: Point, angle: Radians): Point;
+/**
+ * Roate a point by [angle] degree.
+ *
+ * @param point The point to rotate
+ * @param center The point to rotate around, the center point
+ * @param angle The degree to rotate the point by
+ * @returns The rotated point
+ */
+export declare function pointRotateDegs<Point extends GlobalPoint | LocalPoint>(point: Point, center: Point, angle: Degrees): Point;
+/**
+ * Translate a point by a vector.
+ *
+ * WARNING: This is not for translating Excalidraw element points!
+ *          You need to account for rotation on base coordinates
+ *          on your own.
+ *          CONSIDER USING AN APPROPRIATE ELEMENT-AWARE TRANSLATE!
+ *
+ * @param p The point to apply the translation on
+ * @param v The vector to translate by
+ * @returns
+ */
+export declare function pointTranslate<From extends GlobalPoint | LocalPoint, To extends GlobalPoint | LocalPoint>(p: From, v?: Vector): To;
+/**
+ * Find the center point at equal distance from both points.
+ *
+ * @param a One of the points to create the middle point for
+ * @param b The other point to create the middle point for
+ * @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.
+ *
+ * @param a First point
+ * @param b Second point
+ * @returns The euclidean distance between the two points.
+ */
+export declare function pointDistance<P extends LocalPoint | GlobalPoint>(a: P, b: P): number;
+/**
+ * Calculate the squared distance between two points.
+ *
+ * Note: Use this if you only compare distances, it saves a square root.
+ *
+ * @param a First point
+ * @param b Second point
+ * @returns The euclidean distance between the two points.
+ */
+export declare function pointDistanceSq<P extends LocalPoint | GlobalPoint>(a: P, b: P): number;
+/**
+ * Scale a point from a given origin by the multiplier.
+ *
+ * @param p The point to scale
+ * @param mid The origin to scale from
+ * @param multiplier The scaling factor
+ * @returns
+ */
+export declare const pointScaleFromOrigin: <P extends GlobalPoint | LocalPoint>(p: P, mid: P, multiplier: number) => GlobalPoint | LocalPoint;
+/**
+ * Returns whether `q` lies inside the segment/rectangle defined by `p` and `r`.
+ * This is an approximation to "does `q` lie on a segment `pr`" check.
+ *
+ * @param p The first point to compare against
+ * @param q The actual point this function checks whether is in between
+ * @param r The other point to compare against
+ * @returns TRUE if q is indeed between p and r
+ */
+export declare const isPointWithinBounds: <P extends GlobalPoint | LocalPoint>(p: P, q: P, r: P) => boolean;

package/types/math/polygon.d.ts

@@ -1,5 +1,5 @@
-import type { GlobalPoint, LocalPoint, Polygon } from "./types";
-export declare function polygon<Point extends GlobalPoint | LocalPoint>(...points: Point[]): Polygon<Point>;
-export declare function polygonFromPoints<Point extends GlobalPoint | LocalPoint>(points: Point[]): Polygon<Point>;
-export declare const polygonIncludesPoint: <Point extends GlobalPoint | LocalPoint>(point: Point, polygon: Polygon<Point>) => boolean;
-export declare const pointOnPolygon: <Point extends GlobalPoint | LocalPoint>(p: Point, poly: Polygon<Point>, threshold?: number) => boolean;
+import type { GlobalPoint, LocalPoint, Polygon } from "./types";
+export declare function polygon<Point extends GlobalPoint | LocalPoint>(...points: Point[]): Polygon<Point>;
+export declare function polygonFromPoints<Point extends GlobalPoint | LocalPoint>(points: Point[]): Polygon<Point>;
+export declare const polygonIncludesPoint: <Point extends GlobalPoint | LocalPoint>(point: Point, polygon: Polygon<Point>) => boolean;
+export declare const pointOnPolygon: <Point extends GlobalPoint | LocalPoint>(p: Point, poly: Polygon<Point>, threshold?: number) => boolean;

package/types/math/range.d.ts

@@ -1,44 +1,44 @@
-import type { InclusiveRange } from "./types";
-/**
- * Create an inclusive range from the two numbers provided.
- *
- * @param start Start of the range
- * @param end End of the range
- * @returns
- */
-export declare function rangeInclusive(start: number, end: number): InclusiveRange;
-/**
- * Turn a number pair into an inclusive range.
- *
- * @param pair The number pair to convert to an inclusive range
- * @returns The new inclusive range
- */
-export declare function rangeInclusiveFromPair(pair: [start: number, end: number]): [number, number] & {
-    _brand: "excalimath_degree";
-};
-/**
- * Given two ranges, return if the two ranges overlap with each other e.g.
- * [1, 3] overlaps with [2, 4] while [1, 3] does not overlap with [4, 5].
- *
- * @param param0 One of the ranges to compare
- * @param param1 The other range to compare against
- * @returns TRUE if the ranges overlap
- */
-export declare const rangesOverlap: ([a0, a1]: InclusiveRange, [b0, b1]: InclusiveRange) => boolean;
-/**
- * Given two ranges,return ther intersection of the two ranges if any e.g. the
- * intersection of [1, 3] and [2, 4] is [2, 3].
- *
- * @param param0 The first range to compare
- * @param param1 The second range to compare
- * @returns The inclusive range intersection or NULL if no intersection
- */
-export declare const rangeIntersection: ([a0, a1]: InclusiveRange, [b0, b1]: InclusiveRange) => InclusiveRange | null;
-/**
- * Determine if a value is inside a range.
- *
- * @param value The value to check
- * @param range The range
- * @returns
- */
-export declare const rangeIncludesValue: (value: number, [min, max]: InclusiveRange) => boolean;
+import type { InclusiveRange } from "./types";
+/**
+ * Create an inclusive range from the two numbers provided.
+ *
+ * @param start Start of the range
+ * @param end End of the range
+ * @returns
+ */
+export declare function rangeInclusive(start: number, end: number): InclusiveRange;
+/**
+ * Turn a number pair into an inclusive range.
+ *
+ * @param pair The number pair to convert to an inclusive range
+ * @returns The new inclusive range
+ */
+export declare function rangeInclusiveFromPair(pair: [start: number, end: number]): [number, number] & {
+    _brand: "excalimath_degree";
+};
+/**
+ * Given two ranges, return if the two ranges overlap with each other e.g.
+ * [1, 3] overlaps with [2, 4] while [1, 3] does not overlap with [4, 5].
+ *
+ * @param param0 One of the ranges to compare
+ * @param param1 The other range to compare against
+ * @returns TRUE if the ranges overlap
+ */
+export declare const rangesOverlap: ([a0, a1]: InclusiveRange, [b0, b1]: InclusiveRange) => boolean;
+/**
+ * Given two ranges,return ther intersection of the two ranges if any e.g. the
+ * intersection of [1, 3] and [2, 4] is [2, 3].
+ *
+ * @param param0 The first range to compare
+ * @param param1 The second range to compare
+ * @returns The inclusive range intersection or NULL if no intersection
+ */
+export declare const rangeIntersection: ([a0, a1]: InclusiveRange, [b0, b1]: InclusiveRange) => InclusiveRange | null;
+/**
+ * Determine if a value is inside a range.
+ *
+ * @param value The value to check
+ * @param range The range
+ * @returns
+ */
+export declare const rangeIncludesValue: (value: number, [min, max]: InclusiveRange) => boolean;

package/types/math/segment.d.ts

@@ -1,32 +1,32 @@
-import type { GlobalPoint, LineSegment, LocalPoint, Radians } from "./types";
-/**
- * Create a line segment from two points.
- *
- * @param points The two points delimiting the line segment on each end
- * @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
- * @returns
- */
-export declare const isLineSegment: <Point extends GlobalPoint | LocalPoint>(segment: unknown) => segment is LineSegment<Point>;
-/**
- * Return the coordinates resulting from rotating the given line about an origin by an angle in radians
- * 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 lineSegmentRotate: <Point extends GlobalPoint | LocalPoint>(l: LineSegment<Point>, angle: Radians, origin?: Point | undefined) => LineSegment<Point>;
-/**
- * Calculates the point two line segments with a definite start and end point
- * intersect at.
- */
-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;
+import type { GlobalPoint, LineSegment, LocalPoint, Radians } from "./types";
+/**
+ * Create a line segment from two points.
+ *
+ * @param points The two points delimiting the line segment on each end
+ * @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
+ * @returns
+ */
+export declare const isLineSegment: <Point extends GlobalPoint | LocalPoint>(segment: unknown) => segment is LineSegment<Point>;
+/**
+ * Return the coordinates resulting from rotating the given line about an origin by an angle in radians
+ * 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 lineSegmentRotate: <Point extends GlobalPoint | LocalPoint>(l: LineSegment<Point>, angle: Radians, origin?: Point | undefined) => LineSegment<Point>;
+/**
+ * Calculates the point two line segments with a definite start and end point
+ * intersect at.
+ */
+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;

package/types/math/triangle.d.ts

@@ -1,11 +1,11 @@
-import type { GlobalPoint, LocalPoint, Triangle } from "./types";
-/**
- * Tests if a point lies inside a triangle. This function
- * will return FALSE if the point lies exactly on the sides
- * of the triangle.
- *
- * @param triangle The triangle to test the point for
- * @param p The point to test whether is in the triangle
- * @returns TRUE if the point is inside of the triangle
- */
-export declare function triangleIncludesPoint<P extends GlobalPoint | LocalPoint>([a, b, c]: Triangle<P>, p: P): boolean;
+import type { GlobalPoint, LocalPoint, Triangle } from "./types";
+/**
+ * Tests if a point lies inside a triangle. This function
+ * will return FALSE if the point lies exactly on the sides
+ * of the triangle.
+ *
+ * @param triangle The triangle to test the point for
+ * @param p The point to test whether is in the triangle
+ * @returns TRUE if the point is inside of the triangle
+ */
+export declare function triangleIncludesPoint<P extends GlobalPoint | LocalPoint>([a, b, c]: Triangle<P>, p: P): boolean;