@excalidraw/excalidraw 0.17.1-d2f67e6 → 0.17.1-e63dd02

package/dist/excalidraw/element/resizeElements.js

@@ -2,14 +2,15 @@ import { MIN_FONT_SIZE, SHIFT_LOCKING_ANGLE } from "../constants";
 import { rescalePoints } from "../points";
 import { rotate, centerPoint, rotatePoint } from "../math";
 import { getElementAbsoluteCoords, getCommonBounds, getResizedElementAbsoluteCoords, getCommonBoundingBox, } from "./bounds";
-import { isArrowElement, isBoundToContainer, isFrameLikeElement, isFreeDrawElement, isImageElement, isLinearElement, isTextElement, } from "./typeChecks";
+import { isArrowElement, isBoundToContainer, isElbowArrow, isFrameLikeElement, isFreeDrawElement, isImageElement, isLinearElement, isTextElement, } from "./typeChecks";
 import { mutateElement } from "./mutateElement";
 import { getFontString } from "../utils";
-import { updateBoundElements } from "./binding";
+import { getArrowLocalFixedPoints, updateBoundElements } from "./binding";
 import Scene from "../scene/Scene";
 import { getApproxMinLineWidth, getBoundTextElement, getBoundTextElementId, getContainerElement, handleBindTextResize, getBoundTextMaxWidth, getApproxMinLineHeight, wrapText, measureText, getMinTextElementWidth, } from "./textElement";
 import { LinearElementEditor } from "./linearElementEditor";
 import { isInGroup } from "../groups";
+import { mutateElbowArrow } from "./routing";
 export const normalizeAngle = (angle) => {
     if (angle < 0) {
         return angle + 2 * Math.PI;
@@ -20,29 +21,31 @@ export const normalizeAngle = (angle) => {
     return angle;
 };
 // Returns true when transform (resizing/rotation) happened
-export const transformElements = (originalElements, transformHandleType, selectedElements, elementsMap, shouldRotateWithDiscreteAngle, shouldResizeFromCenter, shouldMaintainAspectRatio, pointerX, pointerY, centerX, centerY) => {
+export const transformElements = (originalElements, transformHandleType, selectedElements, elementsMap, shouldRotateWithDiscreteAngle, shouldResizeFromCenter, shouldMaintainAspectRatio, pointerX, pointerY, centerX, centerY, scene) => {
     if (selectedElements.length === 1) {
         const [element] = selectedElements;
         if (transformHandleType === "rotation") {
-            rotateSingleElement(element, elementsMap, pointerX, pointerY, shouldRotateWithDiscreteAngle);
-            updateBoundElements(element, elementsMap);
+            if (!isElbowArrow(element)) {
+                rotateSingleElement(element, elementsMap, pointerX, pointerY, shouldRotateWithDiscreteAngle);
+                updateBoundElements(element, elementsMap, scene);
+            }
         }
         else if (isTextElement(element) && transformHandleType) {
             resizeSingleTextElement(originalElements, element, elementsMap, transformHandleType, shouldResizeFromCenter, pointerX, pointerY);
-            updateBoundElements(element, elementsMap);
+            updateBoundElements(element, elementsMap, scene);
         }
         else if (transformHandleType) {
-            resizeSingleElement(originalElements, shouldMaintainAspectRatio, element, elementsMap, transformHandleType, shouldResizeFromCenter, pointerX, pointerY);
+            resizeSingleElement(originalElements, shouldMaintainAspectRatio, element, elementsMap, transformHandleType, shouldResizeFromCenter, pointerX, pointerY, scene);
         }
         return true;
     }
     else if (selectedElements.length > 1) {
         if (transformHandleType === "rotation") {
-            rotateMultipleElements(originalElements, selectedElements, elementsMap, pointerX, pointerY, shouldRotateWithDiscreteAngle, centerX, centerY);
+            rotateMultipleElements(originalElements, selectedElements, elementsMap, pointerX, pointerY, shouldRotateWithDiscreteAngle, centerX, centerY, scene);
             return true;
         }
         else if (transformHandleType) {
-            resizeMultipleElements(originalElements, selectedElements, elementsMap, transformHandleType, shouldResizeFromCenter, shouldMaintainAspectRatio, pointerX, pointerY);
+            resizeMultipleElements(originalElements, selectedElements, elementsMap, transformHandleType, shouldResizeFromCenter, shouldMaintainAspectRatio, pointerX, pointerY, scene);
             return true;
         }
     }
@@ -224,7 +227,13 @@ const resizeSingleTextElement = (originalElements, element, elementsMap, transfo
         mutateElement(element, resizedElement);
     }
 };
-export const resizeSingleElement = (originalElements, shouldMaintainAspectRatio, element, elementsMap, transformHandleDirection, shouldResizeFromCenter, pointerX, pointerY) => {
+export const resizeSingleElement = (originalElements, shouldMaintainAspectRatio, element, elementsMap, transformHandleDirection, shouldResizeFromCenter, pointerX, pointerY, scene) => {
+    // Elbow arrows cannot be resized when bound on either end
+    if (isArrowElement(element) &&
+        isElbowArrow(element) &&
+        (element.startBinding || element.endBinding)) {
+        return;
+    }
     const stateAtResizeStart = originalElements.get(element.id);
     // Gets bounds corners
     const [x1, y1, x2, y2] = getResizedElementAbsoluteCoords(stateAtResizeStart, stateAtResizeStart.width, stateAtResizeStart.height, true);
@@ -420,8 +429,11 @@ export const resizeSingleElement = (originalElements, shouldMaintainAspectRatio,
         Number.isFinite(resizedElement.x) &&
         Number.isFinite(resizedElement.y)) {
         mutateElement(element, resizedElement);
-        updateBoundElements(element, elementsMap, {
-            newSize: { width: resizedElement.width, height: resizedElement.height },
+        updateBoundElements(element, elementsMap, scene, {
+            oldSize: {
+                width: stateAtResizeStart.width,
+                height: stateAtResizeStart.height,
+            },
         });
         if (boundTextElement && boundTextFont != null) {
             mutateElement(boundTextElement, {
@@ -431,7 +443,7 @@ export const resizeSingleElement = (originalElements, shouldMaintainAspectRatio,
         handleBindTextResize(element, elementsMap, transformHandleDirection, shouldMaintainAspectRatio);
     }
 };
-export const resizeMultipleElements = (originalElements, selectedElements, elementsMap, transformHandleType, shouldResizeFromCenter, shouldMaintainAspectRatio, pointerX, pointerY) => {
+export const resizeMultipleElements = (originalElements, selectedElements, elementsMap, transformHandleType, shouldResizeFromCenter, shouldMaintainAspectRatio, pointerX, pointerY, scene) => {
     // 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
@@ -578,11 +590,17 @@ export const resizeMultipleElements = (originalElements, selectedElements, eleme
     }
     const elementsToUpdate = elementsAndUpdates.map(({ element }) => element);
     for (const { element, update: { boundTextFontSize, ...update }, } of elementsAndUpdates) {
-        const { width, height, angle } = update;
+        const { angle } = update;
+        const { width: oldWidth, height: oldHeight } = element;
         mutateElement(element, update, false);
-        updateBoundElements(element, elementsMap, {
+        if (isArrowElement(element) && isElbowArrow(element)) {
+            mutateElbowArrow(element, scene, element.points, undefined, undefined, {
+                informMutation: false,
+            });
+        }
+        updateBoundElements(element, elementsMap, scene, {
             simultaneouslyUpdated: elementsToUpdate,
-            newSize: { width, height },
+            oldSize: { width: oldWidth, height: oldHeight },
         });
         const boundTextElement = getBoundTextElement(element, elementsMap);
         if (boundTextElement && boundTextFontSize) {
@@ -595,7 +613,7 @@ export const resizeMultipleElements = (originalElements, selectedElements, eleme
     }
     Scene.getScene(elementsAndUpdates[0].element)?.triggerUpdate();
 };
-const rotateMultipleElements = (originalElements, elements, elementsMap, pointerX, pointerY, shouldRotateWithDiscreteAngle, centerX, centerY) => {
+const rotateMultipleElements = (originalElements, elements, elementsMap, pointerX, pointerY, shouldRotateWithDiscreteAngle, centerX, centerY, scene) => {
     let centerAngle = (5 * Math.PI) / 2 + Math.atan2(pointerY - centerY, pointerX - centerX);
     if (shouldRotateWithDiscreteAngle) {
         centerAngle += SHIFT_LOCKING_ANGLE / 2;
@@ -609,12 +627,18 @@ const rotateMultipleElements = (originalElements, elements, elementsMap, pointer
         const cy = (y1 + y2) / 2;
         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, elementsMap, {
+        if (isArrowElement(element) && isElbowArrow(element)) {
+            const points = getArrowLocalFixedPoints(element, elementsMap);
+            mutateElbowArrow(element, scene, points);
+        }
+        else {
+            mutateElement(element, {
+                x: element.x + (rotatedCX - cx),
+                y: element.y + (rotatedCY - cy),
+                angle: normalizeAngle(centerAngle + origAngle),
+            }, false);
+        }
+        updateBoundElements(element, elementsMap, scene, {
             simultaneouslyUpdated: elements,
         });
         const boundText = getBoundTextElement(element, elementsMap);

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

@@ -0,0 +1,13 @@
+import type Scene from "../scene/Scene";
+import type { Point } from "../types";
+import type { ExcalidrawElbowArrowElement, FixedPointBinding } from "./types";
+import type { OrderedExcalidrawElement } from "./types";
+export declare const mutateElbowArrow: (arrow: ExcalidrawElbowArrowElement, scene: Scene, nextPoints: readonly Point[], offset?: Point, otherUpdates?: {
+    startBinding?: FixedPointBinding | null;
+    endBinding?: FixedPointBinding | null;
+}, options?: {
+    changedElements?: Map<string, OrderedExcalidrawElement>;
+    isDragging?: boolean;
+    disableBinding?: boolean;
+    informMutation?: boolean;
+}) => void;