@excalidraw/excalidraw 0.17.1-d2f67e6 → 0.17.1-e63dd02

package/dist/excalidraw/components/Stats/MultiAngle.js

@@ -8,50 +8,59 @@ import { angleIcon } from "../icons";
 import DragInput from "./DragInput";
 import { getStepSizedValue, isPropertyEditable } from "./utils";
 const STEP_SIZE = 15;
-const MultiAngle = ({ elements, elementsMap, scene }) => {
-    const handleDegreeChange = ({ accumulatedChange, originalElements, shouldChangeByStepSize, nextValue, }) => {
-        const editableLatestIndividualElements = elements.filter((el) => !isInGroup(el) && isPropertyEditable(el, "angle"));
-        const editableOriginalIndividualElements = originalElements.filter((el) => !isInGroup(el) && isPropertyEditable(el, "angle"));
-        if (nextValue !== undefined) {
-            const nextAngle = degreeToRadian(nextValue);
-            for (const element of editableLatestIndividualElements) {
-                mutateElement(element, {
-                    angle: nextAngle,
-                }, false);
-                const boundTextElement = getBoundTextElement(element, elementsMap);
-                if (boundTextElement && !isArrowElement(element)) {
-                    mutateElement(boundTextElement, { angle: nextAngle }, false);
-                }
+const handleDegreeChange = ({ accumulatedChange, originalElements, shouldChangeByStepSize, nextValue, property, scene, }) => {
+    const elementsMap = scene.getNonDeletedElementsMap();
+    const editableLatestIndividualElements = originalElements
+        .map((el) => elementsMap.get(el.id))
+        .filter((el) => el && !isInGroup(el) && isPropertyEditable(el, property));
+    const editableOriginalIndividualElements = originalElements.filter((el) => !isInGroup(el) && isPropertyEditable(el, property));
+    if (nextValue !== undefined) {
+        const nextAngle = degreeToRadian(nextValue);
+        for (const element of editableLatestIndividualElements) {
+            if (!element) {
+                continue;
             }
-            scene.triggerUpdate();
-            return;
-        }
-        for (let i = 0; i < editableLatestIndividualElements.length; i++) {
-            const latestElement = editableLatestIndividualElements[i];
-            const originalElement = editableOriginalIndividualElements[i];
-            const originalAngleInDegrees = Math.round(radianToDegree(originalElement.angle) * 100) / 100;
-            const changeInDegrees = Math.round(accumulatedChange);
-            let nextAngleInDegrees = (originalAngleInDegrees + changeInDegrees) % 360;
-            if (shouldChangeByStepSize) {
-                nextAngleInDegrees = getStepSizedValue(nextAngleInDegrees, STEP_SIZE);
-            }
-            nextAngleInDegrees =
-                nextAngleInDegrees < 0 ? nextAngleInDegrees + 360 : nextAngleInDegrees;
-            const nextAngle = degreeToRadian(nextAngleInDegrees);
-            mutateElement(latestElement, {
+            mutateElement(element, {
                 angle: nextAngle,
             }, false);
-            const boundTextElement = getBoundTextElement(latestElement, elementsMap);
-            if (boundTextElement && !isArrowElement(latestElement)) {
+            const boundTextElement = getBoundTextElement(element, elementsMap);
+            if (boundTextElement && !isArrowElement(element)) {
                 mutateElement(boundTextElement, { angle: nextAngle }, false);
             }
         }
         scene.triggerUpdate();
-    };
+        return;
+    }
+    for (let i = 0; i < editableLatestIndividualElements.length; i++) {
+        const latestElement = editableLatestIndividualElements[i];
+        if (!latestElement) {
+            continue;
+        }
+        const originalElement = editableOriginalIndividualElements[i];
+        const originalAngleInDegrees = Math.round(radianToDegree(originalElement.angle) * 100) / 100;
+        const changeInDegrees = Math.round(accumulatedChange);
+        let nextAngleInDegrees = (originalAngleInDegrees + changeInDegrees) % 360;
+        if (shouldChangeByStepSize) {
+            nextAngleInDegrees = getStepSizedValue(nextAngleInDegrees, STEP_SIZE);
+        }
+        nextAngleInDegrees =
+            nextAngleInDegrees < 0 ? nextAngleInDegrees + 360 : nextAngleInDegrees;
+        const nextAngle = degreeToRadian(nextAngleInDegrees);
+        mutateElement(latestElement, {
+            angle: nextAngle,
+        }, false);
+        const boundTextElement = getBoundTextElement(latestElement, elementsMap);
+        if (boundTextElement && !isArrowElement(latestElement)) {
+            mutateElement(boundTextElement, { angle: nextAngle }, false);
+        }
+    }
+    scene.triggerUpdate();
+};
+const MultiAngle = ({ elements, scene, appState, property, }) => {
     const editableLatestIndividualElements = elements.filter((el) => !isInGroup(el) && isPropertyEditable(el, "angle"));
     const angles = editableLatestIndividualElements.map((el) => Math.round((radianToDegree(el.angle) % 360) * 100) / 100);
     const value = new Set(angles).size === 1 ? angles[0] : "Mixed";
     const editable = editableLatestIndividualElements.some((el) => isPropertyEditable(el, "angle"));
-    return (_jsx(DragInput, { label: "A", icon: angleIcon, value: value, elements: elements, dragInputCallback: handleDegreeChange, editable: editable }));
+    return (_jsx(DragInput, { label: "A", icon: angleIcon, value: value, elements: elements, dragInputCallback: handleDegreeChange, editable: editable, appState: appState, scene: scene, property: property }));
 };
 export default MultiAngle;

package/dist/excalidraw/components/Stats/MultiDimension.d.ts

@@ -1,13 +1,15 @@
 /// <reference types="react" />
-import type { ElementsMap, ExcalidrawElement } from "../../element/types";
+import type { ExcalidrawElement, NonDeletedSceneElementsMap } from "../../element/types";
 import type Scene from "../../scene/Scene";
+import type { AppState } from "../../types";
 import type { AtomicUnit } from "./utils";
 interface MultiDimensionProps {
     property: "width" | "height";
     elements: readonly ExcalidrawElement[];
-    elementsMap: ElementsMap;
+    elementsMap: NonDeletedSceneElementsMap;
     atomicUnits: AtomicUnit[];
     scene: Scene;
+    appState: AppState;
 }
-declare const MultiDimension: ({ property, elements, elementsMap, atomicUnits, scene, }: MultiDimensionProps) => JSX.Element;
+declare const MultiDimension: ({ property, elements, elementsMap, atomicUnits, scene, appState, }: MultiDimensionProps) => JSX.Element;
 export default MultiDimension;

package/dist/excalidraw/components/Stats/MultiDimension.js

@@ -6,7 +6,7 @@ import { mutateElement } from "../../element/mutateElement";
 import { rescalePointsInElement } from "../../element/resizeElements";
 import { getBoundTextElement, handleBindTextResize, } from "../../element/textElement";
 import DragInput from "./DragInput";
-import { getStepSizedValue, isPropertyEditable } from "./utils";
+import { getAtomicUnits, getStepSizedValue, isPropertyEditable } from "./utils";
 import { getElementsInAtomicUnit, resizeElement } from "./utils";
 import { MIN_WIDTH_OR_HEIGHT } from "../../constants";
 const STEP_SIZE = 10;
@@ -28,14 +28,15 @@ const getResizedUpdates = (anchorX, anchorY, scale, origElement) => {
             : {}),
     };
 };
-const resizeElementInGroup = (anchorX, anchorY, property, scale, latestElement, origElement, elementsMap, originalElementsMap) => {
+const resizeElementInGroup = (anchorX, anchorY, property, scale, latestElement, origElement, elementsMap, originalElementsMap, scene) => {
     const updates = getResizedUpdates(anchorX, anchorY, scale, origElement);
+    const { width: oldWidth, height: oldHeight } = latestElement;
     mutateElement(latestElement, updates, false);
     const boundTextElement = getBoundTextElement(origElement, originalElementsMap);
     if (boundTextElement) {
         const newFontSize = boundTextElement.fontSize * scale;
-        updateBoundElements(latestElement, elementsMap, {
-            newSize: { width: updates.width, height: updates.height },
+        updateBoundElements(latestElement, elementsMap, scene, {
+            oldSize: { width: oldWidth, height: oldHeight },
         });
         const latestBoundTextElement = elementsMap.get(boundTextElement.id);
         if (latestBoundTextElement && isTextElement(latestBoundTextElement)) {
@@ -46,7 +47,7 @@ const resizeElementInGroup = (anchorX, anchorY, property, scale, latestElement,
         }
     }
 };
-const resizeGroup = (nextWidth, nextHeight, initialHeight, aspectRatio, anchor, property, latestElements, originalElements, elementsMap, originalElementsMap) => {
+const resizeGroup = (nextWidth, nextHeight, initialHeight, aspectRatio, anchor, property, latestElements, originalElements, elementsMap, originalElementsMap, scene) => {
     // keep aspect ratio for groups
     if (property === "width") {
         nextHeight = Math.round((nextWidth / aspectRatio) * 100) / 100;
@@ -58,76 +59,14 @@ const resizeGroup = (nextWidth, nextHeight, initialHeight, aspectRatio, anchor,
     for (let i = 0; i < originalElements.length; i++) {
         const origElement = originalElements[i];
         const latestElement = latestElements[i];
-        resizeElementInGroup(anchor[0], anchor[1], property, scale, latestElement, origElement, elementsMap, originalElementsMap);
+        resizeElementInGroup(anchor[0], anchor[1], property, scale, latestElement, origElement, elementsMap, originalElementsMap, scene);
     }
 };
-const MultiDimension = ({ property, elements, elementsMap, atomicUnits, scene, }) => {
-    const sizes = useMemo(() => atomicUnits.map((atomicUnit) => {
-        const elementsInUnit = getElementsInAtomicUnit(atomicUnit, elementsMap);
-        if (elementsInUnit.length > 1) {
-            const [x1, y1, x2, y2] = getCommonBounds(elementsInUnit.map((el) => el.latest));
-            return (Math.round((property === "width" ? x2 - x1 : y2 - y1) * 100) / 100);
-        }
-        const [el] = elementsInUnit;
-        return (Math.round((property === "width" ? el.latest.width : el.latest.height) * 100) / 100);
-    }), [elementsMap, atomicUnits, property]);
-    const value = new Set(sizes).size === 1 ? Math.round(sizes[0] * 100) / 100 : "Mixed";
-    const editable = sizes.length > 0;
-    const handleDimensionChange = ({ accumulatedChange, originalElementsMap, shouldChangeByStepSize, nextValue, }) => {
-        if (nextValue !== undefined) {
-            for (const atomicUnit of atomicUnits) {
-                const elementsInUnit = getElementsInAtomicUnit(atomicUnit, elementsMap, originalElementsMap);
-                if (elementsInUnit.length > 1) {
-                    const latestElements = elementsInUnit.map((el) => el.latest);
-                    const originalElements = elementsInUnit.map((el) => el.original);
-                    const [x1, y1, x2, y2] = getCommonBounds(originalElements);
-                    const initialWidth = x2 - x1;
-                    const initialHeight = y2 - y1;
-                    const aspectRatio = initialWidth / initialHeight;
-                    const nextWidth = Math.max(MIN_WIDTH_OR_HEIGHT, property === "width" ? Math.max(0, nextValue) : initialWidth);
-                    const nextHeight = Math.max(MIN_WIDTH_OR_HEIGHT, property === "height" ? Math.max(0, nextValue) : initialHeight);
-                    resizeGroup(nextWidth, nextHeight, initialHeight, aspectRatio, [x1, y1], property, latestElements, originalElements, elementsMap, originalElementsMap);
-                }
-                else {
-                    const [el] = elementsInUnit;
-                    const latestElement = el?.latest;
-                    const origElement = el?.original;
-                    if (latestElement &&
-                        origElement &&
-                        isPropertyEditable(latestElement, property)) {
-                        let nextWidth = property === "width"
-                            ? Math.max(0, nextValue)
-                            : latestElement.width;
-                        if (property === "width") {
-                            if (shouldChangeByStepSize) {
-                                nextWidth = getStepSizedValue(nextWidth, STEP_SIZE);
-                            }
-                            else {
-                                nextWidth = Math.round(nextWidth);
-                            }
-                        }
-                        let nextHeight = property === "height"
-                            ? Math.max(0, nextValue)
-                            : latestElement.height;
-                        if (property === "height") {
-                            if (shouldChangeByStepSize) {
-                                nextHeight = getStepSizedValue(nextHeight, STEP_SIZE);
-                            }
-                            else {
-                                nextHeight = Math.round(nextHeight);
-                            }
-                        }
-                        nextWidth = Math.max(MIN_WIDTH_OR_HEIGHT, nextWidth);
-                        nextHeight = Math.max(MIN_WIDTH_OR_HEIGHT, nextHeight);
-                        resizeElement(nextWidth, nextHeight, false, latestElement, origElement, elementsMap, originalElementsMap, false);
-                    }
-                }
-            }
-            scene.triggerUpdate();
-            return;
-        }
-        const changeInWidth = property === "width" ? accumulatedChange : 0;
-        const changeInHeight = property === "height" ? accumulatedChange : 0;
+const handleDimensionChange = ({ accumulatedChange, originalElements, originalElementsMap, originalAppState, shouldChangeByStepSize, nextValue, scene, property, }) => {
+    const elementsMap = scene.getNonDeletedElementsMap();
+    const elements = scene.getNonDeletedElements();
+    const atomicUnits = getAtomicUnits(originalElements, originalAppState);
+    if (nextValue !== undefined) {
         for (const atomicUnit of atomicUnits) {
             const elementsInUnit = getElementsInAtomicUnit(atomicUnit, elementsMap, originalElementsMap);
             if (elementsInUnit.length > 1) {
@@ -137,27 +76,9 @@ const MultiDimension = ({ property, elements, elementsMap, atomicUnits, scene, }
                 const initialWidth = x2 - x1;
                 const initialHeight = y2 - y1;
                 const aspectRatio = initialWidth / initialHeight;
-                let nextWidth = Math.max(0, initialWidth + changeInWidth);
-                if (property === "width") {
-                    if (shouldChangeByStepSize) {
-                        nextWidth = getStepSizedValue(nextWidth, STEP_SIZE);
-                    }
-                    else {
-                        nextWidth = Math.round(nextWidth);
-                    }
-                }
-                let nextHeight = Math.max(0, initialHeight + changeInHeight);
-                if (property === "height") {
-                    if (shouldChangeByStepSize) {
-                        nextHeight = getStepSizedValue(nextHeight, STEP_SIZE);
-                    }
-                    else {
-                        nextHeight = Math.round(nextHeight);
-                    }
-                }
-                nextWidth = Math.max(MIN_WIDTH_OR_HEIGHT, nextWidth);
-                nextHeight = Math.max(MIN_WIDTH_OR_HEIGHT, nextHeight);
-                resizeGroup(nextWidth, nextHeight, initialHeight, aspectRatio, [x1, y1], property, latestElements, originalElements, elementsMap, originalElementsMap);
+                const nextWidth = Math.max(MIN_WIDTH_OR_HEIGHT, property === "width" ? Math.max(0, nextValue) : initialWidth);
+                const nextHeight = Math.max(MIN_WIDTH_OR_HEIGHT, property === "height" ? Math.max(0, nextValue) : initialHeight);
+                resizeGroup(nextWidth, nextHeight, initialHeight, aspectRatio, [x1, y1], property, latestElements, originalElements, elementsMap, originalElementsMap, scene);
             }
             else {
                 const [el] = elementsInUnit;
@@ -166,7 +87,7 @@ const MultiDimension = ({ property, elements, elementsMap, atomicUnits, scene, }
                 if (latestElement &&
                     origElement &&
                     isPropertyEditable(latestElement, property)) {
-                    let nextWidth = Math.max(0, origElement.width + changeInWidth);
+                    let nextWidth = property === "width" ? Math.max(0, nextValue) : latestElement.width;
                     if (property === "width") {
                         if (shouldChangeByStepSize) {
                             nextWidth = getStepSizedValue(nextWidth, STEP_SIZE);
@@ -175,7 +96,9 @@ const MultiDimension = ({ property, elements, elementsMap, atomicUnits, scene, }
                             nextWidth = Math.round(nextWidth);
                         }
                     }
-                    let nextHeight = Math.max(0, origElement.height + changeInHeight);
+                    let nextHeight = property === "height"
+                        ? Math.max(0, nextValue)
+                        : latestElement.height;
                     if (property === "height") {
                         if (shouldChangeByStepSize) {
                             nextHeight = getStepSizedValue(nextHeight, STEP_SIZE);
@@ -186,12 +109,91 @@ const MultiDimension = ({ property, elements, elementsMap, atomicUnits, scene, }
                     }
                     nextWidth = Math.max(MIN_WIDTH_OR_HEIGHT, nextWidth);
                     nextHeight = Math.max(MIN_WIDTH_OR_HEIGHT, nextHeight);
-                    resizeElement(nextWidth, nextHeight, false, latestElement, origElement, elementsMap, originalElementsMap);
+                    resizeElement(nextWidth, nextHeight, false, origElement, elementsMap, elements, scene, false);
                 }
             }
         }
         scene.triggerUpdate();
-    };
-    return (_jsx(DragInput, { label: property === "width" ? "W" : "H", elements: elements, dragInputCallback: handleDimensionChange, value: value, editable: editable }));
+        return;
+    }
+    const changeInWidth = property === "width" ? accumulatedChange : 0;
+    const changeInHeight = property === "height" ? accumulatedChange : 0;
+    for (const atomicUnit of atomicUnits) {
+        const elementsInUnit = getElementsInAtomicUnit(atomicUnit, elementsMap, originalElementsMap);
+        if (elementsInUnit.length > 1) {
+            const latestElements = elementsInUnit.map((el) => el.latest);
+            const originalElements = elementsInUnit.map((el) => el.original);
+            const [x1, y1, x2, y2] = getCommonBounds(originalElements);
+            const initialWidth = x2 - x1;
+            const initialHeight = y2 - y1;
+            const aspectRatio = initialWidth / initialHeight;
+            let nextWidth = Math.max(0, initialWidth + changeInWidth);
+            if (property === "width") {
+                if (shouldChangeByStepSize) {
+                    nextWidth = getStepSizedValue(nextWidth, STEP_SIZE);
+                }
+                else {
+                    nextWidth = Math.round(nextWidth);
+                }
+            }
+            let nextHeight = Math.max(0, initialHeight + changeInHeight);
+            if (property === "height") {
+                if (shouldChangeByStepSize) {
+                    nextHeight = getStepSizedValue(nextHeight, STEP_SIZE);
+                }
+                else {
+                    nextHeight = Math.round(nextHeight);
+                }
+            }
+            nextWidth = Math.max(MIN_WIDTH_OR_HEIGHT, nextWidth);
+            nextHeight = Math.max(MIN_WIDTH_OR_HEIGHT, nextHeight);
+            resizeGroup(nextWidth, nextHeight, initialHeight, aspectRatio, [x1, y1], property, latestElements, originalElements, elementsMap, originalElementsMap, scene);
+        }
+        else {
+            const [el] = elementsInUnit;
+            const latestElement = el?.latest;
+            const origElement = el?.original;
+            if (latestElement &&
+                origElement &&
+                isPropertyEditable(latestElement, property)) {
+                let nextWidth = Math.max(0, origElement.width + changeInWidth);
+                if (property === "width") {
+                    if (shouldChangeByStepSize) {
+                        nextWidth = getStepSizedValue(nextWidth, STEP_SIZE);
+                    }
+                    else {
+                        nextWidth = Math.round(nextWidth);
+                    }
+                }
+                let nextHeight = Math.max(0, origElement.height + changeInHeight);
+                if (property === "height") {
+                    if (shouldChangeByStepSize) {
+                        nextHeight = getStepSizedValue(nextHeight, STEP_SIZE);
+                    }
+                    else {
+                        nextHeight = Math.round(nextHeight);
+                    }
+                }
+                nextWidth = Math.max(MIN_WIDTH_OR_HEIGHT, nextWidth);
+                nextHeight = Math.max(MIN_WIDTH_OR_HEIGHT, nextHeight);
+                resizeElement(nextWidth, nextHeight, false, origElement, elementsMap, elements, scene);
+            }
+        }
+    }
+    scene.triggerUpdate();
+};
+const MultiDimension = ({ property, elements, elementsMap, atomicUnits, scene, appState, }) => {
+    const sizes = useMemo(() => atomicUnits.map((atomicUnit) => {
+        const elementsInUnit = getElementsInAtomicUnit(atomicUnit, elementsMap);
+        if (elementsInUnit.length > 1) {
+            const [x1, y1, x2, y2] = getCommonBounds(elementsInUnit.map((el) => el.latest));
+            return (Math.round((property === "width" ? x2 - x1 : y2 - y1) * 100) / 100);
+        }
+        const [el] = elementsInUnit;
+        return (Math.round((property === "width" ? el.latest.width : el.latest.height) * 100) / 100);
+    }), [elementsMap, atomicUnits, property]);
+    const value = new Set(sizes).size === 1 ? Math.round(sizes[0] * 100) / 100 : "Mixed";
+    const editable = sizes.length > 0;
+    return (_jsx(DragInput, { label: property === "width" ? "W" : "H", elements: elements, dragInputCallback: handleDimensionChange, value: value, editable: editable, appState: appState, property: property, scene: scene }));
 };
 export default MultiDimension;

package/dist/excalidraw/components/Stats/MultiFontSize.d.ts

@@ -1,10 +1,13 @@
 /// <reference types="react" />
-import type { ElementsMap, ExcalidrawElement } from "../../element/types";
+import type { ExcalidrawElement, NonDeletedSceneElementsMap } from "../../element/types";
 import type Scene from "../../scene/Scene";
+import type { AppState } from "../../types";
 interface MultiFontSizeProps {
     elements: readonly ExcalidrawElement[];
-    elementsMap: ElementsMap;
     scene: Scene;
+    elementsMap: NonDeletedSceneElementsMap;
+    appState: AppState;
+    property: "fontSize";
 }
-declare const MultiFontSize: ({ elements, elementsMap, scene, }: MultiFontSizeProps) => JSX.Element;
+declare const MultiFontSize: ({ elements, scene, appState, property, elementsMap, }: MultiFontSizeProps) => JSX.Element | null;
 export default MultiFontSize;

package/dist/excalidraw/components/Stats/MultiFontSize.js

@@ -1,36 +1,47 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { isTextElement, refreshTextDimensions } from "../../element";
+import { isTextElement, redrawTextBoundingBox } from "../../element";
 import { mutateElement } from "../../element/mutateElement";
-import { isBoundToContainer } from "../../element/typeChecks";
+import { hasBoundTextElement } from "../../element/typeChecks";
 import { isInGroup } from "../../groups";
 import { fontSizeIcon } from "../icons";
 import StatsDragInput from "./DragInput";
 import { getStepSizedValue } from "./utils";
+import { getBoundTextElement } from "../../element/textElement";
 const MIN_FONT_SIZE = 4;
 const STEP_SIZE = 4;
-const MultiFontSize = ({ elements, elementsMap, scene, }) => {
-    const latestTextElements = elements.filter((el) => !isInGroup(el) && isTextElement(el) && !isBoundToContainer(el));
-    const fontSizes = latestTextElements.map((textEl) => Math.round(textEl.fontSize * 10) / 10);
-    const value = new Set(fontSizes).size === 1 ? fontSizes[0] : "Mixed";
-    const editable = fontSizes.length > 0;
-    const handleFontSizeChange = ({ accumulatedChange, originalElements, shouldChangeByStepSize, nextValue, }) => {
-        if (nextValue) {
-            const nextFontSize = Math.max(Math.round(nextValue), MIN_FONT_SIZE);
-            for (const textElement of latestTextElements) {
-                const newElement = {
-                    ...textElement,
-                    fontSize: nextFontSize,
-                };
-                const updates = refreshTextDimensions(newElement, null, elementsMap);
-                mutateElement(textElement, {
-                    ...updates,
-                    fontSize: nextFontSize,
-                }, false);
-            }
-            scene.triggerUpdate();
-            return;
+const getApplicableTextElements = (elements, elementsMap) => elements.reduce((acc, el) => {
+    if (!el || isInGroup(el)) {
+        return acc;
+    }
+    if (isTextElement(el)) {
+        acc.push(el);
+        return acc;
+    }
+    if (hasBoundTextElement(el)) {
+        const boundTextElement = getBoundTextElement(el, elementsMap);
+        if (boundTextElement) {
+            acc.push(boundTextElement);
+            return acc;
+        }
+    }
+    return acc;
+}, []);
+const handleFontSizeChange = ({ accumulatedChange, originalElements, shouldChangeByStepSize, nextValue, scene, }) => {
+    const elementsMap = scene.getNonDeletedElementsMap();
+    const latestTextElements = originalElements.map((el) => elementsMap.get(el.id));
+    let nextFontSize;
+    if (nextValue) {
+        nextFontSize = Math.max(Math.round(nextValue), MIN_FONT_SIZE);
+        for (const textElement of latestTextElements) {
+            mutateElement(textElement, {
+                fontSize: nextFontSize,
+            }, false);
+            redrawTextBoundingBox(textElement, scene.getContainerElement(textElement), elementsMap, false);
         }
-        const originalTextElements = originalElements.filter((el) => !isInGroup(el) && isTextElement(el) && !isBoundToContainer(el));
+        scene.triggerUpdate();
+    }
+    else {
+        const originalTextElements = originalElements;
         for (let i = 0; i < latestTextElements.length; i++) {
             const latestElement = latestTextElements[i];
             const originalElement = originalTextElements[i];
@@ -40,18 +51,22 @@ const MultiFontSize = ({ elements, elementsMap, scene, }) => {
             if (shouldChangeByStepSize) {
                 nextFontSize = getStepSizedValue(nextFontSize, STEP_SIZE);
             }
-            const newElement = {
-                ...latestElement,
-                fontSize: nextFontSize,
-            };
-            const updates = refreshTextDimensions(newElement, null, elementsMap);
             mutateElement(latestElement, {
-                ...updates,
                 fontSize: nextFontSize,
             }, false);
+            redrawTextBoundingBox(latestElement, scene.getContainerElement(latestElement), elementsMap, false);
         }
         scene.triggerUpdate();
-    };
-    return (_jsx(StatsDragInput, { label: "F", icon: fontSizeIcon, elements: elements, dragInputCallback: handleFontSizeChange, value: value, editable: editable }));
+    }
+};
+const MultiFontSize = ({ elements, scene, appState, property, elementsMap, }) => {
+    const latestTextElements = getApplicableTextElements(elements, elementsMap);
+    if (!latestTextElements.length) {
+        return null;
+    }
+    const fontSizes = latestTextElements.map((textEl) => Math.round(textEl.fontSize * 10) / 10);
+    const value = new Set(fontSizes).size === 1 ? fontSizes[0] : "Mixed";
+    const editable = fontSizes.length > 0;
+    return (_jsx(StatsDragInput, { label: "F", icon: fontSizeIcon, elements: latestTextElements, dragInputCallback: handleFontSizeChange, value: value, editable: editable, scene: scene, property: property, appState: appState }));
 };
 export default MultiFontSize;

package/dist/excalidraw/components/Stats/MultiPosition.d.ts

@@ -2,12 +2,14 @@
 import type { ElementsMap, ExcalidrawElement } from "../../element/types";
 import type Scene from "../../scene/Scene";
 import type { AtomicUnit } from "./utils";
+import type { AppState } from "../../types";
 interface MultiPositionProps {
     property: "x" | "y";
     elements: readonly ExcalidrawElement[];
     elementsMap: ElementsMap;
     atomicUnits: AtomicUnit[];
     scene: Scene;
+    appState: AppState;
 }
-declare const MultiPosition: ({ property, elements, elementsMap, atomicUnits, scene, }: MultiPositionProps) => JSX.Element;
+declare const MultiPosition: ({ property, elements, elementsMap, atomicUnits, scene, appState, }: MultiPositionProps) => JSX.Element;
 export default MultiPosition;