@excalidraw/excalidraw 0.17.1-7441-4e2c539 → 0.17.1-a38e82f

package/dist/excalidraw/element/binding.js

@@ -23,11 +23,11 @@ const getNonDeletedElements = (scene, ids) => {
     });
     return result;
 };
-export const bindOrUnbindLinearElement = (linearElement, startBindingElement, endBindingElement) => {
+export const bindOrUnbindLinearElement = (linearElement, startBindingElement, endBindingElement, elementsMap) => {
     const boundToElementIds = new Set();
     const unboundFromElementIds = new Set();
-    bindOrUnbindLinearElementEdge(linearElement, startBindingElement, endBindingElement, "start", boundToElementIds, unboundFromElementIds);
-    bindOrUnbindLinearElementEdge(linearElement, endBindingElement, startBindingElement, "end", boundToElementIds, unboundFromElementIds);
+    bindOrUnbindLinearElementEdge(linearElement, startBindingElement, endBindingElement, "start", boundToElementIds, unboundFromElementIds, elementsMap);
+    bindOrUnbindLinearElementEdge(linearElement, endBindingElement, startBindingElement, "end", boundToElementIds, unboundFromElementIds, elementsMap);
     const onlyUnbound = Array.from(unboundFromElementIds).filter((id) => !boundToElementIds.has(id));
     getNonDeletedElements(Scene.getScene(linearElement), onlyUnbound).forEach((element) => {
         mutateElement(element, {
@@ -39,7 +39,7 @@ const bindOrUnbindLinearElementEdge = (linearElement, bindableElement, otherEdge
 // Is mutated
 boundToElementIds, 
 // Is mutated
-unboundFromElementIds) => {
+unboundFromElementIds, elementsMap) => {
     if (bindableElement !== "keep") {
         if (bindableElement != null) {
             // Don't bind if we're trying to bind or are already bound to the same
@@ -49,7 +49,7 @@ unboundFromElementIds) => {
                     ? !isLinearElementSimpleAndAlreadyBoundOnOppositeEdge(linearElement, bindableElement, startOrEnd)
                     : startOrEnd === "start" ||
                         otherEdgeBindableElement.id !== bindableElement.id)) {
-                bindLinearElement(linearElement, bindableElement, startOrEnd);
+                bindLinearElement(linearElement, bindableElement, startOrEnd, elementsMap);
                 boundToElementIds.add(bindableElement.id);
             }
         }
@@ -61,34 +61,34 @@ unboundFromElementIds) => {
         }
     }
 };
-export const bindOrUnbindSelectedElements = (elements) => {
-    elements.forEach((element) => {
-        if (isBindingElement(element)) {
-            bindOrUnbindLinearElement(element, getElligibleElementForBindingElement(element, "start"), getElligibleElementForBindingElement(element, "end"));
+export const bindOrUnbindSelectedElements = (selectedElements, elements, elementsMap) => {
+    selectedElements.forEach((selectedElement) => {
+        if (isBindingElement(selectedElement)) {
+            bindOrUnbindLinearElement(selectedElement, getElligibleElementForBindingElement(selectedElement, "start", elements, elementsMap), getElligibleElementForBindingElement(selectedElement, "end", elements, elementsMap), elementsMap);
         }
-        else if (isBindableElement(element)) {
-            maybeBindBindableElement(element);
+        else if (isBindableElement(selectedElement)) {
+            maybeBindBindableElement(selectedElement, elementsMap);
         }
     });
 };
-const maybeBindBindableElement = (bindableElement) => {
-    getElligibleElementsForBindableElementAndWhere(bindableElement).forEach(([linearElement, where]) => bindOrUnbindLinearElement(linearElement, where === "end" ? "keep" : bindableElement, where === "start" ? "keep" : bindableElement));
+const maybeBindBindableElement = (bindableElement, elementsMap) => {
+    getElligibleElementsForBindableElementAndWhere(bindableElement, elementsMap).forEach(([linearElement, where]) => bindOrUnbindLinearElement(linearElement, where === "end" ? "keep" : bindableElement, where === "start" ? "keep" : bindableElement, elementsMap));
 };
-export const maybeBindLinearElement = (linearElement, appState, scene, pointerCoords) => {
+export const maybeBindLinearElement = (linearElement, appState, scene, pointerCoords, elementsMap) => {
     if (appState.startBoundElement != null) {
-        bindLinearElement(linearElement, appState.startBoundElement, "start");
+        bindLinearElement(linearElement, appState.startBoundElement, "start", elementsMap);
     }
-    const hoveredElement = getHoveredElementForBinding(pointerCoords, scene);
+    const hoveredElement = getHoveredElementForBinding(pointerCoords, scene.getNonDeletedElements(), elementsMap);
     if (hoveredElement != null &&
         !isLinearElementSimpleAndAlreadyBoundOnOppositeEdge(linearElement, hoveredElement, "end")) {
-        bindLinearElement(linearElement, hoveredElement, "end");
+        bindLinearElement(linearElement, hoveredElement, "end", elementsMap);
     }
 };
-export const bindLinearElement = (linearElement, hoveredElement, startOrEnd) => {
+export const bindLinearElement = (linearElement, hoveredElement, startOrEnd, elementsMap) => {
     mutateElement(linearElement, {
         [startOrEnd === "start" ? "startBinding" : "endBinding"]: {
             elementId: hoveredElement.id,
-            ...calculateFocusAndGap(linearElement, hoveredElement, startOrEnd),
+            ...calculateFocusAndGap(linearElement, hoveredElement, startOrEnd, elementsMap),
         },
     });
     const boundElementsMap = arrayToMap(hoveredElement.boundElements || []);
@@ -109,10 +109,10 @@ const isLinearElementSimpleAndAlreadyBoundOnOppositeEdge = (linearElement, binda
 export const isLinearElementSimpleAndAlreadyBound = (linearElement, alreadyBoundToId, bindableElement) => {
     return (alreadyBoundToId === bindableElement.id && linearElement.points.length < 3);
 };
-export const unbindLinearElements = (elements) => {
+export const unbindLinearElements = (elements, elementsMap) => {
     elements.forEach((element) => {
         if (isBindingElement(element)) {
-            bindOrUnbindLinearElement(element, null, null);
+            bindOrUnbindLinearElement(element, null, null, elementsMap);
         }
     });
 };
@@ -125,20 +125,20 @@ const unbindLinearElement = (linearElement, startOrEnd) => {
     mutateElement(linearElement, { [field]: null });
     return binding.elementId;
 };
-export const getHoveredElementForBinding = (pointerCoords, scene) => {
-    const hoveredElement = getElementAtPosition(scene.getNonDeletedElements(), (element) => isBindableElement(element, false) &&
-        bindingBorderTest(element, pointerCoords));
+export const getHoveredElementForBinding = (pointerCoords, elements, elementsMap) => {
+    const hoveredElement = getElementAtPosition(elements, (element) => isBindableElement(element, false) &&
+        bindingBorderTest(element, pointerCoords, elementsMap));
     return hoveredElement;
 };
-const calculateFocusAndGap = (linearElement, hoveredElement, startOrEnd) => {
+const calculateFocusAndGap = (linearElement, hoveredElement, startOrEnd, elementsMap) => {
     const direction = startOrEnd === "start" ? -1 : 1;
     const edgePointIndex = direction === -1 ? 0 : linearElement.points.length - 1;
     const adjacentPointIndex = edgePointIndex - direction;
-    const edgePoint = LinearElementEditor.getPointAtIndexGlobalCoordinates(linearElement, edgePointIndex);
-    const adjacentPoint = LinearElementEditor.getPointAtIndexGlobalCoordinates(linearElement, adjacentPointIndex);
+    const edgePoint = LinearElementEditor.getPointAtIndexGlobalCoordinates(linearElement, edgePointIndex, elementsMap);
+    const adjacentPoint = LinearElementEditor.getPointAtIndexGlobalCoordinates(linearElement, adjacentPointIndex, elementsMap);
     return {
-        focus: determineFocusDistance(hoveredElement, adjacentPoint, edgePoint),
-        gap: Math.max(1, distanceToBindableElement(hoveredElement, edgePoint)),
+        focus: determineFocusDistance(hoveredElement, adjacentPoint, edgePoint, elementsMap),
+        gap: Math.max(1, distanceToBindableElement(hoveredElement, edgePoint, elementsMap)),
     };
 };
 // Supports translating, rotating and scaling `changedElement` with bound
@@ -146,14 +146,15 @@ const calculateFocusAndGap = (linearElement, hoveredElement, startOrEnd) => {
 // Because scaling involves moving the focus points as well, it is
 // done before the `changedElement` is updated, and the `newSize` is passed
 // in explicitly.
-export const updateBoundElements = (changedElement, options) => {
+export const updateBoundElements = (changedElement, elementsMap, options) => {
     const boundLinearElements = (changedElement.boundElements ?? []).filter((el) => el.type === "arrow");
     if (boundLinearElements.length === 0) {
         return;
     }
     const { newSize, simultaneouslyUpdated } = options ?? {};
     const simultaneouslyUpdatedElementIds = getSimultaneouslyUpdatedElementIds(simultaneouslyUpdated);
-    getNonDeletedElements(Scene.getScene(changedElement), boundLinearElements.map((el) => el.id)).forEach((element) => {
+    const scene = Scene.getScene(changedElement);
+    getNonDeletedElements(scene, boundLinearElements.map((el) => el.id)).forEach((element) => {
         if (!isLinearElement(element)) {
             return;
         }
@@ -169,11 +170,11 @@ export const updateBoundElements = (changedElement, options) => {
             mutateElement(element, { startBinding, endBinding });
             return;
         }
-        updateBoundPoint(element, "start", startBinding, changedElement);
-        updateBoundPoint(element, "end", endBinding, changedElement);
-        const boundText = getBoundTextElement(element);
+        updateBoundPoint(element, "start", startBinding, changedElement, elementsMap);
+        updateBoundPoint(element, "end", endBinding, changedElement, elementsMap);
+        const boundText = getBoundTextElement(element, scene.getNonDeletedElementsMap());
         if (boundText) {
-            handleBindTextResize(element, false);
+            handleBindTextResize(element, scene.getNonDeletedElementsMap(), false);
         }
     });
 };
@@ -184,7 +185,7 @@ const doesNeedUpdate = (boundElement, changedElement) => {
 const getSimultaneouslyUpdatedElementIds = (simultaneouslyUpdated) => {
     return new Set((simultaneouslyUpdated || []).map((element) => element.id));
 };
-const updateBoundPoint = (linearElement, startOrEnd, binding, changedElement) => {
+const updateBoundPoint = (linearElement, startOrEnd, binding, changedElement, elementsMap) => {
     if (binding == null ||
         // We only need to update the other end if this is a 2 point line element
         (binding.elementId !== changedElement.id && linearElement.points.length > 2)) {
@@ -198,8 +199,8 @@ const updateBoundPoint = (linearElement, startOrEnd, binding, changedElement) =>
     const direction = startOrEnd === "start" ? -1 : 1;
     const edgePointIndex = direction === -1 ? 0 : linearElement.points.length - 1;
     const adjacentPointIndex = edgePointIndex - direction;
-    const adjacentPoint = LinearElementEditor.getPointAtIndexGlobalCoordinates(linearElement, adjacentPointIndex);
-    const focusPointAbsolute = determineFocusPoint(bindingElement, binding.focus, adjacentPoint);
+    const adjacentPoint = LinearElementEditor.getPointAtIndexGlobalCoordinates(linearElement, adjacentPointIndex, elementsMap);
+    const focusPointAbsolute = determineFocusPoint(bindingElement, binding.focus, adjacentPoint, elementsMap);
     let newEdgePoint;
     // The linear element was not originally pointing inside the bound shape,
     // we can point directly at the focus point
@@ -207,7 +208,7 @@ const updateBoundPoint = (linearElement, startOrEnd, binding, changedElement) =>
         newEdgePoint = focusPointAbsolute;
     }
     else {
-        const intersections = intersectElementWithLine(bindingElement, adjacentPoint, focusPointAbsolute, binding.gap);
+        const intersections = intersectElementWithLine(bindingElement, adjacentPoint, focusPointAbsolute, binding.gap, elementsMap);
         if (intersections.length === 0) {
             // This should never happen, since focusPoint should always be
             // inside the element, but just in case, bail out
@@ -221,7 +222,7 @@ const updateBoundPoint = (linearElement, startOrEnd, binding, changedElement) =>
     LinearElementEditor.movePoints(linearElement, [
         {
             index: edgePointIndex,
-            point: LinearElementEditor.pointFromAbsoluteCoords(linearElement, newEdgePoint),
+            point: LinearElementEditor.pointFromAbsoluteCoords(linearElement, newEdgePoint, elementsMap),
         },
     ], { [startOrEnd === "start" ? "startBinding" : "endBinding"]: binding });
 };
@@ -236,36 +237,37 @@ const maybeCalculateNewGapWhenScaling = (changedElement, currentBinding, newSize
     return { elementId, gap: newGap, focus };
 };
 // TODO: this is a bottleneck, optimise
-export const getEligibleElementsForBinding = (elements) => {
-    const includedElementIds = new Set(elements.map(({ id }) => id));
-    return elements.flatMap((element) => isBindingElement(element, false)
-        ? getElligibleElementsForBindingElement(element).filter((element) => !includedElementIds.has(element.id))
-        : isBindableElement(element, false)
-            ? getElligibleElementsForBindableElementAndWhere(element).filter((binding) => !includedElementIds.has(binding[0].id))
+export const getEligibleElementsForBinding = (selectedElements, elements, elementsMap) => {
+    const includedElementIds = new Set(selectedElements.map(({ id }) => id));
+    return selectedElements.flatMap((selectedElement) => isBindingElement(selectedElement, false)
+        ? getElligibleElementsForBindingElement(selectedElement, elements, elementsMap).filter((element) => !includedElementIds.has(element.id))
+        : isBindableElement(selectedElement, false)
+            ? getElligibleElementsForBindableElementAndWhere(selectedElement, elementsMap).filter((binding) => !includedElementIds.has(binding[0].id))
             : []);
 };
-const getElligibleElementsForBindingElement = (linearElement) => {
+const getElligibleElementsForBindingElement = (linearElement, elements, elementsMap) => {
     return [
-        getElligibleElementForBindingElement(linearElement, "start"),
-        getElligibleElementForBindingElement(linearElement, "end"),
+        getElligibleElementForBindingElement(linearElement, "start", elements, elementsMap),
+        getElligibleElementForBindingElement(linearElement, "end", elements, elementsMap),
     ].filter((element) => element != null);
 };
-const getElligibleElementForBindingElement = (linearElement, startOrEnd) => {
-    return getHoveredElementForBinding(getLinearElementEdgeCoors(linearElement, startOrEnd), Scene.getScene(linearElement));
+const getElligibleElementForBindingElement = (linearElement, startOrEnd, elements, elementsMap) => {
+    return getHoveredElementForBinding(getLinearElementEdgeCoors(linearElement, startOrEnd, elementsMap), elements, elementsMap);
 };
-const getLinearElementEdgeCoors = (linearElement, startOrEnd) => {
+const getLinearElementEdgeCoors = (linearElement, startOrEnd, elementsMap) => {
     const index = startOrEnd === "start" ? 0 : -1;
-    return tupleToCoors(LinearElementEditor.getPointAtIndexGlobalCoordinates(linearElement, index));
+    return tupleToCoors(LinearElementEditor.getPointAtIndexGlobalCoordinates(linearElement, index, elementsMap));
 };
-const getElligibleElementsForBindableElementAndWhere = (bindableElement) => {
-    return Scene.getScene(bindableElement)
+const getElligibleElementsForBindableElementAndWhere = (bindableElement, elementsMap) => {
+    const scene = Scene.getScene(bindableElement);
+    return scene
         .getNonDeletedElements()
         .map((element) => {
         if (!isBindingElement(element, false)) {
             return null;
         }
-        const canBindStart = isLinearElementEligibleForNewBindingByBindable(element, "start", bindableElement);
-        const canBindEnd = isLinearElementEligibleForNewBindingByBindable(element, "end", bindableElement);
+        const canBindStart = isLinearElementEligibleForNewBindingByBindable(element, "start", bindableElement, elementsMap);
+        const canBindEnd = isLinearElementEligibleForNewBindingByBindable(element, "end", bindableElement, elementsMap);
         if (!canBindStart && !canBindEnd) {
             return null;
         }
@@ -277,11 +279,11 @@ const getElligibleElementsForBindableElementAndWhere = (bindableElement) => {
     })
         .filter((maybeElement) => maybeElement != null);
 };
-const isLinearElementEligibleForNewBindingByBindable = (linearElement, startOrEnd, bindableElement) => {
+const isLinearElementEligibleForNewBindingByBindable = (linearElement, startOrEnd, bindableElement, elementsMap) => {
     const existingBinding = linearElement[startOrEnd === "start" ? "startBinding" : "endBinding"];
     return (existingBinding == null &&
         !isLinearElementSimpleAndAlreadyBoundOnOppositeEdge(linearElement, bindableElement, startOrEnd) &&
-        bindingBorderTest(bindableElement, getLinearElementEdgeCoors(linearElement, startOrEnd)));
+        bindingBorderTest(bindableElement, getLinearElementEdgeCoors(linearElement, startOrEnd, elementsMap), elementsMap));
 };
 // We need to:
 // 1: Update elements not selected to point to duplicated elements

package/dist/excalidraw/element/bounds.d.ts

@@ -1,4 +1,4 @@
-import { ExcalidrawElement, ExcalidrawLinearElement, Arrowhead, ExcalidrawFreeDrawElement, NonDeleted } from "./types";
+import { ExcalidrawElement, ExcalidrawLinearElement, Arrowhead, ExcalidrawFreeDrawElement, NonDeleted, ElementsMap } from "./types";
 import { Drawable, Op } from "roughjs/bin/core";
 import { AppState, Point } from "../types";
 export type RectangleBox = {
@@ -25,11 +25,11 @@ export type SceneBounds = readonly [
 ];
 export declare class ElementBounds {
     private static boundsCache;
-    static getBounds(element: ExcalidrawElement): Bounds;
+    static getBounds(element: ExcalidrawElement, elementsMap: ElementsMap): Bounds;
     private static calculateBounds;
 }
-export declare const getElementAbsoluteCoords: (element: ExcalidrawElement, includeBoundText?: boolean) => [number, number, number, number, number, number];
-export declare const getElementLineSegments: (element: ExcalidrawElement) => [Point, Point][];
+export declare const getElementAbsoluteCoords: (element: ExcalidrawElement, elementsMap: ElementsMap, includeBoundText?: boolean) => [number, number, number, number, number, number];
+export declare const getElementLineSegments: (element: ExcalidrawElement, elementsMap: ElementsMap) => [Point, Point][];
 /**
  * Scene -> Scene coords, but in x1,x2,y1,y2 format.
  *
@@ -46,7 +46,7 @@ export declare const getArrowheadSize: (arrowhead: Arrowhead) => number;
 /** @returns number in degrees */
 export declare const getArrowheadAngle: (arrowhead: Arrowhead) => number;
 export declare const getArrowheadPoints: (element: ExcalidrawLinearElement, shape: Drawable[], position: "start" | "end", arrowhead: Arrowhead) => number[] | null;
-export declare const getElementBounds: (element: ExcalidrawElement) => Bounds;
+export declare const getElementBounds: (element: ExcalidrawElement, elementsMap: ElementsMap) => Bounds;
 export declare const getCommonBounds: (elements: readonly ExcalidrawElement[]) => Bounds;
 export declare const getDraggedElementsBounds: (elements: ExcalidrawElement[], dragOffset: {
     x: number;

package/dist/excalidraw/element/bounds.js

@@ -6,10 +6,10 @@ import { rescalePoints } from "../points";
 import { getBoundTextElement, getContainerElement } from "./textElement";
 import { LinearElementEditor } from "./linearElementEditor";
 import { ShapeCache } from "../scene/ShapeCache";
-import Scene from "../scene/Scene";
+import { arrayToMap } from "../utils";
 export class ElementBounds {
     static boundsCache = new WeakMap();
-    static getBounds(element) {
+    static getBounds(element, elementsMap) {
         const cachedBounds = ElementBounds.boundsCache.get(element);
         if (cachedBounds?.version &&
             cachedBounds.version === element.version &&
@@ -18,22 +18,16 @@ export class ElementBounds {
             !isBoundToContainer(element)) {
             return cachedBounds.bounds;
         }
-        const bounds = ElementBounds.calculateBounds(element);
-        // hack to ensure that downstream checks could retrieve element Scene
-        // so as to have correctly calculated bounds
-        // FIXME remove when we get rid of all the id:Scene / element:Scene mapping
-        const shouldCache = Scene.getScene(element);
-        if (shouldCache) {
-            ElementBounds.boundsCache.set(element, {
-                version: element.version,
-                bounds,
-            });
-        }
+        const bounds = ElementBounds.calculateBounds(element, elementsMap);
+        ElementBounds.boundsCache.set(element, {
+            version: element.version,
+            bounds,
+        });
         return bounds;
     }
-    static calculateBounds(element) {
+    static calculateBounds(element, elementsMap) {
         let bounds;
-        const [x1, y1, x2, y2, cx, cy] = getElementAbsoluteCoords(element);
+        const [x1, y1, x2, y2, cx, cy] = getElementAbsoluteCoords(element, elementsMap);
         if (isFreeDrawElement(element)) {
             const [minX, minY, maxX, maxY] = getBoundsFromPoints(element.points.map(([x, y]) => rotate(x, y, cx - element.x, cy - element.y, element.angle)));
             return [
@@ -44,7 +38,7 @@ export class ElementBounds {
             ];
         }
         else if (isLinearElement(element)) {
-            bounds = getLinearElementRotatedBounds(element, cx, cy);
+            bounds = getLinearElementRotatedBounds(element, cx, cy, elementsMap);
         }
         else if (element.type === "diamond") {
             const [x11, y11] = rotate(cx, y1, cx, cy, element.angle);
@@ -84,17 +78,19 @@ export class ElementBounds {
 //
 // If the element is created from right to left, the width is going to be negative
 // This set of functions retrieves the absolute position of the 4 points.
-export const getElementAbsoluteCoords = (element, includeBoundText = false) => {
+export const getElementAbsoluteCoords = (element, elementsMap, includeBoundText = false) => {
     if (isFreeDrawElement(element)) {
         return getFreeDrawElementAbsoluteCoords(element);
     }
     else if (isLinearElement(element)) {
-        return LinearElementEditor.getElementAbsoluteCoords(element, includeBoundText);
+        return LinearElementEditor.getElementAbsoluteCoords(element, elementsMap, includeBoundText);
     }
     else if (isTextElement(element)) {
-        const container = getContainerElement(element);
+        const container = elementsMap
+            ? getContainerElement(element, elementsMap)
+            : null;
         if (isArrowElement(container)) {
-            const coords = LinearElementEditor.getBoundTextElementPosition(container, element);
+            const coords = LinearElementEditor.getBoundTextElementPosition(container, element, elementsMap);
             return [
                 coords.x,
                 coords.y,
@@ -119,8 +115,8 @@ export const getElementAbsoluteCoords = (element, includeBoundText = false) => {
  * that can be used for visual collision detection (useful for frames)
  * as opposed to bounding box collision detection
  */
-export const getElementLineSegments = (element) => {
-    const [x1, y1, x2, y2, cx, cy] = getElementAbsoluteCoords(element);
+export const getElementLineSegments = (element, elementsMap) => {
+    const [x1, y1, x2, y2, cx, cy] = getElementAbsoluteCoords(element, elementsMap);
     const center = [cx, cy];
     if (isLinearElement(element) || isFreeDrawElement(element)) {
         const segments = [];
@@ -459,14 +455,14 @@ const generateLinearElementShape = (element) => {
     })();
     return generator[method](element.points, options);
 };
-const getLinearElementRotatedBounds = (element, cx, cy) => {
+const getLinearElementRotatedBounds = (element, cx, cy, elementsMap) => {
+    const boundTextElement = getBoundTextElement(element, elementsMap);
     if (element.points.length < 2) {
         const [pointX, pointY] = element.points[0];
         const [x, y] = rotate(element.x + pointX, element.y + pointY, cx, cy, element.angle);
         let coords = [x, y, x, y];
-        const boundTextElement = getBoundTextElement(element);
         if (boundTextElement) {
-            const coordsWithBoundText = LinearElementEditor.getMinMaxXYWithBoundText(element, [x, y, x, y], boundTextElement);
+            const coordsWithBoundText = LinearElementEditor.getMinMaxXYWithBoundText(element, elementsMap, [x, y, x, y], boundTextElement);
             coords = [
                 coordsWithBoundText[0],
                 coordsWithBoundText[1],
@@ -483,9 +479,8 @@ const getLinearElementRotatedBounds = (element, cx, cy) => {
     const transformXY = (x, y) => rotate(element.x + x, element.y + y, cx, cy, element.angle);
     const res = getMinMaxXYFromCurvePathOps(ops, transformXY);
     let coords = [res[0], res[1], res[2], res[3]];
-    const boundTextElement = getBoundTextElement(element);
     if (boundTextElement) {
-        const coordsWithBoundText = LinearElementEditor.getMinMaxXYWithBoundText(element, coords, boundTextElement);
+        const coordsWithBoundText = LinearElementEditor.getMinMaxXYWithBoundText(element, elementsMap, coords, boundTextElement);
         coords = [
             coordsWithBoundText[0],
             coordsWithBoundText[1],
@@ -495,8 +490,8 @@ const getLinearElementRotatedBounds = (element, cx, cy) => {
     }
     return coords;
 };
-export const getElementBounds = (element) => {
-    return ElementBounds.getBounds(element);
+export const getElementBounds = (element, elementsMap) => {
+    return ElementBounds.getBounds(element, elementsMap);
 };
 export const getCommonBounds = (elements) => {
     if (!elements.length) {
@@ -506,8 +501,9 @@ export const getCommonBounds = (elements) => {
     let maxX = -Infinity;
     let minY = Infinity;
     let maxY = -Infinity;
+    const elementsMap = arrayToMap(elements);
     elements.forEach((element) => {
-        const [x1, y1, x2, y2] = getElementBounds(element);
+        const [x1, y1, x2, y2] = getElementBounds(element, elementsMap);
         minX = Math.min(minX, x1);
         minY = Math.min(minY, y1);
         maxX = Math.max(maxX, x2);
@@ -577,15 +573,16 @@ export const getClosestElementBounds = (elements, from) => {
     }
     let minDistance = Infinity;
     let closestElement = elements[0];
+    const elementsMap = arrayToMap(elements);
     elements.forEach((element) => {
-        const [x1, y1, x2, y2] = getElementBounds(element);
+        const [x1, y1, x2, y2] = getElementBounds(element, elementsMap);
         const distance = distance2d((x1 + x2) / 2, (y1 + y2) / 2, from.x, from.y);
         if (distance < minDistance) {
             minDistance = distance;
             closestElement = element;
         }
     });
-    return getElementBounds(closestElement);
+    return getElementBounds(closestElement, elementsMap);
 };
 export const getCommonBoundingBox = (elements) => {
     const [minX, minY, maxX, maxY] = getCommonBounds(elements);

package/dist/excalidraw/element/collision.d.ts

@@ -1,21 +1,21 @@
 import * as GA from "../ga";
-import { NonDeletedExcalidrawElement, ExcalidrawBindableElement, ExcalidrawElement, ExcalidrawRectangleElement, ExcalidrawDiamondElement, ExcalidrawTextElement, ExcalidrawEllipseElement, NonDeleted, ExcalidrawImageElement, ExcalidrawFrameLikeElement, ExcalidrawIframeLikeElement } from "./types";
+import { NonDeletedExcalidrawElement, ExcalidrawBindableElement, ExcalidrawElement, ExcalidrawRectangleElement, ExcalidrawDiamondElement, ExcalidrawTextElement, ExcalidrawEllipseElement, NonDeleted, ExcalidrawImageElement, ExcalidrawFrameLikeElement, ExcalidrawIframeLikeElement, ElementsMap } from "./types";
 import { FrameNameBoundsCache, Point } from "../types";
 import { AppState } from "../types";
-export declare const hitTest: (element: NonDeletedExcalidrawElement, appState: AppState, frameNameBoundsCache: FrameNameBoundsCache, x: number, y: number) => boolean;
-export declare const isHittingElementBoundingBoxWithoutHittingElement: (element: NonDeletedExcalidrawElement, appState: AppState, frameNameBoundsCache: FrameNameBoundsCache, x: number, y: number) => boolean;
-export declare const isHittingElementNotConsideringBoundingBox: (element: NonDeletedExcalidrawElement, appState: AppState, frameNameBoundsCache: FrameNameBoundsCache | null, point: readonly [number, number]) => boolean;
-export declare const isPointHittingElementBoundingBox: (element: NonDeleted<ExcalidrawElement>, [x, y]: readonly [number, number], threshold: number, frameNameBoundsCache: FrameNameBoundsCache | null) => boolean;
+export declare const hitTest: (element: NonDeletedExcalidrawElement, appState: AppState, frameNameBoundsCache: FrameNameBoundsCache, x: number, y: number, elementsMap: ElementsMap) => boolean;
+export declare const isHittingElementBoundingBoxWithoutHittingElement: (element: NonDeletedExcalidrawElement, appState: AppState, frameNameBoundsCache: FrameNameBoundsCache, x: number, y: number, elementsMap: ElementsMap) => boolean;
+export declare const isHittingElementNotConsideringBoundingBox: (element: NonDeletedExcalidrawElement, appState: AppState, frameNameBoundsCache: FrameNameBoundsCache | null, point: readonly [number, number], elementsMap: ElementsMap) => boolean;
+export declare const isPointHittingElementBoundingBox: (element: NonDeleted<ExcalidrawElement>, elementsMap: ElementsMap, [x, y]: readonly [number, number], threshold: number, frameNameBoundsCache: FrameNameBoundsCache | null) => boolean;
 export declare const bindingBorderTest: (element: NonDeleted<ExcalidrawBindableElement>, { x, y }: {
     x: number;
     y: number;
-}) => boolean;
+}, elementsMap: ElementsMap) => boolean;
 export declare const maxBindingGap: (element: ExcalidrawElement, elementWidth: number, elementHeight: number) => number;
-export declare const distanceToBindableElement: (element: ExcalidrawBindableElement, point: readonly [number, number]) => number;
-export declare const pointInAbsoluteCoords: (element: ExcalidrawElement, point: readonly [number, number]) => readonly [number, number];
-export declare const determineFocusDistance: (element: ExcalidrawBindableElement, a: readonly [number, number], b: readonly [number, number]) => number;
-export declare const determineFocusPoint: (element: ExcalidrawBindableElement, focus: number, adjecentPoint: readonly [number, number]) => readonly [number, number];
-export declare const intersectElementWithLine: (element: ExcalidrawBindableElement, a: readonly [number, number], b: readonly [number, number], gap?: number) => Point[];
+export declare const distanceToBindableElement: (element: ExcalidrawBindableElement, point: readonly [number, number], elementsMap: ElementsMap) => number;
+export declare const pointInAbsoluteCoords: (element: ExcalidrawElement, elementsMap: ElementsMap, point: readonly [number, number]) => readonly [number, number];
+export declare const determineFocusDistance: (element: ExcalidrawBindableElement, a: readonly [number, number], b: readonly [number, number], elementsMap: ElementsMap) => number;
+export declare const determineFocusPoint: (element: ExcalidrawBindableElement, focus: number, adjecentPoint: readonly [number, number], elementsMap: ElementsMap) => readonly [number, number];
+export declare const intersectElementWithLine: (element: ExcalidrawBindableElement, a: readonly [number, number], b: readonly [number, number], gap: number | undefined, elementsMap: ElementsMap) => Point[];
 export declare const getCircleIntersections: (center: readonly [number, number, number, number, number, number, number, number], radius: number, line: readonly [number, number, number, number, number, number, number, number]) => GA.Point[];
 export declare const findFocusPointForEllipse: (ellipse: ExcalidrawEllipseElement, relativeDistance: number, point: readonly [number, number, number, number, number, number, number, number]) => readonly [number, number, number, number, number, number, number, number];
 export declare const findFocusPointForRectangulars: (element: ExcalidrawRectangleElement | ExcalidrawImageElement | ExcalidrawDiamondElement | ExcalidrawTextElement | ExcalidrawIframeLikeElement | ExcalidrawFrameLikeElement, relativeDistance: number, point: readonly [number, number, number, number, number, number, number, number]) => readonly [number, number, number, number, number, number, number, number];