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

package/dist/excalidraw/element/resizeElements.js

@@ -7,7 +7,7 @@ import { mutateElement } from "./mutateElement";
 import { getFontString } from "../utils";
 import { updateBoundElements } from "./binding";
 import Scene from "../scene/Scene";
-import { getApproxMinLineWidth, getBoundTextElement, getBoundTextElementId, getContainerElement, handleBindTextResize, getBoundTextMaxWidth, getApproxMinLineHeight, measureText, getBoundTextMaxHeight, } from "./textElement";
+import { getApproxMinLineWidth, getBoundTextElement, getBoundTextElementId, getContainerElement, handleBindTextResize, getBoundTextMaxWidth, getApproxMinLineHeight, } from "./textElement";
 import { LinearElementEditor } from "./linearElementEditor";
 export const normalizeAngle = (angle) => {
     if (angle < 0) {
@@ -19,43 +19,43 @@ export const normalizeAngle = (angle) => {
     return angle;
 };
 // Returns true when transform (resizing/rotation) happened
-export const transformElements = (pointerDownState, transformHandleType, selectedElements, resizeArrowDirection, shouldRotateWithDiscreteAngle, shouldResizeFromCenter, shouldMaintainAspectRatio, pointerX, pointerY, centerX, centerY, appState) => {
+export const transformElements = (originalElements, transformHandleType, selectedElements, elementsMap, shouldRotateWithDiscreteAngle, shouldResizeFromCenter, shouldMaintainAspectRatio, pointerX, pointerY, centerX, centerY) => {
     if (selectedElements.length === 1) {
         const [element] = selectedElements;
         if (transformHandleType === "rotation") {
-            rotateSingleElement(element, pointerX, pointerY, shouldRotateWithDiscreteAngle, pointerDownState.originalElements);
-            updateBoundElements(element);
+            rotateSingleElement(element, elementsMap, pointerX, pointerY, shouldRotateWithDiscreteAngle);
+            updateBoundElements(element, elementsMap);
         }
         else if (isTextElement(element) &&
             (transformHandleType === "nw" ||
                 transformHandleType === "ne" ||
                 transformHandleType === "sw" ||
                 transformHandleType === "se")) {
-            resizeSingleTextElement(element, transformHandleType, shouldResizeFromCenter, pointerX, pointerY);
-            updateBoundElements(element);
+            resizeSingleTextElement(element, elementsMap, transformHandleType, shouldResizeFromCenter, pointerX, pointerY);
+            updateBoundElements(element, elementsMap);
         }
         else if (transformHandleType) {
-            resizeSingleElement(pointerDownState.originalElements, shouldMaintainAspectRatio, element, transformHandleType, shouldResizeFromCenter, pointerX, pointerY);
+            resizeSingleElement(originalElements, shouldMaintainAspectRatio, element, elementsMap, transformHandleType, shouldResizeFromCenter, pointerX, pointerY);
         }
         return true;
     }
     else if (selectedElements.length > 1) {
         if (transformHandleType === "rotation") {
-            rotateMultipleElements(pointerDownState, selectedElements, pointerX, pointerY, shouldRotateWithDiscreteAngle, centerX, centerY);
+            rotateMultipleElements(originalElements, selectedElements, elementsMap, pointerX, pointerY, shouldRotateWithDiscreteAngle, centerX, centerY);
             return true;
         }
         else if (transformHandleType === "nw" ||
             transformHandleType === "ne" ||
             transformHandleType === "sw" ||
             transformHandleType === "se") {
-            resizeMultipleElements(pointerDownState, selectedElements, transformHandleType, shouldResizeFromCenter, pointerX, pointerY);
+            resizeMultipleElements(originalElements, selectedElements, elementsMap, transformHandleType, shouldResizeFromCenter, pointerX, pointerY);
             return true;
         }
     }
     return false;
 };
-const rotateSingleElement = (element, pointerX, pointerY, shouldRotateWithDiscreteAngle, originalElements) => {
-    const [x1, y1, x2, y2] = getElementAbsoluteCoords(element);
+const rotateSingleElement = (element, elementsMap, pointerX, pointerY, shouldRotateWithDiscreteAngle) => {
+    const [x1, y1, x2, y2] = getElementAbsoluteCoords(element, elementsMap);
     const cx = (x1 + x2) / 2;
     const cy = (y1 + y2) / 2;
     let angle;
@@ -84,24 +84,22 @@ const rescalePointsInElement = (element, width, height, normalizePoints) => isLi
         points: rescalePoints(0, width, rescalePoints(1, height, element.points, normalizePoints), normalizePoints),
     }
     : {};
-const measureFontSizeFromWidth = (element, nextWidth, nextHeight) => {
+const measureFontSizeFromWidth = (element, elementsMap, nextWidth) => {
     // We only use width to scale font on resize
     let width = element.width;
     const hasContainer = isBoundToContainer(element);
     if (hasContainer) {
-        const container = getContainerElement(element);
+        const container = getContainerElement(element, elementsMap);
         if (container) {
-            width = getBoundTextMaxWidth(container);
+            width = getBoundTextMaxWidth(container, element);
         }
     }
     const nextFontSize = element.fontSize * (nextWidth / width);
     if (nextFontSize < MIN_FONT_SIZE) {
         return null;
     }
-    const metrics = measureText(element.text, getFontString({ fontSize: nextFontSize, fontFamily: element.fontFamily }), element.lineHeight);
     return {
         size: nextFontSize,
-        baseline: metrics.baseline + (nextHeight - metrics.height),
     };
 };
 const getSidesForTransformHandle = (transformHandleType, shouldResizeFromCenter) => {
@@ -116,8 +114,8 @@ const getSidesForTransformHandle = (transformHandleType, shouldResizeFromCenter)
             (shouldResizeFromCenter && /^(w|nw|sw)$/.test(transformHandleType)),
     };
 };
-const resizeSingleTextElement = (element, transformHandleType, shouldResizeFromCenter, pointerX, pointerY) => {
-    const [x1, y1, x2, y2] = getElementAbsoluteCoords(element);
+const resizeSingleTextElement = (element, elementsMap, transformHandleType, shouldResizeFromCenter, pointerX, pointerY) => {
+    const [x1, y1, x2, y2] = getElementAbsoluteCoords(element, elementsMap);
     const cx = (x1 + x2) / 2;
     const cy = (y1 + y2) / 2;
     // rotation pointer with reverse angle
@@ -140,7 +138,7 @@ const resizeSingleTextElement = (element, transformHandleType, shouldResizeFromC
     if (scale > 0) {
         const nextWidth = element.width * scale;
         const nextHeight = element.height * scale;
-        const metrics = measureFontSizeFromWidth(element, nextWidth, nextHeight);
+        const metrics = measureFontSizeFromWidth(element, elementsMap, nextWidth);
         if (metrics === null) {
             return;
         }
@@ -154,13 +152,12 @@ const resizeSingleTextElement = (element, transformHandleType, shouldResizeFromC
             fontSize: metrics.size,
             width: nextWidth,
             height: nextHeight,
-            baseline: metrics.baseline,
             x: nextElementX,
             y: nextElementY,
         });
     }
 };
-export const resizeSingleElement = (originalElements, shouldMaintainAspectRatio, element, transformHandleDirection, shouldResizeFromCenter, pointerX, pointerY) => {
+export const resizeSingleElement = (originalElements, shouldMaintainAspectRatio, element, elementsMap, transformHandleDirection, shouldResizeFromCenter, pointerX, pointerY) => {
     const stateAtResizeStart = originalElements.get(element.id);
     // Gets bounds corners
     const [x1, y1, x2, y2] = getResizedElementAbsoluteCoords(stateAtResizeStart, stateAtResizeStart.width, stateAtResizeStart.height, true);
@@ -180,7 +177,7 @@ export const resizeSingleElement = (originalElements, shouldMaintainAspectRatio,
     let scaleX = atStartBoundsWidth / boundsCurrentWidth;
     let scaleY = atStartBoundsHeight / boundsCurrentHeight;
     let boundTextFont = {};
-    const boundTextElement = getBoundTextElement(element);
+    const boundTextElement = getBoundTextElement(element, elementsMap);
     if (transformHandleDirection.includes("e")) {
         scaleX = (rotatedPointer[0] - startTopLeft[0]) / boundsCurrentWidth;
     }
@@ -224,7 +221,6 @@ export const resizeSingleElement = (originalElements, shouldMaintainAspectRatio,
         if (stateOfBoundTextElementAtResize) {
             boundTextFont = {
                 fontSize: stateOfBoundTextElementAtResize.fontSize,
-                baseline: stateOfBoundTextElementAtResize.baseline,
             };
         }
         if (shouldMaintainAspectRatio) {
@@ -233,13 +229,12 @@ export const resizeSingleElement = (originalElements, shouldMaintainAspectRatio,
                 width: eleNewWidth,
                 height: eleNewHeight,
             };
-            const nextFont = measureFontSizeFromWidth(boundTextElement, getBoundTextMaxWidth(updatedElement), getBoundTextMaxHeight(updatedElement, boundTextElement));
+            const nextFont = measureFontSizeFromWidth(boundTextElement, elementsMap, getBoundTextMaxWidth(updatedElement, boundTextElement));
             if (nextFont === null) {
                 return;
             }
             boundTextFont = {
                 fontSize: nextFont.size,
-                baseline: nextFont.baseline,
             };
         }
         else {
@@ -358,25 +353,24 @@ export const resizeSingleElement = (originalElements, shouldMaintainAspectRatio,
         Number.isFinite(resizedElement.x) &&
         Number.isFinite(resizedElement.y)) {
         mutateElement(element, resizedElement);
-        updateBoundElements(element, {
+        updateBoundElements(element, elementsMap, {
             newSize: { width: resizedElement.width, height: resizedElement.height },
         });
         if (boundTextElement && boundTextFont != null) {
             mutateElement(boundTextElement, {
                 fontSize: boundTextFont.fontSize,
-                baseline: boundTextFont.baseline,
             });
         }
-        handleBindTextResize(element, transformHandleDirection, shouldMaintainAspectRatio);
+        handleBindTextResize(element, elementsMap, transformHandleDirection, shouldMaintainAspectRatio);
     }
 };
-export const resizeMultipleElements = (pointerDownState, selectedElements, transformHandleType, shouldResizeFromCenter, pointerX, pointerY) => {
+export const resizeMultipleElements = (originalElements, selectedElements, elementsMap, transformHandleType, shouldResizeFromCenter, pointerX, pointerY) => {
     // map selected elements to the original elements. While it never should
     // happen that pointerDownState.originalElements won't contain the selected
     // elements during resize, this coupling isn't guaranteed, so to ensure
     // type safety we need to transform only those elements we filter.
     const targetElements = selectedElements.reduce((acc, element) => {
-        const origElement = pointerDownState.originalElements.get(element.id);
+        const origElement = originalElements.get(element.id);
         if (origElement) {
             acc.push({ orig: origElement, latest: element });
         }
@@ -394,11 +388,11 @@ export const resizeMultipleElements = (pointerDownState, selectedElements, trans
         if (!textId) {
             return acc;
         }
-        const text = pointerDownState.originalElements.get(textId) ?? null;
+        const text = originalElements.get(textId) ?? null;
         if (!isBoundToContainer(text)) {
             return acc;
         }
-        const xy = LinearElementEditor.getBoundTextElementPosition(orig, text);
+        const xy = LinearElementEditor.getBoundTextElementPosition(orig, text, elementsMap);
         return [...acc, { ...text, ...xy }];
     }, []);
     const { minX, minY, maxX, maxY, midX, midY } = getCommonBoundingBox(targetElements.map(({ orig }) => orig).concat(boundTextElements));
@@ -487,14 +481,13 @@ export const resizeMultipleElements = (pointerDownState, selectedElements, trans
             }
         }
         if (isTextElement(orig)) {
-            const metrics = measureFontSizeFromWidth(orig, width, height);
+            const metrics = measureFontSizeFromWidth(orig, elementsMap, width);
             if (!metrics) {
                 return;
             }
             update.fontSize = metrics.size;
-            update.baseline = metrics.baseline;
         }
-        const boundTextElement = pointerDownState.originalElements.get(getBoundTextElementId(orig) ?? "");
+        const boundTextElement = originalElements.get(getBoundTextElementId(orig) ?? "");
         if (boundTextElement) {
             const newFontSize = boundTextElement.fontSize * scale;
             if (newFontSize < MIN_FONT_SIZE) {
@@ -511,22 +504,22 @@ export const resizeMultipleElements = (pointerDownState, selectedElements, trans
     for (const { element, update: { boundTextFontSize, ...update }, } of elementsAndUpdates) {
         const { width, height, angle } = update;
         mutateElement(element, update, false);
-        updateBoundElements(element, {
+        updateBoundElements(element, elementsMap, {
             simultaneouslyUpdated: elementsToUpdate,
             newSize: { width, height },
         });
-        const boundTextElement = getBoundTextElement(element);
+        const boundTextElement = getBoundTextElement(element, elementsMap);
         if (boundTextElement && boundTextFontSize) {
             mutateElement(boundTextElement, {
                 fontSize: boundTextFontSize,
                 angle: isLinearElement(element) ? undefined : angle,
             }, false);
-            handleBindTextResize(element, transformHandleType, true);
+            handleBindTextResize(element, elementsMap, transformHandleType, true);
         }
     }
     Scene.getScene(elementsAndUpdates[0].element)?.informMutation();
 };
-const rotateMultipleElements = (pointerDownState, elements, pointerX, pointerY, shouldRotateWithDiscreteAngle, centerX, centerY) => {
+const rotateMultipleElements = (originalElements, elements, elementsMap, pointerX, pointerY, shouldRotateWithDiscreteAngle, centerX, centerY) => {
     let centerAngle = (5 * Math.PI) / 2 + Math.atan2(pointerY - centerY, pointerX - centerX);
     if (shouldRotateWithDiscreteAngle) {
         centerAngle += SHIFT_LOCKING_ANGLE / 2;
@@ -535,19 +528,20 @@ const rotateMultipleElements = (pointerDownState, elements, pointerX, pointerY,
     elements
         .filter((element) => !isFrameLikeElement(element))
         .forEach((element) => {
-        const [x1, y1, x2, y2] = getElementAbsoluteCoords(element);
+        const [x1, y1, x2, y2] = getElementAbsoluteCoords(element, elementsMap);
         const cx = (x1 + x2) / 2;
         const cy = (y1 + y2) / 2;
-        const origAngle = pointerDownState.originalElements.get(element.id)?.angle ??
-            element.angle;
+        const origAngle = originalElements.get(element.id)?.angle ?? element.angle;
         const [rotatedCX, rotatedCY] = rotate(cx, cy, centerX, centerY, centerAngle + origAngle - element.angle);
         mutateElement(element, {
             x: element.x + (rotatedCX - cx),
             y: element.y + (rotatedCY - cy),
             angle: normalizeAngle(centerAngle + origAngle),
         }, false);
-        updateBoundElements(element, { simultaneouslyUpdated: elements });
-        const boundText = getBoundTextElement(element);
+        updateBoundElements(element, elementsMap, {
+            simultaneouslyUpdated: elements,
+        });
+        const boundText = getBoundTextElement(element, elementsMap);
         if (boundText && !isArrowElement(element)) {
             mutateElement(boundText, {
                 x: boundText.x + (rotatedCX - cx),
@@ -558,9 +552,9 @@ const rotateMultipleElements = (pointerDownState, elements, pointerX, pointerY,
     });
     Scene.getScene(elements[0])?.informMutation();
 };
-export const getResizeOffsetXY = (transformHandleType, selectedElements, x, y) => {
+export const getResizeOffsetXY = (transformHandleType, selectedElements, elementsMap, x, y) => {
     const [x1, y1, x2, y2] = selectedElements.length === 1
-        ? getElementAbsoluteCoords(selectedElements[0])
+        ? getElementAbsoluteCoords(selectedElements[0], elementsMap)
         : getCommonBounds(selectedElements);
     const cx = (x1 + x2) / 2;
     const cy = (y1 + y2) / 2;

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

@@ -1,9 +1,9 @@
-import { ExcalidrawElement, PointerType, NonDeletedExcalidrawElement } from "./types";
+import { ExcalidrawElement, PointerType, NonDeletedExcalidrawElement, ElementsMap } from "./types";
 import { MaybeTransformHandleType } from "./transformHandles";
 import { AppState, Zoom } from "../types";
 import { Bounds } from "./bounds";
-export declare const resizeTest: (element: NonDeletedExcalidrawElement, appState: AppState, x: number, y: number, zoom: Zoom, pointerType: PointerType) => MaybeTransformHandleType;
-export declare const getElementWithTransformHandleType: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState, scenePointerX: number, scenePointerY: number, zoom: Zoom, pointerType: PointerType) => {
+export declare const resizeTest: (element: NonDeletedExcalidrawElement, elementsMap: ElementsMap, appState: AppState, x: number, y: number, zoom: Zoom, pointerType: PointerType) => MaybeTransformHandleType;
+export declare const getElementWithTransformHandleType: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState, scenePointerX: number, scenePointerY: number, zoom: Zoom, pointerType: PointerType, elementsMap: ElementsMap) => {
     element: NonDeletedExcalidrawElement;
     transformHandleType: MaybeTransformHandleType;
 } | null;

package/dist/excalidraw/element/resizeTest.js

@@ -3,11 +3,11 @@ const isInsideTransformHandle = (transformHandle, x, y) => x >= transformHandle[
     x <= transformHandle[0] + transformHandle[2] &&
     y >= transformHandle[1] &&
     y <= transformHandle[1] + transformHandle[3];
-export const resizeTest = (element, appState, x, y, zoom, pointerType) => {
+export const resizeTest = (element, elementsMap, appState, x, y, zoom, pointerType) => {
     if (!appState.selectedElementIds[element.id]) {
         return false;
     }
-    const { rotation: rotationTransformHandle, ...transformHandles } = getTransformHandles(element, zoom, pointerType);
+    const { rotation: rotationTransformHandle, ...transformHandles } = getTransformHandles(element, zoom, elementsMap, pointerType);
     if (rotationTransformHandle &&
         isInsideTransformHandle(rotationTransformHandle, x, y)) {
         return "rotation";
@@ -24,12 +24,12 @@ export const resizeTest = (element, appState, x, y, zoom, pointerType) => {
     }
     return false;
 };
-export const getElementWithTransformHandleType = (elements, appState, scenePointerX, scenePointerY, zoom, pointerType) => {
+export const getElementWithTransformHandleType = (elements, appState, scenePointerX, scenePointerY, zoom, pointerType, elementsMap) => {
     return elements.reduce((result, element) => {
         if (result) {
             return result;
         }
-        const transformHandleType = resizeTest(element, appState, scenePointerX, scenePointerY, zoom, pointerType);
+        const transformHandleType = resizeTest(element, elementsMap, appState, scenePointerX, scenePointerY, zoom, pointerType);
         return transformHandleType ? { element, transformHandleType } : null;
     }, null);
 };

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

@@ -1,4 +1,4 @@
-import { ExcalidrawElement } from "./types";
+import { ElementsMap, ExcalidrawElement } from "./types";
 import { AppState, Zoom } from "../types";
 export declare const isInvisiblySmallElement: (element: ExcalidrawElement) => boolean;
 export declare const isElementInViewport: (element: ExcalidrawElement, width: number, height: number, viewTransformations: {
@@ -7,7 +7,7 @@ export declare const isElementInViewport: (element: ExcalidrawElement, width: nu
     offsetTop: number;
     scrollX: number;
     scrollY: number;
-}) => boolean;
+}, elementsMap: ElementsMap) => boolean;
 /**
  * Makes a perfect shape or diagonal/horizontal/vertical line
  */

package/dist/excalidraw/element/sizeHelpers.js

@@ -9,8 +9,8 @@ export const isInvisiblySmallElement = (element) => {
     }
     return element.width === 0 && element.height === 0;
 };
-export const isElementInViewport = (element, width, height, viewTransformations) => {
-    const [x1, y1, x2, y2] = getElementBounds(element); // scene coordinates
+export const isElementInViewport = (element, width, height, viewTransformations, elementsMap) => {
+    const [x1, y1, x2, y2] = getElementBounds(element, elementsMap); // scene coordinates
     const topLeftSceneCoords = viewportCoordsToSceneCoords({
         clientX: viewTransformations.offsetLeft,
         clientY: viewTransformations.offsetTop,

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

@@ -1,22 +1,19 @@
-import { ExcalidrawElement, ExcalidrawElementType, ExcalidrawTextContainer, ExcalidrawTextElement, ExcalidrawTextElementWithContainer, FontFamilyValues, FontString, NonDeletedExcalidrawElement } from "./types";
+import { ElementsMap, ExcalidrawElement, ExcalidrawElementType, ExcalidrawTextContainer, ExcalidrawTextElement, ExcalidrawTextElementWithContainer, FontFamilyValues, FontString, NonDeletedExcalidrawElement } from "./types";
 import { MaybeTransformHandleType } from "./transformHandles";
 import { AppState } from "../types";
 import { ExtractSetType } from "../utility-types";
 export declare const normalizeText: (text: string) => string;
-export declare const splitIntoLines: (text: string) => string[];
-export declare const redrawTextBoundingBox: (textElement: ExcalidrawTextElement, container: ExcalidrawElement | null) => void;
-export declare const bindTextToShapeAfterDuplication: (sceneElements: ExcalidrawElement[], oldElements: ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
-export declare const handleBindTextResize: (container: NonDeletedExcalidrawElement, transformHandleType: MaybeTransformHandleType, shouldMaintainAspectRatio?: boolean) => void;
-export declare const computeBoundTextPosition: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElementWithContainer) => {
+export declare const redrawTextBoundingBox: (textElement: ExcalidrawTextElement, container: ExcalidrawElement | null, elementsMap: ElementsMap) => void;
+export declare const bindTextToShapeAfterDuplication: (newElements: ExcalidrawElement[], oldElements: ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
+export declare const handleBindTextResize: (container: NonDeletedExcalidrawElement, elementsMap: ElementsMap, transformHandleType: MaybeTransformHandleType, shouldMaintainAspectRatio?: boolean) => void;
+export declare const computeBoundTextPosition: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElementWithContainer, elementsMap: ElementsMap) => {
     x: number;
     y: number;
 };
 export declare const measureText: (text: string, font: FontString, lineHeight: ExcalidrawTextElement["lineHeight"]) => {
     width: number;
     height: number;
-    baseline: number;
 };
-export declare const measureBaseline: (text: string, font: FontString, lineHeight: ExcalidrawTextElement["lineHeight"], wrapInContainer?: boolean) => number;
 /**
  * To get unitless line-height (if unknown) we can calculate it by dividing
  * height-per-line by fontSize.
@@ -29,6 +26,10 @@ export declare const detectLineHeight: (textElement: ExcalidrawTextElement) => n
  * aligning with the W3C spec.
  */
 export declare const getLineHeightInPx: (fontSize: ExcalidrawTextElement["fontSize"], lineHeight: ExcalidrawTextElement["lineHeight"]) => number;
+/**
+ * Calculates vertical offset for a text with alphabetic baseline.
+ */
+export declare const getVerticalOffset: (fontFamily: ExcalidrawTextElement["fontFamily"], fontSize: ExcalidrawTextElement["fontSize"], lineHeightPx: number) => number;
 export declare const getApproxMinLineHeight: (fontSize: ExcalidrawTextElement["fontSize"], lineHeight: ExcalidrawTextElement["lineHeight"]) => number;
 export declare const getTextWidth: (text: string, font: FontString) => number;
 export declare const getTextHeight: (text: string, fontSize: number, lineHeight: ExcalidrawTextElement["lineHeight"]) => number;
@@ -43,11 +44,9 @@ export declare const getMinCharWidth: (font: FontString) => number;
 export declare const getMaxCharWidth: (font: FontString) => number;
 export declare const getApproxCharsToFitInWidth: (font: FontString, width: number) => number;
 export declare const getBoundTextElementId: (container: ExcalidrawElement | null) => string | null;
-export declare const getBoundTextElement: (element: ExcalidrawElement | null) => ExcalidrawTextElementWithContainer | null;
-export declare const getContainerElement: (element: (ExcalidrawElement & {
-    containerId: ExcalidrawElement["id"] | null;
-}) | null) => ExcalidrawElement | null;
-export declare const getContainerCenter: (container: ExcalidrawElement, appState: AppState) => {
+export declare const getBoundTextElement: (element: ExcalidrawElement | null, elementsMap: ElementsMap) => ExcalidrawTextElementWithContainer | null;
+export declare const getContainerElement: (element: ExcalidrawTextElement | null, elementsMap: ElementsMap) => ExcalidrawTextContainer | null;
+export declare const getContainerCenter: (container: ExcalidrawElement, appState: AppState, elementsMap: ElementsMap) => {
     x: number;
     y: number;
 };
@@ -55,21 +54,20 @@ export declare const getContainerCoords: (container: NonDeletedExcalidrawElement
     x: number;
     y: number;
 };
-export declare const getTextElementAngle: (textElement: ExcalidrawTextElement) => number;
-export declare const getBoundTextElementOffset: (boundTextElement: ExcalidrawTextElement | null) => number;
-export declare const getBoundTextElementPosition: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElementWithContainer) => {
+export declare const getTextElementAngle: (textElement: ExcalidrawTextElement, container: ExcalidrawTextContainer | null) => number;
+export declare const getBoundTextElementPosition: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElementWithContainer, elementsMap: ElementsMap) => {
     x: number;
     y: number;
 } | undefined;
-export declare const shouldAllowVerticalAlign: (selectedElements: NonDeletedExcalidrawElement[]) => boolean;
-export declare const suppportsHorizontalAlign: (selectedElements: NonDeletedExcalidrawElement[]) => boolean;
-export declare const getTextBindableContainerAtPosition: (elements: readonly ExcalidrawElement[], appState: AppState, x: number, y: number) => ExcalidrawTextContainer | null;
+export declare const shouldAllowVerticalAlign: (selectedElements: NonDeletedExcalidrawElement[], elementsMap: ElementsMap) => boolean;
+export declare const suppportsHorizontalAlign: (selectedElements: NonDeletedExcalidrawElement[], elementsMap: ElementsMap) => boolean;
+export declare const getTextBindableContainerAtPosition: (elements: readonly ExcalidrawElement[], appState: AppState, x: number, y: number, elementsMap: ElementsMap) => ExcalidrawTextContainer | null;
 declare const VALID_CONTAINER_TYPES: Set<string>;
 export declare const isValidTextContainer: (element: {
     type: ExcalidrawElementType;
 }) => boolean;
 export declare const computeContainerDimensionForBoundText: (dimension: number, containerType: ExtractSetType<typeof VALID_CONTAINER_TYPES>) => number;
-export declare const getBoundTextMaxWidth: (container: ExcalidrawElement, boundTextElement?: ExcalidrawTextElement | null) => number;
+export declare const getBoundTextMaxWidth: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElement | null) => number;
 export declare const getBoundTextMaxHeight: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElementWithContainer) => number;
 export declare const isMeasureTextSupported: () => boolean;
 export declare const getDefaultLineHeight: (fontFamily: FontFamilyValues) => number & {