Merge branch 'master' into mtolmacs/transparent-bind-hit

Signed-off-by: Mark Tolmacs <mark@lazycat.hu>

.env.test

@@ -1,7 +0,0 @@
-# VITE_DEBUG_DOM
-#   When "true", testing-library failures (waitFor / getBy*) include the full
-#   serialized DOM in the error message. It's off by default because it's noisy.
-#
-#   Flip it to "true" (or use `VITE_DEBUG_DOM=true yarn test`) when you need to
-#   inspect the DOM of a failing test.
-VITE_DEBUG_DOM=false

excalidraw-app/App.tsx

@@ -22,6 +22,7 @@ import Trans from "@excalidraw/excalidraw/components/Trans";
 import {
   APP_NAME,
   EVENT,
+  THEME,
   VERSION_TIMEOUT,
   debounce,
   getVersion,
@@ -951,7 +952,6 @@ const ExcalidrawWrapper = () => {
         handleKeyboardGlobally={true}
         autoFocus={true}
         theme={editorTheme}
-        onThemeChange={setAppTheme}
         renderTopRightUI={(isMobile) => {
           if (isMobile || !collabAPI || isCollabDisabled) {
             return null;
@@ -988,6 +988,7 @@ const ExcalidrawWrapper = () => {
           isCollaborating={isCollaborating}
           isCollabEnabled={!isCollabDisabled}
           theme={appTheme}
+          setTheme={(theme) => setAppTheme(theme)}
           refresh={() => forceRefresh((prev) => !prev)}
         />
         <AppWelcomeScreen
@@ -1228,6 +1229,14 @@ const ExcalidrawWrapper = () => {
                 }
               },
             },
+            {
+              ...CommandPalette.defaultItems.toggleTheme,
+              perform: () => {
+                setAppTheme(
+                  editorTheme === THEME.DARK ? THEME.LIGHT : THEME.DARK,
+                );
+              },
+            },
             {
               label: t("labels.installPWA"),
               category: DEFAULT_CATEGORIES.app,

excalidraw-app/components/AppMainMenu.tsx

@@ -20,6 +20,7 @@ export const AppMainMenu: React.FC<{
   isCollaborating: boolean;
   isCollabEnabled: boolean;
   theme: Theme | "system";
+  setTheme: (theme: Theme | "system") => void;
   refresh: () => void;
 }> = React.memo((props) => {
   return (
@@ -77,7 +78,11 @@ export const AppMainMenu: React.FC<{
       )}
       <MainMenu.Separator />
       <MainMenu.DefaultItems.Preferences />
-      <MainMenu.DefaultItems.ToggleTheme allowSystemTheme theme={props.theme} />
+      <MainMenu.DefaultItems.ToggleTheme
+        allowSystemTheme
+        theme={props.theme}
+        onSelect={props.setTheme}
+      />
       <MainMenu.ItemCustom>
         <LanguageList style={{ width: "100%" }} />
       </MainMenu.ItemCustom>

excalidraw-app/data/LocalData.ts

@@ -11,7 +11,6 @@
  */
 
 import { clearAppStateForLocalStorage } from "@excalidraw/excalidraw/appState";
-import { stringifyWithPrecision } from "@excalidraw/excalidraw/data/json";
 import {
   CANVAS_SEARCH_TAB,
   DEFAULT_SIDEBAR,
@@ -90,7 +89,7 @@ const saveDataStateToLocalStorage = (
 
     localStorage.setItem(
       STORAGE_KEYS.LOCAL_STORAGE_ELEMENTS,
-      stringifyWithPrecision(getNonDeletedElements(elements)),
+      JSON.stringify(getNonDeletedElements(elements)),
     );
     localStorage.setItem(
       STORAGE_KEYS.LOCAL_STORAGE_APP_STATE,

excalidraw-app/data/firebase.ts

@@ -1,7 +1,6 @@
 import { reconcileElements } from "@excalidraw/excalidraw";
 import { MIME_TYPES, toBrandedType } from "@excalidraw/common";
 import { decompressData } from "@excalidraw/excalidraw/data/encode";
-import { stringifyWithPrecision } from "@excalidraw/excalidraw/data/json";
 import {
   encryptData,
   decryptData,
@@ -95,7 +94,7 @@ const encryptElements = async (
   key: string,
   elements: readonly ExcalidrawElement[],
 ): Promise<{ ciphertext: ArrayBuffer; iv: Uint8Array }> => {
-  const json = stringifyWithPrecision(elements);
+  const json = JSON.stringify(elements);
   const encoded = new TextEncoder().encode(json);
   const { encryptedBuffer, iv } = await encryptData(key, encoded);
 

excalidraw-app/useHandleAppTheme.ts

@@ -1,4 +1,5 @@
 import { THEME } from "@excalidraw/excalidraw";
+import { EVENT, CODES, KEYS } from "@excalidraw/common";
 import { useEffect, useLayoutEffect, useState } from "react";
 
 import type { Theme } from "@excalidraw/element/types";
@@ -30,10 +31,28 @@ export const useHandleAppTheme = () => {
       mediaQuery?.addEventListener("change", handleChange);
     }
 
+    const handleKeydown = (event: KeyboardEvent) => {
+      if (
+        !event[KEYS.CTRL_OR_CMD] &&
+        event.altKey &&
+        event.shiftKey &&
+        event.code === CODES.D
+      ) {
+        event.preventDefault();
+        event.stopImmediatePropagation();
+        setAppTheme(editorTheme === THEME.DARK ? THEME.LIGHT : THEME.DARK);
+      }
+    };
+
+    document.addEventListener(EVENT.KEYDOWN, handleKeydown, { capture: true });
+
     return () => {
       mediaQuery?.removeEventListener("change", handleChange);
+      document.removeEventListener(EVENT.KEYDOWN, handleKeydown, {
+        capture: true,
+      });
     };
-  }, [appTheme]);
+  }, [appTheme, editorTheme, setAppTheme]);
 
   useLayoutEffect(() => {
     localStorage.setItem(STORAGE_KEYS.LOCAL_STORAGE_THEME, appTheme);

packages/common/src/colors.ts

@@ -80,11 +80,7 @@ const cssInvert = (
   return { r: invertedR, g: invertedG, b: invertedB };
 };
 
-export const applyDarkModeFilter = (color: string, enable = true): string => {
+export const applyDarkModeFilter = (color: string): string => {
-  if (!enable) {
-    return color;
-  }
-
   const cached = DARK_MODE_COLORS_CACHE?.get(color);
   if (cached) {
     return cached;

packages/common/src/utils.ts

@@ -1,4 +1,4 @@
-import { average, round } from "@excalidraw/math";
+import { average } from "@excalidraw/math";
 
 import type { GlobalCoord } from "@excalidraw/math";
 
@@ -429,21 +429,11 @@ export const viewportCoordsToSceneCoords = (
     scrollX: number;
     scrollY: number;
   },
-  decimals: number = 2,
 ) => {
   const x = (clientX - offsetLeft) / zoom.value - scrollX;
   const y = (clientY - offsetTop) / zoom.value - scrollY;
 
-  if (decimals === 0) {
+  return { x, y } as GlobalCoord;
-    return toBrandedType<GlobalCoord>({ x, y });
-  }
-
-  const precision = Math.pow(10, decimals);
-
-  return toBrandedType<GlobalCoord>({
-    x: round(x, precision),
-    y: round(y, precision),
-  });
 };
 
 export const sceneCoordsToViewportCoords = (

packages/common/tests/binary-heap.test.ts

@@ -1,109 +0,0 @@
-import { BinaryHeap } from "../src/binary-heap";
-
-describe("BinaryHeap", () => {
-  const numberHeap = () => new BinaryHeap<number>((n) => n);
-
-  const drain = (heap: BinaryHeap<number>) => {
-    const out: number[] = [];
-    while (heap.size() > 0) {
-      out.push(heap.pop()!);
-    }
-    return out;
-  };
-
-  describe("empty heap", () => {
-    it("has size 0", () => {
-      expect(numberHeap().size()).toBe(0);
-    });
-
-    it("pop() returns null", () => {
-      expect(numberHeap().pop()).toBe(null);
-    });
-
-    it("remove() is a no-op and does not throw", () => {
-      const heap = numberHeap();
-      expect(() => heap.remove(1)).not.toThrow();
-      expect(heap.size()).toBe(0);
-    });
-  });
-
-  describe("push / pop", () => {
-    it("tracks size as items are added and removed", () => {
-      const heap = numberHeap();
-      [3, 1, 2].forEach((n) => heap.push(n));
-      expect(heap.size()).toBe(3);
-
-      heap.pop();
-      expect(heap.size()).toBe(2);
-    });
-
-    it("pops a single pushed element back out", () => {
-      const heap = numberHeap();
-      heap.push(42);
-      expect(heap.pop()).toBe(42);
-      expect(heap.pop()).toBe(null);
-    });
-
-    it("always pops the smallest score first", () => {
-      const heap = numberHeap();
-      [5, 3, 8, 1, 9, 2, 7].forEach((n) => heap.push(n));
-      expect(drain(heap)).toEqual([1, 2, 3, 5, 7, 8, 9]);
-    });
-
-    it("handles duplicate scores", () => {
-      const heap = numberHeap();
-      [4, 1, 4, 1, 2].forEach((n) => heap.push(n));
-      expect(drain(heap)).toEqual([1, 1, 2, 4, 4]);
-    });
-
-    it("maintains the heap invariant for a large adversarial (reverse-sorted) input", () => {
-      const heap = numberHeap();
-      // pushing in descending order forces a sift-up on every insert
-      const input = Array.from({ length: 1000 }, (_, i) => 1000 - i);
-      input.forEach((n) => heap.push(n));
-      expect(drain(heap)).toEqual([...input].sort((a, b) => a - b));
-    });
-  });
-
-  describe("remove", () => {
-    it("removes an interior element and keeps the rest ordered", () => {
-      const heap = numberHeap();
-      [5, 3, 8, 1, 9].forEach((n) => heap.push(n));
-
-      heap.remove(8);
-
-      expect(heap.size()).toBe(4);
-      expect(drain(heap)).toEqual([1, 3, 5, 9]);
-    });
-
-    it("can remove the current minimum", () => {
-      const heap = numberHeap();
-      [5, 3, 8, 1, 9].forEach((n) => heap.push(n));
-
-      heap.remove(1);
-
-      expect(heap.size()).toBe(4);
-      expect(heap.pop()).toBe(3);
-    });
-  });
-
-  describe("rescoreElement", () => {
-    type Node = { id: string; f: number };
-
-    it("re-sorts a node after its score is lowered", () => {
-      const heap = new BinaryHeap<Node>((node) => node.f);
-
-      const a = { id: "a", f: 10 };
-      const b = { id: "b", f: 20 };
-      const c = { id: "c", f: 30 };
-      [a, b, c].forEach((node) => heap.push(node));
-
-      c.f = 5;
-      heap.rescoreElement(c);
-
-      expect(heap.pop()).toBe(c);
-      expect(heap.pop()).toBe(a);
-      expect(heap.pop()).toBe(b);
-    });
-  });
-});

packages/element/src/arrows/focus.ts

@@ -10,7 +10,6 @@ import {
   getBindingGap,
   getGlobalFixedPointForBindableElement,
   isBindingEnabled,
-  maxBindingDistance_simple,
   unbindBindingElement,
   updateBoundPoint,
 } from "../binding";
@@ -20,7 +19,7 @@ import {
   isElbowArrow,
 } from "../typeChecks";
 import { LinearElementEditor } from "../linearElementEditor";
-import { getHoveredElementForFocusPoint, hitElementItself } from "../collision";
+import { getHoveredElementForBinding, hitElementItself } from "../collision";
 import { moveArrowAboveBindable } from "../zindex";
 
 import type {
@@ -92,7 +91,7 @@ export const isFocusPointVisible = (
       element: bindableElement,
       elementsMap,
       point: focusPoint,
-      threshold: getBindingGap(bindableElement, arrow),
+      threshold: getBindingGap(bindableElement),
       overrideShouldTestInside: true,
     })
   );
@@ -234,12 +233,12 @@ export const handleFocusPointDrag = (
     pointerCoords.y - offsetY,
   );
   const bindingField = isStartBinding ? "startBinding" : "endBinding";
-  const hit = getHoveredElementForFocusPoint(
+  const hit = getHoveredElementForBinding(
-    point,
     arrow,
+    point,
     scene.getNonDeletedElements(),
     elementsMap,
-    maxBindingDistance_simple(appState.zoom),
+    appState.zoom,
   );
 
   // Hovering a bindable element
@@ -270,6 +269,7 @@ export const handleFocusPointDrag = (
         newMode || "orbit",
         linearElementEditor.draggedFocusPointBinding,
         scene,
+        appState.zoom,
         point,
       );
     }

packages/element/src/binding.ts

@@ -60,6 +60,7 @@ import { updateElbowArrowPoints } from "./elbowArrow";
 import {
   deconstructDiamondElement,
   deconstructRectanguloidElement,
+  getSnapOutlineMidPoint,
   projectFixedPointOntoDiagonal,
 } from "./utils";
 
@@ -110,18 +111,13 @@ export type BindingStrategy =
  * IMPORTANT: currently must be > 0 (this also applies to the computed gap)
  */
 export const BASE_BINDING_GAP = 5;
-export const BASE_BINDING_GAP_ELBOW = 5;
 export const BASE_ARROW_MIN_LENGTH = 10;
 export const FOCUS_POINT_SIZE = 10 / 1.5;
 
 export const getBindingGap = (
   bindTarget: ExcalidrawBindableElement,
-  opts: Pick<ExcalidrawArrowElement, "elbowed">,
 ): number => {
-  return (
+  return BASE_BINDING_GAP + bindTarget.strokeWidth / 2;
-    (opts.elbowed ? BASE_BINDING_GAP_ELBOW : BASE_BINDING_GAP) +
-    bindTarget.strokeWidth / 2
-  );
 };
 
 export const maxBindingDistance_simple = (zoom?: AppState["zoom"]): number => {
@@ -175,6 +171,7 @@ export const bindOrUnbindBindingElement = (
     start,
     "start",
     scene,
+    appState.zoom,
     appState.isBindingEnabled,
   );
   bindOrUnbindBindingElementEdge(
@@ -182,6 +179,7 @@ export const bindOrUnbindBindingElement = (
     end,
     "end",
     scene,
+    appState.zoom,
     appState.isBindingEnabled,
   );
   if (start.focusPoint || end.focusPoint) {
@@ -226,6 +224,7 @@ const bindOrUnbindBindingElementEdge = (
   { mode, element, focusPoint }: BindingStrategy,
   startOrEnd: "start" | "end",
   scene: Scene,
+  zoom: AppState["zoom"],
   shouldSnapToOutline = true,
 ): void => {
   if (mode === null) {
@@ -238,6 +237,7 @@ const bindOrUnbindBindingElementEdge = (
       mode,
       startOrEnd,
       scene,
+      zoom,
       focusPoint,
       shouldSnapToOutline,
     );
@@ -270,10 +270,11 @@ const bindingStrategyForElbowArrowEndpointDragging = (
     elementsMap,
   );
   const hit = getHoveredElementForBinding(
+    arrow,
     globalPoint,
     elements,
     elementsMap,
-    maxBindingDistance_simple(zoom),
+    zoom,
   );
 
   const current = hit
@@ -321,7 +322,7 @@ const bindingStrategyForNewSimpleArrowEndpointDragging = (
     draggingPoints.get(startDragged ? startIdx : endIdx)!.point,
     elementsMap,
   );
-  const hit = getHoveredElementForBinding(point, elements, elementsMap);
+  const hit = getHoveredElementForBinding(arrow, point, elements, elementsMap);
 
   // With new arrows this handles the binding at arrow creation
   if (startDragged) {
@@ -366,7 +367,12 @@ const bindingStrategyForNewSimpleArrowEndpointDragging = (
     // Check and handle nested shapes
     if (hit && arrow.startBinding) {
       const startBinding = arrow.startBinding;
-      const allHits = getAllHoveredElementAtPoint(point, elements, elementsMap);
+      const allHits = getAllHoveredElementAtPoint(
+        arrow,
+        point,
+        elements,
+        elementsMap,
+      );
 
       if (allHits.find((el) => el.id === startBinding.elementId)) {
         const otherElement = elementsMap.get(
@@ -468,9 +474,9 @@ const bindingStrategyForSimpleArrowEndpointDragging_complex = (
   let other: BindingStrategy = { mode: undefined };
 
   const isMultiPoint = arrow.points.length > 2;
-  const hit = getHoveredElementForBinding(point, elements, elementsMap);
+  const hit = getHoveredElementForBinding(arrow, point, elements, elementsMap);
   const isOverlapping = oppositeBinding
-    ? getAllHoveredElementAtPoint(point, elements, elementsMap).some(
+    ? getAllHoveredElementAtPoint(arrow, point, elements, elementsMap).some(
         (el) => el.id === oppositeBinding.elementId,
       )
     : false;
@@ -643,13 +649,10 @@ const getBindingStrategyForDraggingBindingElementEndpoints_simple = (
   let start: BindingStrategy = { mode: undefined };
   let end: BindingStrategy = { mode: undefined };
 
-  if (arrow.points.length < 2) {
+  invariant(
-    console.error(
+    arrow.points.length > 1,
-      "Attempting to bind a linear element with less than 2 points",
+    "Do not attempt to bind linear elements with a single point",
-    );
+  );
-    // a single-point can't be bound -> cancel
-    return { start: { mode: undefined }, end: { mode: undefined } };
-  }
 
   // If none of the ends are dragged, we don't change anything
   if (!startDragged && !endDragged) {
@@ -698,10 +701,11 @@ const getBindingStrategyForDraggingBindingElementEndpoints_simple = (
     elementsMap,
   );
   const hit = getHoveredElementForBinding(
+    arrow,
     globalPoint,
     elements,
     elementsMap,
-    maxBindingDistance_simple(appState.zoom),
+    appState.zoom,
   );
   const pointInElement =
     hit &&
@@ -893,13 +897,10 @@ const getBindingStrategyForDraggingBindingElementEndpoints_complex = (
   let start: BindingStrategy = { mode: undefined };
   let end: BindingStrategy = { mode: undefined };
 
-  if (arrow.points.length < 2) {
+  invariant(
-    console.error(
+    arrow.points.length > 1,
-      "Attempting to bind a linear element with less than 2 points",
+    "Do not attempt to bind linear elements with a single point",
-    );
+  );
-    // a single-point can't be bound -> cancel
-    return { start: { mode: undefined }, end: { mode: undefined } };
-  }
 
   // If none of the ends are dragged, we don't change anything
   if (!startDragged && !endDragged) {
@@ -1025,6 +1026,7 @@ export const bindBindingElement = (
   mode: BindMode,
   startOrEnd: "start" | "end",
   scene: Scene,
+  zoom: AppState["zoom"],
   focusPoint?: GlobalPoint,
   shouldSnapToOutline = true,
 ): void => {
@@ -1041,6 +1043,7 @@ export const bindBindingElement = (
         hoveredElement,
         startOrEnd,
         elementsMap,
+        zoom,
         shouldSnapToOutline,
       ),
     };
@@ -1265,6 +1268,7 @@ const updateArrowBindings = (
         strategy[strategyName].mode,
         strategyName,
         scene,
+        appState.zoom,
         strategy[strategyName].focusPoint,
       );
     }
@@ -1374,6 +1378,7 @@ export const bindPointToSnapToElementOutline = (
   bindableElement: ExcalidrawBindableElement,
   startOrEnd: "start" | "end",
   elementsMap: ElementsMap,
+  zoom: AppState["zoom"],
   customIntersector?: LineSegment<GlobalPoint>,
   isMidpointSnappingEnabled = true,
 ): GlobalPoint => {
@@ -1406,7 +1411,7 @@ export const bindPointToSnapToElementOutline = (
           startOrEnd === "start" ? 1 : -2,
           elementsMap,
         );
-  const bindingGap = getBindingGap(bindableElement, arrowElement);
+  const bindingGap = getBindingGap(bindableElement);
   const aabb = aabbForElement(bindableElement, elementsMap);
   const bindableCenter = getCenterForBounds(aabb);
 
@@ -1416,7 +1421,13 @@ export const bindPointToSnapToElementOutline = (
       headingForPointFromElement(bindableElement, aabb, point),
     );
     const snapPoint = isMidpointSnappingEnabled
-      ? snapToMid(bindableElement, elementsMap, edgePoint, 0.05, arrowElement)
+      ? getSnapOutlineMidPoint(
+          edgePoint,
+          bindableElement,
+          elementsMap,
+          zoom,
+          arrowElement,
+        )
       : undefined;
     const resolved = snapPoint || point;
     const otherPoint = pointFrom<GlobalPoint>(
@@ -1461,7 +1472,7 @@ export const bindPointToSnapToElementOutline = (
         bindableElement,
         elementsMap,
         anotherIntersector,
-        BASE_BINDING_GAP_ELBOW,
+        BASE_BINDING_GAP,
       ).sort(pointDistanceSq)[0];
     }
   } else {
@@ -1520,7 +1531,7 @@ export const avoidRectangularCorner = (
     -bindTarget.angle as Radians,
   );
 
-  const bindingGap = getBindingGap(bindTarget, arrowElement);
+  const bindingGap = getBindingGap(bindTarget);
 
   if (nonRotatedPoint[0] < bindTarget.x && nonRotatedPoint[1] < bindTarget.y) {
     // Top left
@@ -1598,121 +1609,6 @@ export const avoidRectangularCorner = (
   return p;
 };
 
-export const snapToMid = (
-  bindTarget: ExcalidrawBindableElement,
-  elementsMap: ElementsMap,
-  p: GlobalPoint,
-  tolerance: number = 0.05,
-  arrowElement?: ExcalidrawArrowElement,
-): GlobalPoint | undefined => {
-  const { x, y, width, height, angle } = bindTarget;
-  const center = elementCenterPoint(bindTarget, elementsMap, -0.1, -0.1);
-  const nonRotated = pointRotateRads(p, center, -angle as Radians);
-
-  const bindingGap = arrowElement ? getBindingGap(bindTarget, arrowElement) : 0;
-
-  // snap-to-center point is adaptive to element size, but we don't want to go
-  // above and below certain px distance
-  const verticalThreshold = clamp(tolerance * height, 5, 80);
-  const horizontalThreshold = clamp(tolerance * width, 5, 80);
-
-  // Too close to the center makes it hard to resolve direction precisely
-  if (pointDistance(center, nonRotated) < bindingGap) {
-    return undefined;
-  }
-
-  if (
-    nonRotated[0] <= x + width / 2 &&
-    nonRotated[1] > center[1] - verticalThreshold &&
-    nonRotated[1] < center[1] + verticalThreshold
-  ) {
-    // LEFT
-    return pointRotateRads(
-      pointFrom<GlobalPoint>(x - bindingGap, center[1]),
-      center,
-      angle,
-    );
-  } else if (
-    nonRotated[1] <= y + height / 2 &&
-    nonRotated[0] > center[0] - horizontalThreshold &&
-    nonRotated[0] < center[0] + horizontalThreshold
-  ) {
-    // TOP
-    return pointRotateRads(
-      pointFrom<GlobalPoint>(center[0], y - bindingGap),
-      center,
-      angle,
-    );
-  } else if (
-    nonRotated[0] >= x + width / 2 &&
-    nonRotated[1] > center[1] - verticalThreshold &&
-    nonRotated[1] < center[1] + verticalThreshold
-  ) {
-    // RIGHT
-    return pointRotateRads(
-      pointFrom<GlobalPoint>(x + width + bindingGap, center[1]),
-      center,
-      angle,
-    );
-  } else if (
-    nonRotated[1] >= y + height / 2 &&
-    nonRotated[0] > center[0] - horizontalThreshold &&
-    nonRotated[0] < center[0] + horizontalThreshold
-  ) {
-    // DOWN
-    return pointRotateRads(
-      pointFrom<GlobalPoint>(center[0], y + height + bindingGap),
-      center,
-      angle,
-    );
-  } else if (bindTarget.type === "diamond") {
-    const distance = bindingGap;
-    const topLeft = pointFrom<GlobalPoint>(
-      x + width / 4 - distance,
-      y + height / 4 - distance,
-    );
-    const topRight = pointFrom<GlobalPoint>(
-      x + (3 * width) / 4 + distance,
-      y + height / 4 - distance,
-    );
-    const bottomLeft = pointFrom<GlobalPoint>(
-      x + width / 4 - distance,
-      y + (3 * height) / 4 + distance,
-    );
-    const bottomRight = pointFrom<GlobalPoint>(
-      x + (3 * width) / 4 + distance,
-      y + (3 * height) / 4 + distance,
-    );
-
-    if (
-      pointDistance(topLeft, nonRotated) <
-      Math.max(horizontalThreshold, verticalThreshold)
-    ) {
-      return pointRotateRads(topLeft, center, angle);
-    }
-    if (
-      pointDistance(topRight, nonRotated) <
-      Math.max(horizontalThreshold, verticalThreshold)
-    ) {
-      return pointRotateRads(topRight, center, angle);
-    }
-    if (
-      pointDistance(bottomLeft, nonRotated) <
-      Math.max(horizontalThreshold, verticalThreshold)
-    ) {
-      return pointRotateRads(bottomLeft, center, angle);
-    }
-    if (
-      pointDistance(bottomRight, nonRotated) <
-      Math.max(horizontalThreshold, verticalThreshold)
-    ) {
-      return pointRotateRads(bottomRight, center, angle);
-    }
-  }
-
-  return undefined;
-};
-
 const extractBinding = (
   arrow: ExcalidrawArrowElement,
   startOrEnd: "startBinding" | "endBinding",
@@ -1813,7 +1709,7 @@ export const updateBoundPoint = (
       otherBindable,
       elementsMap,
       intersector,
-      getBindingGap(otherBindable, arrow),
+      getBindingGap(otherBindable),
     ).sort(
       (a, b) => pointDistanceSq(a, focusPoint) - pointDistanceSq(b, focusPoint),
     )[0];
@@ -1823,7 +1719,7 @@ export const updateBoundPoint = (
       bindableElement,
       elementsMap,
       intersector,
-      getBindingGap(bindableElement, arrow),
+      getBindingGap(bindableElement),
     ).sort(
       (a, b) =>
         pointDistanceSq(a, otherFocusPointOrArrowPoint) -
@@ -1851,7 +1747,7 @@ export const updateBoundPoint = (
       element: otherBindable,
       point: outlinePoint,
       elementsMap,
-      threshold: getBindingGap(otherBindable, arrow),
+      threshold: getBindingGap(otherBindable),
       overrideShouldTestInside: true,
     })
   ) {
@@ -1912,6 +1808,7 @@ export const calculateFixedPointForElbowArrowBinding = (
   hoveredElement: ExcalidrawBindableElement,
   startOrEnd: "start" | "end",
   elementsMap: ElementsMap,
+  zoom: AppState["zoom"],
   shouldSnapToOutline = true,
   isMidpointSnappingEnabled = true,
 ): { fixedPoint: FixedPoint } => {
@@ -1927,6 +1824,7 @@ export const calculateFixedPointForElbowArrowBinding = (
         hoveredElement,
         startOrEnd,
         elementsMap,
+        zoom,
         undefined,
         isMidpointSnappingEnabled,
       )

packages/element/src/bounds.ts

@@ -1,4 +1,5 @@
 import rough from "roughjs/bin/rough";
+
 import {
   arrayToMap,
   type Bounds,
@@ -6,6 +7,7 @@ import {
   rescalePoints,
   sizeOf,
 } from "@excalidraw/common";
+
 import {
   degreesToRadians,
   lineSegment,
@@ -14,7 +16,9 @@ import {
   pointFromArray,
   pointRotateRads,
 } from "@excalidraw/math";
+
 import { getCurvePathOps } from "@excalidraw/utils/shape";
+
 import { pointsOnBezierCurves } from "points-on-curve";
 
 import type {
@@ -25,7 +29,9 @@ import type {
   LocalPoint,
   Radians,
 } from "@excalidraw/math";
+
 import type { AppState } from "@excalidraw/excalidraw/types";
+
 import type { Mutable } from "@excalidraw/common/utility-types";
 
 import { generateRoughOptions } from "./shape";
@@ -35,20 +41,18 @@ import { getBoundTextElement, getContainerElement } from "./textElement";
 import {
   isArrowElement,
   isBoundToContainer,
-  isFrameLikeElement,
   isFreeDrawElement,
   isLinearElement,
   isLineElement,
   isTextElement,
-  isExcalidrawElement,
 } from "./typeChecks";
+
 import { getElementShape } from "./shape";
+
 import {
   deconstructDiamondElement,
   deconstructRectanguloidElement,
 } from "./utils";
-import { intersectElementWithLineSegment } from "./collision";
-import { elementOverlapsWithFrame, getContainingFrame } from "./frame";
 
 import type { Drawable, Op } from "roughjs/bin/core";
 import type { Point as RoughPoint } from "roughjs/bin/geometry";
@@ -63,7 +67,6 @@ import type {
   ExcalidrawRectanguloidElement,
   ExcalidrawTextElementWithContainer,
   NonDeleted,
-  NonDeletedExcalidrawElement,
 } from "./types";
 
 export type RectangleBox = {
@@ -1292,295 +1295,6 @@ export const boundsContainBounds = (outerBounds: Bounds, innerBounds: Bounds) =>
     pointFrom<GlobalPoint>(innerBounds[2], innerBounds[3]),
   ].every((point) => pointInsideBoundsInclusive(point, outerBounds));
 
-/**
- * High level helper to get elements overlapping a bounding box.
- * It can be used to get elements overlapping a selection box, for example.
- *
- */
-export const elementsOverlappingBBox = ({
-  elements,
-  elementsMap,
-  bounds,
-  type,
-  excludeElementsInFrames,
-  shouldIgnoreElementFromSelection,
-}: {
-  elements: readonly NonDeletedExcalidrawElement[];
-  elementsMap?: ElementsMap;
-  bounds: Bounds | ExcalidrawElement;
-  /**
-   * - overlap: elements overlapping or inside bounds
-   * - contain: elements inside bounds
-   **/
-  type: "contain" | "overlap";
-  excludeElementsInFrames?: boolean;
-  shouldIgnoreElementFromSelection?: (
-    element: NonDeletedExcalidrawElement,
-  ) => boolean;
-}) => {
-  if (!elementsMap) {
-    elementsMap = arrayToMap(elements) as ElementsMap;
-  }
-  const selectionBounds = isExcalidrawElement(bounds)
-    ? getElementBounds(bounds, elementsMap)
-    : bounds;
-  const [selectionX1, selectionY1, selectionX2, selectionY2] = selectionBounds;
-  const selectionEdges = [
-    lineSegment<GlobalPoint>(
-      pointFrom(selectionX1, selectionY1),
-      pointFrom(selectionX2, selectionY1),
-    ),
-    lineSegment<GlobalPoint>(
-      pointFrom(selectionX2, selectionY1),
-      pointFrom(selectionX2, selectionY2),
-    ),
-    lineSegment<GlobalPoint>(
-      pointFrom(selectionX2, selectionY2),
-      pointFrom(selectionX1, selectionY2),
-    ),
-    lineSegment<GlobalPoint>(
-      pointFrom(selectionX1, selectionY2),
-      pointFrom(selectionX1, selectionY1),
-    ),
-  ];
-
-  const framesInSelection = excludeElementsInFrames
-    ? new Set<NonDeletedExcalidrawElement["id"]>()
-    : null;
-  const groups: Record<string, NonDeletedExcalidrawElement[]> = {};
-  const elementsInSelection: Set<NonDeletedExcalidrawElement> = new Set();
-
-  for (const element of elements) {
-    if (shouldIgnoreElementFromSelection?.(element)) {
-      continue;
-    }
-
-    // Track only selectable top-level group members, so ignored elements such
-    // as bound text and locked elements don't affect group selection.
-    const groupId = element.groupIds.at(-1);
-    if (groupId) {
-      if (!groups[groupId]) {
-        groups[groupId] = [];
-      }
-      groups[groupId].push(element);
-    }
-
-    const strokeWidth = element.strokeWidth;
-    let labelAABB: Bounds | null = null;
-    let elementAABB = getElementBounds(element, elementsMap);
-
-    elementAABB = [
-      elementAABB[0] - strokeWidth / 2,
-      elementAABB[1] - strokeWidth / 2,
-      elementAABB[2] + strokeWidth / 2,
-      elementAABB[3] + strokeWidth / 2,
-    ] as Bounds;
-
-    // Whether the element bounds should include the bound text element bounds
-    const boundTextElement =
-      isArrowElement(element) && getBoundTextElement(element, elementsMap);
-    if (boundTextElement) {
-      const { x, y } = LinearElementEditor.getBoundTextElementPosition(
-        element,
-        boundTextElement,
-        elementsMap,
-      );
-      labelAABB = [
-        x,
-        y,
-        x + boundTextElement.width,
-        y + boundTextElement.height,
-      ] as Bounds;
-    }
-
-    // Clip element bounds by its containing frame (if any), since only the
-    // visible (frame-clipped) portion of the element is relevant for selection.
-    const associatedFrame = getContainingFrame(element, elementsMap);
-    if (
-      associatedFrame &&
-      elementOverlapsWithFrame(element, associatedFrame, elementsMap)
-    ) {
-      const frameAABB = getElementBounds(associatedFrame, elementsMap);
-      elementAABB = [
-        Math.max(elementAABB[0], frameAABB[0]),
-        Math.max(elementAABB[1], frameAABB[1]),
-        Math.min(elementAABB[2], frameAABB[2]),
-        Math.min(elementAABB[3], frameAABB[3]),
-      ] as Bounds;
-
-      labelAABB = labelAABB
-        ? ([
-            Math.max(labelAABB[0], frameAABB[0]),
-            Math.max(labelAABB[1], frameAABB[1]),
-            Math.min(labelAABB[2], frameAABB[2]),
-            Math.min(labelAABB[3], frameAABB[3]),
-          ] as Bounds)
-        : null;
-    }
-
-    const commonAABB = labelAABB
-      ? ([
-          Math.min(labelAABB[0], elementAABB[0]),
-          Math.min(labelAABB[1], elementAABB[1]),
-          Math.max(labelAABB[2], elementAABB[2]),
-          Math.max(labelAABB[3], elementAABB[3]),
-        ] as Bounds)
-      : elementAABB;
-
-    // ============== Evaluation ==============
-
-    // 1. If the selection box WRAPs the element's AABB, then add it to the
-    //    selection and move on, regardless of the selection mode.
-    //
-    //    PERF: This trick only works with axis-aligned box selection and the
-    //          current convex element shapes!
-    if (boundsContainBounds(selectionBounds, commonAABB)) {
-      if (framesInSelection && isFrameLikeElement(element)) {
-        framesInSelection.add(element.id);
-      }
-      elementsInSelection.add(element);
-      continue;
-    }
-
-    // 2. Handle the case where the label is overlapped by the selection box
-    if (
-      type === "overlap" &&
-      labelAABB &&
-      doBoundsIntersect(selectionBounds, labelAABB)
-    ) {
-      elementsInSelection.add(element);
-      continue;
-    }
-
-    // 3. Handle the case where the selection is not wrapping the element, but
-    //    it does intersect the element's outline (non-AABB).
-    if (type === "overlap" && doBoundsIntersect(selectionBounds, elementAABB)) {
-      let hasIntersection = false;
-
-      // Preliminary check potential intersection imprecision
-      if (isLinearElement(element) || isFreeDrawElement(element)) {
-        const center = elementCenterPoint(element, elementsMap);
-        hasIntersection = element.points.some((point) => {
-          const rotatedPoint = pointRotateRads(
-            pointFrom<GlobalPoint>(element.x + point[0], element.y + point[1]),
-            center,
-            element.angle,
-          );
-
-          return pointInsideBounds(rotatedPoint, selectionBounds);
-        });
-      } else {
-        const nonRotatedElementBounds = getElementBounds(
-          element,
-          elementsMap,
-          true,
-        );
-        const center = elementCenterPoint(element, elementsMap);
-        hasIntersection = [
-          pointRotateRads(
-            pointFrom<GlobalPoint>(
-              (nonRotatedElementBounds[0] + nonRotatedElementBounds[2]) / 2,
-              nonRotatedElementBounds[1],
-            ),
-            center,
-            element.angle,
-          ),
-          pointRotateRads(
-            pointFrom<GlobalPoint>(
-              nonRotatedElementBounds[2],
-              (nonRotatedElementBounds[1] + nonRotatedElementBounds[3]) / 2,
-            ),
-            center,
-            element.angle,
-          ),
-          pointRotateRads(
-            pointFrom<GlobalPoint>(
-              (nonRotatedElementBounds[0] + nonRotatedElementBounds[2]) / 2,
-              nonRotatedElementBounds[3],
-            ),
-            center,
-            element.angle,
-          ),
-          pointRotateRads(
-            pointFrom<GlobalPoint>(
-              nonRotatedElementBounds[0],
-              (nonRotatedElementBounds[1] + nonRotatedElementBounds[3]) / 2,
-            ),
-            center,
-            element.angle,
-          ),
-        ].some((point) => {
-          return pointInsideBounds(
-            pointRotateRads(point, center, element.angle),
-            selectionBounds,
-          );
-        });
-      }
-
-      if (!hasIntersection) {
-        hasIntersection = selectionEdges.some(
-          (selectionEdge) =>
-            intersectElementWithLineSegment(
-              element,
-              elementsMap,
-              selectionEdge,
-              strokeWidth / 2,
-              true, // Stop at first hit for better performance
-            ).length > 0,
-        );
-      }
-
-      if (hasIntersection) {
-        if (framesInSelection && isFrameLikeElement(element)) {
-          framesInSelection.add(element.id);
-        }
-
-        elementsInSelection.add(element);
-        continue;
-      }
-    }
-
-    // 4. We don't need to handle when the selection is inside the element
-    //    as it is separately handled in App.
-  }
-
-  if (framesInSelection) {
-    elementsInSelection.forEach((element) => {
-      if (element.frameId && framesInSelection.has(element.frameId)) {
-        elementsInSelection.delete(element);
-      }
-    });
-  }
-
-  if (type === "overlap") {
-    Array.from(elementsInSelection).forEach((element) => {
-      const groupId = element.groupIds.at(-1);
-      const group = groupId ? groups[groupId] : null;
-
-      group?.forEach((groupElement) => elementsInSelection.add(groupElement));
-    });
-  } else if (type === "contain") {
-    elementsInSelection.forEach((element) => {
-      // note: currently we only support top-level group handling since
-      // we don't support box selecting while editing the group/subgroup
-      // see https://github.com/excalidraw/excalidraw/pull/11234#issuecomment-4387654451
-      const groupId = element.groupIds.at(-1);
-
-      const group = groupId ? groups[groupId] : null;
-
-      if (
-        group &&
-        !group.every((groupElement) => elementsInSelection.has(groupElement))
-      ) {
-        elementsInSelection.delete(element);
-      }
-    });
-  }
-
-  // to maintain original order elements (namely for group selection)
-  return elements.filter((element) => elementsInSelection.has(element));
-};
-
 export const elementCenterPoint = (
   element: ExcalidrawElement,
   elementsMap: ElementsMap,

packages/element/src/collision.ts

@@ -25,7 +25,7 @@ import type {
   Radians,
 } from "@excalidraw/math";
 
-import type { FrameNameBounds } from "@excalidraw/excalidraw/types";
+import type { AppState, FrameNameBounds } from "@excalidraw/excalidraw/types";
 
 import { isPathALoop } from "./utils";
 import {
@@ -59,13 +59,12 @@ import { LinearElementEditor } from "./linearElementEditor";
 
 import { distanceToElement } from "./distance";
 
-import { getBindingGap } from "./binding";
+import { getBindingGap, maxBindingDistance_simple } from "./binding";
 
 import { hasBackground } from "./comparisons";
 
 import type {
   ElementsMap,
-  ExcalidrawArrowElement,
   ExcalidrawBindableElement,
   ExcalidrawDiamondElement,
   ExcalidrawElement,
@@ -254,25 +253,20 @@ export const hitElementBoundText = (
   return isPointInElement(point, boundTextElement, elementsMap);
 };
 
-const bindingBorderTest = (
+const bindableElementBorderDistanceIfClose = (
   element: NonDeleted<ExcalidrawBindableElement>,
-  [x, y]: Readonly<GlobalPoint>,
+  point: GlobalPoint,
-  elementsMap: NonDeletedSceneElementsMap,
+  elementsMap: ElementsMap,
   tolerance: number = 0,
-): boolean => {
+) => {
-  const p = pointFrom<GlobalPoint>(x, y);
-  const shouldTestInside =
-    // disable fullshape snapping for frame elements so we
-    // can bind to frame children
-    !isFrameLikeElement(element);
-
   // PERF: Run a cheap test to see if the binding element
   // is even close to the element
+  const [x, y] = point;
   const t = Math.max(1, tolerance);
   const bounds = [x - t, y - t, x + t, y + t] as Bounds;
   const elementBounds = getElementBounds(element, elementsMap);
   if (!doBoundsIntersect(bounds, elementBounds)) {
-    return false;
+    return -Infinity;
   }
 
   // If the element is inside a frame, we should clip the element
@@ -283,33 +277,29 @@ const bindingBorderTest = (
         enclosingFrame,
         elementsMap,
       );
-      if (!pointInsideBounds(p, enclosingFrameBounds)) {
+      if (!pointInsideBounds(point, enclosingFrameBounds)) {
-        return false;
+        return -Infinity;
       }
     }
   }
 
-  // Do the intersection test against the element since it's close enough
+  const distance = distanceToElement(element, elementsMap, point);
-  const intersections = intersectElementWithLineSegment(
+  if (isPointInElement(point, element, elementsMap)) {
-    element,
+    return distance;
-    elementsMap,
+  }
-    lineSegment(elementCenterPoint(element, elementsMap), p),
-  );
-  const distance = distanceToElement(element, elementsMap, p);
 
-  return shouldTestInside
+  return distance > tolerance ? -Infinity : -distance;
-    ? intersections.length === 0 || distance <= tolerance
-    : intersections.length > 0 && distance <= t;
 };
 
 export const getAllHoveredElementAtPoint = (
+  arrow: { elbowed: boolean },
   point: Readonly<GlobalPoint>,
   elements: readonly Ordered<NonDeletedExcalidrawElement>[],
   elementsMap: NonDeletedSceneElementsMap,
   tolerance?: number,
 ): NonDeleted<ExcalidrawBindableElement>[] => {
   const candidateElements: NonDeleted<ExcalidrawBindableElement>[] = [];
-  // We need to to hit testing from front (end of the array) to back (beginning of the array)
+  // We need to do hit testing from front (end of the array) to back (beginning of the array)
   // because array is ordered from lower z-index to highest and we want element z-index
   // with higher z-index
   for (let index = elements.length - 1; index >= 0; --index) {
@@ -322,7 +312,13 @@ export const getAllHoveredElementAtPoint = (
 
     if (
       isBindableElement(element, false) &&
-      bindingBorderTest(element, point, elementsMap, tolerance)
+      hitElementItself({
+        element,
+        point,
+        elementsMap,
+        threshold: tolerance ?? getBindingGap(element),
+        overrideShouldTestInside: true,
+      })
     ) {
       candidateElements.push(element);
 
@@ -339,82 +335,92 @@ export const getAllHoveredElementAtPoint = (
 };
 
 export const getHoveredElementForBinding = (
+  arrow: { elbowed: boolean },
   point: Readonly<GlobalPoint>,
   elements: readonly Ordered<NonDeletedExcalidrawElement>[],
   elementsMap: NonDeletedSceneElementsMap,
-  tolerance?: number,
+  zoom?: AppState["zoom"],
 ): NonDeleted<ExcalidrawBindableElement> | null => {
-  const candidateElements = getAllHoveredElementAtPoint(
+  type Candidate = {
-    point,
+    element: NonDeleted<ExcalidrawBindableElement>;
-    elements,
+    distance: number;
-    elementsMap,
+    overlapPercent?: number;
-    tolerance,
+    relativeArea?: number;
-  );
+  };
 
-  if (!candidateElements || candidateElements.length === 0) {
+  const candidates: Candidate[] = [];
-    return null;
-  }
-
-  if (candidateElements.length === 1) {
-    return candidateElements[0];
-  }
-
-  // Prefer smaller shapes
-  return candidateElements
-    .sort(
-      (a, b) => b.width ** 2 + b.height ** 2 - (a.width ** 2 + a.height ** 2),
-    )
-    .pop() as NonDeleted<ExcalidrawBindableElement>;
-};
-
-export const getHoveredElementForFocusPoint = (
-  point: GlobalPoint,
-  arrow: ExcalidrawArrowElement,
-  elements: readonly Ordered<NonDeletedExcalidrawElement>[],
-  elementsMap: NonDeletedSceneElementsMap,
-  tolerance?: number,
-): ExcalidrawBindableElement | null => {
-  const candidateElements: NonDeleted<ExcalidrawBindableElement>[] = [];
-  // We need to to hit testing from front (end of the array) to back (beginning of the array)
-  // because array is ordered from lower z-index to highest and we want element z-index
-  // with higher z-index
   for (let index = elements.length - 1; index >= 0; --index) {
     const element = elements[index];
 
-    invariant(
+    if (!isBindableElement(element, false)) {
-      !element.isDeleted,
+      continue;
-      "Elements in the function parameter for getAllElementsAtPositionForBinding() should not contain deleted elements",
+    }
+
+    const maxDistance = maxBindingDistance_simple(zoom);
+    const distance = bindableElementBorderDistanceIfClose(
+      element,
+      point,
+      elementsMap,
+      maxDistance,
     );
 
-    if (
+    if (distance > -maxDistance) {
-      isBindableElement(element, false) &&
+      candidates.push({ element, distance });
-      bindingBorderTest(element, point, elementsMap, tolerance)
+
-    ) {
+      if (!isTransparent(element.backgroundColor) && distance >= 0) {
-      candidateElements.push(element);
+        break;
+      }
     }
   }
 
-  if (!candidateElements || candidateElements.length === 0) {
+  if (candidates.length === 0) {
     return null;
   }
 
-  if (candidateElements.length === 1) {
+  if (candidates.length === 1) {
-    return candidateElements[0];
+    return candidates[0].element;
   }
 
-  const distanceFilteredCandidateElements = candidateElements
+  const closestElements = candidates.sort(
-    // Resolve by distance
+    (a, b) => Math.abs(a.distance) - Math.abs(b.distance),
-    .filter(
+  );
-      (el) =>
-        distanceToElement(el, elementsMap, point) <= getBindingGap(el, arrow) ||
-        isPointInElement(point, el, elementsMap),
-    );
 
-  if (distanceFilteredCandidateElements.length === 0) {
+  const candidate = closestElements[0];
-    return null;
+  const [cx1, cy1, cx2, cy2] = getElementBounds(candidate.element, elementsMap);
-  }
+  const candidateArea = Math.max(
+    0.00001,
+    Math.abs(cx2 - cx1) * Math.abs(cy2 - cy1),
+  );
+  const overlaps = closestElements
+    .map((c) => {
+      if (c.element === candidate.element) {
+        return { ...c, overlapPercent: 0, relativeArea: 1 };
+      }
 
-  return distanceFilteredCandidateElements[0] as NonDeleted<ExcalidrawBindableElement>;
+      const [x1, y1, x2, y2] = getElementBounds(c.element, elementsMap);
+      const overlapX1 = x1 > cx1 && x1 < cx2 ? x1 : cx1;
+      const overlapY1 = y1 > cy1 && y1 < cy2 ? y1 : cy1;
+      const overlapX2 = x2 < cx2 && x2 > cx1 ? x2 : cx2;
+      const overlapY2 = y2 < cy2 && y2 > cy1 ? y2 : cy2;
+      const overlapWdith =
+        overlapX1 !== cx1 || overlapX2 !== cx2 ? overlapX2 - overlapX1 : 0;
+      const overlapHeight =
+        overlapY1 !== cy1 || overlapY2 !== cy2 ? overlapY2 - overlapY1 : 0;
+      const area = Math.max(0.00001, Math.abs(x2 - x1) * Math.abs(y2 - y1));
+      const overlapPercent = Math.abs(overlapHeight * overlapWdith) / area;
+
+      return {
+        ...c,
+        overlapPercent,
+        relativeArea:
+          overlapPercent === 0 ? 1 : Math.min(area / candidateArea, 1),
+      };
+    })
+    .filter((c) => c.overlapPercent > 0.25 && c.relativeArea < 0.75);
+
+  return candidate.distance >= 0 && overlaps.length > 0
+    ? overlaps[0].element
+    : candidate.element;
 };
 
 /**

packages/element/src/dragElements.ts

@@ -21,7 +21,7 @@ import { getPerfectElementSize } from "./sizeHelpers";
 import { getBoundTextElement } from "./textElement";
 import { getMinTextElementWidth } from "./textMeasurements";
 import {
-  isArrowElement,
+  isArrowElement as isBindingElement,
   isElbowArrow,
   isFrameLikeElement,
   isImageElement,
@@ -108,19 +108,7 @@ export const dragSelectedElements = (
   );
 
   elementsToUpdate.forEach((element) => {
-    const isArrow = !isArrowElement(element);
+    if (!isBindingElement(element)) {
-    const isStartBoundElementSelected =
-      isArrow ||
-      (element.startBinding
-        ? elementsToUpdateIds.has(element.startBinding.elementId)
-        : false);
-    const isEndBoundElementSelected =
-      isArrow ||
-      (element.endBinding
-        ? elementsToUpdateIds.has(element.endBinding.elementId)
-        : false);
-
-    if (!isArrowElement(element)) {
       updateElementCoords(pointerDownState, element, scene, adjustedOffset);
 
       // skip arrow labels since we calculate its position during render
@@ -143,7 +131,6 @@ export const dragSelectedElements = (
       // NOTE: Add a little initial drag to the arrow dragging when the arrow
       // is the single element being dragged to avoid accidentally unbinding
       // the arrow when the user just wants to select it.
-
       elementsToUpdate.size > 1 ||
       Math.max(Math.abs(adjustedOffset.x), Math.abs(adjustedOffset.y)) >
         DRAGGING_THRESHOLD ||
@@ -151,9 +138,12 @@ export const dragSelectedElements = (
     ) {
       updateElementCoords(pointerDownState, element, scene, adjustedOffset);
 
-      const shouldUnbindStart =
+      const shouldUnbindStart = element.startBinding
-        element.startBinding && !isStartBoundElementSelected;
+        ? !elementsToUpdateIds.has(element.startBinding.elementId)
-      const shouldUnbindEnd = element.endBinding && !isEndBoundElementSelected;
+        : true;
+      const shouldUnbindEnd = element.endBinding
+        ? !elementsToUpdateIds.has(element.endBinding.elementId)
+        : true;
       if (shouldUnbindStart || shouldUnbindEnd) {
         // NOTE: Moving the bound arrow should unbind it, otherwise we would
         // have weird situations, like 0 lenght arrow when the user moves

packages/element/src/elbowArrow.ts

@@ -30,8 +30,7 @@ import {
   getHeadingForElbowArrowSnap,
   getGlobalFixedPointForBindableElement,
   getBindingGap,
-  maxBindingDistance_simple,
+  BASE_BINDING_GAP,
-  BASE_BINDING_GAP_ELBOW,
 } from "./binding";
 import { distanceToElement } from "./distance";
 import {
@@ -318,6 +317,7 @@ const handleSegmentRelease = (
     ...rest
   } = getElbowArrowData(
     {
+      ...arrow,
       x,
       y,
       startBinding,
@@ -1041,6 +1041,7 @@ export const updateElbowArrowPoints = (
     ...rest
   } = getElbowArrowData(
     {
+      ...arrow,
       x: arrow.x,
       y: arrow.y,
       startBinding,
@@ -1190,15 +1191,7 @@ export const updateElbowArrowPoints = (
  * - hoveredEndElement: The element being hovered over at the end point.
  */
 const getElbowArrowData = (
-  arrow: {
+  arrow: ExcalidrawElbowArrowElement,
-    x: number;
-    y: number;
-    startBinding: FixedPointBinding | null;
-    endBinding: FixedPointBinding | null;
-    startArrowhead: Arrowhead | null;
-    endArrowhead: Arrowhead | null;
-    points: readonly LocalPoint[];
-  },
   elementsMap: NonDeletedSceneElementsMap,
   nextPoints: readonly LocalPoint[],
   options?: {
@@ -1223,6 +1216,7 @@ const getElbowArrowData = (
     const elements = Array.from(elementsMap.values());
     hoveredStartElement =
       getHoveredElement(
+        arrow,
         origStartGlobalPoint,
         elementsMap,
         elements,
@@ -1230,6 +1224,7 @@ const getElbowArrowData = (
       ) || null;
     hoveredEndElement =
       getHoveredElement(
+        arrow,
         origEndGlobalPoint,
         elementsMap,
         elements,
@@ -1256,6 +1251,7 @@ const getElbowArrowData = (
     "start",
     arrow.startBinding?.fixedPoint,
     origStartGlobalPoint,
+    options?.zoom || ({ value: 1 } as AppState["zoom"]),
     hoveredStartElement,
     elementsMap,
     options?.isDragging,
@@ -1273,6 +1269,7 @@ const getElbowArrowData = (
     "end",
     arrow.endBinding?.fixedPoint,
     origEndGlobalPoint,
+    options?.zoom || ({ value: 1 } as AppState["zoom"]),
     hoveredEndElement,
     elementsMap,
     options?.isDragging,
@@ -1314,8 +1311,8 @@ const getElbowArrowData = (
         offsetFromHeading(
           startHeading,
           arrow.startArrowhead
-            ? getBindingGap(hoveredStartElement, { elbowed: true }) * 6
+            ? getBindingGap(hoveredStartElement) * 6
-            : getBindingGap(hoveredStartElement, { elbowed: true }) * 2,
+            : getBindingGap(hoveredStartElement) * 2,
           1,
         ),
       )
@@ -1327,8 +1324,8 @@ const getElbowArrowData = (
         offsetFromHeading(
           endHeading,
           arrow.endArrowhead
-            ? getBindingGap(hoveredEndElement, { elbowed: true }) * 6
+            ? getBindingGap(hoveredEndElement) * 6
-            : getBindingGap(hoveredEndElement, { elbowed: true }) * 2,
+            : getBindingGap(hoveredEndElement) * 2,
           1,
         ),
       )
@@ -1375,8 +1372,8 @@ const getElbowArrowData = (
             ? 0
             : BASE_PADDING -
                 (arrow.startArrowhead
-                  ? BASE_BINDING_GAP_ELBOW * 6
+                  ? BASE_BINDING_GAP * 6
-                  : BASE_BINDING_GAP_ELBOW * 2),
+                  : BASE_BINDING_GAP * 2),
           BASE_PADDING,
         ),
     boundsOverlap
@@ -1391,8 +1388,8 @@ const getElbowArrowData = (
             ? 0
             : BASE_PADDING -
                 (arrow.endArrowhead
-                  ? BASE_BINDING_GAP_ELBOW * 6
+                  ? BASE_BINDING_GAP * 6
-                  : BASE_BINDING_GAP_ELBOW * 2),
+                  : BASE_BINDING_GAP * 2),
           BASE_PADDING,
         ),
     boundsOverlap,
@@ -2218,6 +2215,7 @@ const getGlobalPoint = (
   startOrEnd: "start" | "end",
   fixedPointRatio: [number, number] | undefined | null,
   initialPoint: GlobalPoint,
+  zoom: AppState["zoom"],
   element?: ExcalidrawBindableElement | null,
   elementsMap?: ElementsMap,
   isDragging?: boolean,
@@ -2231,6 +2229,7 @@ const getGlobalPoint = (
         element,
         startOrEnd,
         elementsMap,
+        zoom,
         undefined,
         isMidpointSnappingEnabled,
       );
@@ -2279,16 +2278,18 @@ const getBindPointHeading = (
   );
 
 const getHoveredElement = (
+  arrow: ExcalidrawElbowArrowElement,
   origPoint: GlobalPoint,
   elementsMap: NonDeletedSceneElementsMap,
   elements: readonly Ordered<NonDeletedExcalidrawElement>[],
   zoom?: AppState["zoom"],
 ) => {
   return getHoveredElementForBinding(
+    arrow,
     origPoint,
     elements,
     elementsMap,
-    maxBindingDistance_simple(zoom),
+    zoom,
   );
 };
 

packages/element/src/flowchart.ts

@@ -452,8 +452,16 @@ const createBindingArrow = (
     "orbit",
     "start",
     scene,
+    appState.zoom,
+  );
+  bindBindingElement(
+    bindingArrow,
+    endBindingElement,
+    "orbit",
+    "end",
+    scene,
+    appState.zoom,
   );
-  bindBindingElement(bindingArrow, endBindingElement, "orbit", "end", scene);
 
   const changedElements = new Map<string, OrderedExcalidrawElement>();
   changedElements.set(

packages/element/src/frame.ts

@@ -1,9 +1,6 @@
 import { arrayToMap } from "@excalidraw/common";
-import {
+import { isPointWithinBounds, pointFrom } from "@excalidraw/math";
-  isPointWithinBounds,
+import { doLineSegmentsIntersect } from "@excalidraw/utils/bbox";
-  pointFrom,
-  segmentsIntersectAt,
-} from "@excalidraw/math";
 
 import type {
   AppClassProperties,
@@ -81,7 +78,7 @@ export function isElementIntersectingFrame(
 
   const intersecting = frameLineSegments.some((frameLineSegment) =>
     elementLineSegments.some((elementLineSegment) =>
-      segmentsIntersectAt(frameLineSegment, elementLineSegment),
+      doLineSegmentsIntersect(frameLineSegment, elementLineSegment),
     ),
   );
 
@@ -569,6 +566,10 @@ export const addElementsToFrame = <T extends ElementsMapOrArray>(
       continue;
     }
 
+    if (element.frameId && element.frameId !== frame.id) {
+      continue;
+    }
+
     finalElementsToAdd.add(element);
 
     const boundTextElement = getBoundTextElement(element, elementsMap);

packages/element/src/linearElementEditor.ts

@@ -48,7 +48,6 @@ import {
   calculateFixedPointForNonElbowArrowBinding,
   getBindingStrategyForDraggingBindingElementEndpoints,
   isBindingEnabled,
-  snapToMid,
   updateBoundPoint,
 } from "./binding";
 import {
@@ -344,7 +343,7 @@ export class LinearElementEditor {
 
     // Apply the point movement if needed
     let suggestedBinding: AppState["suggestedBinding"] = null;
-    const { positions, updates } = pointDraggingUpdates(
+    const { positions, updates, hit } = pointDraggingUpdates(
       [idx],
       deltaX,
       deltaY,
@@ -382,17 +381,20 @@ export class LinearElementEditor {
 
     // Move the arrow over the bindable object in terms of z-index
     if (isBindingElement(element)) {
-      moveArrowAboveBindable(
+      if (hit) {
-        LinearElementEditor.getPointGlobalCoordinates(
+        moveArrowAboveBindable(
+          LinearElementEditor.getPointGlobalCoordinates(
+            element,
+            element.points[element.points.length - 1],
+            elementsMap,
+          ),
           element,
-          element.points[element.points.length - 1],
+          elements,
           elementsMap,
-        ),
+          app.scene,
-        element,
+          hit,
-        elements,
+        );
-        elementsMap,
+      }
-        app.scene,
-      );
     }
 
     // PERF: Avoid state updates if not absolutely necessary
@@ -539,7 +541,7 @@ export class LinearElementEditor {
 
     // Apply the point movement if needed
     let suggestedBinding: AppState["suggestedBinding"] = null;
-    const { positions, updates } = pointDraggingUpdates(
+    const { positions, updates, hit } = pointDraggingUpdates(
       selectedPointsIndices,
       deltaX,
       deltaY,
@@ -578,19 +580,22 @@ export class LinearElementEditor {
 
     // Move the arrow over the bindable object in terms of z-index
     if (isBindingElement(element) && startIsSelected !== endIsSelected) {
-      moveArrowAboveBindable(
+      if (hit) {
-        LinearElementEditor.getPointGlobalCoordinates(
+        moveArrowAboveBindable(
+          LinearElementEditor.getPointGlobalCoordinates(
+            element,
+            startIsSelected
+              ? element.points[0]
+              : element.points[element.points.length - 1],
+            elementsMap,
+          ),
           element,
-          startIsSelected
+          elements,
-            ? element.points[0]
-            : element.points[element.points.length - 1],
           elementsMap,
-        ),
+          app.scene,
-        element,
+          hit,
-        elements,
+        );
-        elementsMap,
+      }
-        app.scene,
-      );
     }
 
     // Attached text might need to update if arrow dimensions change
@@ -2136,6 +2141,7 @@ const pointDraggingUpdates = (
 ): {
   positions: PointsPositionUpdates;
   updates?: PointMoveOtherUpdates;
+  hit?: ExcalidrawBindableElement | null;
 } => {
   const naiveDraggingPoints = new Map(
     selectedPointsIndices.map((pointIndex) => {
@@ -2193,13 +2199,15 @@ const pointDraggingUpdates = (
           ? {
               element: suggestedBindingElement,
               midPoint: app.state.isMidpointSnappingEnabled
-                ? snapToMid(
+                ? getSnapOutlineMidPoint(
-                    suggestedBindingElement,
-                    elementsMap,
                     pointFrom<GlobalPoint>(
                       scenePointerX - linearElementEditor.pointerOffset.x,
                       scenePointerY - linearElementEditor.pointerOffset.y,
                     ),
+                    suggestedBindingElement,
+                    elementsMap,
+                    app.state.zoom,
+                    element,
                   )
                 : undefined,
             }
@@ -2306,6 +2314,7 @@ const pointDraggingUpdates = (
               start.element,
               elementsMap,
               app.state.zoom,
+              element,
             ),
           }
         : null;
@@ -2345,6 +2354,7 @@ const pointDraggingUpdates = (
               end.element,
               elementsMap,
               app.state.zoom,
+              element,
             ),
           }
         : null;
@@ -2497,6 +2507,7 @@ const pointDraggingUpdates = (
         ];
       }),
     ),
+    hit: startIsDragged ? start.element : end.element,
   };
 };
 

packages/element/src/renderElement.ts

@@ -422,10 +422,10 @@ const drawElementOnCanvas = (
 
       for (const shape of shapes) {
         if (typeof shape === "string") {
-          context.fillStyle = applyDarkModeFilter(
+          context.fillStyle =
-            element.strokeColor,
+            renderConfig.theme === THEME.DARK
-            renderConfig.theme === THEME.DARK,
+              ? applyDarkModeFilter(element.strokeColor)
-          );
+              : element.strokeColor;
           context.fill(new Path2D(shape));
         } else {
           rc.draw(shape);
@@ -555,10 +555,10 @@ const drawElementOnCanvas = (
         context.canvas.setAttribute("dir", rtl ? "rtl" : "ltr");
         context.save();
         context.font = getFontString(element);
-        context.fillStyle = applyDarkModeFilter(
+        context.fillStyle =
-          element.strokeColor,
+          renderConfig.theme === THEME.DARK
-          renderConfig.theme === THEME.DARK,
+            ? applyDarkModeFilter(element.strokeColor)
-        );
+            : element.strokeColor;
         context.textAlign = element.textAlign as CanvasTextAlign;
 
         // Canvas does not support multiline text by default
@@ -811,10 +811,10 @@ export const renderElement = (
         context.fillStyle = "rgba(0, 0, 200, 0.04)";
 
         context.lineWidth = FRAME_STYLE.strokeWidth / appState.zoom.value;
-        context.strokeStyle = applyDarkModeFilter(
+        context.strokeStyle =
-          FRAME_STYLE.strokeColor,
+          appState.theme === THEME.DARK
-          appState.theme === THEME.DARK,
+            ? applyDarkModeFilter(FRAME_STYLE.strokeColor)
-        );
+            : FRAME_STYLE.strokeColor;
 
         // TODO change later to only affect AI frames
         if (isMagicFrameElement(element)) {

packages/element/src/selection.ts

@@ -1,4 +1,10 @@
 import { arrayToMap, isShallowEqual, type Bounds } from "@excalidraw/common";
+import {
+  lineSegment,
+  pointFrom,
+  pointRotateRads,
+  type GlobalPoint,
+} from "@excalidraw/math";
 
 import type {
   AppState,
@@ -6,18 +12,33 @@ import type {
   InteractiveCanvasAppState,
 } from "@excalidraw/excalidraw/types";
 
-import { elementsOverlappingBBox, getElementAbsoluteCoords } from "./bounds";
+import {
+  boundsContainBounds,
+  doBoundsIntersect,
+  elementCenterPoint,
+  getElementAbsoluteCoords,
+  getElementBounds,
+  pointInsideBounds,
+} from "./bounds";
+import { intersectElementWithLineSegment } from "./collision";
 import { isElementInViewport } from "./sizeHelpers";
 import {
+  isArrowElement,
   isBoundToContainer,
   isFrameLikeElement,
+  isFreeDrawElement,
   isLinearElement,
   isTextElement,
 } from "./typeChecks";
-import { getFrameChildren } from "./frame";
+import {
+  elementOverlapsWithFrame,
+  getContainingFrame,
+  getFrameChildren,
+} from "./frame";
 
 import { LinearElementEditor } from "./linearElementEditor";
 import { selectGroupsForSelectedElements } from "./groups";
+import { getBoundTextElement } from "./textElement";
 
 import type {
   ElementsMap,
@@ -86,15 +107,263 @@ export const getElementsWithinSelection = (
     selectionX2,
     selectionY2,
   ] as Bounds;
+  const selectionEdges = [
+    lineSegment<GlobalPoint>(
+      pointFrom(selectionX1, selectionY1),
+      pointFrom(selectionX2, selectionY1),
+    ),
+    lineSegment<GlobalPoint>(
+      pointFrom(selectionX2, selectionY1),
+      pointFrom(selectionX2, selectionY2),
+    ),
+    lineSegment<GlobalPoint>(
+      pointFrom(selectionX2, selectionY2),
+      pointFrom(selectionX1, selectionY2),
+    ),
+    lineSegment<GlobalPoint>(
+      pointFrom(selectionX1, selectionY2),
+      pointFrom(selectionX1, selectionY1),
+    ),
+  ];
 
-  return elementsOverlappingBBox({
+  const framesInSelection = excludeElementsInFrames
-    elements,
+    ? new Set<NonDeletedExcalidrawElement["id"]>()
-    bounds: selectionBounds,
+    : null;
-    elementsMap,
+  const groups: Record<string, NonDeletedExcalidrawElement[]> = {};
-    type: boxSelectionMode,
+  const elementsInSelection: Set<NonDeletedExcalidrawElement> = new Set();
-    shouldIgnoreElementFromSelection,
+
-    excludeElementsInFrames,
+  for (const element of elements) {
-  });
+    if (shouldIgnoreElementFromSelection(element)) {
+      continue;
+    }
+
+    // Track only selectable top-level group members, so ignored elements such
+    // as bound text and locked elements don't affect group selection.
+    const groupId = element.groupIds.at(-1);
+    if (groupId) {
+      if (!groups[groupId]) {
+        groups[groupId] = [];
+      }
+      groups[groupId].push(element);
+    }
+
+    const strokeWidth = element.strokeWidth;
+    let labelAABB: Bounds | null = null;
+    let elementAABB = getElementBounds(element, elementsMap);
+
+    elementAABB = [
+      elementAABB[0] - strokeWidth / 2,
+      elementAABB[1] - strokeWidth / 2,
+      elementAABB[2] + strokeWidth / 2,
+      elementAABB[3] + strokeWidth / 2,
+    ] as Bounds;
+
+    // Whether the element bounds should include the bound text element bounds
+    const boundTextElement =
+      isArrowElement(element) && getBoundTextElement(element, elementsMap);
+    if (boundTextElement) {
+      const { x, y } = LinearElementEditor.getBoundTextElementPosition(
+        element,
+        boundTextElement,
+        elementsMap,
+      );
+      labelAABB = [
+        x,
+        y,
+        x + boundTextElement.width,
+        y + boundTextElement.height,
+      ] as Bounds;
+    }
+
+    // Clip element bounds by its containing frame (if any), since only the
+    // visible (frame-clipped) portion of the element is relevant for selection.
+    const associatedFrame = getContainingFrame(element, elementsMap);
+    if (
+      associatedFrame &&
+      elementOverlapsWithFrame(element, associatedFrame, elementsMap)
+    ) {
+      const frameAABB = getElementBounds(associatedFrame, elementsMap);
+      elementAABB = [
+        Math.max(elementAABB[0], frameAABB[0]),
+        Math.max(elementAABB[1], frameAABB[1]),
+        Math.min(elementAABB[2], frameAABB[2]),
+        Math.min(elementAABB[3], frameAABB[3]),
+      ] as Bounds;
+
+      labelAABB = labelAABB
+        ? ([
+            Math.max(labelAABB[0], frameAABB[0]),
+            Math.max(labelAABB[1], frameAABB[1]),
+            Math.min(labelAABB[2], frameAABB[2]),
+            Math.min(labelAABB[3], frameAABB[3]),
+          ] as Bounds)
+        : null;
+    }
+
+    const commonAABB = labelAABB
+      ? ([
+          Math.min(labelAABB[0], elementAABB[0]),
+          Math.min(labelAABB[1], elementAABB[1]),
+          Math.max(labelAABB[2], elementAABB[2]),
+          Math.max(labelAABB[3], elementAABB[3]),
+        ] as Bounds)
+      : elementAABB;
+
+    // ============== Evaluation ==============
+
+    // 1. If the selection box WRAPs the element's AABB, then add it to the
+    //    selection and move on, regardless of the selection mode.
+    //
+    //    PERF: This trick only works with axis-aligned box selection and the
+    //          current convex element shapes!
+    if (boundsContainBounds(selectionBounds, commonAABB)) {
+      if (framesInSelection && isFrameLikeElement(element)) {
+        framesInSelection.add(element.id);
+      }
+      elementsInSelection.add(element);
+      continue;
+    }
+
+    // 2. Handle the case where the label is overlapped by the selection box
+    if (
+      boxSelectionMode === "overlap" &&
+      labelAABB &&
+      doBoundsIntersect(selectionBounds, labelAABB)
+    ) {
+      elementsInSelection.add(element);
+      continue;
+    }
+
+    // 3. Handle the case where the selection is not wrapping the element, but
+    //    it does intersect the element's outline (non-AABB).
+    if (
+      boxSelectionMode === "overlap" &&
+      doBoundsIntersect(selectionBounds, elementAABB)
+    ) {
+      let hasIntersection = false;
+
+      // Preliminary check potential intersection imprecision
+      if (isLinearElement(element) || isFreeDrawElement(element)) {
+        const center = elementCenterPoint(element, elementsMap);
+        hasIntersection = element.points.some((point) => {
+          const rotatedPoint = pointRotateRads(
+            pointFrom<GlobalPoint>(element.x + point[0], element.y + point[1]),
+            center,
+            element.angle,
+          );
+
+          return pointInsideBounds(rotatedPoint, selectionBounds);
+        });
+      } else {
+        const nonRotatedElementBounds = getElementBounds(
+          element,
+          elementsMap,
+          true,
+        );
+        const center = elementCenterPoint(element, elementsMap);
+        hasIntersection = [
+          pointRotateRads(
+            pointFrom<GlobalPoint>(
+              (nonRotatedElementBounds[0] + nonRotatedElementBounds[2]) / 2,
+              nonRotatedElementBounds[1],
+            ),
+            center,
+            element.angle,
+          ),
+          pointRotateRads(
+            pointFrom<GlobalPoint>(
+              nonRotatedElementBounds[2],
+              (nonRotatedElementBounds[1] + nonRotatedElementBounds[3]) / 2,
+            ),
+            center,
+            element.angle,
+          ),
+          pointRotateRads(
+            pointFrom<GlobalPoint>(
+              (nonRotatedElementBounds[0] + nonRotatedElementBounds[2]) / 2,
+              nonRotatedElementBounds[3],
+            ),
+            center,
+            element.angle,
+          ),
+          pointRotateRads(
+            pointFrom<GlobalPoint>(
+              nonRotatedElementBounds[0],
+              (nonRotatedElementBounds[1] + nonRotatedElementBounds[3]) / 2,
+            ),
+            center,
+            element.angle,
+          ),
+        ].some((point) => {
+          return pointInsideBounds(
+            pointRotateRads(point, center, element.angle),
+            selectionBounds,
+          );
+        });
+      }
+
+      if (!hasIntersection) {
+        hasIntersection = selectionEdges.some(
+          (selectionEdge) =>
+            intersectElementWithLineSegment(
+              element,
+              elementsMap,
+              selectionEdge,
+              strokeWidth / 2,
+              true, // Stop at first hit for better performance
+            ).length > 0,
+        );
+      }
+
+      if (hasIntersection) {
+        if (framesInSelection && isFrameLikeElement(element)) {
+          framesInSelection.add(element.id);
+        }
+
+        elementsInSelection.add(element);
+        continue;
+      }
+    }
+
+    // 4. We don't need to handle when the selection is inside the element
+    //    as it is separately handled in App.
+  }
+
+  if (framesInSelection) {
+    elementsInSelection.forEach((element) => {
+      if (element.frameId && framesInSelection.has(element.frameId)) {
+        elementsInSelection.delete(element);
+      }
+    });
+  }
+
+  if (boxSelectionMode === "overlap") {
+    Array.from(elementsInSelection).forEach((element) => {
+      const groupId = element.groupIds.at(-1);
+      const group = groupId ? groups[groupId] : null;
+
+      group?.forEach((groupElement) => elementsInSelection.add(groupElement));
+    });
+  } else if (boxSelectionMode === "contain") {
+    elementsInSelection.forEach((element) => {
+      // note: currently we only support top-level group handling since
+      // we don't support box selecting while editing the group/subgroup
+      // see https://github.com/excalidraw/excalidraw/pull/11234#issuecomment-4387654451
+      const groupId = element.groupIds.at(-1);
+
+      const group = groupId ? groups[groupId] : null;
+
+      if (
+        group &&
+        !group.every((groupElement) => elementsInSelection.has(groupElement))
+      ) {
+        elementsInSelection.delete(element);
+      }
+    });
+  }
+
+  // to maintain original order elements (namely for group selection)
+  return elements.filter((element) => elementsInSelection.has(element));
 };
 
 export const getVisibleAndNonSelectedElements = (

packages/element/src/shape.ts

@@ -218,7 +218,9 @@ export const generateRoughOptions = (
     fillWeight: element.strokeWidth / 2,
     hachureGap: element.strokeWidth * 4,
     roughness: adjustRoughness(element),
-    stroke: applyDarkModeFilter(element.strokeColor, isDarkMode),
+    stroke: isDarkMode
+      ? applyDarkModeFilter(element.strokeColor)
+      : element.strokeColor,
     preserveVertices:
       continuousPath || element.roughness < ROUGHNESS.cartoonist,
   };
@@ -232,7 +234,9 @@ export const generateRoughOptions = (
       options.fillStyle = element.fillStyle;
       options.fill = isTransparent(element.backgroundColor)
         ? undefined
-        : applyDarkModeFilter(element.backgroundColor, isDarkMode);
+        : isDarkMode
+        ? applyDarkModeFilter(element.backgroundColor)
+        : element.backgroundColor;
       if (element.type === "ellipse") {
         options.curveFitting = 1;
       }
@@ -245,7 +249,9 @@ export const generateRoughOptions = (
         options.fill =
           element.backgroundColor === "transparent"
             ? undefined
-            : applyDarkModeFilter(element.backgroundColor, isDarkMode);
+            : isDarkMode
+            ? applyDarkModeFilter(element.backgroundColor)
+            : element.backgroundColor;
       }
       return options;
     }
@@ -380,11 +386,12 @@ const getArrowheadShapes = (
     return [];
   }
 
-  const strokeColor = applyDarkModeFilter(element.strokeColor, isDarkMode);
+  const strokeColor = isDarkMode
-  const backgroundFillColor = applyDarkModeFilter(
+    ? applyDarkModeFilter(element.strokeColor)
-    canvasBackgroundColor,
+    : element.strokeColor;
-    isDarkMode,
+  const backgroundFillColor = isDarkMode
-  );
+    ? applyDarkModeFilter(canvasBackgroundColor)
+    : canvasBackgroundColor;
   const cardinalityOneOrManyOffset = -0.25;
   const cardinalityZeroCircleScale = 0.8;
 

packages/element/src/transform.ts

@@ -17,6 +17,7 @@ import {
 } from "@excalidraw/common";
 
 import type { MarkOptional } from "@excalidraw/common/utility-types";
+import type { Zoom } from "@excalidraw/excalidraw/types";
 
 import { bindBindingElement } from "./binding";
 import {
@@ -248,6 +249,7 @@ const bindLinearElementToElement = (
   end: ValidLinearElement["end"],
   elementStore: ElementStore,
   scene: Scene,
+  zoom: Zoom,
 ): {
   linearElement: ExcalidrawLinearElement;
   startBoundElement?: ExcalidrawElement;
@@ -335,6 +337,7 @@ const bindLinearElementToElement = (
         "orbit",
         "start",
         scene,
+        zoom,
       );
     }
   }
@@ -411,6 +414,7 @@ const bindLinearElementToElement = (
         "orbit",
         "end",
         scene,
+        zoom,
       );
     }
   }
@@ -696,6 +700,7 @@ export const convertToExcalidrawElements = (
                 originalEnd,
                 elementStore,
                 scene,
+                { value: 1 } as Zoom,
               );
             container = linearElement;
             elementStore.add(linearElement);
@@ -721,6 +726,7 @@ export const convertToExcalidrawElements = (
                   end,
                   elementStore,
                   scene,
+                  { value: 1 } as Zoom,
                 );
 
               elementStore.add(linearElement);

packages/element/src/utils.ts

@@ -8,6 +8,7 @@ import {
 
 import {
   bezierEquation,
+  clamp,
   curve,
   curveCatmullRomCubicApproxPoints,
   curveOffsetPoints,
@@ -26,7 +27,7 @@ import {
   type GlobalPoint,
 } from "@excalidraw/math";
 
-import type { Curve, LineSegment, LocalPoint } from "@excalidraw/math";
+import type { Curve, LineSegment, LocalPoint, Radians } from "@excalidraw/math";
 
 import type {
   AppState,
@@ -41,7 +42,7 @@ import { generateLinearCollisionShape } from "./shape";
 import { hitElementItself, isPointInElement } from "./collision";
 import { LinearElementEditor } from "./linearElementEditor";
 import { isRectangularElement } from "./typeChecks";
-import { maxBindingDistance_simple } from "./binding";
+import { getBindingGap, maxBindingDistance_simple } from "./binding";
 
 import {
   getGlobalFixedPointForBindableElement,
@@ -587,67 +588,193 @@ const getDiagonalsForBindableElement = (
   return [diagonalOne, diagonalTwo];
 };
 
-export const getSnapOutlineMidPoint = (
+const getSnappedMidpointIndexForElbowArrow = (
-  point: GlobalPoint,
   element: ExcalidrawBindableElement,
-  elementsMap: ElementsMap,
+  point: GlobalPoint,
-  zoom: AppState["zoom"],
+  center: GlobalPoint,
+  horizontalThreshold: number,
+  verticalThreshold: number,
 ) => {
-  const center = elementCenterPoint(element, elementsMap);
+  const { x, y, width, height, angle } = element;
-  const sideMidpoints =
+  const nonRotated = pointRotateRads(point, center, -angle as Radians);
-    element.type === "diamond"
-      ? getDiamondBaseCorners(element).map((curve) => {
-          const point = bezierEquation(curve, 0.5);
-          const rotatedPoint = pointRotateRads(point, center, element.angle);
 
-          return pointFrom<GlobalPoint>(rotatedPoint[0], rotatedPoint[1]);
+  const bindingGap = getBindingGap(element);
-        })
+
-      : [
+  if (pointDistance(center, nonRotated) < bindingGap) {
-          // RIGHT midpoint
+    return -1;
-          pointRotateRads(
+  }
-            pointFrom<GlobalPoint>(
+
-              element.x + element.width,
+  if (
-              element.y + element.height / 2,
+    nonRotated[0] <= x + width / 2 &&
-            ),
+    nonRotated[1] > center[1] - verticalThreshold &&
-            center,
+    nonRotated[1] < center[1] + verticalThreshold
-            element.angle,
+  ) {
-          ),
+    return 2;
-          // BOTTOM midpoint
+  } else if (
-          pointRotateRads(
+    nonRotated[1] <= y + height / 2 &&
-            pointFrom<GlobalPoint>(
+    nonRotated[0] > center[0] - horizontalThreshold &&
-              element.x + element.width / 2,
+    nonRotated[0] < center[0] + horizontalThreshold
-              element.y + element.height,
+  ) {
-            ),
+    return 3;
-            center,
+  } else if (
-            element.angle,
+    nonRotated[0] >= x + width / 2 &&
-          ),
+    nonRotated[1] > center[1] - verticalThreshold &&
-          // LEFT midpoint
+    nonRotated[1] < center[1] + verticalThreshold
-          pointRotateRads(
+  ) {
-            pointFrom<GlobalPoint>(element.x, element.y + element.height / 2),
+    return 0;
-            center,
+  } else if (
-            element.angle,
+    nonRotated[1] >= y + height / 2 &&
-          ),
+    nonRotated[0] > center[0] - horizontalThreshold &&
-          // TOP midpoint
+    nonRotated[0] < center[0] + horizontalThreshold
-          pointRotateRads(
+  ) {
-            pointFrom<GlobalPoint>(element.x + element.width / 2, element.y),
+    return 1;
-            center,
+  } else if (element.type === "diamond") {
-            element.angle,
+    const distance = bindingGap;
-          ),
+    const topLeft = pointFrom<GlobalPoint>(
-        ];
+      x + width / 4 - distance,
-  const candidate = sideMidpoints.find(
+      y + height / 4 - distance,
-    (midpoint) =>
+    );
-      pointDistance(point, midpoint) <=
+    const topRight = pointFrom<GlobalPoint>(
-        maxBindingDistance_simple(zoom) + element.strokeWidth / 2 &&
+      x + (3 * width) / 4 + distance,
+      y + height / 4 - distance,
+    );
+    const bottomLeft = pointFrom<GlobalPoint>(
+      x + width / 4 - distance,
+      y + (3 * height) / 4 + distance,
+    );
+    const bottomRight = pointFrom<GlobalPoint>(
+      x + (3 * width) / 4 + distance,
+      y + (3 * height) / 4 + distance,
+    );
+
+    if (
+      pointDistance(bottomLeft, nonRotated) <
+      Math.max(horizontalThreshold, verticalThreshold)
+    ) {
+      return 1;
+    }
+    if (
+      pointDistance(bottomRight, nonRotated) <
+      Math.max(horizontalThreshold, verticalThreshold)
+    ) {
+      return 0;
+    }
+    if (
+      pointDistance(topLeft, nonRotated) <
+      Math.max(horizontalThreshold, verticalThreshold)
+    ) {
+      return 2;
+    }
+    if (
+      pointDistance(topRight, nonRotated) <
+      Math.max(horizontalThreshold, verticalThreshold)
+    ) {
+      return 3;
+    }
+  }
+
+  return -1;
+};
+
+const getSnappedMidpointIndexForSimpleArrow = (
+  element: ExcalidrawBindableElement,
+  point: GlobalPoint,
+  elementsMap: ElementsMap,
+  horizontalThreshold: number,
+  verticalThreshold: number,
+) => {
+  const baseMidpoints = getAllMidpoints(element, elementsMap);
+
+  for (let i = 0; i < baseMidpoints.length; i++) {
+    const threshold = i % 2 === 0 ? horizontalThreshold : verticalThreshold;
+
+    if (
+      pointDistance(baseMidpoints[i], point) <= threshold &&
       !hitElementItself({
         point,
         element,
         threshold: 0,
         elementsMap,
         overrideShouldTestInside: true,
-      }),
+      })
-  );
+    ) {
+      return i;
+    }
+  }
 
-  return candidate;
+  return -1;
+};
+
+export const getAllMidpoints = (
+  element: ExcalidrawBindableElement,
+  elementsMap: ElementsMap,
+): GlobalPoint[] => {
+  const center = elementCenterPoint(element, elementsMap);
+
+  if (element.type === "diamond") {
+    return getDiamondBaseCorners(element).map((curve) =>
+      pointRotateRads(bezierEquation(curve, 0.5), center, element.angle),
+    );
+  }
+
+  return [
+    pointFrom(element.width, element.height / 2),
+    pointFrom(element.width / 2, element.height),
+    pointFrom(0, element.height / 2),
+    pointFrom(element.width / 2, 0),
+  ].map(([x, y]) =>
+    pointRotateRads(
+      pointFrom<GlobalPoint>(element.x + x, element.y + y),
+      center,
+      element.angle,
+    ),
+  );
+};
+
+export const getSnapOutlineMidPoint = (
+  point: GlobalPoint,
+  element: ExcalidrawBindableElement,
+  elementsMap: ElementsMap,
+  zoom: AppState["zoom"],
+  arrow: { elbowed: boolean },
+): GlobalPoint | undefined => {
+  const center = elementCenterPoint(element, elementsMap);
+  const baseMidpoints = getAllMidpoints(element, elementsMap);
+  const sideMidpoints =
+    element.type === "diamond"
+      ? baseMidpoints.map((midpoint) => {
+          return pointFrom<GlobalPoint>(
+            midpoint[0] + (midpoint[0] - center[0]) * 0.1,
+            midpoint[1] + (midpoint[1] - center[1]) * 0.1,
+          );
+        })
+      : baseMidpoints;
+
+  const TOLERANCE = 0.05;
+  const maxDistance = maxBindingDistance_simple(zoom) + element.strokeWidth / 2;
+  const verticalThreshold = clamp(TOLERANCE * element.height, 5, maxDistance);
+  const horizontalThreshold = clamp(TOLERANCE * element.width, 5, maxDistance);
+  const idx = arrow.elbowed
+    ? getSnappedMidpointIndexForElbowArrow(
+        element,
+        point,
+        center,
+        horizontalThreshold,
+        verticalThreshold,
+      )
+    : getSnappedMidpointIndexForSimpleArrow(
+        element,
+        point,
+        elementsMap,
+        horizontalThreshold,
+        verticalThreshold,
+      );
+
+  if (idx === -1) {
+    return undefined;
+  }
+
+  return sideMidpoints[idx];
 };
 
 export const projectFixedPointOntoDiagonal = (
@@ -660,9 +787,6 @@ export const projectFixedPointOntoDiagonal = (
   isMidpointSnappingEnabled: boolean = true,
 ): GlobalPoint | null => {
   invariant(arrow.points.length >= 2, "Arrow must have at least two points");
-  if (arrow.width < 3 && arrow.height < 3) {
-    return null;
-  }
 
   if (isMidpointSnappingEnabled) {
     const sideMidPoint = getSnapOutlineMidPoint(
@@ -670,6 +794,7 @@ export const projectFixedPointOntoDiagonal = (
       element,
       elementsMap,
       zoom,
+      arrow,
     );
     if (sideMidPoint) {
       return sideMidPoint;

packages/element/src/visualdebug.ts

@@ -5,7 +5,6 @@ import {
   pointFrom,
   type GlobalPoint,
   type LocalPoint,
-  type LineSegment,
 } from "@excalidraw/math";
 import { type Bounds, isBounds } from "@excalidraw/common";
 import {
@@ -18,6 +17,7 @@ import {
 
 import type { ElementsMap, ExcalidrawElement } from "@excalidraw/element/types";
 import type { Curve } from "@excalidraw/math";
+import type { LineSegment } from "@excalidraw/utils";
 
 // The global data holder to collect the debug operations
 declare global {

packages/element/src/zindex.ts

@@ -1,7 +1,5 @@
 import { arrayToMap, findIndex, findLastIndex } from "@excalidraw/common";
 
-import { isFiniteNumber } from "@excalidraw/math";
-
 import type { AppState } from "@excalidraw/excalidraw/types";
 import type { GlobalPoint } from "@excalidraw/math";
 
@@ -10,7 +8,6 @@ import { getElementsInGroup } from "./groups";
 import { syncMovedIndices } from "./fractionalIndex";
 import { getSelectedElements } from "./selection";
 import { getBoundTextElement, getContainerElement } from "./textElement";
-import { getHoveredElementForBinding } from "./collision";
 
 import type { Scene } from "./Scene";
 import type {
@@ -158,12 +155,8 @@ export const moveArrowAboveBindable = (
   elements: readonly Ordered<NonDeletedExcalidrawElement>[],
   elementsMap: NonDeletedSceneElementsMap,
   scene: Scene,
-  hit?: NonDeletedExcalidrawElement,
+  hoveredElement: NonDeletedExcalidrawElement,
 ): readonly OrderedExcalidrawElement[] => {
-  const hoveredElement = hit
-    ? hit
-    : getHoveredElementForBinding(point, elements, elementsMap);
-
   if (!hoveredElement) {
     return elements;
   }
@@ -315,46 +308,12 @@ const getTargetElementsMap = <T extends ExcalidrawElement>(
   }, new Map<string, ExcalidrawElement>());
 };
 
-const hasSameElementIds = (
-  prevElements: readonly ExcalidrawElement[],
-  nextElements: readonly ExcalidrawElement[],
-) => {
-  if (prevElements.length !== nextElements.length) {
-    console.error(
-      "z-index reordering failed: resulting array have different lengths",
-    );
-    return false;
-  }
-
-  const prevElementIdCounts = new Map<ExcalidrawElement["id"], number>();
-  for (const element of prevElements) {
-    prevElementIdCounts.set(
-      element.id,
-      (prevElementIdCounts.get(element.id) || 0) + 1,
-    );
-  }
-
-  for (const element of nextElements) {
-    const count = prevElementIdCounts.get(element.id);
-    if (!count) {
-      console.error(
-        "z-index reordering failed: element id mismatch / duplicate ids",
-      );
-      return false;
-    }
-    prevElementIdCounts.set(element.id, count - 1);
-  }
-
-  return true;
-};
-
 const shiftElementsByOne = (
   elements: readonly ExcalidrawElement[],
   appState: AppState,
   direction: "left" | "right",
   scene: Scene,
 ) => {
-  const originalElements = elements;
   const indicesToMove = getIndicesToMove(elements, appState);
   const targetElementsMap = getTargetElementsMap(elements, indicesToMove);
 
@@ -425,10 +384,6 @@ const shiftElementsByOne = (
           ];
   });
 
-  if (!hasSameElementIds(originalElements, elements)) {
-    return originalElements;
-  }
-
   syncMovedIndices(elements, targetElementsMap);
 
   return elements;
@@ -442,20 +397,11 @@ const shiftElementsToEnd = (
   elementsToBeMoved?: readonly ExcalidrawElement[],
 ) => {
   const indicesToMove = getIndicesToMove(elements, appState, elementsToBeMoved);
-
-  // Nothing to move (e.g. `elementsToBeMoved` is empty because all selected
-  // elements were frame children handled in a prior pass). Bail out early —
-  // otherwise `leadingIndex`/`trailingIndex` below resolve to `undefined` and
-  // the resulting `slice()` calls overlap, duplicating elements.
-  if (indicesToMove.length === 0) {
-    return elements;
-  }
-
   const targetElementsMap = getTargetElementsMap(elements, indicesToMove);
   const displacedElements: ExcalidrawElement[] = [];
 
-  let leadingIndex: number | undefined;
+  let leadingIndex: number;
-  let trailingIndex: number | undefined;
+  let trailingIndex: number;
   if (direction === "left") {
     if (containingFrame) {
       leadingIndex = findIndex(elements, (el) =>
@@ -500,19 +446,6 @@ const shiftElementsToEnd = (
     leadingIndex = 0;
   }
 
-  const isValidIndex = (index: number | undefined): index is number => {
-    return isFiniteNumber(index) && index >= 0;
-  };
-
-  if (
-    !isValidIndex(leadingIndex) ||
-    !isValidIndex(trailingIndex) ||
-    leadingIndex > trailingIndex ||
-    indicesToMove.some((index) => index < leadingIndex || index > trailingIndex)
-  ) {
-    return elements;
-  }
-
   for (let index = leadingIndex; index < trailingIndex + 1; index++) {
     if (!indicesToMove.includes(index)) {
       displacedElements.push(elements[index]);
@@ -537,10 +470,6 @@ const shiftElementsToEnd = (
           ...trailingElements,
         ];
 
-  if (!hasSameElementIds(elements, nextElements)) {
-    return elements;
-  }
-
   syncMovedIndices(nextElements, targetElementsMap);
 
   return nextElements;
@@ -609,7 +538,7 @@ function shiftElementsAccountingForFrames(
 
   for (const [frameId, children] of frameChildrenSets) {
     nextElements = shiftFunction(
-      nextElements,
+      allElements,
       appState,
       direction,
       frameId,

packages/element/tests/align.test.tsx

@@ -72,123 +72,123 @@ describe("aligning", () => {
   it("aligns two objects correctly to the top", () => {
     createAndSelectTwoRectangles();
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(110);
+    expect(API.getSelectedElements()[1].x).toEqual(110);
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(110);
+    expect(API.getSelectedElements()[1].y).toEqual(110);
 
     Keyboard.withModifierKeys({ ctrl: true, shift: true }, () => {
       Keyboard.keyPress(KEYS.ARROW_UP);
     });
 
     // Check if x position did not change
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(110);
+    expect(API.getSelectedElements()[1].x).toEqual(110);
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toEqual(0);
   });
 
   it("aligns two objects correctly to the bottom", () => {
     createAndSelectTwoRectangles();
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(110);
+    expect(API.getSelectedElements()[1].x).toEqual(110);
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(110);
+    expect(API.getSelectedElements()[1].y).toEqual(110);
 
     Keyboard.withModifierKeys({ ctrl: true, shift: true }, () => {
       Keyboard.keyPress(KEYS.ARROW_DOWN);
     });
 
     // Check if x position did not change
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(110);
+    expect(API.getSelectedElements()[1].x).toEqual(110);
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(110);
+    expect(API.getSelectedElements()[0].y).toEqual(110);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(110);
+    expect(API.getSelectedElements()[1].y).toEqual(110);
   });
 
   it("aligns two objects correctly to the left", () => {
     createAndSelectTwoRectangles();
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(110);
+    expect(API.getSelectedElements()[1].x).toEqual(110);
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(110);
+    expect(API.getSelectedElements()[1].y).toEqual(110);
 
     Keyboard.withModifierKeys({ ctrl: true, shift: true }, () => {
       Keyboard.keyPress(KEYS.ARROW_LEFT);
     });
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toEqual(0);
 
     // Check if y position did not change
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(110);
+    expect(API.getSelectedElements()[1].y).toEqual(110);
   });
 
   it("aligns two objects correctly to the right", () => {
     createAndSelectTwoRectangles();
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(110);
+    expect(API.getSelectedElements()[1].x).toEqual(110);
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(110);
+    expect(API.getSelectedElements()[1].y).toEqual(110);
 
     Keyboard.withModifierKeys({ ctrl: true, shift: true }, () => {
       Keyboard.keyPress(KEYS.ARROW_RIGHT);
     });
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(110);
+    expect(API.getSelectedElements()[0].x).toEqual(110);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(110);
+    expect(API.getSelectedElements()[1].x).toEqual(110);
 
     // Check if y position did not change
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(110);
+    expect(API.getSelectedElements()[1].y).toEqual(110);
   });
 
   it("centers two objects with different sizes correctly vertically", () => {
     createAndSelectTwoRectanglesWithDifferentSizes();
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(110);
+    expect(API.getSelectedElements()[1].x).toEqual(110);
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(110);
+    expect(API.getSelectedElements()[1].y).toEqual(110);
 
     API.executeAction(actionAlignVerticallyCentered);
 
     // Check if x position did not change
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(110);
+    expect(API.getSelectedElements()[1].x).toEqual(110);
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(60);
+    expect(API.getSelectedElements()[0].y).toEqual(60);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(55);
+    expect(API.getSelectedElements()[1].y).toEqual(55);
   });
 
   it("centers two objects with different sizes correctly horizontally", () => {
     createAndSelectTwoRectanglesWithDifferentSizes();
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(110);
+    expect(API.getSelectedElements()[1].x).toEqual(110);
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(110);
+    expect(API.getSelectedElements()[1].y).toEqual(110);
 
     API.executeAction(actionAlignHorizontallyCentered);
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(60);
+    expect(API.getSelectedElements()[0].x).toEqual(60);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(55);
+    expect(API.getSelectedElements()[1].x).toEqual(55);
 
     // Check if y position did not change
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(110);
+    expect(API.getSelectedElements()[1].y).toEqual(110);
   });
 
   const createAndSelectGroupAndRectangle = () => {
@@ -226,85 +226,85 @@ describe("aligning", () => {
   it("aligns a group with another element correctly to the top", () => {
     createAndSelectGroupAndRectangle();
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].y).toEqual(200);
 
     API.executeAction(actionAlignTop);
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[2].y).toEqual(0);
   });
 
   it("aligns a group with another element correctly to the bottom", () => {
     createAndSelectGroupAndRectangle();
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].y).toEqual(200);
 
     API.executeAction(actionAlignBottom);
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[0].y).toEqual(100);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[1].y).toEqual(200);
-    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].y).toEqual(200);
   });
 
   it("aligns a group with another element correctly to the left", () => {
     createAndSelectGroupAndRectangle();
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].x).toEqual(200);
 
     API.executeAction(actionAlignLeft);
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[2].x).toEqual(0);
   });
 
   it("aligns a group with another element correctly to the right", () => {
     createAndSelectGroupAndRectangle();
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].x).toEqual(200);
 
     API.executeAction(actionAlignRight);
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[0].x).toEqual(100);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[1].x).toEqual(200);
-    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].x).toEqual(200);
   });
 
   it("centers a group with another element correctly vertically", () => {
     createAndSelectGroupAndRectangle();
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].y).toEqual(200);
 
     API.executeAction(actionAlignVerticallyCentered);
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(50);
+    expect(API.getSelectedElements()[0].y).toEqual(50);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(150);
+    expect(API.getSelectedElements()[1].y).toEqual(150);
-    expect(API.getSelectedElements()[2].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].y).toEqual(100);
   });
 
   it("centers a group with another element correctly horizontally", () => {
     createAndSelectGroupAndRectangle();
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].x).toEqual(200);
 
     API.executeAction(actionAlignHorizontallyCentered);
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(50);
+    expect(API.getSelectedElements()[0].x).toEqual(50);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(150);
+    expect(API.getSelectedElements()[1].x).toEqual(150);
-    expect(API.getSelectedElements()[2].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].x).toEqual(100);
   });
 
   const createAndSelectTwoGroups = () => {
@@ -354,97 +354,97 @@ describe("aligning", () => {
   it("aligns two groups correctly to the top", () => {
     createAndSelectTwoGroups();
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].y).toEqual(200);
-    expect(API.getSelectedElements()[3].y).toBeCloseTo(300);
+    expect(API.getSelectedElements()[3].y).toEqual(300);
 
     API.executeAction(actionAlignTop);
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[2].y).toEqual(0);
-    expect(API.getSelectedElements()[3].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[3].y).toEqual(100);
   });
 
   it("aligns two groups correctly to the bottom", () => {
     createAndSelectTwoGroups();
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].y).toEqual(200);
-    expect(API.getSelectedElements()[3].y).toBeCloseTo(300);
+    expect(API.getSelectedElements()[3].y).toEqual(300);
 
     API.executeAction(actionAlignBottom);
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[0].y).toEqual(200);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(300);
+    expect(API.getSelectedElements()[1].y).toEqual(300);
-    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].y).toEqual(200);
-    expect(API.getSelectedElements()[3].y).toBeCloseTo(300);
+    expect(API.getSelectedElements()[3].y).toEqual(300);
   });
 
   it("aligns two groups correctly to the left", () => {
     createAndSelectTwoGroups();
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].x).toEqual(200);
-    expect(API.getSelectedElements()[3].x).toBeCloseTo(300);
+    expect(API.getSelectedElements()[3].x).toEqual(300);
 
     API.executeAction(actionAlignLeft);
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[2].x).toEqual(0);
-    expect(API.getSelectedElements()[3].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[3].x).toEqual(100);
   });
 
   it("aligns two groups correctly to the right", () => {
     createAndSelectTwoGroups();
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].x).toEqual(200);
-    expect(API.getSelectedElements()[3].x).toBeCloseTo(300);
+    expect(API.getSelectedElements()[3].x).toEqual(300);
 
     API.executeAction(actionAlignRight);
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[0].x).toEqual(200);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(300);
+    expect(API.getSelectedElements()[1].x).toEqual(300);
-    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].x).toEqual(200);
-    expect(API.getSelectedElements()[3].x).toBeCloseTo(300);
+    expect(API.getSelectedElements()[3].x).toEqual(300);
   });
 
   it("centers two groups correctly vertically", () => {
     createAndSelectTwoGroups();
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].y).toEqual(200);
-    expect(API.getSelectedElements()[3].y).toBeCloseTo(300);
+    expect(API.getSelectedElements()[3].y).toEqual(300);
 
     API.executeAction(actionAlignVerticallyCentered);
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[0].y).toEqual(100);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[1].y).toEqual(200);
-    expect(API.getSelectedElements()[2].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].y).toEqual(100);
-    expect(API.getSelectedElements()[3].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[3].y).toEqual(200);
   });
 
   it("centers two groups correctly horizontally", () => {
     createAndSelectTwoGroups();
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].x).toEqual(200);
-    expect(API.getSelectedElements()[3].x).toBeCloseTo(300);
+    expect(API.getSelectedElements()[3].x).toEqual(300);
 
     API.executeAction(actionAlignHorizontallyCentered);
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[0].x).toEqual(100);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[1].x).toEqual(200);
-    expect(API.getSelectedElements()[2].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].x).toEqual(100);
-    expect(API.getSelectedElements()[3].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[3].x).toEqual(200);
   });
 
   const createAndSelectNestedGroupAndRectangle = () => {
@@ -497,97 +497,97 @@ describe("aligning", () => {
   it("aligns nested group and other element correctly to the top", () => {
     createAndSelectNestedGroupAndRectangle();
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].y).toEqual(200);
-    expect(API.getSelectedElements()[3].y).toBeCloseTo(300);
+    expect(API.getSelectedElements()[3].y).toEqual(300);
 
     API.executeAction(actionAlignTop);
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].y).toEqual(200);
-    expect(API.getSelectedElements()[3].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[3].y).toEqual(0);
   });
 
   it("aligns nested group and other element correctly to the bottom", () => {
     createAndSelectNestedGroupAndRectangle();
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].y).toEqual(200);
-    expect(API.getSelectedElements()[3].y).toBeCloseTo(300);
+    expect(API.getSelectedElements()[3].y).toEqual(300);
 
     API.executeAction(actionAlignBottom);
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[0].y).toEqual(100);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[1].y).toEqual(200);
-    expect(API.getSelectedElements()[2].y).toBeCloseTo(300);
+    expect(API.getSelectedElements()[2].y).toEqual(300);
-    expect(API.getSelectedElements()[3].y).toBeCloseTo(300);
+    expect(API.getSelectedElements()[3].y).toEqual(300);
   });
 
   it("aligns nested group and other element correctly to the left", () => {
     createAndSelectNestedGroupAndRectangle();
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].x).toEqual(200);
-    expect(API.getSelectedElements()[3].x).toBeCloseTo(300);
+    expect(API.getSelectedElements()[3].x).toEqual(300);
 
     API.executeAction(actionAlignLeft);
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].x).toEqual(200);
-    expect(API.getSelectedElements()[3].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[3].x).toEqual(0);
   });
 
   it("aligns nested group and other element correctly to the right", () => {
     createAndSelectNestedGroupAndRectangle();
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].x).toEqual(200);
-    expect(API.getSelectedElements()[3].x).toBeCloseTo(300);
+    expect(API.getSelectedElements()[3].x).toEqual(300);
 
     API.executeAction(actionAlignRight);
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[0].x).toEqual(100);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[1].x).toEqual(200);
-    expect(API.getSelectedElements()[2].x).toBeCloseTo(300);
+    expect(API.getSelectedElements()[2].x).toEqual(300);
-    expect(API.getSelectedElements()[3].x).toBeCloseTo(300);
+    expect(API.getSelectedElements()[3].x).toEqual(300);
   });
 
   it("centers nested group and other element correctly vertically", () => {
     createAndSelectNestedGroupAndRectangle();
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].y).toEqual(200);
-    expect(API.getSelectedElements()[3].y).toBeCloseTo(300);
+    expect(API.getSelectedElements()[3].y).toEqual(300);
 
     API.executeAction(actionAlignVerticallyCentered);
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(50);
+    expect(API.getSelectedElements()[0].y).toEqual(50);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(150);
+    expect(API.getSelectedElements()[1].y).toEqual(150);
-    expect(API.getSelectedElements()[2].y).toBeCloseTo(250);
+    expect(API.getSelectedElements()[2].y).toEqual(250);
-    expect(API.getSelectedElements()[3].y).toBeCloseTo(150);
+    expect(API.getSelectedElements()[3].y).toEqual(150);
   });
 
   it("centers nested group and other element correctly horizontally", () => {
     createAndSelectNestedGroupAndRectangle();
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].x).toEqual(200);
-    expect(API.getSelectedElements()[3].x).toBeCloseTo(300);
+    expect(API.getSelectedElements()[3].x).toEqual(300);
 
     API.executeAction(actionAlignHorizontallyCentered);
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(50);
+    expect(API.getSelectedElements()[0].x).toEqual(50);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(150);
+    expect(API.getSelectedElements()[1].x).toEqual(150);
-    expect(API.getSelectedElements()[2].x).toBeCloseTo(250);
+    expect(API.getSelectedElements()[2].x).toEqual(250);
-    expect(API.getSelectedElements()[3].x).toBeCloseTo(150);
+    expect(API.getSelectedElements()[3].x).toEqual(150);
   });
 
   const createGroupAndSelectInEditGroupMode = () => {
@@ -622,68 +622,68 @@ describe("aligning", () => {
   it("aligns elements within a group while in group edit mode correctly to the top", () => {
     createGroupAndSelectInEditGroupMode();
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toEqual(100);
 
     API.executeAction(actionAlignTop);
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toEqual(0);
   });
   it("aligns elements within a group while in group edit mode correctly to the bottom", () => {
     createGroupAndSelectInEditGroupMode();
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toEqual(100);
 
     API.executeAction(actionAlignBottom);
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[0].y).toEqual(100);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toEqual(100);
   });
   it("aligns elements within a group while in group edit mode correctly to the left", () => {
     createGroupAndSelectInEditGroupMode();
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toEqual(100);
 
     API.executeAction(actionAlignLeft);
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toEqual(0);
   });
   it("aligns elements within a group while in group edit mode correctly to the right", () => {
     createGroupAndSelectInEditGroupMode();
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toEqual(100);
 
     API.executeAction(actionAlignRight);
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[0].x).toEqual(100);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toEqual(100);
   });
   it("aligns elements within a group while in group edit mode correctly to the vertical center", () => {
     createGroupAndSelectInEditGroupMode();
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toEqual(100);
 
     API.executeAction(actionAlignVerticallyCentered);
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(50);
+    expect(API.getSelectedElements()[0].y).toEqual(50);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(50);
+    expect(API.getSelectedElements()[1].y).toEqual(50);
   });
   it("aligns elements within a group while in group edit mode correctly to the horizontal center", () => {
     createGroupAndSelectInEditGroupMode();
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toEqual(100);
 
     API.executeAction(actionAlignHorizontallyCentered);
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(50);
+    expect(API.getSelectedElements()[0].x).toEqual(50);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(50);
+    expect(API.getSelectedElements()[1].x).toEqual(50);
   });
 
   const createNestedGroupAndSelectInEditGroupMode = () => {
@@ -735,80 +735,80 @@ describe("aligning", () => {
   it("aligns element and nested group while in group edit mode correctly to the top", () => {
     createNestedGroupAndSelectInEditGroupMode();
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].y).toEqual(200);
 
     API.executeAction(actionAlignTop);
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[2].y).toEqual(0);
   });
   it("aligns element and nested group while in group edit mode correctly to the bottom", () => {
     createNestedGroupAndSelectInEditGroupMode();
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].y).toEqual(200);
 
     API.executeAction(actionAlignBottom);
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[0].y).toEqual(100);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[1].y).toEqual(200);
-    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].y).toEqual(200);
   });
   it("aligns element and nested group while in group edit mode correctly to the left", () => {
     createNestedGroupAndSelectInEditGroupMode();
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].x).toEqual(200);
 
     API.executeAction(actionAlignLeft);
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[2].x).toEqual(0);
   });
   it("aligns element and nested group while in group edit mode correctly to the right", () => {
     createNestedGroupAndSelectInEditGroupMode();
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].x).toEqual(200);
 
     API.executeAction(actionAlignRight);
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[0].x).toEqual(100);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[1].x).toEqual(200);
-    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].x).toEqual(200);
   });
   it("aligns element and nested group while in group edit mode correctly to the vertical center", () => {
     createNestedGroupAndSelectInEditGroupMode();
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].y).toEqual(200);
 
     API.executeAction(actionAlignVerticallyCentered);
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(50);
+    expect(API.getSelectedElements()[0].y).toEqual(50);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(150);
+    expect(API.getSelectedElements()[1].y).toEqual(150);
-    expect(API.getSelectedElements()[2].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].y).toEqual(100);
   });
   it("aligns elements and nested group within a group while in group edit mode correctly to the horizontal center", () => {
     createNestedGroupAndSelectInEditGroupMode();
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].x).toEqual(200);
 
     API.executeAction(actionAlignHorizontallyCentered);
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(50);
+    expect(API.getSelectedElements()[0].x).toEqual(50);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(150);
+    expect(API.getSelectedElements()[1].x).toEqual(150);
-    expect(API.getSelectedElements()[2].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].x).toEqual(100);
   });
 
   const createAndSelectSingleGroup = () => {
@@ -834,68 +834,68 @@ describe("aligning", () => {
   it("aligns elements within a single-selected group correctly to the top", () => {
     createAndSelectSingleGroup();
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toEqual(100);
 
     API.executeAction(actionAlignTop);
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].y).toEqual(0);
   });
   it("aligns elements within a single-selected group correctly to the bottom", () => {
     createAndSelectSingleGroup();
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toEqual(100);
 
     API.executeAction(actionAlignBottom);
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[0].y).toEqual(100);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toEqual(100);
   });
   it("aligns elements within a single-selected group correctly to the left", () => {
     createAndSelectSingleGroup();
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toEqual(100);
 
     API.executeAction(actionAlignLeft);
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[1].x).toEqual(0);
   });
   it("aligns elements within a single-selected group correctly to the right", () => {
     createAndSelectSingleGroup();
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toEqual(100);
 
     API.executeAction(actionAlignRight);
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[0].x).toEqual(100);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toEqual(100);
   });
   it("aligns elements within a single-selected group correctly to the vertical center", () => {
     createAndSelectSingleGroup();
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toEqual(100);
 
     API.executeAction(actionAlignVerticallyCentered);
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(50);
+    expect(API.getSelectedElements()[0].y).toEqual(50);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(50);
+    expect(API.getSelectedElements()[1].y).toEqual(50);
   });
   it("aligns elements within a single-selected group correctly to the horizontal center", () => {
     createAndSelectSingleGroup();
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toEqual(100);
 
     API.executeAction(actionAlignHorizontallyCentered);
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(50);
+    expect(API.getSelectedElements()[0].x).toEqual(50);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(50);
+    expect(API.getSelectedElements()[1].x).toEqual(50);
   });
 
   const createAndSelectSingleGroupWithNestedGroup = () => {
@@ -934,79 +934,79 @@ describe("aligning", () => {
   it("aligns elements within a single-selected group containing a nested group correctly to the top", () => {
     createAndSelectSingleGroupWithNestedGroup();
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].y).toEqual(200);
 
     API.executeAction(actionAlignTop);
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[2].y).toEqual(0);
   });
   it("aligns elements within a single-selected group containing a nested group correctly to the bottom", () => {
     createAndSelectSingleGroupWithNestedGroup();
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].y).toEqual(200);
 
     API.executeAction(actionAlignBottom);
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[0].y).toEqual(100);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[1].y).toEqual(200);
-    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].y).toEqual(200);
   });
   it("aligns elements within a single-selected group containing a nested group correctly to the left", () => {
     createAndSelectSingleGroupWithNestedGroup();
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].x).toEqual(200);
 
     API.executeAction(actionAlignLeft);
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[2].x).toEqual(0);
   });
   it("aligns elements within a single-selected group containing a nested group correctly to the right", () => {
     createAndSelectSingleGroupWithNestedGroup();
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].x).toEqual(200);
 
     API.executeAction(actionAlignRight);
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[0].x).toEqual(100);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[1].x).toEqual(200);
-    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].x).toEqual(200);
   });
   it("aligns elements within a single-selected group containing a nested group correctly to the vertical center", () => {
     createAndSelectSingleGroupWithNestedGroup();
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].y).toEqual(100);
-    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].y).toEqual(200);
 
     API.executeAction(actionAlignVerticallyCentered);
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(50);
+    expect(API.getSelectedElements()[0].y).toEqual(50);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(150);
+    expect(API.getSelectedElements()[1].y).toEqual(150);
-    expect(API.getSelectedElements()[2].y).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].y).toEqual(100);
   });
   it("aligns elements within a single-selected group containing a nested group correctly to the horizontal center", () => {
     createAndSelectSingleGroupWithNestedGroup();
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[1].x).toEqual(100);
-    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].x).toEqual(200);
 
     API.executeAction(actionAlignHorizontallyCentered);
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(50);
+    expect(API.getSelectedElements()[0].x).toEqual(50);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(150);
+    expect(API.getSelectedElements()[1].x).toEqual(150);
-    expect(API.getSelectedElements()[2].x).toBeCloseTo(100);
+    expect(API.getSelectedElements()[2].x).toEqual(100);
   });
 });

packages/element/tests/binding.test.tsx

@@ -178,64 +178,6 @@ describe("binding for simple arrows", () => {
     });
   });
 
-  describe("self-binding (both ends to the same element) single-click finalize", () => {
-    // rect spans x:200..400, y:200..400; orbit ring is ~15px outside the outline
-    const INSIDE: [number, number] = [250, 250];
-    const ORBIT_LEFT: [number, number] = [187, 300];
-    const ORBIT_RIGHT: [number, number] = [413, 300];
-    const MIDDLE: [number, number] = [550, 100];
-
-    beforeEach(async () => {
-      mouse.reset();
-      await act(() => setLanguage(defaultLang));
-      await render(<Excalidraw handleKeyboardGlobally={true} />);
-      UI.createElement("rectangle", {
-        x: 200,
-        y: 200,
-        width: 200,
-        height: 200,
-      });
-    });
-
-    const drawSelfArrow = (start: [number, number], end: [number, number]) => {
-      UI.clickTool("arrow");
-      mouse.reset();
-      mouse.clickAt(...start);
-      mouse.moveTo(...MIDDLE);
-      mouse.clickAt(...MIDDLE); // commit a middle point so it's a multi-point arrow
-      mouse.moveTo(...end);
-      mouse.clickAt(...end); // single click at the end
-    };
-
-    it("orbit -> orbit finalizes on a single click", () => {
-      drawSelfArrow(ORBIT_LEFT, ORBIT_RIGHT);
-
-      const arrow = h.elements[h.elements.length - 1] as ExcalidrawArrowElement;
-      expect(h.state.multiElement).toBe(null);
-      expect(h.state.activeTool.type).toBe("selection");
-      expect(arrow.startBinding?.elementId).toBe(arrow.endBinding?.elementId);
-      expect(arrow.endBinding?.elementId).not.toBe(undefined);
-    });
-
-    it("inside -> orbit finalizes on a single click", () => {
-      drawSelfArrow(INSIDE, ORBIT_RIGHT);
-
-      const arrow = h.elements[h.elements.length - 1] as ExcalidrawArrowElement;
-      expect(h.state.multiElement).toBe(null);
-      expect(h.state.activeTool.type).toBe("selection");
-      expect(arrow.startBinding?.elementId).toBe(arrow.endBinding?.elementId);
-      expect(arrow.endBinding?.elementId).not.toBe(undefined);
-    });
-
-    it("inside -> inside keep in multi-point mode (no single-click finalize)", () => {
-      drawSelfArrow(INSIDE, [INSIDE[0] + 50, INSIDE[1] + 50]); // end dropped inside the rect
-
-      // ambiguous → must be confirmed with a second click, so still in progress
-      expect(h.state.multiElement).not.toBe(null);
-      expect(h.state.activeTool.type).toBe("arrow");
-    });
-  });
-
   describe("when arrow is outside of shape", () => {
     beforeEach(async () => {
       mouse.reset();
@@ -461,7 +403,6 @@ describe("binding for simple arrows", () => {
       mouse.moveTo(340, 251);
       mouse.moveTo(410, 251);
       mouse.clickAt(410, 251);
-      mouse.clickAt(410, 251);
       const arrow = h.elements[h.elements.length - 1] as any;
 
       expect(arrow.startBinding?.elementId).toBe(rectLeft.id);
@@ -506,7 +447,6 @@ describe("binding for simple arrows", () => {
       mouse.moveTo(350, 251);
       mouse.moveTo(410, 251);
       mouse.clickAt(410, 251);
-      mouse.clickAt(410, 251);
 
       const arrow = API.getSelectedElement() as ExcalidrawArrowElement;
 

packages/element/tests/bounds.test.ts

@@ -1,14 +1,10 @@
 import { pointFrom } from "@excalidraw/math";
-import { arrayToMap, type Bounds, ROUNDNESS } from "@excalidraw/common";
+
-import { API } from "@excalidraw/excalidraw/tests/helpers/api";
+import { arrayToMap, ROUNDNESS } from "@excalidraw/common";
 
 import type { LocalPoint } from "@excalidraw/math";
 
-import {
+import { getElementAbsoluteCoords, getElementBounds } from "../src/bounds";
-  elementsOverlappingBBox,
-  getElementAbsoluteCoords,
-  getElementBounds,
-} from "../src/bounds";
 
 import type { ExcalidrawElement, ExcalidrawLinearElement } from "../src/types";
 
@@ -145,65 +141,3 @@ describe("getElementBounds", () => {
     expect(y2).toEqual(319.8162855827246);
   });
 });
-
-const makeElement = (x: number, y: number, width: number, height: number) =>
-  API.createElement({
-    type: "rectangle",
-    x,
-    y,
-    width,
-    height,
-  });
-
-const makeBBox = (
-  minX: number,
-  minY: number,
-  maxX: number,
-  maxY: number,
-): Bounds => [minX, minY, maxX, maxY];
-
-describe("elementsOverlappingBBox()", () => {
-  it("should return elements that overlap bbox", () => {
-    const bbox = makeBBox(0, 0, 100, 100);
-
-    const rectOutside = makeElement(110, 110, 100, 100);
-    const rectInside = makeElement(10, 10, 85, 85);
-    const rectContainingBBox = makeElement(-10, -10, 110, 110);
-    const rectOverlappingTopLeft = makeElement(-10, -10, 50, 50);
-
-    expect(
-      elementsOverlappingBBox({
-        bounds: bbox,
-        type: "overlap",
-        elements: [
-          rectOutside,
-          rectInside,
-          rectContainingBBox,
-          rectOverlappingTopLeft,
-        ],
-      }),
-    ).toEqual([rectInside, rectOverlappingTopLeft]);
-  });
-
-  it("should return elements inside/containing bbox", () => {
-    const bbox = makeBBox(0, 0, 100, 100);
-
-    const rectOutside = makeElement(110, 110, 100, 100);
-    const rectInside = makeElement(10, 10, 85, 85);
-    const rectContainingBBox = makeElement(-10, -10, 110, 110);
-    const rectOverlappingTopLeft = makeElement(-10, -10, 50, 50);
-
-    expect(
-      elementsOverlappingBBox({
-        bounds: bbox,
-        type: "contain",
-        elements: [
-          rectOutside,
-          rectInside,
-          rectContainingBBox,
-          rectOverlappingTopLeft,
-        ],
-      }),
-    ).toEqual([rectInside]);
-  });
-});

packages/element/tests/distribute.test.tsx

@@ -76,53 +76,53 @@ describe("distributing", () => {
 
   it("should distribute selected elements horizontally", async () => {
     createAndSelectThreeRectanglesWithGap();
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(10);
+    expect(API.getSelectedElements()[1].x).toEqual(10);
-    expect(API.getSelectedElements()[2].x).toBeCloseTo(300);
+    expect(API.getSelectedElements()[2].x).toEqual(300);
 
     API.executeAction(distributeHorizontally);
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(150);
+    expect(API.getSelectedElements()[1].x).toEqual(150);
-    expect(API.getSelectedElements()[2].x).toBeCloseTo(300);
+    expect(API.getSelectedElements()[2].x).toEqual(300);
   });
 
   it("should distribute selected elements vertically", async () => {
     createAndSelectThreeRectanglesWithGap();
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(10);
+    expect(API.getSelectedElements()[1].y).toEqual(10);
-    expect(API.getSelectedElements()[2].y).toBeCloseTo(300);
+    expect(API.getSelectedElements()[2].y).toEqual(300);
 
     API.executeAction(distributeVertically);
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(150);
+    expect(API.getSelectedElements()[1].y).toEqual(150);
-    expect(API.getSelectedElements()[2].y).toBeCloseTo(300);
+    expect(API.getSelectedElements()[2].y).toEqual(300);
   });
 
   it("should distribute selected elements horizontally based on their centers", async () => {
     createAndSelectThreeRectanglesWithoutGap();
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(10);
+    expect(API.getSelectedElements()[1].x).toEqual(10);
-    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].x).toEqual(200);
 
     API.executeAction(distributeHorizontally);
 
-    expect(API.getSelectedElements()[0].x).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].x).toEqual(0);
-    expect(API.getSelectedElements()[1].x).toBeCloseTo(50);
+    expect(API.getSelectedElements()[1].x).toEqual(50);
-    expect(API.getSelectedElements()[2].x).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].x).toEqual(200);
   });
 
   it("should distribute selected elements vertically with based on their centers", async () => {
     createAndSelectThreeRectanglesWithoutGap();
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(10);
+    expect(API.getSelectedElements()[1].y).toEqual(10);
-    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].y).toEqual(200);
 
     API.executeAction(distributeVertically);
 
-    expect(API.getSelectedElements()[0].y).toBeCloseTo(0);
+    expect(API.getSelectedElements()[0].y).toEqual(0);
-    expect(API.getSelectedElements()[1].y).toBeCloseTo(50);
+    expect(API.getSelectedElements()[1].y).toEqual(50);
-    expect(API.getSelectedElements()[2].y).toBeCloseTo(200);
+    expect(API.getSelectedElements()[2].y).toEqual(200);
   });
 });

packages/element/tests/elbowArrow.test.tsx

@@ -16,6 +16,7 @@ import "@excalidraw/utils/test-utils";
 import { bindBindingElement } from "@excalidraw/element";
 
 import type { LocalPoint } from "@excalidraw/math";
+import type { Zoom } from "@excalidraw/excalidraw/types";
 
 import { Scene } from "../src/Scene";
 
@@ -187,8 +188,12 @@ describe("elbow arrow routing", () => {
     }) as ExcalidrawElbowArrowElement;
     API.setElements([rectangle1, rectangle2, arrow]);
 
-    bindBindingElement(arrow, rectangle1, "orbit", "start", h.scene);
+    bindBindingElement(arrow, rectangle1, "orbit", "start", h.scene, {
-    bindBindingElement(arrow, rectangle2, "orbit", "end", h.scene);
+      value: 1,
+    } as Zoom);
+    bindBindingElement(arrow, rectangle2, "orbit", "end", h.scene, {
+      value: 1,
+    } as Zoom);
 
     expect(arrow.startBinding).not.toBe(null);
     expect(arrow.endBinding).not.toBe(null);

packages/element/tests/frame.test.tsx

@@ -692,34 +692,6 @@ describe("adding elements to frames", () => {
       expect(rect2.frameId).toBe(frame.id);
     });
 
-    it("should move an element dragged from one frame into another", () => {
-      const otherFrame = API.createElement({
-        id: "otherFrame",
-        type: "frame",
-        x: 300,
-        y: 0,
-        width: 150,
-        height: 150,
-      });
-      const frameChild = API.createElement({
-        id: "frameChild",
-        type: "rectangle",
-        x: 50,
-        y: 50,
-        width: 20,
-        height: 20,
-        frameId: frame.id,
-      });
-
-      API.setElements([frame, frameChild, otherFrame]);
-
-      expect(frameChild.frameId).toBe(frame.id);
-
-      dragElementIntoFrame(otherFrame, frameChild);
-
-      expect(frameChild.frameId).toBe(otherFrame.id);
-    });
-
     it("should layer a dragged element above the highest frame child", () => {
       const frameChild = API.createElement({
         id: "frameChild",

packages/element/tests/linearElementEditor.test.tsx

@@ -1318,8 +1318,8 @@ describe("Test Linear Elements", () => {
 
       expect(arrow.endBinding?.elementId).toBe(rect.id);
       expect(arrow.width).toBeCloseTo(404);
-      expect(rect.x).toBeCloseTo(400);
+      expect(rect.x).toBe(400);
-      expect(rect.y).toBeCloseTo(0);
+      expect(rect.y).toBe(0);
       expect(
         wrapText(
           textElement.originalText,
@@ -1340,8 +1340,9 @@ describe("Test Linear Elements", () => {
       expect(rect.x).toBe(200);
       expect(rect.y).toBe(0);
       expect(handleBindTextResizeSpy).toHaveBeenCalledWith(
-        h.elements[1],
+        h.elements[0],
         h.app.scene,
+        "nw",
         false,
       );
       expect(

packages/element/tests/zindex.test.tsx

@@ -1509,190 +1509,4 @@ describe("z-indexing with frames", () => {
       ],
     });
   });
-
-  it("bringing to front / sending to back children of MULTIPLE frames at once moves all of them", () => {
-    assertZindex({
-      elements: [
-        { id: "F1_1", frameId: "F1", isSelected: true },
-        { id: "F1_2", frameId: "F1" },
-        { id: "F1", type: "frame" },
-        { id: "F2_1", frameId: "F2", isSelected: true },
-        { id: "F2_2", frameId: "F2" },
-        { id: "F2", type: "frame" },
-      ],
-      operations: [
-        // +∞: each selected child moves to the front of its own frame
-        [actionBringToFront, ["F1_2", "F1", "F1_1", "F2_2", "F2", "F2_1"]],
-        // -∞: each selected child moves to the back of its own frame
-        [actionSendToBack, ["F1_1", "F1_2", "F1", "F2_1", "F2_2", "F2"]],
-      ],
-    });
-  });
-
-  it("send to back / bring to front of a grouped frame child (in group-editing mode) must not duplicate elements", () => {
-    assertZindex({
-      elements: [
-        { id: "F1_1", frameId: "F1", groupIds: ["g1"] },
-        { id: "F1_2", frameId: "F1", groupIds: ["g1"], isSelected: true },
-        { id: "F1", type: "frame" },
-        { id: "F2_1", frameId: "F2", groupIds: ["g2"] },
-        { id: "F2_2", frameId: "F2", groupIds: ["g2"] },
-        { id: "F2", type: "frame" },
-      ],
-      appState: { editingGroupId: "g1" },
-      operations: [
-        // -∞ (send to back, within the frame)
-        [actionSendToBack, ["F1_2", "F1_1", "F1", "F2_1", "F2_2", "F2"]],
-        // +∞ (bring to front, within the frame)
-        [actionBringToFront, ["F1_1", "F1", "F1_2", "F2_1", "F2_2", "F2"]],
-      ],
-    });
-  });
-});
-
-/**
- * The inputs in this block intentionally VIOLATE the (soft) invariant that a
- * frame's children — and a group's members — are contiguous in the elements
- * array. Such states shouldn't occur in normal use, but they CAN arise from
- * bugs or broken input, because nothing re-defragments element order during
- * a reorder (`normalizeElementOrder` only runs on duplication). We keep these
- * tests so the reordering ops stay exercised against malformed order.
- *
- * HARD CONTRACT (a failure here is a real bug): a reorder must never throw,
- * duplicate, or drop elements. `assertReorderPreservesElements` checks this.
- *
- * SOFT SNAPSHOT (read before "fixing"): the exact resulting ORDER is NOT a
- * contract for invalid input — it's whatever the slice math happens to
- * produce. If a future change alters an `expected` order below, that is NOT
- * necessarily a functional regression. First confirm from the diff that the
- * hard contract still holds (nothing duplicated/lost), then update the
- * expected order to match, provided it's deemed an improvement over the
- * previous order, or it's an acceptable change given the underlying logic
- * change.
- */
-describe("z-index reordering with broken contiguity (invariant-violating input)", () => {
-  beforeEach(async () => {
-    await render(<Excalidraw />);
-  });
-
-  const assertReorderPreservesElements = (
-    elements: Parameters<typeof populateElements>[0],
-    appState: Parameters<typeof populateElements>[1],
-    // each op is applied to a freshly-populated (broken) state
-    cases: [Actions, string[]][],
-  ) => {
-    for (const [action, expected] of cases) {
-      populateElements(elements, appState);
-      const before = h.elements.map((el) => el.id);
-
-      expect(() => API.executeAction(action)).not.toThrow();
-
-      const after = h.elements.map((el) => el.id);
-      // hard contract:
-      expect(after.length).toBe(before.length); // no loss
-      expect(new Set(after).size).toBe(after.length); // no duplication
-      // soft snapshot (see block comment before changing):
-      expect(after).toEqual(expected);
-    }
-  };
-
-  it("discontiguous frame children (foreign frame's child interleaved in span)", () => {
-    // F2_1 (a child of frame F2) sits INSIDE frame F1's z-span. Reordering F1's
-    // child sweeps F2_1 along (span-based frame handling) — wrong ordering, but
-    // never a duplication/loss, and the op does not throw.
-    const elements: Parameters<typeof populateElements>[0] = [
-      { id: "F1_1", frameId: "F1", isSelected: true },
-      { id: "F2_1", frameId: "F2" },
-      { id: "F1_2", frameId: "F1" },
-      { id: "F1", type: "frame" },
-      { id: "F2", type: "frame" },
-    ];
-    assertReorderPreservesElements(elements, undefined, [
-      [actionBringForward, ["F2_1", "F1_2", "F1_1", "F1", "F2"]],
-      [actionSendBackward, ["F1_1", "F2_1", "F1_2", "F1", "F2"]],
-      [actionBringToFront, ["F2_1", "F1_2", "F1", "F1_1", "F2"]],
-      [actionSendToBack, ["F1_1", "F2_1", "F1_2", "F1", "F2"]],
-    ]);
-  });
-
-  it("discontiguous group, whole group selected", () => {
-    // g1 = {A, C}, scattered by the loose elements B and D.
-    const elements: Parameters<typeof populateElements>[0] = [
-      { id: "A", groupIds: ["g1"], isSelected: true },
-      { id: "B" },
-      { id: "C", groupIds: ["g1"], isSelected: true },
-      { id: "D" },
-    ];
-    assertReorderPreservesElements(elements, undefined, [
-      // move-by-one leaves the group scattered (each run moves independently)
-      [actionBringForward, ["B", "A", "D", "C"]],
-      [actionSendBackward, ["A", "C", "B", "D"]],
-      // to-front / to-back gather the scattered members back into one block
-      [actionBringToFront, ["B", "D", "A", "C"]],
-      [actionSendToBack, ["A", "C", "B", "D"]],
-    ]);
-  });
-
-  it("discontiguous group, single member selected in group-editing mode", () => {
-    const elements: Parameters<typeof populateElements>[0] = [
-      { id: "A", groupIds: ["g1"] },
-      { id: "B" },
-      { id: "C", groupIds: ["g1"], isSelected: true },
-      { id: "D" },
-    ];
-    assertReorderPreservesElements(elements, { editingGroupId: "g1" }, [
-      [actionBringForward, ["A", "B", "C", "D"]],
-      [actionSendBackward, ["C", "A", "B", "D"]],
-      [actionBringToFront, ["A", "B", "C", "D"]],
-      [actionSendToBack, ["C", "A", "B", "D"]],
-    ]);
-  });
-
-  it("two interleaved groups, both fully selected", () => {
-    const elements: Parameters<typeof populateElements>[0] = [
-      { id: "A", groupIds: ["g1"], isSelected: true },
-      { id: "X", groupIds: ["g2"], isSelected: true },
-      { id: "C", groupIds: ["g1"], isSelected: true },
-      { id: "Y", groupIds: ["g2"], isSelected: true },
-      { id: "Z" },
-    ];
-    assertReorderPreservesElements(elements, undefined, [
-      [actionBringForward, ["Z", "A", "X", "C", "Y"]],
-      [actionSendBackward, ["A", "X", "C", "Y", "Z"]],
-      [actionBringToFront, ["Z", "A", "X", "C", "Y"]],
-      [actionSendToBack, ["A", "X", "C", "Y", "Z"]],
-    ]);
-  });
-});
-
-describe("z-index reordering with inconsistent group-editing state", () => {
-  beforeEach(async () => {
-    await render(<Excalidraw />);
-  });
-
-  it("does not duplicate or drop elements when selected elements fall outside the edited group scope", () => {
-    assertZindex({
-      elements: [
-        { id: "A", groupIds: ["g1"], isSelected: true },
-        { id: "C", groupIds: ["g1"] },
-        { id: "X", groupIds: ["g2"] },
-        { id: "Y", groupIds: ["g2"] },
-        { id: "R" },
-      ],
-      appState: { editingGroupId: "g2" },
-      operations: [[actionSendToBack, ["A", "C", "X", "Y", "R"]]],
-    });
-
-    assertZindex({
-      elements: [
-        { id: "A", groupIds: ["g1"] },
-        { id: "C", groupIds: ["g1"] },
-        { id: "X", groupIds: ["g2"], isSelected: true },
-        { id: "Y", groupIds: ["g2"] },
-        { id: "R" },
-      ],
-      appState: { editingGroupId: "g1" },
-      operations: [[actionBringToFront, ["A", "C", "X", "Y", "R"]]],
-    });
-  });
 });

packages/excalidraw/CHANGELOG.md

@@ -17,13 +17,6 @@ Please add the latest change on the top under the correct section.
 
 ### Breaking changes
 
-- Theme changes initiated by the default UI are now delegated to `<Excalidraw onThemeChange={(theme) => ...} />` when supplied. If `onThemeChange` is not supplied, light/dark theme toggling still falls back to updating the internal editor state.
-
-  - `MainMenu.DefaultItems.ToggleTheme` no longer accepts the item-level `onSelect` callback. Host apps that need to control light/dark/system theme should pass `onThemeChange` to `<Excalidraw />` instead.
-  - `MainMenu.DefaultItems.ToggleTheme` with system theme support now uses `allowSystemTheme` together with `theme={Theme | "system"}` only to render the selected value. For the regular light/dark item, pass `allowSystemTheme={false}`.
-  - `CommandPalette.defaultItems.toggleTheme` was removed. The default theme command is now rendered by the command palette itself when `UIOptions.canvasActions.toggleTheme` enables the action (see below).
-  - `UIOptions.canvasActions.toggleTheme` still controls default theme UI availability. When it is `null`, it defaults to `true` if `props.theme` is omitted or `props.onThemeChange` is supplied, and otherwise defaults to disabled.
-
 - Renamed the `excalidrawAPI` prop to `onExcalidrawAPI`.
   - `onExcalidrawAPI` is now called on mount (instead of during constructor), and later on unmount (with `null` value). The API may be removed altogether in the future (you can use `onMount` & `onUmount` to manage the `ExcalidrawAPI` object (e.g. to cache it to a global state), already).
 

packages/excalidraw/actions/actionCanvas.tsx

@@ -477,28 +477,17 @@ export const actionToggleTheme = register<AppState["theme"]>({
     appState.theme === THEME.LIGHT ? MoonIcon : SunIcon,
   viewMode: true,
   trackEvent: { category: "canvas" },
-  perform: (_, appState, value, app) => {
+  perform: (_, appState, value) => {
-    const nextTheme =
-      value || (appState.theme === THEME.LIGHT ? THEME.DARK : THEME.LIGHT);
-
-    if (app.props.onThemeChange) {
-      app.props.onThemeChange(nextTheme);
-      return false;
-    }
-
     return {
       appState: {
         ...appState,
-        theme: nextTheme,
+        theme:
+          value || (appState.theme === THEME.LIGHT ? THEME.DARK : THEME.LIGHT),
       },
       captureUpdate: CaptureUpdateAction.EVENTUALLY,
     };
   },
-  keyTest: (event) =>
+  keyTest: (event) => event.altKey && event.shiftKey && event.code === CODES.D,
-    !event[KEYS.CTRL_OR_CMD] &&
-    event.altKey &&
-    event.shiftKey &&
-    event.code === CODES.D,
   predicate: (elements, appState, props, app) => {
     return !!app.props.UIOptions.canvasActions.toggleTheme;
   },

packages/excalidraw/actions/actionFinalize.tsx

@@ -54,7 +54,6 @@ export const actionFinalize = register<FormData>({
   label: "",
   trackEvent: false,
   perform: (elements, appState, data, app) => {
-    let shouldCommit = true;
     let newElements = elements;
     const { interactiveCanvas, focusContainer, scene } = app;
     const elementsMap = scene.getNonDeletedElementsMap();
@@ -223,44 +222,9 @@ export const actionFinalize = register<FormData>({
           !lastCommittedPoint ||
           points[points.length - 1] !== lastCommittedPoint
         ) {
-          shouldCommit = false;
           scene.mutateElement(element, {
             points: element.points.slice(0, -1),
           });
-          if (
-            isBindingElement(element) &&
-            element.endBinding &&
-            // after slicing the trailing point a <2-point arrow may be left
-            element.points.length > 1
-          ) {
-            const newArrow = !!appState.newElement;
-            const draggedPoints: PointsPositionUpdates = new Map([
-              [
-                element.points.length - 1,
-                {
-                  point: element.points[element.points.length - 1],
-                  isDragging: false,
-                },
-              ],
-            ]);
-            const globalPoint =
-              LinearElementEditor.getPointAtIndexGlobalCoordinates(
-                element,
-                -1,
-                elementsMap,
-              );
-            bindOrUnbindBindingElement(
-              element,
-              draggedPoints,
-              globalPoint[0],
-              globalPoint[1],
-              scene,
-              appState,
-              {
-                newArrow,
-              },
-            );
-          }
         }
       }
 
@@ -380,9 +344,7 @@ export const actionFinalize = register<FormData>({
         selectedLinearElement,
       },
       // TODO: #7348 we should not capture everything, but if we don't, it leads to incosistencies -> revisit
-      captureUpdate: shouldCommit
+      captureUpdate: CaptureUpdateAction.IMMEDIATELY,
-        ? CaptureUpdateAction.IMMEDIATELY
-        : CaptureUpdateAction.NEVER,
     };
   },
   keyTest: (event, appState) =>

packages/excalidraw/actions/actionProperties.tsx

@@ -1897,6 +1897,7 @@ export const actionChangeArrowType = register<keyof typeof ARROW_TYPE>({
                   startElement,
                   "start",
                   elementsMap,
+                  appState.zoom,
                   appState.isBindingEnabled,
                 ),
               }
@@ -1911,6 +1912,7 @@ export const actionChangeArrowType = register<keyof typeof ARROW_TYPE>({
                   endElement,
                   "end",
                   elementsMap,
+                  appState.zoom,
                   appState.isBindingEnabled,
                 ),
               }
@@ -1943,6 +1945,7 @@ export const actionChangeArrowType = register<keyof typeof ARROW_TYPE>({
               appState.bindMode === "inside" ? "inside" : "orbit",
               "start",
               app.scene,
+              appState.zoom,
             );
           }
         }
@@ -1957,6 +1960,7 @@ export const actionChangeArrowType = register<keyof typeof ARROW_TYPE>({
               appState.bindMode === "inside" ? "inside" : "orbit",
               "end",
               app.scene,
+              appState.zoom,
             );
           }
         }

packages/excalidraw/clipboard.ts

@@ -25,8 +25,6 @@ import type {
   NonDeletedExcalidrawElement,
 } from "@excalidraw/element/types";
 
-import { stringifyWithPrecision } from "./data/json";
-
 import { ExcalidrawError } from "./errors";
 import {
   createFile,
@@ -190,7 +188,7 @@ export const serializeAsClipboardJSON = ({
     files: files ? _files : undefined,
   };
 
-  return stringifyWithPrecision(contents);
+  return JSON.stringify(contents);
 };
 
 export const copyToClipboard = async (

packages/excalidraw/components/App.tsx

@@ -248,7 +248,6 @@ import {
   getElementBounds,
   doBoundsIntersect,
   isPointInElement,
-  maxBindingDistance_simple,
   convertToExcalidrawElements,
   type ExcalidrawElementSkeleton,
   getSnapOutlineMidPoint,
@@ -260,7 +259,6 @@ import {
   getUncroppedWidthAndHeight,
   getActiveTextElement,
   isEligibleFrameChildType,
-  getBindingStrategyForDraggingBindingElementEndpoints,
 } from "@excalidraw/element";
 
 import type { GlobalPoint, LocalPoint, Radians } from "@excalidraw/math";
@@ -935,14 +933,20 @@ class App extends React.Component<AppProps, AppState> {
         "Missing last pointer move coords when changing bind skip mode for arrow start",
       );
       const elementsMap = this.scene.getNonDeletedElementsMap();
-      const hoveredElement = getHoveredElementForBinding(
+      const arrow = elementsMap.get(
-        pointFrom<GlobalPoint>(
+        this.state.selectedLinearElement.elementId,
-          this.lastPointerMoveCoords.x,
+      ) as ExcalidrawArrowElement | undefined;
-          this.lastPointerMoveCoords.y,
+      const hoveredElement =
-        ),
+        arrow &&
-        this.scene.getNonDeletedElements(),
+        getHoveredElementForBinding(
-        elementsMap,
+          arrow,
-      );
+          pointFrom<GlobalPoint>(
+            this.lastPointerMoveCoords.x,
+            this.lastPointerMoveCoords.y,
+          ),
+          this.scene.getNonDeletedElements(),
+          elementsMap,
+        );
       const element = LinearElementEditor.getElement(
         this.state.selectedLinearElement.elementId,
         elementsMap,
@@ -1072,6 +1076,7 @@ class App extends React.Component<AppProps, AppState> {
 
       const { x, y } = this.lastPointerMoveCoords;
       const hoveredElement = getHoveredElementForBinding(
+        arrow,
         pointFrom<GlobalPoint>(x, y),
         this.scene.getNonDeletedElements(),
         this.scene.getNonDeletedElementsMap(),
@@ -1996,10 +2001,9 @@ class App extends React.Component<AppProps, AppState> {
               }
             }}
             style={{
-              background: applyDarkModeFilter(
+              background: isDarkTheme
-                this.state.viewBackgroundColor,
+                ? applyDarkModeFilter(this.state.viewBackgroundColor)
-                isDarkTheme,
+                : this.state.viewBackgroundColor,
-              ),
               zIndex: 2,
               border: "none",
               display: "block",
@@ -5379,12 +5383,6 @@ class App extends React.Component<AppProps, AppState> {
           this.state,
         );
 
-        const hoveredElement = getHoveredElementForBinding(
-          pointFrom<GlobalPoint>(scenePointer.x, scenePointer.y),
-          this.scene.getNonDeletedElements(),
-          this.scene.getNonDeletedElementsMap(),
-        );
-
         if (this.state.selectedLinearElement) {
           const element = LinearElementEditor.getElement(
             this.state.selectedLinearElement.elementId,
@@ -5392,6 +5390,13 @@ class App extends React.Component<AppProps, AppState> {
           );
 
           if (isBindingElement(element)) {
+            const hoveredElement = getHoveredElementForBinding(
+              element,
+              pointFrom<GlobalPoint>(scenePointer.x, scenePointer.y),
+              this.scene.getNonDeletedElements(),
+              this.scene.getNonDeletedElementsMap(),
+            );
+
             this.handleDelayedBindModeChange(element, hoveredElement);
           }
         }
@@ -7078,10 +7083,11 @@ class App extends React.Component<AppProps, AppState> {
         );
         const elementsMap = this.scene.getNonDeletedElementsMap();
         const hoveredElement = getHoveredElementForBinding(
-          globalPoint,
+          { elbowed: this.state.currentItemArrowType === ARROW_TYPE.elbow },
+          pointFrom<GlobalPoint>(scenePointerX, scenePointerY),
           this.scene.getNonDeletedElements(),
           elementsMap,
-          maxBindingDistance_simple(this.state.zoom),
+          this.state.zoom,
         );
         if (hoveredElement) {
           this.setState({
@@ -7092,6 +7098,9 @@ class App extends React.Component<AppProps, AppState> {
                 hoveredElement,
                 elementsMap,
                 this.state.zoom,
+                {
+                  elbowed: this.state.currentItemArrowType === ARROW_TYPE.elbow,
+                },
               ),
             },
           });
@@ -7113,7 +7122,46 @@ class App extends React.Component<AppProps, AppState> {
       setCursorForShape(this.interactiveCanvas, this.state);
 
       if (lastPoint === lastCommittedPoint) {
-        if (
+        const hoveredElement =
+          isArrowElement(this.state.newElement) &&
+          isBindingEnabled(this.state) &&
+          getHoveredElementForBinding(
+            this.state.newElement,
+            pointFrom<GlobalPoint>(scenePointerX, scenePointerY),
+            this.scene.getNonDeletedElements(),
+            this.scene.getNonDeletedElementsMap(),
+            this.state.zoom,
+          );
+        if (hoveredElement) {
+          this.actionManager.executeAction(actionFinalize, "ui", {
+            event: event.nativeEvent,
+            sceneCoords: {
+              x: scenePointerX,
+              y: scenePointerY,
+            },
+          });
+          this.setState({ suggestedBinding: null });
+          if (!this.state.activeTool.locked) {
+            resetCursor(this.interactiveCanvas);
+            this.setState((prevState) => ({
+              newElement: null,
+              activeTool: updateActiveTool(this.state, {
+                type: this.state.preferredSelectionTool.type,
+              }),
+              selectedElementIds: makeNextSelectedElementIds(
+                {
+                  ...prevState.selectedElementIds,
+                  [multiElement.id]: true,
+                },
+                prevState,
+              ),
+              selectedLinearElement: new LinearElementEditor(
+                multiElement,
+                this.scene.getNonDeletedElementsMap(),
+              ),
+            }));
+          }
+        } else if (
           // if we haven't yet created a temp point and we're beyond commit-zone
           // threshold, add a point
           pointDistance(
@@ -7121,24 +7169,6 @@ class App extends React.Component<AppProps, AppState> {
             lastPoint,
           ) >= LINE_CONFIRM_THRESHOLD
         ) {
-          this.store.scheduleCapture();
-          flushSync(() => {
-            invariant(
-              this.state.selectedLinearElement?.initialState,
-              "initialState must be set",
-            );
-            this.setState({
-              selectedLinearElement: {
-                ...this.state.selectedLinearElement,
-                lastCommittedPoint: points[points.length - 1],
-                selectedPointsIndices: [multiElement.points.length],
-                initialState: {
-                  ...this.state.selectedLinearElement.initialState,
-                  lastClickedPoint: multiElement.points.length,
-                },
-              },
-            });
-          });
           this.scene.mutateElement(
             multiElement,
             {
@@ -7149,6 +7179,21 @@ class App extends React.Component<AppProps, AppState> {
             },
             { informMutation: false, isDragging: false },
           );
+          invariant(
+            this.state.selectedLinearElement?.initialState,
+            "initialState must be set",
+          );
+          this.setState({
+            selectedLinearElement: {
+              ...this.state.selectedLinearElement,
+              lastCommittedPoint: points[points.length - 1],
+              selectedPointsIndices: [multiElement.points.length - 1],
+              initialState: {
+                ...this.state.selectedLinearElement.initialState,
+                lastClickedPoint: multiElement.points.length - 1,
+              },
+            },
+          });
         } else {
           setCursor(this.interactiveCanvas, CURSOR_TYPE.POINTER);
           // in this branch, we're inside the commit zone, and no uncommitted
@@ -7200,6 +7245,7 @@ class App extends React.Component<AppProps, AppState> {
 
         if (isSimpleArrow(multiElement)) {
           const hoveredElement = getHoveredElementForBinding(
+            multiElement,
             pointFrom<GlobalPoint>(scenePointerX, scenePointerY),
             this.scene.getNonDeletedElements(),
             elementsMap,
@@ -7232,10 +7278,11 @@ class App extends React.Component<AppProps, AppState> {
 
     if (this.state.activeTool.type === "arrow") {
       const hit = getHoveredElementForBinding(
+        { elbowed: this.state.currentItemArrowType === ARROW_TYPE.elbow },
         pointFrom<GlobalPoint>(scenePointerX, scenePointerY),
         this.scene.getNonDeletedElements(),
         this.scene.getNonDeletedElementsMap(),
-        maxBindingDistance_simple(this.state.zoom),
+        this.state.zoom,
       );
       const scenePointer = pointFrom<GlobalPoint>(scenePointerX, scenePointerY);
       const elementsMap = this.scene.getNonDeletedElementsMap();
@@ -7248,6 +7295,7 @@ class App extends React.Component<AppProps, AppState> {
               hit,
               elementsMap,
               this.state.zoom,
+              { elbowed: this.state.currentItemArrowType === ARROW_TYPE.elbow },
             ),
           },
         });
@@ -9230,58 +9278,33 @@ class App extends React.Component<AppProps, AppState> {
 
       const { x: rx, y: ry } = multiElement;
       const { lastCommittedPoint } = selectedLinearElement;
-      const sceneCoords = viewportCoordsToSceneCoords(event, this.state);
-      const { start, end } =
-        isBindingElement(multiElement) && isBindingEnabled(this.state)
-          ? getBindingStrategyForDraggingBindingElementEndpoints(
-              multiElement,
-              new Map([
-                [
-                  multiElement.points.length - 1,
-                  {
-                    point: multiElement.points[multiElement.points.length - 1],
-                    isDragging: false,
-                  },
-                ],
-              ]),
-              sceneCoords.x,
-              sceneCoords.y,
-              this.scene.getNonDeletedElementsMap(),
-              this.scene.getNonDeletedElements(),
-              this.state,
-              {
-                newArrow: Boolean(this.state.newElement),
-                zoom: this.state.zoom,
-              },
-            )
-          : { end: { mode: undefined } };
 
-      const elementsMap = this.scene.getNonDeletedElementsMap();
+      const hoveredElementForBinding =
-      // Auto-confirm when both ends bind to the SAME element and the end point
+        isBindingEnabled(this.state) &&
-      // lands on the outline rather than inside it
+        getHoveredElementForBinding(
-      const endOutsideSameElement =
+          { elbowed: isElbowArrow(multiElement) },
-        start?.mode != null &&
+          pointFrom<GlobalPoint>(
-        end.mode != null &&
+            this.lastPointerMoveCoords?.x ??
-        start.element.id === end.element.id &&
+              rx + multiElement.points[multiElement.points.length - 1][0],
-        !isPointInElement(end.focusPoint, end.element, elementsMap);
+            this.lastPointerMoveCoords?.y ??
-      const boundOutsideFromElsewhere =
+              ry + multiElement.points[multiElement.points.length - 1][1],
-        end.mode === "orbit" &&
-        multiElement.startBinding?.elementId !== end.element?.id;
-      const lastCommittedPointIsInsideCommitZone =
-        lastCommittedPoint &&
-        pointDistance(
-          pointFrom(
-            pointerDownState.origin.x - rx,
-            pointerDownState.origin.y - ry,
           ),
-          lastCommittedPoint,
+          this.scene.getNonDeletedElements(),
-        ) < LINE_CONFIRM_THRESHOLD;
+          this.scene.getNonDeletedElementsMap(),
+        );
 
       // clicking inside commit zone → finalize arrow
       if (
-        boundOutsideFromElsewhere || // Outside -> orbit: Bind immediately
+        (isBindingElement(multiElement) && hoveredElementForBinding) ||
-        endOutsideSameElement || // End outside the start's element: Bind immediately
+        (multiElement.points.length > 1 &&
-        (multiElement.points.length > 1 && lastCommittedPointIsInsideCommitZone)
+          lastCommittedPoint &&
+          pointDistance(
+            pointFrom(
+              pointerDownState.origin.x - rx,
+              pointerDownState.origin.y - ry,
+            ),
+            lastCommittedPoint,
+          ) < LINE_CONFIRM_THRESHOLD)
       ) {
         this.actionManager.executeAction(actionFinalize, "ui", {
           event: event.nativeEvent,
@@ -9382,6 +9405,7 @@ class App extends React.Component<AppProps, AppState> {
       const elementsMap = this.scene.getNonDeletedElementsMap();
       const boundElement = isBindingEnabled(this.state)
         ? getHoveredElementForBinding(
+            { elbowed: this.state.currentItemArrowType === ARROW_TYPE.elbow },
             point,
             this.scene.getNonDeletedElements(),
             elementsMap,
@@ -9457,7 +9481,6 @@ class App extends React.Component<AppProps, AppState> {
             ...prevState,
             bindMode: "orbit",
             newElement: element,
-            startBoundElement: boundElement,
             suggestedBinding:
               boundElement && isBindingElement(element)
                 ? {
@@ -9467,6 +9490,7 @@ class App extends React.Component<AppProps, AppState> {
                       boundElement,
                       elementsMap,
                       this.state.zoom,
+                      element,
                     ),
                   }
                 : null,
@@ -9863,16 +9887,16 @@ class App extends React.Component<AppProps, AppState> {
             return;
           }
 
-          if (isBindingElement(element)) {
+          if (isBindingElement(element) && getFeatureFlag("COMPLEX_BINDINGS")) {
             const hoveredElement = getHoveredElementForBinding(
+              element,
               pointFrom<GlobalPoint>(pointerCoords.x, pointerCoords.y),
               this.scene.getNonDeletedElements(),
               elementsMap,
+              this.state.zoom,
             );
 
-            if (getFeatureFlag("COMPLEX_BINDINGS")) {
+            this.handleDelayedBindModeChange(element, hoveredElement);
-              this.handleDelayedBindModeChange(element, hoveredElement);
-            }
           }
 
           if (
@@ -10856,6 +10880,13 @@ class App extends React.Component<AppProps, AppState> {
       }
 
       if (isLinearElement(newElement)) {
+        if (
+          newElement!.points.length > 1 &&
+          newElement.points[1][0] !== 0 &&
+          newElement.points[1][1] !== 0
+        ) {
+          this.store.scheduleCapture();
+        }
         const pointerCoords = viewportCoordsToSceneCoords(
           childEvent,
           this.state,
@@ -10893,15 +10924,23 @@ class App extends React.Component<AppProps, AppState> {
 
             this.actionManager.executeAction(actionFinalize);
           } else {
-            // Movement out of commit area will create the point
+            const dx = pointerCoords.x - newElement.x;
+            const dy = pointerCoords.y - newElement.y;
+
+            this.scene.mutateElement(
+              newElement,
+              {
+                points: [newElement.points[0], pointFrom<LocalPoint>(dx, dy)],
+              },
+              { informMutation: false, isDragging: false },
+            );
+
             this.setState({
               multiElement: newElement,
               newElement,
             });
           }
         } else if (pointerDownState.drag.hasOccurred && !multiElement) {
-          this.store.scheduleCapture();
-
           if (isLinearElement(newElement)) {
             this.actionManager.executeAction(actionFinalize, "ui", {
               event: childEvent,

packages/excalidraw/components/CommandPalette/CommandPalette.tsx

@@ -19,7 +19,6 @@ import {
   actionClearCanvas,
   actionLink,
   actionToggleSearchMenu,
-  actionToggleTheme,
 } from "../../actions";
 import {
   actionCopyElementLink,
@@ -425,7 +424,6 @@ function CommandPaletteInner({
       ];
 
       const additionalCommands: CommandPaletteItem[] = [
-        actionToCommand(actionToggleTheme, DEFAULT_CATEGORIES.app),
         {
           label: t("toolBar.library"),
           category: DEFAULT_CATEGORIES.app,

packages/excalidraw/components/CommandPalette/defaultCommandPaletteItems.ts

@@ -1 +1,12 @@
-export {};
+import { actionToggleTheme } from "../../actions";
+
+import type { CommandPaletteItem } from "./types";
+
+export const toggleTheme: CommandPaletteItem = {
+  ...actionToggleTheme,
+  category: "App",
+  label: "Toggle theme",
+  perform: ({ actionManager }) => {
+    actionManager.executeAction(actionToggleTheme, "commandPalette");
+  },
+};

packages/excalidraw/components/ConvertElementTypePopup.tsx

@@ -831,13 +831,14 @@ const convertElementType = <
       newElement({
         ...element,
         type: targetType,
-        roundness: element.roundness
+        roundness:
-          ? {
+          targetType === "diamond" && element.roundness
-              type: isUsingAdaptiveRadius(targetType)
+            ? {
-                ? ROUNDNESS.ADAPTIVE_RADIUS
+                type: isUsingAdaptiveRadius(targetType)
-                : ROUNDNESS.PROPORTIONAL_RADIUS,
+                  ? ROUNDNESS.ADAPTIVE_RADIUS
-            }
+                  : ROUNDNESS.PROPORTIONAL_RADIUS,
-          : element.roundness,
+              }
+            : element.roundness,
       }),
     ) as typeof element;
 

packages/excalidraw/components/HelpDialog.tsx

@@ -4,13 +4,11 @@ import { isDarwin, isFirefox, isWindows } from "@excalidraw/common";
 
 import { KEYS } from "@excalidraw/common";
 
-import { actionToggleTheme } from "../actions";
 import { getShortcutFromShortcutName } from "../actions/shortcuts";
 import { probablySupportsClipboardBlob } from "../clipboard";
 import { t } from "../i18n";
 import { getShortcutKey } from "../shortcut";
 
-import { useExcalidrawActionManager } from "./App";
 import { Dialog } from "./Dialog";
 import { ExternalLinkIcon, GithubIcon, youtubeIcon } from "./icons";
 
@@ -126,7 +124,6 @@ const ShortcutKey = (props: { children: React.ReactNode }) => (
 );
 
 export const HelpDialog = ({ onClose }: { onClose?: () => void }) => {
-  const actionManager = useExcalidrawActionManager();
   const handleClose = React.useCallback(() => {
     if (onClose) {
       onClose();
@@ -305,12 +302,10 @@ export const HelpDialog = ({ onClose }: { onClose?: () => void }) => {
               label={t("labels.viewMode")}
               shortcuts={[getShortcutKey("Alt+R")]}
             />
-            {actionManager.isActionEnabled(actionToggleTheme) && (
+            <Shortcut
-              <Shortcut
+              label={t("labels.toggleTheme")}
-                label={t("labels.toggleTheme")}
+              shortcuts={[getShortcutKey("Alt+Shift+D")]}
-                shortcuts={[getShortcutKey("Alt+Shift+D")]}
+            />
-              />
-            )}
             <Shortcut
               label={t("stats.fullTitle")}
               shortcuts={[getShortcutKey("Alt+/")]}

packages/excalidraw/components/Island.scss

@@ -7,6 +7,7 @@
     border-radius: var(--border-radius-lg);
     padding: calc(var(--padding) * var(--space-factor));
     position: relative;
+    transition: box-shadow 0.5s ease-in-out;
 
     &.zen-mode {
       box-shadow: none;

packages/excalidraw/components/LayerUI.tsx

@@ -122,7 +122,7 @@ const DefaultMainMenu: React.FC<{
         <MainMenu.DefaultItems.Socials />
       </MainMenu.Group>
       <MainMenu.Separator />
-      <MainMenu.DefaultItems.ToggleTheme allowSystemTheme={false} />
+      <MainMenu.DefaultItems.ToggleTheme />
       <MainMenu.DefaultItems.ChangeCanvasBackground />
     </MainMenu>
   );

packages/excalidraw/components/RadioGroup.scss

@@ -29,7 +29,6 @@
     gap: 2px;
 
     &__choice {
-      box-sizing: content-box;
       position: relative;
       display: flex;
       align-items: center;
@@ -51,11 +50,13 @@
       user-select: none;
       letter-spacing: 0.4px;
 
+      transition: all 75ms ease-out;
+
       &:hover {
         color: var(--RadioGroup-choice-color-off-hover);
       }
 
-      &:not(.active):active {
+      &:active {
         background: var(--RadioGroup-choice-background-off-active);
       }
 

packages/excalidraw/components/main-menu/DefaultItems.tsx

@@ -232,22 +232,18 @@ export const ToggleTheme = (
   props:
     | {
         allowSystemTheme: true;
-        /**
-         * Controls the theme of this UI component only.
-         * You should subscribe to `props.onThemeChange` and control the theme
-         * upstream.
-         */
         theme: Theme | "system";
+        onSelect: (theme: Theme | "system") => void;
       }
     | {
-        allowSystemTheme: false;
+        allowSystemTheme?: false;
+        onSelect?: (theme: Theme) => void;
       },
 ) => {
   const { t } = useI18n();
   const appState = useUIAppState();
   const actionManager = useExcalidrawActionManager();
   const shortcut = getShortcutFromShortcutName("toggleTheme");
-  const appProps = useAppProps();
 
   if (!actionManager.isActionEnabled(actionToggleTheme)) {
     return null;
@@ -258,16 +254,7 @@ export const ToggleTheme = (
       <DropdownMenuItemContentRadio
         name="theme"
         value={props.theme}
-        onChange={(value: Theme | "system") => {
+        onChange={(value: Theme | "system") => props.onSelect(value)}
-          if (appProps.onThemeChange) {
-            appProps.onThemeChange(value);
-            return;
-          }
-
-          console.warn(
-            "MainMenu.DefaultItems.ToggleTheme: `<Excalidraw/> props.onThemeChange` must be defined to use system theme selection.",
-          );
-        }}
         choices={[
           {
             value: THEME.LIGHT,
@@ -297,7 +284,13 @@ export const ToggleTheme = (
         // do not close the menu when changing theme
         event.preventDefault();
 
-        actionManager.executeAction(actionToggleTheme);
+        if (props?.onSelect) {
+          props.onSelect(
+            appState.theme === THEME.DARK ? THEME.LIGHT : THEME.DARK,
+          );
+        } else {
+          return actionManager.executeAction(actionToggleTheme);
+        }
       }}
       icon={appState.theme === THEME.DARK ? SunIcon : MoonIcon}
       data-testid="toggle-dark-mode"

packages/excalidraw/data/json.ts

@@ -22,41 +22,6 @@ import type {
   ImportedLibraryData,
 } from "./types";
 
-const SCALAR_ROUNDED_KEYS = new Set(["x", "y", "width", "height"]);
-
-// JSON.stringify encodes \x00 as \u0000 (6-char literal sequence) in the output
-// string. We use this as a sentinel so we can strip the surrounding quotes
-// afterward, emitting raw number tokens without a float round-trip.
-const PRECISION_SENTINEL = "\x00";
-const PRECISION_SENTINEL_RE = /"\\u0000([^"]+)\\u0000"/g;
-
-export const stringifyWithPrecision = (
-  value: unknown,
-  precision = 2,
-  space?: number | string,
-): string => {
-  const fmt = (n: number) =>
-    `${PRECISION_SENTINEL}${n.toFixed(precision)}${PRECISION_SENTINEL}`;
-
-  return JSON.stringify(
-    value,
-    (key, val) => {
-      if (SCALAR_ROUNDED_KEYS.has(key) && typeof val === "number") {
-        return fmt(val);
-      }
-      if (key === "points" && Array.isArray(val)) {
-        return (val as number[][]).map((pt) =>
-          Array.isArray(pt)
-            ? pt.map((n) => (typeof n === "number" ? fmt(n) : n))
-            : pt,
-        );
-      }
-      return val;
-    },
-    space,
-  ).replace(PRECISION_SENTINEL_RE, "$1");
-};
-
 export type JSONExportData = {
   elements: readonly NonDeleted<ExcalidrawElement>[];
   appState: AppState;
@@ -106,7 +71,7 @@ export const serializeAsJSON = (
           undefined,
   };
 
-  return stringifyWithPrecision(data, 2, 2);
+  return JSON.stringify(data, null, 2);
 };
 
 export const saveAsJSON = async ({
@@ -176,7 +141,7 @@ export const serializeLibraryAsJSON = (libraryItems: LibraryItems) => {
     source: getExportSource(),
     libraryItems,
   };
-  return stringifyWithPrecision(data, 2, 2);
+  return JSON.stringify(data, null, 2);
 };
 
 export const saveLibraryAsJSON = async (libraryItems: LibraryItems) => {

packages/excalidraw/index.tsx

@@ -7,7 +7,6 @@ import React, {
 } from "react";
 
 import {
-  applyDarkModeFilter,
   DEFAULT_IMAGE_OPTIONS,
   DEFAULT_UI_OPTIONS,
   isShallowEqual,
@@ -67,7 +66,6 @@ const ExcalidrawBase = (props: ExcalidrawProps) => {
   const {
     onExport,
     onChange,
-    onThemeChange,
     onIncrement,
     initialData,
     onExcalidrawAPI,
@@ -130,7 +128,7 @@ const ExcalidrawBase = (props: ExcalidrawProps) => {
 
   if (
     UIOptions.canvasActions.toggleTheme === null &&
-    (theme == null || onThemeChange)
+    typeof theme === "undefined"
   ) {
     UIOptions.canvasActions.toggleTheme = true;
   }
@@ -186,7 +184,6 @@ const ExcalidrawBase = (props: ExcalidrawProps) => {
         <App
           onExport={onExport}
           onChange={onChange}
-          onThemeChange={onThemeChange}
           onIncrement={onIncrement}
           initialData={initialData}
           onExcalidrawAPI={handleExcalidrawAPI}
@@ -400,7 +397,11 @@ export {
   convertToExcalidrawElements,
 } from "@excalidraw/element";
 
-export { elementsOverlappingBBox } from "@excalidraw/element";
+export {
+  elementsOverlappingBBox,
+  isElementInsideBBox,
+  elementPartiallyOverlapsWithOrContainsBBox,
+} from "@excalidraw/utils/withinBounds";
 
 export { DiagramToCodePlugin } from "./components/DiagramToCodePlugin/DiagramToCodePlugin";
 export { getDataURL } from "./data/blob";
@@ -449,5 +450,3 @@ export function useExcalidrawStateValue(
 // -----------------------------------------------------------------------------
 
 export { _useOnAppStateChange as useOnExcalidrawStateChange };
-
-export { applyDarkModeFilter };

packages/excalidraw/renderer/helpers.ts

@@ -62,10 +62,10 @@ export const bootstrapCanvas = ({
       context.clearRect(0, 0, normalizedWidth, normalizedHeight);
     }
     context.save();
-    context.fillStyle = applyDarkModeFilter(
+    context.fillStyle =
-      viewBackgroundColor,
+      theme === THEME.DARK
-      theme === THEME.DARK,
+        ? applyDarkModeFilter(viewBackgroundColor)
-    );
+        : viewBackgroundColor;
     context.fillRect(0, 0, normalizedWidth, normalizedHeight);
     context.restore();
   } else {

packages/excalidraw/renderer/interactiveScene.ts

@@ -7,7 +7,6 @@ import {
   type Radians,
   bezierEquation,
   pointRotateRads,
-  pointDistance,
 } from "@excalidraw/math";
 
 import {
@@ -24,13 +23,12 @@ import {
   deconstructDiamondElement,
   deconstructRectanguloidElement,
   elementCenterPoint,
-  getDiamondBaseCorners,
+  getAllMidpoints,
   FOCUS_POINT_SIZE,
   getOmitSidesForEditorInterface,
   getTransformHandles,
   getTransformHandlesFromCoords,
   hasBoundingBox,
-  hitElementItself,
   isArrowElement,
   isBindableElement,
   isElbowArrow,
@@ -38,7 +36,6 @@ import {
   isImageElement,
   isLinearElement,
   isLineElement,
-  maxBindingDistance_simple,
   isTextElement,
   LinearElementEditor,
   getActiveTextElement,
@@ -413,145 +410,42 @@ const renderBindingHighlightForBindableElement_simple = (
       break;
   }
 
+  // Draw midpoint indicators
   if (
     appState.isMidpointSnappingEnabled &&
     (isFrameLikeElement(suggestedBinding.element) ||
       isBindableElement(suggestedBinding.element))
   ) {
-    // Draw midpoint indicators
+    context.save();
-    const linearElement = appState.selectedLinearElement;
-    const arrow =
-      linearElement?.elementId &&
-      LinearElementEditor.getElement(linearElement?.elementId, elementsMap);
-    const cursorIsInsideBindable =
-      pointerCoords &&
-      hitElementItself({
-        point: pointerCoords,
-        element: suggestedBinding.element,
-        elementsMap,
-        threshold: 0,
-        overrideShouldTestInside: true,
-      });
 
-    const isElbow =
+    const midpointRadius = 4 / appState.zoom.value;
-      (arrow && isElbowArrow(arrow)) ||
-      (appState.activeTool.type === "arrow" &&
-        appState.currentItemArrowType === "elbow");
 
-    if (!cursorIsInsideBindable || isElbow) {
+    // Render base midpoints
-      context.save();
+    const midpoints = getAllMidpoints(suggestedBinding.element, elementsMap);
-
+    for (const midpoint of midpoints) {
-      const center = elementCenterPoint(suggestedBinding.element, elementsMap);
+      context.fillStyle =
-
+        appState.theme === THEME.DARK
-      let midpoints: GlobalPoint[];
+          ? `rgba(0, 0, 0, 0.8)`
-      if (suggestedBinding.element.type === "diamond") {
+          : `rgba(65, 65, 65, 0.5)`;
-        const center = elementCenterPoint(
+      context.beginPath();
-          suggestedBinding.element,
+      context.arc(midpoint[0], midpoint[1], midpointRadius, 0, 2 * Math.PI);
-          elementsMap,
+      context.fill();
-        );
-        midpoints = getDiamondBaseCorners(suggestedBinding.element).map(
-          (curve) => {
-            const point = bezierEquation(curve, 0.5);
-            const rotatedPoint = pointRotateRads(
-              point,
-              center,
-              suggestedBinding.element.angle,
-            );
-
-            return pointFrom<GlobalPoint>(rotatedPoint[0], rotatedPoint[1]);
-          },
-        );
-      } else {
-        const basePoints = [
-          {
-            x: suggestedBinding.element.width,
-            y: suggestedBinding.element.height / 2,
-          }, // RIGHT
-          {
-            x: suggestedBinding.element.width / 2,
-            y: suggestedBinding.element.height,
-          }, // BOTTOM
-          { x: 0, y: suggestedBinding.element.height / 2 }, // LEFT
-          { x: suggestedBinding.element.width / 2, y: 0 }, // TOP
-        ];
-        midpoints = basePoints.map((point) => {
-          const globalPoint = pointFrom<GlobalPoint>(
-            point.x + suggestedBinding.element.x,
-            point.y + suggestedBinding.element.y,
-          );
-          const rotatedPoint = pointRotateRads(
-            globalPoint,
-            center,
-            suggestedBinding.element.angle,
-          );
-          return pointFrom<GlobalPoint>(rotatedPoint[0], rotatedPoint[1]);
-        });
-      }
-
-      const hoveredMidpoint =
-        pointerCoords &&
-        midpoints.reduce(
-          (
-            closestIdx: {
-              idx: number;
-              distance: number;
-            },
-            point,
-            idx,
-          ) => {
-            const distance = pointDistance(point, pointerCoords);
-            if (idx === -1 || distance < closestIdx.distance) {
-              return { idx, distance };
-            }
-            return closestIdx;
-          },
-          {
-            idx: -1,
-            distance: Infinity,
-          },
-        );
-
-      const midpointRadius = 4 / appState.zoom.value;
-      const highlightThreshold =
-        maxBindingDistance_simple(appState.zoom) +
-        suggestedBinding.element.strokeWidth / 2;
-
-      midpoints.forEach((midpoint, idx) => {
-        const isHighlighted =
-          (!cursorIsInsideBindable || isElbow) &&
-          hoveredMidpoint?.idx === idx &&
-          hoveredMidpoint.distance <= highlightThreshold;
-
-        // also render midpoint if cursor close but not highlighted
-        // (for elbows, always show all points)
-        const isShown =
-          !isHighlighted &&
-          (isElbow ||
-            (idx === hoveredMidpoint?.idx &&
-              hoveredMidpoint.distance <= highlightThreshold * 2));
-
-        if (isHighlighted) {
-          context.fillStyle =
-            appState.theme === THEME.DARK
-              ? `rgba(3, 93, 161, 1)`
-              : `rgba(106, 189, 252, 1)`;
-
-          context.beginPath();
-          context.arc(midpoint[0], midpoint[1], midpointRadius, 0, 2 * Math.PI);
-          context.fill();
-        } else if (isShown) {
-          context.fillStyle =
-            appState.theme === THEME.DARK
-              ? `rgba(0, 0, 0, 0.8)`
-              : `rgba(65, 65, 65, 0.5)`;
-          context.beginPath();
-          context.arc(midpoint[0], midpoint[1], midpointRadius, 0, 2 * Math.PI);
-          context.fill();
-        }
-      });
-
-      context.restore();
     }
+
+    // Render the highlighted midpoint if any
+    const midpoint = appState.suggestedBinding?.midPoint;
+    if (midpoint) {
+      context.fillStyle =
+        appState.theme === THEME.DARK
+          ? `rgba(3, 93, 161, 1)`
+          : `rgba(106, 189, 252, 1)`;
+
+      context.beginPath();
+      context.arc(midpoint[0], midpoint[1], midpointRadius, 0, 2 * Math.PI);
+      context.fill();
+    }
+
+    context.restore();
   }
 };
 

packages/excalidraw/renderer/staticSvgScene.ts

@@ -291,14 +291,6 @@ const renderElementToSvg = (
         );
         offsetX = offsetX || 0;
         offsetY = offsetY || 0;
-        // Pin the mask to user space; the default maskUnits="objectBoundingBox"
-        // collapses to zero area for axis-aligned arrows (zero-size bbox),
-        // hiding the whole line from SVG exports (#11439).
-        maskPath.setAttribute("maskUnits", "userSpaceOnUse");
-        maskPath.setAttribute("x", "0");
-        maskPath.setAttribute("y", "0");
-        maskPath.setAttribute("width", `${element.width + 100 + offsetX}`);
-        maskPath.setAttribute("height", `${element.height + 100 + offsetY}`);
         maskRectVisible.setAttribute("x", "0");
         maskRectVisible.setAttribute("y", "0");
         maskRectVisible.setAttribute("fill", "#fff");
@@ -394,10 +386,9 @@ const renderElementToSvg = (
           const path = svgRoot.ownerDocument.createElementNS(SVG_NS, "path");
           path.setAttribute(
             "fill",
-            applyDarkModeFilter(
+            renderConfig.theme === THEME.DARK
-              element.strokeColor,
+              ? applyDarkModeFilter(element.strokeColor)
-              renderConfig.theme === THEME.DARK,
+              : element.strokeColor,
-            ),
           );
           path.setAttribute("d", shape);
           wrapper.appendChild(path);
@@ -630,10 +621,9 @@ const renderElementToSvg = (
         rect.setAttribute("fill", "none");
         rect.setAttribute(
           "stroke",
-          applyDarkModeFilter(
+          renderConfig.theme === THEME.DARK
-            FRAME_STYLE.strokeColor,
+            ? applyDarkModeFilter(FRAME_STYLE.strokeColor)
-            renderConfig.theme === THEME.DARK,
+            : FRAME_STYLE.strokeColor,
-          ),
         );
         rect.setAttribute("stroke-width", FRAME_STYLE.strokeWidth.toString());
 
@@ -687,10 +677,9 @@ const renderElementToSvg = (
           text.setAttribute("font-size", `${element.fontSize}px`);
           text.setAttribute(
             "fill",
-            applyDarkModeFilter(
+            renderConfig.theme === THEME.DARK
-              element.strokeColor,
+              ? applyDarkModeFilter(element.strokeColor)
-              renderConfig.theme === THEME.DARK,
+              : element.strokeColor,
-            ),
           );
           text.setAttribute("text-anchor", textAnchor);
           text.setAttribute("style", "white-space: pre;");

packages/excalidraw/scene/export.ts

@@ -459,7 +459,9 @@ export const exportToSvg = async (
     rect.setAttribute("height", `${height}`);
     rect.setAttribute(
       "fill",
-      applyDarkModeFilter(viewBackgroundColor, exportWithDarkMode),
+      exportWithDarkMode
+        ? applyDarkModeFilter(viewBackgroundColor)
+        : viewBackgroundColor,
     );
     svgRoot.appendChild(rect);
   }

packages/excalidraw/tests/__snapshots__/contextmenu.test.tsx.snap

@@ -1464,7 +1464,7 @@ exports[`contextMenu element > selecting 'Bring forward' in context menu brings
   "versionNonce": 493213705,
   "width": 20,
   "x": -10,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -1516,7 +1516,7 @@ exports[`contextMenu element > selecting 'Bring forward' in context menu brings
             "version": 3,
             "width": 20,
             "x": -10,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -1795,7 +1795,7 @@ exports[`contextMenu element > selecting 'Bring to front' in context menu brings
   "versionNonce": 493213705,
   "width": 20,
   "x": -10,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -1847,7 +1847,7 @@ exports[`contextMenu element > selecting 'Bring to front' in context menu brings
             "version": 3,
             "width": 20,
             "x": -10,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -2490,7 +2490,7 @@ exports[`contextMenu element > selecting 'Duplicate' in context menu duplicates
   "resizingElement": null,
   "scrollX": 0,
   "scrollY": 0,
-  "scrolledOutside": true,
+  "scrolledOutside": false,
   "searchMatches": null,
   "selectedElementIds": {
     "id3": true,
@@ -2854,7 +2854,7 @@ exports[`contextMenu element > selecting 'Group selection' in context menu group
   "versionNonce": 915032327,
   "width": 20,
   "x": -10,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -2940,7 +2940,7 @@ exports[`contextMenu element > selecting 'Group selection' in context menu group
             "version": 3,
             "width": 20,
             "x": -10,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -3221,7 +3221,7 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s
   "versionNonce": 1402203177,
   "width": 20,
   "x": -10,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -3305,7 +3305,7 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s
             "version": 3,
             "width": 20,
             "x": -10,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -3744,7 +3744,7 @@ exports[`contextMenu element > selecting 'Send backward' in context menu sends e
   "versionNonce": 2019559783,
   "width": 20,
   "x": -10,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -3796,7 +3796,7 @@ exports[`contextMenu element > selecting 'Send backward' in context menu sends e
             "version": 3,
             "width": 20,
             "x": -10,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -4067,7 +4067,7 @@ exports[`contextMenu element > selecting 'Send to back' in context menu sends el
   "versionNonce": 2019559783,
   "width": 20,
   "x": -10,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -4119,7 +4119,7 @@ exports[`contextMenu element > selecting 'Send to back' in context menu sends el
             "version": 3,
             "width": 20,
             "x": -10,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -4361,7 +4361,7 @@ exports[`contextMenu element > selecting 'Ungroup selection' in context menu ung
   "versionNonce": 1006504105,
   "width": 20,
   "x": -10,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -4445,7 +4445,7 @@ exports[`contextMenu element > selecting 'Ungroup selection' in context menu ung
             "version": 3,
             "width": 20,
             "x": -10,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -5646,7 +5646,7 @@ exports[`contextMenu element > shows 'Group selection' in context menu for multi
   "versionNonce": 1150084233,
   "width": 10,
   "x": -10,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -5678,7 +5678,7 @@ exports[`contextMenu element > shows 'Group selection' in context menu for multi
   "versionNonce": 23633383,
   "width": 10,
   "x": 12,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -5730,7 +5730,7 @@ exports[`contextMenu element > shows 'Group selection' in context menu for multi
             "version": 3,
             "width": 10,
             "x": -10,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -5784,7 +5784,7 @@ exports[`contextMenu element > shows 'Group selection' in context menu for multi
             "version": 3,
             "width": 10,
             "x": 12,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -6867,7 +6867,7 @@ exports[`contextMenu element > shows 'Ungroup selection' in context menu for gro
   "versionNonce": 1723083209,
   "width": 10,
   "x": -10,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -6901,7 +6901,7 @@ exports[`contextMenu element > shows 'Ungroup selection' in context menu for gro
   "versionNonce": 760410951,
   "width": 10,
   "x": 12,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -6953,7 +6953,7 @@ exports[`contextMenu element > shows 'Ungroup selection' in context menu for gro
             "version": 3,
             "width": 10,
             "x": -10,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -7007,7 +7007,7 @@ exports[`contextMenu element > shows 'Ungroup selection' in context menu for gro
             "version": 3,
             "width": 10,
             "x": 12,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,

packages/excalidraw/tests/__snapshots__/export.test.tsx.snap

@@ -1,7 +1,7 @@
 // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
 
 exports[`export > export svg-embedded scene > svg-embdedded scene export output 1`] = `
-"<svg version="1.1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 36 36" width="36" height="36"><!-- svg-source:excalidraw --><metadata><!-- payload-type:application/vnd.excalidraw+json --><!-- payload-version:2 --><!-- payload-start -->eyJ2ZXJzaW9uIjoiMSIsImVuY29kaW5nIjoiYnN0cmluZyIsImNvbXByZXNzZWQiOnRydWUsImVuY29kZWQiOiJ4nHVTTW/bMFxmve9XXHUwMDE47rVonVx1MDAxNN0ht36iPbSHZsBcdTAwMGXDXHUwMDBlqsXYRFx1MDAxNEmQ6CZZXHUwMDEwYD9jt/3F/YRRimvZTmtcdTAwMDNcdTAwMDb8SJGPj0+7L1mW09ZCPsty2JRCoXRinZ9cdTAwMDb8XHKcR6M5NI3/3jSujJk1kZ2dnyvDXHUwMDA3auNpdlFcdTAwMTTF4Vx1MDAxMChYgSbPaT/4P8t28ctcdTAwMTGU4ehVTIvAe1+CXHIldMNQcVZcdTAwMTRcdTAwMWSwXHUwMDFkXHUwMDAza5RUMzj52kdrwKqmI1joSoUuXHTx5MxcdTAwMTJujDIudD+ZQHhcdTAwMTOBV1EuK2dcdTAwMWEtu1x1MDAxY3JCeytcdTAwMWNcdTAwMGaW8lx1MDAxNqjUnLaxOmvDyuWjXHUwMDFl31ui01x1MDAxMf7ZKW5a1Vx1MDAxYXxcdTAwMTBv0qHGilx1MDAxMimoMOnNXHUwMDE1XHUwMDE42kdcdTAwMTl1/pk4ObGCxyC0bpTqYNRcdTAwMTI2YzCO2HZcdTAwMWJcdTAwMDQ8gFx1MDAxYzBIRjjCno0uh/Kiv2VcdTAwMGZQLLFcdTAwMTDKQ1x1MDAxMjY0vEv+XHUwMDE4NG2sXHUwMDE0NOqrUC/Heey55Vx1MDAwN7Wjh1jRf3///O6tyGia469AcFpcZtB7sUJcdTAwMTU0vVx1MDAxY5S4UliFOXNcdTAwMDWL3qp5WEL2elx1MDAxNyZjU7Tkelx1MDAwMjW4Y+GNw1xutVDfPqQnXHUwMDFhMi/gXHUwMDBmXHUwMDA0yTXQn1x1MDAxY1x1MDAxZTpDn00vY2DP37jrXFxYOyfWi6OH+8V+QDlcdTAwMWH1gFx1MDAxMdg0ZoSejIQ7LV7VWMf8XHJhfX1s/5NFfFri7Vxunlx1MDAxYUU451WXxD5cYvvcXHUwMDA1fvvIj+9cdTAwMDa00P4/o1sqkiJ9<!-- payload-end --></metadata><defs><style class="style-fonts">
+"<svg version="1.1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 36 36" width="36" height="36"><!-- svg-source:excalidraw --><metadata><!-- payload-type:application/vnd.excalidraw+json --><!-- payload-version:2 --><!-- payload-start -->eyJ2ZXJzaW9uIjoiMSIsImVuY29kaW5nIjoiYnN0cmluZyIsImNvbXByZXNzZWQiOnRydWUsImVuY29kZWQiOiJ4nHVTS27bMFx1MDAxMN33XHUwMDE0grItXHUwMDEy2UW68C7NXHUwMDA3zVwiXdRcdTAwMDW6KLpgxLE0ME1cdTAwMTLkKLZrXHUwMDE4yDG661x1MDAxNXOEXGZpVTTlRFx1MDAwMlxi8M3vzZvh7kNRlLS1UM6KXHUwMDEyNrVQKJ1Yl1x1MDAxZlx1MDAwM/5cdTAwMDTOo9Fsmsa7N52ro2dLZGdcdTAwMTdcdTAwMTfKcEBrPM0+VVV1XGJcdTAwMDJcdTAwMDUr0OTZ7Vx1MDAxN9+LYlx1MDAxN0+2oFxmoVfRLVx1MDAwMv/rXHUwMDEybCihXHUwMDFihqrhts1ua5TUMjL5PEAtYNNSjlx03SjIXHUwMDAyPTmzhGujjFx1MDAwYlx1MDAxNc8mXHUwMDEw/lT0UdTLxplOy8GHnNDeXG7HzSS/XHUwMDA1KjWnbczOerBa5ajGz57idIS/XHUwMDE3xUWbVoNcdTAwMGaCTVx1MDAwNtRYUSOF5idV6lwiMLT3Mmr7O3FyYlx1MDAwNfdBXFzdKTXAqCVsxmBssa+WXHUwMDE5PIDMXHUwMDE4pOGfYN+MrnN50d/w3CmmWFxi5SFcdFx1MDAxYlxu3qadyIp2VlxuXHUwMDFh1VWol2M/3rPlXHUwMDFiuePesKIv//4+XHUwMDFmjchomuOfQHBaZeidWKFcbppeZimuXHUwMDE0NqHPUsHiaNTcLCHv92AmY5O15nxcdTAwMDI1uFPhjcNcdTAwMDa1UD/epCc6Mt/BXHUwMDFmXGKS6+C4c/g6bPP59DJcdTAwMWH2fMZZl8LaObFebD28Kd5cdTAwMDeUo1ZcdTAwMGZcdTAwMTiBTW1G6MFIuNXiUY11LJ9cdTAwMTDWX07X/2xcdTAwMTG/nng/godOXHUwMDExznnUNfFcdTAwMWWEee5cdTAwMDK/feTHb1x1MDAwM3po/1xua2IoWiJ9<!-- payload-end --></metadata><defs><style class="style-fonts">
       </style></defs><rect x="0" y="0" width="36" height="36" fill="#ffffff"></rect><g transform="translate(10 10) rotate(0 8 8)" data-id="A"><text x="0" y="17.619999999999997" font-family="Excalifont, Xiaolai, sans-serif, Segoe UI Emoji" font-size="20px" fill="#1e1e1e" text-anchor="start" style="white-space: pre;" direction="ltr" dominant-baseline="alphabetic">😀</text></g></svg>"
 `;
 

packages/excalidraw/tests/__snapshots__/history.test.tsx.snap

@@ -98,7 +98,6 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -227,8 +226,8 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   "updated": 1,
   "version": 22,
   "width": "94.00000",
-  "x": "0.00000",
+  "x": 0,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -442,8 +441,8 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
             "startBinding": null,
             "version": 22,
             "width": "94.00000",
-            "x": "0.00000",
+            "x": 0,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "height": "105.58874",
@@ -618,8 +617,8 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
             "type": "arrow",
             "version": 4,
             "width": 100,
-            "x": "0.00000",
+            "x": 0,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -732,7 +731,6 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -855,7 +853,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   "version": 25,
   "width": 100,
   "x": 150,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -1005,7 +1003,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
             "version": 25,
             "width": 100,
             "x": 150,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "height": "0.01000",
@@ -1180,8 +1178,8 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
             "type": "arrow",
             "version": 4,
             "width": 100,
-            "x": "0.00000",
+            "x": 0,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -2277,7 +2275,6 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -2377,7 +2374,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   "endBinding": {
     "elementId": "id1",
     "fixedPoint": [
-      0,
+      "0.50010",
       "0.50010",
     ],
     "mode": "orbit",
@@ -2385,7 +2382,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   "fillStyle": "solid",
   "frameId": null,
   "groupIds": [],
-  "height": "439.20000",
+  "height": "399.26547",
   "id": "id4",
   "index": "a2",
   "isDeleted": false,
@@ -2399,8 +2396,8 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
       0,
     ],
     [
-      488,
+      "488.00000",
-      "-439.20000",
+      "-399.26547",
     ],
   ],
   "roughness": 1,
@@ -2422,9 +2419,9 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
   "type": "arrow",
   "updated": 1,
   "version": 11,
-  "width": 488,
+  "width": "488.00000",
   "x": 6,
-  "y": "-5.39000",
+  "y": "-4.89900",
 }
 `;
 
@@ -2545,7 +2542,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
             "endBinding": {
               "elementId": "id1",
               "fixedPoint": [
-                0,
+                "0.50010",
                 "0.50010",
               ],
               "mode": "orbit",
@@ -2553,7 +2550,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
             "fillStyle": "solid",
             "frameId": null,
             "groupIds": [],
-            "height": "439.20000",
+            "height": "399.26547",
             "index": "a2",
             "isDeleted": false,
             "link": null,
@@ -2565,8 +2562,8 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
                 0,
               ],
               [
-                488,
+                "488.00000",
-                "-439.20000",
+                "-399.26547",
               ],
             ],
             "roughness": 1,
@@ -2587,9 +2584,9 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
             "strokeWidth": 2,
             "type": "arrow",
             "version": 11,
-            "width": 488,
+            "width": "488.00000",
             "x": 6,
-            "y": "-5.39000",
+            "y": "-4.89900",
           },
           "inserted": {
             "isDeleted": true,
@@ -6288,7 +6285,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   "version": 3,
   "width": 10,
   "x": 10,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -6318,7 +6315,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   "version": 9,
   "width": 10,
   "x": 20,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -6400,7 +6397,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
             "version": 3,
             "width": 10,
             "x": 10,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -6455,7 +6452,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
             "version": 8,
             "width": 10,
             "x": 20,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -7355,7 +7352,6 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -7416,8 +7412,8 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   "updated": 1,
   "version": 7,
   "width": 10,
-  "x": "0.00000",
+  "x": 0,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -7491,8 +7487,8 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
             "type": "arrow",
             "version": 7,
             "width": 10,
-            "x": "0.00000",
+            "x": 0,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -7692,7 +7688,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
   "version": 9,
   "width": 10,
   "x": 10,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -7745,7 +7741,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
             "version": 8,
             "width": 10,
             "x": 10,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -9577,7 +9573,7 @@ exports[`history > multiplayer undo/redo > should not override remote changes on
   "version": 7,
   "width": 10,
   "x": 10,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -9687,7 +9683,7 @@ exports[`history > multiplayer undo/redo > should not override remote changes on
             "version": 3,
             "width": 10,
             "x": 10,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -9842,7 +9838,7 @@ exports[`history > multiplayer undo/redo > should not override remote changes on
   "version": 7,
   "width": 10,
   "x": 10,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -9894,7 +9890,7 @@ exports[`history > multiplayer undo/redo > should not override remote changes on
             "version": 3,
             "width": 10,
             "x": 10,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -10327,7 +10323,6 @@ exports[`history > multiplayer undo/redo > should override remotely added points
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -10400,8 +10395,8 @@ exports[`history > multiplayer undo/redo > should override remotely added points
   "updated": 1,
   "version": 10,
   "width": 30,
-  "x": "0.00000",
+  "x": 0,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -10474,8 +10469,8 @@ exports[`history > multiplayer undo/redo > should override remotely added points
             "type": "arrow",
             "version": 9,
             "width": 10,
-            "x": "0.00000",
+            "x": 0,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -10687,7 +10682,7 @@ exports[`history > multiplayer undo/redo > should redistribute deltas when eleme
   "version": 9,
   "width": 10,
   "x": 10,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -10739,7 +10734,7 @@ exports[`history > multiplayer undo/redo > should redistribute deltas when eleme
             "version": 8,
             "width": 10,
             "x": 10,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -11850,7 +11845,7 @@ exports[`history > multiplayer undo/redo > should update history entries after r
   "version": 13,
   "width": 10,
   "x": 10,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -11955,7 +11950,7 @@ exports[`history > multiplayer undo/redo > should update history entries after r
             "version": 3,
             "width": 10,
             "x": 10,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -12137,8 +12132,8 @@ exports[`history > singleplayer undo/redo > remounting undo/redo buttons should
   "updated": 1,
   "version": 4,
   "width": 10,
-  "x": "0.00000",
+  "x": 0,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -12190,8 +12185,8 @@ exports[`history > singleplayer undo/redo > remounting undo/redo buttons should
             "type": "rectangle",
             "version": 3,
             "width": 10,
-            "x": "0.00000",
+            "x": 0,
-            "y": "0.00000",
+            "y": 0,
           },
         },
       },
@@ -12345,7 +12340,7 @@ exports[`history > singleplayer undo/redo > should clear the redo stack on eleme
   "version": 4,
   "width": 10,
   "x": 10,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -12375,7 +12370,7 @@ exports[`history > singleplayer undo/redo > should clear the redo stack on eleme
   "version": 3,
   "width": 10,
   "x": 20,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -12427,7 +12422,7 @@ exports[`history > singleplayer undo/redo > should clear the redo stack on eleme
             "version": 3,
             "width": 10,
             "x": 20,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -12975,8 +12970,8 @@ exports[`history > singleplayer undo/redo > should create new history entry on e
   "updated": 1,
   "version": 4,
   "width": 560,
-  "x": "0.00000",
+  "x": 0,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -13027,8 +13022,8 @@ exports[`history > singleplayer undo/redo > should create new history entry on e
             "type": "embeddable",
             "version": 4,
             "width": 560,
-            "x": "0.00000",
+            "x": 0,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -13182,8 +13177,8 @@ exports[`history > singleplayer undo/redo > should create new history entry on e
   "updated": 1,
   "version": 4,
   "width": 560,
-  "x": "0.00000",
+  "x": 0,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -13234,8 +13229,8 @@ exports[`history > singleplayer undo/redo > should create new history entry on e
             "type": "embeddable",
             "version": 4,
             "width": 560,
-            "x": "0.00000",
+            "x": 0,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -14263,8 +14258,8 @@ exports[`history > singleplayer undo/redo > should disable undo/redo buttons whe
   "updated": 1,
   "version": 5,
   "width": 10,
-  "x": "0.00000",
+  "x": 0,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -14315,8 +14310,8 @@ exports[`history > singleplayer undo/redo > should disable undo/redo buttons whe
             "type": "rectangle",
             "version": 5,
             "width": 10,
-            "x": "0.00000",
+            "x": 0,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -14500,8 +14495,8 @@ exports[`history > singleplayer undo/redo > should end up with no history entry
   "updated": 1,
   "version": 5,
   "width": 10,
-  "x": "0.00000",
+  "x": 0,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -14552,8 +14547,8 @@ exports[`history > singleplayer undo/redo > should end up with no history entry
             "type": "rectangle",
             "version": 5,
             "width": 10,
-            "x": "0.00000",
+            "x": 0,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -14708,7 +14703,7 @@ exports[`history > singleplayer undo/redo > should iterate through the history w
   "version": 4,
   "width": 10,
   "x": 10,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -14801,7 +14796,7 @@ exports[`history > singleplayer undo/redo > should iterate through the history w
             "version": 3,
             "width": 10,
             "x": 10,
-            "y": "0.00000",
+            "y": 0,
           },
         },
       },
@@ -14955,7 +14950,7 @@ exports[`history > singleplayer undo/redo > should not clear the redo stack on s
   "version": 3,
   "width": 10,
   "x": 10,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -14985,7 +14980,7 @@ exports[`history > singleplayer undo/redo > should not clear the redo stack on s
   "version": 5,
   "width": 10,
   "x": 20,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -15037,7 +15032,7 @@ exports[`history > singleplayer undo/redo > should not clear the redo stack on s
             "version": 3,
             "width": 10,
             "x": 10,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -15131,7 +15126,7 @@ exports[`history > singleplayer undo/redo > should not clear the redo stack on s
             "version": 5,
             "width": 10,
             "x": 20,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -16158,7 +16153,7 @@ exports[`history > singleplayer undo/redo > should not override appstate changes
   "version": 11,
   "width": 10,
   "x": 10,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -16283,7 +16278,7 @@ exports[`history > singleplayer undo/redo > should not override appstate changes
             "version": 3,
             "width": 10,
             "x": 10,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -16558,7 +16553,6 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -17307,7 +17301,6 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -17954,7 +17947,6 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -18599,7 +18591,6 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -19352,7 +19343,6 @@ exports[`history > singleplayer undo/redo > should support bidirectional binding
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -20195,7 +20185,7 @@ exports[`history > singleplayer undo/redo > should support changes in elements'
   "version": 7,
   "width": 10,
   "x": 10,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -20277,7 +20267,7 @@ exports[`history > singleplayer undo/redo > should support changes in elements'
             "version": 3,
             "width": 10,
             "x": 10,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -21153,7 +21143,7 @@ exports[`history > singleplayer undo/redo > should support element creation, del
   "version": 5,
   "width": 10,
   "x": 10,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -21265,7 +21255,7 @@ exports[`history > singleplayer undo/redo > should support element creation, del
             "version": 5,
             "width": 10,
             "x": 10,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -21570,7 +21560,6 @@ exports[`history > singleplayer undo/redo > should support linear element creati
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -21635,8 +21624,8 @@ exports[`history > singleplayer undo/redo > should support linear element creati
   "updated": 1,
   "version": 12,
   "width": 20,
-  "x": "0.00000",
+  "x": 0,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 
@@ -21709,8 +21698,8 @@ exports[`history > singleplayer undo/redo > should support linear element creati
             "type": "arrow",
             "version": 10,
             "width": 10,
-            "x": "0.00000",
+            "x": 0,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,

packages/excalidraw/tests/__snapshots__/move.test.tsx.snap

@@ -128,8 +128,8 @@ exports[`move element > rectangles with binding arrow 5`] = `
   "version": 4,
   "versionNonce": 760410951,
   "width": 100,
-  "x": "0.00000",
+  "x": 0,
-  "y": "0.00000",
+  "y": 0,
 }
 `;
 

packages/excalidraw/tests/__snapshots__/regressionTests.test.tsx.snap

@@ -171,8 +171,8 @@ exports[`given element A and group of elements B and given both are selected whe
             "type": "rectangle",
             "version": 3,
             "width": 10,
-            "x": "0.00000",
+            "x": 0,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -225,7 +225,7 @@ exports[`given element A and group of elements B and given both are selected whe
             "type": "rectangle",
             "version": 3,
             "width": 10,
-            "x": "0.00000",
+            "x": 0,
             "y": 30,
           },
           "inserted": {
@@ -279,7 +279,7 @@ exports[`given element A and group of elements B and given both are selected whe
             "type": "rectangle",
             "version": 3,
             "width": 10,
-            "x": "0.00000",
+            "x": 0,
             "y": 60,
           },
           "inserted": {
@@ -599,8 +599,8 @@ exports[`given element A and group of elements B and given both are selected whe
             "type": "rectangle",
             "version": 3,
             "width": 100,
-            "x": "0.00000",
+            "x": 0,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -1006,8 +1006,8 @@ exports[`regression tests > Cmd/Ctrl-click exclusively select element under poin
             "type": "rectangle",
             "version": 3,
             "width": 10,
-            "x": "0.00000",
+            "x": 0,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -1061,7 +1061,7 @@ exports[`regression tests > Cmd/Ctrl-click exclusively select element under poin
             "version": 3,
             "width": 10,
             "x": 30,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -1230,7 +1230,7 @@ exports[`regression tests > Cmd/Ctrl-click exclusively select element under poin
             "version": 3,
             "width": 10,
             "x": 60,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -1572,8 +1572,8 @@ exports[`regression tests > Drags selected element when hitting only bounding bo
             "type": "ellipse",
             "version": 3,
             "width": 10,
-            "x": "0.00000",
+            "x": 0,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -1604,8 +1604,8 @@ exports[`regression tests > Drags selected element when hitting only bounding bo
           },
           "inserted": {
             "version": 3,
-            "x": "0.00000",
+            "x": 0,
-            "y": "0.00000",
+            "y": 0,
           },
         },
       },
@@ -4220,7 +4220,7 @@ exports[`regression tests > deleting last but one element in editing group shoul
             "version": 3,
             "width": 10,
             "x": 10,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -4274,7 +4274,7 @@ exports[`regression tests > deleting last but one element in editing group shoul
             "version": 3,
             "width": 10,
             "x": 50,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -4682,8 +4682,8 @@ exports[`regression tests > deselects group of selected elements on pointer down
             "type": "rectangle",
             "version": 3,
             "width": 10,
-            "x": "0.00000",
+            "x": 0,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -4937,8 +4937,8 @@ exports[`regression tests > deselects group of selected elements on pointer up w
             "type": "rectangle",
             "version": 3,
             "width": 10,
-            "x": "0.00000",
+            "x": 0,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -5240,8 +5240,8 @@ exports[`regression tests > deselects selected element on pointer down when poin
             "type": "rectangle",
             "version": 3,
             "width": 10,
-            "x": "0.00000",
+            "x": 0,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -5420,8 +5420,8 @@ exports[`regression tests > deselects selected element, on pointer up, when clic
             "type": "ellipse",
             "version": 3,
             "width": 100,
-            "x": "0.00000",
+            "x": 0,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -6017,8 +6017,8 @@ exports[`regression tests > drags selected elements from point inside common bou
             "type": "rectangle",
             "version": 3,
             "width": 10,
-            "x": "0.00000",
+            "x": 0,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -6123,8 +6123,8 @@ exports[`regression tests > drags selected elements from point inside common bou
           },
           "inserted": {
             "version": 3,
-            "x": "0.00000",
+            "x": 0,
-            "y": "0.00000",
+            "y": 0,
           },
         },
         "id3": {
@@ -6243,7 +6243,6 @@ exports[`regression tests > draw every type of shape > [end of test] appState 1`
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -6814,12 +6813,12 @@ exports[`regression tests > draw every type of shape > [end of test] undo stack
                 10,
               ],
               [
-                "80.00000",
+                80,
                 20,
               ],
             ],
             "version": 5,
-            "width": "80.00000",
+            "width": 80,
           },
           "inserted": {
             "height": 10,
@@ -7102,8 +7101,8 @@ exports[`regression tests > given a group of selected elements with an element t
             "type": "rectangle",
             "version": 3,
             "width": 10,
-            "x": "0.00000",
+            "x": 0,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -7436,8 +7435,8 @@ exports[`regression tests > given a selected element A and a not selected elemen
             "type": "rectangle",
             "version": 3,
             "width": 1000,
-            "x": "0.00000",
+            "x": 0,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -8692,7 +8691,6 @@ exports[`regression tests > key 5 selects arrow tool > [end of test] appState 1`
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -8925,7 +8923,6 @@ exports[`regression tests > key 6 selects line tool > [end of test] appState 1`]
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -9348,7 +9345,6 @@ exports[`regression tests > key a selects arrow tool > [end of test] appState 1`
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -9761,7 +9757,6 @@ exports[`regression tests > key l selects line tool > [end of test] appState 1`]
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -11513,8 +11508,8 @@ exports[`regression tests > shift click on selected element should deselect it o
             "type": "rectangle",
             "version": 3,
             "width": 10,
-            "x": "0.00000",
+            "x": 0,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -12472,7 +12467,7 @@ exports[`regression tests > single-clicking on a subgroup of a selected group sh
             "version": 3,
             "width": 10,
             "x": 10,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -12526,7 +12521,7 @@ exports[`regression tests > single-clicking on a subgroup of a selected group sh
             "version": 3,
             "width": 10,
             "x": 50,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -13229,8 +13224,8 @@ exports[`regression tests > supports nested groups > [end of test] undo stack 1`
             "type": "rectangle",
             "version": 3,
             "width": 50,
-            "x": "0.00000",
+            "x": 0,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -13817,8 +13812,8 @@ exports[`regression tests > switches from group of selected elements to another
     "version": 1,
     "versionNonce": 0,
     "width": 0,
-    "x": "0.00000",
+    "x": 0,
-    "y": "0.00000",
+    "y": 0,
   },
   "shouldCacheIgnoreZoom": false,
   "showHyperlinkPopup": false,
@@ -13889,8 +13884,8 @@ exports[`regression tests > switches from group of selected elements to another
             "type": "rectangle",
             "version": 3,
             "width": 10,
-            "x": "0.00000",
+            "x": 0,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -14155,8 +14150,8 @@ exports[`regression tests > switches selected element on pointer down > [end of
     "version": 1,
     "versionNonce": 0,
     "width": 0,
-    "x": "0.00000",
+    "x": 0,
-    "y": "0.00000",
+    "y": 0,
   },
   "shouldCacheIgnoreZoom": false,
   "showHyperlinkPopup": false,
@@ -14227,8 +14222,8 @@ exports[`regression tests > switches selected element on pointer down > [end of
             "type": "rectangle",
             "version": 3,
             "width": 10,
-            "x": "0.00000",
+            "x": 0,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,
@@ -14519,7 +14514,6 @@ exports[`regression tests > undo/redo drawing an element > [end of test] appStat
   "showHyperlinkPopup": false,
   "showWelcomeScreen": true,
   "snapLines": [],
-  "startBoundElement": null,
   "stats": {
     "open": false,
     "panels": 3,
@@ -14583,12 +14577,12 @@ exports[`regression tests > undo/redo drawing an element > [end of test] redo st
                 10,
               ],
               [
-                "100.00000",
+                100,
                 20,
               ],
             ],
             "version": 5,
-            "width": "100.00000",
+            "width": 100,
           },
         },
       },
@@ -14770,7 +14764,7 @@ exports[`regression tests > undo/redo drawing an element > [end of test] undo st
             "version": 5,
             "width": 30,
             "x": 40,
-            "y": "0.00000",
+            "y": 0,
           },
           "inserted": {
             "isDeleted": true,

packages/excalidraw/tests/convertElementType.test.tsx

@@ -1,46 +0,0 @@
-import { ROUNDNESS } from "@excalidraw/common";
-
-import { convertElementTypes } from "../components/ConvertElementTypePopup";
-import { Excalidraw } from "../index";
-
-import { API } from "./helpers/api";
-import { act, render } from "./test-utils";
-
-const { h } = window;
-
-describe("convert element type", () => {
-  beforeEach(async () => {
-    await render(<Excalidraw handleKeyboardGlobally={true} />);
-  });
-
-  // #9662
-  it("recalculates roundness type when switching between generic shapes", () => {
-    const rectangle = API.createElement({
-      type: "rectangle",
-      roundness: { type: ROUNDNESS.ADAPTIVE_RADIUS }, // Dooesn't matter as long as it is set
-    });
-
-    API.setElements([rectangle]);
-    API.setSelectedElements([rectangle]);
-
-    act(() => {
-      convertElementTypes(h.app, {
-        conversionType: "generic",
-        nextType: "diamond",
-      });
-    });
-
-    expect(h.elements[0].type).toBe("diamond");
-    expect(h.elements[0].roundness?.type).toBe(ROUNDNESS.PROPORTIONAL_RADIUS);
-
-    act(() => {
-      convertElementTypes(h.app, {
-        conversionType: "generic",
-        nextType: "rectangle",
-      });
-    });
-
-    expect(h.elements[0].type).toBe("rectangle");
-    expect(h.elements[0].roundness?.type).toBe(ROUNDNESS.ADAPTIVE_RADIUS);
-  });
-});

packages/excalidraw/tests/data/__snapshots__/restore.test.ts.snap

@@ -154,7 +154,7 @@ exports[`restoreElements > should restore correctly with rectangle, ellipse and
   "opacity": 10,
   "roughness": 2,
   "roundness": {
-    "type": 2,
+    "type": 3,
   },
   "seed": Any<Number>,
   "strokeColor": "red",
@@ -192,7 +192,7 @@ exports[`restoreElements > should restore correctly with rectangle, ellipse and
   "opacity": 10,
   "roughness": 2,
   "roundness": {
-    "type": 2,
+    "type": 3,
   },
   "seed": Any<Number>,
   "strokeColor": "red",

packages/excalidraw/tests/excalidraw.test.tsx

@@ -1,4 +1,5 @@
 import { queryByText, queryByTestId } from "@testing-library/react";
+import React from "react";
 import { useMemo } from "react";
 
 import { THEME } from "@excalidraw/common";
@@ -432,7 +433,7 @@ describe("<Excalidraw/>", () => {
         const customMenu = useMemo(() => {
           return (
             <MainMenu>
-              <MainMenu.DefaultItems.ToggleTheme allowSystemTheme={false} />
+              <MainMenu.DefaultItems.ToggleTheme />
             </MainMenu>
           );
         }, []);
@@ -456,32 +457,5 @@ describe("<Excalidraw/>", () => {
         queryByTestId(container, "toggle-dark-mode")?.textContent,
       ).toContain(t("buttons.lightMode"));
     });
-
-    it("should show theme toggle when the theme prop and onThemeChange are defined", async () => {
-      const onThemeChange = vi.fn();
-      const { container } = await render(
-        <Excalidraw theme={THEME.DARK} onThemeChange={onThemeChange} />,
-      );
-
-      expect(h.state.theme).toBe(THEME.DARK);
-      //open menu
-      toggleMenu(container);
-      const darkModeToggle = queryByTestId(container, "toggle-dark-mode");
-      expect(darkModeToggle).toBeTruthy();
-    });
-
-    it("should call onThemeChange instead of mutating theme when defined", async () => {
-      const onThemeChange = vi.fn();
-      const { container } = await render(
-        <Excalidraw theme={THEME.LIGHT} onThemeChange={onThemeChange} />,
-      );
-
-      //open menu
-      toggleMenu(container);
-      fireEvent.click(queryByTestId(container, "toggle-dark-mode")!);
-
-      expect(onThemeChange).toHaveBeenCalledWith(THEME.DARK);
-      expect(h.state.theme).toBe(THEME.LIGHT);
-    });
   });
 });

packages/excalidraw/tests/helpers/api.ts

@@ -19,7 +19,8 @@ import {
   newTextElement,
 } from "@excalidraw/element";
 
-import { isUsingAdaptiveRadius, getSelectedElements } from "@excalidraw/element";
+import { isLinearElementType } from "@excalidraw/element";
+import { getSelectedElements } from "@excalidraw/element";
 import { selectGroupsForSelectedElements } from "@excalidraw/element";
 
 import { FONT_SIZES } from "@excalidraw/common";
@@ -266,9 +267,9 @@ export class API {
           : rest.roundness
       )
         ? {
-            type: isUsingAdaptiveRadius(type)
+            type: isLinearElementType(type)
-                    ? ROUNDNESS.ADAPTIVE_RADIUS
+              ? ROUNDNESS.PROPORTIONAL_RADIUS
-                    : ROUNDNESS.PROPORTIONAL_RADIUS,
+              : ROUNDNESS.ADAPTIVE_RADIUS,
           }
         : null,
       roughness: rest.roughness ?? appState.currentItemRoughness,

packages/excalidraw/tests/history.test.tsx

@@ -5132,7 +5132,7 @@ describe("history", () => {
               }),
               endBinding: expect.objectContaining({
                 elementId: rect2.id,
-                fixedPoint: expect.arrayContaining([0, 0.5001]),
+                fixedPoint: expect.arrayContaining([0.5001, 0.5001]),
               }),
               isDeleted: true,
             }),

packages/excalidraw/tests/move.test.tsx

@@ -16,6 +16,8 @@ import * as StaticScene from "../renderer/staticScene";
 import { UI, Pointer, Keyboard } from "./helpers/ui";
 import { render, fireEvent, act, unmountComponent } from "./test-utils";
 
+import type { Zoom } from "../types";
+
 unmountComponent();
 
 const renderInteractiveScene = vi.spyOn(
@@ -88,6 +90,7 @@ describe("move element", () => {
         "orbit",
         "start",
         h.app.scene,
+        { value: 1 } as Zoom,
       );
       bindBindingElement(
         arrow.get() as NonDeleted<ExcalidrawArrowElement>,
@@ -95,6 +98,7 @@ describe("move element", () => {
         "orbit",
         "end",
         h.app.scene,
+        { value: 1 } as Zoom,
       );
     });
 
@@ -108,13 +112,16 @@ describe("move element", () => {
     expect(h.state.selectionElement).toBeNull();
     expect(h.elements.length).toEqual(3);
     expect(h.state.selectedElementIds[rectB.id]).toBeTruthy();
-    expect([[rectA.x, rectA.y]]).toCloselyEqualPoints([[0, 0]]);
+    expect([rectA.x, rectA.y]).toEqual([0, 0]);
-    expect([[rectB.x, rectB.y]]).toCloselyEqualPoints([[200, 0]]);
+    expect([rectB.x, rectB.y]).toEqual([200, 0]);
     expect([[arrow.x, arrow.y]]).toCloselyEqualPoints(
-      [[106.00000000000001, 55.6867741935484]],
+      [[106, 56.011199999998695]],
+      0,
+    );
+    expect([[arrow.width, arrow.height]]).toCloselyEqualPoints(
+      [[88, 88.01760000000121]],
       0,
     );
-    expect([[arrow.width, arrow.height]]).toCloselyEqualPoints([[88, 88]], 0);
 
     renderInteractiveScene.mockClear();
     renderStaticScene.mockClear();
@@ -130,13 +137,16 @@ describe("move element", () => {
     expect(h.state.selectionElement).toBeNull();
     expect(h.elements.length).toEqual(3);
     expect(h.state.selectedElementIds[rectB.id]).toBeTruthy();
-    expect([[rectA.x, rectA.y]]).toCloselyEqualPoints([[0, 0]]);
+    expect([rectA.x, rectA.y]).toEqual([0, 0]);
-    expect([[rectB.x, rectB.y]]).toCloselyEqualPoints([[201, 2]]);
+    expect([rectB.x, rectB.y]).toEqual([201, 2]);
     expect([[arrow.x, arrow.y]]).toCloselyEqualPoints(
-      [[106, 55.6867741935484]],
+      [[106, 56.011199999998695]],
+      0,
+    );
+    expect([[arrow.width, arrow.height]]).toCloselyEqualPoints(
+      [[89, 90.01760000000121]],
       0,
     );
-    expect([[arrow.width, arrow.height]]).toCloselyEqualPoints([[89, 90]], 0);
 
     h.elements.forEach((element) => expect(element).toMatchSnapshot());
   });

packages/excalidraw/tests/scene/__snapshots__/export.test.ts.snap

@@ -240,7 +240,7 @@ exports[`exportToSvg > with elements that have a link 1`] = `
 `;
 
 exports[`exportToSvg > with exportEmbedScene 1`] = `
-"<!-- svg-source:excalidraw --><metadata><!-- payload-type:application/vnd.excalidraw+json --><!-- payload-version:2 --><!-- payload-start -->eyJ2ZXJzaW9uIjoiMSIsImVuY29kaW5nIjoiYnN0cmluZyIsImNvbXByZXNzZWQiOnRydWUsImVuY29kZWQiOiJ4nO1WW2vbMFx1MDAxOH3vrzDaa2llJ2myvGXrLoWxwTIorPRBtT7bwrLkSnIuXHUwMDBi+e+V5MVy0rL3ZHHAoPNddHR0PpzNRVx1MDAxNCGzrlx1MDAwMU0jXHUwMDA0q5RwRlx1MDAxNVmiS4cvQGkmhVxyJX6tZaNSn1lcdTAwMThTT6+vubRcdTAwMDWF1GY6wFx1MDAxOLdFwKFcdTAwMDJhtE17sOso2vi3jTDqSlx1MDAxN/fq+ccsK5mgyXNajb/dzr789qU+aWVzhvHwXG7jXHUwMDBlWjtcdTAwMDKDcVx1MDAxZloyalxuXHUwMDBix1x1MDAxOPfhXHUwMDAyWF6Y1zhcdTAwMTE5d7xcdTAwMDOijZIlfJRcXCpH6lx1MDAxZPZPoPFE0jJXslx1MDAxMTTkxCNCnrKQkzHO52bNW0VIWjRcbtDBXHUwMDBl9zuiXHUwMDA3eFenpVU8VNkt80KA1ns1siYpM+v2YFx1MDAxZOr41XfUK/1cdTAwMThYKVLBnZNaNJz3XHUwMDFiXHUwMDBi+rfxXsDeXHUwMDAzONFcdTAwMTHpXHUwMDFkX1x1MDAwM1C/2zC+XHUwMDE5jd/jSVx1MDAxN1x0nohcdTAwMTN8iH6XwvsjjidcdTAwMTOMh8n4Jmyjb60zjG+bXHUwMDExriFI7Zh9XG6u2WPX1JS0RUFccs5EeZhnnVi+0XvnbMpIJVx1MDAwNUVcdTAwMWXfXp59eUy+jE/Xl8A5qzVcdTAwMWOfL2Nwv//bl8np+tLAyvQuTlxuM2d/XFykd1x1MDAwNod+Jlx1MDAxNeNO51Fo4UptXHUwMDBiqVjOXHUwMDA04dF+r1x1MDAxZPzr32luNeMsd8IhXHUwMDBlWS9ktTPM/u/owkbWIZpaVoRcdFCvr9TqXHUwMDAwXzvHXyWBM2mM/Fx0uj2iV+Q8kEc4kIPzQHZcdTAwMDNcdTAwMTmIn9JA2rc3XG5cInU9N1ZYXHUwMDFibsdcdTAwMTMtXHUwMDE4LD+8YfrMP+5cdTAwMGLrx9mZXHUwMDFl3C1ttlx1MDAxN9tcdTAwMTcwdk6zIn0=<!-- payload-end --></metadata><defs><style class="style-fonts">
+"<!-- svg-source:excalidraw --><metadata><!-- payload-type:application/vnd.excalidraw+json --><!-- payload-version:2 --><!-- payload-start -->eyJ2ZXJzaW9uIjoiMSIsImVuY29kaW5nIjoiYnN0cmluZyIsImNvbXByZXNzZWQiOnRydWUsImVuY29kZWQiOiJ4nO1WW2vbMFx1MDAxOH3vrzDaa1llJ2nSvGXrLoWxwTIorOxBtT7bwrLkSnIuXHUwMDBi+e+T5MVyvLLnNYtcdTAwMDOG7350dD6c3UVcdTAwMTQhs61cdTAwMDHNI1x1MDAwNJuUcEZcdTAwMTVZo0vnX4HSTFxuXHUwMDFiSrytZaNSn1lcdTAwMThTz6+uuLRcdTAwMDWF1GY+wlx1MDAxOLdFwKFcdTAwMDJhtE17sHZcdTAwMTTt/NtGXHUwMDE4daWre/X0ZZGVTNDkKa2mn25cdTAwMTdcdTAwMWa++1KftLE543jc2Vs3fTTt7DWjprC+XHUwMDE4485XXHUwMDAwy1x1MDAwYjNwXHUwMDEykXOHNXi0UbKEt5JL5YC8wv5cdKNcdTAwMWZJWuZKNoKGnHhCyGNcdTAwMTZyMsb50mx5y1x1MDAwMkmLRlx1MDAwMVx1MDAxYUy4P0BcdTAwMWP4uzotLcuhyo7MXHUwMDBiXHUwMDAxWlx1MDAxZtXImqTMbFx1MDAwN6dy+Oo76tn9XHUwMDExUClSwZ2jVzSc91x1MDAxYlx1MDAwYvq78VHAclx1MDAwZo5oRHrH11x1MDAwMNRPXHUwMDFix9eT6VxynnWRoIM4wUPvZym8JuJ4NsN4nEyvw1x1MDAxOH1r1WB824xwXHKBaofsXVDKXHUwMDExuqampC1cbmxwJsphnlVf+Uzvg5opI5VcdTAwMTRcdTAwMTR5//7yrMV/XYvx6WpcdTAwMTE4Z7WGl6HFXHUwMDE43O//1mJyulo0sDG9i5PCLNlPXHUwMDE36Z3Bed+TinHH8yS0cKW2hVQsZ4Lw6LjXwf3t72nOWnCWO+JcdTAwMTCHrFx1MDAxN7LcXHUwMDE5Zv9TdGEj61x1MDAxME0tKsJcdTAwMDSoP6/U8lx1MDAwMFx1MDAxZju5v05cdTAwMDJm0lx1MDAxOPlcdTAwMTV0e0TPyHlcdF/IXHUwMDEyjs5L2C1hXHUwMDAwfkpLaN9eKIjU9dJYYm24XUm0YrB+84zoM/+4L6lfYSd6cLe021/sf1x1MDAwMVSoRdMifQ==<!-- payload-end --></metadata><defs><style class="style-fonts">
       @font-face { font-family: Excalifont; src: url(data:font/woff2;base64,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); }
       @font-face { font-family: Excalifont; src: url(data:font/woff2;base64,d09GMgABAAAAAAHcAA0AAAAAA9gAAAGMAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGx4cNAZgAAQRCAoAKgsEAAE2AiQDBAQgBYMYByAbHQPIrgp4MjSeIQLqpl4jnPFQwveqm205gmrZevZ2/8kKGaJ6ictBuCwMMnsKo8hC4RwaLBrJ7dXaFrFk0Re1e/Dk3t9wCUVrYAiZkgiZ5rGDVFdY04wBF4APOCzXHr/ljrNIDqLAY/slkQf0SyjxLNBaAq8Z1AJqYW5j0GjbckRLQhoJCgwYoyfY3q33QS5DrSAwYB4hFruNve4WoN2On4P29GEFWsC+nVM/UvSlVwIcsWycI/5gbqfUhE/9Q2P7UppTOAVeIR4TYIocELVKIEACZJgXCJ5GXl0o+esbFP3g+763DcDPx6/60MrnBaBPAsGPUDRC/8+FGIqGUSBA+NIJOwTWe13HRCIrgEvfRhj1RjLiE42eG7I5DIpVNuqkNNhxwaItTI2srRz4dfHGjhZoO0O8nb2pilFYQKhenFaycLUxsYcoAQRyoRBEnPvcgfysPq+npClt8UxLyvHWjaudqbGJA+TCckNECBGBGFforuTs0M4CUMbCAvp+P4in4o864XECREBtFQAAAAA=); }
       @font-face { font-family: Nunito; src: url(data:font/woff2;base64,d09GMgABAAAAAAIsAA4AAAAABLQAAAHYAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGx4cLgZgP1NUQVREAAQRCAoAKgsEAAE2AiQDBAQgBYQkByAb5wPIrgp4Mt6IIcJZFNCfWmZY6KzqazTt6AiVHCFawzJ7V0CQBKoSQQEpFKrCVxiSFbqqqsaTevKs/q7s6uBYmujMyA9wxb6a7XnEOcNnDLgG4nW8PoPzHzYpS2uqp51pL3eB/xZoxIllCQc80B9o4j/4xMbxQB+j+SC3hsm6JmI8RMaHj+aJApW6ZbkXlg4vXSE5FECg0og6LzxP9pOarug4tF1RLpbHeZqLX0pIt2mfy3pNG6eyGaRIjrnrr/gv2c//yGdjpJ/7DuJLin5eIZRLaObBMM/NpYpuXJ8z3SE088mEFANcCARESfwChCioAwESsVxBgeyxp6+vZ3Xzv8uz7Ae8tRk+p6RUTPOR7BmlEgh+STsAimNuKibilyluhBNe5/wCACSBKrcykVfgyb+RYcK/TGq9yMyCt3bOskSnR1FqTLMSVBsMGLQVltDKKw2IYA+wcGxHJCINY9mDOCaN4IZEo1ChY4xNg8DaB0RxDqnbMNjXJJRzF9iInqahtm67M8dOHFvXaYbn+wrGxKG3YZI+2V4CW58ovdfV1tFHXFJJiPH7T1FAJxEgYo5BKkA5iDIVQluOqZYWhQapGF6TAFhaFAAoTBIZsCFHi/0oV3gpVKwbAA==); }

packages/excalidraw/tests/scene/export.test.ts

@@ -6,16 +6,12 @@ import {
   FRAME_STYLE,
 } from "@excalidraw/common";
 
-import { pointFrom } from "@excalidraw/math";
-
 import type {
   ExcalidrawTextElement,
   FractionalIndex,
   NonDeletedExcalidrawElement,
 } from "@excalidraw/element/types";
 
-import type { LocalPoint } from "@excalidraw/math";
-
 import { prepareElementsForExport } from "../../data";
 import * as exportUtils from "../../scene/export";
 import {
@@ -196,45 +192,6 @@ describe("exportToSvg", () => {
     );
     expect(svgElement.innerHTML).toMatchSnapshot();
   });
-
-  // #11439: a perfectly horizontal/vertical arrow has a zero-size bounding box.
-  // The bound-text "gap" mask must use userSpaceOnUse units, otherwise its
-  // objectBoundingBox region collapses to zero area and the whole arrow line
-  // disappears from the SVG export (only the label remains).
-  it("keeps a horizontal arrow with a bound label visible (#11439)", async () => {
-    const arrow = API.createElement({
-      type: "arrow",
-      id: "arrow-11439",
-      width: 200,
-      height: 0,
-      points: [pointFrom<LocalPoint>(0, 0), pointFrom<LocalPoint>(200, 0)],
-      boundElements: [{ type: "text", id: "label-11439" }],
-    });
-    const label = API.createElement({
-      type: "text",
-      id: "label-11439",
-      text: "label",
-      width: 50,
-      height: 20,
-      containerId: "arrow-11439",
-    });
-
-    const svgElement = await exportUtils.exportToSvg(
-      [arrow, label] as NonDeletedExcalidrawElement[],
-      DEFAULT_OPTIONS,
-      null,
-    );
-
-    const mask = svgElement.querySelector("mask");
-    expect(mask).not.toBeNull();
-    expect(mask?.getAttribute("maskUnits")).toBe("userSpaceOnUse");
-    // a degenerate (objectBoundingBox) region would be zero-area here
-    expect(Number(mask?.getAttribute("width"))).toBeGreaterThan(0);
-    expect(Number(mask?.getAttribute("height"))).toBeGreaterThan(0);
-
-    // the masked arrow group still renders its line (not clipped away)
-    expect(svgElement.querySelector("g[mask] path")).not.toBeNull();
-  });
 });
 
 describe("exporting frames", () => {

packages/excalidraw/types.ts

@@ -573,7 +573,6 @@ export interface ExcalidrawProps {
     appState: AppState,
     files: BinaryFiles,
   ) => void;
-  onThemeChange?: (theme: Theme | "system") => void;
   /**
    * note: only subscribes if the props.onIncrement is defined on initial render
    */
@@ -751,11 +750,6 @@ export type CanvasActions = Partial<{
   export: false | ExportOpts;
   loadScene: boolean;
   saveToActiveFile: boolean;
-  /**
-   * defaults to true if `props.theme` is omitted or `props.onThemeChange`
-   * is supplied (at which point the theme is considered as host-app controlled),
-   * else default to false
-   * */
   toggleTheme: boolean | null;
   saveAsImage: boolean;
 }>;

packages/excalidraw/wysiwyg/textWysiwyg.tsx

@@ -392,10 +392,10 @@ export const textWysiwyg = ({
         ),
         textAlign,
         verticalAlign,
-        color: applyDarkModeFilter(
+        color:
-          updatedTextElement.strokeColor,
+          appState.theme === THEME.DARK
-          appState.theme === THEME.DARK,
+            ? applyDarkModeFilter(updatedTextElement.strokeColor)
-        ),
+            : updatedTextElement.strokeColor,
         opacity: updatedTextElement.opacity / 100,
         maxHeight: `${editorMaxHeight}px`,
       });

packages/utils/src/bbox.ts

@@ -0,0 +1,73 @@
+import {
+  vectorCross,
+  vectorFromPoint,
+  type GlobalPoint,
+  type LocalPoint,
+} from "@excalidraw/math";
+
+import type { Bounds } from "@excalidraw/common";
+
+export type LineSegment<P extends LocalPoint | GlobalPoint> = [P, P];
+
+export function getBBox<P extends LocalPoint | GlobalPoint>(
+  line: LineSegment<P>,
+): Bounds {
+  return [
+    Math.min(line[0][0], line[1][0]),
+    Math.min(line[0][1], line[1][1]),
+    Math.max(line[0][0], line[1][0]),
+    Math.max(line[0][1], line[1][1]),
+  ];
+}
+
+export function doBBoxesIntersect(a: Bounds, b: Bounds) {
+  return a[0] <= b[2] && a[2] >= b[0] && a[1] <= b[3] && a[3] >= b[1];
+}
+
+const EPSILON = 0.000001;
+
+export function isPointOnLine<P extends GlobalPoint | LocalPoint>(
+  l: LineSegment<P>,
+  p: P,
+) {
+  const p1 = vectorFromPoint(l[1], l[0]);
+  const p2 = vectorFromPoint(p, l[0]);
+
+  const r = vectorCross(p1, p2);
+
+  return Math.abs(r) < EPSILON;
+}
+
+export function isPointRightOfLine<P extends GlobalPoint | LocalPoint>(
+  l: LineSegment<P>,
+  p: P,
+) {
+  const p1 = vectorFromPoint(l[1], l[0]);
+  const p2 = vectorFromPoint(p, l[0]);
+
+  return vectorCross(p1, p2) < 0;
+}
+
+export function isLineSegmentTouchingOrCrossingLine<
+  P extends GlobalPoint | LocalPoint,
+>(a: LineSegment<P>, b: LineSegment<P>) {
+  return (
+    isPointOnLine(a, b[0]) ||
+    isPointOnLine(a, b[1]) ||
+    (isPointRightOfLine(a, b[0])
+      ? !isPointRightOfLine(a, b[1])
+      : isPointRightOfLine(a, b[1]))
+  );
+}
+
+// https://martin-thoma.com/how-to-check-if-two-line-segments-intersect/
+export function doLineSegmentsIntersect<P extends GlobalPoint | LocalPoint>(
+  a: LineSegment<P>,
+  b: LineSegment<P>,
+) {
+  return (
+    doBBoxesIntersect(getBBox(a), getBBox(b)) &&
+    isLineSegmentTouchingOrCrossingLine(a, b) &&
+    isLineSegmentTouchingOrCrossingLine(b, a)
+  );
+}

packages/utils/src/index.ts

@@ -1,3 +1,4 @@
 export * from "./export";
-export { elementsOverlappingBBox } from "@excalidraw/element";
+export * from "./withinBounds";
+export * from "./bbox";
 export { getCommonBounds } from "@excalidraw/element";

packages/utils/src/withinBounds.ts

@@ -0,0 +1,228 @@
+import { arrayToMap, type Bounds } from "@excalidraw/common";
+import { getElementBounds } from "@excalidraw/element";
+import {
+  isArrowElement,
+  isExcalidrawElement,
+  isFreeDrawElement,
+  isLinearElement,
+  isTextElement,
+} from "@excalidraw/element";
+import {
+  rangeIncludesValue,
+  pointFrom,
+  pointRotateRads,
+  rangeInclusive,
+} from "@excalidraw/math";
+
+import type {
+  ExcalidrawElement,
+  ExcalidrawFreeDrawElement,
+  ExcalidrawLinearElement,
+  NonDeletedExcalidrawElement,
+} from "@excalidraw/element/types";
+import type { LocalPoint } from "@excalidraw/math";
+
+type Element = NonDeletedExcalidrawElement;
+type Elements = readonly NonDeletedExcalidrawElement[];
+
+type Points = readonly LocalPoint[];
+
+/** @returns vertices relative to element's top-left [0,0] position  */
+const getNonLinearElementRelativePoints = (
+  element: Exclude<
+    Element,
+    ExcalidrawLinearElement | ExcalidrawFreeDrawElement
+  >,
+): [
+  TopLeft: LocalPoint,
+  TopRight: LocalPoint,
+  BottomRight: LocalPoint,
+  BottomLeft: LocalPoint,
+] => {
+  if (element.type === "diamond") {
+    return [
+      pointFrom(element.width / 2, 0),
+      pointFrom(element.width, element.height / 2),
+      pointFrom(element.width / 2, element.height),
+      pointFrom(0, element.height / 2),
+    ];
+  }
+  return [
+    pointFrom(0, 0),
+    pointFrom(0 + element.width, 0),
+    pointFrom(0 + element.width, element.height),
+    pointFrom(0, element.height),
+  ];
+};
+
+/** @returns vertices relative to element's top-left [0,0] position  */
+const getElementRelativePoints = (element: ExcalidrawElement): Points => {
+  if (isLinearElement(element) || isFreeDrawElement(element)) {
+    return element.points;
+  }
+  return getNonLinearElementRelativePoints(element);
+};
+
+const getMinMaxPoints = (points: Points) => {
+  const ret = points.reduce(
+    (limits, [x, y]) => {
+      limits.minY = Math.min(limits.minY, y);
+      limits.minX = Math.min(limits.minX, x);
+
+      limits.maxX = Math.max(limits.maxX, x);
+      limits.maxY = Math.max(limits.maxY, y);
+
+      return limits;
+    },
+    {
+      minX: Infinity,
+      minY: Infinity,
+      maxX: -Infinity,
+      maxY: -Infinity,
+      cx: 0,
+      cy: 0,
+    },
+  );
+
+  ret.cx = (ret.maxX + ret.minX) / 2;
+  ret.cy = (ret.maxY + ret.minY) / 2;
+
+  return ret;
+};
+
+const getRotatedBBox = (element: Element): Bounds => {
+  const points = getElementRelativePoints(element);
+
+  const { cx, cy } = getMinMaxPoints(points);
+  const centerPoint = pointFrom<LocalPoint>(cx, cy);
+
+  const rotatedPoints = points.map((p) =>
+    pointRotateRads(p, centerPoint, element.angle),
+  );
+  const { minX, minY, maxX, maxY } = getMinMaxPoints(rotatedPoints);
+
+  return [
+    minX + element.x,
+    minY + element.y,
+    maxX + element.x,
+    maxY + element.y,
+  ];
+};
+
+export const isElementInsideBBox = (
+  element: Element,
+  bbox: Bounds,
+  eitherDirection = false,
+): boolean => {
+  const elementBBox = getRotatedBBox(element);
+
+  const elementInsideBbox =
+    bbox[0] <= elementBBox[0] &&
+    bbox[2] >= elementBBox[2] &&
+    bbox[1] <= elementBBox[1] &&
+    bbox[3] >= elementBBox[3];
+
+  if (!eitherDirection) {
+    return elementInsideBbox;
+  }
+
+  if (elementInsideBbox) {
+    return true;
+  }
+
+  return (
+    elementBBox[0] <= bbox[0] &&
+    elementBBox[2] >= bbox[2] &&
+    elementBBox[1] <= bbox[1] &&
+    elementBBox[3] >= bbox[3]
+  );
+};
+
+export const elementPartiallyOverlapsWithOrContainsBBox = (
+  element: Element,
+  bbox: Bounds,
+): boolean => {
+  const elementBBox = getRotatedBBox(element);
+
+  return (
+    (rangeIncludesValue(elementBBox[0], rangeInclusive(bbox[0], bbox[2])) ||
+      rangeIncludesValue(
+        bbox[0],
+        rangeInclusive(elementBBox[0], elementBBox[2]),
+      )) &&
+    (rangeIncludesValue(elementBBox[1], rangeInclusive(bbox[1], bbox[3])) ||
+      rangeIncludesValue(
+        bbox[1],
+        rangeInclusive(elementBBox[1], elementBBox[3]),
+      ))
+  );
+};
+
+export const elementsOverlappingBBox = ({
+  elements,
+  bounds,
+  type,
+  errorMargin = 0,
+}: {
+  elements: Elements;
+  bounds: Bounds | ExcalidrawElement;
+  /** safety offset. Defaults to 0. */
+  errorMargin?: number;
+  /**
+   * - overlap: elements overlapping or inside bounds
+   * - contain: elements inside bounds or bounds inside elements
+   * - inside: elements inside bounds
+   **/
+  type: "overlap" | "contain" | "inside";
+}) => {
+  if (isExcalidrawElement(bounds)) {
+    bounds = getElementBounds(bounds, arrayToMap(elements));
+  }
+  const adjustedBBox: Bounds = [
+    bounds[0] - errorMargin,
+    bounds[1] - errorMargin,
+    bounds[2] + errorMargin,
+    bounds[3] + errorMargin,
+  ];
+
+  const includedElementSet = new Set<string>();
+
+  for (const element of elements) {
+    if (includedElementSet.has(element.id)) {
+      continue;
+    }
+
+    const isOverlaping =
+      type === "overlap"
+        ? elementPartiallyOverlapsWithOrContainsBBox(element, adjustedBBox)
+        : type === "inside"
+        ? isElementInsideBBox(element, adjustedBBox)
+        : isElementInsideBBox(element, adjustedBBox, true);
+
+    if (isOverlaping) {
+      includedElementSet.add(element.id);
+
+      if (element.boundElements) {
+        for (const boundElement of element.boundElements) {
+          includedElementSet.add(boundElement.id);
+        }
+      }
+
+      if (isTextElement(element) && element.containerId) {
+        includedElementSet.add(element.containerId);
+      }
+
+      if (isArrowElement(element)) {
+        if (element.startBinding) {
+          includedElementSet.add(element.startBinding.elementId);
+        }
+
+        if (element.endBinding) {
+          includedElementSet.add(element.endBinding?.elementId);
+        }
+      }
+    }
+  }
+
+  return elements.filter((element) => includedElementSet.has(element.id));
+};

packages/utils/tests/withinBounds.test.ts

@@ -0,0 +1,264 @@
+import { API } from "@excalidraw/excalidraw/tests/helpers/api";
+
+import type { Bounds } from "@excalidraw/common";
+
+import {
+  elementPartiallyOverlapsWithOrContainsBBox,
+  elementsOverlappingBBox,
+  isElementInsideBBox,
+} from "../src/withinBounds";
+
+const makeElement = (x: number, y: number, width: number, height: number) =>
+  API.createElement({
+    type: "rectangle",
+    x,
+    y,
+    width,
+    height,
+  });
+
+const makeBBox = (
+  minX: number,
+  minY: number,
+  maxX: number,
+  maxY: number,
+): Bounds => [minX, minY, maxX, maxY];
+
+describe("isElementInsideBBox()", () => {
+  it("should return true if element is fully inside", () => {
+    const bbox = makeBBox(0, 0, 100, 100);
+
+    // bbox contains element
+    expect(isElementInsideBBox(makeElement(0, 0, 100, 100), bbox)).toBe(true);
+    expect(isElementInsideBBox(makeElement(10, 10, 90, 90), bbox)).toBe(true);
+  });
+
+  it("should return false if element is only partially overlapping", () => {
+    const bbox = makeBBox(0, 0, 100, 100);
+
+    // element contains bbox
+    expect(isElementInsideBBox(makeElement(-10, -10, 110, 110), bbox)).toBe(
+      false,
+    );
+
+    // element overlaps bbox from top-left
+    expect(isElementInsideBBox(makeElement(-10, -10, 100, 100), bbox)).toBe(
+      false,
+    );
+    // element overlaps bbox from top-right
+    expect(isElementInsideBBox(makeElement(90, -10, 100, 100), bbox)).toBe(
+      false,
+    );
+    // element overlaps bbox from bottom-left
+    expect(isElementInsideBBox(makeElement(-10, 90, 100, 100), bbox)).toBe(
+      false,
+    );
+    // element overlaps bbox from bottom-right
+    expect(isElementInsideBBox(makeElement(90, 90, 100, 100), bbox)).toBe(
+      false,
+    );
+  });
+
+  it("should return false if element outside", () => {
+    const bbox = makeBBox(0, 0, 100, 100);
+
+    // outside diagonally
+    expect(isElementInsideBBox(makeElement(110, 110, 100, 100), bbox)).toBe(
+      false,
+    );
+
+    // outside on the left
+    expect(isElementInsideBBox(makeElement(-110, 10, 50, 50), bbox)).toBe(
+      false,
+    );
+    // outside on the right
+    expect(isElementInsideBBox(makeElement(110, 10, 50, 50), bbox)).toBe(false);
+    // outside on the top
+    expect(isElementInsideBBox(makeElement(10, -110, 50, 50), bbox)).toBe(
+      false,
+    );
+    // outside on the bottom
+    expect(isElementInsideBBox(makeElement(10, 110, 50, 50), bbox)).toBe(false);
+  });
+
+  it("should return true if bbox contains element and flag enabled", () => {
+    const bbox = makeBBox(0, 0, 100, 100);
+
+    // element contains bbox
+    expect(
+      isElementInsideBBox(makeElement(-10, -10, 110, 110), bbox, true),
+    ).toBe(true);
+
+    // bbox contains element
+    expect(isElementInsideBBox(makeElement(0, 0, 100, 100), bbox)).toBe(true);
+    expect(isElementInsideBBox(makeElement(10, 10, 90, 90), bbox)).toBe(true);
+  });
+});
+
+describe("elementPartiallyOverlapsWithOrContainsBBox()", () => {
+  it("should return true if element overlaps, is inside, or contains", () => {
+    const bbox = makeBBox(0, 0, 100, 100);
+
+    // bbox contains element
+    expect(
+      elementPartiallyOverlapsWithOrContainsBBox(
+        makeElement(0, 0, 100, 100),
+        bbox,
+      ),
+    ).toBe(true);
+    expect(
+      elementPartiallyOverlapsWithOrContainsBBox(
+        makeElement(10, 10, 90, 90),
+        bbox,
+      ),
+    ).toBe(true);
+
+    // element contains bbox
+    expect(
+      elementPartiallyOverlapsWithOrContainsBBox(
+        makeElement(-10, -10, 110, 110),
+        bbox,
+      ),
+    ).toBe(true);
+
+    // element overlaps bbox from top-left
+    expect(
+      elementPartiallyOverlapsWithOrContainsBBox(
+        makeElement(-10, -10, 100, 100),
+        bbox,
+      ),
+    ).toBe(true);
+    // element overlaps bbox from top-right
+    expect(
+      elementPartiallyOverlapsWithOrContainsBBox(
+        makeElement(90, -10, 100, 100),
+        bbox,
+      ),
+    ).toBe(true);
+    // element overlaps bbox from bottom-left
+    expect(
+      elementPartiallyOverlapsWithOrContainsBBox(
+        makeElement(-10, 90, 100, 100),
+        bbox,
+      ),
+    ).toBe(true);
+    // element overlaps bbox from bottom-right
+    expect(
+      elementPartiallyOverlapsWithOrContainsBBox(
+        makeElement(90, 90, 100, 100),
+        bbox,
+      ),
+    ).toBe(true);
+  });
+
+  it("should return false if element does not overlap", () => {
+    const bbox = makeBBox(0, 0, 100, 100);
+
+    // outside diagonally
+    expect(
+      elementPartiallyOverlapsWithOrContainsBBox(
+        makeElement(110, 110, 100, 100),
+        bbox,
+      ),
+    ).toBe(false);
+
+    // outside on the left
+    expect(
+      elementPartiallyOverlapsWithOrContainsBBox(
+        makeElement(-110, 10, 50, 50),
+        bbox,
+      ),
+    ).toBe(false);
+    // outside on the right
+    expect(
+      elementPartiallyOverlapsWithOrContainsBBox(
+        makeElement(110, 10, 50, 50),
+        bbox,
+      ),
+    ).toBe(false);
+    // outside on the top
+    expect(
+      elementPartiallyOverlapsWithOrContainsBBox(
+        makeElement(10, -110, 50, 50),
+        bbox,
+      ),
+    ).toBe(false);
+    // outside on the bottom
+    expect(
+      elementPartiallyOverlapsWithOrContainsBBox(
+        makeElement(10, 110, 50, 50),
+        bbox,
+      ),
+    ).toBe(false);
+  });
+});
+
+describe("elementsOverlappingBBox()", () => {
+  it("should return elements that overlap bbox", () => {
+    const bbox = makeBBox(0, 0, 100, 100);
+
+    const rectOutside = makeElement(110, 110, 100, 100);
+    const rectInside = makeElement(10, 10, 90, 90);
+    const rectContainingBBox = makeElement(-10, -10, 110, 110);
+    const rectOverlappingTopLeft = makeElement(-10, -10, 50, 50);
+
+    expect(
+      elementsOverlappingBBox({
+        bounds: bbox,
+        type: "overlap",
+        elements: [
+          rectOutside,
+          rectInside,
+          rectContainingBBox,
+          rectOverlappingTopLeft,
+        ],
+      }),
+    ).toEqual([rectInside, rectContainingBBox, rectOverlappingTopLeft]);
+  });
+
+  it("should return elements inside/containing bbox", () => {
+    const bbox = makeBBox(0, 0, 100, 100);
+
+    const rectOutside = makeElement(110, 110, 100, 100);
+    const rectInside = makeElement(10, 10, 90, 90);
+    const rectContainingBBox = makeElement(-10, -10, 110, 110);
+    const rectOverlappingTopLeft = makeElement(-10, -10, 50, 50);
+
+    expect(
+      elementsOverlappingBBox({
+        bounds: bbox,
+        type: "contain",
+        elements: [
+          rectOutside,
+          rectInside,
+          rectContainingBBox,
+          rectOverlappingTopLeft,
+        ],
+      }),
+    ).toEqual([rectInside, rectContainingBBox]);
+  });
+
+  it("should return elements inside bbox", () => {
+    const bbox = makeBBox(0, 0, 100, 100);
+
+    const rectOutside = makeElement(110, 110, 100, 100);
+    const rectInside = makeElement(10, 10, 90, 90);
+    const rectContainingBBox = makeElement(-10, -10, 110, 110);
+    const rectOverlappingTopLeft = makeElement(-10, -10, 50, 50);
+
+    expect(
+      elementsOverlappingBBox({
+        bounds: bbox,
+        type: "inside",
+        elements: [
+          rectOutside,
+          rectInside,
+          rectContainingBBox,
+          rectOverlappingTopLeft,
+        ],
+      }),
+    ).toEqual([rectInside]);
+  });
+
+  // TODO test linear, freedraw, and diamond element types (+rotated)
+});

setupTests.ts

@@ -3,7 +3,6 @@ import fs from "fs";
 // vitest.setup.ts
 import "vitest-canvas-mock";
 import "@testing-library/jest-dom";
-import { configure } from "@testing-library/react";
 import { vi } from "vitest";
 
 import polyfill from "./packages/excalidraw/polyfill";
@@ -17,21 +16,6 @@ import {
 Object.assign(globalThis, testPolyfills);
 PolyfillLocalStorage();
 
-// By default testing-library dumps the entire serialized DOM into the error
-// message whenever a `waitFor`/`getBy*` fails, which floods the test output
-// (often hundreds of lines of HTML per failure). Strip it out unless
-// VITE_DEBUG_DOM is enabled (see .env.test), e.g. `VITE_DEBUG_DOM=true yarn test`.
-const debugDom = ["true", "1"].includes(process.env.VITE_DEBUG_DOM ?? "");
-if (!debugDom) {
-  configure({
-    getElementError: (message) => {
-      const error = new Error(message ?? undefined);
-      error.name = "TestingLibraryElementError";
-      return error;
-    },
-  });
-}
-
 vi.mock("@excalidraw/common", async (importOriginal) => {
   const module = await importOriginal<typeof import("@excalidraw/common")>();
 

vercel.json

@@ -1,4 +1,5 @@
 {
+  "public": true,
   "headers": [
     {
       "source": "/(.*)",

vitest.config.mts

@@ -71,8 +71,6 @@ export default defineConfig({
     setupFiles: ["./setupTests.ts"],
     globals: true,
     environment: "jsdom",
-    // don't list skipped tests in the failure tree — keeps output readable
-    hideSkippedTests: true,
     coverage: {
       reporter: ["text", "json-summary", "json", "html", "lcovonly"],
       // Since v2, it ignores empty lines by default and we need to disable it as it affects the coverage