@excalidraw/excalidraw 0.17.1-c0b80a0 → 0.17.1-c329470

package/dist/excalidraw/element/bounds.js

@@ -329,6 +329,10 @@ export const getArrowheadSize = (arrowhead) => {
         case "diamond":
         case "diamond_outline":
             return 12;
+        case "crowfoot_many":
+        case "crowfoot_one":
+        case "crowfoot_one_or_many":
+            return 20;
         default:
             return 15;
     }
@@ -413,6 +417,12 @@ export const getArrowheadPoints = (element, shape, position, arrowhead) => {
         return [x2, y2, diameter];
     }
     const angle = getArrowheadAngle(arrowhead);
+    if (arrowhead === "crowfoot_many" || arrowhead === "crowfoot_one_or_many") {
+        // swap (xs, ys) with (x2, y2)
+        const [x3, y3] = pointRotateRads(pointFrom(x2, y2), pointFrom(xs, ys), degreesToRadians(-angle));
+        const [x4, y4] = pointRotateRads(pointFrom(x2, y2), pointFrom(xs, ys), degreesToRadians(angle));
+        return [xs, ys, x3, y3, x4, y4];
+    }
     // Return points
     const [x3, y3] = pointRotateRads(pointFrom(xs, ys), pointFrom(x2, y2), ((-angle * Math.PI) / 180));
     const [x4, y4] = pointRotateRads(pointFrom(xs, ys), pointFrom(x2, y2), degreesToRadians(angle));

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

@@ -1,5 +1,6 @@
 import type { TransformHandleType } from "./transformHandles";
 import type { ElementsMap, ExcalidrawImageElement, ImageCrop } from "./types";
+export declare const MINIMAL_CROP_SIZE = 10;
 export declare const cropElement: (element: ExcalidrawImageElement, transformHandle: TransformHandleType, naturalWidth: number, naturalHeight: number, pointerX: number, pointerY: number, widthAspectRatio?: number) => {
     x: number;
     y: number;
@@ -12,3 +13,7 @@ export declare const getUncroppedWidthAndHeight: (element: ExcalidrawImageElemen
     width: number;
     height: number;
 };
+export declare const getFlipAdjustedCropPosition: (element: ExcalidrawImageElement, natural?: boolean) => {
+    x: number;
+    y: number;
+} | null;

package/dist/excalidraw/element/cropElement.js

@@ -1,6 +1,6 @@
 import { pointFrom, pointCenter, pointRotateRads, vectorFromPoint, vectorNormalize, vectorSubtract, vectorAdd, vectorScale, pointFromVector, clamp, isCloseTo, } from "../../math";
 import { getElementAbsoluteCoords, getResizedElementAbsoluteCoords, } from "./bounds";
-const MINIMAL_CROP_SIZE = 10;
+export const MINIMAL_CROP_SIZE = 10;
 export const cropElement = (element, transformHandle, naturalWidth, naturalHeight, pointerX, pointerY, widthAspectRatio) => {
     const { width: uncroppedWidth, height: uncroppedHeight } = getUncroppedWidthAndHeight(element);
     const naturalWidthToUncropped = naturalWidth / uncroppedWidth;
@@ -335,3 +335,30 @@ const adjustCropPosition = (crop, scale) => {
         cropY,
     };
 };
+export const getFlipAdjustedCropPosition = (element, natural = false) => {
+    const crop = element.crop;
+    if (!crop) {
+        return null;
+    }
+    const isFlippedByX = element.scale[0] === -1;
+    const isFlippedByY = element.scale[1] === -1;
+    let cropX = crop.x;
+    let cropY = crop.y;
+    if (isFlippedByX) {
+        cropX = crop.naturalWidth - crop.width - crop.x;
+    }
+    if (isFlippedByY) {
+        cropY = crop.naturalHeight - crop.height - crop.y;
+    }
+    if (natural) {
+        return {
+            x: cropX,
+            y: cropY,
+        };
+    }
+    const { width, height } = getUncroppedWidthAndHeight(element);
+    return {
+        x: cropX / (crop.naturalWidth / width),
+        y: cropY / (crop.naturalHeight / height),
+    };
+};

package/dist/excalidraw/element/dragElements.js

@@ -13,7 +13,14 @@ export const dragSelectedElements = (pointerDownState, _selectedElements, offset
         (_selectedElements[0].startBinding || _selectedElements[0].endBinding)) {
         return;
     }
-    const selectedElements = _selectedElements.filter((el) => !(isElbowArrow(el) && el.startBinding && el.endBinding));
+    const selectedElements = _selectedElements.filter((element) => {
+        if (isElbowArrow(element) && element.startBinding && element.endBinding) {
+            const startElement = _selectedElements.find((el) => el.id === element.startBinding?.elementId);
+            const endElement = _selectedElements.find((el) => el.id === element.endBinding?.elementId);
+            return startElement && endElement;
+        }
+        return true;
+    });
     // we do not want a frame and its elements to be selected at the same time
     // but when it happens (due to some bug), we want to avoid updating element
     // in the frame twice, hence the use of set
@@ -32,17 +39,16 @@ export const dragSelectedElements = (pointerDownState, _selectedElements, offset
     const adjustedOffset = calculateOffset(commonBounds, offset, snapOffset, gridSize);
     elementsToUpdate.forEach((element) => {
         updateElementCoords(pointerDownState, element, adjustedOffset);
-        if (
-        // skip arrow labels since we calculate its position during render
-        !isArrowElement(element)) {
+        if (!isArrowElement(element)) {
+            // skip arrow labels since we calculate its position during render
             const textElement = getBoundTextElement(element, scene.getNonDeletedElementsMap());
             if (textElement) {
                 updateElementCoords(pointerDownState, textElement, adjustedOffset);
             }
+            updateBoundElements(element, scene.getElementsMapIncludingDeleted(), {
+                simultaneouslyUpdated: Array.from(elementsToUpdate),
+            });
         }
-        updateBoundElements(element, scene.getElementsMapIncludingDeleted(), {
-            simultaneouslyUpdated: Array.from(elementsToUpdate),
-        });
     });
 };
 const calculateOffset = (commonBounds, dragOffset, snapOffset, gridSize) => {

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

@@ -0,0 +1,16 @@
+import { type LocalPoint } from "../../math";
+import { type ElementUpdate } from "./mutateElement";
+import { type ExcalidrawElbowArrowElement, type NonDeletedSceneElementsMap, type SceneElementsMap } from "./types";
+import type { FixedPointBinding, FixedSegment } from "./types";
+export declare const BASE_PADDING = 40;
+/**
+ *
+ */
+export declare const updateElbowArrowPoints: (arrow: Readonly<ExcalidrawElbowArrowElement>, elementsMap: NonDeletedSceneElementsMap | SceneElementsMap, updates: {
+    points?: readonly LocalPoint[];
+    fixedSegments?: FixedSegment[] | null;
+    startBinding?: FixedPointBinding | null;
+    endBinding?: FixedPointBinding | null;
+}, options?: {
+    isDragging?: boolean;
+}) => ElementUpdate<ExcalidrawElbowArrowElement>;