fix ts

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

.github/workflows/cancel.yml

@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 3
     steps:
-      - uses: styfle/cancel-workflow-action@ce177499ccf9fd2aded3b0426c97e5434c2e8a73 # 0.6.0
+      - uses: styfle/cancel-workflow-action@0.6.0
         with:
           workflow_id: 400555, 400556, 905313, 1451724, 1710116, 3185001, 3438604
           access_token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/locales-coverage.yml

@@ -40,7 +40,7 @@ jobs:
           echo ::set-output name=body::$body
 
       - name: Update description with coverage
-        uses: kt3k/update-pr-description@1b35a6dcd84d81aa0bc1889610efdcde7f37b0c0 # v1.0.1
+        uses: kt3k/update-pr-description@v1.0.1
         with:
           pr_body: ${{ steps.getCommentBody.outputs.body }}
           pr_title: "chore: Update translations from Crowdin"

.github/workflows/publish-docker.yml

@@ -13,16 +13,16 @@ jobs:
       - name: Checkout repository
         uses: actions/checkout@v3
       - name: Login to DockerHub
-        uses: docker/login-action@465a07811f14bebb1938fbed4728c6a1ff8901fc # v2
+        uses: docker/login-action@v2
         with:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@c7c53464625b32c7a7e944ae62b3e17d2b600130 # v3
+        uses: docker/setup-qemu-action@v3
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3
+        uses: docker/setup-buildx-action@v3
       - name: Build and push
-        uses: docker/build-push-action@ca052bb54ab0790a636c9b5f226502c73d547a25 # v5
+        uses: docker/build-push-action@v5
         with:
           context: .
           push: true

.github/workflows/semantic-pr-title.yml

@@ -11,6 +11,6 @@ jobs:
   semantic:
     runs-on: ubuntu-latest
     steps:
-      - uses: amannn/action-semantic-pull-request@e32d7e603df1aa1ba07e981f2a23455dee596825 # v5
+      - uses: amannn/action-semantic-pull-request@v5
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/size-limit.yml

@@ -20,7 +20,7 @@ jobs:
         working-directory: packages/excalidraw
         env:
           CI: true
-      - uses: andresz1/size-limit-action@e7493a72a44b113341c0cf6186ab49c17c4b65c1 # v1
+      - uses: andresz1/size-limit-action@v1
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
           build_script: build:esm

.github/workflows/test-coverage-pr.yml

@@ -21,6 +21,6 @@ jobs:
         run: yarn test:coverage
       - name: "Report Coverage"
         if: always() # Also generate the report if tests are failing
-        uses: davelosert/vitest-coverage-report-action@2500dafcee7dd64f85ab689c0b83798a8359770e # v2
+        uses: davelosert/vitest-coverage-report-action@v2
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}

excalidraw-app/components/DebugCanvas.tsx

@@ -3,24 +3,41 @@ import {
   CloseIcon,
   TrashIcon,
 } from "@excalidraw/excalidraw/components/icons";
+import { useExcalidrawAPI } from "@excalidraw/excalidraw/index";
 import {
   bootstrapCanvas,
+  fillCircle,
   getNormalizedCanvasDimensions,
 } from "@excalidraw/excalidraw/renderer/helpers";
 import { type AppState } from "@excalidraw/excalidraw/types";
-import { arrayToMap, throttleRAF } from "@excalidraw/common";
+import {
-import { useCallback } from "react";
+  arrayToMap,
+  sceneCoordsToViewportCoords,
+  throttleRAF,
+  viewportCoordsToSceneCoords,
+} from "@excalidraw/common";
+import { useCallback, useEffect, useRef, useState } from "react";
 
 import {
+  CaptureUpdateAction,
+  clearSimpleArrowTangentOverride,
   getGlobalFixedPointForBindableElement,
+  getElementAbsoluteCoords,
+  getSimpleArrowCurveDebugData,
   isArrowElement,
   isBindableElement,
+  setSimpleArrowTangentOverride,
+  ShapeCache,
 } from "@excalidraw/element";
 
 import {
   isLineSegment,
+  pointFrom,
+  pointRotateRads,
   type GlobalPoint,
+  type LocalPoint,
   type LineSegment,
+  type Radians,
 } from "@excalidraw/math";
 import { isCurve } from "@excalidraw/math/curve";
 
@@ -36,11 +53,260 @@ import type {
   ExcalidrawArrowElement,
   ExcalidrawBindableElement,
   FixedPointBinding,
+  Ordered,
   OrderedExcalidrawElement,
 } from "@excalidraw/element/types";
+import type { SimpleArrowCurveDebugData } from "@excalidraw/element";
 
 import { STORAGE_KEYS } from "../app_constants";
 
+type DebugCanvasOverlayState = Pick<
+  AppState,
+  | "width"
+  | "height"
+  | "zoom"
+  | "scrollX"
+  | "scrollY"
+  | "offsetLeft"
+  | "offsetTop"
+  | "selectedElementIds"
+>;
+
+type SimpleArrowHandleDirection = "incoming" | "outgoing";
+
+type SimpleArrowHandleDescriptor = {
+  key: string;
+  elementId: string;
+  pointIndex: number;
+  direction: SimpleArrowHandleDirection;
+  point: GlobalPoint;
+  handle: GlobalPoint;
+  isOverridden: boolean;
+  title: string;
+};
+
+type SelectedSimpleArrowDebugState = {
+  element: ExcalidrawArrowElement;
+  debugData: SimpleArrowCurveDebugData<GlobalPoint>;
+  handles: SimpleArrowHandleDescriptor[];
+};
+
+const areSimpleArrowTangentHandlesEnabled = () =>
+  window.EXCALIDRAW_DEBUG_LINEAR_ARROW_TANGENTS !== false;
+
+const pickOverlayState = (appState: AppState): DebugCanvasOverlayState => ({
+  width: appState.width,
+  height: appState.height,
+  zoom: appState.zoom,
+  scrollX: appState.scrollX,
+  scrollY: appState.scrollY,
+  offsetLeft: appState.offsetLeft,
+  offsetTop: appState.offsetTop,
+  selectedElementIds: appState.selectedElementIds,
+});
+
+const getSimpleArrowTransform = (
+  element: ExcalidrawArrowElement,
+  elementsMap: ElementsMap,
+) => {
+  const [, , , , cx, cy] = getElementAbsoluteCoords(element, elementsMap);
+  const center = pointFrom<GlobalPoint>(cx, cy);
+
+  return {
+    pointToGlobal: (point: LocalPoint): GlobalPoint => {
+      const rotated = pointRotateRads(
+        pointFrom<GlobalPoint>(element.x + point[0], element.y + point[1]),
+        center,
+        element.angle,
+      );
+
+      return pointFrom<GlobalPoint>(rotated[0], rotated[1]);
+    },
+    vectorToGlobal: (vector: [number, number]): [number, number] => {
+      const rotated = pointRotateRads(
+        pointFrom<GlobalPoint>(vector[0], vector[1]),
+        pointFrom<GlobalPoint>(0, 0),
+        element.angle,
+      );
+
+      return [rotated[0], rotated[1]];
+    },
+    vectorToLocal: (vector: [number, number]): [number, number] => {
+      const rotated = pointRotateRads(
+        pointFrom<GlobalPoint>(vector[0], vector[1]),
+        pointFrom<GlobalPoint>(0, 0),
+        -element.angle as Radians,
+      );
+
+      return [rotated[0], rotated[1]];
+    },
+  };
+};
+
+const getSimpleArrowDebugStateForElement = (
+  elements: readonly OrderedExcalidrawElement[],
+  elementId: string,
+): SelectedSimpleArrowDebugState | null => {
+  const element = elements.find(
+    (candidate): candidate is Ordered<ExcalidrawArrowElement> =>
+      candidate.id === elementId &&
+      !candidate.isDeleted &&
+      isArrowElement(candidate) &&
+      !!candidate.roundness &&
+      !candidate.elbowed,
+  );
+
+  if (!element) {
+    return null;
+  }
+
+  const elementsMap = arrayToMap(elements);
+  const transform = getSimpleArrowTransform(element, elementsMap);
+  const localDebugData = getSimpleArrowCurveDebugData(element.points, 0.5, {
+    elementId: element.id,
+  });
+  const debugData: SimpleArrowCurveDebugData<GlobalPoint> = {
+    ...localDebugData,
+    tangents: localDebugData.tangents.map((tangent) => ({
+      ...tangent,
+      point: transform.pointToGlobal(tangent.point as LocalPoint),
+      base: transform.vectorToGlobal(tangent.base),
+      autoScaled: transform.vectorToGlobal(tangent.autoScaled),
+      scaled: transform.vectorToGlobal(tangent.scaled),
+    })),
+    segments: localDebugData.segments.map((segment) => ({
+      ...segment,
+      start: transform.pointToGlobal(segment.start as LocalPoint),
+      end: transform.pointToGlobal(segment.end as LocalPoint),
+      baseCp1: transform.pointToGlobal(segment.baseCp1 as LocalPoint),
+      baseCp2: transform.pointToGlobal(segment.baseCp2 as LocalPoint),
+      cp1: transform.pointToGlobal(segment.cp1 as LocalPoint),
+      cp2: transform.pointToGlobal(segment.cp2 as LocalPoint),
+    })),
+  };
+  const handles = debugData.tangents.flatMap((tangent, pointIndex) => {
+    const descriptors: SimpleArrowHandleDescriptor[] = [];
+    const lengthRatio =
+      tangent.normalized.finalLengthVsMinNeighbor === null
+        ? "n/a"
+        : tangent.normalized.finalLengthVsMinNeighbor.toFixed(3);
+    const angleDelta = tangent.normalized.angleDelta.toFixed(3);
+    const title = `point ${pointIndex} · len/min ${lengthRatio} · dAngle ${angleDelta} · dblclick resets`;
+
+    if (pointIndex < debugData.tangents.length - 1) {
+      descriptors.push({
+        key: `${element.id}:${pointIndex}:out`,
+        elementId: element.id,
+        pointIndex,
+        direction: "outgoing",
+        point: tangent.point,
+        handle: pointFrom<GlobalPoint>(
+          tangent.point[0] + tangent.scaled[0] / 3,
+          tangent.point[1] + tangent.scaled[1] / 3,
+        ),
+        isOverridden: tangent.isOverridden,
+        title,
+      });
+    }
+
+    if (pointIndex > 0) {
+      descriptors.push({
+        key: `${element.id}:${pointIndex}:in`,
+        elementId: element.id,
+        pointIndex,
+        direction: "incoming",
+        point: tangent.point,
+        handle: pointFrom<GlobalPoint>(
+          tangent.point[0] - tangent.scaled[0] / 3,
+          tangent.point[1] - tangent.scaled[1] / 3,
+        ),
+        isOverridden: tangent.isOverridden,
+        title,
+      });
+    }
+
+    return descriptors;
+  });
+
+  return {
+    element,
+    debugData,
+    handles,
+  };
+};
+
+const getSelectedSimpleArrowDebugState = (
+  elements: readonly OrderedExcalidrawElement[],
+  appState: Pick<AppState, "selectedElementIds">,
+) => {
+  const selectedIds = Object.keys(appState.selectedElementIds);
+
+  if (selectedIds.length !== 1) {
+    return null;
+  }
+
+  return getSimpleArrowDebugStateForElement(elements, selectedIds[0]);
+};
+
+const renderSelectedSimpleArrowTangentOverlay = (
+  context: CanvasRenderingContext2D,
+  zoom: number,
+  debugState: SelectedSimpleArrowDebugState,
+) => {
+  context.save();
+  context.lineWidth = 1;
+
+  context.setLineDash([6, 4]);
+  context.strokeStyle = "rgba(134, 142, 150, 0.75)";
+
+  for (const segment of debugState.debugData.segments) {
+    context.beginPath();
+    context.moveTo(segment.start[0] * zoom, segment.start[1] * zoom);
+    context.lineTo(segment.baseCp1[0] * zoom, segment.baseCp1[1] * zoom);
+    context.lineTo(segment.baseCp2[0] * zoom, segment.baseCp2[1] * zoom);
+    context.lineTo(segment.end[0] * zoom, segment.end[1] * zoom);
+    context.stroke();
+  }
+
+  context.setLineDash([]);
+
+  for (const segment of debugState.debugData.segments) {
+    context.strokeStyle = segment.overshootsBaseline
+      ? "rgba(245, 159, 0, 0.9)"
+      : "rgba(94, 90, 216, 0.85)";
+
+    context.beginPath();
+    context.moveTo(segment.start[0] * zoom, segment.start[1] * zoom);
+    context.lineTo(segment.cp1[0] * zoom, segment.cp1[1] * zoom);
+    context.lineTo(segment.cp2[0] * zoom, segment.cp2[1] * zoom);
+    context.lineTo(segment.end[0] * zoom, segment.end[1] * zoom);
+    context.stroke();
+  }
+
+  for (const tangent of debugState.debugData.tangents) {
+    if (!tangent.isAdjusted) {
+      continue;
+    }
+
+    context.strokeStyle = tangent.isOverridden
+      ? "rgba(230, 73, 128, 0.95)"
+      : "rgba(201, 42, 42, 0.85)";
+    context.fillStyle = tangent.isOverridden
+      ? "rgba(230, 73, 128, 0.95)"
+      : "rgba(201, 42, 42, 0.95)";
+
+    fillCircle(
+      context,
+      tangent.point[0] * zoom,
+      tangent.point[1] * zoom,
+      3,
+      true,
+    );
+  }
+
+  context.restore();
+};
+
 const renderLine = (
   context: CanvasRenderingContext2D,
   zoom: number,
@@ -359,6 +625,13 @@ const _debugRenderer = (
   renderOrigin(context, appState.zoom.value);
   renderBindings(context, elements, appState.zoom.value);
 
+  const selectedSimpleArrowDebugState = areSimpleArrowTangentHandlesEnabled()
+    ? getSelectedSimpleArrowDebugState(elements, appState)
+    : null;
+
+  window.EXCALIDRAW_DEBUG_SELECTED_LINEAR_ARROW =
+    selectedSimpleArrowDebugState?.debugData;
+
   if (
     window.visualDebug?.currentFrame &&
     window.visualDebug?.data &&
@@ -375,6 +648,14 @@ const _debugRenderer = (
     });
   }
 
+  if (selectedSimpleArrowDebugState) {
+    renderSelectedSimpleArrowTangentOverlay(
+      context,
+      appState.zoom.value,
+      selectedSimpleArrowDebugState,
+    );
+  }
+
   if (window.visualDebug) {
     window.visualDebug!.data =
       window.visualDebug?.data.map((frame) =>
@@ -542,23 +823,324 @@ interface DebugCanvasProps {
 
 const DebugCanvas = React.forwardRef<HTMLCanvasElement, DebugCanvasProps>(
   ({ appState, scale }, ref) => {
-    const { width, height } = appState;
+    const excalidrawAPI = useExcalidrawAPI();
+    const [overlayState, setOverlayState] = useState<DebugCanvasOverlayState>(
+      () => pickOverlayState(appState),
+    );
+    const [selectedSimpleArrowDebugState, setSelectedSimpleArrowDebugState] =
+      useState<SelectedSimpleArrowDebugState | null>(null);
+    const dragStateRef = useRef<{
+      elementId: string;
+      pointIndex: number;
+      direction: SimpleArrowHandleDirection;
+    } | null>(null);
+
+    const syncSelectedSimpleArrowDebugState = useCallback(
+      (
+        nextAppState: AppState,
+        nextElements?: readonly OrderedExcalidrawElement[],
+      ) => {
+        if (!excalidrawAPI || excalidrawAPI.isDestroyed) {
+          return;
+        }
+
+        const elements =
+          nextElements ??
+          (excalidrawAPI.getSceneElements() as OrderedExcalidrawElement[]);
+
+        setOverlayState(pickOverlayState(nextAppState));
+
+        const nextDebugState = areSimpleArrowTangentHandlesEnabled()
+          ? getSelectedSimpleArrowDebugState(elements, nextAppState)
+          : null;
+
+        window.EXCALIDRAW_DEBUG_SELECTED_LINEAR_ARROW =
+          nextDebugState?.debugData;
+        setSelectedSimpleArrowDebugState(nextDebugState);
+      },
+      [excalidrawAPI],
+    );
+
+    useEffect(() => {
+      if (!excalidrawAPI || excalidrawAPI.isDestroyed) {
+        return;
+      }
+
+      syncSelectedSimpleArrowDebugState(excalidrawAPI.getAppState());
+
+      const unsubscribeChange = excalidrawAPI.onChange(
+        (elements, nextAppState) =>
+          syncSelectedSimpleArrowDebugState(
+            nextAppState,
+            elements as readonly OrderedExcalidrawElement[],
+          ),
+      );
+      const unsubscribeState = excalidrawAPI.onStateChange(
+        [
+          "selectedElementIds",
+          "zoom",
+          "scrollX",
+          "scrollY",
+          "offsetLeft",
+          "offsetTop",
+          "width",
+          "height",
+        ],
+        (_value, nextAppState) =>
+          syncSelectedSimpleArrowDebugState(nextAppState),
+      );
+
+      return () => {
+        unsubscribeChange();
+        unsubscribeState();
+      };
+    }, [excalidrawAPI, syncSelectedSimpleArrowDebugState]);
+
+    const rerenderSceneForSimpleArrowOverride = useCallback(() => {
+      if (!excalidrawAPI || excalidrawAPI.isDestroyed) {
+        return;
+      }
+
+      excalidrawAPI.updateScene({
+        elements: excalidrawAPI.getSceneElementsIncludingDeleted(),
+        captureUpdate: CaptureUpdateAction.NEVER,
+      });
+    }, [excalidrawAPI]);
+
+    const commitOverrideForHandle = useCallback(
+      (
+        handle: Pick<
+          SimpleArrowHandleDescriptor,
+          "elementId" | "pointIndex" | "direction"
+        >,
+        clientX: number,
+        clientY: number,
+      ) => {
+        if (!excalidrawAPI || excalidrawAPI.isDestroyed) {
+          return;
+        }
+
+        const nextAppState = excalidrawAPI.getAppState();
+        const nextElements =
+          excalidrawAPI.getSceneElements() as OrderedExcalidrawElement[];
+        const debugState = getSimpleArrowDebugStateForElement(
+          nextElements,
+          handle.elementId,
+        );
+
+        if (!debugState) {
+          return;
+        }
+
+        const scenePoint = viewportCoordsToSceneCoords(
+          { clientX, clientY },
+          nextAppState,
+        );
+        const tangent =
+          handle.direction === "outgoing"
+            ? ([
+                (scenePoint.x -
+                  debugState.debugData.tangents[handle.pointIndex].point[0]) *
+                  3,
+                (scenePoint.y -
+                  debugState.debugData.tangents[handle.pointIndex].point[1]) *
+                  3,
+              ] as [number, number])
+            : ([
+                (debugState.debugData.tangents[handle.pointIndex].point[0] -
+                  scenePoint.x) *
+                  3,
+                (debugState.debugData.tangents[handle.pointIndex].point[1] -
+                  scenePoint.y) *
+                  3,
+              ] as [number, number]);
+        const localTangent = getSimpleArrowTransform(
+          debugState.element,
+          arrayToMap(nextElements),
+        ).vectorToLocal(tangent);
+
+        setSimpleArrowTangentOverride(
+          debugState.element.id,
+          handle.pointIndex,
+          localTangent,
+        );
+        ShapeCache.delete(debugState.element);
+        rerenderSceneForSimpleArrowOverride();
+        syncSelectedSimpleArrowDebugState(nextAppState, nextElements);
+      },
+      [
+        excalidrawAPI,
+        rerenderSceneForSimpleArrowOverride,
+        syncSelectedSimpleArrowDebugState,
+      ],
+    );
+
+    const onPointerMove = useCallback(
+      (event: PointerEvent) => {
+        if (!dragStateRef.current) {
+          return;
+        }
+
+        event.preventDefault();
+        commitOverrideForHandle(
+          dragStateRef.current,
+          event.clientX,
+          event.clientY,
+        );
+      },
+      [commitOverrideForHandle],
+    );
+
+    const onPointerUp = useCallback(
+      (event: PointerEvent) => {
+        if (!dragStateRef.current) {
+          return;
+        }
+
+        event.preventDefault();
+        dragStateRef.current = null;
+        window.removeEventListener("pointermove", onPointerMove);
+        window.removeEventListener("pointerup", onPointerUp);
+        window.removeEventListener("pointercancel", onPointerUp);
+      },
+      [onPointerMove],
+    );
+
+    useEffect(() => {
+      return () => {
+        dragStateRef.current = null;
+        window.removeEventListener("pointermove", onPointerMove);
+        window.removeEventListener("pointerup", onPointerUp);
+        window.removeEventListener("pointercancel", onPointerUp);
+      };
+    }, [onPointerMove, onPointerUp]);
+
+    const handlePointerDown = useCallback(
+      (
+        handle: SimpleArrowHandleDescriptor,
+        event: React.PointerEvent<HTMLDivElement>,
+      ) => {
+        event.preventDefault();
+        event.stopPropagation();
+
+        dragStateRef.current = {
+          elementId: handle.elementId,
+          pointIndex: handle.pointIndex,
+          direction: handle.direction,
+        };
+
+        window.addEventListener("pointermove", onPointerMove, {
+          passive: false,
+        });
+        window.addEventListener("pointerup", onPointerUp, {
+          passive: false,
+        });
+        window.addEventListener("pointercancel", onPointerUp, {
+          passive: false,
+        });
+
+        commitOverrideForHandle(handle, event.clientX, event.clientY);
+      },
+      [commitOverrideForHandle, onPointerMove, onPointerUp],
+    );
+
+    const resetHandleOverride = useCallback(
+      (
+        handle: SimpleArrowHandleDescriptor,
+        event: React.MouseEvent<HTMLDivElement>,
+      ) => {
+        event.preventDefault();
+        event.stopPropagation();
+
+        if (!excalidrawAPI || excalidrawAPI.isDestroyed) {
+          return;
+        }
+
+        clearSimpleArrowTangentOverride(handle.elementId, handle.pointIndex);
+
+        const nextElements =
+          excalidrawAPI.getSceneElements() as OrderedExcalidrawElement[];
+        const element = nextElements.find(
+          (candidate): candidate is Ordered<ExcalidrawArrowElement> =>
+            candidate.id === handle.elementId &&
+            !candidate.isDeleted &&
+            isArrowElement(candidate),
+        );
+
+        if (element) {
+          ShapeCache.delete(element);
+          rerenderSceneForSimpleArrowOverride();
+        }
+
+        syncSelectedSimpleArrowDebugState(
+          excalidrawAPI.getAppState(),
+          nextElements,
+        );
+      },
+      [
+        excalidrawAPI,
+        rerenderSceneForSimpleArrowOverride,
+        syncSelectedSimpleArrowDebugState,
+      ],
+    );
+
+    const { width, height } = overlayState;
 
     return (
-      <canvas
+      <>
-        style={{
+        <canvas
-          width,
+          style={{
-          height,
+            width,
-          position: "absolute",
+            height,
-          zIndex: 2,
+            position: "absolute",
-          pointerEvents: "none",
+            inset: 0,
-        }}
+            zIndex: 2,
-        width={width * scale}
+            pointerEvents: "none",
-        height={height * scale}
+          }}
-        ref={ref}
+          width={width * scale}
-      >
+          height={height * scale}
-        Debug Canvas
+          ref={ref}
-      </canvas>
+        >
+          Debug Canvas
+        </canvas>
+        {selectedSimpleArrowDebugState?.handles.map((handle) => {
+          const { x, y } = sceneCoordsToViewportCoords(
+            {
+              sceneX: handle.handle[0],
+              sceneY: handle.handle[1],
+            },
+            overlayState,
+          );
+
+          return (
+            <div
+              key={handle.key}
+              title={handle.title}
+              onPointerDown={(event) => handlePointerDown(handle, event)}
+              onDoubleClick={(event) => resetHandleOverride(handle, event)}
+              style={{
+                position: "absolute",
+                left: x - overlayState.offsetLeft,
+                top: y - overlayState.offsetTop,
+                width: 12,
+                height: 12,
+                zIndex: 3,
+                borderRadius: handle.direction === "outgoing" ? "999px" : 3,
+                transform: "translate(-50%, -50%)",
+                background: handle.isOverridden
+                  ? "rgba(230, 73, 128, 0.95)"
+                  : handle.direction === "outgoing"
+                  ? "rgba(94, 90, 216, 0.95)"
+                  : "rgba(245, 159, 0, 0.95)",
+                border: "2px solid rgba(255,255,255,0.95)",
+                boxShadow: "0 0 0 1px rgba(0, 0, 0, 0.18)",
+                pointerEvents: "auto",
+                cursor: "grab",
+              }}
+            />
+          );
+        })}
+      </>
     );
   },
 );

packages/common/src/constants.ts

@@ -405,9 +405,8 @@ export const ROUGHNESS = {
 
 export const STROKE_WIDTH = {
   thin: 1,
-  medium: 2,
+  bold: 2,
-  bold: 4,
+  extraBold: 4,
-  extraBold: 8,
 } as const;
 
 export const DEFAULT_ELEMENT_PROPS: {
@@ -430,8 +429,6 @@ export const DEFAULT_ELEMENT_PROPS: {
   locked: false,
 };
 
-export const DEFAULT_FREE_DRAW_STROKE_SHAPE = "variable" as const;
-
 export const LIBRARY_SIDEBAR_TAB = "library";
 export const CANVAS_SEARCH_TAB = "search";
 

packages/element/src/__tests__/__snapshots__/transform.test.ts.snap

@@ -1822,7 +1822,7 @@ exports[`Test Transform > should transform the elements correctly when linear el
   "versionNonce": Any<Number>,
   "verticalAlign": "middle",
   "width": 120,
-  "x": 187.75450000000004,
+  "x": 187.7545,
   "y": 44.5,
 }
 `;

packages/element/src/bounds.ts

@@ -168,14 +168,12 @@ export class ElementBounds {
           ),
         ),
       );
-      const padding =
-        element.strokeShape === "fixed" ? element.strokeWidth / 2 : 0;
 
       return [
-        minX + element.x - padding,
+        minX + element.x,
-        minY + element.y - padding,
+        minY + element.y,
-        maxX + element.x + padding,
+        maxX + element.x,
-        maxY + element.y + padding,
+        maxY + element.y,
       ];
     } else if (isLinearElement(element)) {
       bounds = getLinearElementRotatedBounds(element, cx, cy, elementsMap);
@@ -682,9 +680,8 @@ export const getMinMaxXYFromCurvePathOps = (
   return [minX, minY, maxX, maxY];
 };
 
-export const getBoundsFromPoints = <P extends GlobalPoint | LocalPoint>(
+export const getBoundsFromPoints = (
-  points: readonly P[],
+  points: ExcalidrawFreeDrawElement["points"],
-  padding: number = 0,
 ): Bounds => {
   let minX = Infinity;
   let minY = Infinity;
@@ -698,18 +695,17 @@ export const getBoundsFromPoints = <P extends GlobalPoint | LocalPoint>(
     maxY = Math.max(maxY, y);
   }
 
-  return [minX - padding, minY - padding, maxX + padding, maxY + padding];
+  return [minX, minY, maxX, maxY];
 };
 
 const getFreeDrawElementAbsoluteCoords = (
   element: ExcalidrawFreeDrawElement,
 ): [number, number, number, number, number, number] => {
   const [minX, minY, maxX, maxY] = getBoundsFromPoints(element.points);
-  const padding = element.strokeShape === "fixed" ? element.strokeWidth / 2 : 0;
+  const x1 = minX + element.x;
-  const x1 = minX + element.x - padding;
+  const y1 = minY + element.y;
-  const y1 = minY + element.y - padding;
+  const x2 = maxX + element.x;
-  const x2 = maxX + element.x + padding;
+  const y2 = maxY + element.y;
-  const y2 = maxY + element.y + padding;
   return [x1, y1, x2, y2, (x1 + x2) / 2, (y1 + y2) / 2];
 };
 
@@ -793,27 +789,41 @@ export const getArrowheadPoints = (
     p0 = pointFrom(prevOp.data[4], prevOp.data[5]);
   }
 
-  // B(t) = p0 * (1-t)^3 + 3p1 * t * (1-t)^2 + 3p2 * t^2 * (1-t) + p3 * t^3
+  // We know the last point of the arrow (or the first, if start arrowhead).
-  const equation = (t: number, idx: number) =>
-    Math.pow(1 - t, 3) * p3[idx] +
-    3 * t * Math.pow(1 - t, 2) * p2[idx] +
-    3 * Math.pow(t, 2) * (1 - t) * p1[idx] +
-    p0[idx] * Math.pow(t, 3);
-
-  // Ee know the last point of the arrow (or the first, if start arrowhead).
   const [x2, y2] = position === "start" ? p0 : p3;
 
-  // By using cubic bezier equation (B(t)) and the given parameters,
+  // Use the analytic tangent at the Bézier endpoint for a precise arrowhead
-  // we calculate a point that is closer to the last point.
+  // direction. For a cubic Bézier B(t) with control points p0p3:
-  // The value 0.3 is chosen arbitrarily and it works best for all
+  //   B'(1): (p3 − p2) tangent at the end
-  // the tested cases.
+  //   B'(0): (p1 − p0) for start arrowhead, arrow points away: (p0 − p1)
-  const [x1, y1] = [equation(0.3, 0), equation(0.3, 1)];
+  let dx: number;
-
+  let dy: number;
-  // Find the normalized direction vector based on the
+  if (position === "end") {
-  // previously calculated points.
+    dx = p3[0] - p2[0];
-  const distance = Math.hypot(x2 - x1, y2 - y1);
+    dy = p3[1] - p2[1];
-  const nx = (x2 - x1) / distance;
+    if (Math.hypot(dx, dy) < 1e-6) {
-  const ny = (y2 - y1) / distance;
+      dx = p3[0] - p1[0];
+      dy = p3[1] - p1[1];
+    }
+    if (Math.hypot(dx, dy) < 1e-6) {
+      dx = p3[0] - p0[0];
+      dy = p3[1] - p0[1];
+    }
+  } else {
+    dx = p0[0] - p1[0];
+    dy = p0[1] - p1[1];
+    if (Math.hypot(dx, dy) < 1e-6) {
+      dx = p0[0] - p2[0];
+      dy = p0[1] - p2[1];
+    }
+    if (Math.hypot(dx, dy) < 1e-6) {
+      dx = p0[0] - p3[0];
+      dy = p0[1] - p3[1];
+    }
+  }
+  const distance = Math.hypot(dx, dy);
+  const nx = dx / distance;
+  const ny = dy / distance;
 
   const size = getArrowheadSize(arrowhead);
 
@@ -1265,17 +1275,6 @@ export const pointInsideBounds = <P extends GlobalPoint | LocalPoint>(
 ): boolean =>
   p[0] > bounds[0] && p[0] < bounds[2] && p[1] > bounds[1] && p[1] < bounds[3];
 
-// TODO make pointInsideBounds inclusive and remove this function once we
-// test nothing is breaking
-export const pointInsideBoundsInclusive = <P extends GlobalPoint | LocalPoint>(
-  p: P,
-  bounds: Bounds,
-): boolean =>
-  p[0] >= bounds[0] &&
-  p[0] <= bounds[2] &&
-  p[1] >= bounds[1] &&
-  p[1] <= bounds[3];
-
 export const doBoundsIntersect = (
   bounds1: Bounds | null,
   bounds2: Bounds | null,
@@ -1290,21 +1289,13 @@ export const doBoundsIntersect = (
   return minX1 < maxX2 && maxX1 > minX2 && minY1 < maxY2 && maxY1 > minY2;
 };
 
-export const boundsContainBounds = (outerBounds: Bounds, innerBounds: Bounds) =>
-  [
-    pointFrom<GlobalPoint>(innerBounds[0], innerBounds[1]),
-    pointFrom<GlobalPoint>(innerBounds[0], innerBounds[3]),
-    pointFrom<GlobalPoint>(innerBounds[2], innerBounds[1]),
-    pointFrom<GlobalPoint>(innerBounds[2], innerBounds[3]),
-  ].every((point) => pointInsideBoundsInclusive(point, outerBounds));
-
 export const elementCenterPoint = (
   element: ExcalidrawElement,
   elementsMap: ElementsMap,
   xOffset: number = 0,
   yOffset: number = 0,
 ) => {
-  if (isLinearElement(element) || isFreeDrawElement(element)) {
+  if (isLinearElement(element)) {
     const [x1, y1, x2, y2] = getElementAbsoluteCoords(element, elementsMap);
     const [x, y] = pointFrom<GlobalPoint>((x1 + x2) / 2, (y1 + y2) / 2);
 

packages/element/src/collision.ts

@@ -27,7 +27,6 @@ import type {
 
 import type { FrameNameBounds } from "@excalidraw/excalidraw/types";
 
-import { isLoopFreeDrawElement } from "./freedraw";
 import { isPathALoop } from "./utils";
 import {
   doBoundsIntersect,
@@ -94,7 +93,7 @@ export const shouldTestInside = (element: ExcalidrawElement) => {
   }
 
   if (element.type === "freedraw") {
-    return isDraggableFromInside && isLoopFreeDrawElement(element);
+    return isDraggableFromInside && isPathALoop(element.points);
   }
 
   return isDraggableFromInside || isImageElement(element);
@@ -155,11 +154,14 @@ export const hitElementItself = ({
 
   // Hit test against the extended, rotated bounding box of the element first
   const bounds = getElementBounds(element, elementsMap, true);
-  const hitBounds = isPointInRotatedBounds(
+  const hitBounds = isPointWithinBounds(
-    point,
+    pointFrom(bounds[0] - threshold, bounds[1] - threshold),
-    bounds,
+    pointRotateRads(
-    element.angle,
+      point,
-    threshold,
+      getCenterForBounds(bounds),
+      -element.angle as Radians,
+    ),
+    pointFrom(bounds[2] + threshold, bounds[3] + threshold),
   );
 
   // PERF: Bail out early if the point is not even in the
@@ -190,32 +192,18 @@ export const hitElementItself = ({
   return result;
 };
 
-const isPointInRotatedBounds = (
-  point: GlobalPoint,
-  bounds: Bounds,
-  angle: Radians,
-  tolerance = 0,
-) => {
-  const adjustedPoint =
-    angle === 0
-      ? point
-      : pointRotateRads(point, getCenterForBounds(bounds), -angle as Radians);
-
-  return isPointWithinBounds(
-    pointFrom(bounds[0] - tolerance, bounds[1] - tolerance),
-    adjustedPoint,
-    pointFrom(bounds[2] + tolerance, bounds[3] + tolerance),
-  );
-};
-
 export const hitElementBoundingBox = (
   point: GlobalPoint,
   element: ExcalidrawElement,
   elementsMap: ElementsMap,
   tolerance = 0,
 ) => {
-  const bounds = getElementBounds(element, elementsMap, true);
+  let [x1, y1, x2, y2] = getElementBounds(element, elementsMap);
-  return isPointInRotatedBounds(point, bounds, element.angle, tolerance);
+  x1 -= tolerance;
+  y1 -= tolerance;
+  x2 += tolerance;
+  y2 += tolerance;
+  return isPointWithinBounds(pointFrom(x1, y1), point, pointFrom(x2, y2));
 };
 
 export const hitElementBoundingBoxOnly = (
@@ -477,12 +465,7 @@ export const intersectElementWithLineSegment = (
     case "line":
     case "freedraw":
     case "arrow":
-      return intersectLinearOrFreeDrawWithLineSegment(
+      return intersectLinearOrFreeDrawWithLineSegment(element, line, onlyFirst);
-        element,
-        line,
-        elementsMap,
-        onlyFirst,
-      );
   }
 };
 
@@ -549,15 +532,11 @@ const lineIntersections = (
 const intersectLinearOrFreeDrawWithLineSegment = (
   element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement,
   segment: LineSegment<GlobalPoint>,
-  elementsMap: ElementsMap,
   onlyFirst = false,
 ): GlobalPoint[] => {
   // NOTE: This is the only one which return the decomposed elements
   // rotated! This is due to taking advantage of roughjs definitions.
-  const [lines, curves] = deconstructLinearOrFreeDrawElement(
+  const [lines, curves] = deconstructLinearOrFreeDrawElement(element);
-    element,
-    elementsMap,
-  );
   const intersections: GlobalPoint[] = [];
 
   for (const l of lines) {
@@ -585,9 +564,7 @@ const intersectLinearOrFreeDrawWithLineSegment = (
       continue;
     }
 
-    const hits = curveIntersectLineSegment(c, segment, {
+    const hits = curveIntersectLineSegment(c, segment);
-      iterLimit: 10,
-    });
 
     if (hits.length > 0) {
       intersections.push(...hits);
@@ -755,8 +732,8 @@ export const isPointInElement = (
   elementsMap: ElementsMap,
 ) => {
   if (
-    (isLinearElement(element) && !isPathALoop(element.points)) ||
+    (isLinearElement(element) || isFreeDrawElement(element)) &&
-    (isFreeDrawElement(element) && !isLoopFreeDrawElement(element))
+    !isPathALoop(element.points)
   ) {
     // There isn't any "inside" for a non-looping path
     return false;

packages/element/src/distance.ts

@@ -48,7 +48,7 @@ export const distanceToElement = (
     case "line":
     case "arrow":
     case "freedraw":
-      return distanceToLinearOrFreeDraElement(element, elementsMap, p);
+      return distanceToLinearOrFreeDraElement(element, p);
   }
 };
 
@@ -133,13 +133,9 @@ const distanceToEllipseElement = (
 
 const distanceToLinearOrFreeDraElement = (
   element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement,
-  elementsMap: ElementsMap,
   p: GlobalPoint,
 ) => {
-  const [lines, curves] = deconstructLinearOrFreeDrawElement(
+  const [lines, curves] = deconstructLinearOrFreeDrawElement(element);
-    element,
-    elementsMap,
-  );
   return Math.min(
     ...lines.map((s) => distanceToLineSegment(p, s)),
     ...curves.map((a) => curvePointDistance(a, p)),

packages/element/src/frame.ts

@@ -1,6 +1,7 @@
 import { arrayToMap } from "@excalidraw/common";
 import { isPointWithinBounds, pointFrom } from "@excalidraw/math";
 import { doLineSegmentsIntersect } from "@excalidraw/utils/bbox";
+import { elementsOverlappingBBox } from "@excalidraw/utils/withinBounds";
 
 import type {
   AppClassProperties,
@@ -17,8 +18,6 @@ import {
   getElementLineSegments,
   getCommonBounds,
   getElementAbsoluteCoords,
-  doBoundsIntersect,
-  getElementBounds,
 } from "./bounds";
 import { mutateElement } from "./mutateElement";
 import { getBoundTextElement, getContainerElement } from "./textElement";
@@ -921,17 +920,16 @@ export const getFrameLikeTitle = (element: ExcalidrawFrameLikeElement) => {
 export const getElementsOverlappingFrame = (
   elements: readonly ExcalidrawElement[],
   frame: ExcalidrawFrameLikeElement,
-  elementsMap: ElementsMap,
 ) => {
-  return elements.filter(
+  return (
-    (el) =>
+    elementsOverlappingBBox({
-      // exclude elements which are overlapping, but are in a different frame,
+      elements,
+      bounds: frame,
+      type: "overlap",
+    })
+      // removes elements who are overlapping, but are in a different frame,
       // and thus invisible in target frame
-      (!el.frameId || el.frameId === frame.id) &&
+      .filter((el) => !el.frameId || el.frameId === frame.id)
-      doBoundsIntersect(
-        getElementBounds(el, elementsMap),
-        getElementBounds(frame, elementsMap),
-      ),
   );
 };
 

packages/element/src/freedraw.ts

@@ -1,181 +0,0 @@
-import {
-  pointDistance,
-  vectorCross,
-  vectorDot,
-  vectorFromPoint,
-} from "@excalidraw/math";
-
-import type { LocalPoint } from "@excalidraw/math";
-
-import { isPathALoop } from "./utils";
-
-import type { ExcalidrawFreeDrawElement } from "./types";
-
-type ZoomValue = NonNullable<Parameters<typeof isPathALoop>[1]>;
-
-type FixedFreeDrawSimplificationProfile = {
-  minPointDistancePx: number;
-  maxPointDistance: number;
-  strokeDistanceFactor: number;
-  collinearityFactor: number;
-  minAlignment: number;
-  zoomScaling: "sqrt" | "none";
-};
-
-const FIXED_FREEDRAW_CAPTURE_PROFILE: FixedFreeDrawSimplificationProfile = {
-  minPointDistancePx: 0.35,
-  maxPointDistance: 0.85,
-  strokeDistanceFactor: 0.08,
-  collinearityFactor: 0.3,
-  minAlignment: 0.985,
-  zoomScaling: "sqrt",
-};
-
-const hasSyntheticLoopClosure = (
-  points: readonly LocalPoint[],
-): points is readonly [LocalPoint, LocalPoint, ...LocalPoint[]] => {
-  if (points.length < 3) {
-    return false;
-  }
-
-  const firstPoint = points[0];
-  const lastPoint = points[points.length - 1];
-
-  return firstPoint[0] === lastPoint[0] && firstPoint[1] === lastPoint[1];
-};
-
-const stripSyntheticLoopClosure = (points: readonly LocalPoint[]) =>
-  hasSyntheticLoopClosure(points) ? points.slice(0, -1) : points;
-
-export const isLoopFreeDrawElement = (
-  element: ExcalidrawFreeDrawElement,
-  zoomValue: ZoomValue = 1 as ZoomValue,
-) => element.strokeShape !== "fixed" && isPathALoop(element.points, zoomValue);
-
-export const getFixedFreeDrawPoints = (
-  element: ExcalidrawFreeDrawElement,
-): readonly LocalPoint[] => stripSyntheticLoopClosure(element.points);
-
-export const getFixedFreeDrawPointSamplingDistance = (
-  strokeWidth: number,
-  zoomValue: ZoomValue = 1 as ZoomValue,
-  profile: FixedFreeDrawSimplificationProfile = FIXED_FREEDRAW_CAPTURE_PROFILE,
-) =>
-  Math.min(
-    Math.max(
-      profile.minPointDistancePx /
-        (profile.zoomScaling === "sqrt"
-          ? Math.max(1, Math.sqrt(zoomValue))
-          : 1),
-      strokeWidth * profile.strokeDistanceFactor,
-    ),
-    profile.maxPointDistance,
-  );
-
-const isRedundantFixedFreeDrawPoint = (
-  previousPoint: LocalPoint,
-  currentPoint: LocalPoint,
-  nextPoint: LocalPoint,
-  strokeWidth: number,
-  zoomValue: ZoomValue,
-  profile: FixedFreeDrawSimplificationProfile,
-) => {
-  const previousSegmentLength = pointDistance(previousPoint, currentPoint);
-  const nextSegmentLength = pointDistance(currentPoint, nextPoint);
-
-  if (!previousSegmentLength || !nextSegmentLength) {
-    return true;
-  }
-
-  const previousVector = vectorFromPoint(currentPoint, previousPoint);
-  const nextVector = vectorFromPoint(nextPoint, currentPoint);
-  const alignment =
-    vectorDot(previousVector, nextVector) /
-    (previousSegmentLength * nextSegmentLength);
-
-  if (alignment < profile.minAlignment) {
-    return false;
-  }
-
-  const chord = vectorFromPoint(nextPoint, previousPoint);
-  const chordLength = pointDistance(previousPoint, nextPoint);
-
-  if (!chordLength) {
-    return true;
-  }
-
-  const distanceToChord =
-    Math.abs(vectorCross(vectorFromPoint(currentPoint, previousPoint), chord)) /
-    chordLength;
-
-  return (
-    distanceToChord <=
-    getFixedFreeDrawPointSamplingDistance(strokeWidth, zoomValue, profile) *
-      profile.collinearityFactor
-  );
-};
-
-export const getFixedFreeDrawPointAction = ({
-  points,
-  nextPoint,
-  strokeWidth,
-  zoomValue,
-  isFinalPoint = false,
-  profile,
-}: {
-  points: readonly LocalPoint[];
-  nextPoint: LocalPoint;
-  strokeWidth: number;
-  zoomValue: ZoomValue;
-  isFinalPoint?: boolean;
-  profile?: FixedFreeDrawSimplificationProfile;
-}) => {
-  const simplificationProfile = profile ?? FIXED_FREEDRAW_CAPTURE_PROFILE;
-  const lastPoint = points[points.length - 1];
-
-  if (!lastPoint) {
-    return "append" as const;
-  }
-
-  if (lastPoint[0] === nextPoint[0] && lastPoint[1] === nextPoint[1]) {
-    return "discard" as const;
-  }
-
-  const samplingDistance = getFixedFreeDrawPointSamplingDistance(
-    strokeWidth,
-    zoomValue,
-    simplificationProfile,
-  );
-
-  if (points.length === 1) {
-    return !isFinalPoint &&
-      pointDistance(lastPoint, nextPoint) < samplingDistance
-      ? ("discard" as const)
-      : ("append" as const);
-  }
-
-  const previousPoint = points[points.length - 2];
-
-  if (
-    isRedundantFixedFreeDrawPoint(
-      previousPoint,
-      lastPoint,
-      nextPoint,
-      strokeWidth,
-      zoomValue,
-      simplificationProfile,
-    )
-  ) {
-    return "replace" as const;
-  }
-
-  if (!isFinalPoint && pointDistance(lastPoint, nextPoint) < samplingDistance) {
-    return "discard" as const;
-  }
-
-  return "append" as const;
-};
-
-export const getRenderableFixedFreeDrawPoints = (
-  element: ExcalidrawFreeDrawElement,
-): readonly LocalPoint[] => getFixedFreeDrawPoints(element);

packages/element/src/index.ts

@@ -69,7 +69,6 @@ export * from "./duplicate";
 export * from "./elbowArrow";
 export * from "./elementLink";
 export * from "./embeddable";
-export * from "./freedraw";
 export * from "./flowchart";
 export * from "./arrows/focus";
 export * from "./fractionalIndex";

packages/element/src/linearElementEditor.ts

@@ -476,22 +476,16 @@ export class LinearElementEditor {
       });
     }
 
-    if (
+    invariant(
-      lastClickedPoint < 0 ||
+      lastClickedPoint > -1 &&
-      !selectedPointsIndices.includes(lastClickedPoint) ||
+        selectedPointsIndices.includes(lastClickedPoint) &&
-      !element.points[lastClickedPoint]
+        element.points[lastClickedPoint],
-    ) {
+      `There must be a valid lastClickedPoint in order to drag it. selectedPointsIndices(${JSON.stringify(
-      console.error(
+        selectedPointsIndices,
-        `There must be a valid lastClickedPoint in order to drag it. selectedPointsIndices(${JSON.stringify(
+      )}) points(0..${
-          selectedPointsIndices,
+        element.points.length - 1
-        )}) points(0..${
+      }) lastClickedPoint(${lastClickedPoint})`,
-          element.points.length - 1
+    );
-        }) lastClickedPoint(${lastClickedPoint})`,
-      );
-
-      // Fall back to the actual last point as a last resort.
-      lastClickedPoint = element.points.length - 1;
-    }
 
     // point that's being dragged (out of all selected points)
     const draggingPoint = element.points[lastClickedPoint];
@@ -790,9 +784,20 @@ export class LinearElementEditor {
       elementsMap,
     );
 
+    // For curved (non-elbow) arrows the quadratic spline produces N-2 arcs
+    // for N anchor points. Cap the loop to the actual segment count so we
+    // don't request a midpoint for a segment that doesn't exist.
+    const [lines, segCurves] = deconstructLinearOrFreeDrawElement(element);
+    const segmentCount = lines.length + segCurves.length;
+
     let index = 0;
     const midpoints: (GlobalPoint | null)[] = [];
     while (index < points.length - 1) {
+      if (segmentCount > 0 && index >= segmentCount) {
+        midpoints.push(null);
+        index++;
+        continue;
+      }
       if (
         LinearElementEditor.isSegmentTooShort(
           element,
@@ -800,7 +805,6 @@ export class LinearElementEditor {
           element.points[index + 1],
           index,
           appState.zoom,
-          elementsMap,
         )
       ) {
         midpoints.push(null);
@@ -810,7 +814,6 @@ export class LinearElementEditor {
       const segmentMidPoint = LinearElementEditor.getSegmentMidPoint(
         element,
         index + 1,
-        elementsMap,
       );
       midpoints.push(segmentMidPoint);
       index++;
@@ -898,7 +901,6 @@ export class LinearElementEditor {
     endPoint: P,
     index: number,
     zoom: Zoom,
-    elementsMap: ElementsMap,
   ) {
     if (isElbowArrow(element)) {
       if (index >= 0 && index < element.points.length) {
@@ -913,10 +915,7 @@ export class LinearElementEditor {
 
     let distance = pointDistance(startPoint, endPoint);
     if (element.points.length > 2 && element.roundness) {
-      const [lines, curves] = deconstructLinearOrFreeDrawElement(
+      const [lines, curves] = deconstructLinearOrFreeDrawElement(element);
-        element,
-        elementsMap,
-      );
 
       invariant(
         lines.length === 0 && curves.length > 0,
@@ -936,7 +935,6 @@ export class LinearElementEditor {
   static getSegmentMidPoint(
     element: NonDeleted<ExcalidrawLinearElement>,
     index: number,
-    elementsMap: ElementsMap,
   ): GlobalPoint {
     if (isElbowArrow(element)) {
       invariant(
@@ -949,10 +947,7 @@ export class LinearElementEditor {
       return pointFrom<GlobalPoint>(element.x + p[0], element.y + p[1]);
     }
 
-    const [lines, curves] = deconstructLinearOrFreeDrawElement(
+    const [lines, curves] = deconstructLinearOrFreeDrawElement(element);
-      element,
-      elementsMap,
-    );
 
     invariant(
       (lines.length === 0 && curves.length > 0) ||
@@ -1867,7 +1862,6 @@ export class LinearElementEditor {
       const midSegmentMidpoint = LinearElementEditor.getSegmentMidPoint(
         element,
         index + 1,
-        elementsMap,
       );
 
       x = midSegmentMidpoint[0] - boundTextElement.width / 2;
@@ -2417,7 +2411,7 @@ const pointDraggingUpdates = (
     ? nextArrow.points[0]
     : endBindable
     ? updateBoundPoint(
-        nextArrow,
+        element,
         "endBinding",
         nextArrow.endBinding,
         endBindable,
@@ -2448,7 +2442,7 @@ const pointDraggingUpdates = (
       ? endLocalPoint
       : startBindable
       ? updateBoundPoint(
-          nextArrow,
+          element,
           "startBinding",
           nextArrow.startBinding,
           startBindable,

packages/element/src/mutateElement.ts

@@ -1,5 +1,4 @@
 import {
-  DEFAULT_FREE_DRAW_STROKE_SHAPE,
   getSizeFromPoints,
   randomInteger,
   getUpdatedTimestamp,
@@ -19,8 +18,6 @@ import type {
   ElementsMap,
   ExcalidrawElbowArrowElement,
   ExcalidrawElement,
-  ExcalidrawFreeDrawElement,
-  FreeDrawStrokeShape,
   NonDeletedSceneElementsMap,
 } from "./types";
 
@@ -180,30 +177,6 @@ export const newElementWith = <TElement extends ExcalidrawElement>(
   };
 };
 
-export const newFreeDrawElementWithStrokeShape = <
-  TElement extends ExcalidrawFreeDrawElement,
->(
-  element: TElement,
-  strokeShape: FreeDrawStrokeShape,
-): TElement => {
-  if (strokeShape === DEFAULT_FREE_DRAW_STROKE_SHAPE) {
-    if (!("strokeShape" in element)) {
-      return element;
-    }
-    const nextElement = newElementWith(
-      element,
-      {} as ElementUpdate<TElement>,
-      true,
-    );
-    delete (nextElement as Mutable<Partial<TElement>>).strokeShape;
-    return nextElement;
-  }
-
-  return newElementWith(element, {
-    strokeShape,
-  } as ElementUpdate<TElement>);
-};
-
 /**
  * Mutates element, bumping `version`, `versionNonce`, and `updated`.
  *

packages/element/src/newElement.ts

@@ -445,7 +445,6 @@ export const newFreeDrawElement = (
     points?: ExcalidrawFreeDrawElement["points"];
     simulatePressure: boolean;
     pressures?: ExcalidrawFreeDrawElement["pressures"];
-    strokeShape?: ExcalidrawFreeDrawElement["strokeShape"];
   } & ElementConstructorOpts,
 ): NonDeleted<ExcalidrawFreeDrawElement> => {
   return {
@@ -453,7 +452,6 @@ export const newFreeDrawElement = (
     points: opts.points || [],
     pressures: opts.pressures || [],
     simulatePressure: opts.simulatePressure,
-    ...(opts.strokeShape === "fixed" ? { strokeShape: opts.strokeShape } : {}),
   };
 };
 

packages/element/src/renderElement.ts

@@ -417,27 +417,16 @@ const drawElementOnCanvas = (
     case "freedraw": {
       // Draw directly to canvas
       context.save();
-      context.lineJoin = "round";
-      context.lineCap = "round";
 
       const shapes = ShapeCache.generateElementShape(element, renderConfig);
-      const isFixedStroke = element.strokeShape === "fixed";
 
       for (const shape of shapes) {
         if (typeof shape === "string") {
-          const strokeColor =
+          context.fillStyle =
             renderConfig.theme === THEME.DARK
               ? applyDarkModeFilter(element.strokeColor)
               : element.strokeColor;
-
+          context.fill(new Path2D(shape));
-          if (isFixedStroke) {
-            context.strokeStyle = strokeColor;
-            context.lineWidth = element.strokeWidth;
-            context.stroke(new Path2D(shape));
-          } else {
-            context.fillStyle = strokeColor;
-            context.fill(new Path2D(shape));
-          }
         } else {
           rc.draw(shape);
         }

packages/element/src/selection.ts

@@ -1,32 +1,15 @@
-import { arrayToMap, isShallowEqual, type Bounds } from "@excalidraw/common";
+import { arrayToMap, isShallowEqual } from "@excalidraw/common";
-import {
-  lineSegment,
-  pointFrom,
-  pointRotateRads,
-  type GlobalPoint,
-} from "@excalidraw/math";
 
 import type {
   AppState,
-  BoxSelectionMode,
   InteractiveCanvasAppState,
 } from "@excalidraw/excalidraw/types";
 
-import {
+import { getElementAbsoluteCoords, getElementBounds } from "./bounds";
-  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";
@@ -34,38 +17,19 @@ import {
   elementOverlapsWithFrame,
   getContainingFrame,
   getFrameChildren,
-  isElementIntersectingFrame,
 } from "./frame";
 
 import { LinearElementEditor } from "./linearElementEditor";
 import { selectGroupsForSelectedElements } from "./groups";
-import { getBoundTextElement } from "./textElement";
 
 import type {
   ElementsMap,
   ElementsMapOrArray,
   ExcalidrawElement,
-  ExcalidrawFrameLikeElement,
   NonDeleted,
   NonDeletedExcalidrawElement,
 } from "./types";
 
-const shouldIgnoreElementFromSelection = (
-  element: NonDeletedExcalidrawElement,
-) => element.locked || isBoundToContainer(element);
-
-const excludeElementsFromFrames = <T extends ExcalidrawElement>(
-  selectedElements: readonly T[],
-  framesInSelection: Set<ExcalidrawFrameLikeElement["id"]>,
-) => {
-  return selectedElements.filter((element) => {
-    if (element.frameId && framesInSelection.has(element.frameId)) {
-      return false;
-    }
-    return true;
-  });
-};
-
 /**
  * Frames and their containing elements are not to be selected at the same time.
  * Given an array of selected elements, if there are frames and their containing elements
@@ -85,243 +49,55 @@ export const excludeElementsInFramesFromSelection = <
     }
   });
 
-  return excludeElementsFromFrames(selectedElements, framesInSelection);
+  return selectedElements.filter((element) => {
+    if (element.frameId && framesInSelection.has(element.frameId)) {
+      return false;
+    }
+    return true;
+  });
 };
 
 export const getElementsWithinSelection = (
   elements: readonly NonDeletedExcalidrawElement[],
   selection: NonDeletedExcalidrawElement,
   elementsMap: ElementsMap,
-  // TODO remove (this flag is effectively unused AFAIK)
   excludeElementsInFrames: boolean = true,
-  boxSelectionMode: BoxSelectionMode = "contain",
+) => {
-): NonDeletedExcalidrawElement[] => {
+  const [selectionX1, selectionY1, selectionX2, selectionY2] =
-  const [selectionStartX, selectionStartY, selectionEndX, selectionEndY] =
     getElementAbsoluteCoords(selection, elementsMap);
-  const selectionX1 = Math.min(selectionStartX, selectionEndX);
-  const selectionY1 = Math.min(selectionStartY, selectionEndY);
-  const selectionX2 = Math.max(selectionStartX, selectionEndX);
-  const selectionY2 = Math.max(selectionStartY, selectionEndY);
-  const selectionBounds = [
-    selectionX1,
-    selectionY1,
-    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),
-    ),
-  ];
 
-  const framesInSelection = excludeElementsInFrames
+  let elementsInSelection = elements.filter((element) => {
-    ? new Set<NonDeletedExcalidrawElement["id"]>()
+    let [elementX1, elementY1, elementX2, elementY2] = getElementBounds(
-    : null;
+      element,
-  let elementsInSelection: NonDeletedExcalidrawElement[] = [];
+      elementsMap,
+    );
 
-  for (const element of elements) {
+    const containingFrame = getContainingFrame(element, elementsMap);
-    if (shouldIgnoreElementFromSelection(element)) {
+    if (containingFrame) {
-      continue;
+      const [fx1, fy1, fx2, fy2] = getElementBounds(
-    }
+        containingFrame,
-
-    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,
+      elementX1 = Math.max(fx1, elementX1);
-        y,
+      elementY1 = Math.max(fy1, elementY1);
-        x + boundTextElement.width,
+      elementX2 = Math.min(fx2, elementX2);
-        y + boundTextElement.height,
+      elementY2 = Math.min(fy2, elementY2);
-      ] as Bounds;
     }
 
-    // Clip element bounds by its containing frame (if any), since only the
+    return (
-    // visible (frame-clipped) portion of the element is relevant for selection.
+      element.locked === false &&
-    const associatedFrame = getContainingFrame(element, elementsMap);
+      element.type !== "selection" &&
-    if (
+      !isBoundToContainer(element) &&
-      associatedFrame &&
+      selectionX1 <= elementX1 &&
-      isElementIntersectingFrame(element, associatedFrame, elementsMap)
+      selectionY1 <= elementY1 &&
-    ) {
+      selectionX2 >= elementX2 &&
-      const frameAABB = getElementBounds(associatedFrame, elementsMap);
+      selectionY2 >= elementY2
-      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
+  elementsInSelection = excludeElementsInFrames
-        ? ([
+    ? excludeElementsInFramesFromSelection(elementsInSelection)
-            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);
-      } else {
-        elementsInSelection.push(element);
-        continue;
-      }
-    }
-
-    // 2. Handle the case where the label is overlapped by the selection box
-    if (
-      boxSelectionMode === "overlap" &&
-      labelAABB &&
-      doBoundsIntersect(selectionBounds, labelAABB)
-    ) {
-      elementsInSelection.push(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.push(element);
-        continue;
-      }
-    }
-
-    // 4. We don't need to handle when the selection is inside the element
-    //    as it is separately handled in App.
-  }
-
-  elementsInSelection = framesInSelection
-    ? excludeElementsFromFrames(elementsInSelection, framesInSelection)
     : elementsInSelection;
 
   elementsInSelection = elementsInSelection.filter((element) => {

packages/element/src/textElement.ts

@@ -347,7 +347,6 @@ export const getContainerCenter = (
     midSegmentMidpoint = LinearElementEditor.getSegmentMidPoint(
       container,
       index + 1,
-      elementsMap,
     );
   }
   return { x: midSegmentMidpoint[0], y: midSegmentMidpoint[1] };

packages/element/src/types.ts

@@ -26,7 +26,6 @@ export type PointerType = "mouse" | "pen" | "touch";
 export type StrokeRoundness = "round" | "sharp";
 export type RoundnessType = ValueOf<typeof ROUNDNESS>;
 export type StrokeStyle = "solid" | "dashed" | "dotted";
-export type FreeDrawStrokeShape = "variable" | "fixed";
 export type TextAlign = typeof TEXT_ALIGN[keyof typeof TEXT_ALIGN];
 
 type VerticalAlignKeys = keyof typeof VERTICAL_ALIGN;
@@ -391,7 +390,6 @@ export type ExcalidrawFreeDrawElement = _ExcalidrawElementBase &
     points: readonly LocalPoint[];
     pressures: readonly number[];
     simulatePressure: boolean;
-    strokeShape?: FreeDrawStrokeShape;
   }>;
 
 export type FileId = string & { _brand: "FileId" };

packages/element/src/utils.ts

@@ -124,7 +124,6 @@ const setElementShapesCacheEntry = <T extends ExcalidrawElement>(
  */
 export function deconstructLinearOrFreeDrawElement(
   element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement,
-  elementsMap: ElementsMap,
 ): [LineSegment<GlobalPoint>[], Curve<GlobalPoint>[]] {
   const cachedShape = getElementShapesCacheEntry(element, 0);
 
@@ -132,7 +131,10 @@ export function deconstructLinearOrFreeDrawElement(
     return cachedShape;
   }
 
-  const ops = generateLinearCollisionShape(element, elementsMap);
+  const ops = generateLinearCollisionShape(element) as {
+    op: string;
+    data: number[];
+  }[];
   const lines = [];
   const curves = [];
 

packages/element/tests/bounds.test.ts

@@ -6,11 +6,7 @@ import type { LocalPoint } from "@excalidraw/math";
 
 import { getElementAbsoluteCoords, getElementBounds } from "../src/bounds";
 
-import type {
+import type { ExcalidrawElement, ExcalidrawLinearElement } from "../src/types";
-  ExcalidrawElement,
-  ExcalidrawFreeDrawElement,
-  ExcalidrawLinearElement,
-} from "../src/types";
 
 const _ce = ({
   x,
@@ -121,31 +117,6 @@ describe("getElementBounds", () => {
     expect(y2).toEqual(42.90569415042095);
   });
 
-  it("fixed freedraw", () => {
-    const element = {
-      ..._ce({
-        x: 40,
-        y: 30,
-        w: 10,
-        h: 0,
-        a: 0,
-        t: "freedraw",
-      }),
-      strokeWidth: 8,
-      points: [pointFrom<LocalPoint>(0, 0), pointFrom<LocalPoint>(10, 0)],
-      pressures: [],
-      simulatePressure: true,
-      strokeShape: "fixed",
-    } as unknown as ExcalidrawFreeDrawElement;
-
-    const [x1, y1, x2, y2] = getElementBounds(element, arrayToMap([element]));
-
-    expect(x1).toEqual(36);
-    expect(y1).toEqual(26);
-    expect(x2).toEqual(54);
-    expect(y2).toEqual(34);
-  });
-
   it("curved line", () => {
     const element = {
       ..._ce({
@@ -164,9 +135,9 @@ describe("getElementBounds", () => {
     } as ExcalidrawLinearElement;
 
     const [x1, y1, x2, y2] = getElementBounds(element, arrayToMap([element]));
-    expect(x1).toEqual(360.9291017525165);
+    expect(x1).toEqual(360.3176068760539);
-    expect(y1).toEqual(185.24770129343722);
+    expect(y1).toEqual(185.90654264413516);
-    expect(x2).toEqual(481.4815539037601);
+    expect(x2).toEqual(486.6924560404731);
-    expect(y2).toEqual(319.8162855827246);
+    expect(y2).toEqual(320.391865303557);
   });
 });

packages/element/tests/collision.test.tsx

@@ -1,4 +1,4 @@
-import { arrayToMap, reseed } from "@excalidraw/common";
+import { arrayToMap } from "@excalidraw/common";
 import { type GlobalPoint, type LocalPoint, pointFrom } from "@excalidraw/math";
 import { Excalidraw } from "@excalidraw/excalidraw";
 import { API } from "@excalidraw/excalidraw/tests/helpers/api";
@@ -12,7 +12,6 @@ import { hitElementItself } from "../src/collision";
 describe("check rotated elements can be hit:", () => {
   beforeEach(async () => {
     localStorage.clear();
-    reseed(7);
     await render(<Excalidraw handleKeyboardGlobally={true} />);
   });
 
@@ -57,7 +56,6 @@ describe("hitElementItself cache", () => {
     });
 
     localStorage.clear();
-    reseed(7);
     await render(<Excalidraw handleKeyboardGlobally={true} />);
   });
 

packages/element/tests/linearElementEditor.test.tsx

@@ -434,12 +434,12 @@ describe("Test Linear Elements", () => {
       expect(midPointsWithRoundEdge).toMatchInlineSnapshot(`
         [
           [
-            "54.27552",
+            "53.63967",
-            "46.16120",
+            "47.15774",
           ],
           [
-            "76.95494",
+            "78.65236",
-            "44.56052",
+            "44.31886",
           ],
         ]
       `);
@@ -499,12 +499,12 @@ describe("Test Linear Elements", () => {
       expect(newMidPoints).toMatchInlineSnapshot(`
         [
           [
-            "104.27552",
+            "103.63967",
-            "66.16120",
+            "67.15774",
           ],
           [
-            "126.95494",
+            "128.65236",
-            "64.56052",
+            "64.31886",
           ],
         ]
       `);
@@ -815,12 +815,12 @@ describe("Test Linear Elements", () => {
         expect(newMidPoints).toMatchInlineSnapshot(`
           [
             [
-              "29.28349",
+              "28.64089",
-              "20.91105",
+              "21.69997",
             ],
             [
-              "78.86048",
+              "82.34322",
-              "46.12277",
+              "47.57759",
             ],
           ]
         `);
@@ -904,12 +904,12 @@ describe("Test Linear Elements", () => {
         expect(newMidPoints).toMatchInlineSnapshot(`
           [
             [
-              "54.27552",
+              "53.63967",
-              "46.16120",
+              "47.15774",
             ],
             [
-              "76.95494",
+              "78.65236",
-              "44.56052",
+              "44.31886",
             ],
           ]
         `);
@@ -1191,7 +1191,7 @@ describe("Test Linear Elements", () => {
           20,
           105,
           80,
-          "55.45894",
+          "56.00000",
           45,
         ]
       `);
@@ -1202,7 +1202,7 @@ describe("Test Linear Elements", () => {
         .toMatchInlineSnapshot(`
           {
             "height": 130,
-            "width": "366.11716",
+            "width": "367.18528",
           }
         `);
 
@@ -1214,7 +1214,7 @@ describe("Test Linear Elements", () => {
         ),
       ).toMatchInlineSnapshot(`
         {
-          "x": "271.11716",
+          "x": "272.18528",
           "y": 45,
         }
       `);
@@ -1231,9 +1231,9 @@ describe("Test Linear Elements", () => {
         [
           20,
           35,
-          "501.11716",
+          "502.18528",
           95,
-          "205.45894",
+          "208.69244",
           "52.50000",
         ]
       `);

packages/element/tests/shape.test.ts

@@ -1,160 +0,0 @@
-import { pointFrom } from "@excalidraw/math";
-import { API } from "@excalidraw/excalidraw/tests/helpers/api";
-import { vi } from "vitest";
-
-vi.mock("perfect-freehand", () => ({
-  getStroke: vi.fn(() => []),
-}));
-
-import { getStroke } from "perfect-freehand";
-
-import { getFreedrawOutlinePoints, ShapeCache } from "../src/shape";
-
-describe("freedraw stroke shape", () => {
-  beforeEach(() => {
-    vi.mocked(getStroke).mockClear();
-    ShapeCache.destroy();
-  });
-
-  it("renders fixed strokes from the centerline path", () => {
-    const element = API.createElement({
-      type: "freedraw",
-      strokeShape: "fixed",
-      points: [pointFrom(0, 0), pointFrom(10, 10), pointFrom(20, 15)],
-    });
-
-    const shapes = ShapeCache.generateElementShape(element, null);
-
-    expect(shapes).toEqual([expect.any(String)]);
-    expect(shapes[0]).not.toContain("Z");
-    expect(vi.mocked(getStroke)).not.toHaveBeenCalled();
-  });
-
-  it("rounds fixed stroke corners without flattening them", () => {
-    const element = API.createElement({
-      type: "freedraw",
-      strokeShape: "fixed",
-      strokeWidth: 1,
-      points: [pointFrom(0, 0), pointFrom(10, 0), pointFrom(10, 10)],
-    });
-
-    const [path] = ShapeCache.generateElementShape(element, null);
-
-    expect(path).toBe("M0,0 L8.5,0 Q10,0 10,1.5 L10,10 ");
-  });
-
-  it("does not round fixed stroke hairpin turns", () => {
-    const element = API.createElement({
-      type: "freedraw",
-      strokeShape: "fixed",
-      strokeWidth: 1,
-      points: [pointFrom(0, 0), pointFrom(10, 0), pointFrom(9, 1)],
-    });
-
-    const [path] = ShapeCache.generateElementShape(element, null);
-
-    expect(path).toBe("M0,0 L10,0 L9,1 ");
-  });
-
-  it("curves directly to the endpoint for tiny final smooth segments", () => {
-    const element = API.createElement({
-      type: "freedraw",
-      strokeShape: "fixed",
-      strokeWidth: 1,
-      points: [pointFrom(0, 0), pointFrom(0.5, 0.1), pointFrom(0.8, 0.3)],
-    });
-
-    const [path] = ShapeCache.generateElementShape(element, null);
-
-    expect(path).toBe("M0,0 Q0.5,0.1 0.8,0.3 ");
-  });
-
-  it("curves directly to the endpoint for tiny final rounded corners", () => {
-    const element = API.createElement({
-      type: "freedraw",
-      strokeShape: "fixed",
-      strokeWidth: 1,
-      points: [pointFrom(0, 0), pointFrom(10, 0), pointFrom(10, 1)],
-    });
-
-    const [path] = ShapeCache.generateElementShape(element, null);
-
-    expect(path).toBe("M0,0 L9.65,0 Q10,0 10,1 ");
-  });
-
-  it("smooths dense fixed stroke points without dropping them", () => {
-    const element = API.createElement({
-      type: "freedraw",
-      strokeShape: "fixed",
-      points: [
-        pointFrom(0, 0),
-        pointFrom(0.3, 0.1),
-        pointFrom(0.6, 0.35),
-        pointFrom(1, 0.9),
-      ],
-    });
-
-    const [path] = ShapeCache.generateElementShape(element, null);
-
-    expect(path).toContain("Q0.3,0.1 ");
-    expect(path).toContain("Q0.6,0.35 ");
-  });
-
-  it("drops synthetic loop closure for fixed strokes", () => {
-    const element = API.createElement({
-      type: "freedraw",
-      strokeShape: "fixed",
-      points: [pointFrom(0, 0), pointFrom(10, 0), pointFrom(0, 0)],
-    });
-
-    const [path] = ShapeCache.generateElementShape(element, null);
-
-    expect(path).toBe("M0,0 L10,0 ");
-  });
-
-  it("uses fixed perfect-freehand settings for fixed strokes", () => {
-    const element = API.createElement({
-      type: "freedraw",
-      strokeShape: "fixed",
-      strokeWidth: 8,
-      points: [pointFrom(0, 0), pointFrom(10, 10), pointFrom(20, 15)],
-    });
-
-    getFreedrawOutlinePoints(element);
-
-    expect(vi.mocked(getStroke)).toHaveBeenCalledWith(
-      element.points,
-      expect.objectContaining({
-        simulatePressure: false,
-        size: element.strokeWidth,
-        thinning: 0,
-      }),
-    );
-  });
-
-  it("keeps pressure-aware perfect-freehand settings for variable strokes", () => {
-    const element = API.createElement({
-      type: "freedraw",
-      points: [pointFrom(0, 0), pointFrom(10, 10), pointFrom(20, 15)],
-    });
-
-    getFreedrawOutlinePoints({
-      ...element,
-      simulatePressure: false,
-      pressures: [0.2, 0.8, 0.4],
-    });
-
-    expect(vi.mocked(getStroke)).toHaveBeenCalledWith(
-      [
-        [0, 0, 0.2],
-        [10, 10, 0.8],
-        [20, 15, 0.4],
-      ],
-      expect.objectContaining({
-        simulatePressure: false,
-        size: element.strokeWidth * 4.25,
-        thinning: 0.6,
-      }),
-    );
-  });
-});

packages/excalidraw/actions/actionDeselect.ts

@@ -1,145 +0,0 @@
-import {
-  getElementsInGroup,
-  isSomeElementSelected,
-  makeNextSelectedElementIds,
-  selectGroupsForSelectedElements,
-} from "@excalidraw/element";
-import { CaptureUpdateAction } from "@excalidraw/element";
-import { KEYS, isWritableElement, updateActiveTool } from "@excalidraw/common";
-
-import type { GroupId } from "@excalidraw/element/types";
-
-import { register } from "./register";
-
-import type { AppClassProperties, AppState } from "../types";
-
-const getNextActiveTool = (
-  appState: Readonly<AppState>,
-  app: AppClassProperties,
-) => {
-  if (appState.activeTool.type === "eraser") {
-    return updateActiveTool(appState, {
-      ...(appState.activeTool.lastActiveTool || {
-        type: app.state.preferredSelectionTool.type,
-      }),
-      lastActiveToolBeforeEraser: null,
-    });
-  }
-
-  return updateActiveTool(appState, {
-    type: app.state.preferredSelectionTool.type,
-  });
-};
-
-const getParentEditingGroupId = (
-  appState: Readonly<AppState>,
-  app: AppClassProperties,
-  selectedElementIds: AppState["selectedElementIds"],
-): GroupId | null => {
-  if (!appState.editingGroupId) {
-    return null;
-  }
-
-  const nonDeletedElements = app.scene.getNonDeletedElements();
-  const selectedElements = app.scene.getSelectedElements({
-    selectedElementIds,
-    elements: nonDeletedElements,
-  });
-  const candidateElements = selectedElements.length
-    ? selectedElements
-    : getElementsInGroup(nonDeletedElements, appState.editingGroupId);
-
-  for (const element of candidateElements) {
-    const editingGroupIndex = element.groupIds.indexOf(appState.editingGroupId);
-    if (editingGroupIndex !== -1 && element.groupIds[editingGroupIndex + 1]) {
-      return element.groupIds[editingGroupIndex + 1] as GroupId;
-    }
-  }
-
-  return null;
-};
-
-export const actionDeselect = register({
-  name: "deselect",
-  label: "",
-  trackEvent: false,
-  perform: (_elements, appState, _, app) => {
-    const activeTool = getNextActiveTool(appState, app);
-
-    if (appState.editingGroupId) {
-      const nonDeletedElements = app.scene.getNonDeletedElements();
-      const selectedElementIds =
-        Object.keys(appState.selectedElementIds).length > 0
-          ? appState.selectedElementIds
-          : getElementsInGroup(
-              nonDeletedElements,
-              appState.editingGroupId,
-            ).reduce((acc, element) => {
-              acc[element.id] = true;
-              return acc;
-            }, {} as Record<string, true>);
-
-      return {
-        appState: {
-          ...appState,
-          ...selectGroupsForSelectedElements(
-            {
-              editingGroupId: getParentEditingGroupId(
-                appState,
-                app,
-                selectedElementIds,
-              ),
-              selectedElementIds,
-            },
-            nonDeletedElements,
-            appState,
-            app,
-          ),
-          activeEmbeddable: null,
-          activeTool,
-          selectedLinearElement: null,
-          selectionElement: null,
-          showHyperlinkPopup: false,
-          suggestedBinding: null,
-        },
-        captureUpdate: CaptureUpdateAction.IMMEDIATELY,
-      };
-    }
-
-    return {
-      appState: {
-        ...appState,
-        activeEmbeddable: null,
-        activeTool,
-        editingGroupId: null,
-        selectedElementIds: makeNextSelectedElementIds({}, appState),
-        selectedGroupIds: {},
-        selectedLinearElement: null,
-        selectionElement: null,
-        showHyperlinkPopup: false,
-        suggestedBinding: null,
-      },
-      captureUpdate: CaptureUpdateAction.IMMEDIATELY,
-    };
-  },
-  keyTest: (event, appState, _, app) => {
-    if (event.key !== KEYS.ESCAPE) {
-      return false;
-    }
-
-    if (isWritableElement(event.target)) {
-      return false;
-    }
-
-    return (
-      !appState.newElement &&
-      appState.multiElement === null &&
-      !appState.selectedLinearElement?.isEditing &&
-      (appState.activeEmbeddable !== null ||
-        appState.activeTool.type !== app.state.preferredSelectionTool.type ||
-        !!appState.editingGroupId ||
-        !!appState.selectedLinearElement ||
-        isSomeElementSelected(app.scene.getNonDeletedElements(), appState))
-    );
-  },
-});

packages/excalidraw/actions/actionFinalize.tsx

@@ -2,7 +2,6 @@ import { pointFrom } from "@excalidraw/math";
 
 import { bindOrUnbindBindingElement } from "@excalidraw/element/binding";
 import {
-  isLoopFreeDrawElement,
   isValidPolygon,
   LinearElementEditor,
   newElementWith,
@@ -243,11 +242,7 @@ export const actionFinalize = register<FormData>({
         // If the multi point line closes the loop,
         // set the last point to first point.
         // This ensures that loop remains closed at different scales.
-        const isLoop = isLineElement(element)
+        const isLoop = isPathALoop(element.points, appState.zoom.value);
-          ? isPathALoop(element.points, appState.zoom.value)
-          : isFreeDrawElement(element)
-          ? isLoopFreeDrawElement(element, appState.zoom.value)
-          : false;
 
         if (isLoop && (isLineElement(element) || isFreeDrawElement(element))) {
           const linePoints = element.points;
@@ -353,7 +348,9 @@ export const actionFinalize = register<FormData>({
     };
   },
   keyTest: (event, appState) =>
-    (event.key === KEYS.ESCAPE && appState.selectedLinearElement?.isEditing) ||
+    (event.key === KEYS.ESCAPE &&
+      (appState.selectedLinearElement?.isEditing ||
+        (!appState.newElement && appState.multiElement === null))) ||
     ((event.key === KEYS.ESCAPE || event.key === KEYS.ENTER) &&
       appState.multiElement !== null),
   PanelComponent: ({ appState, updateData, data }) => (

packages/excalidraw/actions/actionProperties.test.tsx

@@ -1,5 +1,4 @@
 import { queryByTestId } from "@testing-library/react";
-import { pointFrom } from "@excalidraw/math";
 
 import {
   COLOR_PALETTE,
@@ -11,7 +10,7 @@ import {
 import { Excalidraw } from "../index";
 import { API } from "../tests/helpers/api";
 import { UI } from "../tests/helpers/ui";
-import { act, render } from "../tests/test-utils";
+import { render } from "../tests/test-utils";
 
 describe("element locking", () => {
   beforeEach(async () => {
@@ -81,20 +80,6 @@ describe("element locking", () => {
       const centerTextAlign = queryByTestId(document.body, `align-right`);
       expect(centerTextAlign).toBeChecked();
     });
-
-    it("should show the active freedraw stroke type", () => {
-      UI.clickTool("freedraw");
-
-      API.setAppState({
-        currentItemStrokeShape: "fixed",
-      });
-
-      const fixedStrokeShape = queryByTestId(
-        document.body,
-        "strokeShape-fixed",
-      );
-      expect(fixedStrokeShape).toBeChecked();
-    });
   });
 
   describe("properties when elements selected", () => {
@@ -159,9 +144,6 @@ describe("element locking", () => {
       expect(
         queryByTestId(document.body, `strokeWidth-thin`),
       ).not.toBeChecked();
-      expect(
-        queryByTestId(document.body, `strokeWidth-medium`),
-      ).not.toBeChecked();
       expect(
         queryByTestId(document.body, `strokeWidth-bold`),
       ).not.toBeChecked();
@@ -177,7 +159,6 @@ describe("element locking", () => {
       });
       const text = API.createElement({
         type: "text",
-        strokeWidth: STROKE_WIDTH.bold,
         fontFamily: FONT_FAMILY["Comic Shanns"],
       });
       API.setElements([rect, text]);
@@ -188,35 +169,5 @@ describe("element locking", () => {
         "active",
       );
     });
-
-    it("should highlight the fixed freedraw stroke type for selected elements", () => {
-      const freedraw = API.createElement({
-        type: "freedraw",
-        strokeShape: "fixed",
-        points: [pointFrom(0, 0), pointFrom(10, 10), pointFrom(20, 15)],
-      });
-      API.setElements([freedraw]);
-      API.setSelectedElements([freedraw]);
-
-      const fixedStrokeShape = queryByTestId(
-        document.body,
-        "strokeShape-fixed",
-      );
-      expect(fixedStrokeShape).toBeChecked();
-    });
-
-    it("should apply fixed freedraw stroke type to newly drawn strokes", () => {
-      UI.clickTool("freedraw");
-
-      act(() => {
-        queryByTestId(document.body, "strokeShape-fixed")?.click();
-      });
-
-      const freedraw = UI.createElement("freedraw", {
-        points: [pointFrom(0, 0), pointFrom(10, 10), pointFrom(20, 15)],
-      });
-
-      expect(freedraw.strokeShape).toBe("fixed");
-    });
   });
 });

packages/excalidraw/actions/actionProperties.tsx

@@ -3,7 +3,6 @@ import { pointFrom } from "@excalidraw/math";
 import { useEffect, useMemo, useRef, useState } from "react";
 
 import {
-  DEFAULT_FREE_DRAW_STROKE_SHAPE,
   DEFAULT_ELEMENT_BACKGROUND_COLOR_PALETTE,
   DEFAULT_ELEMENT_BACKGROUND_PICKS,
   DEFAULT_ELEMENT_STROKE_COLOR_PALETTE,
@@ -37,7 +36,6 @@ import {
 import { LinearElementEditor } from "@excalidraw/element";
 
 import { newElementWith } from "@excalidraw/element";
-import { newFreeDrawElementWithStrokeShape } from "@excalidraw/element";
 import { getArrowheadForPicker } from "@excalidraw/element";
 
 import {
@@ -49,7 +47,6 @@ import {
   isArrowElement,
   isBoundToContainer,
   isElbowArrow,
-  isFreeDrawElement,
   isLinearElement,
   isLineElement,
   isTextElement,
@@ -73,7 +70,6 @@ import type {
   ElementsMap,
   ExcalidrawBindableElement,
   ExcalidrawElement,
-  ExcalidrawFreeDrawElement,
   ExcalidrawLinearElement,
   ExcalidrawTextElement,
   FontFamilyValues,
@@ -109,11 +105,8 @@ import {
   SloppinessArtistIcon,
   SloppinessCartoonistIcon,
   StrokeWidthBaseIcon,
-  StrokeWidthMediumIcon,
   StrokeWidthBoldIcon,
   StrokeWidthExtraBoldIcon,
-  StrokeShapeFixedIcon,
-  StrokeShapeVariableIcon,
   FontSizeSmallIcon,
   FontSizeMediumIcon,
   FontSizeLargeIcon,
@@ -194,29 +187,6 @@ export const changeProperty = (
   });
 };
 
-const getFreeDrawStrokeShape = (item: {
-  strokeShape?: ExcalidrawFreeDrawElement["strokeShape"];
-  currentItemStrokeShape?: AppState["currentItemStrokeShape"];
-}) =>
-  item.strokeShape ??
-  item.currentItemStrokeShape ??
-  DEFAULT_FREE_DRAW_STROKE_SHAPE;
-
-const getAppStateWithCurrentItemStrokeShape = (
-  appState: AppState,
-  strokeShape: NonNullable<ExcalidrawFreeDrawElement["strokeShape"]>,
-) => {
-  // if (strokeShape === DEFAULT_FREE_DRAW_STROKE_SHAPE) {
-  //   const { currentItemStrokeShape, ...nextAppState } = appState;
-  //   return nextAppState;
-  // }
-
-  return {
-    ...appState,
-    currentItemStrokeShape: strokeShape,
-  };
-};
-
 export const getFormValue = function <T extends Primitive>(
   elements: readonly ExcalidrawElement[],
   app: AppClassProperties,
@@ -604,12 +574,6 @@ export const actionChangeStrokeWidth = register<
               icon: StrokeWidthBaseIcon,
               testId: "strokeWidth-thin",
             },
-            {
-              value: STROKE_WIDTH.medium,
-              text: t("labels.medium"),
-              icon: StrokeWidthMediumIcon,
-              testId: "strokeWidth-medium",
-            },
             {
               value: STROKE_WIDTH.bold,
               text: t("labels.bold"),
@@ -638,60 +602,6 @@ export const actionChangeStrokeWidth = register<
   ),
 });
 
-export const actionChangeStrokeShape = register<
-  NonNullable<ExcalidrawFreeDrawElement["strokeShape"]>
->({
-  name: "changeStrokeShape",
-  label: "labels.strokeShape",
-  trackEvent: false,
-  perform: (elements, appState, value) => {
-    invariant(value, "actionChangeStrokeShape: value must be defined");
-    return {
-      elements: changeProperty(elements, appState, (el) =>
-        isFreeDrawElement(el)
-          ? newFreeDrawElementWithStrokeShape(el, value)
-          : el,
-      ),
-      appState: getAppStateWithCurrentItemStrokeShape(appState, value),
-      captureUpdate: CaptureUpdateAction.IMMEDIATELY,
-    };
-  },
-  PanelComponent: ({ elements, appState, updateData, app }) => (
-    <fieldset>
-      <legend>{t("labels.strokeShape")}</legend>
-      <div className="buttonList">
-        <RadioSelection
-          group="stroke-shape"
-          options={[
-            {
-              value: "variable",
-              text: t("labels.strokeShape_variable"),
-              icon: StrokeShapeVariableIcon,
-              testId: "strokeShape-variable",
-            },
-            {
-              value: "fixed",
-              text: t("labels.strokeShape_fixed"),
-              icon: StrokeShapeFixedIcon,
-              testId: "strokeShape-fixed",
-            },
-          ]}
-          value={getFormValue(
-            elements,
-            app,
-            (element) =>
-              getFreeDrawStrokeShape(element as ExcalidrawFreeDrawElement),
-            isFreeDrawElement,
-            (hasSelection) =>
-              hasSelection ? null : getFreeDrawStrokeShape(appState),
-          )}
-          onChange={(value) => updateData(value)}
-        />
-      </div>
-    </fieldset>
-  ),
-});
-
 export const actionChangeSloppiness = register<ExcalidrawElement["roughness"]>({
   name: "changeSloppiness",
   label: "labels.sloppiness",

packages/excalidraw/actions/actionStyles.ts

@@ -1,5 +1,4 @@
 import {
-  DEFAULT_FREE_DRAW_STROKE_SHAPE,
   DEFAULT_FONT_SIZE,
   DEFAULT_FONT_FAMILY,
   DEFAULT_TEXT_ALIGN,
@@ -11,7 +10,6 @@ import {
 import { newElementWith } from "@excalidraw/element";
 
 import {
-  isFreeDrawElement,
   hasBoundTextElement,
   canApplyRoundnessTypeToElement,
   getDefaultRoundnessTypeForElement,
@@ -20,7 +18,6 @@ import {
   isExcalidrawElement,
   isTextElement,
 } from "@excalidraw/element";
-import { newFreeDrawElementWithStrokeShape } from "@excalidraw/element";
 
 import {
   getBoundTextElement,
@@ -157,17 +154,6 @@ export const actionPasteStyles = register({
             });
           }
 
-          if (
-            isFreeDrawElement(newElement) &&
-            isFreeDrawElement(elementStylesToCopyFrom)
-          ) {
-            newElement = newFreeDrawElementWithStrokeShape(
-              newElement,
-              elementStylesToCopyFrom.strokeShape ??
-                DEFAULT_FREE_DRAW_STROKE_SHAPE,
-            );
-          }
-
           if (isFrameLikeElement(element)) {
             newElement = newElementWith(newElement, {
               roundness: null,

packages/excalidraw/actions/index.ts

@@ -34,7 +34,6 @@ export {
 export { actionSetEmbeddableAsActiveTool } from "./actionEmbeddable";
 
 export { actionFinalize } from "./actionFinalize";
-export { actionDeselect } from "./actionDeselect";
 
 export {
   actionChangeProjectName,

packages/excalidraw/actions/types.ts

@@ -114,7 +114,6 @@ export type ActionName =
   | "distributeVertically"
   | "flipHorizontal"
   | "flipVertical"
-  | "deselect"
   | "viewMode"
   | "exportWithDarkMode"
   | "toggleTheme"

packages/excalidraw/appState.ts

@@ -128,7 +128,6 @@ export const getDefaultAppState = (): Omit<
     lockedMultiSelections: {},
     activeLockedId: null,
     bindMode: "orbit",
-    boxSelectionMode: "contain",
   };
 };
 
@@ -172,7 +171,6 @@ const APP_STATE_STORAGE_CONF = (<
   currentItemStrokeColor: { browser: true, export: false, server: false },
   currentItemStrokeStyle: { browser: true, export: false, server: false },
   currentItemStrokeWidth: { browser: true, export: false, server: false },
-  currentItemStrokeShape: { browser: true, export: false, server: false },
   currentItemTextAlign: { browser: true, export: false, server: false },
   currentHoveredFontFamily: { browser: false, export: false, server: false },
   cursorButton: { browser: true, export: false, server: false },
@@ -195,7 +193,6 @@ const APP_STATE_STORAGE_CONF = (<
   gridModeEnabled: { browser: true, export: true, server: true },
   height: { browser: false, export: false, server: false },
   isBindingEnabled: { browser: true, export: false, server: false },
-  boxSelectionMode: { browser: true, export: false, server: false },
   bindingPreference: { browser: true, export: false, server: false },
   isMidpointSnappingEnabled: { browser: true, export: false, server: false },
   defaultSidebarDockedPreference: {

packages/excalidraw/components/Actions.tsx

@@ -394,11 +394,6 @@ const CombinedShapeProperties = ({
                   hasStrokeWidth(element.type),
                 )) &&
                 renderAction("changeStrokeWidth")}
-              {(appState.activeTool.type === "freedraw" ||
-                targetElements.some(
-                  (element) => element.type === "freedraw",
-                )) &&
-                renderAction("changeStrokeShape")}
               {(hasStrokeStyle(appState.activeTool.type) ||
                 targetElements.some((element) =>
                   hasStrokeStyle(element.type),

packages/excalidraw/components/App.tsx

@@ -9,7 +9,6 @@ import {
   clamp,
   pointFrom,
   pointDistance,
-  round,
   vector,
   pointRotateRads,
   vectorFromPoint,
@@ -28,7 +27,6 @@ import {
   KEYS,
   APP_NAME,
   CURSOR_TYPE,
-  DEFAULT_TRANSFORM_HANDLE_SPACING,
   DEFAULT_MAX_IMAGE_WIDTH_OR_HEIGHT,
   DEFAULT_VERTICAL_ALIGN,
   DRAGGING_THRESHOLD,
@@ -120,7 +118,6 @@ import {
   getElementAbsoluteCoords,
   bindOrUnbindBindingElements,
   fixBindingsAfterDeletion,
-  getFixedFreeDrawPointAction,
   getHoveredElementForBinding,
   isBindingEnabled,
   updateBoundElements,
@@ -617,19 +614,6 @@ const gesture: Gesture = {
   initialScale: null,
 };
 
-const FREEDRAW_POINT_DECIMALS = 2;
-const FREEDRAW_PRESSURE_DECIMALS = 3;
-const FREEDRAW_DOT_EPSILON = 1 / 10 ** FREEDRAW_POINT_DECIMALS;
-
-const roundFreeDrawCoordinate = (value: number) =>
-  round(value, FREEDRAW_POINT_DECIMALS);
-
-const roundFreeDrawPressure = (value: number) =>
-  round(value, FREEDRAW_PRESSURE_DECIMALS);
-
-const getRoundedFreeDrawPoint = (x: number, y: number) =>
-  pointFrom<LocalPoint>(roundFreeDrawCoordinate(x), roundFreeDrawCoordinate(y));
-
 class App extends React.Component<AppProps, AppState> {
   canvas: AppClassProperties["canvas"];
   interactiveCanvas: AppClassProperties["interactiveCanvas"] = null;
@@ -2540,7 +2524,6 @@ class App extends React.Component<AppProps, AppState> {
     const magicFrameChildren = getElementsOverlappingFrame(
       this.scene.getNonDeletedElements(),
       magicFrame,
-      this.scene.getNonDeletedElementsMap(),
     ).filter((el) => !isMagicFrameElement(el));
 
     if (!magicFrameChildren.length) {
@@ -5742,13 +5725,13 @@ class App extends React.Component<AppProps, AppState> {
         const isDeleted = !nextOriginalText.trim();
         updateElement(nextOriginalText, isDeleted);
 
-        // keyboard-submit keeps focus on the edited object. For bound text, keep
+        // select the created text element only if submitting via keyboard
-        // the container selected even if the text becomes empty and is deleted.
+        // (when submitting via click it should act as signal to deselect)
-        const elementIdToSelect = viaKeyboard
+        if (!isDeleted && viaKeyboard) {
-          ? element.containerId || (!isDeleted ? element.id : null)
+          const elementIdToSelect = element.containerId
-          : null;
+            ? element.containerId
+            : element.id;
 
-        if (elementIdToSelect) {
           // needed to ensure state is updated before "finalize" action
           // that's invoked on keyboard-submit as well
           // TODO either move this into finalize as well, or handle all state
@@ -7012,23 +6995,27 @@ class App extends React.Component<AppProps, AppState> {
           },
           { informMutation: false, isDragging: false },
         );
-        const newLastIdx = multiElement.points.length - 1;
         this.setState({
           selectedLinearElement: {
             ...selectedLinearElement,
-            selectedPointsIndices: selectedLinearElement.selectedPointsIndices
+            selectedPointsIndices:
-              ? [
+              selectedLinearElement.selectedPointsIndices?.includes(
-                  ...new Set(
+                multiElement.points.length,
-                    selectedLinearElement.selectedPointsIndices.map((idx) =>
+              )
-                      Math.min(idx, newLastIdx),
+                ? [
+                    ...selectedLinearElement.selectedPointsIndices.filter(
+                      (idx) =>
+                        idx !== multiElement.points.length &&
+                        idx !== multiElement.points.length - 1,
                     ),
-                  ),
+                    multiElement.points.length - 1,
-                ]
+                  ]
-              : selectedLinearElement.selectedPointsIndices,
+                : selectedLinearElement.selectedPointsIndices,
-            lastCommittedPoint: multiElement.points[newLastIdx],
+            lastCommittedPoint:
+              multiElement.points[multiElement.points.length - 1],
             initialState: {
               ...selectedLinearElement.initialState,
-              lastClickedPoint: newLastIdx,
+              lastClickedPoint: multiElement.points.length - 1,
             },
           },
         });
@@ -7256,14 +7243,6 @@ class App extends React.Component<AppProps, AppState> {
           this.interactiveCanvas,
           isTextElement(hitElement) ? CURSOR_TYPE.TEXT : CURSOR_TYPE.CROSSHAIR,
         );
-      } else if (
-        !event[KEYS.CTRL_OR_CMD] &&
-        this.isHittingCommonBoundingBoxOfSelectedElements(
-          scenePointer,
-          selectedElements,
-        )
-      ) {
-        setCursor(this.interactiveCanvas, CURSOR_TYPE.MOVE);
       } else if (this.state.viewModeEnabled) {
         setCursor(this.interactiveCanvas, CURSOR_TYPE.GRAB);
       } else if (this.state.openDialog?.name === "elementLinkSelector") {
@@ -7755,24 +7734,17 @@ class App extends React.Component<AppProps, AppState> {
       const hitSelectedElement =
         pointerDownState.hit.element &&
         this.isASelectedElement(pointerDownState.hit.element);
-      const shouldForceLassoReselect =
-        event.altKey &&
-        event[KEYS.CTRL_OR_CMD] &&
-        !pointerDownState.resize.handleType;
-      const shouldStartLassoSelection =
-        shouldForceLassoReselect ||
-        (!pointerDownState.hit.hasHitCommonBoundingBoxOfSelectedElements &&
-          !pointerDownState.resize.handleType &&
-          !hitSelectedElement);
 
-      if (shouldStartLassoSelection) {
+      if (
-        if (!this.lassoTrail.hasCurrentTrail) {
+        !pointerDownState.hit.hasHitCommonBoundingBoxOfSelectedElements &&
-          this.lassoTrail.startPath(
+        !pointerDownState.resize.handleType &&
-            pointerDownState.origin.x,
+        !hitSelectedElement
-            pointerDownState.origin.y,
+      ) {
-            event.shiftKey,
+        this.lassoTrail.startPath(
-          );
+          pointerDownState.origin.x,
-        }
+          pointerDownState.origin.y,
+          event.shiftKey,
+        );
 
         // block dragging after lasso selection on PCs until the next pointer down
         // (on mobile or tablet, we want to allow user to drag immediately)
@@ -8095,7 +8067,7 @@ class App extends React.Component<AppProps, AppState> {
 
     setCursor(this.interactiveCanvas, CURSOR_TYPE.GRABBING);
     let { clientX: lastX, clientY: lastY } = event;
-    const onPointerMove = ((event: PointerEvent) => {
+    const onPointerMove = withBatchedUpdatesThrottled((event: PointerEvent) => {
       const deltaX = lastX - event.clientX;
       const deltaY = lastY - event.clientY;
       lastX = event.clientX;
@@ -8161,7 +8133,7 @@ class App extends React.Component<AppProps, AppState> {
         window.removeEventListener(EVENT.POINTER_MOVE, onPointerMove);
         window.removeEventListener(EVENT.POINTER_UP, teardown);
         window.removeEventListener(EVENT.BLUR, teardown);
-        // onPointerMove.flush();
+        onPointerMove.flush();
       }),
     );
     window.addEventListener(EVENT.BLUR, teardown);
@@ -8271,14 +8243,14 @@ class App extends React.Component<AppProps, AppState> {
     isDraggingScrollBar = true;
     pointerDownState.lastCoords.x = event.clientX;
     pointerDownState.lastCoords.y = event.clientY;
-    const onPointerMove = (event: PointerEvent) => {
+    const onPointerMove = withBatchedUpdatesThrottled((event: PointerEvent) => {
       const target = event.target;
       if (!(target instanceof HTMLElement)) {
         return;
       }
 
       this.handlePointerMoveOverScrollbars(event, pointerDownState);
-    };
+    });
     const onPointerUp = withBatchedUpdates(() => {
       lastPointerUp = null;
       isDraggingScrollBar = false;
@@ -8289,7 +8261,7 @@ class App extends React.Component<AppProps, AppState> {
       this.savePointer(event.clientX, event.clientY, "up");
       window.removeEventListener(EVENT.POINTER_MOVE, onPointerMove);
       window.removeEventListener(EVENT.POINTER_UP, onPointerUp);
-      // onPointerMove.flush();
+      onPointerMove.flush();
     });
 
     lastPointerUp = onPointerUp;
@@ -8761,14 +8733,12 @@ class App extends React.Component<AppProps, AppState> {
       DEFAULT_COLLISION_THRESHOLD / this.state.zoom.value,
       1,
     );
-    const boundsPadding =
-      (DEFAULT_TRANSFORM_HANDLE_SPACING * 2) / this.state.zoom.value;
     const [x1, y1, x2, y2] = getCommonBounds(selectedElements);
     return (
-      point.x > x1 - boundsPadding - threshold &&
+      point.x > x1 - threshold &&
-      point.x < x2 + boundsPadding + threshold &&
+      point.x < x2 + threshold &&
-      point.y > y1 - boundsPadding - threshold &&
+      point.y > y1 - threshold &&
-      point.y < y2 + boundsPadding + threshold
+      point.y < y2 + threshold
     );
   }
 
@@ -8848,13 +8818,10 @@ class App extends React.Component<AppProps, AppState> {
       opacity: this.state.currentItemOpacity,
       roundness: null,
       simulatePressure,
-      strokeShape: this.state.currentItemStrokeShape,
       locked: false,
       frameId: topLayerFrame ? topLayerFrame.id : null,
       points: [pointFrom<LocalPoint>(0, 0)],
-      pressures: simulatePressure
+      pressures: simulatePressure ? [] : [event.pressure],
-        ? []
-        : [roundFreeDrawPressure(event.pressure)],
     });
 
     this.scene.insertElement(element);
@@ -9496,7 +9463,7 @@ class App extends React.Component<AppProps, AppState> {
   private onPointerMoveFromPointerDownHandler(
     pointerDownState: PointerDownState,
   ) {
-    return (event: PointerEvent) => {
+    return withBatchedUpdatesThrottled((event: PointerEvent) => {
       if (this.state.openDialog?.name === "elementLinkSelector") {
         return;
       }
@@ -10192,36 +10159,20 @@ class App extends React.Component<AppProps, AppState> {
           const points = newElement.points;
           const dx = pointerCoords.x - newElement.x;
           const dy = pointerCoords.y - newElement.y;
-          const nextPoint = getRoundedFreeDrawPoint(dx, dy);
-          const pressure = roundFreeDrawPressure(event.pressure);
-          const pointAction =
-            newElement.strokeShape === "fixed"
-              ? getFixedFreeDrawPointAction({
-                  points,
-                  nextPoint,
-                  strokeWidth: newElement.strokeWidth,
-                  zoomValue: this.state.zoom.value,
-                })
-              : points.length > 0 &&
-                points[points.length - 1][0] === nextPoint[0] &&
-                points[points.length - 1][1] === nextPoint[1]
-              ? "discard"
-              : "append";
 
-          if (pointAction !== "discard") {
+          const lastPoint = points.length > 0 && points[points.length - 1];
+          const discardPoint =
+            lastPoint && lastPoint[0] === dx && lastPoint[1] === dy;
+
+          if (!discardPoint) {
             const pressures = newElement.simulatePressure
               ? newElement.pressures
-              : pointAction === "replace"
+              : [...newElement.pressures, event.pressure];
-              ? [...newElement.pressures.slice(0, -1), pressure]
-              : [...newElement.pressures, pressure];
 
             this.scene.mutateElement(
               newElement,
               {
-                points:
+                points: [...points, pointFrom<LocalPoint>(dx, dy)],
-                  pointAction === "replace"
-                    ? [...points.slice(0, -1), nextPoint]
-                    : [...points, nextPoint],
                 pressures,
               },
               {
@@ -10320,7 +10271,6 @@ class App extends React.Component<AppProps, AppState> {
                 this.state.selectionElement,
                 this.scene.getNonDeletedElementsMap(),
                 false,
-                this.state.boxSelectionMode,
               )
             : [];
 
@@ -10379,7 +10329,7 @@ class App extends React.Component<AppProps, AppState> {
           });
         }
       }
-    };
+    });
   }
 
   // Returns whether the pointer move happened over either scrollbar
@@ -10424,7 +10374,7 @@ class App extends React.Component<AppProps, AppState> {
       this.removePointer(childEvent);
       pointerDownState.drag.blockDragging = false;
       if (pointerDownState.eventListeners.onMove) {
-        // pointerDownState.eventListeners.onMove.flush();
+        pointerDownState.eventListeners.onMove.flush();
       }
       const {
         newElement,
@@ -10661,48 +10611,23 @@ class App extends React.Component<AppProps, AppState> {
         );
 
         const points = newElement.points;
-        const dx = pointerCoords.x - newElement.x;
+        let dx = pointerCoords.x - newElement.x;
-        const dy = pointerCoords.y - newElement.y;
+        let dy = pointerCoords.y - newElement.y;
-        let nextPoint = getRoundedFreeDrawPoint(dx, dy);
 
         // Allows dots to avoid being flagged as infinitely small
-        if (nextPoint[0] === points[0][0] && nextPoint[1] === points[0][1]) {
+        if (dx === points[0][0] && dy === points[0][1]) {
-          nextPoint = getRoundedFreeDrawPoint(
+          dy += 0.0001;
-            dx + FREEDRAW_DOT_EPSILON,
+          dx += 0.0001;
-            dy + FREEDRAW_DOT_EPSILON,
-          );
         }
 
-        const lastPoint = points[points.length - 1];
+        const pressures = newElement.simulatePressure
-        const pressure = roundFreeDrawPressure(childEvent.pressure);
+          ? []
-        const pointAction =
+          : [...newElement.pressures, childEvent.pressure];
-          newElement.strokeShape === "fixed"
-            ? getFixedFreeDrawPointAction({
-                points,
-                nextPoint,
-                strokeWidth: newElement.strokeWidth,
-                zoomValue: this.state.zoom.value,
-                isFinalPoint: true,
-              })
-            : !lastPoint ||
-              lastPoint[0] !== nextPoint[0] ||
-              lastPoint[1] !== nextPoint[1]
-            ? "append"
-            : "discard";
 
-        if (pointAction !== "discard") {
+        this.scene.mutateElement(newElement, {
-          this.scene.mutateElement(newElement, {
+          points: [...points, pointFrom<LocalPoint>(dx, dy)],
-            points:
+          pressures,
-              pointAction === "replace"
+        });
-                ? [...points.slice(0, -1), nextPoint]
-                : [...points, nextPoint],
-            pressures: newElement.simulatePressure
-              ? []
-              : pointAction === "replace"
-              ? [...newElement.pressures.slice(0, -1), pressure]
-              : [...newElement.pressures, pressure],
-          });
-        }
 
         this.actionManager.executeAction(actionFinalize);
 

packages/excalidraw/components/FontPicker/FontPickerList.tsx

@@ -46,7 +46,6 @@ import {
 import { fontPickerKeyHandler } from "./keyboardNavHandlers";
 
 import type { JSX } from "react";
-import type { ExcalidrawFontFace } from "../../fonts/ExcalidrawFontFace";
 
 export interface FontDescriptor {
   value: number;
@@ -87,15 +86,6 @@ const getFontFamilyIcon = (fontFamily: FontFamilyValues): JSX.Element => {
   }
 };
 
-const getFontFamilyLabel = (
-  fontFamily: FontFamilyValues,
-  fontFaces: ExcalidrawFontFace[],
-) =>
-  // prefer our config as the browser resolved names may be wrapped in quotes and such
-  Object.entries(FONT_FAMILY).find(([, id]) => id === fontFamily)?.[0] ??
-  fontFaces[0]?.fontFace?.family ??
-  "Unknown";
-
 export const FontPickerList = React.memo(
   ({
     selectedFontFamily,
@@ -124,7 +114,7 @@ export const FontPickerList = React.memo(
             const fontDescriptor = {
               value: familyId,
               icon: getFontFamilyIcon(familyId),
-              text: getFontFamilyLabel(familyId, fontFaces),
+              text: fontFaces[0]?.fontFace?.family ?? "Unknown",
             };
 
             if (metadata.deprecated) {

packages/excalidraw/components/RadioGroup.scss

@@ -26,16 +26,13 @@
     background: var(--RadioGroup-background);
     border: 1px solid var(--RadioGroup-border);
 
-    gap: 2px;
-
     &__choice {
       position: relative;
       display: flex;
       align-items: center;
       justify-content: center;
-      min-width: 20px;
+      width: 32px;
       height: 24px;
-      padding: 0 0.375rem;
 
       color: var(--RadioGroup-choice-color-off);
       background: var(--RadioGroup-choice-background-off);

packages/excalidraw/components/Stats/stats.test.tsx

@@ -750,7 +750,7 @@ describe("frame resizing behavior", () => {
       x: 0,
       y: 0,
       width: 100,
-      height: 103,
+      height: 100,
     });
 
     // Create a rectangle outside the frame

packages/excalidraw/components/dropdownMenu/DropdownMenu.scss

@@ -2,7 +2,7 @@
 
 .excalidraw {
   .dropdown-menu {
-    max-width: 20rem;
+    max-width: 16rem;
     z-index: 1;
 
     &--placement-top {

packages/excalidraw/components/dropdownMenu/DropdownMenuItemContentRadio.tsx

@@ -1,5 +1,4 @@
 import { useEditorInterface } from "../App";
-import { Ellipsify } from "../Ellipsify";
 import { RadioGroup } from "../RadioGroup";
 
 type Props<T> = {
@@ -13,7 +12,6 @@ type Props<T> = {
   onChange: (value: T) => void;
   children: React.ReactNode;
   name: string;
-  icon?: React.ReactNode;
 };
 
 const DropdownMenuItemContentRadio = <T,>({
@@ -23,17 +21,13 @@ const DropdownMenuItemContentRadio = <T,>({
   choices,
   children,
   name,
-  icon,
 }: Props<T>) => {
   const editorInterface = useEditorInterface();
 
   return (
     <>
       <div className="dropdown-menu-item-base dropdown-menu-item-bare">
-        {icon && <div className="dropdown-menu-item__icon">{icon}</div>}
+        <label className="dropdown-menu-item__text">{children}</label>
-        <label className="dropdown-menu-item__text">
-          <Ellipsify>{children}</Ellipsify>
-        </label>
         <RadioGroup
           name={name}
           value={value}

packages/excalidraw/components/icons.tsx

@@ -1164,22 +1164,11 @@ export const StrokeWidthBaseIcon = createIcon(
   modifiedTablerIconProps,
 );
 
-export const StrokeWidthMediumIcon = createIcon(
-  <path
-    d="M5 10h10"
-    stroke="currentColor"
-    strokeWidth="2.5"
-    strokeLinecap="round"
-    strokeLinejoin="round"
-  />,
-  modifiedTablerIconProps,
-);
-
 export const StrokeWidthBoldIcon = createIcon(
   <path
     d="M5 10h10"
     stroke="currentColor"
-    strokeWidth="3.75"
+    strokeWidth="2.5"
     strokeLinecap="round"
     strokeLinejoin="round"
   />,
@@ -1190,38 +1179,7 @@ export const StrokeWidthExtraBoldIcon = createIcon(
   <path
     d="M5 10h10"
     stroke="currentColor"
-    strokeWidth="5"
+    strokeWidth="3.75"
-    strokeLinecap="round"
-    strokeLinejoin="round"
-  />,
-  modifiedTablerIconProps,
-);
-
-export const StrokeShapeVariableIcon = createIcon(
-  <>
-    <path
-      d="M3.5 12.5c1.8-3.5 4.1-5.2 6.8-5.2 2.4 0 4.4 1.3 6.2 3.9"
-      stroke="currentColor"
-      strokeWidth="1.25"
-      strokeLinecap="round"
-      strokeLinejoin="round"
-    />
-    <path
-      d="M7.75 10.8c1-.9 2-1.35 3.05-1.35 1.2 0 2.4.57 3.7 1.72"
-      stroke="currentColor"
-      strokeWidth="2.5"
-      strokeLinecap="round"
-      strokeLinejoin="round"
-    />
-  </>,
-  modifiedTablerIconProps,
-);
-
-export const StrokeShapeFixedIcon = createIcon(
-  <path
-    d="M3.5 12h13"
-    stroke="currentColor"
-    strokeWidth="2.5"
     strokeLinecap="round"
     strokeLinejoin="round"
   />,

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

@@ -39,13 +39,7 @@ import DropdownMenuItemCheckbox from "../dropdownMenu/DropdownMenuItemCheckbox";
 import DropdownMenuItemContentRadio from "../dropdownMenu/DropdownMenuItemContentRadio";
 import DropdownMenuItemLink from "../dropdownMenu/DropdownMenuItemLink";
 import DropdownMenuSub from "../dropdownMenu/DropdownMenuSub";
-import {
+import { GithubIcon, DiscordIcon, XBrandIcon, settingsIcon } from "../icons";
-  GithubIcon,
-  DiscordIcon,
-  XBrandIcon,
-  settingsIcon,
-  emptyIcon,
-} from "../icons";
 import {
   boltIcon,
   DeviceDesktopIcon,
@@ -433,39 +427,6 @@ const PreferencesToggleToolLockItem = () => {
   );
 };
 
-const PreferencesBoxSelectionModeItem = () => {
-  const { t } = useI18n();
-  const appState = useUIAppState();
-  const setAppState = useExcalidrawSetAppState();
-
-  return (
-    <DropdownMenuItemContentRadio<"contain" | "overlap">
-      name="boxSelectionMode"
-      icon={emptyIcon}
-      value={appState.boxSelectionMode}
-      onChange={(value) => {
-        setAppState({
-          boxSelectionMode: value,
-        });
-      }}
-      choices={[
-        {
-          value: "contain",
-          label: t("labels.boxSelectionContain"),
-          ariaLabel: t("labels.boxSelectionContain"),
-        },
-        {
-          value: "overlap",
-          label: t("labels.boxSelectionOverlap"),
-          ariaLabel: t("labels.boxSelectionOverlap"),
-        },
-      ]}
-    >
-      {t("labels.boxSelectionMode")}
-    </DropdownMenuItemContentRadio>
-  );
-};
-
 const PreferencesToggleSnapModeItem = () => {
   const { t } = useI18n();
   const actionManager = useExcalidrawActionManager();
@@ -607,7 +568,6 @@ export const Preferences = ({
       <DropdownMenuSub.Content className="excalidraw-main-menu-preferences-submenu">
         {children || (
           <>
-            <PreferencesBoxSelectionModeItem />
             <PreferencesToggleToolLockItem />
             <PreferencesToggleSnapModeItem />
             <PreferencesToggleGridModeItem />
@@ -625,7 +585,6 @@ export const Preferences = ({
 };
 
 Preferences.ToggleToolLock = PreferencesToggleToolLockItem;
-Preferences.BoxSelectionMode = PreferencesBoxSelectionModeItem;
 Preferences.ToggleSnapMode = PreferencesToggleSnapModeItem;
 Preferences.ToggleArrowBinding = PreferencesToggleArrowBindingItem;
 Preferences.ToggleMidpointSnapping = PreferencesToggleMidpointSnappingItem;

packages/excalidraw/data/index.ts

@@ -6,7 +6,6 @@ import {
   MIME_TYPES,
   cloneJSON,
   SVG_DOCUMENT_PREAMBLE,
-  arrayToMap,
 } from "@excalidraw/common";
 
 import { getNonDeletedElements } from "@excalidraw/element";
@@ -50,7 +49,6 @@ export const prepareElementsForExport = (
   exportSelectionOnly: boolean,
 ) => {
   elements = getNonDeletedElements(elements);
-  const elementsMap = arrayToMap(elements);
 
   const isExportingSelection =
     exportSelectionOnly &&
@@ -73,11 +71,7 @@ export const prepareElementsForExport = (
       isFrameLikeElement(exportedElements[0])
     ) {
       exportingFrame = exportedElements[0];
-      exportedElements = getElementsOverlappingFrame(
+      exportedElements = getElementsOverlappingFrame(elements, exportingFrame);
-        elements,
-        exportingFrame,
-        elementsMap,
-      );
     } else if (exportedElements.length > 1) {
       exportedElements = getSelectedElements(
         elements,

packages/excalidraw/data/restore.ts

@@ -96,13 +96,6 @@ type RestoredAppState = Omit<
   "offsetTop" | "offsetLeft" | "width" | "height"
 >;
 
-const normalizeFreeDrawStrokeShape = (
-  strokeShape: unknown,
-): AppState["currentItemStrokeShape"] =>
-  strokeShape === "fixed" || strokeShape === "stable"
-    ? "fixed"
-    : undefined;
-
 export const AllowedExcalidrawActiveTools: Record<
   AppState["activeTool"]["type"],
   boolean
@@ -258,9 +251,7 @@ const repairBinding = <T extends ExcalidrawArrowElement>(
       };
     }
 
-    console.error(
+    console.error(`could not repair binding for element`);
-      `Could not repair binding for element "${boundElement?.id}" out of (${elementsMap?.size}) elements`,
-    );
   } catch (error) {
     console.error("Error repairing binding:", error);
   }
@@ -419,12 +410,10 @@ export const restoreElement = (
 
       return element;
     case "freedraw": {
-      const strokeShape = normalizeFreeDrawStrokeShape(element.strokeShape);
       return restoreElementWithProperties(element, {
         points: element.points,
         simulatePressure: element.simulatePressure,
         pressures: element.pressures,
-        ...(strokeShape ? { strokeShape } : {}),
       });
     }
     case "image":
@@ -945,24 +934,8 @@ export const restoreAppState = (
         : defaultValue;
   }
 
-  const boxSelectionMode =
-    appState.boxSelectionMode ?? localAppState?.boxSelectionMode;
-  if (boxSelectionMode !== undefined) {
-    nextAppState.boxSelectionMode = boxSelectionMode;
-  }
-
   return {
     ...nextAppState,
-    ...(normalizeFreeDrawStrokeShape(
-      appState.currentItemStrokeShape ?? localAppState?.currentItemStrokeShape,
-    )
-      ? {
-          currentItemStrokeShape: normalizeFreeDrawStrokeShape(
-            appState.currentItemStrokeShape ??
-              localAppState?.currentItemStrokeShape,
-          ),
-        }
-      : {}),
     cursorButton: localAppState?.cursorButton || "up",
     // reset on fresh restore so as to hide the UI button if penMode not active
     penDetected:

packages/excalidraw/global.d.ts

@@ -4,6 +4,8 @@ interface Window {
   EXCALIDRAW_ASSET_PATH: string | string[] | undefined;
   EXCALIDRAW_THROTTLE_RENDER: boolean | undefined;
   DEBUG_FRACTIONAL_INDICES: boolean | undefined;
+  EXCALIDRAW_DEBUG_LINEAR_ARROW_TANGENTS: boolean | undefined;
+  EXCALIDRAW_DEBUG_SELECTED_LINEAR_ARROW: unknown;
   EXCALIDRAW_EXPORT_SOURCE: string;
   gtag: Function;
   sa_event: Function;

packages/excalidraw/index.tsx

@@ -382,8 +382,6 @@ export { DiagramToCodePlugin } from "./components/DiagramToCodePlugin/DiagramToC
 export { getDataURL } from "./data/blob";
 export { isElementLink } from "@excalidraw/element";
 
-export { Fonts } from "./fonts/Fonts";
-
 export { setCustomTextMetricsProvider } from "@excalidraw/element";
 
 export { CommandPalette } from "./components/CommandPalette/CommandPalette";

packages/excalidraw/locales/en.json

@@ -30,9 +30,6 @@
     "changeBackground": "Change background color",
     "fill": "Fill",
     "strokeWidth": "Stroke width",
-    "strokeShape": "Stroke type",
-    "strokeShape_variable": "Variable",
-    "strokeShape_fixed": "Fixed",
     "strokeStyle": "Stroke style",
     "strokeStyle_solid": "Solid",
     "strokeStyle_dashed": "Dashed",
@@ -188,9 +185,6 @@
     "shapeSwitch": "Switch shape",
     "preferences": "Preferences",
     "preferences_toolLock": "Tool lock",
-    "boxSelectionMode": "Select on",
-    "boxSelectionContain": "Wrap",
-    "boxSelectionOverlap": "Overlap",
     "arrowBinding": "Arrow binding",
     "midpointSnapping": "Snap to midpoints"
   },
@@ -667,7 +661,7 @@
     "placeholder": {
       "title": "Let's design your diagram",
       "description": "Describe the diagram you want to create, and we'll generate it for you.",
-      "hint": "At the moment we know Flowchart, Sequence, Class, State, and Entity Relationship diagrams."
+      "hint": "At the moment we know Flowchart, Sequence, Class, and Entity Relationship diagrams."
     },
     "preview": "Preview",
     "insert": "Insert",

packages/excalidraw/package.json

@@ -88,7 +88,7 @@
     "@excalidraw/element": "0.18.0",
     "@excalidraw/laser-pointer": "1.3.1",
     "@excalidraw/math": "0.18.0",
-    "@excalidraw/mermaid-to-excalidraw": "2.2.2",
+    "@excalidraw/mermaid-to-excalidraw": "2.1.1",
     "@excalidraw/random-username": "1.1.0",
     "browser-fs-access": "0.38.0",
     "canvas-roundrect-polyfill": "0.0.1",

packages/excalidraw/reactUtils.ts

@@ -11,10 +11,10 @@ export const withBatchedUpdates = <
   TFunction extends ((event: any) => void) | (() => void),
 >(
   func: Parameters<TFunction>["length"] extends 0 | 1 ? TFunction : never,
-) => func;
+) =>
-// ((event) => {
+  ((event) => {
-//   unstable_batchedUpdates(func as TFunction, event);
+    unstable_batchedUpdates(func as TFunction, event);
-// }) as TFunction;
+  }) as TFunction;
 
 /**
  * barches React state updates and throttles the calls to a single call per

packages/excalidraw/renderer/interactiveScene.ts

@@ -42,6 +42,7 @@ import {
   isTextElement,
   LinearElementEditor,
   getActiveTextElement,
+  getSimpleArrowCurveDebugData,
 } from "@excalidraw/element";
 
 import { renderSelectionElement } from "@excalidraw/element";
@@ -1156,7 +1157,6 @@ const renderLinearPointHandles = (
           points[idx],
           idx,
           appState.zoom,
-          elementsMap,
         )
       ) {
         renderSingleLinearPoint(
@@ -1202,6 +1202,105 @@ const renderLinearPointHandles = (
   context.restore();
 };
 
+const isSimpleArrowTangentDebugEnabled = () =>
+  window.EXCALIDRAW_DEBUG_LINEAR_ARROW_TANGENTS === true;
+
+const renderSimpleArrowTangentOverlay = (
+  context: CanvasRenderingContext2D,
+  appState: InteractiveCanvasAppState,
+  element: NonDeleted<ExcalidrawArrowElement>,
+  elementsMap: RenderableElementsMap,
+) => {
+  const points = LinearElementEditor.getPointsGlobalCoordinates(
+    element,
+    elementsMap,
+  );
+  const debugData = getSimpleArrowCurveDebugData(points);
+
+  window.EXCALIDRAW_DEBUG_SELECTED_LINEAR_ARROW = debugData;
+
+  context.save();
+  context.translate(appState.scrollX, appState.scrollY);
+  context.lineWidth = 1 / appState.zoom.value;
+
+  context.setLineDash([6 / appState.zoom.value, 4 / appState.zoom.value]);
+  context.strokeStyle = "rgba(134, 142, 150, 0.75)";
+
+  for (const segment of debugData.segments) {
+    context.beginPath();
+    context.moveTo(segment.start[0], segment.start[1]);
+    context.lineTo(segment.baseCp1[0], segment.baseCp1[1]);
+    context.lineTo(segment.baseCp2[0], segment.baseCp2[1]);
+    context.lineTo(segment.end[0], segment.end[1]);
+    context.stroke();
+  }
+
+  context.setLineDash([]);
+
+  for (const segment of debugData.segments) {
+    const strokeStyle = segment.overshootsBaseline
+      ? "rgba(245, 159, 0, 0.9)"
+      : "rgba(94, 90, 216, 0.85)";
+
+    context.strokeStyle = strokeStyle;
+    context.fillStyle = "rgba(255, 255, 255, 0.95)";
+
+    context.beginPath();
+    context.moveTo(segment.start[0], segment.start[1]);
+    context.lineTo(segment.cp1[0], segment.cp1[1]);
+    context.lineTo(segment.cp2[0], segment.cp2[1]);
+    context.lineTo(segment.end[0], segment.end[1]);
+    context.stroke();
+
+    fillCircle(
+      context,
+      segment.cp1[0],
+      segment.cp1[1],
+      4 / appState.zoom.value,
+      true,
+      true,
+    );
+    fillCircle(
+      context,
+      segment.cp2[0],
+      segment.cp2[1],
+      4 / appState.zoom.value,
+      true,
+      true,
+    );
+  }
+
+  context.strokeStyle = "rgba(201, 42, 42, 0.85)";
+  context.fillStyle = "rgba(201, 42, 42, 0.95)";
+
+  for (const tangent of debugData.tangents) {
+    if (!tangent.isAdjusted) {
+      continue;
+    }
+
+    const handle = pointFrom<GlobalPoint>(
+      tangent.point[0] + tangent.scaled[0] / 3,
+      tangent.point[1] + tangent.scaled[1] / 3,
+    );
+
+    context.beginPath();
+    context.moveTo(tangent.point[0], tangent.point[1]);
+    context.lineTo(handle[0], handle[1]);
+    context.stroke();
+
+    fillCircle(
+      context,
+      tangent.point[0],
+      tangent.point[1],
+      3 / appState.zoom.value,
+      true,
+      true,
+    );
+  }
+
+  context.restore();
+};
+
 const renderFocusPointConnectionLine = (
   context: CanvasRenderingContext2D,
   appState: InteractiveCanvasAppState,
@@ -1723,6 +1822,13 @@ const _renderInteractiveScene = ({
   const selectedLinearElement =
     linearState &&
     LinearElementEditor.getElement(linearState.elementId, allElementsMap);
+  const selectedRoundedArrow =
+    selectedElements.length === 1 &&
+    isArrowElement(selectedElements[0]) &&
+    !isElbowArrow(selectedElements[0]) &&
+    !!selectedElements[0].roundness
+      ? (selectedElements[0] as NonDeleted<ExcalidrawArrowElement>)
+      : null;
   // Arrows have a different highlight behavior when
   // they are the only selected element
   if (selectedLinearElement) {
@@ -1759,6 +1865,17 @@ const _renderInteractiveScene = ({
     }
   }
 
+  if (selectedRoundedArrow && isSimpleArrowTangentDebugEnabled()) {
+    renderSimpleArrowTangentOverlay(
+      context,
+      appState,
+      selectedRoundedArrow,
+      elementsMap,
+    );
+  } else {
+    window.EXCALIDRAW_DEBUG_SELECTED_LINEAR_ARROW = undefined;
+  }
+
   // Paint selected elements
   if (
     !appState.multiElement &&

packages/excalidraw/renderer/staticSvgScene.ts

@@ -376,11 +376,6 @@ const renderElementToSvg = (
     }
     case "freedraw": {
       const wrapper = svgRoot.ownerDocument.createElementNS(SVG_NS, "g");
-      const isFixedStroke = element.strokeShape === "fixed";
-      const strokeColor =
-        renderConfig.theme === THEME.DARK
-          ? applyDarkModeFilter(element.strokeColor)
-          : element.strokeColor;
 
       const shapes = ShapeCache.generateElementShape(element, renderConfig);
       // always ordered as [background, stroke]
@@ -389,15 +384,12 @@ const renderElementToSvg = (
           // stroke (SVGPathString)
 
           const path = svgRoot.ownerDocument.createElementNS(SVG_NS, "path");
-          if (isFixedStroke) {
+          path.setAttribute(
-            path.setAttribute("fill", "none");
+            "fill",
-            path.setAttribute("stroke", strokeColor);
+            renderConfig.theme === THEME.DARK
-            path.setAttribute("stroke-width", `${element.strokeWidth}`);
+              ? applyDarkModeFilter(element.strokeColor)
-            path.setAttribute("stroke-linecap", "round");
+              : element.strokeColor,
-            path.setAttribute("stroke-linejoin", "round");
+          );
-          } else {
-            path.setAttribute("fill", strokeColor);
-          }
           path.setAttribute("d", shape);
           wrapper.appendChild(path);
         } else {

packages/excalidraw/scene/export.ts

@@ -157,11 +157,7 @@ const prepareElementsForRender = ({
   let nextElements: readonly ExcalidrawElement[];
 
   if (exportingFrame) {
-    nextElements = getElementsOverlappingFrame(
+    nextElements = getElementsOverlappingFrame(elements, exportingFrame);
-      elements,
-      exportingFrame,
-      arrayToMap(elements),
-    );
   } else if (frameRendering.enabled && frameRendering.name) {
     nextElements = addFrameLabelsAsTextElements(elements, {
       exportWithDarkMode,

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

@@ -13,7 +13,6 @@ exports[`contextMenu element > right-clicking on a group should select whole gro
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": {
     "items": [
@@ -1087,7 +1086,6 @@ exports[`contextMenu element > selecting 'Add to library' in context menu adds e
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -1302,7 +1300,6 @@ exports[`contextMenu element > selecting 'Bring forward' in context menu brings
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -1634,7 +1631,6 @@ exports[`contextMenu element > selecting 'Bring to front' in context menu brings
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -1966,7 +1962,6 @@ exports[`contextMenu element > selecting 'Copy styles' in context menu copies st
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2181,7 +2176,6 @@ exports[`contextMenu element > selecting 'Delete' in context menu deletes elemen
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2423,7 +2417,6 @@ exports[`contextMenu element > selecting 'Duplicate' in context menu duplicates
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2722,7 +2715,6 @@ exports[`contextMenu element > selecting 'Group selection' in context menu group
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3095,7 +3087,6 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3589,7 +3580,6 @@ exports[`contextMenu element > selecting 'Send backward' in context menu sends e
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3913,7 +3903,6 @@ exports[`contextMenu element > selecting 'Send to back' in context menu sends el
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -4237,7 +4226,6 @@ exports[`contextMenu element > selecting 'Ungroup selection' in context menu ung
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -4370,7 +4358,7 @@ exports[`contextMenu element > selecting 'Ungroup selection' in context menu ung
   "type": "rectangle",
   "updated": 1,
   "version": 5,
-  "versionNonce": 1006504105,
+  "versionNonce": 760410951,
   "width": 20,
   "x": -10,
   "y": 0,
@@ -4395,14 +4383,14 @@ exports[`contextMenu element > selecting 'Ungroup selection' in context menu ung
   "opacity": 100,
   "roughness": 1,
   "roundness": null,
-  "seed": 400692809,
+  "seed": 238820263,
   "strokeColor": "#1e1e1e",
   "strokeStyle": "solid",
   "strokeWidth": 2,
   "type": "rectangle",
   "updated": 1,
   "version": 5,
-  "versionNonce": 289600103,
+  "versionNonce": 1006504105,
   "width": 20,
   "x": 20,
   "y": 30,
@@ -4649,7 +4637,6 @@ exports[`contextMenu element > shows 'Group selection' in context menu for multi
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": {
     "items": [
@@ -5867,7 +5854,6 @@ exports[`contextMenu element > shows 'Ungroup selection' in context menu for gro
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": {
     "items": [
@@ -6878,7 +6864,7 @@ exports[`contextMenu element > shows 'Ungroup selection' in context menu for gro
   "type": "rectangle",
   "updated": 1,
   "version": 4,
-  "versionNonce": 1723083209,
+  "versionNonce": 747212839,
   "width": 10,
   "x": -10,
   "y": 0,
@@ -6905,14 +6891,14 @@ exports[`contextMenu element > shows 'Ungroup selection' in context menu for gro
   "opacity": 100,
   "roughness": 1,
   "roundness": null,
-  "seed": 400692809,
+  "seed": 238820263,
   "strokeColor": "#1e1e1e",
   "strokeStyle": "solid",
   "strokeWidth": 2,
   "type": "rectangle",
   "updated": 1,
   "version": 4,
-  "versionNonce": 760410951,
+  "versionNonce": 1723083209,
   "width": 10,
   "x": 12,
   "y": 0,
@@ -7136,7 +7122,6 @@ exports[`contextMenu element > shows context menu for canvas > [end of test] app
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": {
     "items": [
@@ -7826,7 +7811,6 @@ exports[`contextMenu element > shows context menu for element > [end of test] ap
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": {
     "items": [
@@ -8818,7 +8802,6 @@ exports[`contextMenu element > shows context menu for element > [end of test] ap
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": {
     "items": [

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

@@ -13,7 +13,6 @@ exports[`given element A and group of elements B and given both are selected whe
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -440,7 +439,6 @@ exports[`given element A and group of elements B and given both are selected whe
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -857,7 +855,6 @@ exports[`regression tests > Cmd/Ctrl-click exclusively select element under poin
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -1424,7 +1421,6 @@ exports[`regression tests > Drags selected element when hitting only bounding bo
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -1632,7 +1628,6 @@ exports[`regression tests > adjusts z order when grouping > [end of test] appSta
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2017,7 +2012,6 @@ exports[`regression tests > alt-drag duplicates an element > [end of test] appSt
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2263,7 +2257,6 @@ exports[`regression tests > arrow keys > [end of test] appState 1`] = `
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2444,7 +2437,6 @@ exports[`regression tests > can drag element that covers another element, while
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -2770,7 +2762,6 @@ exports[`regression tests > change the properties of a shape > [end of test] app
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3026,7 +3017,6 @@ exports[`regression tests > click on an element and drag it > [dragged] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3268,7 +3258,6 @@ exports[`regression tests > click on an element and drag it > [end of test] appS
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3505,7 +3494,6 @@ exports[`regression tests > click to select a shape > [end of test] appState 1`]
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -3764,7 +3752,6 @@ exports[`regression tests > click-drag to select a group > [end of test] appStat
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -4079,7 +4066,6 @@ exports[`regression tests > deleting last but one element in editing group shoul
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -4516,7 +4502,6 @@ exports[`regression tests > deselects group of selected elements on pointer down
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -4800,7 +4785,6 @@ exports[`regression tests > deselects group of selected elements on pointer up w
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -5077,7 +5061,6 @@ exports[`regression tests > deselects selected element on pointer down when poin
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -5286,7 +5269,6 @@ exports[`regression tests > deselects selected element, on pointer up, when clic
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -5487,7 +5469,6 @@ exports[`regression tests > double click to edit a group > [end of test] appStat
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -5881,7 +5862,6 @@ exports[`regression tests > drags selected elements from point inside common bou
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -6179,7 +6159,6 @@ exports[`regression tests > draw every type of shape > [end of test] appState 1`
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -6968,7 +6947,6 @@ exports[`regression tests > given a group of selected elements with an element t
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -7303,7 +7281,6 @@ exports[`regression tests > given a selected element A and a not selected elemen
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -7583,7 +7560,6 @@ exports[`regression tests > given selected element A with lower z-index than uns
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -7819,7 +7795,6 @@ exports[`regression tests > given selected element A with lower z-index than uns
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -8060,7 +8035,6 @@ exports[`regression tests > key 2 selects rectangle tool > [end of test] appStat
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -8241,7 +8215,6 @@ exports[`regression tests > key 3 selects diamond tool > [end of test] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -8422,7 +8395,6 @@ exports[`regression tests > key 4 selects ellipse tool > [end of test] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -8603,7 +8575,6 @@ exports[`regression tests > key 5 selects arrow tool > [end of test] appState 1`
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -8836,7 +8807,6 @@ exports[`regression tests > key 6 selects line tool > [end of test] appState 1`]
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -9067,7 +9037,6 @@ exports[`regression tests > key 7 selects freedraw tool > [end of test] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -9260,7 +9229,6 @@ exports[`regression tests > key a selects arrow tool > [end of test] appState 1`
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -9493,7 +9461,6 @@ exports[`regression tests > key d selects diamond tool > [end of test] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -9674,7 +9641,6 @@ exports[`regression tests > key l selects line tool > [end of test] appState 1`]
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -9905,7 +9871,6 @@ exports[`regression tests > key o selects ellipse tool > [end of test] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -10086,7 +10051,6 @@ exports[`regression tests > key p selects freedraw tool > [end of test] appState
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -10279,7 +10243,6 @@ exports[`regression tests > key r selects rectangle tool > [end of test] appStat
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -10460,7 +10423,6 @@ exports[`regression tests > make a group and duplicate it > [end of test] appSta
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -10992,7 +10954,6 @@ exports[`regression tests > noop interaction after undo shouldn't create history
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -11273,7 +11234,6 @@ exports[`regression tests > pinch-to-zoom works > [end of test] appState 1`] = `
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -11397,7 +11357,6 @@ exports[`regression tests > shift click on selected element should deselect it o
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -11598,7 +11557,6 @@ exports[`regression tests > shift-click to multiselect, then drag > [end of test
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -11918,7 +11876,6 @@ exports[`regression tests > should group elements and ungroup them > [end of tes
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -12348,7 +12305,6 @@ exports[`regression tests > single-clicking on a subgroup of a selected group sh
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -12989,7 +12945,6 @@ exports[`regression tests > spacebar + drag scrolls the canvas > [end of test] a
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -13116,7 +13071,6 @@ exports[`regression tests > supports nested groups > [end of test] appState 1`]
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -13748,7 +13702,6 @@ exports[`regression tests > switches from group of selected elements to another
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14088,7 +14041,6 @@ exports[`regression tests > switches selected element on pointer down > [end of
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14353,7 +14305,6 @@ exports[`regression tests > two-finger scroll works > [end of test] appState 1`]
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14477,7 +14428,6 @@ exports[`regression tests > undo/redo drawing an element > [end of test] appStat
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14842,7 +14792,6 @@ exports[`regression tests > updates fontSize & fontFamily appState > [end of tes
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,
@@ -14966,7 +14915,6 @@ exports[`regression tests > zoom hotkeys > [end of test] appState 1`] = `
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,

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

@@ -160,40 +160,6 @@ describe("restoreElements", () => {
     });
   });
 
-  it("should restore fixed freedraw element correctly", () => {
-    const freedrawElement = API.createElement({
-      type: "freedraw",
-      id: "id-freedraw02",
-      strokeShape: "fixed",
-      points: [pointFrom(0, 0), pointFrom(10, 10)],
-    });
-
-    const restoredFreedraw = restore.restoreElements(
-      [freedrawElement],
-      null,
-    )[0] as ExcalidrawFreeDrawElement;
-
-    expect(restoredFreedraw.strokeShape).toBe("fixed");
-  });
-
-  it("should restore legacy stable freedraw element as fixed", () => {
-    const restoredFreedraw = restore.restoreElements(
-      [
-        {
-          ...API.createElement({
-            type: "freedraw",
-            id: "id-freedraw03",
-            points: [pointFrom(0, 0), pointFrom(10, 10)],
-          }),
-          strokeShape: "stable",
-        } as any,
-      ],
-      null,
-    )[0] as ExcalidrawFreeDrawElement;
-
-    expect(restoredFreedraw.strokeShape).toBe("fixed");
-  });
-
   it("should restore line and draw elements correctly", () => {
     const lineElement = API.createElement({ type: "line", id: "id-line01" });
 
@@ -675,26 +641,6 @@ describe("restoreAppState", () => {
     expect(restoredAppState.name).toBe(stubImportedAppState.name);
   });
 
-  it("should restore fixed freedraw stroke type from app state", () => {
-    const restoredAppState = restore.restoreAppState(
-      { currentItemStrokeShape: "fixed" } as ImportedDataState["appState"],
-      null,
-    );
-
-    expect(restoredAppState.currentItemStrokeShape).toBe("fixed");
-  });
-
-  it("should restore legacy stable freedraw stroke type from app state as fixed", () => {
-    const restoredAppState = restore.restoreAppState(
-      {
-        currentItemStrokeShape: "stable",
-      } as unknown as ImportedDataState["appState"],
-      null,
-    );
-
-    expect(restoredAppState.currentItemStrokeShape).toBe("fixed");
-  });
-
   it("should return local app state when imported data state is null", () => {
     const stubLocalAppState = getDefaultAppState();
     stubLocalAppState.cursorButton = "down";

packages/excalidraw/tests/freedraw.test.tsx

@@ -1,78 +0,0 @@
-import React from "react";
-
-import { Excalidraw } from "../index";
-import { API } from "./helpers/api";
-import { Pointer, UI } from "./helpers/ui";
-import { render } from "./test-utils";
-
-describe("freedraw", () => {
-  beforeEach(async () => {
-    await render(<Excalidraw />);
-  });
-
-  it("rounds stored points and drops duplicates after rounding", () => {
-    const mouse = new Pointer("mouse");
-
-    UI.clickTool("freedraw");
-    mouse.downAt(10, 20);
-    mouse.moveTo(10.1234, 20.5678);
-    mouse.moveTo(10.1249, 20.5681);
-    mouse.upAt(20.9999, 30.0001);
-
-    const freedraw = window.h.elements.at(-1);
-
-    expect(freedraw).toEqual(expect.objectContaining({ type: "freedraw" }));
-    expect((freedraw as any).points).toEqual([
-      [0, 0],
-      [0.12, 0.57],
-      [11, 10],
-    ]);
-  });
-
-  it("does not snap fixed strokes closed when ending near the start point", () => {
-    const mouse = new Pointer("mouse");
-
-    API.setAppState({ currentItemStrokeShape: "fixed" });
-    UI.clickTool("freedraw");
-    mouse.downAt(10, 10);
-    mouse.moveTo(40, 10);
-    mouse.moveTo(30, 30);
-    mouse.upAt(12, 12);
-
-    const freedraw = window.h.elements.at(-1) as any;
-
-    expect(freedraw.points[0]).toEqual([0, 0]);
-    expect(freedraw.points.at(-1)).not.toEqual([0, 0]);
-  });
-
-  it("coalesces nearly straight fixed freedraw points at the tip", () => {
-    const mouse = new Pointer("mouse");
-
-    API.setAppState({ currentItemStrokeShape: "fixed" });
-    UI.clickTool("freedraw");
-    mouse.downAt(10, 10);
-
-    [
-      [10.2, 10.01],
-      [10.4, 10.03],
-      [10.6, 10.02],
-      [10.8, 10.04],
-      [11, 10.03],
-      [11.2, 10.05],
-      [11.4, 10.04],
-      [11.6, 10.06],
-      [11.8, 10.05],
-    ].forEach(([x, y]) => {
-      mouse.moveTo(x, y);
-    });
-    mouse.upAt(12, 10.05);
-
-    const freedraw = window.h.elements.at(-1) as any;
-
-    expect(freedraw.points.length).toBeLessThan(5);
-    expect(freedraw.points).toEqual([
-      [0, 0],
-      [2, 0.05],
-    ]);
-  });
-});

packages/excalidraw/tests/helpers/api.ts

@@ -201,9 +201,6 @@ export class API {
       ? ExcalidrawTextElement["containerId"]
       : never;
     points?: T extends "arrow" | "line" | "freedraw" ? readonly LocalPoint[] : never;
-    strokeShape?: T extends "freedraw"
-      ? ExcalidrawFreeDrawElement["strokeShape"]
-      : never;
     locked?: boolean;
     fileId?: T extends "image" ? string : never;
     scale?: T extends "image" ? ExcalidrawImageElement["scale"] : never;
@@ -321,7 +318,6 @@ export class API {
           type: type as "freedraw",
           simulatePressure: true,
           points: rest.points,
-          strokeShape: rest.strokeShape ?? appState.currentItemStrokeShape,
           ...base,
         });
         break;

packages/excalidraw/tests/helpers/ui.ts

@@ -28,7 +28,6 @@ import type { GlobalPoint, LocalPoint, Radians } from "@excalidraw/math";
 import type { TransformHandleType } from "@excalidraw/element";
 import type {
   ExcalidrawElement,
-  ExcalidrawFreeDrawElement,
   ExcalidrawLinearElement,
   ExcalidrawTextElement,
   ExcalidrawArrowElement,
@@ -433,10 +432,8 @@ type DrawingToolName = Exclude<
   "lock" | "selection" | "eraser" | "lasso"
 >;
 
-type Element<T extends DrawingToolName> = T extends "line"
+type Element<T extends DrawingToolName> = T extends "line" | "freedraw"
   ? ExcalidrawLinearElement
-  : T extends "freedraw"
-  ? ExcalidrawFreeDrawElement
   : T extends "arrow"
   ? ExcalidrawArrowElement
   : T extends "text"

packages/excalidraw/tests/history.test.tsx

@@ -314,7 +314,7 @@ describe("history", () => {
         expect.objectContaining({ id: rect2.id, isDeleted: true }),
       ]);
 
-      mouse.downAt(-10, -10);
+      mouse.downAt(0, 0);
       mouse.moveTo(25, 25);
       mouse.moveTo(50, 50);
       mouse.upAt(50, 50);
@@ -2971,82 +2971,6 @@ describe("history", () => {
       expect(h.state.editingGroupId).toBeNull();
     });
 
-    // TODO mark with "noncritical" tag once we migrate to vitest 4
-    it.skip("should support undo and redo when escape unwinds nested group editing", async () => {
-      const rectA = API.createElement({
-        type: "rectangle",
-        groupIds: ["inner", "outer"],
-        x: 0,
-      });
-      const rectB = API.createElement({
-        type: "rectangle",
-        groupIds: ["outer"],
-        x: 100,
-      });
-      const rectC = API.createElement({
-        type: "rectangle",
-        groupIds: ["inner", "outer"],
-        x: 200,
-      });
-
-      API.setElements([rectA, rectB, rectC]);
-      mouse.select(rectA);
-      mouse.doubleClickOn(rectA);
-      mouse.doubleClickOn(rectA);
-
-      assertSelectedElements([rectA]);
-      expect(h.state.editingGroupId).toBe("inner");
-      expect(API.getUndoStack().length).toBe(3);
-      expect(API.getRedoStack().length).toBe(0);
-
-      Keyboard.keyPress(KEYS.ESCAPE);
-      assertSelectedElements([rectA, rectC]);
-      expect(h.state.editingGroupId).toBe("outer");
-      expect(API.getUndoStack().length).toBe(4);
-      expect(API.getRedoStack().length).toBe(0);
-
-      Keyboard.keyPress(KEYS.ESCAPE);
-      assertSelectedElements([rectA, rectB, rectC]);
-      expect(h.state.editingGroupId).toBeNull();
-      expect(h.state.selectedGroupIds).toEqual({ outer: true });
-      expect(API.getUndoStack().length).toBe(5);
-      expect(API.getRedoStack().length).toBe(0);
-
-      Keyboard.keyPress(KEYS.ESCAPE);
-      expect(API.getSelectedElements()).toEqual([]);
-      expect(h.state.editingGroupId).toBeNull();
-      expect(h.state.selectedGroupIds).toEqual({});
-      expect(API.getUndoStack().length).toBe(6);
-      expect(API.getRedoStack().length).toBe(0);
-
-      Keyboard.undo();
-      assertSelectedElements([rectA, rectB, rectC]);
-      expect(h.state.editingGroupId).toBeNull();
-      expect(h.state.selectedGroupIds).toEqual({ outer: true });
-
-      Keyboard.undo();
-      assertSelectedElements([rectA, rectC]);
-      expect(h.state.editingGroupId).toBe("outer");
-
-      Keyboard.undo();
-      assertSelectedElements([rectA]);
-      expect(h.state.editingGroupId).toBe("inner");
-
-      Keyboard.redo();
-      assertSelectedElements([rectA, rectC]);
-      expect(h.state.editingGroupId).toBe("outer");
-
-      Keyboard.redo();
-      assertSelectedElements([rectA, rectB, rectC]);
-      expect(h.state.editingGroupId).toBeNull();
-      expect(h.state.selectedGroupIds).toEqual({ outer: true });
-
-      Keyboard.redo();
-      expect(API.getSelectedElements()).toEqual([]);
-      expect(h.state.editingGroupId).toBeNull();
-      expect(h.state.selectedGroupIds).toEqual({});
-    });
-
     it("should iterate through the history when selected or editing linear element was remotely deleted", async () => {
       // create three point arrow
       UI.clickTool("arrow");

packages/excalidraw/tests/regressionTests.test.tsx

@@ -468,7 +468,7 @@ describe("regression tests", () => {
     mouse.reset();
     mouse.down();
     mouse.move(-1000, -1000);
-    mouse.restorePosition(end[0] + 3, end[1] + 3);
+    mouse.restorePosition(...end);
     mouse.up();
 
     expect(h.elements.length).toBe(3);
@@ -519,7 +519,7 @@ describe("regression tests", () => {
     mouse.reset();
     mouse.down();
     mouse.move(-1000, -1000);
-    mouse.restorePosition(end[0] + 3, end[1] + 3);
+    mouse.restorePosition(...end);
     mouse.up();
 
     for (const element of h.elements) {
@@ -537,7 +537,7 @@ describe("regression tests", () => {
     mouse.moveTo(-10, -10); // the NW resizing handle is at [0, 0], so moving further
     mouse.down();
     mouse.move(-1000, -1000);
-    mouse.restorePosition(end[0] + 3, end[1] + 3);
+    mouse.restorePosition(...end);
     mouse.up();
 
     Keyboard.withModifierKeys({ ctrl: true, shift: true }, () => {

packages/excalidraw/tests/selection.test.tsx

@@ -1,9 +1,7 @@
 import React from "react";
 import { vi } from "vitest";
 
-import { KEYS, ROUNDNESS, reseed } from "@excalidraw/common";
+import { KEYS, reseed } from "@excalidraw/common";
-import { getElementBounds, getElementLineSegments } from "@excalidraw/element";
-import { pointFrom, pointRotateRads, type LocalPoint } from "@excalidraw/math";
 
 import { SHAPES } from "../components/shapes";
 
@@ -14,7 +12,6 @@ import * as StaticScene from "../renderer/staticScene";
 import { API } from "./helpers/api";
 import { Keyboard, Pointer, UI } from "./helpers/ui";
 import {
-  act,
   render,
   fireEvent,
   mockBoundingClientRect,
@@ -42,19 +39,6 @@ const { h } = window;
 
 const mouse = new Pointer("mouse");
 
-const getOutlineBounds = (element: ReturnType<typeof API.createElement>) => {
-  const sceneElement = API.getElement(element);
-  const elementsMap = h.scene.getNonDeletedElementsMap();
-  const points = getElementLineSegments(sceneElement, elementsMap).flat();
-
-  return [
-    Math.min(...points.map((point) => point[0])),
-    Math.min(...points.map((point) => point[1])),
-    Math.max(...points.map((point) => point[0])),
-    Math.max(...points.map((point) => point[1])),
-  ] as const;
-};
-
 describe("box-selection", () => {
   beforeEach(async () => {
     await render(<Excalidraw />);
@@ -124,497 +108,6 @@ describe("box-selection", () => {
 
     assertSelectedElements([]);
   });
-
-  it("should not select an element when the selection box only partially overlaps it", () => {
-    const rect1 = API.createElement({
-      type: "rectangle",
-      x: 0,
-      y: 0,
-      width: 50,
-      height: 50,
-      backgroundColor: "red",
-      fillStyle: "solid",
-    });
-
-    API.setElements([rect1]);
-
-    mouse.downAt(25, -20);
-    mouse.move(-1000, -1000);
-    mouse.moveTo(75, 70);
-    mouse.up();
-
-    assertSelectedElements([]);
-  });
-});
-
-describe("lasso reselection", () => {
-  beforeEach(async () => {
-    await render(<Excalidraw />);
-  });
-
-  it("should allow ctrl+alt lasso reselection when starting inside the active common bounds", () => {
-    const rectA = API.createElement({
-      type: "rectangle",
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100,
-      backgroundColor: "red",
-      fillStyle: "solid",
-    });
-    const rectB = API.createElement({
-      type: "rectangle",
-      x: 220,
-      y: 0,
-      width: 100,
-      height: 100,
-      backgroundColor: "blue",
-      fillStyle: "solid",
-    });
-
-    API.setElements([rectA, rectB]);
-    mouse.select([rectA, rectB]);
-    act(() => {
-      h.app.setActiveTool({ type: "lasso" });
-    });
-
-    Keyboard.withModifierKeys({ ctrl: true, alt: true }, () => {
-      mouse.downAt(110, 50);
-      mouse.moveTo(50, -20);
-
-      expect(h.app.lassoTrail.hasCurrentTrail).toBe(true);
-
-      mouse.moveTo(-20, 50);
-      mouse.moveTo(50, 120);
-      mouse.moveTo(110, 50);
-      mouse.up();
-    });
-
-    assertSelectedElements([rectA.id]);
-  });
-});
-
-describe("box-selection overlap mode", () => {
-  const boxSelect = (
-    startX: number,
-    startY: number,
-    endX: number,
-    endY: number,
-  ) => {
-    mouse.downAt(startX, startY);
-    mouse.move(-1000, -1000);
-    mouse.moveTo(endX, endY);
-    mouse.up();
-  };
-
-  const boxSelectTopLeftAabbCorner = (
-    element: ReturnType<typeof API.createElement>,
-  ) => {
-    const sceneElement = API.getElement(element);
-    const elementsMap = h.scene.getNonDeletedElementsMap();
-    const [x1, y1] = getElementBounds(sceneElement, elementsMap);
-
-    boxSelect(x1 + 2, y1 + 2, x1 + 12, y1 + 12);
-  };
-
-  const boxSelectTopRightAabbCorner = (
-    element: ReturnType<typeof API.createElement>,
-  ) => {
-    const sceneElement = API.getElement(element);
-    const elementsMap = h.scene.getNonDeletedElementsMap();
-    const [, y1, x2] = getElementBounds(sceneElement, elementsMap);
-
-    boxSelect(x2 - 12, y1 + 2, x2 - 2, y1 + 12);
-  };
-
-  const boxSelectTopLeftRotatedLocalBoundsCorner = (
-    element: ReturnType<typeof API.createElement>,
-  ) => {
-    const sceneElement = API.getElement(element);
-    const elementsMap = h.scene.getNonDeletedElementsMap();
-    const [x1, y1, x2, y2] = getElementBounds(sceneElement, elementsMap, true);
-    const center = pointFrom((x1 + x2) / 2, (y1 + y2) / 2);
-    const [cornerX, cornerY] = pointRotateRads(
-      pointFrom(x1, y1),
-      center,
-      sceneElement.angle,
-    );
-
-    boxSelect(cornerX - 4, cornerY - 4, cornerX + 4, cornerY + 4);
-  };
-
-  beforeEach(async () => {
-    await render(
-      <Excalidraw
-        initialData={{ appState: { boxSelectionMode: "overlap" } }}
-      />,
-    );
-  });
-
-  it("should select an element when the selection box partially overlaps it", () => {
-    const rect1 = API.createElement({
-      type: "rectangle",
-      x: 0,
-      y: 0,
-      width: 50,
-      height: 50,
-      backgroundColor: "red",
-      fillStyle: "solid",
-    });
-
-    API.setElements([rect1]);
-
-    boxSelect(25, -20, 75, 70);
-
-    assertSelectedElements([rect1.id]);
-  });
-
-  it("should not select a transparent rectangle when the selection box stays inside it", () => {
-    const rect1 = API.createElement({
-      type: "rectangle",
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100,
-      backgroundColor: "transparent",
-      fillStyle: "solid",
-    });
-
-    API.setElements([rect1]);
-
-    boxSelect(25, 25, 75, 75);
-
-    assertSelectedElements([]);
-  });
-
-  it("should select a transparent rectangle when the selection box crosses its outline", () => {
-    const rect1 = API.createElement({
-      type: "rectangle",
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100,
-      backgroundColor: "transparent",
-      fillStyle: "solid",
-    });
-
-    API.setElements([rect1]);
-
-    boxSelect(25, 25, 125, 75);
-
-    assertSelectedElements([rect1.id]);
-  });
-
-  it("should not select a rotated transparent rectangle when the selection box stays inside it", () => {
-    const rect1 = API.createElement({
-      type: "rectangle",
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100,
-      angle: Math.PI / 4,
-      backgroundColor: "transparent",
-      fillStyle: "solid",
-    });
-
-    API.setElements([rect1]);
-
-    boxSelect(40, 40, 60, 60);
-
-    assertSelectedElements([]);
-  });
-
-  it("should select a rotated rounded rectangle when the selection box contains its outline but not its bounds", () => {
-    const rect = API.createElement({
-      type: "rectangle",
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 180,
-      angle: Math.PI / 6,
-      backgroundColor: "transparent",
-      fillStyle: "solid",
-      roundness: { type: ROUNDNESS.ADAPTIVE_RADIUS },
-      roughness: 0,
-    });
-
-    API.setElements([rect]);
-
-    const sceneRect = API.getElement(rect);
-    const elementsMap = h.scene.getNonDeletedElementsMap();
-    const [boundsX1, boundsY1, boundsX2, boundsY2] = getElementBounds(
-      sceneRect,
-      elementsMap,
-    );
-    const [outlineX1, outlineY1, outlineX2, outlineY2] = getOutlineBounds(rect);
-
-    expect(outlineX1).toBeGreaterThan(boundsX1 - 1);
-    expect(outlineY1).toBeGreaterThan(boundsY1 - 1);
-    expect(outlineX2).toBeLessThan(boundsX2 + 1);
-    expect(outlineY2).toBeLessThan(boundsY2 + 1);
-
-    boxSelect(
-      outlineX1 - (outlineX1 - boundsX1) / 2,
-      outlineY1 - (outlineY1 - boundsY1) / 2,
-      outlineX2 + (boundsX2 - outlineX2) / 2,
-      outlineY2 + (boundsY2 - outlineY2) / 2,
-    );
-
-    assertSelectedElements([rect.id]);
-  });
-
-  it("should not select a filled rotated rectangle when the selection box only overlaps its axis-aligned bounds", () => {
-    const rect = API.createElement({
-      type: "rectangle",
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100,
-      angle: Math.PI / 4,
-      backgroundColor: "red",
-      fillStyle: "solid",
-    });
-
-    API.setElements([rect]);
-
-    boxSelectTopLeftAabbCorner(rect);
-
-    assertSelectedElements([]);
-  });
-
-  it("should not select a filled ellipse when the selection box only overlaps its bounds corner", () => {
-    const ellipse = API.createElement({
-      type: "ellipse",
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100,
-      backgroundColor: "red",
-      fillStyle: "solid",
-    });
-
-    API.setElements([ellipse]);
-
-    boxSelectTopRightAabbCorner(ellipse);
-
-    assertSelectedElements([]);
-  });
-
-  it("should not select a filled diamond when the selection box only overlaps its bounds corner", () => {
-    const diamond = API.createElement({
-      type: "diamond",
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100,
-      backgroundColor: "red",
-      fillStyle: "solid",
-    });
-
-    API.setElements([diamond]);
-
-    boxSelectTopRightAabbCorner(diamond);
-
-    assertSelectedElements([]);
-  });
-
-  it("should not select a filled rotated ellipse when the selection box only overlaps its axis-aligned bounds", () => {
-    const ellipse = API.createElement({
-      type: "ellipse",
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100,
-      angle: Math.PI / 4,
-      backgroundColor: "red",
-      fillStyle: "solid",
-    });
-
-    API.setElements([ellipse]);
-
-    boxSelectTopLeftRotatedLocalBoundsCorner(ellipse);
-
-    assertSelectedElements([]);
-  });
-
-  it("should not select a filled rotated diamond when the selection box only overlaps its rotated local bounds", () => {
-    const diamond = API.createElement({
-      type: "diamond",
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100,
-      angle: Math.PI / 4,
-      backgroundColor: "red",
-      fillStyle: "solid",
-    });
-
-    API.setElements([diamond]);
-
-    boxSelectTopLeftRotatedLocalBoundsCorner(diamond);
-
-    assertSelectedElements([]);
-  });
-
-  it("should not select rotated text when the selection box only overlaps its axis-aligned bounds", () => {
-    const text = API.createElement({
-      type: "text",
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100,
-      angle: Math.PI / 4,
-      text: "test",
-    });
-
-    API.setElements([text]);
-
-    boxSelect(-18, -18, -8, -8);
-
-    assertSelectedElements([]);
-  });
-
-  it("should not select rotated image when the selection box only overlaps its axis-aligned bounds", () => {
-    const image = API.createElement({
-      type: "image",
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100,
-      angle: Math.PI / 4,
-      fileId: "file_A",
-      status: "saved",
-    });
-
-    API.setElements([image]);
-
-    boxSelect(-18, -18, -8, -8);
-
-    assertSelectedElements([]);
-  });
-
-  it("should deselect a selected rotated rectangle when clicking in the empty corner of its axis-aligned bounds", () => {
-    const rect = API.createElement({
-      type: "rectangle",
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100,
-      angle: Math.PI / 4,
-      backgroundColor: "red",
-      fillStyle: "solid",
-    });
-
-    API.setElements([rect]);
-
-    mouse.clickAt(50, 50);
-    assertSelectedElements([rect.id]);
-
-    const sceneRect = API.getElement(rect);
-    const elementsMap = h.scene.getNonDeletedElementsMap();
-    const [x1, y1] = getElementBounds(sceneRect, elementsMap);
-
-    mouse.clickAt(x1 + 2, y1 + 2);
-
-    assertSelectedElements([]);
-  });
-
-  it("should not select a line when the selection box only overlaps its bounds", () => {
-    const line = API.createElement({
-      type: "line",
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100,
-      backgroundColor: "transparent",
-      points: [pointFrom<LocalPoint>(0, 0), pointFrom<LocalPoint>(100, 100)],
-    });
-
-    API.setElements([line]);
-
-    boxSelect(20, 50, 30, 60);
-
-    assertSelectedElements([]);
-  });
-
-  it("should not click-select rotated freedraw in the corner of its axis-aligned bounds", () => {
-    const freedraw = API.createElement({
-      type: "freedraw",
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100,
-      angle: Math.PI / 4,
-      backgroundColor: "transparent",
-      points: [
-        pointFrom<LocalPoint>(0, 0),
-        pointFrom<LocalPoint>(100, 0),
-        pointFrom<LocalPoint>(100, 100),
-        pointFrom<LocalPoint>(0, 100),
-        pointFrom<LocalPoint>(0, 0),
-      ],
-    });
-
-    API.setElements([freedraw]);
-
-    const sceneFreedraw = API.getElement(freedraw);
-    const elementsMap = h.scene.getNonDeletedElementsMap();
-    const [x1, y1] = getElementBounds(sceneFreedraw, elementsMap);
-
-    mouse.clickAt(x1 + 2, y1 + 2);
-
-    assertSelectedElements([]);
-  });
-
-  it("should not select a freedraw when the selection box only overlaps its bounds", () => {
-    const freedraw = API.createElement({
-      type: "freedraw",
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100,
-      backgroundColor: "transparent",
-      points: [
-        pointFrom<LocalPoint>(0, 0),
-        pointFrom<LocalPoint>(50, 50),
-        pointFrom<LocalPoint>(100, 100),
-      ],
-    });
-
-    API.setElements([freedraw]);
-
-    boxSelect(20, 50, 30, 60);
-
-    assertSelectedElements([]);
-  });
-
-  it("should not select a transparent framed element when the selection box stays inside its clipped bounds", () => {
-    const frame = API.createElement({
-      type: "frame",
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100,
-      backgroundColor: "transparent",
-      fillStyle: "solid",
-    });
-    const rect1 = API.createElement({
-      type: "rectangle",
-      x: 50,
-      y: 10,
-      width: 100,
-      height: 80,
-      frameId: frame.id,
-      backgroundColor: "transparent",
-      fillStyle: "solid",
-    });
-
-    API.setElements([frame, rect1]);
-
-    boxSelect(60, 20, 90, 60);
-
-    assertSelectedElements([]);
-  });
 });
 
 describe("inner box-selection", () => {
@@ -833,7 +326,7 @@ describe("select single element on the scene", () => {
     fireEvent.pointerUp(canvas);
 
     expect(renderInteractiveScene).toHaveBeenCalledTimes(8);
-    expect(renderStaticScene).toHaveBeenCalledTimes(7);
+    expect(renderStaticScene).toHaveBeenCalledTimes(6);
     expect(h.state.selectionElement).toBeNull();
     expect(h.elements.length).toEqual(1);
     expect(h.state.selectedElementIds[h.elements[0].id]).toBeTruthy();
@@ -866,7 +359,7 @@ describe("select single element on the scene", () => {
     fireEvent.pointerUp(canvas);
 
     expect(renderInteractiveScene).toHaveBeenCalledTimes(8);
-    expect(renderStaticScene).toHaveBeenCalledTimes(7);
+    expect(renderStaticScene).toHaveBeenCalledTimes(6);
     expect(h.state.selectionElement).toBeNull();
     expect(h.elements.length).toEqual(1);
     expect(h.state.selectedElementIds[h.elements[0].id]).toBeTruthy();
@@ -899,7 +392,7 @@ describe("select single element on the scene", () => {
     fireEvent.pointerUp(canvas);
 
     expect(renderInteractiveScene).toHaveBeenCalledTimes(8);
-    expect(renderStaticScene).toHaveBeenCalledTimes(7);
+    expect(renderStaticScene).toHaveBeenCalledTimes(6);
     expect(h.state.selectionElement).toBeNull();
     expect(h.elements.length).toEqual(1);
     expect(h.state.selectedElementIds[h.elements[0].id]).toBeTruthy();
@@ -945,7 +438,7 @@ describe("select single element on the scene", () => {
     fireEvent.pointerUp(canvas);
 
     expect(renderInteractiveScene).toHaveBeenCalledTimes(10);
-    expect(renderStaticScene).toHaveBeenCalledTimes(9);
+    expect(renderStaticScene).toHaveBeenCalledTimes(8);
     expect(h.state.selectionElement).toBeNull();
     expect(h.elements.length).toEqual(1);
     expect(h.state.selectedElementIds[h.elements[0].id]).toBeTruthy();
@@ -990,7 +483,7 @@ describe("select single element on the scene", () => {
     fireEvent.pointerUp(canvas);
 
     expect(renderInteractiveScene).toHaveBeenCalledTimes(10);
-    expect(renderStaticScene).toHaveBeenCalledTimes(9);
+    expect(renderStaticScene).toHaveBeenCalledTimes(8);
     expect(h.state.selectionElement).toBeNull();
     expect(h.elements.length).toEqual(1);
     expect(h.state.selectedElementIds[h.elements[0].id]).toBeTruthy();
@@ -1065,58 +558,3 @@ describe("selectedElementIds stability", () => {
     expect(h.state.selectedElementIds).toBe(selectedElementIds_2);
   });
 });
-
-describe("deselecting", () => {
-  beforeEach(async () => {
-    await render(<Excalidraw handleKeyboardGlobally={true} />);
-  });
-
-  it("esc unwinds nested group editing before deselecting", () => {
-    const rectA = API.createElement({
-      type: "rectangle",
-      x: 0,
-      y: 0,
-      groupIds: ["inner", "outer"],
-    });
-    const rectB = API.createElement({
-      type: "rectangle",
-      x: 100,
-      y: 0,
-      groupIds: ["outer"],
-    });
-    const rectC = API.createElement({
-      type: "rectangle",
-      x: 200,
-      y: 0,
-      groupIds: ["inner", "outer"],
-    });
-
-    API.setElements([rectA, rectB, rectC]);
-
-    mouse.select(rectA);
-    assertSelectedElements(rectA, rectB, rectC);
-    expect(h.state.editingGroupId).toBeNull();
-
-    mouse.doubleClickOn(rectA);
-    assertSelectedElements(rectA, rectC);
-    expect(h.state.editingGroupId).toBe("outer");
-
-    mouse.doubleClickOn(rectA);
-    assertSelectedElements(rectA);
-    expect(h.state.editingGroupId).toBe("inner");
-
-    Keyboard.keyPress(KEYS.ESCAPE);
-    assertSelectedElements(rectA, rectC);
-    expect(h.state.editingGroupId).toBe("outer");
-
-    Keyboard.keyPress(KEYS.ESCAPE);
-    assertSelectedElements(rectA, rectB, rectC);
-    expect(h.state.editingGroupId).toBeNull();
-    expect(h.state.selectedGroupIds).toEqual({ outer: true });
-
-    Keyboard.keyPress(KEYS.ESCAPE);
-    expect(API.getSelectedElements()).toEqual([]);
-    expect(h.state.editingGroupId).toBeNull();
-    expect(h.state.selectedGroupIds).toEqual({});
-  });
-});

packages/excalidraw/types.ts

@@ -33,7 +33,6 @@ import type {
   ExcalidrawNonSelectionElement,
   BindMode,
   ExcalidrawTextElement,
-  FreeDrawStrokeShape,
 } from "@excalidraw/element/types";
 
 import type {
@@ -270,8 +269,6 @@ export type ObservedElementsAppState = {
   activeLockedId: AppState["activeLockedId"];
 };
 
-export type BoxSelectionMode = "contain" | "overlap";
-
 export interface AppState {
   contextMenu: {
     items: ContextMenuItems;
@@ -310,8 +307,6 @@ export interface AppState {
    * `bindingPreference` and keyboard modifiers (ctrl/alt)
    */
   isBindingEnabled: boolean;
-  /** user box selection preference; defaults to "contain" when unset */
-  boxSelectionMode: BoxSelectionMode;
   /** user arrow binding preference */
   bindingPreference: "enabled" | "disabled";
   /** user preference whether arrow snap to midpoints while binding */
@@ -359,7 +354,6 @@ export interface AppState {
   currentItemFillStyle: ExcalidrawElement["fillStyle"];
   currentItemStrokeWidth: number;
   currentItemStrokeStyle: ExcalidrawElement["strokeStyle"];
-  currentItemStrokeShape?: FreeDrawStrokeShape;
   currentItemRoughness: number;
   currentItemOpacity: number;
   currentItemFontFamily: FontFamilyValues;
@@ -890,7 +884,7 @@ export type PointerDownState = Readonly<{
   // We need to have these in the state so that we can unsubscribe them
   eventListeners: {
     // It's defined on the initial pointer down event
-    onMove: null | ((event: PointerEvent) => void);
+    onMove: null | ReturnType<typeof throttleRAF>;
     // It's defined on the initial pointer down event
     onUp: null | ((event: PointerEvent) => void);
     // It's defined on the initial pointer down event

packages/excalidraw/wysiwyg/textWysiwyg.test.tsx

@@ -45,28 +45,6 @@ unmountComponent();
 const tab = "    ";
 const mouse = new Pointer("mouse");
 
-const exitTextEditorAndAssertSelection = async ({
-  editor,
-  selectedIds,
-  nextText,
-}: {
-  editor: HTMLTextAreaElement;
-  selectedIds: string[];
-  nextText?: string;
-}) => {
-  if (nextText !== undefined) {
-    updateTextEditor(editor, nextText);
-  }
-
-  Keyboard.exitTextEditor(editor);
-
-  expect(await getTextEditor({ waitForEditor: false })).toBe(null);
-  expect(window.h.state.editingTextElement).toBeNull();
-  expect(API.getSelectedElements().map((element) => element.id)).toEqual(
-    selectedIds,
-  );
-};
-
 describe("textWysiwyg", () => {
   describe("start text editing", () => {
     const { h } = window;
@@ -293,33 +271,6 @@ describe("textWysiwyg", () => {
       expect(h.elements.length).toBe(1);
     });
 
-    it("should reselect text after exiting wysiwyg with escape", async () => {
-      const text = API.createElement({
-        type: "text",
-        text: "ola",
-        x: 60,
-        y: 0,
-        width: 100,
-        height: 100,
-      });
-
-      API.setElements([text]);
-      API.setSelectedElements([text]);
-      UI.clickTool("selection");
-
-      Keyboard.keyPress(KEYS.ENTER);
-
-      const editor = await getTextEditor();
-
-      expect(editor).not.toBe(null);
-      expect(h.state.editingTextElement?.id).toBe(text.id);
-
-      await exitTextEditorAndAssertSelection({
-        editor,
-        selectedIds: [text.id],
-      });
-    });
-
     it("should edit selected bound text on single click", async () => {
       const container = API.createElement({
         type: "rectangle",
@@ -1354,40 +1305,6 @@ describe("textWysiwyg", () => {
       );
     });
 
-    it.each([
-      {
-        label: "container",
-        createElements: () => API.createTextContainer(),
-      },
-      {
-        label: "arrow",
-        createElements: () => API.createLabeledArrow(),
-      },
-    ])(
-      "should reselect $label after deleting bound text with escape",
-      async ({ createElements }) => {
-        const [selectedElement, text] = createElements();
-        API.setElements([selectedElement, text]);
-        API.setSelectedElements([selectedElement]);
-
-        Keyboard.keyPress(KEYS.ENTER);
-        const editor = await getTextEditor();
-
-        await exitTextEditorAndAssertSelection({
-          editor,
-          nextText: "",
-          selectedIds: [selectedElement.id],
-        });
-
-        expect(selectedElement.boundElements).toStrictEqual([]);
-        expect(h.elements[1]).toEqual(
-          expect.objectContaining({
-            isDeleted: true,
-          }),
-        );
-      },
-    );
-
     it("should restore original container height and clear cache once text is unbind", async () => {
       const container = API.createElement({
         type: "rectangle",

packages/math/src/curve.ts

@@ -137,17 +137,8 @@ const calculate = <Point extends GlobalPoint | LocalPoint>(
   [t0, s0]: [number, number],
   l: LineSegment<Point>,
   c: Curve<Point>,
-  tolerance: number = 1e-2,
-  iterLimit: number = 4,
 ) => {
-  const solution = solveWithAnalyticalJacobian(
+  const solution = solveWithAnalyticalJacobian(c, l, t0, s0, 1e-2, 4);
-    c,
-    l,
-    t0,
-    s0,
-    tolerance,
-    iterLimit,
-  );
 
   if (!solution) {
     return null;
@@ -167,43 +158,18 @@ const calculate = <Point extends GlobalPoint | LocalPoint>(
  */
 export function curveIntersectLineSegment<
   Point extends GlobalPoint | LocalPoint,
->(
+>(c: Curve<Point>, l: LineSegment<Point>): Point[] {
-  c: Curve<Point>,
+  let solution = calculate(initial_guesses[0], l, c);
-  l: LineSegment<Point>,
-  opts?: {
-    tolerance?: number;
-    iterLimit?: number;
-  },
-): Point[] {
-  let solution = calculate(
-    initial_guesses[0],
-    l,
-    c,
-    opts?.tolerance,
-    opts?.iterLimit,
-  );
   if (solution) {
     return [solution];
   }
 
-  solution = calculate(
+  solution = calculate(initial_guesses[1], l, c);
-    initial_guesses[1],
-    l,
-    c,
-    opts?.tolerance,
-    opts?.iterLimit,
-  );
   if (solution) {
     return [solution];
   }
 
-  solution = calculate(
+  solution = calculate(initial_guesses[2], l, c);
-    initial_guesses[2],
-    l,
-    c,
-    opts?.tolerance,
-    opts?.iterLimit,
-  );
   if (solution) {
     return [solution];
   }

packages/math/src/segment.ts

@@ -40,7 +40,7 @@ export const isLineSegment = <Point extends GlobalPoint | LocalPoint>(
   Array.isArray(segment) &&
   segment.length === 2 &&
   isPoint(segment[0]) &&
-  isPoint(segment[1]);
+  isPoint(segment[0]);
 
 /**
  * Return the coordinates resulting from rotating the given line about an origin by an angle in radians

packages/math/tests/segment.test.ts

@@ -1,9 +1,5 @@
 import { pointFrom } from "../src/point";
-import {
+import { lineSegment, lineSegmentIntersectionPoints } from "../src/segment";
-  lineSegment,
-  lineSegmentIntersectionPoints,
-  isLineSegment,
-} from "../src/segment";
 
 describe("line-segment intersections", () => {
   it("should correctly detect intersection", () => {
@@ -23,23 +19,3 @@ describe("line-segment intersections", () => {
     ).toEqual(null);
   });
 });
-describe("isLineSegment validation", () => {
-  it("should return true for a valid segment", () => {
-    expect(
-      isLineSegment([
-        [0, 0],
-        [1, 1],
-      ]),
-    ).toBe(true);
-  });
-
-  it("should return false if second element is not a point", () => {
-    const invalidSegment = [[0, 0], "not-a-point"] as any;
-
-    expect(isLineSegment(invalidSegment)).toBe(false);
-  });
-
-  it("should return false for wrong length", () => {
-    expect(isLineSegment([[0, 0]])).toBe(false);
-  });
-});

packages/utils/src/shape.ts

@@ -196,7 +196,7 @@ export const getEllipseShape = <Point extends GlobalPoint | LocalPoint>(
 
 export const getCurvePathOps = (shape: Drawable): Op[] => {
   // NOTE (mtolmacs): Temporary fix for extremely large elements
-  if (!shape) {
+  if (!shape || shape.sets.length === 0) {
     return [];
   }
 
@@ -205,6 +205,7 @@ export const getCurvePathOps = (shape: Drawable): Op[] => {
       return set.ops;
     }
   }
+
   return shape.sets[0].ops;
 };
 
@@ -316,26 +317,29 @@ export const getClosedCurveShape = <Point extends GlobalPoint | LocalPoint>(
     };
   }
 
-  const ops = getCurvePathOps(roughShape);
+  // Prefer the fillPath set
+  const fillPathSet = roughShape.sets.find((s) => s.type === "fillPath");
+  const ops = fillPathSet ? fillPathSet.ops : getCurvePathOps(roughShape);
 
   const points: Point[] = [];
   let odd = false;
   for (const operation of ops) {
     if (operation.op === "move") {
-      odd = !odd;
+      if (fillPathSet) {
-      if (odd) {
+        // fillPath is always a single run — no odd/even skipping needed
         points.push(pointFrom(operation.data[0], operation.data[1]));
+      } else {
+        odd = !odd;
+        if (odd) {
+          points.push(pointFrom(operation.data[0], operation.data[1]));
+        }
       }
     } else if (operation.op === "bcurveTo") {
-      if (odd) {
+      if (fillPathSet || odd) {
         points.push(pointFrom(operation.data[0], operation.data[1]));
         points.push(pointFrom(operation.data[2], operation.data[3]));
         points.push(pointFrom(operation.data[4], operation.data[5]));
       }
-    } else if (operation.op === "lineTo") {
-      if (odd) {
-        points.push(pointFrom(operation.data[0], operation.data[1]));
-      }
     }
   }
 

packages/utils/tests/__snapshots__/export.test.ts.snap

@@ -13,7 +13,6 @@ exports[`exportToSvg > with default arguments 1`] = `
   },
   "bindMode": "orbit",
   "bindingPreference": "enabled",
-  "boxSelectionMode": "contain",
   "collaborators": Map {},
   "contextMenu": null,
   "croppingElementId": null,

scripts/woff2/woff2-vite-plugins.js

@@ -90,13 +90,6 @@ module.exports.woff2BrowserPlugin = () => {
         type="font/woff2"
         crossorigin="anonymous"
       />
-      <link
-        rel="preload"
-        href="${OSS_FONTS_CDN}fonts/Assistant/Assistant-SemiBold.woff2"
-        as="font"
-        type="font/woff2"
-        crossorigin="anonymous"
-      />
       <link
         rel="preload"
         href="${OSS_FONTS_CDN}fonts/ComicShanns/ComicShanns-Regular-279a7b317d12eb88de06167bd672b4b4.woff2"

yarn.lock

@@ -1531,10 +1531,10 @@
   resolved "https://registry.yarnpkg.com/@excalidraw/markdown-to-text/-/markdown-to-text-0.1.2.tgz#1703705e7da608cf478f17bfe96fb295f55a23eb"
   integrity sha512-1nDXBNAojfi3oSFwJswKREkFm5wrSjqay81QlyRv2pkITG/XYB5v+oChENVBQLcxQwX4IUATWvXM5BcaNhPiIg==
 
-"@excalidraw/mermaid-to-excalidraw@2.2.2":
+"@excalidraw/mermaid-to-excalidraw@2.1.0":
-  version "2.2.2"
+  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/@excalidraw/mermaid-to-excalidraw/-/mermaid-to-excalidraw-2.2.2.tgz#ee6b597a0d95b9a76f7ae41ce0e3733a9b96e4a0"
+  resolved "https://registry.yarnpkg.com/@excalidraw/mermaid-to-excalidraw/-/mermaid-to-excalidraw-2.1.0.tgz#a5b9cf87c3185558cda7f9687d87b9937f452358"
-  integrity sha512-5VKQq5CdRocC82vOIUpQ5ufJOVV9FpBTdHGA+ULqazeIVV+cr299877omQCibsdS3Bpitz2fsnTwnIXEmLVDSg==
+  integrity sha512-RMd+c2b7WzzUjhERMpKwp8PhF2/XlHDjr/zK+Gxfp8K9sVlafPYJ5OEa/GkN6edi2rBUXRfW+41WdO6L56b6Kw==
   dependencies:
     "@excalidraw/markdown-to-text" "0.1.2"
     "@mermaid-js/parser" "^0.6.3"