@excalidraw/excalidraw 0.18.0-c4c0649 → 0.18.0-c65b684e9

package/dist/types/excalidraw/components/App.d.ts

@@ -1,11 +1,7 @@
 import React from "react";
 import { type EXPORT_IMAGE_TYPES, Emitter } from "@excalidraw/common";
-import { LinearElementEditor } from "@excalidraw/element";
-import { FlowChartCreator } from "@excalidraw/element";
-import { Scene } from "@excalidraw/element";
-import { Store } from "@excalidraw/element";
-import type { ElementUpdate } from "@excalidraw/element";
-import type { ExcalidrawElement, NonDeleted, InitializedExcalidrawImageElement, ExcalidrawImageElement, NonDeletedExcalidrawElement, ExcalidrawFrameLikeElement, ExcalidrawIframeElement, ExcalidrawEmbeddableElement, Ordered } from "@excalidraw/element/types";
+import { LinearElementEditor, FlowChartCreator, Scene, Store, type ElementUpdate } from "@excalidraw/element";
+import type { ExcalidrawElement, NonDeleted, NonDeletedExcalidrawElement, ExcalidrawFrameLikeElement, ExcalidrawIframeElement, ExcalidrawEmbeddableElement, Ordered } from "@excalidraw/element/types";
 import type { Mutable } from "@excalidraw/common/utility-types";
 import { ActionManager } from "../actions/manager";
 import { AnimationFrameHandler } from "../animation-frame-handler";
@@ -82,6 +78,7 @@ declare class App extends React.Component<AppProps, AppState> {
     /** embeds that have been inserted to DOM (as a perf optim, we don't want to
      * insert to DOM before user initially scrolls to them) */
     private initializedEmbeds;
+    private handleToastClose;
     private elementsPendingErasure;
     flowChartCreator: FlowChartCreator;
     private flowChartNavigator;
@@ -415,12 +412,9 @@ declare class App extends React.Component<AppProps, AppState> {
     private onKeyDown;
     private onKeyUp;
     private isToolSupported;
-    setActiveTool: (tool: (({
-        type: Exclude<ToolType, "image">;
+    setActiveTool: (tool: ({
+        type: ToolType;
     } | {
-        type: Extract<ToolType, "image">;
-        insertOnCanvasDirectly?: boolean;
-    }) | {
         type: "custom";
         customType: string;
     }) & {
@@ -446,7 +440,7 @@ declare class App extends React.Component<AppProps, AppState> {
     private getTextElementAtPosition;
     private getElementAtPosition;
     private getElementsAtPosition;
-    getElementHitThreshold(): number;
+    getElementHitThreshold(element: ExcalidrawElement): number;
     private hitElement;
     private getTextBindableContainerAtPosition;
     private startTextEditing;
@@ -509,13 +503,18 @@ declare class App extends React.Component<AppProps, AppState> {
     private restoreReadyToEraseElements;
     private eraseElements;
     private initializeImage;
+    /**
+     * use during async image initialization,
+     * when the placeholder image could have been modified in the meantime,
+     * and when you don't want to loose those modifications
+     */
+    private getLatestInitializedImageElement;
     /**
      * inserts image into elements array and rerenders
      */
-    insertImageElement: (imageElement: ExcalidrawImageElement, imageFile: File, showCursorImagePreview?: boolean) => Promise<NonDeleted<InitializedExcalidrawImageElement> | null | undefined>;
-    private setImagePreviewCursor;
+    private insertImageElement;
     private onImageAction;
-    initializeImageDimensions: (imageElement: ExcalidrawImageElement, forceNaturalSize?: boolean) => void;
+    private getImageNaturalDimensions;
     /** updates image cache, refreshing updated elements and/or setting status
         to error for images that fail during <img> element creation */
     private updateImageCache;
@@ -526,7 +525,6 @@ declare class App extends React.Component<AppProps, AppState> {
     private scheduleImageRefresh;
     private updateBindingEnabledOnPointerMove;
     private maybeSuggestBindingAtCursor;
-    private maybeSuggestBindingsForLinearElementAtCoords;
     private clearSelection;
     private handleInteractiveCanvasRef;
     private handleAppOnDrop;

package/dist/types/excalidraw/components/ButtonIcon.d.ts

@@ -10,6 +10,7 @@ interface ButtonIconProps {
     /** include standalone style (could interfere with parent styles) */
     standalone?: boolean;
     onClick: (event: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
+    style?: React.CSSProperties;
 }
 export declare const ButtonIcon: import("react").ForwardRefExoticComponent<ButtonIconProps & import("react").RefAttributes<HTMLButtonElement>>;
 export {};

package/dist/types/excalidraw/components/Ellipsify.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+export declare const Ellipsify: ({ children, ...rest }: {
+    children: React.ReactNode;
+} & import("react").HTMLAttributes<HTMLSpanElement>) => import("react/jsx-runtime").JSX.Element;

package/dist/types/excalidraw/components/{ButtonIconSelect.d.ts → RadioSelection.d.ts}

@@ -1,5 +1,5 @@
 import type { JSX } from "react";
-export declare const ButtonIconSelect: <T extends Object>(props: {
+export declare const RadioSelection: <T extends Object>(props: {
     options: {
         value: T;
         text: string;

package/dist/types/excalidraw/components/Stats/DragInput.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="react" />
 import type { ElementsMap, ExcalidrawElement } from "@excalidraw/element/types";
 import type { Scene } from "@excalidraw/element";
+import { useApp, useExcalidrawSetAppState } from "../App";
 import "./DragInput.scss";
 import type { StatsInputProperty } from "./utils";
 import type { AppState } from "../../types";
@@ -16,6 +17,14 @@ export type DragInputCallbackType<P extends StatsInputProperty, E = ExcalidrawEl
     property: P;
     originalAppState: AppState;
     setInputValue: (value: number) => void;
+    app: ReturnType<typeof useApp>;
+    setAppState: ReturnType<typeof useExcalidrawSetAppState>;
+}) => void;
+export type DragFinishedCallbackType<E = ExcalidrawElement> = (props: {
+    app: ReturnType<typeof useApp>;
+    setAppState: ReturnType<typeof useExcalidrawSetAppState>;
+    originalElements: readonly E[] | null;
+    originalAppState: AppState;
 }) => void;
 interface StatsDragInputProps<T extends StatsInputProperty, E = ExcalidrawElement> {
     label: string | React.ReactNode;
@@ -30,6 +39,7 @@ interface StatsDragInputProps<T extends StatsInputProperty, E = ExcalidrawElemen
     appState: AppState;
     /** how many px you need to drag to get 1 unit change */
     sensitivity?: number;
+    dragFinishedCallback?: DragFinishedCallbackType;
 }
-declare const StatsDragInput: <T extends StatsInputProperty, E extends ExcalidrawElement = ExcalidrawElement>({ label, icon, dragInputCallback, value, elements, editable, shouldKeepAspectRatio, property, scene, appState, sensitivity, }: StatsDragInputProps<T, E>) => import("react/jsx-runtime").JSX.Element | null;
+declare const StatsDragInput: <T extends StatsInputProperty, E extends ExcalidrawElement = ExcalidrawElement>({ label, icon, dragInputCallback, value, elements, editable, shouldKeepAspectRatio, property, scene, appState, sensitivity, dragFinishedCallback, }: StatsDragInputProps<T, E>) => import("react/jsx-runtime").JSX.Element | null;
 export default StatsDragInput;

package/dist/types/excalidraw/components/UnlockPopup.d.ts

@@ -0,0 +1,8 @@
+import "./UnlockPopup.scss";
+import type App from "./App";
+import type { AppState } from "../types";
+declare const UnlockPopup: ({ app, activeLockedId, }: {
+    app: App;
+    activeLockedId: NonNullable<AppState["activeLockedId"]>;
+}) => import("react/jsx-runtime").JSX.Element | null;
+export default UnlockPopup;

package/dist/types/excalidraw/components/hyperlink/helpers.d.ts

@@ -2,6 +2,7 @@ import type { GlobalPoint, Radians } from "@excalidraw/math";
 import type { Bounds } from "@excalidraw/element";
 import type { ElementsMap, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
 import type { AppState, UIAppState } from "../../types";
+export declare const DEFAULT_LINK_SIZE = 12;
 export declare const EXTERNAL_LINK_IMG: HTMLImageElement;
 export declare const ELEMENT_LINK_IMG: HTMLImageElement;
 export declare const getLinkHandleFromCoords: ([x1, y1, x2, y2]: Bounds, angle: Radians, appState: Pick<UIAppState, "zoom">) => Bounds;

package/dist/types/excalidraw/components/icons.d.ts

@@ -12,8 +12,10 @@ export declare const LibraryIcon: import("react/jsx-runtime").JSX.Element;
 export declare const PlusIcon: import("react/jsx-runtime").JSX.Element;
 export declare const DotsIcon: import("react/jsx-runtime").JSX.Element;
 export declare const PinIcon: import("react/jsx-runtime").JSX.Element;
+export declare const polygonIcon: import("react/jsx-runtime").JSX.Element;
 export declare const UnlockedIcon: import("react/jsx-runtime").JSX.Element;
 export declare const LockedIcon: import("react/jsx-runtime").JSX.Element;
+export declare const LockedIconFilled: import("react/jsx-runtime").JSX.Element;
 export declare const WelcomeScreenMenuArrow: import("react/jsx-runtime").JSX.Element;
 export declare const WelcomeScreenHelpArrow: import("react/jsx-runtime").JSX.Element;
 export declare const WelcomeScreenTopToolbarArrow: import("react/jsx-runtime").JSX.Element;

package/dist/types/excalidraw/components/shapes.d.ts

@@ -59,4 +59,4 @@ export declare const SHAPES: readonly [{
     readonly numericKey: "0";
     readonly fillable: false;
 }];
-export declare const findShapeByKey: (key: string) => "text" | "line" | "arrow" | "selection" | "rectangle" | "diamond" | "ellipse" | "freedraw" | "image" | "eraser" | null;
+export declare const findShapeByKey: (key: string) => "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "freedraw" | "eraser" | null;

package/dist/types/excalidraw/data/blob.d.ts

@@ -6,7 +6,7 @@ import type { FileSystemHandle } from "./filesystem";
 import type { ImportedLibraryData } from "./types";
 export declare const getMimeType: (blob: Blob | string) => string;
 export declare const getFileHandleType: (handle: FileSystemHandle | null) => string | null;
-export declare const isImageFileHandleType: (type: string | null) => type is "svg" | "png";
+export declare const isImageFileHandleType: (type: string | null) => type is "png" | "svg";
 export declare const isImageFileHandle: (handle: FileSystemHandle | null) => boolean;
 export declare const isSupportedImageFileType: (type: string | null | undefined) => boolean;
 export declare const isSupportedImageFile: (blob: Blob | null | undefined) => blob is Blob & {

package/dist/types/excalidraw/eraser/index.d.ts

@@ -4,8 +4,6 @@ import type App from "../components/App";
 export declare class EraserTrail extends AnimatedTrail {
     private elementsToErase;
     private groupsToErase;
-    private segmentsCache;
-    private geometricShapesCache;
     constructor(animationFrameHandler: AnimationFrameHandler, app: App);
     startPath(x: number, y: number): void;
     addPointToPath(x: number, y: number, restore?: boolean): string[];

package/dist/types/excalidraw/history.d.ts

@@ -1,8 +1,25 @@
 import { Emitter } from "@excalidraw/common";
-import { StoreDelta, type Store } from "@excalidraw/element";
+import { StoreDelta } from "@excalidraw/element";
+import type { StoreSnapshot, Store } from "@excalidraw/element";
 import type { SceneElementsMap } from "@excalidraw/element/types";
 import type { AppState } from "./types";
-declare class HistoryEntry extends StoreDelta {
+export declare class HistoryDelta extends StoreDelta {
+    /**
+     * Apply the delta to the passed elements and appState, does not modify the snapshot.
+     */
+    applyTo(elements: SceneElementsMap, appState: AppState, snapshot: StoreSnapshot): [SceneElementsMap, AppState, boolean];
+    /**
+     * Overriding once to avoid type casting everywhere.
+     */
+    static calculate(prevSnapshot: StoreSnapshot, nextSnapshot: StoreSnapshot): HistoryDelta;
+    /**
+     * Overriding once to avoid type casting everywhere.
+     */
+    static inverse(delta: StoreDelta): HistoryDelta;
+    /**
+     * Overriding once to avoid type casting everywhere.
+     */
+    static applyLatestChanges(delta: StoreDelta, prevElements: SceneElementsMap, nextElements: SceneElementsMap, modifierOptions?: "deleted" | "inserted"): HistoryDelta;
 }
 export declare class HistoryChangedEvent {
     readonly isUndoStackEmpty: boolean;
@@ -12,8 +29,8 @@ export declare class HistoryChangedEvent {
 export declare class History {
     private readonly store;
     readonly onHistoryChangedEmitter: Emitter<[HistoryChangedEvent]>;
-    readonly undoStack: HistoryEntry[];
-    readonly redoStack: HistoryEntry[];
+    readonly undoStack: HistoryDelta[];
+    readonly redoStack: HistoryDelta[];
     get isUndoStackEmpty(): boolean;
     get isRedoStackEmpty(): boolean;
     constructor(store: Store);
@@ -29,4 +46,3 @@ export declare class History {
     private static pop;
     private static push;
 }
-export {};

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

@@ -29,6 +29,7 @@ export { Sidebar } from "./components/Sidebar/Sidebar";
 export { Button } from "./components/Button";
 export { Footer };
 export { MainMenu };
+export { Ellipsify } from "./components/Ellipsify";
 export { useDevice } from "./components/App";
 export { WelcomeScreen };
 export { LiveCollaborationTrigger };

package/dist/types/excalidraw/lasso/index.d.ts

@@ -5,6 +5,7 @@ export declare class LassoTrail extends AnimatedTrail {
     private intersectedElements;
     private enclosedElements;
     private elementsSegments;
+    private canvasTranslate;
     private keepPreviousSelection;
     constructor(animationFrameHandler: AnimationFrameHandler, app: App);
     startPath(x: number, y: number, keepPreviousSelection?: boolean): void;

package/dist/types/excalidraw/lasso/utils.d.ts

@@ -1,8 +1,9 @@
 import type { ElementsSegmentsMap, GlobalPoint } from "@excalidraw/math/types";
-import type { ExcalidrawElement } from "@excalidraw/element/types";
+import type { ElementsMap, ExcalidrawElement } from "@excalidraw/element/types";
 export declare const getLassoSelectedElementIds: (input: {
     lassoPath: GlobalPoint[];
     elements: readonly ExcalidrawElement[];
+    elementsMap: ElementsMap;
     elementsSegments: ElementsSegmentsMap;
     intersectedElements: Set<ExcalidrawElement["id"]>;
     enclosedElements: Set<ExcalidrawElement["id"]>;

package/dist/types/excalidraw/renderer/helpers.d.ts

@@ -1,7 +1,7 @@
-import type { ExcalidrawDiamondElement, ExcalidrawRectanguloidElement } from "@excalidraw/element/types";
+import type { ElementsMap, ExcalidrawDiamondElement, ExcalidrawRectanguloidElement } from "@excalidraw/element/types";
 import type { StaticCanvasRenderConfig } from "../scene/types";
 import type { AppState, StaticCanvasAppState } from "../types";
-export declare const fillCircle: (context: CanvasRenderingContext2D, cx: number, cy: number, radius: number, stroke?: boolean) => void;
+export declare const fillCircle: (context: CanvasRenderingContext2D, cx: number, cy: number, radius: number, stroke: boolean, fill?: boolean) => void;
 export declare const getNormalizedCanvasDimensions: (canvas: HTMLCanvasElement, scale: number) => [number, number];
 export declare const bootstrapCanvas: ({ canvas, scale, normalizedWidth, normalizedHeight, theme, isExporting, viewBackgroundColor, }: {
     canvas: HTMLCanvasElement;
@@ -12,7 +12,7 @@ export declare const bootstrapCanvas: ({ canvas, scale, normalizedWidth, normali
     isExporting?: boolean | undefined;
     viewBackgroundColor?: string | null | undefined;
 }) => CanvasRenderingContext2D;
-export declare const drawHighlightForRectWithRotation: (context: CanvasRenderingContext2D, element: ExcalidrawRectanguloidElement, padding: number) => void;
+export declare const drawHighlightForRectWithRotation: (context: CanvasRenderingContext2D, element: ExcalidrawRectanguloidElement, elementsMap: ElementsMap, padding: number) => void;
 export declare const strokeEllipseWithRotation: (context: CanvasRenderingContext2D, width: number, height: number, cx: number, cy: number, angle: number) => void;
 export declare const strokeRectWithRotation: (context: CanvasRenderingContext2D, x: number, y: number, width: number, height: number, cx: number, cy: number, angle: number, fill?: boolean, radius?: number) => void;
-export declare const drawHighlightForDiamondWithRotation: (context: CanvasRenderingContext2D, padding: number, element: ExcalidrawDiamondElement) => void;
+export declare const drawHighlightForDiamondWithRotation: (context: CanvasRenderingContext2D, padding: number, element: ExcalidrawDiamondElement, elementsMap: ElementsMap) => void;

package/dist/types/excalidraw/renderer/staticScene.d.ts

@@ -1,4 +1,7 @@
-import type { StaticSceneRenderConfig } from "../scene/types";
+import type { ExcalidrawFrameLikeElement } from "@excalidraw/element/types";
+import type { StaticCanvasRenderConfig, StaticSceneRenderConfig } from "../scene/types";
+import type { StaticCanvasAppState } from "../types";
+export declare const frameClip: (frame: ExcalidrawFrameLikeElement, context: CanvasRenderingContext2D, renderConfig: StaticCanvasRenderConfig, appState: StaticCanvasAppState) => void;
 /** throttled to animation framerate */
 export declare const renderStaticSceneThrottled: {
     (config: StaticSceneRenderConfig): void;

package/dist/types/excalidraw/scene/Renderer.d.ts

@@ -16,7 +16,6 @@ export declare class Renderer {
         /** note: first render of newElement will always bust the cache
          * (we'd have to prefilter elements outside of this function) */
         newElementId: ExcalidrawElement["id"] | undefined;
-        pendingImageElementId: AppState["pendingImageElementId"];
         sceneNonce: ReturnType<InstanceType<typeof Scene>["getSceneNonce"]>;
     }) => {
         elementsMap: Map<string, NonDeletedExcalidrawElement> & import("@excalidraw/common/utility-types").MakeBrand<"NonDeletedElementsMap"> & import("@excalidraw/common/utility-types").MakeBrand<"RenderableElementsMap">;

package/dist/types/excalidraw/types.d.ts

@@ -2,7 +2,7 @@ import type { IMAGE_MIME_TYPES, UserIdleState, throttleRAF, MIME_TYPES } from "@
 import type { SuggestedBinding } from "@excalidraw/element";
 import type { LinearElementEditor } from "@excalidraw/element";
 import type { MaybeTransformHandleType } from "@excalidraw/element";
-import type { PointerType, ExcalidrawLinearElement, NonDeletedExcalidrawElement, NonDeleted, TextAlign, ExcalidrawElement, GroupId, ExcalidrawBindableElement, Arrowhead, ChartType, FontFamilyValues, FileId, ExcalidrawImageElement, Theme, StrokeRoundness, ExcalidrawEmbeddableElement, ExcalidrawMagicFrameElement, ExcalidrawFrameLikeElement, ExcalidrawElementType, ExcalidrawIframeLikeElement, OrderedExcalidrawElement, ExcalidrawNonSelectionElement } from "@excalidraw/element/types";
+import type { PointerType, ExcalidrawLinearElement, NonDeletedExcalidrawElement, NonDeleted, TextAlign, ExcalidrawElement, GroupId, ExcalidrawBindableElement, Arrowhead, ChartType, FontFamilyValues, FileId, Theme, StrokeRoundness, ExcalidrawEmbeddableElement, ExcalidrawMagicFrameElement, ExcalidrawFrameLikeElement, ExcalidrawElementType, ExcalidrawIframeLikeElement, OrderedExcalidrawElement, ExcalidrawNonSelectionElement } from "@excalidraw/element/types";
 import type { Merge, MaybePromise, ValueOf, MakeBrand } from "@excalidraw/common/utility-types";
 import type { CaptureUpdateActionType, DurableIncrement, EphemeralIncrement } from "@excalidraw/element";
 import type { Action } from "./actions/types";
@@ -113,7 +113,6 @@ type _CommonCanvasAppState = {
     offsetLeft: AppState["offsetLeft"];
     offsetTop: AppState["offsetTop"];
     theme: AppState["theme"];
-    pendingImageElementId: AppState["pendingImageElementId"];
 };
 export type StaticCanvasAppState = Readonly<_CommonCanvasAppState & {
     shouldCacheIgnoreZoom: AppState["shouldCacheIgnoreZoom"];
@@ -130,7 +129,6 @@ export type StaticCanvasAppState = Readonly<_CommonCanvasAppState & {
 }>;
 export type InteractiveCanvasAppState = Readonly<_CommonCanvasAppState & {
     activeEmbeddable: AppState["activeEmbeddable"];
-    editingLinearElement: AppState["editingLinearElement"];
     selectionElement: AppState["selectionElement"];
     selectedGroupIds: AppState["selectedGroupIds"];
     selectedLinearElement: AppState["selectedLinearElement"];
@@ -146,6 +144,7 @@ export type InteractiveCanvasAppState = Readonly<_CommonCanvasAppState & {
     isCropping: AppState["isCropping"];
     croppingElementId: AppState["croppingElementId"];
     searchMatches: AppState["searchMatches"];
+    activeLockedId: AppState["activeLockedId"];
 }>;
 export type ObservedAppState = ObservedStandaloneAppState & ObservedElementsAppState;
 export type ObservedStandaloneAppState = {
@@ -156,9 +155,11 @@ export type ObservedElementsAppState = {
     editingGroupId: AppState["editingGroupId"];
     selectedElementIds: AppState["selectedElementIds"];
     selectedGroupIds: AppState["selectedGroupIds"];
-    editingLinearElementId: LinearElementEditor["elementId"] | null;
     selectedLinearElementId: LinearElementEditor["elementId"] | null;
+    selectedLinearElementIsEditing: boolean | null;
     croppingElementId: AppState["croppingElementId"];
+    lockedMultiSelections: AppState["lockedMultiSelections"];
+    activeLockedId: AppState["activeLockedId"];
 };
 export interface AppState {
     contextMenu: {
@@ -209,7 +210,6 @@ export interface AppState {
      * set when a new text is created or when an existing text is being edited
      */
     editingTextElement: NonDeletedExcalidrawElement | null;
-    editingLinearElement: LinearElementEditor | null;
     activeTool: {
         /**
          * indicates a previous tool we should revert back to if we deselect the
@@ -324,8 +324,6 @@ export interface AppState {
         shown: true;
         data: Spreadsheet;
     };
-    /** imageElement waiting to be placed on canvas */
-    pendingImageElementId: ExcalidrawImageElement["id"] | null;
     showHyperlinkPopup: false | "info" | "editor";
     selectedLinearElement: LinearElementEditor | null;
     snapLines: readonly SnapLine[];
@@ -346,6 +344,11 @@ export interface AppState {
         focusedId: ExcalidrawElement["id"] | null;
         matches: readonly SearchMatch[];
     }> | null;
+    /** the locked element/group that's active and shows unlock popup */
+    activeLockedId: string | null;
+    lockedMultiSelections: {
+        [groupId: string]: true;
+    };
 }
 export type SearchMatch = {
     id: string;
@@ -617,6 +620,7 @@ export interface ExcalidrawImperativeAPI {
     updateLibrary: InstanceType<typeof Library>["updateLibrary"];
     resetScene: InstanceType<typeof App>["resetScene"];
     getSceneElementsIncludingDeleted: InstanceType<typeof App>["getSceneElementsIncludingDeleted"];
+    getSceneElementsMapIncludingDeleted: InstanceType<typeof App>["getSceneElementsMapIncludingDeleted"];
     history: {
         clear: InstanceType<typeof App>["resetHistory"];
     };

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

@@ -15,3 +15,5 @@ export declare function radiansToDegrees(degrees: Radians): Degrees;
  * @returns TRUE if the provided angle is a right angle
  */
 export declare function isRightAngleRads(rads: Radians): boolean;
+export declare function radiansBetweenAngles(a: Radians, min: Radians, max: Radians): boolean;
+export declare function radiansDifference(a: Radians, b: Radians): Radians;

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

@@ -0,0 +1,3 @@
+export declare const PRECISION = 0.0001;
+export declare const LegendreGaussN24TValues: number[];
+export declare const LegendreGaussN24CValues: number[];

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

@@ -40,3 +40,35 @@ export declare function curvePointDistance<Point extends GlobalPoint | LocalPoin
  */
 export declare function isCurve<P extends GlobalPoint | LocalPoint>(v: unknown): v is Curve<P>;
 export declare function curveTangent<Point extends GlobalPoint | LocalPoint>([p0, p1, p2, p3]: Curve<Point>, t: number): import("./types").Vector;
+export declare function curveCatmullRomQuadraticApproxPoints(points: GlobalPoint[], tension?: number): [GlobalPoint, GlobalPoint][] | undefined;
+export declare function curveCatmullRomCubicApproxPoints<Point extends GlobalPoint | LocalPoint>(points: Point[], tension?: number): Curve<Point>[] | undefined;
+export declare function curveOffsetPoints([p0, p1, p2, p3]: Curve<GlobalPoint>, offset: number, steps?: number): GlobalPoint[];
+export declare function offsetPointsForQuadraticBezier(p0: GlobalPoint, p1: GlobalPoint, p2: GlobalPoint, offsetDist: number, steps?: number): GlobalPoint[];
+/**
+ * Implementation based on Legendre-Gauss quadrature for more accurate arc
+ * length calculation.
+ *
+ * Reference: https://pomax.github.io/bezierinfo/#arclength
+ *
+ * @param c The curve to calculate the length of
+ * @returns The approximated length of the curve
+ */
+export declare function curveLength<P extends GlobalPoint | LocalPoint>(c: Curve<P>): number;
+/**
+ * Calculates the curve length from t=0 to t=parameter using the same
+ * Legendre-Gauss quadrature method used in curveLength
+ *
+ * @param c The curve to calculate the partial length for
+ * @param t The parameter value (0 to 1) to calculate length up to
+ * @returns The length of the curve from beginning to parameter t
+ */
+export declare function curveLengthAtParameter<P extends GlobalPoint | LocalPoint>(c: Curve<P>, t: number): number;
+/**
+ * Calculates the point at a specific percentage of a curve's total length
+ * using binary search for improved efficiency and accuracy.
+ *
+ * @param c The curve to calculate point on
+ * @param percent A value between 0 and 1 representing the percentage of the curve's length
+ * @returns The point at the specified percentage of curve length
+ */
+export declare function curvePointAtLength<P extends GlobalPoint | LocalPoint>(c: Curve<P>, percent: number): P;

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

@@ -1,5 +1,6 @@
 export * from "./angle";
 export * from "./curve";
+export * from "./ellipse";
 export * from "./line";
 export * from "./point";
 export * from "./polygon";

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

@@ -43,7 +43,7 @@ export declare 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 declare function pointsEqual<Point extends GlobalPoint | LocalPoint>(a: Point, b: Point): boolean;
+export declare function pointsEqual<Point extends GlobalPoint | LocalPoint>(a: Point, b: Point, tolerance?: number): boolean;
 /**
  * Rotate a point by [angle] radians.
  *

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

@@ -1,3 +1,5 @@
 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 rectangleFromNumberSequence<Point extends LocalPoint | GlobalPoint>(minX: number, minY: number, maxX: number, maxY: number): Rectangle<Point>;
 export declare function rectangleIntersectLineSegment<Point extends LocalPoint | GlobalPoint>(r: Rectangle<Point>, l: LineSegment<Point>): Point[];
+export declare function rectangleIntersectRectangle<Point extends LocalPoint | GlobalPoint>(rectangle1: Rectangle<Point>, rectangle2: Rectangle<Point>): boolean;

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

@@ -12,9 +12,11 @@ export declare function vector(x: number, y: number, originX?: number, originY?:
  *
  * @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
+ * @param threshold The threshold to consider the vector as 'undefined'
+ * @param defaultValue The default value to return if the vector is 'undefined'
+ * @returns The created vector from the point and the origin or default
  */
-export declare function vectorFromPoint<Point extends GlobalPoint | LocalPoint>(p: Point, origin?: Point): Vector;
+export declare function vectorFromPoint<Point extends GlobalPoint | LocalPoint>(p: Point, origin?: Point, threshold?: number, defaultValue?: Vector): Vector;
 /**
  * Cross product is a binary operation on two vectors in 2D space.
  * It results in a vector that is perpendicular to both vectors.