@excalidraw/excalidraw 0.18.0-817d8c5 → 0.18.0-8fc71066d

package/dist/types/excalidraw/laser-trails.d.ts

@@ -1,5 +1,5 @@
-import type { Trail } from "./animated-trail";
 import { AnimatedTrail } from "./animated-trail";
+import type { Trail } from "./animated-trail";
 import type { AnimationFrameHandler } from "./animation-frame-handler";
 import type App from "./components/App";
 export declare class LaserTrails implements Trail {

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

@@ -0,0 +1,16 @@
+import { type AnimationFrameHandler } from "../animation-frame-handler";
+import { AnimatedTrail } from "../animated-trail";
+import type App from "../components/App";
+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;
+    selectElementsFromIds: (ids: string[]) => void;
+    addPointToPath: (x: number, y: number, keepPreviousSelection?: boolean) => void;
+    private updateSelection;
+    endPath(): void;
+}

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

@@ -0,0 +1,13 @@
+import type { ElementsSegmentsMap, GlobalPoint } from "@excalidraw/math/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"]>;
+    simplifyDistance?: number;
+}) => {
+    selectedElementIds: string[];
+};

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

@@ -1,13 +1,18 @@
-import type { StaticCanvasAppState, AppState } from "../types";
+import type { ElementsMap, ExcalidrawDiamondElement, ExcalidrawRectanguloidElement } from "@excalidraw/element/types";
 import type { StaticCanvasRenderConfig } from "../scene/types";
-export declare const fillCircle: (context: CanvasRenderingContext2D, cx: number, cy: number, radius: number, stroke?: boolean) => void;
+import type { AppState, StaticCanvasAppState } from "../types";
+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;
     scale: number;
     normalizedWidth: number;
     normalizedHeight: number;
-    theme?: import("../element/types").Theme | undefined;
+    theme?: import("@excalidraw/element/types").Theme | undefined;
     isExporting?: boolean | undefined;
     viewBackgroundColor?: string | null | undefined;
 }) => CanvasRenderingContext2D;
+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, 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/renderer/staticSvgScene.d.ts

@@ -1,5 +1,5 @@
-import type { RoughSVG } from "roughjs/bin/svg";
-import type { NonDeletedExcalidrawElement } from "../element/types";
+import type { NonDeletedExcalidrawElement } from "@excalidraw/element/types";
 import type { RenderableElementsMap, SVGRenderConfig } from "../scene/types";
 import type { BinaryFiles } from "../types";
+import type { RoughSVG } from "roughjs/bin/svg";
 export declare const renderSceneToSvg: (elements: readonly NonDeletedExcalidrawElement[], elementsMap: RenderableElementsMap, rsvg: RoughSVG, svgRoot: SVGElement, files: BinaryFiles, renderConfig: SVGRenderConfig) => void;

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

@@ -1,6 +1,6 @@
-import type { ExcalidrawElement, NonDeletedExcalidrawElement } from "../element/types";
+import type { ExcalidrawElement, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
+import type { Scene } from "@excalidraw/element";
 import type { AppState } from "../types";
-import type Scene from "./Scene";
 export declare class Renderer {
     private scene;
     constructor(scene: Scene);
@@ -16,10 +16,9 @@ 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("../utility-types").MakeBrand<"NonDeletedElementsMap"> & import("../utility-types").MakeBrand<"RenderableElementsMap">;
+        elementsMap: Map<string, NonDeletedExcalidrawElement> & import("@excalidraw/common/utility-types").MakeBrand<"NonDeletedElementsMap"> & import("@excalidraw/common/utility-types").MakeBrand<"RenderableElementsMap">;
         visibleElements: readonly NonDeletedExcalidrawElement[];
     }) & {
         clear: () => void;

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

@@ -1,4 +1,4 @@
-import type { ExcalidrawFrameLikeElement, NonDeletedExcalidrawElement } from "../element/types";
+import type { ExcalidrawFrameLikeElement, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
 import type { AppState, BinaryFiles } from "../types";
 export declare const exportToCanvas: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState, files: BinaryFiles, { exportBackground, exportPadding, viewBackgroundColor, exportingFrame, }: {
     exportBackground: boolean;

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

@@ -1,4 +1,4 @@
-export { isSomeElementSelected, getElementsWithinSelection, getCommonAttributeOfSelectedElements, getSelectedElements, getTargetElements, } from "./selection";
+export { isSomeElementSelected, getElementsWithinSelection, getSelectedElements, getTargetElements, } from "@excalidraw/element";
 export { calculateScrollCenter } from "./scroll";
-export { hasBackground, hasStrokeWidth, hasStrokeStyle, canHaveArrowheads, canChangeRoundness, } from "./comparisons";
+export { hasBackground, hasStrokeWidth, hasStrokeStyle, canHaveArrowheads, canChangeRoundness, } from "@excalidraw/element";
 export { getNormalizedZoom, getNormalizedGridSize, getNormalizedGridStep, } from "./normalize";

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

@@ -1,5 +1,5 @@
+import type { ExcalidrawElement } from "@excalidraw/element/types";
 import type { AppState, Offsets, PointerCoords, Zoom } from "../types";
-import type { ExcalidrawElement } from "../element/types";
 export declare const centerScrollOn: ({ scenePoint, viewportDimensions, zoom, offsets, }: {
     scenePoint: PointerCoords;
     viewportDimensions: {

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

@@ -1,10 +1,9 @@
 import type { InteractiveCanvasAppState } from "../types";
-import type { ScrollBars } from "./types";
-import type { ExcalidrawElement } from "../element/types";
+import type { RenderableElementsMap, ScrollBars } from "./types";
 export declare const SCROLLBAR_MARGIN = 4;
 export declare const SCROLLBAR_WIDTH = 6;
 export declare const SCROLLBAR_COLOR = "rgba(0,0,0,0.3)";
-export declare const getScrollBars: (elements: readonly ExcalidrawElement[], viewportWidth: number, viewportHeight: number, appState: InteractiveCanvasAppState) => ScrollBars;
+export declare const getScrollBars: (elements: RenderableElementsMap, viewportWidth: number, viewportHeight: number, appState: InteractiveCanvasAppState) => ScrollBars;
 export declare const isOverScrollBars: (scrollBars: ScrollBars, x: number, y: number) => {
     isOverEither: boolean;
     isOverHorizontal: boolean;

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

@@ -1,9 +1,9 @@
+import type { UserIdleState } from "@excalidraw/common";
+import type { ExcalidrawElement, NonDeletedElementsMap, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap } from "@excalidraw/element/types";
+import type { MakeBrand } from "@excalidraw/common/utility-types";
+import type { AppClassProperties, AppState, EmbedsValidationStatus, ElementsPendingErasure, InteractiveCanvasAppState, StaticCanvasAppState, SocketId, Device, PendingExcalidrawElements } from "../types";
 import type { RoughCanvas } from "roughjs/bin/canvas";
 import type { Drawable } from "roughjs/bin/core";
-import type { ExcalidrawElement, NonDeletedElementsMap, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap } from "../element/types";
-import type { AppClassProperties, AppState, EmbedsValidationStatus, ElementsPendingErasure, InteractiveCanvasAppState, StaticCanvasAppState, SocketId, Device, PendingExcalidrawElements } from "../types";
-import type { MakeBrand } from "../utility-types";
-import type { UserIdleState } from "../constants";
 export type RenderableElementsMap = NonDeletedElementsMap & MakeBrand<"RenderableElementsMap">;
 export type StaticCanvasRenderConfig = {
     canvasBackgroundColor: AppState["viewBackgroundColor"];
@@ -93,12 +93,14 @@ export type ScrollBars = {
         y: number;
         width: number;
         height: number;
+        deltaMultiplier: number;
     } | null;
     vertical: {
         x: number;
         y: number;
         width: number;
         height: number;
+        deltaMultiplier: number;
     } | null;
 };
 export type ElementShape = Drawable | Drawable[] | null;

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

@@ -1,9 +1,9 @@
-import type { InclusiveRange } from "@excalidraw/math";
 import { type GlobalPoint } from "@excalidraw/math";
-import type { Bounds } from "./element/bounds";
-import type { MaybeTransformHandleType } from "./element/transformHandles";
-import type { ElementsMap, ExcalidrawElement, NonDeletedExcalidrawElement } from "./element/types";
-import type { AppClassProperties, AppState, KeyboardModifiersObject, NullableGridSize } from "./types";
+import type { InclusiveRange } from "@excalidraw/math";
+import type { Bounds } from "@excalidraw/element";
+import type { MaybeTransformHandleType } from "@excalidraw/element";
+import type { ElementsMap, ExcalidrawElement, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
+import type { AppClassProperties, AppState, KeyboardModifiersObject } from "./types";
 export declare const getSnapDistance: (zoomValue: number) => number;
 type Vector2D = {
     x: number;
@@ -108,5 +108,4 @@ export declare const getSnapLinesAtPointer: (elements: readonly ExcalidrawElemen
     snapLines: PointerSnapLine[];
 };
 export declare const isActiveToolNonLinearSnappable: (activeToolType: AppState["activeTool"]["type"]) => boolean;
-export declare const getGridPoint: (x: number, y: number, gridSize: NullableGridSize) => [number, number];
 export {};

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

@@ -1,25 +1,23 @@
-import type { JSX } from "react";
-import type React from "react";
-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 "./element/types";
+import type { IMAGE_MIME_TYPES, UserIdleState, throttleRAF, MIME_TYPES } from "@excalidraw/common";
+import type { ApplyToOptions, 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, 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";
-import type { LinearElementEditor } from "./element/linearElementEditor";
-import type { SuggestedBinding } from "./element/binding";
-import type { ImportedDataState } from "./data/types";
-import type App from "./components/App";
-import type { throttleRAF } from "./utils";
 import type { Spreadsheet } from "./charts";
-import type { Language } from "./i18n";
 import type { ClipboardData } from "./clipboard";
-import type { isOverScrollBars } from "./scene/scrollbars";
-import type { MaybeTransformHandleType } from "./element/transformHandles";
+import type App from "./components/App";
 import type Library from "./data/library";
 import type { FileSystemHandle } from "./data/filesystem";
-import type { IMAGE_MIME_TYPES, MIME_TYPES } from "./constants";
 import type { ContextMenuItems } from "./components/ContextMenu";
 import type { SnapLine } from "./snapping";
-import type { Merge, MaybePromise, ValueOf, MakeBrand } from "./utility-types";
-import type { CaptureUpdateActionType } from "./store";
-import type { UserIdleState } from "./constants";
+import type { ImportedDataState } from "./data/types";
+import type { Language } from "./i18n";
+import type { isOverScrollBars } from "./scene/scrollbars";
+import type React from "react";
+import type { JSX } from "react";
 export type SocketId = string & {
     _brand: "SocketId";
 };
@@ -86,7 +84,7 @@ export type BinaryFileData = {
 };
 export type BinaryFileMetadata = Omit<BinaryFileData, "dataURL">;
 export type BinaryFiles = Record<ExcalidrawElement["id"], BinaryFileData>;
-export type ToolType = "selection" | "rectangle" | "diamond" | "ellipse" | "arrow" | "line" | "freedraw" | "text" | "image" | "eraser" | "hand" | "frame" | "magicframe" | "embeddable" | "laser";
+export type ToolType = "selection" | "lasso" | "rectangle" | "diamond" | "ellipse" | "arrow" | "line" | "freedraw" | "text" | "image" | "eraser" | "hand" | "frame" | "magicframe" | "embeddable" | "laser";
 export type ElementOrToolType = ExcalidrawElementType | ToolType | "custom";
 export type ActiveTool = {
     type: ToolType;
@@ -115,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"];
@@ -132,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"];
@@ -148,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 = {
@@ -158,9 +155,13 @@ export type ObservedElementsAppState = {
     editingGroupId: AppState["editingGroupId"];
     selectedElementIds: AppState["selectedElementIds"];
     selectedGroupIds: AppState["selectedGroupIds"];
-    editingLinearElementId: LinearElementEditor["elementId"] | null;
-    selectedLinearElementId: LinearElementEditor["elementId"] | null;
+    selectedLinearElement: {
+        elementId: LinearElementEditor["elementId"];
+        isEditing: boolean;
+    } | null;
     croppingElementId: AppState["croppingElementId"];
+    lockedMultiSelections: AppState["lockedMultiSelections"];
+    activeLockedId: AppState["activeLockedId"];
 };
 export interface AppState {
     contextMenu: {
@@ -211,7 +212,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
@@ -219,6 +219,7 @@ export interface AppState {
          */
         lastActiveTool: ActiveTool | null;
         locked: boolean;
+        fromSelection: boolean;
     } & ActiveTool;
     penMode: boolean;
     penDetected: boolean;
@@ -325,8 +326,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[];
@@ -342,9 +341,18 @@ export interface AppState {
     /** image cropping */
     isCropping: boolean;
     croppingElementId: ExcalidrawElement["id"] | null;
-    searchMatches: readonly SearchMatch[];
+    /** null if no search matches found / search closed */
+    searchMatches: Readonly<{
+        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;
+    };
 }
-type SearchMatch = {
+export type SearchMatch = {
     id: string;
     focus: boolean;
     matchedLines: {
@@ -352,6 +360,7 @@ type SearchMatch = {
         offsetY: number;
         width: number;
         height: number;
+        showOnCanvas: boolean;
     }[];
 };
 export type UIAppState = Omit<AppState, "suggestedBindings" | "startBoundElement" | "cursorButton" | "scrollX" | "scrollY">;
@@ -404,6 +413,7 @@ export type OnUserFollowedPayload = {
 };
 export interface ExcalidrawProps {
     onChange?: (elements: readonly OrderedExcalidrawElement[], appState: AppState, files: BinaryFiles) => void;
+    onIncrement?: (event: DurableIncrement | EphemeralIncrement) => void;
     initialData?: (() => MaybePromise<ExcalidrawInitialDataState | null>) | MaybePromise<ExcalidrawInitialDataState | null>;
     excalidrawAPI?: (api: ExcalidrawImperativeAPI) => void;
     isCollaborating?: boolean;
@@ -460,6 +470,7 @@ export interface ExcalidrawProps {
     renderEmbeddable?: (element: NonDeleted<ExcalidrawEmbeddableElement>, appState: AppState) => JSX.Element | null;
     aiEnabled?: boolean;
     showDeprecatedFonts?: boolean;
+    renderScrollbars?: boolean;
 }
 export type SceneData = {
     elements?: ImportedDataState["elements"];
@@ -467,6 +478,7 @@ export type SceneData = {
     collaborators?: Map<SocketId, Collaborator>;
     captureUpdate?: CaptureUpdateActionType;
 };
+export type ApplyDeltasOptions = Omit<ApplyToOptions, "skipRedraw">;
 export type ExportOpts = {
     saveFileToDisk?: boolean;
     onExportToBackend?: (exportedElements: readonly NonDeletedExcalidrawElement[], appState: UIAppState, files: BinaryFiles) => void;
@@ -545,6 +557,7 @@ export type AppClassProperties = {
     visibleElements: App["visibleElements"];
     excalidrawContainerValue: App["excalidrawContainerValue"];
     onPointerUpEmitter: App["onPointerUpEmitter"];
+    updateEditorAtom: App["updateEditorAtom"];
 };
 export type PointerDownState = Readonly<{
     origin: Readonly<{
@@ -588,6 +601,10 @@ export type PointerDownState = Readonly<{
             x: number;
             y: number;
         } | null;
+        origin: {
+            x: number;
+            y: number;
+        };
     };
     eventListeners: {
         onMove: null | ReturnType<typeof throttleRAF>;
@@ -602,9 +619,12 @@ export type PointerDownState = Readonly<{
 export type UnsubscribeCallback = () => void;
 export interface ExcalidrawImperativeAPI {
     updateScene: InstanceType<typeof App>["updateScene"];
+    applyDeltas: InstanceType<typeof App>["applyDeltas"];
+    mutateElement: InstanceType<typeof App>["mutateElement"];
     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"];
     };
@@ -629,6 +649,7 @@ export interface ExcalidrawImperativeAPI {
      */
     updateFrameRendering: InstanceType<typeof App>["updateFrameRendering"];
     onChange: (callback: (elements: readonly ExcalidrawElement[], appState: AppState, files: BinaryFiles) => void) => UnsubscribeCallback;
+    onIncrement: (callback: (event: DurableIncrement | EphemeralIncrement) => void) => UnsubscribeCallback;
     onPointerDown: (callback: (activeTool: AppState["activeTool"], pointerDownState: PointerDownState, event: React.PointerEvent<HTMLElement>) => void) => UnsubscribeCallback;
     onPointerUp: (callback: (activeTool: AppState["activeTool"], pointerDownState: PointerDownState, event: PointerEvent) => void) => UnsubscribeCallback;
     onScrollChange: (callback: (scrollX: number, scrollY: number, zoom: Zoom) => void) => UnsubscribeCallback;

package/dist/types/excalidraw/{element → wysiwyg}/textWysiwyg.d.ts

@@ -1,5 +1,6 @@
-import type { ExcalidrawElement, ExcalidrawTextElement } from "./types";
+import type { ExcalidrawElement, ExcalidrawTextElement } from "@excalidraw/element/types";
 import type App from "../components/App";
+type SubmitHandler = () => void;
 export declare const textWysiwyg: ({ id, onChange, onSubmit, getViewportCoords, element, canvas, excalidrawContainer, app, autoSelect, }: {
     id: ExcalidrawElement["id"];
     /**
@@ -19,4 +20,5 @@ export declare const textWysiwyg: ({ id, onChange, onSubmit, getViewportCoords,
     excalidrawContainer: HTMLDivElement | null;
     app: App;
     autoSelect?: boolean | undefined;
-}) => void;
+}) => SubmitHandler;
+export {};

package/dist/types/math/{angle.d.ts → 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

@@ -0,0 +1,74 @@
+import type { Curve, GlobalPoint, LineSegment, LocalPoint } from "./types";
+/**
+ *
+ * @param a
+ * @param b
+ * @param c
+ * @param d
+ * @returns
+ */
+export declare function curve<Point extends GlobalPoint | LocalPoint>(a: Point, b: Point, c: Point, d: Point): Curve<Point>;
+export declare const bezierEquation: <Point extends GlobalPoint | LocalPoint>(c: Curve<Point>, t: number) => Point;
+/**
+ * Computes the intersection between a cubic spline and a line segment.
+ */
+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 x
+ * @param y
+ * @param P0
+ * @param P1
+ * @param P2
+ * @param P3
+ * @param tolerance
+ * @param maxLevel
+ * @returns
+ */
+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 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 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/{index.d.ts → 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/{point.d.ts → src/point.d.ts}

@@ -43,9 +43,9 @@ 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;
 /**
- * Roate a point by [angle] radians.
+ * Rotate a point by [angle] radians.
  *
  * @param point The point to rotate
  * @param center The point to rotate around, the center point
@@ -54,7 +54,7 @@ export declare function pointsEqual<Point extends GlobalPoint | LocalPoint>(a: P
  */
 export declare function pointRotateRads<Point extends GlobalPoint | LocalPoint>([x, y]: Point, [cx, cy]: Point, angle: Radians): Point;
 /**
- * Roate a point by [angle] degree.
+ * Rotate a point by [angle] degree.
  *
  * @param point The point to rotate
  * @param center The point to rotate around, the center point

package/dist/types/math/{polygon.d.ts → src/polygon.d.ts}

@@ -2,4 +2,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 polygonIncludesPointNonZero: <Point extends [number, number]>(point: Point, polygon: Point[]) => boolean;
 export declare const pointOnPolygon: <Point extends GlobalPoint | LocalPoint>(p: Point, poly: Polygon<Point>, threshold?: number) => boolean;

package/dist/types/math/{rectangle.d.ts → 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/{segment.d.ts → src/segment.d.ts}

@@ -36,4 +36,4 @@ export declare const distanceToLineSegment: <Point extends GlobalPoint | LocalPo
  * @param s
  * @returns
  */
-export declare function lineSegmentIntersectionPoints<Point extends GlobalPoint | LocalPoint>(l: LineSegment<Point>, s: LineSegment<Point>): Point | null;
+export declare function lineSegmentIntersectionPoints<Point extends GlobalPoint | LocalPoint>(l: LineSegment<Point>, s: LineSegment<Point>, threshold?: number): Point | null;

package/dist/types/math/{types.d.ts → src/types.d.ts}

@@ -103,3 +103,4 @@ export type Ellipse<Point extends GlobalPoint | LocalPoint> = {
 } & {
     _brand: "excalimath_ellipse";
 };
+export type ElementsSegmentsMap = Map<string, LineSegment<GlobalPoint>[]>;

package/dist/types/math/{vector.d.ts → 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.
@@ -86,3 +88,7 @@ export declare function vectorMagnitude(v: Vector): number;
  * @returns The new normalized vector
  */
 export declare const vectorNormalize: (v: Vector) => Vector;
+/**
+ * Calculate the right-hand normal of the vector.
+ */
+export declare const vectorNormal: (v: Vector) => Vector;

package/dist/types/utils/{bbox.d.ts → src/bbox.d.ts}

@@ -1,5 +1,5 @@
 import { type GlobalPoint, type LocalPoint } from "@excalidraw/math";
-import type { Bounds } from "@excalidraw/excalidraw/element/bounds";
+import type { Bounds } from "@excalidraw/element";
 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;

package/dist/types/utils/{export.d.ts → src/export.d.ts}

@@ -1,6 +1,6 @@
+import { MIME_TYPES } from "@excalidraw/common";
+import type { ExcalidrawElement, ExcalidrawFrameLikeElement, NonDeleted } from "@excalidraw/element/types";
 import type { AppState, BinaryFiles } from "@excalidraw/excalidraw/types";
-import type { ExcalidrawElement, ExcalidrawFrameLikeElement, NonDeleted } from "@excalidraw/excalidraw/element/types";
-import { MIME_TYPES } from "@excalidraw/excalidraw/constants";
 export { MIME_TYPES };
 type ExportOpts = {
     elements: readonly NonDeleted<ExcalidrawElement>[];

package/dist/types/utils/{index.d.ts → src/index.d.ts}

@@ -1,4 +1,4 @@
 export * from "./export";
 export * from "./withinBounds";
 export * from "./bbox";
-export { getCommonBounds } from "@excalidraw/excalidraw/element/bounds";
+export { getCommonBounds } from "@excalidraw/element";

package/dist/types/utils/{geometry → src}/shape.d.ts

@@ -1,19 +1,6 @@
-/**
- * this file defines pure geometric shapes
- *
- * for instance, a cubic bezier curve is specified by its four control points and
- * an ellipse is defined by its center, angle, semi major axis and semi minor axis
- * (but in semi-width and semi-height so it's more relevant to Excalidraw)
- *
- * the idea with pure shapes is so that we can provide collision and other geoemtric methods not depending on
- * the specifics of roughjs or elements in Excalidraw; instead, we can focus on the pure shapes themselves
- *
- * also included in this file are methods for converting an Excalidraw element or a Drawable from roughjs
- * to pure shapes
- */
-import type { Curve, LineSegment, Polygon, Radians } from "@excalidraw/math";
 import { type GlobalPoint, type LocalPoint } from "@excalidraw/math";
-import type { ElementsMap, ExcalidrawBindableElement, ExcalidrawDiamondElement, ExcalidrawElement, ExcalidrawEllipseElement, ExcalidrawEmbeddableElement, ExcalidrawFrameLikeElement, ExcalidrawFreeDrawElement, ExcalidrawIframeElement, ExcalidrawImageElement, ExcalidrawLinearElement, ExcalidrawRectangleElement, ExcalidrawSelectionElement, ExcalidrawTextElement } from "@excalidraw/excalidraw/element/types";
+import type { ElementsMap, ExcalidrawBindableElement, ExcalidrawDiamondElement, ExcalidrawElement, ExcalidrawEllipseElement, ExcalidrawEmbeddableElement, ExcalidrawFrameLikeElement, ExcalidrawFreeDrawElement, ExcalidrawIframeElement, ExcalidrawImageElement, ExcalidrawLinearElement, ExcalidrawRectangleElement, ExcalidrawSelectionElement, ExcalidrawTextElement } from "@excalidraw/element/types";
+import type { Curve, LineSegment, Polygon, Radians } from "@excalidraw/math";
 import type { Drawable, Op } from "roughjs/bin/core";
 export type Polyline<Point extends GlobalPoint | LocalPoint> = LineSegment<Point>[];
 export type Polycurve<Point extends GlobalPoint | LocalPoint> = Curve<Point>[];