@zsviczian/excalidraw 0.17.1-obsidian-47 → 0.17.1-obsidian-48

package/types/math/vector.d.ts

@@ -0,0 +1,88 @@
+import type { GlobalPoint, LocalPoint, Vector } from "./types";
+/**
+ * Create a vector from the x and y coordiante elements.
+ *
+ * @param x The X aspect of the vector
+ * @param y T Y aspect of the vector
+ * @returns The constructed vector with X and Y as the coordinates
+ */
+export declare function vector(x: number, y: number, originX?: number, originY?: number): Vector;
+/**
+ * Turn a point into a vector with the origin point.
+ *
+ * @param p The point to turn into a vector
+ * @param origin The origin point in a given coordiante system
+ * @returns The created vector from the point and the origin
+ */
+export declare function vectorFromPoint<Point extends GlobalPoint | LocalPoint>(p: Point, origin?: Point): Vector;
+/**
+ * Cross product is a binary operation on two vectors in 2D space.
+ * It results in a vector that is perpendicular to both vectors.
+ *
+ * @param a One of the vectors to use for the directed area calculation
+ * @param b The other vector to use for the directed area calculation
+ * @returns The directed area value for the two vectos
+ */
+export declare function vectorCross(a: Vector, b: Vector): number;
+/**
+ * Dot product is defined as the sum of the products of the
+ * two vectors.
+ *
+ * @param a One of the vectors for which the sum of products is calculated
+ * @param b The other vector for which the sum of products is calculated
+ * @returns The sum of products of the two vectors
+ */
+export declare function vectorDot(a: Vector, b: Vector): number;
+/**
+ * Determines if the value has the shape of a Vector.
+ *
+ * @param v The value to test
+ * @returns TRUE if the value has the shape and components of a Vectors
+ */
+export declare function isVector(v: unknown): v is Vector;
+/**
+ * Add two vectors by adding their coordinates.
+ *
+ * @param a One of the vectors to add
+ * @param b The other vector to add
+ * @returns The sum vector of the two provided vectors
+ */
+export declare function vectorAdd(a: Readonly<Vector>, b: Readonly<Vector>): Vector;
+/**
+ * Add two vectors by adding their coordinates.
+ *
+ * @param start One of the vectors to add
+ * @param end The other vector to add
+ * @returns The sum vector of the two provided vectors
+ */
+export declare function vectorSubtract(start: Readonly<Vector>, end: Readonly<Vector>): Vector;
+/**
+ * Scale vector by a scalar.
+ *
+ * @param v The vector to scale
+ * @param scalar The scalar to multiply the vector components with
+ * @returns The new scaled vector
+ */
+export declare function vectorScale(v: Vector, scalar: number): Vector;
+/**
+ * Calculates the sqare magnitude of a vector. Use this if you compare
+ * magnitudes as it saves you an SQRT.
+ *
+ * @param v The vector to measure
+ * @returns The scalar squared magnitude of the vector
+ */
+export declare function vectorMagnitudeSq(v: Vector): number;
+/**
+ * Calculates the magnitude of a vector.
+ *
+ * @param v The vector to measure
+ * @returns The scalar magnitude of the vector
+ */
+export declare function vectorMagnitude(v: Vector): number;
+/**
+ * Normalize the vector (i.e. make the vector magnitue equal 1).
+ *
+ * @param v The vector to normalize
+ * @returns The new normalized vector
+ */
+export declare const vectorNormalize: (v: Vector) => Vector;

package/types/utils/bbox.d.ts

@@ -1,11 +1,9 @@
+import { type GlobalPoint, type LocalPoint } from "../math";
 import type { Bounds } from "../excalidraw/element/bounds";
-import type { Point } from "../excalidraw/types";
-export type LineSegment = [Point, Point];
-export declare function getBBox(line: LineSegment): Bounds;
-export declare function crossProduct(a: Point, b: Point): number;
+export type LineSegment<P extends LocalPoint | GlobalPoint> = [P, P];
+export declare function getBBox<P extends LocalPoint | GlobalPoint>(line: LineSegment<P>): Bounds;
 export declare function doBBoxesIntersect(a: Bounds, b: Bounds): boolean;
-export declare function translate(a: Point, b: Point): Point;
-export declare function isPointOnLine(l: LineSegment, p: Point): boolean;
-export declare function isPointRightOfLine(l: LineSegment, p: Point): boolean;
-export declare function isLineSegmentTouchingOrCrossingLine(a: LineSegment, b: LineSegment): boolean;
-export declare function doLineSegmentsIntersect(a: LineSegment, b: LineSegment): boolean;
+export declare function isPointOnLine<P extends GlobalPoint | LocalPoint>(l: LineSegment<P>, p: P): boolean;
+export declare function isPointRightOfLine<P extends GlobalPoint | LocalPoint>(l: LineSegment<P>, p: P): boolean;
+export declare function isLineSegmentTouchingOrCrossingLine<P extends GlobalPoint | LocalPoint>(a: LineSegment<P>, b: LineSegment<P>): boolean;
+export declare function doLineSegmentsIntersect<P extends GlobalPoint | LocalPoint>(a: LineSegment<P>, b: LineSegment<P>): boolean;

package/types/utils/collision.d.ts

@@ -1,4 +1,9 @@
-import type { Point, Polygon, GeometricShape } from "./geometry/shape";
-export declare const isPointOnShape: (point: Point, shape: GeometricShape, tolerance?: number) => boolean;
-export declare const isPointInShape: (point: Point, shape: GeometricShape) => boolean;
-export declare const isPointInBounds: (point: Point, bounds: Polygon) => boolean;
+import type { Polyline } from "./geometry/shape";
+import { type GeometricShape } from "./geometry/shape";
+import type { Curve } from "../math";
+import { type GlobalPoint, type LocalPoint, type Polygon } from "../math";
+export declare const isPointOnShape: <Point extends GlobalPoint | LocalPoint>(point: Point, shape: GeometricShape<Point>, tolerance?: number) => boolean;
+export declare const isPointInShape: <Point extends GlobalPoint | LocalPoint>(point: Point, shape: GeometricShape<Point>) => boolean;
+export declare const isPointInBounds: <Point extends GlobalPoint | LocalPoint>(point: Point, bounds: Polygon<Point>) => boolean;
+export declare const pointOnCurve: <Point extends GlobalPoint | LocalPoint>(point: Point, curve: Curve<Point>, threshold: number) => boolean;
+export declare const pointOnPolyline: <Point extends GlobalPoint | LocalPoint>(point: Point, polyline: Polyline<Point>, threshold?: number) => boolean;

package/types/utils/geometry/shape.d.ts

@@ -11,46 +11,61 @@
  * also included in this file are methods for converting an Excalidraw element or a Drawable from roughjs
  * to pure shapes
  */
-import type { ElementsMap, ExcalidrawDiamondElement, ExcalidrawElement, ExcalidrawEllipseElement, ExcalidrawEmbeddableElement, ExcalidrawFrameLikeElement, ExcalidrawFreeDrawElement, ExcalidrawIframeElement, ExcalidrawImageElement, ExcalidrawLinearElement, ExcalidrawRectangleElement, ExcalidrawSelectionElement, ExcalidrawTextElement } from "../../excalidraw/element/types";
+import type { Curve, LineSegment, Polygon, Radians } from "../../math";
+import { type GlobalPoint, type LocalPoint } from "../../math";
+import type { ElementsMap, ExcalidrawBindableElement, ExcalidrawDiamondElement, ExcalidrawElement, ExcalidrawEllipseElement, ExcalidrawEmbeddableElement, ExcalidrawFrameLikeElement, ExcalidrawFreeDrawElement, ExcalidrawIframeElement, ExcalidrawImageElement, ExcalidrawLinearElement, ExcalidrawRectangleElement, ExcalidrawSelectionElement, ExcalidrawTextElement } from "../../excalidraw/element/types";
 import type { Drawable, Op } from "roughjs/bin/core";
-export type Point = [number, number];
-export type Vector = Point;
-export type Line = [Point, Point];
-export type Polyline = Line[];
-export type Curve = [Point, Point, Point, Point];
-export type Polycurve = Curve[];
-export type Polygon = Point[];
-export type Ellipse = {
+export type Polyline<Point extends GlobalPoint | LocalPoint> = LineSegment<Point>[];
+export type Polycurve<Point extends GlobalPoint | LocalPoint> = Curve<Point>[];
+export type Ellipse<Point extends GlobalPoint | LocalPoint> = {
     center: Point;
-    angle: number;
+    angle: Radians;
     halfWidth: number;
     halfHeight: number;
 };
-export type GeometricShape = {
+export type GeometricShape<Point extends GlobalPoint | LocalPoint> = {
     type: "line";
-    data: Line;
+    data: LineSegment<Point>;
 } | {
     type: "polygon";
-    data: Polygon;
+    data: Polygon<Point>;
 } | {
     type: "curve";
-    data: Curve;
+    data: Curve<Point>;
 } | {
     type: "ellipse";
-    data: Ellipse;
+    data: Ellipse<Point>;
 } | {
     type: "polyline";
-    data: Polyline;
+    data: Polyline<Point>;
 } | {
     type: "polycurve";
-    data: Polycurve;
+    data: Polycurve<Point>;
 };
 type RectangularElement = ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawFrameLikeElement | ExcalidrawEmbeddableElement | ExcalidrawImageElement | ExcalidrawIframeElement | ExcalidrawTextElement | ExcalidrawSelectionElement;
-export declare const getPolygonShape: (element: RectangularElement) => GeometricShape;
-export declare const getSelectionBoxShape: (element: ExcalidrawElement, elementsMap: ElementsMap, padding?: number) => GeometricShape;
-export declare const getEllipseShape: (element: ExcalidrawEllipseElement) => GeometricShape;
+export declare const getPolygonShape: <Point extends GlobalPoint | LocalPoint>(element: RectangularElement) => GeometricShape<Point>;
+export declare const getSelectionBoxShape: <Point extends GlobalPoint | LocalPoint>(element: ExcalidrawElement, elementsMap: ElementsMap, padding?: number) => GeometricShape<Point>;
+export declare const getEllipseShape: <Point extends GlobalPoint | LocalPoint>(element: ExcalidrawEllipseElement) => GeometricShape<Point>;
 export declare const getCurvePathOps: (shape: Drawable) => Op[];
-export declare const getCurveShape: (roughShape: Drawable, startingPoint: Point | undefined, angleInRadian: number, center: Point) => GeometricShape;
-export declare const getFreedrawShape: (element: ExcalidrawFreeDrawElement, center: Point, isClosed?: boolean) => GeometricShape;
-export declare const getClosedCurveShape: (element: ExcalidrawLinearElement, roughShape: Drawable, startingPoint: Point | undefined, angleInRadian: number, center: Point) => GeometricShape;
+export declare const getCurveShape: <Point extends GlobalPoint | LocalPoint>(roughShape: Drawable, startingPoint: Point | undefined, angleInRadian: Radians, center: Point) => GeometricShape<Point>;
+export declare const getFreedrawShape: <Point extends GlobalPoint | LocalPoint>(element: ExcalidrawFreeDrawElement, center: Point, isClosed?: boolean) => GeometricShape<Point>;
+export declare const getClosedCurveShape: <Point extends GlobalPoint | LocalPoint>(element: ExcalidrawLinearElement, roughShape: Drawable, startingPoint: Point | undefined, angleInRadian: Radians, center: Point) => GeometricShape<Point>;
+/**
+ * Determine intersection of a rectangular shaped element and a
+ * line segment.
+ *
+ * @param element The rectangular element to test against
+ * @param segment The segment intersecting the element
+ * @param gap Optional value to inflate the shape before testing
+ * @returns An array of intersections
+ */
+export declare const segmentIntersectRectangleElement: <Point extends GlobalPoint | LocalPoint>(element: ExcalidrawBindableElement, segment: LineSegment<Point>, gap?: number) => Point[];
+export declare const pointOnEllipse: <Point extends GlobalPoint | LocalPoint>(point: Point, ellipse: Ellipse<Point>, threshold?: number) => boolean;
+export declare const pointInEllipse: <Point extends GlobalPoint | LocalPoint>(p: Point, ellipse: Ellipse<Point>) => boolean;
+export declare const ellipseAxes: <Point extends GlobalPoint | LocalPoint>(ellipse: Ellipse<Point>) => {
+    majorAxis: number;
+    minorAxis: number;
+};
+export declare const ellipseFocusToCenter: <Point extends GlobalPoint | LocalPoint>(ellipse: Ellipse<Point>) => number;
+export declare const ellipseExtremes: <Point extends GlobalPoint | LocalPoint>(ellipse: Ellipse<Point>) => import("../../math").Vector[];
 export {};