@excalidraw/common 0.18.0-4e0441e → 0.18.0-4e758db

package/dist/types/element/src/Scene.d.ts

@@ -1,5 +1,5 @@
 import { type ElementUpdate } from "@excalidraw/element";
-import type { ExcalidrawElement, NonDeletedExcalidrawElement, NonDeleted, ExcalidrawFrameLikeElement, ElementsMapOrArray, OrderedExcalidrawElement, Ordered } from "@excalidraw/element/types";
+import type { ExcalidrawElement, NonDeletedExcalidrawElement, NonDeleted, ExcalidrawFrameLikeElement, ElementsMapOrArray, SceneElementsMap, NonDeletedSceneElementsMap, OrderedExcalidrawElement, Ordered } from "@excalidraw/element/types";
 import type { Mutable } from "@excalidraw/common/utility-types";
 import type { AppState } from "../../excalidraw/types";
 type SceneStateCallback = () => void;
@@ -22,9 +22,9 @@ export declare class Scene {
      */
     private sceneNonce;
     getSceneNonce(): number | undefined;
-    getNonDeletedElementsMap(): Map<string, Ordered<NonDeletedExcalidrawElement>> & import("@excalidraw/common/utility-types").MakeBrand<"NonDeletedSceneElementsMap">;
+    getNonDeletedElementsMap(): NonDeletedSceneElementsMap;
     getElementsIncludingDeleted(): readonly OrderedExcalidrawElement[];
-    getElementsMapIncludingDeleted(): Map<string, Ordered<ExcalidrawElement>> & import("@excalidraw/common/utility-types").MakeBrand<"SceneElementsMap">;
+    getElementsMapIncludingDeleted(): SceneElementsMap;
     getNonDeletedElements(): readonly Ordered<NonDeletedExcalidrawElement>[];
     getFramesIncludingDeleted(): readonly ExcalidrawFrameLikeElement[];
     constructor(elements?: ElementsMapOrArray | null, options?: {
@@ -40,7 +40,7 @@ export declare class Scene {
         elements?: ElementsMapOrArray;
         includeBoundTextElement?: boolean;
         includeElementsInFrames?: boolean;
-    }): NonDeleted<ExcalidrawElement>[];
+    }): NonDeletedExcalidrawElement[];
     getNonDeletedFramesLikes(): readonly NonDeleted<ExcalidrawFrameLikeElement>[];
     getElement<T extends ExcalidrawElement>(id: T["id"]): T | null;
     getNonDeletedElement(id: ExcalidrawElement["id"]): NonDeleted<ExcalidrawElement> | null;
@@ -63,18 +63,22 @@ export declare class Scene {
     triggerUpdate(): void;
     onUpdate(cb: SceneStateCallback): SceneStateCallbackRemover;
     destroy(): void;
-    insertElementAtIndex(element: ExcalidrawElement, index: number): void;
-    insertElementsAtIndex(elements: ExcalidrawElement[], index: number): void;
+    /** low-level - generally use app.insertNewElements() */
+    insertElementsAtIndex(elements: ExcalidrawElement[], 
+    /** null indicates end of the array */
+    index: number | null): void;
+    /** low-level - generally use app.insertNewElement() */
     insertElement: (element: ExcalidrawElement) => void;
-    insertElements: (elements: ExcalidrawElement[]) => void;
     getElementIndex(elementId: string): number;
     getContainerElement: (element: (ExcalidrawElement & {
         containerId: ExcalidrawElement["id"] | null;
-    }) | null) => import("@excalidraw/element/types").ExcalidrawTextElement | import("@excalidraw/element/types").ExcalidrawRectangleElement | import("@excalidraw/element/types").ExcalidrawDiamondElement | import("@excalidraw/element/types").ExcalidrawFrameElement | import("@excalidraw/element/types").ExcalidrawMagicFrameElement | import("@excalidraw/element/types").ExcalidrawEmbeddableElement | import("@excalidraw/element/types").ExcalidrawImageElement | import("@excalidraw/element/types").ExcalidrawIframeElement | import("@excalidraw/element/types").ExcalidrawSelectionElement | import("@excalidraw/element/types").ExcalidrawEllipseElement | import("@excalidraw/element/types").ExcalidrawLinearElement | import("@excalidraw/element/types").ExcalidrawFreeDrawElement | null;
+    }) | null) => import("@excalidraw/element/types").ExcalidrawLinearElement | import("@excalidraw/element/types").ExcalidrawSelectionElement | import("@excalidraw/element/types").ExcalidrawRectangleElement | import("@excalidraw/element/types").ExcalidrawStickyNoteElement | import("@excalidraw/element/types").ExcalidrawDiamondElement | import("@excalidraw/element/types").ExcalidrawEllipseElement | import("@excalidraw/element/types").ExcalidrawEmbeddableElement | import("@excalidraw/element/types").ExcalidrawIframeElement | import("@excalidraw/element/types").ExcalidrawImageElement | import("@excalidraw/element/types").ExcalidrawFrameElement | import("@excalidraw/element/types").ExcalidrawMagicFrameElement | import("@excalidraw/element/types").ExcalidrawTextElement | import("@excalidraw/element/types").ExcalidrawFreeDrawElement | null;
     getElementsFromId: (id: string) => ExcalidrawElement[];
     mutateElement<TElement extends Mutable<ExcalidrawElement>>(element: TElement, updates: ElementUpdate<TElement>, options?: {
         informMutation: boolean;
         isDragging: boolean;
+        isBindingEnabled?: boolean;
+        isMidpointSnappingEnabled?: boolean;
     }): TElement;
 }
 export {};

package/dist/types/element/src/align.d.ts

@@ -1,8 +1,8 @@
 import type { AppState } from "@excalidraw/excalidraw/types";
 import type { Scene } from "./Scene";
-import type { ExcalidrawElement } from "./types";
+import type { NonDeletedExcalidrawElement } from "./types";
 export interface Alignment {
     position: "start" | "center" | "end";
     axis: "x" | "y";
 }
-export declare const alignElements: (selectedElements: ExcalidrawElement[], alignment: Alignment, scene: Scene, appState: Readonly<AppState>) => ExcalidrawElement[];
+export declare const alignElements: (selectedElements: NonDeletedExcalidrawElement[], alignment: Alignment, scene: Scene, appState: Readonly<AppState>) => NonDeletedExcalidrawElement[];

package/dist/types/element/src/arrowEndpointText.d.ts

@@ -0,0 +1,49 @@
+import type { GlobalPoint } from "@excalidraw/math";
+import type { AppState } from "@excalidraw/excalidraw/types";
+import type { ElementsMap, ExcalidrawArrowElement, ExcalidrawTextElement, FixedPoint, NonDeleted, NonDeletedExcalidrawElement, TextAlign, VerticalAlign } from "./types";
+export type ArrowEndpoint = {
+    arrow: NonDeleted<ExcalidrawArrowElement>;
+    startOrEnd: "start" | "end";
+};
+/**
+ * Finds a free (unbound) arrow endpoint under the cursor, front-most first.
+ * Used by the text tool to offer creating a text label anchored to the tip of
+ * an arrow.
+ */
+export declare const getUnboundArrowEndpointAtPoint: (scenePointer: GlobalPoint, elements: readonly NonDeletedExcalidrawElement[], elementsMap: ElementsMap, zoom: AppState["zoom"]) => ArrowEndpoint | null;
+/**
+ * Describes how a text element should be created so that it reads as a label
+ * for the given arrow endpoint.
+ *
+ * The arrow is treated as fixed: rather than routing the arrow to the text, we
+ * pick the side of the text the arrow should attach to (the one it already
+ * points at), and place the text so that side's midpoint lands on the existing
+ * endpoint. The alignment returned pins that same midpoint while the text is
+ * typed, so the arrow doesn't swing around during editing.
+ */
+export declare const getTextBindingForArrowEndpoint: (arrow: NonDeleted<ExcalidrawArrowElement>, startOrEnd: "start" | "end", elementsMap: ElementsMap, 
+/**
+ * stroke width the text will be created with — the binding gap is derived
+ * from the *bind target*, so using the arrow's would offset the anchor by
+ * half the difference between the two
+ */
+targetStrokeWidth: number) => {
+    /** the text-local ratio the arrow binds to (a side midpoint) */
+    fixedPoint: FixedPoint;
+    textAlign: TextAlign;
+    verticalAlign: VerticalAlign;
+    /** scene position the text's bound side midpoint should sit at */
+    anchor: GlobalPoint;
+} | null;
+/**
+ * Whether an arrow endpoint is bound to this text — i.e. the text serves as an
+ * arrow-endpoint label. Checked on the arrows' own bindings: the text's
+ * `boundElements` only says an arrow relates to it, while the binding on the
+ * arrow is the authoritative side of the relationship.
+ */
+export declare const isEndpointBoundText: (text: ExcalidrawTextElement, elementsMap: ElementsMap) => boolean;
+/** the anchor a text bound to an arrow endpoint grows away from */
+export declare const getEndpointBoundTextDragAnchor: (newElement: ExcalidrawTextElement) => {
+    anchorRatio: number;
+    anchorX: number;
+};

package/dist/types/element/src/arrowheads.d.ts

@@ -0,0 +1,3 @@
+import type { Arrowhead, AnyArrowhead } from "./types";
+export declare const normalizeArrowhead: (arrowhead: AnyArrowhead | null | undefined) => Arrowhead | null;
+export declare const getArrowheadForPicker: (arrowhead: AnyArrowhead | null | undefined) => Arrowhead | null;

package/dist/types/element/src/arrows/focus.d.ts

@@ -0,0 +1,30 @@
+import { type GlobalPoint } from "@excalidraw/math";
+import type { AppState, NullableGridSize } from "@excalidraw/excalidraw/types";
+import { LinearElementEditor } from "../linearElementEditor";
+import type { ElementsMap, ExcalidrawArrowElement, ExcalidrawBindableElement, FixedPointBinding, NonDeletedSceneElementsMap } from "../types";
+import type { Scene } from "../Scene";
+export declare const isFocusPointVisible: (focusPoint: GlobalPoint, arrow: ExcalidrawArrowElement, bindableElement: ExcalidrawBindableElement, elementsMap: ElementsMap, appState: {
+    isBindingEnabled: AppState["isBindingEnabled"];
+    zoom: AppState["zoom"];
+}, startOrEnd: "start" | "end", ignoreOverlap?: boolean) => boolean;
+export declare const handleFocusPointDrag: (linearElementEditor: LinearElementEditor, elementsMap: NonDeletedSceneElementsMap, pointerCoords: {
+    x: number;
+    y: number;
+}, scene: Scene, appState: AppState, gridSize: NullableGridSize, switchToInsideBinding: boolean) => void;
+export declare const handleFocusPointPointerDown: (arrow: ExcalidrawArrowElement, pointerDownState: {
+    origin: {
+        x: number;
+        y: number;
+    };
+}, elementsMap: NonDeletedSceneElementsMap, appState: AppState) => {
+    hitFocusPoint: "start" | "end" | null;
+    pointerOffset: {
+        x: number;
+        y: number;
+    };
+    arrowOtherEndpointInitialBinding: FixedPointBinding | null;
+};
+export declare const handleFocusPointPointerUp: (linearElementEditor: LinearElementEditor, scene: Scene) => {
+    arrowOtherEndpointInitialBinding: null;
+};
+export declare const handleFocusPointHover: (arrow: ExcalidrawArrowElement, scenePointerX: number, scenePointerY: number, scene: Scene, appState: AppState) => "start" | "end" | null;

package/dist/types/element/src/arrows/helpers.d.ts

@@ -0,0 +1,5 @@
+import type { App } from "@excalidraw/excalidraw/types";
+export declare const maybeHandleArrowPointlikeDrag: ({ app, event, }: {
+    app: App;
+    event: KeyboardEvent | React.KeyboardEvent<Element> | PointerEvent;
+}) => boolean;

package/dist/types/element/src/binding.d.ts

@@ -1,68 +1,87 @@
 import { type GlobalPoint } from "@excalidraw/math";
-import type { LocalPoint } from "@excalidraw/math";
-import type { AppState } from "@excalidraw/excalidraw/types";
+import type { LineSegment, LocalPoint } from "@excalidraw/math";
+import type { AppState, NullableGridSize } from "@excalidraw/excalidraw/types";
+import type { Bounds } from "@excalidraw/common";
 import { type Heading } from "./heading";
 import type { Scene } from "./Scene";
-import type { Bounds } from "./bounds";
 import type { ElementUpdate } from "./mutateElement";
-import type { ExcalidrawBindableElement, ExcalidrawElement, NonDeleted, ExcalidrawLinearElement, NonDeletedExcalidrawElement, ElementsMap, NonDeletedSceneElementsMap, ExcalidrawElbowArrowElement, FixedPoint } from "./types";
-export type SuggestedBinding = NonDeleted<ExcalidrawBindableElement> | SuggestedPointBinding;
-export type SuggestedPointBinding = [
-    NonDeleted<ExcalidrawLinearElement>,
-    "start" | "end" | "both",
-    NonDeleted<ExcalidrawBindableElement>
-];
-export declare const shouldEnableBindingForPointerEvent: (event: React.PointerEvent<HTMLElement>) => boolean;
-export declare const isBindingEnabled: (appState: AppState) => boolean;
-export declare const FIXED_BINDING_DISTANCE = 5;
-export declare const BINDING_HIGHLIGHT_THICKNESS = 10;
-export declare const bindOrUnbindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, startBindingElement: ExcalidrawBindableElement | null | "keep", endBindingElement: ExcalidrawBindableElement | null | "keep", scene: Scene) => void;
-export declare const bindOrUnbindLinearElements: (selectedElements: NonDeleted<ExcalidrawLinearElement>[], isBindingEnabled: boolean, draggingPoints: readonly number[] | null, scene: Scene, zoom?: AppState["zoom"]) => void;
-export declare const getSuggestedBindingsForArrows: (selectedElements: NonDeleted<ExcalidrawElement>[], elementsMap: NonDeletedSceneElementsMap, zoom: AppState["zoom"]) => SuggestedBinding[];
-export declare const maybeSuggestBindingsForLinearElementAtCoords: (linearElement: NonDeleted<ExcalidrawLinearElement>, pointerCoords: {
-    x: number;
-    y: number;
-}[], scene: Scene, zoom: AppState["zoom"], oppositeBindingBoundElement?: ExcalidrawBindableElement | null) => ExcalidrawBindableElement[];
-export declare const maybeBindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, appState: AppState, pointerCoords: {
-    x: number;
-    y: number;
-}, scene: Scene) => void;
-export declare const bindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", scene: Scene) => void;
-export declare const isLinearElementSimpleAndAlreadyBound: (linearElement: NonDeleted<ExcalidrawLinearElement>, alreadyBoundToId: ExcalidrawBindableElement["id"] | undefined, bindableElement: ExcalidrawBindableElement) => boolean;
-export declare const getHoveredElementForBinding: (pointerCoords: {
-    x: number;
-    y: number;
-}, elements: readonly NonDeletedExcalidrawElement[], elementsMap: NonDeletedSceneElementsMap, zoom?: AppState["zoom"], fullShape?: boolean, considerAllElements?: boolean) => NonDeleted<ExcalidrawBindableElement> | null;
+import type { BindMode, ElementsMap, ExcalidrawArrowElement, ExcalidrawBindableElement, ExcalidrawElbowArrowElement, ExcalidrawElement, FixedPoint, FixedPointBinding, NonDeleted, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap, Ordered, PointsPositionUpdates } from "./types";
+export type BindingStrategy = {
+    mode: BindMode;
+    element: NonDeleted<ExcalidrawBindableElement>;
+    focusPoint: GlobalPoint;
+} | {
+    mode: null;
+    element?: undefined;
+    focusPoint?: undefined;
+} | {
+    mode: undefined;
+    element?: undefined;
+    focusPoint?: undefined;
+};
+/**
+ * gaps exclude element strokeWidth
+ *
+ * IMPORTANT: currently must be > 0 (this also applies to the computed gap)
+ */
+export declare const BASE_BINDING_GAP = 5;
+export declare const BASE_BINDING_GAP_ELBOW = 5;
+export declare const BASE_ARROW_MIN_LENGTH = 10;
+export declare const FOCUS_POINT_SIZE: number;
+export declare const getBindingGap: (bindTarget: Pick<ExcalidrawBindableElement, "strokeWidth">, opts: Pick<ExcalidrawArrowElement, "elbowed">) => number;
+export declare const maxBindingDistance_simple: (zoom?: AppState["zoom"]) => number;
+export declare const isBindingEnabled: (appState: {
+    isBindingEnabled: AppState["isBindingEnabled"];
+}) => boolean;
+export declare const bindOrUnbindBindingElement: (arrow: NonDeleted<ExcalidrawArrowElement>, draggingPoints: PointsPositionUpdates, scenePointerX: number, scenePointerY: number, scene: Scene, appState: AppState, opts?: {
+    newArrow?: boolean;
+    altKey?: boolean;
+    angleLocked?: boolean;
+    initialBinding?: boolean;
+    gridSize?: NullableGridSize;
+}) => {
+    start: BindingStrategy;
+    end: BindingStrategy;
+};
+export declare const getBindingStrategyForDraggingBindingElementEndpoints: (arrow: NonDeleted<ExcalidrawArrowElement>, draggingPoints: PointsPositionUpdates, screenPointerX: number, screenPointerY: number, elementsMap: NonDeletedSceneElementsMap, elements: readonly Ordered<NonDeletedExcalidrawElement>[], appState: AppState, opts?: {
+    newArrow?: boolean;
+    angleLocked?: boolean;
+    altKey?: boolean;
+    finalize?: boolean;
+    initialBinding?: boolean;
+    zoom?: AppState["zoom"];
+    gridSize?: NullableGridSize;
+}) => {
+    start: BindingStrategy;
+    end: BindingStrategy;
+};
+export declare const bindOrUnbindBindingElements: (selectedArrows: NonDeleted<ExcalidrawArrowElement>[], scene: Scene, appState: AppState) => void;
+export declare const bindBindingElement: (arrow: NonDeleted<ExcalidrawArrowElement>, hoveredElement: NonDeleted<ExcalidrawBindableElement>, mode: BindMode, startOrEnd: "start" | "end", scene: Scene, focusPoint?: GlobalPoint, shouldSnapToOutline?: boolean, isMidpointSnappingEnabled?: boolean) => void;
+export declare const unbindBindingElement: (arrow: ExcalidrawArrowElement, startOrEnd: "start" | "end", scene: Scene) => ExcalidrawBindableElement["id"] | null;
 export declare const updateBoundElements: (changedElement: NonDeletedExcalidrawElement, scene: Scene, options?: {
-    simultaneouslyUpdated?: readonly ExcalidrawElement[];
-    newSize?: {
-        width: number;
-        height: number;
-    };
+    simultaneouslyUpdated?: readonly NonDeletedExcalidrawElement[];
     changedElements?: Map<string, ExcalidrawElement>;
 }) => void;
-export declare const updateBindings: (latestElement: ExcalidrawElement, scene: Scene, options?: {
-    simultaneouslyUpdated?: readonly ExcalidrawElement[];
+export declare const updateBindings: (latestElement: NonDeletedExcalidrawElement, scene: Scene, appState: AppState, options?: {
+    simultaneouslyUpdated?: readonly NonDeletedExcalidrawElement[];
     newSize?: {
         width: number;
         height: number;
     };
-    zoom?: AppState["zoom"];
 }) => void;
 export declare const getHeadingForElbowArrowSnap: (p: Readonly<GlobalPoint>, otherPoint: Readonly<GlobalPoint>, bindableElement: ExcalidrawBindableElement | undefined | null, aabb: Bounds | undefined | null, origPoint: GlobalPoint, elementsMap: ElementsMap, zoom?: AppState["zoom"]) => Heading;
-export declare const bindPointToSnapToElementOutline: (arrow: ExcalidrawElbowArrowElement, bindableElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap) => GlobalPoint;
-export declare const avoidRectangularCorner: (element: ExcalidrawBindableElement, elementsMap: ElementsMap, p: GlobalPoint) => GlobalPoint;
-export declare const snapToMid: (element: ExcalidrawBindableElement, elementsMap: ElementsMap, p: GlobalPoint, tolerance?: number) => GlobalPoint;
-export declare const calculateFixedPointForElbowArrowBinding: (linearElement: NonDeleted<ExcalidrawElbowArrowElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap) => {
+export declare const bindPointToSnapToElementOutline: (arrowElement: ExcalidrawArrowElement, bindableElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap, customIntersector?: LineSegment<GlobalPoint>, isMidpointSnappingEnabled?: boolean) => GlobalPoint;
+export declare const avoidRectangularCorner: (arrowElement: ExcalidrawArrowElement, bindTarget: ExcalidrawBindableElement, elementsMap: ElementsMap, p: GlobalPoint) => GlobalPoint;
+export declare const snapToMid: (bindTarget: ExcalidrawBindableElement, elementsMap: ElementsMap, p: GlobalPoint, tolerance?: number, arrowElement?: ExcalidrawArrowElement) => GlobalPoint | undefined;
+export declare const updateBoundPoint: (arrow: NonDeleted<ExcalidrawArrowElement>, startOrEnd: "startBinding" | "endBinding", binding: FixedPointBinding | null | undefined, bindableElement: ExcalidrawBindableElement, elementsMap: ElementsMap, dragging?: boolean) => LocalPoint | null;
+export declare const calculateFixedPointForElbowArrowBinding: (linearElement: NonDeleted<ExcalidrawElbowArrowElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap, shouldSnapToOutline?: boolean, isMidpointSnappingEnabled?: boolean) => {
+    fixedPoint: FixedPoint;
+};
+export declare const calculateFixedPointForNonElbowArrowBinding: (linearElement: NonDeleted<ExcalidrawArrowElement>, hoveredElement: NonDeleted<ExcalidrawBindableElement>, startOrEnd: "start" | "end", elementsMap: ElementsMap, focusPoint?: GlobalPoint) => {
     fixedPoint: FixedPoint;
 };
 export declare const fixDuplicatedBindingsAfterDuplication: (duplicatedElements: ExcalidrawElement[], origIdToDuplicateId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>, duplicateElementsMap: NonDeletedSceneElementsMap) => void;
 export declare const fixBindingsAfterDeletion: (sceneElements: readonly ExcalidrawElement[], deletedElements: readonly ExcalidrawElement[]) => void;
-export declare const bindingBorderTest: (element: NonDeleted<ExcalidrawBindableElement>, { x, y }: {
-    x: number;
-    y: number;
-}, elementsMap: NonDeletedSceneElementsMap, zoom?: AppState["zoom"], fullShape?: boolean) => boolean;
-export declare const maxBindingGap: (element: ExcalidrawElement, elementWidth: number, elementHeight: number, zoom?: AppState["zoom"]) => number;
 export declare const bindingProperties: Set<BindableProp | BindingProp>;
 export type BindableProp = "boundElements";
 export type BindingProp = "frameId" | "containerId" | "startBinding" | "endBinding";
@@ -104,7 +123,16 @@ export declare class BindableElement {
      */
     static rebindAffected: (elements: ElementsMap, bindableElement: ExcalidrawElement | undefined, updateElementWith: (affected: ExcalidrawElement, updates: ElementUpdate<ExcalidrawElement>) => void) => void;
 }
-export declare const getGlobalFixedPointForBindableElement: (fixedPointRatio: [number, number], element: ExcalidrawBindableElement, elementsMap: ElementsMap) => GlobalPoint;
-export declare const getGlobalFixedPoints: (arrow: ExcalidrawElbowArrowElement, elementsMap: ElementsMap) => [GlobalPoint, GlobalPoint];
+export declare const getGlobalFixedPointForBindableElement: (fixedPointRatio: FixedPoint, element: ExcalidrawBindableElement, elementsMap: ElementsMap) => GlobalPoint;
+export declare const getGlobalFixedPoints: (arrow: ExcalidrawArrowElement, elementsMap: ElementsMap) => [GlobalPoint, GlobalPoint];
 export declare const getArrowLocalFixedPoints: (arrow: ExcalidrawElbowArrowElement, elementsMap: ElementsMap) => LocalPoint[];
-export declare const normalizeFixedPoint: <T extends FixedPoint | null>(fixedPoint: T) => T extends null ? null : FixedPoint;
+export declare const isFixedPoint: (fixedPoint: any) => fixedPoint is FixedPointBinding["fixedPoint"];
+export declare const normalizeFixedPoint: <T extends FixedPoint>(fixedPoint: T) => FixedPoint;
+export declare const getBindingSideMidPoint: (binding: FixedPointBinding, elementsMap: ElementsMap) => GlobalPoint | LocalPoint | null;
+/**
+ * Binds an arrow endpoint to an explicit fixed point on a bindable element,
+ * bypassing the "derive the ratio from where the endpoint currently is"
+ * strategy used when dragging. Needed when the binding target is placed to fit
+ * the arrow rather than the other way round.
+ */
+export declare const bindBindingElementToFixedPoint: (arrow: NonDeleted<ExcalidrawArrowElement>, bindableElement: NonDeleted<ExcalidrawBindableElement>, startOrEnd: "start" | "end", fixedPoint: FixedPoint, scene: Scene) => void;

package/dist/types/element/src/bounds.d.ts

@@ -1,7 +1,8 @@
+import { type Bounds } from "@excalidraw/common";
 import type { Degrees, GlobalPoint, LineSegment, LocalPoint } from "@excalidraw/math";
 import type { AppState } from "@excalidraw/excalidraw/types";
 import type { Drawable, Op } from "roughjs/bin/core";
-import type { Arrowhead, ElementsMap, ElementsMapOrArray, ExcalidrawElement, ExcalidrawFreeDrawElement, ExcalidrawLinearElement, NonDeleted } from "./types";
+import type { Arrowhead, ElementsMap, ElementsMapOrArray, ExcalidrawElement, ExcalidrawLinearElement, NonDeleted, NonDeletedExcalidrawElement } from "./types";
 export type RectangleBox = {
     x: number;
     y: number;
@@ -9,15 +10,6 @@ export type RectangleBox = {
     height: number;
     angle: number;
 };
-/**
- * x and y position of top left corner, x and y position of bottom right corner
- */
-export type Bounds = readonly [
-    minX: number,
-    minY: number,
-    maxX: number,
-    maxY: number
-];
 export type SceneBounds = readonly [
     sceneX: number,
     sceneY: number,
@@ -45,25 +37,21 @@ export declare const getElementLineSegments: (element: ExcalidrawElement, elemen
 export declare const getRectangleBoxAbsoluteCoords: (boxSceneCoords: RectangleBox) => number[];
 export declare const getDiamondPoints: (element: ExcalidrawElement) => number[];
 export declare const getCubicBezierCurveBound: (p0: GlobalPoint, p1: GlobalPoint, p2: GlobalPoint, p3: GlobalPoint) => Bounds;
-export declare const getMinMaxXYFromCurvePathOps: (ops: Op[], transformXY?: ((p: GlobalPoint) => GlobalPoint) | undefined) => Bounds;
-export declare const getBoundsFromPoints: (points: ExcalidrawFreeDrawElement["points"]) => Bounds;
+export declare const getMinMaxXYFromCurvePathOps: (ops: Op[], transformXY?: (p: GlobalPoint) => GlobalPoint) => Bounds;
+export declare const getBoundsFromPoints: <P extends GlobalPoint | LocalPoint>(points: readonly P[], padding?: number) => Bounds;
 /** @returns number in pixels */
 export declare const getArrowheadSize: (arrowhead: Arrowhead) => number;
 /** @returns number in degrees */
 export declare const getArrowheadAngle: (arrowhead: Arrowhead) => Degrees;
-export declare const getArrowheadPoints: (element: ExcalidrawLinearElement, shape: Drawable[], position: "start" | "end", arrowhead: Arrowhead) => number[] | null;
+export declare const getArrowheadPoints: (element: ExcalidrawLinearElement, shape: Drawable[], position: "start" | "end", arrowhead: Arrowhead, offsetMultiplier?: number) => number[] | null;
 export declare const getElementBounds: (element: ExcalidrawElement, elementsMap: ElementsMap, nonRotated?: boolean) => Bounds;
 export declare const getCommonBounds: (elements: ElementsMapOrArray, elementsMap?: ElementsMap) => Bounds;
-export declare const getDraggedElementsBounds: (elements: ExcalidrawElement[], dragOffset: {
+export declare const getDraggedElementsBounds: (elements: readonly NonDeletedExcalidrawElement[], dragOffset: {
     x: number;
     y: number;
 }) => number[];
 export declare const getResizedElementAbsoluteCoords: (element: ExcalidrawElement, nextWidth: number, nextHeight: number, normalizePoints: boolean) => Bounds;
 export declare const getElementPointsCoords: (element: ExcalidrawLinearElement, points: readonly (readonly [number, number])[]) => Bounds;
-export declare const getClosestElementBounds: (elements: readonly ExcalidrawElement[], from: {
-    x: number;
-    y: number;
-}) => Bounds;
 export interface BoundingBox {
     minX: number;
     minY: number;
@@ -85,5 +73,24 @@ export declare const getCenterForBounds: (bounds: Bounds) => GlobalPoint;
  */
 export declare const aabbForElement: (element: Readonly<ExcalidrawElement>, elementsMap: ElementsMap, offset?: [number, number, number, number]) => Bounds;
 export declare const pointInsideBounds: <P extends GlobalPoint | LocalPoint>(p: P, bounds: Bounds) => boolean;
+export declare const pointInsideBoundsInclusive: <P extends GlobalPoint | LocalPoint>(p: P, bounds: Bounds) => boolean;
 export declare const doBoundsIntersect: (bounds1: Bounds | null, bounds2: Bounds | null) => boolean;
+export declare const boundsContainBounds: (outerBounds: Bounds, innerBounds: Bounds) => boolean;
+/**
+ * High level helper to get elements overlapping a bounding box.
+ * It can be used to get elements overlapping a selection box, for example.
+ *
+ */
+export declare const elementsOverlappingBBox: <T extends ExcalidrawElement>({ elements, elementsMap, bounds, type, excludeElementsInFrames, shouldIgnoreElementFromSelection, }: {
+    elements: readonly T[];
+    elementsMap?: ElementsMap;
+    bounds: Bounds | ExcalidrawElement;
+    /**
+     * - overlap: elements overlapping or inside bounds
+     * - contain: elements inside bounds
+     **/
+    type: "contain" | "overlap";
+    excludeElementsInFrames?: boolean;
+    shouldIgnoreElementFromSelection?: (element: T) => boolean;
+}) => T[];
 export declare const elementCenterPoint: (element: ExcalidrawElement, elementsMap: ElementsMap, xOffset?: number, yOffset?: number) => GlobalPoint;

package/dist/types/element/src/bucketFill.d.ts

@@ -0,0 +1,110 @@
+import type { GlobalPoint } from "@excalidraw/math";
+import type { ElementsMap, ExcalidrawElement, ExcalidrawLineElement, NonDeletedExcalidrawElement } from "./types";
+export type BucketFillOptions = {
+    /**
+     * geometric fidelity: vertices closer than this collapse to the same graph
+     * node, and a node this close to a stroke splits it (T-junction). Keep
+     * SMALL — every merge can relocate a vertex by up to this distance, so
+     * this value is the upper bound on how far the filled shape may deviate
+     * from the actual strokes.
+     */
+    snapEpsilon: number;
+    /**
+     * connectivity: loose stroke ends within this distance of another stroke
+     * are bridged with a connector edge so the region reads as closed. Also
+     * used as broad-phase padding around the owner bounds. Unlike
+     * `snapEpsilon` this does not affect the shape's fidelity (bridges add
+     * edges; they never move existing vertices).
+     */
+    gapTolerance: number;
+    /** discard faces / polygons smaller than this absolute area */
+    minArea: number;
+    /** bail out with `too_complex` above this many input segments */
+    maxBoundarySegments: number;
+    /** cap on the number of generated polygon points */
+    maxGeneratedPoints: number;
+    /**
+     * initial half-extent of the owner-less search box around the click
+     * (doubles up to 3 times while the found face touches the box frontier)
+     */
+    fallbackSearchRadius: number;
+};
+export declare const DEFAULT_BUCKET_FILL_OPTIONS: BucketFillOptions;
+export type BucketFillFailureReason = "no_owner" | "open_region" | "too_complex" | "too_small" | "invalid_polygon";
+/**
+ * Where the generated fill element belongs in the scene order, expressed
+ * relative to an existing element so the caller can resolve it against
+ * whatever (e.g. deleted-inclusive) array it inserts into.
+ */
+export type BucketFillInsertion = {
+    placement: "above" | "below";
+    elementId: ExcalidrawElement["id"];
+};
+export type BucketFillGeometryResult = {
+    ok: true;
+    /**
+     * the closed element under the click, or null for fills resolved by
+     * the owner-less fallback (regions formed by open lines)
+     */
+    ownerId: ExcalidrawElement["id"] | null;
+    boundaryElementIds: ExcalidrawElement["id"][];
+    /**
+     * closed polygon ring in scene coordinates. When the region contains
+     * islands, this is a keyhole path: the hole contours are spliced in
+     * via zero-width bridges, so it still renders as one polygon with
+     * unpainted hole interiors
+     */
+    scenePoints: GlobalPoint[];
+    insertion: BucketFillInsertion;
+} | {
+    ok: false;
+    reason: BucketFillFailureReason;
+};
+/**
+ * Whether the element visually paints an opaque background fill — i.e. can
+ * actually hide outlines beneath it. Element types that never render their
+ * `backgroundColor` (text, image, frames), see-through fill styles
+ * (hachure/cross-hatch), partial element opacity, and colors with an alpha
+ * channel below 1 (`#RRGGBBAA`, `rgba(…)`) all don't count — anything under
+ * them shows through.
+ *
+ * Shared with the app layer's z-order pass so "covers" means the same thing
+ * in boundary clipping and in fill insertion.
+ */
+export declare const rendersOpaqueFill: (element: ExcalidrawElement) => boolean;
+/**
+ * Whether the element renders as pure paint the bucket tool could have
+ * produced: a closed, visible line polygon with a background and no visible
+ * stroke. Recognition is by SHAPE, not by a metadata marker — any marker
+ * would go stale the moment the user restyles a fill, and a hand-drawn
+ * strokeless background polygon is indistinguishable from a generated fill
+ * anyway. Such paint never becomes an owner and is what the app layer
+ * restyles in place on re-click (see `isRestylableFill`).
+ */
+export declare const isBucketFillCompatible: (element: ExcalidrawElement) => element is ExcalidrawLineElement;
+export declare const computeBucketFillPolygon: (args: {
+    point: GlobalPoint;
+    elements: readonly NonDeletedExcalidrawElement[];
+    elementsMap: ElementsMap;
+    options?: Partial<BucketFillOptions>;
+}) => BucketFillGeometryResult;
+/**
+ * Whether the element the click landed on is a fill the bucket tool should
+ * restyle in place (instead of stacking an identical fill on top), given
+ * the computed region.
+ *
+ * Fill-compatibility is decided by shape (`isBucketFillCompatible`): a fill
+ * the user gave a stroke to has been repurposed into an outline and
+ * participates as a boundary instead of being restyled.
+ *
+ * One guard on top: the computed region's net area and bounds must match
+ * the element's. Without it, a click inside a shape drawn ON TOP of a
+ * filled region would recolor the underlying fill instead of filling that
+ * shape; a click on a since-subdivided part of an old fill likewise
+ * creates a new (smaller) fill rather than restyling the old one.
+ */
+export declare const isRestylableFill: (args: {
+    hitElement: ExcalidrawElement;
+    scenePoints: readonly GlobalPoint[];
+    elementsMap: ElementsMap;
+}) => boolean;

package/dist/types/element/src/collision.d.ts

@@ -1,6 +1,6 @@
 import type { GlobalPoint, LineSegment } from "@excalidraw/math";
 import type { FrameNameBounds } from "@excalidraw/excalidraw/types";
-import type { ElementsMap, ExcalidrawElement } from "./types";
+import type { ElementsMap, ExcalidrawArrowElement, ExcalidrawBindableElement, ExcalidrawElement, NonDeleted, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap, Ordered } from "./types";
 export declare const shouldTestInside: (element: ExcalidrawElement) => boolean;
 export type HitTestArgs = {
     point: GlobalPoint;
@@ -8,11 +8,15 @@ export type HitTestArgs = {
     threshold: number;
     elementsMap: ElementsMap;
     frameNameBound?: FrameNameBounds | null;
+    overrideShouldTestInside?: boolean;
 };
-export declare const hitElementItself: ({ point, element, threshold, elementsMap, frameNameBound, }: HitTestArgs) => boolean;
+export declare const hitElementItself: ({ point, element, threshold, elementsMap, frameNameBound, overrideShouldTestInside, }: HitTestArgs) => boolean;
 export declare const hitElementBoundingBox: (point: GlobalPoint, element: ExcalidrawElement, elementsMap: ElementsMap, tolerance?: number) => boolean;
 export declare const hitElementBoundingBoxOnly: (hitArgs: HitTestArgs, elementsMap: ElementsMap) => boolean;
 export declare const hitElementBoundText: (point: GlobalPoint, element: ExcalidrawElement, elementsMap: ElementsMap) => boolean;
+export declare const getAllHoveredElementAtPoint: (point: Readonly<GlobalPoint>, elements: readonly Ordered<NonDeletedExcalidrawElement>[], elementsMap: NonDeletedSceneElementsMap, tolerance?: number) => NonDeleted<ExcalidrawBindableElement>[];
+export declare const getHoveredElementForBinding: (point: Readonly<GlobalPoint>, elements: readonly Ordered<NonDeletedExcalidrawElement>[], elementsMap: NonDeletedSceneElementsMap, tolerance?: number) => NonDeleted<ExcalidrawBindableElement> | null;
+export declare const getHoveredElementForFocusPoint: (point: GlobalPoint, arrow: ExcalidrawArrowElement, elements: readonly Ordered<NonDeletedExcalidrawElement>[], elementsMap: NonDeletedSceneElementsMap, tolerance?: number) => NonDeleted<ExcalidrawBindableElement> | null;
 /**
  * Intersect a line with an element for binding test
  *
@@ -30,3 +34,4 @@ export declare const intersectElementWithLineSegment: (element: ExcalidrawElemen
  * @returns
  */
 export declare const isPointInElement: (point: GlobalPoint, element: ExcalidrawElement, elementsMap: ElementsMap) => boolean;
+export declare const isBindableElementInsideOtherBindable: (innerElement: ExcalidrawBindableElement, outerElement: ExcalidrawBindableElement, elementsMap: ElementsMap) => boolean;

package/dist/types/element/src/comparisons.d.ts

@@ -1,8 +1,11 @@
 import type { ElementOrToolType } from "@excalidraw/excalidraw/types";
-export declare const hasBackground: (type: ElementOrToolType) => boolean;
-export declare const hasStrokeColor: (type: ElementOrToolType) => boolean;
-export declare const hasStrokeWidth: (type: ElementOrToolType) => boolean;
-export declare const hasStrokeStyle: (type: ElementOrToolType) => boolean;
-export declare const canChangeRoundness: (type: ElementOrToolType) => boolean;
-export declare const toolIsArrow: (type: ElementOrToolType) => boolean;
-export declare const canHaveArrowheads: (type: ElementOrToolType) => boolean;
+export declare const hasBackground: (type: ElementOrToolType) => type is "line" | "rectangle" | "stickynote" | "diamond" | "ellipse" | "embeddable" | "iframe" | "freedraw" | "autoshape" | "bucketfill";
+export declare const hasFillStyle: (type: ElementOrToolType) => type is "line" | "rectangle" | "diamond" | "ellipse" | "embeddable" | "iframe" | "freedraw" | "autoshape" | "bucketfill";
+export declare const hasStrokeColor: (type: ElementOrToolType) => type is "line" | "arrow" | "text" | "rectangle" | "stickynote" | "diamond" | "ellipse" | "embeddable" | "freedraw" | "autoshape";
+export declare const hasStrokeWidth: (type: ElementOrToolType) => type is "line" | "arrow" | "rectangle" | "diamond" | "ellipse" | "embeddable" | "iframe" | "freedraw" | "autoshape";
+export declare const hasStrokeStyle: (type: ElementOrToolType) => type is "line" | "arrow" | "rectangle" | "diamond" | "ellipse" | "embeddable" | "iframe" | "autoshape";
+export declare const hasRoughness: (type: ElementOrToolType) => type is "line" | "arrow" | "rectangle" | "stickynote" | "diamond" | "ellipse" | "embeddable" | "iframe" | "autoshape";
+export declare const hasFreedrawMode: (type: ElementOrToolType) => type is "freedraw";
+export declare const canChangeRoundness: (type: ElementOrToolType) => type is "line" | "rectangle" | "stickynote" | "diamond" | "embeddable" | "iframe" | "image";
+export declare const toolIsArrow: (type: ElementOrToolType) => type is "arrow";
+export declare const canHaveArrowheads: (type: ElementOrToolType) => type is "arrow";

package/dist/types/element/src/convertToShape.d.ts

@@ -0,0 +1,23 @@
+import type { App, AppState } from "@excalidraw/excalidraw/types";
+import type { LocalPoint, GlobalPoint } from "@excalidraw/math";
+import type { Bounds } from "@excalidraw/common";
+import type { ExcalidrawArrowElement, ExcalidrawDiamondElement, ExcalidrawElement, ExcalidrawEllipseElement, ExcalidrawFreeDrawElement, ExcalidrawFrameLikeElement, ExcalidrawRectangleElement, ElementsMap, NonDeleted, ExcalidrawLineElement } from "@excalidraw/element/types";
+declare global {
+    interface Window {
+        LAST_POINTS?: readonly GlobalPoint[];
+    }
+}
+type NonDeletedRecognizedShapeElement = NonDeleted<ExcalidrawRectangleElement | ExcalidrawEllipseElement | ExcalidrawDiamondElement | ExcalidrawArrowElement | ExcalidrawLineElement | ExcalidrawFreeDrawElement>;
+type Shape = NonDeletedRecognizedShapeElement["type"];
+interface ShapeRecognitionResult<P extends LocalPoint | GlobalPoint> {
+    type: Shape;
+    points: readonly P[];
+    boundingBox: Bounds;
+}
+export declare const recognizeShape: <P extends LocalPoint | GlobalPoint>(points: P[], previousElement: ExcalidrawElement | null, zoom?: number) => ShapeRecognitionResult<P>;
+export declare const convertToShape: (points: GlobalPoint[], appState: AppState, elementsMap: ElementsMap, previousElement: ExcalidrawElement | null, frames?: readonly ExcalidrawFrameLikeElement[]) => NonDeletedRecognizedShapeElement | undefined;
+export declare const convertToShapeHandlePointerMoveFromPointerDown: (app: App, pointerCoords: {
+    x: number;
+    y: number;
+}) => boolean;
+export {};

package/dist/types/element/src/delta.d.ts

@@ -192,7 +192,29 @@ export declare class ElementsDelta implements DeltaContainer<SceneElementsMap> {
     private static createGetter;
     private static applyDelta;
     /**
-     * Check for visible changes regardless of whether they were removed, added or updated.
+     * Whether an element looks different after the delta — and the layout that
+     * followed it — was applied. The input to history's "skip entries with no
+     * visible change" loop.
+     *
+     * Both sides are first reduced to what actually paints:
+     * - a missing or deleted element paints nothing;
+     * - an empty text element paints nothing either — unless it carries arrow
+     *   bindings (an arrow may end at it) or sits on an arrow (an empty label
+     *   still cuts the arrow's gap);
+     * so an empty label's deletion or restoration compares as nothing against
+     * nothing. Two painting elements are then compared property by property:
+     * - `version`, `versionNonce`, `updated`, `created` are metadata, and
+     *   `index` is covered by the separate z-order check (`reorderElements`);
+     * - `boundElements` is compared as `type:id` references with references to
+     *   empty labels dropped, so adding or removing an empty label's reference
+     *   is not visible on its own, and binding repair that rebuilt equal
+     *   objects is not either;
+     * - everything else counts. Nested arrays (`points`, binding fixed points)
+     *   compare by reference, which can only over-report a change — the safe
+     *   direction, where undo stops one entry early.
+     *
+     * `previousElements` holds only `idsToCheck` (see `applyTo`); the label
+     * lookups it serves are for elements whose labels are in that set.
      */
     private static checkForVisibleDifference;
     /**