@excalidraw/common 0.18.0-3bdaafe → 0.18.0-3c916c5

package/dist/types/common/src/versionedSnapshotStore.d.ts

@@ -0,0 +1,17 @@
+export type VersionedSnapshot<T> = Readonly<{
+    version: number;
+    value: T;
+}>;
+export declare class VersionedSnapshotStore<T> {
+    private readonly isEqual;
+    private version;
+    private value;
+    private readonly waiters;
+    private readonly subscribers;
+    constructor(initialValue: T, isEqual?: (prev: T, next: T) => boolean);
+    getSnapshot(): VersionedSnapshot<T>;
+    set(nextValue: T): boolean;
+    update(updater: (prev: T) => T): boolean;
+    subscribe(subscriber: (snapshot: VersionedSnapshot<T>) => void): () => void;
+    pull(sinceVersion?: number): Promise<VersionedSnapshot<T>>;
+}

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,11 @@
 import type { AppState } from "@excalidraw/excalidraw/types";
+import type { RenderEnvironment } from "./renderEnvironment";
 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>, 
+/** measures the labels of the bound arrows the alignment moves */
+renderEnvironment?: RenderEnvironment) => 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,155 @@
 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 { RenderEnvironment } from "./renderEnvironment";
 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: {
+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_ARROW_MIN_LENGTH = 10;
+export declare const FOCUS_POINT_SIZE: number;
+export declare const getBindingGap: (bindTarget: Pick<ExcalidrawBindableElement, "strokeWidth">) => 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;
+    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, zoom: AppState["zoom"], focusPoint?: GlobalPoint, shouldSnapToOutline?: boolean, isMidpointSnappingEnabled?: boolean) => void;
+/**
+ * Whether the arrow's end is bound to an element it's beyond the binding area
+ * of, i.e. that it couldn't be bound to in the editor (e.g. a participant's
+ * header in a sequence diagram, as laid out by mermaid)
+ */
+export declare const isEndBoundBeyondBindingArea: (arrow: ExcalidrawArrowElement, startOrEnd: "start" | "end", elementsMap: NonDeletedSceneElementsMap, zoom: AppState["zoom"]) => boolean;
+/**
+ * Extends the arrow's bound end along its end segment, by the segment's length
+ * (at least MIN_BOUND_END_EXTENSION), to find where it would reach the element
+ * it's bound to, off the element by the binding gap. Moving the end there
+ * restores bindings given to arrows that just fall short of their elements.
+ *
+ * @returns where to move the end to, or null if it doesn't reach the element
+ */
+export declare const getBoundEndExtension: (arrow: ExcalidrawArrowElement, startOrEnd: "start" | "end", elementsMap: NonDeletedSceneElementsMap) => GlobalPoint | null;
+export declare const unbindBindingElement: (arrow: ExcalidrawArrowElement, startOrEnd: "start" | "end", scene: Scene) => ExcalidrawBindableElement["id"] | null;
+export declare const reanchorBindingsToOutline: (changedElement: NonDeleted<ExcalidrawBindableElement>, scene: Scene, zoom: AppState["zoom"]) => void;
+/**
+ * Places both bound ends of `arrow` where its bindings put them on the elements
+ * in `elementsMap` they're bound to, and rewraps its label along it as placed.
+ * Leaves the label's x/y as they were (the editor derives arrow labels' x/y as
+ * it renders them), so callers returning the elements as data must store them
+ * (see `LinearElementEditor.getBoundTextElementPosition`).
+ */
+export declare const updateBoundArrow: (arrow: NonDeleted<ExcalidrawArrowElement>, scene: Scene, elementsMap: ElementsMap, 
+/** measures the arrow's label */
+renderEnvironment?: RenderEnvironment, 
+/**
+ * whether it's placed as what it's bound to moved: an arrow bound to one
+ * element at both ends then moves with it whole (its midpoints with its
+ * start), rather than only at its ends
+ */
+boundElementMoved?: boolean) => void;
+/** Whether `arrow` is bound to an element not in `elementIds`. */
+export declare const isBoundToElementNotIn: (arrow: ExcalidrawArrowElement, elementIds: ReadonlySet<ExcalidrawElement["id"]>) => boolean;
+/**
+ * The arrows that move with a frame being moved (with `movedElements`) but are
+ * bound to elements that don't (e.g. in other frames). They must neither be
+ * unbound, nor be left for what they're bound to to move: move everything
+ * else without them, and then them, with `moveFrameArrows()`.
+ *
+ * @param movedElements all the elements moving, frames included
+ */
+export declare const getFrameArrowIdsToReattach: (movedElements: readonly ExcalidrawElement[]) => ReadonlySet<ExcalidrawElement["id"]>;
+/**
+ * Moves the arrows (see `getFrameArrowIdsToReattach()`) by `offset` from where
+ * they were in `originalElements` (from where they are, without it), and puts
+ * their bound ends on what they're bound to: an end bound to a moved element
+ * thus follows it, and one bound to an unmoved element stays. Call it once
+ * everything else has moved.
+ */
+export declare const moveFrameArrows: (arrowIds: ReadonlySet<ExcalidrawElement["id"]>, offset: {
     x: number;
     y: number;
-}, elements: readonly NonDeletedExcalidrawElement[], elementsMap: NonDeletedSceneElementsMap, zoom?: AppState["zoom"], fullShape?: boolean, considerAllElements?: boolean) => NonDeleted<ExcalidrawBindableElement> | null;
+}, scene: Scene, opts?: {
+    originalElements?: ElementsMap;
+    /** measures the arrows' labels */
+    renderEnvironment?: RenderEnvironment;
+}) => void;
 export declare const updateBoundElements: (changedElement: NonDeletedExcalidrawElement, scene: Scene, options?: {
-    simultaneouslyUpdated?: readonly ExcalidrawElement[];
-    newSize?: {
-        width: number;
-        height: number;
-    };
+    /** see `getSimultaneouslyUpdatedElementIds` for how to pass it */
+    simultaneouslyUpdated?: readonly NonDeletedExcalidrawElement[];
     changedElements?: Map<string, ExcalidrawElement>;
+    /** measures the labels of the arrows it updates (the host's, in the editor) */
+    renderEnvironment?: RenderEnvironment;
 }) => 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"];
+    /** measures the labels of the bound arrows it updates */
+    renderEnvironment?: RenderEnvironment;
 }) => void;
+/**
+ * The id set of `simultaneouslyUpdated`, shared by every `updateBoundElements()`
+ * call given the same array. Pass one array instance for all elements of an
+ * operation, and don't change its membership after the first lookup, or the
+ * cached ids go stale.
+ */
+export declare const getSimultaneouslyUpdatedElementIds: (simultaneouslyUpdated: readonly ExcalidrawElement[] | undefined) => ReadonlySet<ExcalidrawElement["id"]>;
 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, zoom: AppState["zoom"], customIntersector?: LineSegment<GlobalPoint>, isMidpointSnappingEnabled?: boolean) => GlobalPoint;
+export declare const avoidRectangularCorner: (arrowElement: ExcalidrawArrowElement, bindTarget: ExcalidrawBindableElement, elementsMap: ElementsMap, p: GlobalPoint) => GlobalPoint;
+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, zoom: AppState["zoom"], 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 +191,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,27 @@ 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;
+export declare const CARDINALITY_ONE_OR_MANY_BAR_OFFSET = -0.25;
+export declare const CARDINALITY_INNER_BAR_OFFSET = -0.5;
+export declare const CARDINALITY_ZERO_CIRCLE_OFFSET = 1.5;
+export declare const CARDINALITY_ZERO_CIRCLE_SCALE = 0.8;
 /** @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 getArrowheadAngle: (arrowhead: Arrowhead, 
+/** size the arrowhead is drawn at, if scaled down */
+size?: number) => Degrees;
+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 +79,26 @@ 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, includeStroke, }: {
+    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;
+    /** whether elements extend by their stroke, as they render */
+    includeStroke?: 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;