wip

.codesandbox/Dockerfile

@@ -1,4 +1,4 @@
-FROM node:24-bullseye
+FROM node:18-bullseye
 
 # Vite wants to open the browser using `open`, so we
 # need to install those utils.

.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 }}

Dockerfile

@@ -1,4 +1,4 @@
-FROM --platform=${BUILDPLATFORM} node:24 AS build
+FROM --platform=${BUILDPLATFORM} node:18 AS build
 
 WORKDIR /opt/node_app
 
@@ -13,7 +13,7 @@ ARG NODE_ENV=production
 
 RUN npm_config_target_arch=${TARGETARCH} yarn build:app:docker
 
-FROM nginx:1.27-alpine
+FROM --platform=${TARGETPLATFORM} nginx:1.27-alpine
 
 COPY --from=build /opt/node_app/excalidraw-app/build /usr/share/nginx/html
 

README.md

@@ -29,7 +29,7 @@
   <a href="https://docs.excalidraw.com/docs/introduction/contributing">
     <img alt="PRs welcome!" src="https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat"  /></a>
   <a href="https://discord.gg/UexuTaE">
-    <img alt="Chat on Discord" src="https://img.shields.io/discord/723672430744174682?color=738ad6&label=Chat%20on%20Discord&logo=discord&logoColor=ffffff&widget=false"/></a>
+    <img alt="Chat on Discord" src="https://img.shields.io/discord/723672430744174682?color=738ad6&label=Chat%20on%20Discord&logo=discord&logoColor=ffffff&widge=false"/></a>
   <a href="https://deepwiki.com/excalidraw/excalidraw">
     <img alt="Ask DeepWiki" src="https://deepwiki.com/badge.svg" /></a>
   <a href="https://twitter.com/excalidraw">

dev-docs/docusaurus.config.js

@@ -97,8 +97,8 @@ const config = {
                 href: "https://discord.gg/UexuTaE",
               },
               {
-                label: "𝕏",
+                label: "Twitter",
-                href: "https://x.com/excalidraw",
+                href: "https://twitter.com/excalidraw",
               },
               {
                 label: "Linkedin",

excalidraw-app/components/AI.tsx

@@ -25,15 +25,19 @@ export const AIComponents = ({
           const appState = excalidrawAPI.getAppState();
 
           const blob = await exportToBlob({
-            elements: children,
+            data: {
-            appState: {
+              elements: children,
-              ...appState,
+              appState: {
-              exportBackground: true,
+                ...appState,
-              viewBackgroundColor: appState.viewBackgroundColor,
+                exportBackground: true,
+                viewBackgroundColor: appState.viewBackgroundColor,
+              },
+              files: excalidrawAPI.getFiles(),
+            },
+            config: {
+              exportingFrame: frame,
+              mimeType: MIME_TYPES.jpg,
             },
-            exportingFrame: frame,
-            files: excalidrawAPI.getFiles(),
-            mimeType: MIME_TYPES.jpg,
           });
 
           const dataURL = await getDataURL(blob);

packages/element/src/binding.ts

@@ -1943,9 +1943,9 @@ export const calculateFixedPointForElbowArrowBinding = (
   return {
     fixedPoint: normalizeFixedPoint([
       (nonRotatedSnappedGlobalPoint[0] - hoveredElement.x) /
-        Math.max(hoveredElement.width, PRECISION),
+        hoveredElement.width,
       (nonRotatedSnappedGlobalPoint[1] - hoveredElement.y) /
-        Math.max(hoveredElement.height, PRECISION),
+        hoveredElement.height,
     ]),
   };
 };
@@ -1976,11 +1976,9 @@ export const calculateFixedPointForNonElbowArrowBinding = (
 
   // Calculate the ratio relative to the element's bounds
   const fixedPointX =
-    (nonRotatedPoint[0] - hoveredElement.x) /
+    (nonRotatedPoint[0] - hoveredElement.x) / hoveredElement.width;
-    Math.max(hoveredElement.width, PRECISION);
   const fixedPointY =
-    (nonRotatedPoint[1] - hoveredElement.y) /
+    (nonRotatedPoint[1] - hoveredElement.y) / hoveredElement.height;
-    Math.max(hoveredElement.height, PRECISION);
 
   return {
     fixedPoint: normalizeFixedPoint([fixedPointX, fixedPointY]),

packages/element/src/bounds.ts

@@ -680,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;
@@ -696,7 +695,7 @@ 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 = (
@@ -1262,17 +1261,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,
@@ -1287,21 +1275,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

@@ -154,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
@@ -189,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 = (
@@ -476,12 +465,7 @@ export const intersectElementWithLineSegment = (
     case "line":
     case "freedraw":
     case "arrow":
-      return intersectLinearOrFreeDrawWithLineSegment(
+      return intersectLinearOrFreeDrawWithLineSegment(element, line, onlyFirst);
-        element,
-        line,
-        elementsMap,
-        onlyFirst,
-      );
   }
 };
 
@@ -548,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) {
@@ -584,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);

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/elbowArrow.ts

@@ -2124,8 +2124,8 @@ const normalizeArrowElementUpdate = (
     offsetY < -MAX_POS ||
     offsetY > MAX_POS ||
     offsetX + points[points.length - 1][0] < -MAX_POS ||
-    offsetX + points[points.length - 1][0] > MAX_POS ||
+    offsetY + points[points.length - 1][0] > MAX_POS ||
-    offsetY + points[points.length - 1][1] < -MAX_POS ||
+    offsetX + points[points.length - 1][1] < -MAX_POS ||
     offsetY + points[points.length - 1][1] > MAX_POS
   ) {
     console.error(

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/index.ts

@@ -88,7 +88,6 @@ export * from "./selection";
 export * from "./shape";
 export * from "./showSelectedShapeActions";
 export * from "./sizeHelpers";
-export * from "./snapping";
 export * from "./sortElements";
 export * from "./store";
 export * from "./textElement";

packages/element/src/linearElementEditor.ts

@@ -7,7 +7,6 @@ import {
   type LocalPoint,
   pointDistance,
   vectorFromPoint,
-  line,
   curveLength,
   curvePointAtLength,
 } from "@excalidraw/math";
@@ -30,9 +29,6 @@ import {
   isPathALoop,
   moveArrowAboveBindable,
   projectFixedPointOntoDiagonal,
-  snapLinearElementPoint,
-  snapToDiscreteAngle,
-  type SnapLine,
   type Store,
 } from "@excalidraw/element";
 
@@ -52,7 +48,6 @@ import {
   calculateFixedPointForNonElbowArrowBinding,
   getBindingStrategyForDraggingBindingElementEndpoints,
   isBindingEnabled,
-  maxBindingDistance_simple,
   snapToMid,
   updateBoundPoint,
 } from "./binding";
@@ -61,7 +56,6 @@ import {
   getElementPointsCoords,
   getMinMaxXYFromCurvePathOps,
 } from "./bounds";
-import { getHoveredElementForBinding } from "./collision";
 
 import { headingIsHorizontal, vectorToHeading } from "./heading";
 import { mutateElement } from "./mutateElement";
@@ -300,10 +294,7 @@ export class LinearElementEditor {
     scenePointerX: number,
     scenePointerY: number,
     linearElementEditor: LinearElementEditor,
-  ): Pick<
+  ): Pick<AppState, "suggestedBinding" | "selectedLinearElement"> | null {
-    AppState,
-    "suggestedBinding" | "selectedLinearElement" | "snapLines"
-  > | null {
     const elementsMap = app.scene.getNonDeletedElementsMap();
     const elements = app.scene.getNonDeletedElements();
     const { elementId } = linearElementEditor;
@@ -320,26 +311,36 @@ export class LinearElementEditor {
       linearElementEditor.customLineAngle ??
       determineCustomLinearAngle(pivotPoint, element.points[idx]);
 
-    const { point: newDraggingPointPosition, snapLines } =
+    // Determine if point movement should happen and how much
-      LinearElementEditor._getSnappedPointForLinearElement({
+    let deltaX = 0;
-        app,
+    let deltaY = 0;
-        event,
+    if (shouldRotateWithDiscreteAngle(event)) {
-        elements,
+      const [width, height] = LinearElementEditor._getShiftLockedDelta(
-        elementsMap,
         element,
-        pointIndex: idx,
+        elementsMap,
-        scenePointerX,
+        pivotPoint,
-        scenePointerY,
+        pointFrom(scenePointerX, scenePointerY),
-        pointerOffset: linearElementEditor.pointerOffset,
+        event[KEYS.CTRL_OR_CMD] ? null : app.getEffectiveGridSize(),
-        referencePoint: shouldRotateWithDiscreteAngle(event)
-          ? pivotPoint
-          : null,
-        selectedPointsIndices: [idx],
         customLineAngle,
-      });
+      );
+      const target = pointFrom<LocalPoint>(
+        width + pivotPoint[0],
+        height + pivotPoint[1],
+      );
 
-    const deltaX = newDraggingPointPosition[0] - point[0];
+      deltaX = target[0] - point[0];
-    const deltaY = newDraggingPointPosition[1] - point[1];
+      deltaY = target[1] - point[1];
+    } else {
+      const newDraggingPointPosition = LinearElementEditor.createPointAt(
+        element,
+        elementsMap,
+        scenePointerX - linearElementEditor.pointerOffset.x,
+        scenePointerY - linearElementEditor.pointerOffset.y,
+        event[KEYS.CTRL_OR_CMD] ? null : app.getEffectiveGridSize(),
+      );
+      deltaX = newDraggingPointPosition[0] - point[0];
+      deltaY = newDraggingPointPosition[1] - point[1];
+    }
 
     // Apply the point movement if needed
     let suggestedBinding: AppState["suggestedBinding"] = null;
@@ -397,8 +398,6 @@ export class LinearElementEditor {
     // PERF: Avoid state updates if not absolutely necessary
     if (
       app.state.selectedLinearElement?.customLineAngle === customLineAngle &&
-      app.state.snapLines.length === 0 &&
-      snapLines.length === 0 &&
       linearElementEditor.initialState.altFocusPoint &&
       (!suggestedBinding ||
         isShallowEqual(app.state.suggestedBinding ?? [], suggestedBinding))
@@ -437,7 +436,6 @@ export class LinearElementEditor {
     return {
       selectedLinearElement: newLinearElementEditor,
       suggestedBinding,
-      snapLines,
     };
   }
 
@@ -447,10 +445,7 @@ export class LinearElementEditor {
     scenePointerX: number,
     scenePointerY: number,
     linearElementEditor: LinearElementEditor,
-  ): Pick<
+  ): Pick<AppState, "suggestedBinding" | "selectedLinearElement"> | null {
-    AppState,
-    "suggestedBinding" | "selectedLinearElement" | "snapLines"
-  > | null {
     const elementsMap = app.scene.getNonDeletedElementsMap();
     const elements = app.scene.getNonDeletedElements();
     const { elbowed, elementId, initialState } = linearElementEditor;
@@ -481,23 +476,18 @@ 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];
     // The adjacent point to the one dragged point
     const pivotPoint =
@@ -511,27 +501,35 @@ export class LinearElementEditor {
       element.points.length - 1,
     );
 
-    const { point: newDraggingPointPosition, snapLines } =
+    // Determine if point movement should happen and how much
-      LinearElementEditor._getSnappedPointForLinearElement({
+    let deltaX = 0;
-        app,
+    let deltaY = 0;
-        event,
+    if (shouldRotateWithDiscreteAngle(event) && singlePointDragged) {
-        elements,
+      const [width, height] = LinearElementEditor._getShiftLockedDelta(
-        elementsMap,
         element,
-        pointIndex: lastClickedPoint,
+        elementsMap,
-        scenePointerX,
+        pivotPoint,
-        scenePointerY,
+        pointFrom(scenePointerX, scenePointerY),
-        pointerOffset: linearElementEditor.pointerOffset,
+        event[KEYS.CTRL_OR_CMD] ? null : app.getEffectiveGridSize(),
-        referencePoint:
-          shouldRotateWithDiscreteAngle(event) && singlePointDragged
-            ? pivotPoint
-            : null,
-        selectedPointsIndices,
         customLineAngle,
-      });
+      );
-
+      const target = pointFrom<LocalPoint>(
-    const deltaX = newDraggingPointPosition[0] - draggingPoint[0];
+        width + pivotPoint[0],
-    const deltaY = newDraggingPointPosition[1] - draggingPoint[1];
+        height + pivotPoint[1],
+      );
+      deltaX = target[0] - draggingPoint[0];
+      deltaY = target[1] - draggingPoint[1];
+    } else {
+      const newDraggingPointPosition = LinearElementEditor.createPointAt(
+        element,
+        elementsMap,
+        scenePointerX - linearElementEditor.pointerOffset.x,
+        scenePointerY - linearElementEditor.pointerOffset.y,
+        event[KEYS.CTRL_OR_CMD] ? null : app.getEffectiveGridSize(),
+      );
+      deltaX = newDraggingPointPosition[0] - draggingPoint[0];
+      deltaY = newDraggingPointPosition[1] - draggingPoint[1];
+    }
 
     // Apply the point movement if needed
     let suggestedBinding: AppState["suggestedBinding"] = null;
@@ -670,7 +668,6 @@ export class LinearElementEditor {
     return {
       selectedLinearElement: newLinearElementEditor,
       suggestedBinding,
-      snapLines,
     };
   }
 
@@ -797,7 +794,6 @@ export class LinearElementEditor {
           element.points[index + 1],
           index,
           appState.zoom,
-          elementsMap,
         )
       ) {
         midpoints.push(null);
@@ -807,7 +803,6 @@ export class LinearElementEditor {
       const segmentMidPoint = LinearElementEditor.getSegmentMidPoint(
         element,
         index + 1,
-        elementsMap,
       );
       midpoints.push(segmentMidPoint);
       index++;
@@ -895,7 +890,6 @@ export class LinearElementEditor {
     endPoint: P,
     index: number,
     zoom: Zoom,
-    elementsMap: ElementsMap,
   ) {
     if (isElbowArrow(element)) {
       if (index >= 0 && index < element.points.length) {
@@ -910,10 +904,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,
@@ -933,7 +924,6 @@ export class LinearElementEditor {
   static getSegmentMidPoint(
     element: NonDeleted<ExcalidrawLinearElement>,
     index: number,
-    elementsMap: ElementsMap,
   ): GlobalPoint {
     if (isElbowArrow(element)) {
       invariant(
@@ -946,10 +936,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) ||
@@ -1175,10 +1162,7 @@ export class LinearElementEditor {
     scenePointerX: number,
     scenePointerY: number,
     app: AppClassProperties,
-  ): {
+  ): LinearElementEditor | null {
-    editingLinearElement: LinearElementEditor;
-    snapLines: readonly SnapLine[];
-  } | null {
     const appState = app.state;
     if (!appState.selectedLinearElement?.isEditing) {
       return null;
@@ -1187,10 +1171,7 @@ export class LinearElementEditor {
     const elementsMap = app.scene.getNonDeletedElementsMap();
     const element = LinearElementEditor.getElement(elementId, elementsMap);
     if (!element) {
-      return {
+      return appState.selectedLinearElement;
-        editingLinearElement: appState.selectedLinearElement,
-        snapLines: appState.snapLines,
-      };
     }
 
     const { points } = element;
@@ -1202,37 +1183,36 @@ export class LinearElementEditor {
       }
       return appState.selectedLinearElement?.lastUncommittedPoint
         ? {
-            editingLinearElement: {
+            ...appState.selectedLinearElement,
-              ...appState.selectedLinearElement,
+            lastUncommittedPoint: null,
-              lastUncommittedPoint: null,
-            },
-            snapLines: [],
           }
-        : {
+        : appState.selectedLinearElement;
-            editingLinearElement: appState.selectedLinearElement,
-            snapLines: [],
-          };
     }
 
-    const anchor = points[points.length - 2];
+    let newPoint: LocalPoint;
-    const elements = app.scene.getNonDeletedElements();
+
-    const { point: newPoint, snapLines } =
+    if (shouldRotateWithDiscreteAngle(event) && points.length >= 2) {
-      LinearElementEditor._getSnappedPointForLinearElement({
+      const anchor = points[points.length - 2];
-        app,
+      const [width, height] = LinearElementEditor._getShiftLockedDelta(
-        event,
-        elements,
-        elementsMap,
         element,
-        pointIndex: points.length - 1,
+        elementsMap,
-        scenePointerX,
+        anchor,
-        scenePointerY,
+        pointFrom(scenePointerX, scenePointerY),
-        pointerOffset: appState.selectedLinearElement.pointerOffset,
+        event[KEYS.CTRL_OR_CMD] ? null : app.getEffectiveGridSize(),
-        referencePoint:
+      );
-          shouldRotateWithDiscreteAngle(event) && points.length >= 2
+
-            ? anchor
+      newPoint = pointFrom(width + anchor[0], height + anchor[1]);
-            : null,
+    } else {
-        selectedPointsIndices: [points.length - 1],
+      newPoint = LinearElementEditor.createPointAt(
-      });
+        element,
+        elementsMap,
+        scenePointerX - appState.selectedLinearElement.pointerOffset.x,
+        scenePointerY - appState.selectedLinearElement.pointerOffset.y,
+        event[KEYS.CTRL_OR_CMD] || isElbowArrow(element)
+          ? null
+          : app.getEffectiveGridSize(),
+      );
+    }
 
     if (lastPoint === lastUncommittedPoint) {
       LinearElementEditor.movePoints(
@@ -1240,7 +1220,7 @@ export class LinearElementEditor {
         app.scene,
         new Map([
           [
-            points.length - 1,
+            element.points.length - 1,
             {
               point: newPoint,
             },
@@ -1250,13 +1230,9 @@ export class LinearElementEditor {
     } else {
       LinearElementEditor.addPoints(element, app.scene, [newPoint]);
     }
-
     return {
-      editingLinearElement: {
+      ...appState.selectedLinearElement,
-        ...appState.selectedLinearElement,
+      lastUncommittedPoint: element.points[element.points.length - 1],
-        lastUncommittedPoint: element.points[element.points.length - 1],
-      },
-      snapLines,
     };
   }
 
@@ -1282,53 +1258,18 @@ export class LinearElementEditor {
   static getPointsGlobalCoordinates(
     element: NonDeleted<ExcalidrawLinearElement>,
     elementsMap: ElementsMap,
-    options: {
-      dragOffset?: { x: number; y: number };
-      excludePointsIndices?: readonly number[];
-    } = {},
   ): GlobalPoint[] {
-    const { dragOffset, excludePointsIndices } = options;
-
-    if (!element.points || element.points.length === 0) {
-      return [];
-    }
-
     const [x1, y1, x2, y2] = getElementAbsoluteCoords(element, elementsMap);
     const cx = (x1 + x2) / 2;
     const cy = (y1 + y2) / 2;
-
+    return element.points.map((p) => {
-    let elementX = element.x;
+      const { x, y } = element;
-    let elementY = element.y;
+      return pointRotateRads(
-
+        pointFrom(x + p[0], y + p[1]),
-    if (dragOffset) {
-      elementX += dragOffset.x;
-      elementY += dragOffset.y;
-    }
-
-    const globalPoints: GlobalPoint[] = [];
-
-    for (let i = 0; i < element.points.length; i++) {
-      // Skip the point being edited if specified
-      if (
-        excludePointsIndices?.length &&
-        excludePointsIndices.find((index) => index === i) !== undefined
-      ) {
-        continue;
-      }
-
-      const p = element.points[i];
-      const globalX = elementX + p[0];
-      const globalY = elementY + p[1];
-
-      const rotated = pointRotateRads<GlobalPoint>(
-        pointFrom(globalX, globalY),
         pointFrom(cx, cy),
         element.angle,
       );
-      globalPoints.push(rotated);
+    });
-    }
-
-    return globalPoints;
   }
 
   static getPointAtIndexGlobalCoordinates(
@@ -1882,222 +1823,6 @@ export class LinearElementEditor {
     );
   }
 
-  private static _getPointPlacementGridSize(
-    element: NonDeleted<ExcalidrawLinearElement>,
-    app: AppClassProperties,
-    event: Pick<KeyboardEvent | PointerEvent, typeof KEYS.CTRL_OR_CMD>,
-  ): NullableGridSize {
-    return event[KEYS.CTRL_OR_CMD] || isElbowArrow(element)
-      ? null
-      : app.getEffectiveGridSize();
-  }
-
-  private static _shouldSkipExternalSnapForBindableTarget({
-    appState,
-    elements,
-    elementsMap,
-    element,
-    pointIndex,
-    scenePoint,
-    selectedPointsIndices,
-  }: {
-    appState: AppState;
-    elements: readonly Ordered<NonDeletedExcalidrawElement>[];
-    elementsMap: NonDeletedSceneElementsMap;
-    element: NonDeleted<ExcalidrawLinearElement>;
-    pointIndex: number;
-    scenePoint: GlobalPoint;
-    selectedPointsIndices?: readonly number[];
-  }) {
-    if (
-      isElbowArrow(element) ||
-      !isBindingElement(element) ||
-      !isBindingEnabled(appState) ||
-      selectedPointsIndices?.length !== 1
-    ) {
-      return false;
-    }
-
-    if (pointIndex !== 0 && pointIndex !== element.points.length - 1) {
-      return false;
-    }
-
-    return !!getHoveredElementForBinding(
-      scenePoint,
-      elements,
-      elementsMap,
-      maxBindingDistance_simple(appState.zoom),
-    );
-  }
-
-  private static _getSnappedPointForLinearElement({
-    app,
-    event,
-    elements,
-    elementsMap,
-    element,
-    pointIndex,
-    scenePointerX,
-    scenePointerY,
-    pointerOffset,
-    referencePoint,
-    selectedPointsIndices,
-    customLineAngle,
-  }: {
-    app: AppClassProperties;
-    event: PointerEvent | React.PointerEvent<HTMLCanvasElement>;
-    elements: readonly Ordered<NonDeletedExcalidrawElement>[];
-    elementsMap: NonDeletedSceneElementsMap;
-    element: NonDeleted<ExcalidrawLinearElement>;
-    pointIndex: number;
-    scenePointerX: number;
-    scenePointerY: number;
-    pointerOffset: Readonly<{ x: number; y: number }>;
-    referencePoint?: LocalPoint | null;
-    selectedPointsIndices?: readonly number[];
-    customLineAngle?: number | null;
-  }): {
-    point: LocalPoint;
-    snapLines: SnapLine[];
-  } {
-    const gridSize = LinearElementEditor._getPointPlacementGridSize(
-      element,
-      app,
-      event,
-    );
-
-    if (referencePoint) {
-      const referencePointCoords =
-        LinearElementEditor.getPointGlobalCoordinates(
-          element,
-          referencePoint,
-          elementsMap,
-        );
-      const [gridX, gridY] = getGridPoint(
-        scenePointerX,
-        scenePointerY,
-        gridSize,
-      );
-
-      let { width: dxFromReference, height: dyFromReference } =
-        getLockedLinearCursorAlignSize(
-          referencePointCoords[0],
-          referencePointCoords[1],
-          gridX,
-          gridY,
-          customLineAngle ?? undefined,
-        );
-
-      const effectiveGridX = referencePointCoords[0] + dxFromReference;
-      const effectiveGridY = referencePointCoords[1] + dyFromReference;
-
-      let snapLines: SnapLine[] = [];
-      const shouldSkipExternalSnap =
-        LinearElementEditor._shouldSkipExternalSnapForBindableTarget({
-          appState: app.state,
-          elements,
-          elementsMap,
-          element,
-          pointIndex,
-          scenePoint: pointFrom<GlobalPoint>(effectiveGridX, effectiveGridY),
-          selectedPointsIndices,
-        });
-
-      if (!isElbowArrow(element)) {
-        const { snapOffset, snapLines: nextSnapLines } = snapLinearElementPoint(
-          elements,
-          element,
-          pointFrom<GlobalPoint>(effectiveGridX, effectiveGridY),
-          app,
-          event,
-          elementsMap,
-          {
-            includeExternalPoints: !shouldSkipExternalSnap,
-            includeSelfPoints: true,
-            selectedPointsIndices,
-          },
-        );
-
-        snapLines = nextSnapLines;
-
-        if (nextSnapLines.length > 0) {
-          const result = snapToDiscreteAngle(
-            nextSnapLines,
-            line(
-              pointFrom(effectiveGridX, effectiveGridY),
-              pointFrom(referencePointCoords[0], referencePointCoords[1]),
-            ),
-            pointFrom(gridX, gridY),
-            referencePointCoords,
-          );
-
-          if (result.snapLines.length > 0) {
-            dxFromReference = result.dxFromReference;
-            dyFromReference = result.dyFromReference;
-            snapLines = result.snapLines;
-          } else {
-            dxFromReference =
-              effectiveGridX + snapOffset.x - referencePointCoords[0];
-            dyFromReference =
-              effectiveGridY + snapOffset.y - referencePointCoords[1];
-          }
-        }
-      }
-
-      const [rotatedX, rotatedY] = pointRotateRads(
-        pointFrom(dxFromReference, dyFromReference),
-        pointFrom(0, 0),
-        -element.angle as Radians,
-      );
-
-      return {
-        point: pointFrom(
-          referencePoint[0] + rotatedX,
-          referencePoint[1] + rotatedY,
-        ),
-        snapLines,
-      };
-    }
-
-    const originalPointerX = scenePointerX - pointerOffset.x;
-    const originalPointerY = scenePointerY - pointerOffset.y;
-    const shouldSkipExternalSnap =
-      LinearElementEditor._shouldSkipExternalSnapForBindableTarget({
-        appState: app.state,
-        elements,
-        elementsMap,
-        element,
-        pointIndex,
-        scenePoint: pointFrom<GlobalPoint>(originalPointerX, originalPointerY),
-        selectedPointsIndices,
-      });
-
-    const { snapOffset, snapLines } = snapLinearElementPoint(
-      elements,
-      element,
-      pointFrom(originalPointerX, originalPointerY),
-      app,
-      event,
-      elementsMap,
-      {
-        includeExternalPoints: !shouldSkipExternalSnap,
-        includeSelfPoints: true,
-        selectedPointsIndices,
-      },
-    );
-
-    return {
-      point: LinearElementEditor.createPointAt(
-        element,
-        elementsMap,
-        originalPointerX + snapOffset.x,
-        originalPointerY + snapOffset.y,
-        gridSize,
-      ),
-      snapLines,
-    };
-  }
-
   static getBoundTextElementPosition = (
     element: ExcalidrawLinearElement,
     boundTextElement: ExcalidrawTextElementWithContainer,
@@ -2126,7 +1851,6 @@ export class LinearElementEditor {
       const midSegmentMidpoint = LinearElementEditor.getSegmentMidPoint(
         element,
         index + 1,
-        elementsMap,
       );
 
       x = midSegmentMidpoint[0] - boundTextElement.width / 2;
@@ -2676,7 +2400,7 @@ const pointDraggingUpdates = (
     ? nextArrow.points[0]
     : endBindable
     ? updateBoundPoint(
-        nextArrow,
+        element,
         "endBinding",
         nextArrow.endBinding,
         endBindable,
@@ -2707,7 +2431,7 @@ const pointDraggingUpdates = (
       ? endLocalPoint
       : startBindable
       ? updateBoundPoint(
-          nextArrow,
+          element,
           "startBinding",
           nextArrow.startBinding,
           startBindable,

packages/element/src/selection.ts

@@ -1,71 +1,33 @@
-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";
 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 +47,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) => {
@@ -514,19 +288,3 @@ export const getSelectionStateForElements = (
     ),
   };
 };
-
-/**
- * Returns editing or single-selected text element, if any.
- */
-export const getActiveTextElement = (
-  selectedElements: readonly NonDeleted<ExcalidrawElement>[],
-  appState: Pick<AppState, "editingTextElement">,
-) => {
-  const activeTextElement =
-    appState.editingTextElement ||
-    (selectedElements.length === 1 &&
-      isTextElement(selectedElements[0]) &&
-      selectedElements[0]);
-
-  return activeTextElement || null;
-};

packages/element/src/shape.ts

@@ -57,8 +57,8 @@ import { headingForPointIsHorizontal } from "./heading";
 
 import { canChangeRoundness } from "./comparisons";
 import {
-  elementCenterPoint,
   getArrowheadPoints,
+  getCenterForBounds,
   getDiamondPoints,
   getElementAbsoluteCoords,
 } from "./bounds";
@@ -583,11 +583,7 @@ const getArrowheadShapes = (
 
 export const generateLinearCollisionShape = (
   element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement,
-  elementsMap: ElementsMap,
+) => {
-): {
-  op: string;
-  data: number[];
-}[] => {
   const generator = new RoughGenerator();
   const options: Options = {
     seed: element.seed,
@@ -596,7 +592,20 @@ export const generateLinearCollisionShape = (
     roughness: 0,
     preserveVertices: true,
   };
-  const center = elementCenterPoint(element, elementsMap);
+  const center = getCenterForBounds(
+    // Need a non-rotated center point
+    element.points.reduce(
+      (acc, point) => {
+        return [
+          Math.min(element.x + point[0], acc[0]),
+          Math.min(element.y + point[1], acc[1]),
+          Math.max(element.x + point[0], acc[2]),
+          Math.max(element.y + point[1], acc[3]),
+        ];
+      },
+      [Infinity, Infinity, -Infinity, -Infinity],
+    ),
+  );
 
   switch (element.type) {
     case "line":

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] };
@@ -442,8 +441,7 @@ const VALID_CONTAINER_TYPES = new Set([
 
 export const isValidTextContainer = (element: {
   type: ExcalidrawElementType;
-}): element is ExcalidrawTextContainer =>
+}) => VALID_CONTAINER_TYPES.has(element.type);
-  VALID_CONTAINER_TYPES.has(element.type);
 
 export const computeContainerDimensionForBoundText = (
   dimension: number,

packages/element/src/textWrapping.ts

@@ -4,22 +4,6 @@ import { charWidth, getLineWidth } from "./textMeasurements";
 
 import type { FontString } from "./types";
 
-/**
- * This module approximates browser-like soft wrapping for Excalidraw text.
- *
- * The flow is:
- * 1. `parseTokens()` splits a hard line into breakable tokens using a unicode-aware regex.
- * 2. `getWrappedTextLines()` reflows each hard line into one or more visual lines and
- *    records where each visual line came from in the source text.
- * 3. `wrapLine()` assembles tokens into lines, and `wrapWord()` handles a single token
- *    that is wider than the available width.
- * 4. `trimLine()` / `trimLineEndAtSoftBreak()` mirror browser behavior around trailing
- *    whitespace so the rendered text stays consistent with what users see on canvas.
- *
- * Mostly, you'll want to use wrapText(). getWrappedTextLines() is for callers
- * that need metadata such as mapping visual lines back to `originalText`
- * for caret placement or future editor features.
- */
 let cachedCjkRegex: RegExp | undefined;
 let cachedLineBreakRegex: RegExp | undefined;
 let cachedEmojiRegex: RegExp | undefined;
@@ -374,10 +358,6 @@ const Break = {
 
 /**
  * Breaks the line into the tokens based on the found line break opporutnities.
- *
- * Note: tokenization normalizes to NFC first so decomposed graphemes are treated as
- * their composed variants for wrapping. Any code that needs exact source offsets should
- * keep in mind that this assumes the input text is already NFC-normalized.
  */
 export const parseTokens = (line: string) => {
   const breakLineRegex = getLineBreakRegex();
@@ -390,120 +370,56 @@ export const parseTokens = (line: string) => {
 
 /**
  * Wraps the original text into the lines based on the given width.
- *
- * This is a convenience adapter over `getWrappedTextLines()` for call sites
- * that only need the rendered wrapped string and not the source offsets.
  */
 export const wrapText = (
   text: string,
   font: FontString,
   maxWidth: number,
 ): string => {
-  return getWrappedTextLines(text, font, maxWidth)
-    .map((line) => line.text)
-    .join("\n");
-};
-
-/**
- * A single rendered visual line produced from the original text.
- *
- * `start` and `end` are end-exclusive code-unit offsets into the original text, and do
- * not include synthetic soft line breaks inserted by this module. If trailing whitespace
- * was trimmed away at a wrap boundary, `end` points to the last rendered character.
- */
-export type WrappedTextLine = {
-  text: string;
-  start: number;
-  end: number;
-};
-
-/**
- * Splits only on existing hard line breaks and preserves original offsets.
- */
-const getHardLineBreaks = (text: string): WrappedTextLine[] => {
-  let offset = 0;
-
-  return text.split("\n").map((line) => {
-    const start = offset;
-    const end = start + line.length;
-
-    offset = end + 1;
-
-    return {
-      text: line,
-      start,
-      end,
-    };
-  });
-};
-
-/**
- * Returns the rendered visual lines together with their source offsets.
- *
- * This is the source-of-truth wrapping pipeline for callers that need more than the
- * final wrapped string, for example caret placement or future editor/rich-text mapping.
- */
-export const getWrappedTextLines = (
-  text: string,
-  font: FontString,
-  maxWidth: number,
-): WrappedTextLine[] => {
   // if maxWidth is not finite or NaN which can happen in case of bugs in
   // computation, we need to make sure we don't continue as we'll end up
   // in an infinite loop
   if (!Number.isFinite(maxWidth) || maxWidth < 0) {
-    return getHardLineBreaks(text);
+    return text;
   }
 
-  const lines: WrappedTextLine[] = [];
+  const lines: Array<string> = [];
-  let offset = 0;
+  const originalLines = text.split("\n");
 
-  for (const originalLine of text.split("\n")) {
+  for (const originalLine of originalLines) {
-    const originalLineWidth = getLineWidth(originalLine, font);
+    const currentLineWidth = getLineWidth(originalLine, font);
 
-    if (originalLineWidth <= maxWidth) {
+    if (currentLineWidth <= maxWidth) {
-      lines.push({
+      lines.push(originalLine);
-        text: originalLine,
+      continue;
-        start: offset,
-        end: offset + originalLine.length,
-      });
-    } else {
-      lines.push(...wrapLine(originalLine, font, maxWidth, offset));
     }
 
-    offset += originalLine.length + 1;
+    const wrappedLine = wrapLine(originalLine, font, maxWidth);
+    lines.push(...wrappedLine);
   }
 
-  return lines;
+  return lines.join("\n");
 };
 
 /**
- * Wraps a single hard line into one or more visual lines.
+ * Wraps the original line into the lines based on the given width.
- *
- * The line-local offsets are tracked in original-text code units so
- * we can map the visual line back to the source.
  */
 const wrapLine = (
   line: string,
   font: FontString,
   maxWidth: number,
-  lineStart: number,
+): string[] => {
-): WrappedTextLine[] => {
+  const lines: Array<string> = [];
-  const lines: WrappedTextLine[] = [];
   const tokens = parseTokens(line);
+  const tokenIterator = tokens[Symbol.iterator]();
 
   let currentLine = "";
-  let currentLineStart = lineStart;
-  let currentLineEnd = lineStart;
   let currentLineWidth = 0;
-  // Tracks the next token's code-unit position in the original source string.
-  let tokenOffset = lineStart;
-  let tokenIndex = 0;
 
-  while (tokenIndex < tokens.length) {
+  let iterator = tokenIterator.next();
-    const token = tokens[tokenIndex];
+
-    const tokenStart = tokenOffset;
+  while (!iterator.done) {
-    const tokenEnd = tokenStart + token.length;
+    const token = iterator.value;
     const testLine = currentLine + token;
 
     // cache single codepoint whitespace, CJK or emoji width calc. as kerning should not apply here
@@ -513,59 +429,37 @@ const wrapLine = (
 
     // build up the current line, skipping length check for possibly trailing whitespaces
     if (/\s/.test(token) || testLineWidth <= maxWidth) {
-      if (!currentLine) {
-        currentLineStart = tokenStart;
-      }
       currentLine = testLine;
-      currentLineEnd = tokenEnd;
       currentLineWidth = testLineWidth;
-      tokenOffset = tokenEnd;
+      iterator = tokenIterator.next();
-      tokenIndex++;
       continue;
     }
 
     // current line is empty => just the token (word) is longer than `maxWidth` and needs to be wrapped
     if (!currentLine) {
-      const wrappedWord = wrapWord(token, font, maxWidth, tokenStart);
+      const wrappedWord = wrapWord(token, font, maxWidth);
-      const trailingLine = wrappedWord[wrappedWord.length - 1] ?? {
+      const trailingLine = wrappedWord[wrappedWord.length - 1] ?? "";
-        text: "",
-        start: tokenStart,
-        end: tokenStart,
-      };
       const precedingLines = wrappedWord.slice(0, -1);
 
       lines.push(...precedingLines);
 
       // trailing line of the wrapped word might still be joined with next token/s
-      currentLine = trailingLine.text;
+      currentLine = trailingLine;
-      currentLineStart = trailingLine.start;
+      currentLineWidth = getLineWidth(trailingLine, font);
-      currentLineEnd = trailingLine.end;
+      iterator = tokenIterator.next();
-      currentLineWidth = getLineWidth(trailingLine.text, font);
-      tokenOffset = tokenEnd;
-      tokenIndex++;
     } else {
       // push & reset, but don't iterate on the next token, as we didn't use it yet!
-      lines.push(
+      lines.push(currentLine.trimEnd());
-        trimLineEndAtSoftBreak(currentLine, currentLineStart, currentLineEnd),
-      );
 
       // purposefully not iterating and not setting `currentLine` to `token`, so that we could use a simple !currentLine check above
       currentLine = "";
-      currentLineStart = tokenStart;
-      currentLineEnd = tokenStart;
       currentLineWidth = 0;
     }
   }
 
   // iterator done, push the trailing line if exists
   if (currentLine) {
-    const trailingLine = trimLine(
+    const trailingLine = trimLine(currentLine, font, maxWidth);
-      currentLine,
-      currentLineStart,
-      currentLineEnd,
-      font,
-      maxWidth,
-    );
     lines.push(trailingLine);
   }
 
@@ -573,100 +467,59 @@ const wrapLine = (
 };
 
 /**
- * Wraps a single word that could not be placed on an empty line as-is.
+ * Wraps the word into the lines based on the given width.
  */
 const wrapWord = (
   word: string,
   font: FontString,
   maxWidth: number,
-  wordStart: number,
+): Array<string> => {
-): WrappedTextLine[] => {
   // multi-codepoint emojis are already broken apart and shouldn't be broken further
   if (getEmojiRegex().test(word)) {
-    return [
+    return [word];
-      {
-        text: word,
-        start: wordStart,
-        end: wordStart + word.length,
-      },
-    ];
   }
 
   satisfiesWordInvariant(word);
 
-  const lines: WrappedTextLine[] = [];
+  const lines: Array<string> = [];
   const chars = Array.from(word);
 
   let currentLine = "";
-  let currentLineStart = wordStart;
-  let currentLineEnd = wordStart;
   let currentLineWidth = 0;
-  let offset = wordStart;
 
   for (const char of chars) {
-    const charStart = offset;
-    const charEnd = charStart + char.length;
     const _charWidth = charWidth.calculate(char, font);
     const testLineWidth = currentLineWidth + _charWidth;
 
     if (testLineWidth <= maxWidth) {
-      if (!currentLine) {
-        currentLineStart = charStart;
-      }
       currentLine = currentLine + char;
-      currentLineEnd = charEnd;
       currentLineWidth = testLineWidth;
-      offset = charEnd;
       continue;
     }
 
     if (currentLine) {
-      lines.push({
+      lines.push(currentLine);
-        text: currentLine,
-        start: currentLineStart,
-        end: currentLineEnd,
-      });
     }
 
     currentLine = char;
-    currentLineStart = charStart;
-    currentLineEnd = charEnd;
     currentLineWidth = _charWidth;
-    offset = charEnd;
   }
 
   if (currentLine) {
-    lines.push({
+    lines.push(currentLine);
-      text: currentLine,
-      start: currentLineStart,
-      end: currentLineEnd,
-    });
   }
 
   return lines;
 };
 
 /**
- * Trims trailing whitespace that is exceeding the `maxWidth`.
+ * Similarly to browsers, does not trim all trailing whitespaces, but only those exceeding the `maxWidth`.
- *
- * Used for the trailing visual line of a hard line, where some trailing
- * whitespace may still be visible if it fits into the available width.
  */
-const trimLine = (
+const trimLine = (line: string, font: FontString, maxWidth: number) => {
-  line: string,
-  start: number,
-  end: number,
-  font: FontString,
-  maxWidth: number,
-): WrappedTextLine => {
   const shouldTrimWhitespaces = getLineWidth(line, font) > maxWidth;
 
   if (!shouldTrimWhitespaces) {
-    return {
+    return line;
-      text: line,
-      start,
-      end,
-    };
   }
 
   // defensively default to `trimeEnd` in case the regex does not match
@@ -690,30 +543,7 @@ const trimLine = (
     trimmedLineWidth = testLineWidth;
   }
 
-  return {
+  return trimmedLine;
-    text: trimmedLine,
-    start,
-    end: end - (line.length - trimmedLine.length),
-  };
-};
-
-/**
- * Used for internal soft-wrap boundaries, where trailing whitespace should not
- * survive into the rendered line even though it still exists in the original
- * text.
- */
-const trimLineEndAtSoftBreak = (
-  line: string,
-  start: number,
-  end: number,
-): WrappedTextLine => {
-  const trimmedLine = line.trimEnd();
-
-  return {
-    text: trimmedLine,
-    start,
-    end: end - (line.length - trimmedLine.length),
-  };
 };
 
 /**

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/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/cropElement.test.tsx

@@ -330,22 +330,30 @@ describe("Cropping and other features", async () => {
     const widthToHeightRatio = image.width / image.height;
 
     const canvas = await exportToCanvas({
-      elements: [image],
+      data: {
-      // @ts-ignore
+        elements: [image],
-      appState: h.state,
+        // @ts-ignore
-      files: h.app.files,
+        appState: h.state,
-      exportPadding: 0,
+        files: h.app.files,
+      },
+      config: {
+        padding: 0,
+      },
     });
     const exportedCanvasRatio = canvas.width / canvas.height;
 
     expect(widthToHeightRatio).toBeCloseTo(exportedCanvasRatio);
 
     const svg = await exportToSvg({
-      elements: [image],
+      data: {
-      // @ts-ignore
+        elements: [image],
-      appState: h.state,
+        // @ts-ignore
-      files: h.app.files,
+        appState: h.state,
-      exportPadding: 0,
+        files: h.app.files,
+      },
+      config: {
+        padding: 0,
+      },
     });
     const svgWidth = svg.getAttribute("width");
     const svgHeight = svg.getAttribute("height");

packages/element/tests/linearElementEditor.test.tsx

@@ -155,24 +155,6 @@ describe("Test Linear Elements", () => {
     });
   };
 
-  const dragMove = (startPoint: GlobalPoint, endPoint: GlobalPoint) => {
-    fireEvent.pointerDown(interactiveCanvas, {
-      clientX: startPoint[0],
-      clientY: startPoint[1],
-    });
-    fireEvent.pointerMove(interactiveCanvas, {
-      clientX: endPoint[0],
-      clientY: endPoint[1],
-    });
-  };
-
-  const dragEnd = (endPoint: GlobalPoint) => {
-    fireEvent.pointerUp(interactiveCanvas, {
-      clientX: endPoint[0],
-      clientY: endPoint[1],
-    });
-  };
-
   const deletePoint = (point: GlobalPoint) => {
     fireEvent.pointerDown(interactiveCanvas, {
       clientX: point[0],
@@ -276,73 +258,6 @@ describe("Test Linear Elements", () => {
     expect(h.state.selectedLinearElement?.elementId).toEqual(h.elements[0].id);
   });
 
-  it("shows snap lines and snaps the endpoint when creating a line", () => {
-    const rect = API.createElement({
-      type: "rectangle",
-      x: 100,
-      y: 100,
-      width: 40,
-      height: 40,
-    });
-    API.setElements([rect]);
-    API.setAppState({ objectsSnapModeEnabled: true });
-
-    UI.clickTool("line");
-
-    const startPoint = pointFrom<GlobalPoint>(20, 20);
-    const pointerNearCorner = pointFrom<GlobalPoint>(95, 95);
-
-    dragMove(startPoint, pointerNearCorner);
-
-    expect(h.state.snapLines.length).toBeGreaterThan(0);
-
-    dragEnd(pointerNearCorner);
-
-    const line = h.elements.find(
-      (element): element is ExcalidrawLinearElement => element.type === "line",
-    );
-
-    expect(line).toBeDefined();
-
-    const endpoint = LinearElementEditor.getPointGlobalCoordinates(
-      line!,
-      line!.points[line!.points.length - 1],
-      h.app.scene.getNonDeletedElementsMap(),
-    );
-
-    expect(endpoint).toEqual(pointFrom<GlobalPoint>(100, 100));
-  });
-
-  it("prefers binding over external snaps when creating an arrow endpoint", () => {
-    const rect = API.createElement({
-      type: "rectangle",
-      x: 100,
-      y: 100,
-      width: 40,
-      height: 40,
-    });
-    API.setElements([rect]);
-    API.setAppState({ objectsSnapModeEnabled: true });
-
-    UI.clickTool("arrow");
-
-    const startPoint = pointFrom<GlobalPoint>(20, 20);
-    const pointerNearBindable = pointFrom<GlobalPoint>(96, 118);
-
-    dragMove(startPoint, pointerNearBindable);
-
-    expect(h.state.suggestedBinding?.element.id).toBe(rect.id);
-    expect(h.state.snapLines).toEqual([]);
-
-    dragEnd(pointerNearBindable);
-
-    const arrow = h.elements.find(
-      (element): element is ExcalidrawLinearElement => element.type === "arrow",
-    );
-
-    expect(arrow?.endBinding?.elementId).toBe(rect.id);
-  });
-
   it("should enter line editor via enter (line)", () => {
     createTwoPointerLinearElement("line");
     expect(h.state.selectedLinearElement?.isEditing).toBe(false);
@@ -486,77 +401,6 @@ describe("Test Linear Elements", () => {
       `);
     });
 
-    it("shows snap lines when dragging a point to another line point axis", () => {
-      const line = API.createElement({
-        type: "line",
-        x: 20,
-        y: 20,
-        width: 100,
-        height: 50,
-        roughness: 0,
-        points: [
-          pointFrom<LocalPoint>(0, 0),
-          pointFrom<LocalPoint>(50, 50),
-          pointFrom<LocalPoint>(100, 0),
-        ],
-      });
-
-      API.setElements([line]);
-      API.setAppState({ objectsSnapModeEnabled: true });
-      enterLineEditingMode(line);
-
-      const middlePoint = pointFrom<GlobalPoint>(70, 70);
-      const pointerNearEndPointX = pointFrom<GlobalPoint>(117, 65);
-
-      dragMove(middlePoint, pointerNearEndPointX);
-
-      expect(h.state.snapLines.length).toBeGreaterThan(0);
-
-      dragEnd(pointerNearEndPointX);
-
-      expect(API.getElement(line).points[1]).toEqual(
-        pointFrom<LocalPoint>(100, 45),
-      );
-    });
-
-    it("prefers binding over external snaps when dragging an existing arrow endpoint", () => {
-      const rect = API.createElement({
-        type: "rectangle",
-        x: 100,
-        y: 100,
-        width: 40,
-        height: 40,
-      });
-      const arrow = API.createElement({
-        type: "arrow",
-        x: 20,
-        y: 20,
-        width: 40,
-        height: 0,
-        points: [pointFrom<LocalPoint>(0, 0), pointFrom<LocalPoint>(40, 0)],
-      });
-
-      API.setElements([rect, arrow]);
-      API.setAppState({ objectsSnapModeEnabled: true });
-      enterLineEditingMode(arrow);
-
-      const endPoint = LinearElementEditor.getPointGlobalCoordinates(
-        arrow,
-        arrow.points[arrow.points.length - 1],
-        h.app.scene.getNonDeletedElementsMap(),
-      );
-      const pointerNearBindable = pointFrom<GlobalPoint>(96, 118);
-
-      dragMove(endPoint, pointerNearBindable);
-
-      expect(h.state.suggestedBinding?.element.id).toBe(rect.id);
-      expect(h.state.snapLines).toEqual([]);
-
-      dragEnd(pointerNearBindable);
-
-      expect(API.getElement(arrow).endBinding?.elementId).toBe(rect.id);
-    });
-
     it("should update the midpoints when element roundness changed", async () => {
       createThreePointerLinearElement("line");
 

packages/element/tests/textWrapping.test.ts

@@ -1,8 +1,4 @@
-import {
+import { wrapText, parseTokens } from "../src/textWrapping";
-  getWrappedTextLines,
-  parseTokens,
-  wrapText,
-} from "../src/textWrapping";
 
 import type { FontString } from "../src/types";
 
@@ -106,71 +102,6 @@ describe("Test wrapText", () => {
     expect(res2).toBe(`\tA)\none\ntab\n- two\ntabs\n- 8\nspace\ns`);
   });
 
-  it("should retain original text offsets for wrapped lines", () => {
-    expect(getWrappedTextLines("Hello World!", font, 60)).toEqual([
-      {
-        text: "Hello",
-        start: 0,
-        end: 5,
-      },
-      {
-        text: "World!",
-        start: 6,
-        end: 12,
-      },
-    ]);
-  });
-
-  it("should exclude whitespace trimmed away at soft-wrap boundaries from line offsets", () => {
-    expect(getWrappedTextLines("  Hello  World", font, 90)).toEqual([
-      {
-        text: "  Hello",
-        start: 0,
-        end: 7,
-      },
-      {
-        text: "World",
-        start: 9,
-        end: 14,
-      },
-    ]);
-  });
-
-  it("should retain offsets when wrapping a single long token", () => {
-    expect(getWrappedTextLines("Excalidraw", font, 50)).toEqual([
-      {
-        text: "Excal",
-        start: 0,
-        end: 5,
-      },
-      {
-        text: "idraw",
-        start: 5,
-        end: 10,
-      },
-    ]);
-  });
-
-  it("should preserve empty hard lines in metadata", () => {
-    expect(getWrappedTextLines("A\n\nB", font, 100)).toEqual([
-      {
-        text: "A",
-        start: 0,
-        end: 1,
-      },
-      {
-        text: "",
-        start: 2,
-        end: 2,
-      },
-      {
-        text: "B",
-        start: 3,
-        end: 4,
-      },
-    ]);
-  });
-
   describe("When text is CJK", () => {
     it("should break each CJK character when width is very small", () => {
       // "안녕하세요" (Hangul) + "こんにちは世界" (Hiragana, Kanji) + "ｺﾝﾆﾁハ" (Katakana) + "你好" (Han) = "Hello Hello World Hello Hi"

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

@@ -348,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.tsx

@@ -191,7 +191,7 @@ export const getFormValue = function <T extends Primitive>(
   elements: readonly ExcalidrawElement[],
   app: AppClassProperties,
   getAttribute: (element: ExcalidrawElement) => T,
-  elementPredicate: true | ((element: ExcalidrawElement) => boolean),
+  isRelevantElement: true | ((element: ExcalidrawElement) => boolean),
   defaultValue: T | ((isSomeElementSelected: boolean) => T),
 ): T {
   const editingTextElement = app.state.editingTextElement;
@@ -209,9 +209,9 @@ export const getFormValue = function <T extends Primitive>(
     if (hasSelection) {
       const selectedElements = app.scene.getSelectedElements(app.state);
       const targetElements =
-        elementPredicate === true
+        isRelevantElement === true
           ? selectedElements
-          : selectedElements.filter((el) => elementPredicate(el));
+          : selectedElements.filter((el) => isRelevantElement(el));
 
       ret =
         reduceToCommonValue(targetElements, getAttribute) ??
@@ -730,28 +730,9 @@ export const actionChangeOpacity = register<ExcalidrawElement["opacity"]>({
       captureUpdate: CaptureUpdateAction.IMMEDIATELY,
     };
   },
-  PanelComponent: ({ elements, appState, app, updateData }) => {
+  PanelComponent: ({ app, updateData }) => (
-    const opacity = getFormValue(
+    <Range updateData={updateData} app={app} testId="opacity" />
-      elements,
+  ),
-      app,
-      (element) => element.opacity,
-      true,
-      (hasSelection) => (hasSelection ? null : appState.currentItemOpacity),
-    );
-
-    return (
-      <Range
-        label={t("labels.opacity")}
-        value={opacity ?? appState.currentItemOpacity}
-        hasCommonValue={opacity !== null}
-        onChange={updateData}
-        min={0}
-        max={100}
-        step={10}
-        testId="opacity"
-      />
-    );
-  },
 });
 
 export const actionChangeFontSize = register<ExcalidrawTextElement["fontSize"]>(

packages/excalidraw/actions/actionTextAutoResize.ts

@@ -1,24 +1,24 @@
 import { getFontString } from "@excalidraw/common";
 
-import { isExcalidrawElement, newElementWith } from "@excalidraw/element";
+import { newElementWith } from "@excalidraw/element";
 import { measureText } from "@excalidraw/element";
 
 import { isTextElement } from "@excalidraw/element";
 
 import { CaptureUpdateAction } from "@excalidraw/element";
 
-import type { ExcalidrawElement } from "@excalidraw/element/types";
-
 import { getSelectedElements } from "../scene";
 
 import { register } from "./register";
 
+import type { AppClassProperties } from "../types";
+
 export const actionTextAutoResize = register({
   name: "autoResize",
   label: "labels.autoResize",
   icon: null,
   trackEvent: { category: "element" },
-  predicate: (elements, appState, _: unknown) => {
+  predicate: (elements, appState, _: unknown, app: AppClassProperties) => {
     const selectedElements = getSelectedElements(elements, appState);
     return (
       selectedElements.length === 1 &&
@@ -26,18 +26,13 @@ export const actionTextAutoResize = register({
       !selectedElements[0].autoResize
     );
   },
-  perform: (elements, appState, targetElement) => {
+  perform: (elements, appState, _, app) => {
     const selectedElements = getSelectedElements(elements, appState);
 
-    const targetTextElement =
-      isExcalidrawElement(targetElement) && isTextElement(targetElement)
-        ? targetElement
-        : (selectedElements[0] as ExcalidrawElement | undefined);
-
     return {
       appState,
       elements: elements.map((element) => {
-        if (element.id === targetTextElement?.id && isTextElement(element)) {
+        if (element.id === selectedElements[0].id && isTextElement(element)) {
           const metrics = measureText(
             element.originalText,
             getFontString(element),

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",
   };
 };
 
@@ -194,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/App.tsx

@@ -27,7 +27,6 @@ import {
   KEYS,
   APP_NAME,
   CURSOR_TYPE,
-  DEFAULT_TRANSFORM_HANDLE_SPACING,
   DEFAULT_MAX_IMAGE_WIDTH_OR_HEIGHT,
   DEFAULT_VERTICAL_ALIGN,
   DRAGGING_THRESHOLD,
@@ -239,16 +238,6 @@ import {
   hitElementBoundingBox,
   isLineElement,
   isSimpleArrow,
-  isGridModeEnabled,
-  SnapCache,
-  isActiveToolNonLinearSnappable,
-  getSnapLinesAtPointer,
-  isSnappingEnabled,
-  getReferenceSnapPoints,
-  getVisibleGaps,
-  snapDraggedElements,
-  snapNewElement,
-  snapResizingElements,
   StoreDelta,
   type ApplyToOptions,
   positionElementsOnGrid,
@@ -268,7 +257,6 @@ import {
   handleFocusPointPointerUp,
   maybeHandleArrowPointlikeDrag,
   getUncroppedWidthAndHeight,
-  getActiveTextElement,
 } from "@excalidraw/element";
 
 import type { GlobalPoint, LocalPoint, Radians } from "@excalidraw/math";
@@ -406,6 +394,18 @@ import {
 import { Fonts } from "../fonts";
 import { editorJotaiStore, type WritableAtom } from "../editor-jotai";
 import { ImageSceneDataError } from "../errors";
+import {
+  getSnapLinesAtPointer,
+  snapDraggedElements,
+  isActiveToolNonLinearSnappable,
+  snapNewElement,
+  snapResizingElements,
+  isSnappingEnabled,
+  getVisibleGaps,
+  getReferenceSnapPoints,
+  SnapCache,
+  isGridModeEnabled,
+} from "../snapping";
 import { Renderer } from "../scene/Renderer";
 import {
   setEraserCursor,
@@ -416,7 +416,6 @@ import {
 import { ElementCanvasButtons } from "../components/ElementCanvasButtons";
 import { LaserTrails } from "../laser-trails";
 import { withBatchedUpdates, withBatchedUpdatesThrottled } from "../reactUtils";
-import { isPointHittingTextAutoResizeHandle } from "../textAutoResizeHandle";
 import { textWysiwyg } from "../wysiwyg/textWysiwyg";
 import { isOverScrollBars } from "../scene/scrollbars";
 
@@ -685,15 +684,9 @@ class App extends React.Component<AppProps, AppState> {
   lastPointerDownEvent: React.PointerEvent<HTMLElement> | null = null;
   lastPointerUpEvent: React.PointerEvent<HTMLElement> | PointerEvent | null =
     null;
-  // TODO this is a hack and we should ideally unify touch and pointer events
-  // and implement our own double click handling end-to-end (currently we're
-  // using a mix of native browser for click events and manual for touch -
-  // and browser doubleClick sucks to begin with)
-  lastPointerUpIsDoubleClick: boolean = false;
   lastPointerMoveEvent: PointerEvent | null = null;
   /** current frame pointer cords */
   lastPointerMoveCoords: { x: number; y: number } | null = null;
-  private lastCompletedCanvasClicks: { x: number; y: number }[] = [];
   /** previous frame pointer coords */
   previousPointerMoveCoords: { x: number; y: number } | null = null;
   lastViewportPosition = { x: 0, y: 0 };
@@ -783,29 +776,6 @@ class App extends React.Component<AppProps, AppState> {
     return api;
   }
 
-  private withStableSnapLines<T extends { snapLines: AppState["snapLines"] }>(
-    state: T,
-  ): T {
-    const snapLines = updateStable(this.state.snapLines, state.snapLines);
-
-    return snapLines === state.snapLines
-      ? state
-      : {
-          ...state,
-          snapLines,
-        };
-  }
-
-  private shouldUpdateSelectedLinearElementState(
-    selectedLinearElement: AppState["selectedLinearElement"],
-    snapLines: AppState["snapLines"],
-  ) {
-    return (
-      selectedLinearElement !== this.state.selectedLinearElement ||
-      snapLines !== this.state.snapLines
-    );
-  }
-
   constructor(props: AppProps) {
     super(props);
     const defaultAppState = getDefaultAppState();
@@ -1278,26 +1248,6 @@ class App extends React.Component<AppProps, AppState> {
     ) as NullableGridSize;
   };
 
-  private getTextCreationGridPoint = (x: number, y: number) => {
-    const effectiveGridSize = this.getEffectiveGridSize();
-
-    if (effectiveGridSize === null) {
-      return null;
-    }
-
-    const getTextCreationGridCoordinate = (coordinate: number) => {
-      const topLeftGridPoint =
-        Math.floor(coordinate / effectiveGridSize) * effectiveGridSize;
-
-      return topLeftGridPoint;
-    };
-
-    return {
-      x: getTextCreationGridCoordinate(x),
-      y: getTextCreationGridCoordinate(y),
-    };
-  };
-
   private getHTMLIFrameElement(
     element: ExcalidrawIframeLikeElement,
   ): HTMLIFrameElement | undefined {
@@ -1488,21 +1438,6 @@ class App extends React.Component<AppProps, AppState> {
     return true;
   }
 
-  private isDoubleClick = (
-    lastPointerEvent:
-      | PointerEvent
-      | React.PointerEvent<HTMLElement>
-      | undefined
-      | null,
-    currentPointerEvent: PointerEvent | React.PointerEvent<HTMLElement>,
-  ) => {
-    return (
-      lastPointerEvent != null &&
-      currentPointerEvent.timeStamp - lastPointerEvent.timeStamp <=
-        TAP_TWICE_TIMEOUT
-    );
-  };
-
   private isIframeLikeElementCenter(
     el: ExcalidrawIframeLikeElement | null,
     event: React.PointerEvent<HTMLElement> | PointerEvent,
@@ -2386,7 +2321,6 @@ class App extends React.Component<AppProps, AppState> {
                             }
                             handleCanvasRef={this.handleInteractiveCanvasRef}
                             onContextMenu={this.handleCanvasContextMenu}
-                            onClick={this.handleCanvasClick}
                             onPointerMove={this.handleCanvasPointerMove}
                             onPointerUp={this.handleCanvasPointerUp}
                             onPointerCancel={this.removePointer}
@@ -2546,7 +2480,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) {
@@ -3641,14 +3574,10 @@ class App extends React.Component<AppProps, AppState> {
         this.lassoTrail.endPath();
         this.deselectElements();
 
+        // @ts-ignore
         this.handleCanvasDoubleClick({
           clientX: touch.clientX,
           clientY: touch.clientY,
-          type: "touch",
-          altKey: false,
-          ctrlKey: false,
-          metaKey: false,
-          shiftKey: false,
         });
       }
       didTapTwice = false;
@@ -5688,14 +5617,8 @@ class App extends React.Component<AppProps, AppState> {
     element: ExcalidrawTextElement,
     {
       isExistingElement = false,
-      initialCaretSceneCoords = null,
     }: {
       isExistingElement?: boolean;
-      /**
-       * supply null if no caret positioning is desired, and instead
-       * text should be auto-selected
-       */
-      initialCaretSceneCoords?: { x: number; y: number } | null;
     },
   ) {
     const elementsMap = this.scene.getElementsMapIncludingDeleted();
@@ -5748,13 +5671,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
@@ -5798,7 +5721,6 @@ class App extends React.Component<AppProps, AppState> {
       element,
       excalidrawContainer: this.excalidrawContainerRef.current,
       app: this,
-      initialCaretSceneCoords,
       // when text is selected, it's hard (at least on iOS) to re-position the
       // caret (i.e. deselect). There's not much use for always selecting
       // the text on edit anyway (and users can select-all from contextmenu
@@ -5822,68 +5744,6 @@ class App extends React.Component<AppProps, AppState> {
     });
   }
 
-  private getSelectedTextElement(
-    container?: ExcalidrawTextContainer | null,
-  ): NonDeleted<ExcalidrawTextElement> | null {
-    const selectedElements = this.scene.getSelectedElements(this.state);
-
-    if (selectedElements.length !== 1) {
-      return null;
-    }
-
-    const selectedElement = selectedElements[0]!;
-
-    if (isTextElement(selectedElement)) {
-      return selectedElement;
-    }
-
-    if (!container) {
-      return null;
-    }
-
-    return getBoundTextElement(
-      selectedElement,
-      this.scene.getNonDeletedElementsMap(),
-    );
-  }
-
-  private getSelectedTextEditingContainerAtPosition(
-    hitElement: NonDeletedExcalidrawElement | null,
-    sceneCoords: { x: number; y: number },
-  ): ExcalidrawTextContainer | null | undefined {
-    const selectedElements = this.scene.getSelectedElements(this.state);
-
-    if (
-      selectedElements.length !== 1 ||
-      !hitElement ||
-      hitElement.id !== selectedElements[0]!.id
-    ) {
-      return null;
-    }
-
-    const selectedElement = selectedElements[0]!;
-
-    if (isTextElement(selectedElement)) {
-      return null;
-    }
-
-    if (!isValidTextContainer(selectedElement)) {
-      return undefined;
-    }
-
-    const textElement = this.getSelectedTextElement(selectedElement);
-    const hitTextElement = this.getTextElementAtPosition(
-      sceneCoords.x,
-      sceneCoords.y,
-    );
-
-    if (!textElement || hitTextElement?.id !== textElement.id) {
-      return undefined;
-    }
-
-    return selectedElement;
-  }
-
   private getTextElementAtPosition(
     x: number,
     y: number,
@@ -5897,58 +5757,6 @@ class App extends React.Component<AppProps, AppState> {
     return null;
   }
 
-  private isHittingTextAutoResizeHandle = (
-    selectedElements: NonDeleted<ExcalidrawElement>[],
-    point: Readonly<{ x: number; y: number }>,
-  ): boolean => {
-    const activeTextElement = getActiveTextElement(
-      selectedElements,
-      this.state,
-    );
-
-    if (
-      activeTextElement &&
-      !activeTextElement.isDeleted &&
-      !activeTextElement.autoResize &&
-      isPointHittingTextAutoResizeHandle(
-        point,
-        activeTextElement,
-        this.state.zoom.value,
-        this.editorInterface.formFactor,
-      )
-    ) {
-      return true;
-    }
-
-    return false;
-  };
-
-  private handleTextAutoResizeHandlePointerDown = (
-    selectedElements: NonDeleted<ExcalidrawElement>[],
-    point: Readonly<{ x: number; y: number }>,
-  ) => {
-    const activeTextElement = getActiveTextElement(
-      selectedElements,
-      this.state,
-    );
-    if (
-      !activeTextElement ||
-      !this.isHittingTextAutoResizeHandle(selectedElements, point)
-    ) {
-      return false;
-    }
-
-    this.actionManager.executeAction(
-      actionTextAutoResize,
-      "ui",
-      // we need to pass down the element since it may already be deselected
-      // due to the pointerdown
-      activeTextElement,
-    );
-    this.resetCursor();
-    return true;
-  };
-
   // NOTE: Hot path for hit testing, so avoid unnecessary computations
   private getElementAtPosition(
     x: number,
@@ -6161,7 +5969,6 @@ class App extends React.Component<AppProps, AppState> {
     insertAtParentCenter = true,
     container,
     autoEdit = true,
-    initialCaretSceneCoords,
   }: {
     /** X position to insert text at */
     sceneX: number;
@@ -6171,7 +5978,6 @@ class App extends React.Component<AppProps, AppState> {
     insertAtParentCenter?: boolean;
     container?: ExcalidrawTextContainer | null;
     autoEdit?: boolean;
-    initialCaretSceneCoords?: { x: number; y: number };
   }) => {
     let shouldBindToContainer = false;
 
@@ -6192,9 +5998,24 @@ class App extends React.Component<AppProps, AppState> {
         shouldBindToContainer = true;
       }
     }
-    const existingTextElement =
+    let existingTextElement: NonDeleted<ExcalidrawTextElement> | null = null;
-      this.getSelectedTextElement(container) ||
+
-      this.getTextElementAtPosition(sceneX, sceneY);
+    const selectedElements = this.scene.getSelectedElements(this.state);
+
+    if (selectedElements.length === 1) {
+      if (isTextElement(selectedElements[0])) {
+        existingTextElement = selectedElements[0];
+      } else if (container) {
+        existingTextElement = getBoundTextElement(
+          selectedElements[0],
+          this.scene.getNonDeletedElementsMap(),
+        );
+      } else {
+        existingTextElement = this.getTextElementAtPosition(sceneX, sceneY);
+      }
+    } else {
+      existingTextElement = this.getTextElementAtPosition(sceneX, sceneY);
+    }
 
     const fontFamily =
       existingTextElement?.fontFamily || this.state.currentItemFontFamily;
@@ -6241,32 +6062,11 @@ class App extends React.Component<AppProps, AppState> {
       y: sceneY,
     });
 
-    const textCreationGridPoint = this.getTextCreationGridPoint(sceneX, sceneY);
-
-    const newTextElementPosition = parentCenterPosition
-      ? {
-          x: parentCenterPosition.elementCenterX,
-          y: parentCenterPosition.elementCenterY,
-        }
-      : !existingTextElement
-      ? {
-          x: textCreationGridPoint?.x ?? sceneX,
-          y:
-            textCreationGridPoint === null
-              ? // Free text starts from a point cursor, so center the first line box on it.
-                sceneY - getLineHeightInPx(fontSize, lineHeight) / 2
-              : textCreationGridPoint.y,
-        }
-      : {
-          x: sceneX,
-          y: sceneY,
-        };
-
     const element =
       existingTextElement ||
       newTextElement({
-        x: newTextElementPosition.x,
+        x: parentCenterPosition ? parentCenterPosition.elementCenterX : sceneX,
-        y: newTextElementPosition.y,
+        y: parentCenterPosition ? parentCenterPosition.elementCenterY : sceneY,
         strokeColor: this.state.currentItemStrokeColor,
         backgroundColor: this.state.currentItemBackgroundColor,
         fillStyle: this.state.currentItemFillStyle,
@@ -6316,9 +6116,6 @@ class App extends React.Component<AppProps, AppState> {
     if (autoEdit || existingTextElement || container) {
       this.handleTextWysiwyg(element, {
         isExistingElement: !!existingTextElement,
-        initialCaretSceneCoords: existingTextElement
-          ? initialCaretSceneCoords
-          : null,
       });
     } else {
       this.setState({
@@ -6344,48 +6141,9 @@ class App extends React.Component<AppProps, AppState> {
     }
   };
 
-  private shouldHandleBrowserCanvasDoubleClick = (type: string) => {
-    // TODO remove this once we consolidate double-click logic and handle
-    // ourselves for all event types together
-    if (type === "touch") {
-      return true;
-    }
-    if (this.lastCompletedCanvasClicks.length === 0) {
-      return true;
-    }
-
-    if (this.lastCompletedCanvasClicks.length < 2) {
-      return false;
-    }
-
-    const [firstClick, secondClick] = this.lastCompletedCanvasClicks;
-
-    return (
-      pointDistance(
-        pointFrom(firstClick.x, firstClick.y),
-        pointFrom(secondClick.x, secondClick.y),
-      ) <= DOUBLE_TAP_POSITION_THRESHOLD
-    );
-  };
-
   private handleCanvasDoubleClick = (
-    event: Pick<
+    event: React.MouseEvent<HTMLCanvasElement>,
-      React.MouseEvent<HTMLCanvasElement>,
-      | "type"
-      | "clientX"
-      | "clientY"
-      | "altKey"
-      | "ctrlKey"
-      | "metaKey"
-      | "shiftKey"
-    >,
   ) => {
-    if (
-      this.state.editingTextElement ||
-      !this.shouldHandleBrowserCanvasDoubleClick(event.type)
-    ) {
-      return;
-    }
     // case: double-clicking with arrow/line tool selected would both create
     // text and enter multiElement mode
     if (this.state.multiElement) {
@@ -6573,21 +6331,6 @@ class App extends React.Component<AppProps, AppState> {
     }
   };
 
-  private handleCanvasClick = (event: React.MouseEvent<HTMLCanvasElement>) => {
-    if (event.button !== POINTER_BUTTON.MAIN) {
-      this.lastCompletedCanvasClicks = [];
-      return;
-    }
-
-    this.lastCompletedCanvasClicks = [
-      ...this.lastCompletedCanvasClicks.slice(-1),
-      {
-        x: event.clientX,
-        y: event.clientY,
-      },
-    ];
-  };
-
   private getElementLinkAtPosition = (
     scenePointer: Readonly<{ x: number; y: number }>,
     hitElementMightBeLocked: NonDeletedExcalidrawElement | null,
@@ -6807,10 +6550,7 @@ class App extends React.Component<AppProps, AppState> {
 
     if (
       !this.state.newElement &&
-      (isActiveToolNonLinearSnappable(this.state.activeTool.type) ||
+      isActiveToolNonLinearSnappable(this.state.activeTool.type)
-        ((this.state.activeTool.type === "line" ||
-          this.state.activeTool.type === "arrow") &&
-          this.state.currentItemArrowType !== ARROW_TYPE.elbow))
     ) {
       const { originOffset, snapLines } = getSnapLinesAtPointer(
         this.scene.getNonDeletedElements(),
@@ -6859,7 +6599,7 @@ class App extends React.Component<AppProps, AppState> {
       this.state.selectedLinearElement?.isEditing &&
       !this.state.selectedLinearElement.isDragging
     ) {
-      const result = this.state.newElement
+      const editingLinearElement = this.state.newElement
         ? null
         : LinearElementEditor.handlePointerMoveInEditMode(
             event,
@@ -6868,33 +6608,18 @@ class App extends React.Component<AppProps, AppState> {
             this,
           );
 
-      if (result) {
+      if (
-        const { editingLinearElement, snapLines } = result;
+        editingLinearElement &&
-        const nextState = this.withStableSnapLines({
+        editingLinearElement !== this.state.selectedLinearElement
-          selectedLinearElement: editingLinearElement,
+      ) {
-          snapLines,
+        // Since we are reading from previous state which is not possible with
-        });
+        // automatic batching in React 18 hence using flush sync to synchronously
-
+        // update the state. Check https://github.com/excalidraw/excalidraw/pull/5508 for more details.
-        if (
+        flushSync(() => {
-          editingLinearElement &&
+          this.setState({
-          this.shouldUpdateSelectedLinearElementState(
+            selectedLinearElement: editingLinearElement,
-            nextState.selectedLinearElement,
-            nextState.snapLines,
-          )
-        ) {
-          // Since we are reading from previous state which is not possible with
-          // automatic batching in React 18 hence using flush sync to synchronously
-          // update the state. Check https://github.com/excalidraw/excalidraw/pull/5508 for more details.
-          flushSync(() => {
-            this.setState(nextState);
           });
-        }
+        });
-        if (
-          editingLinearElement.lastUncommittedPoint == null &&
-          this.state.suggestedBinding
-        ) {
-          this.setState({ suggestedBinding: null });
-        }
       }
     }
 
@@ -7036,23 +6761,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,
             },
           },
         });
@@ -7138,12 +6867,6 @@ class App extends React.Component<AppProps, AppState> {
     const elements = this.scene.getNonDeletedElements();
 
     const selectedElements = this.scene.getSelectedElements(this.state);
-
-    if (this.isHittingTextAutoResizeHandle(selectedElements, scenePointer)) {
-      setCursor(this.interactiveCanvas, CURSOR_TYPE.POINTER);
-      return;
-    }
-
     if (
       selectedElements.length === 1 &&
       !isOverScrollBar &&
@@ -7280,14 +7003,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") {
@@ -7296,9 +7011,7 @@ class App extends React.Component<AppProps, AppState> {
         setCursor(this.interactiveCanvas, CURSOR_TYPE.AUTO);
       } else if (
         // if using cmd/ctrl, we're not dragging
-        !event[KEYS.CTRL_OR_CMD] &&
+        !event[KEYS.CTRL_OR_CMD]
-        // editing text -> don't show move cursor when hovering over its bbox
-        hitElement?.id !== this.state.editingTextElement?.id
       ) {
         if (
           (hitElement ||
@@ -7519,8 +7232,6 @@ class App extends React.Component<AppProps, AppState> {
   private handleCanvasPointerDown = (
     event: React.PointerEvent<HTMLElement>,
   ) => {
-    const selectedElements = this.scene.getSelectedElements(this.state);
-
     // If Ctrl is not held, ensure isBindingEnabled reflects the user preference.
     if (!event.ctrlKey) {
       const preferenceEnabled = this.state.bindingPreference === "enabled";
@@ -7744,15 +7455,6 @@ class App extends React.Component<AppProps, AppState> {
       selectedElementsAreBeingDragged: false,
     });
 
-    if (
-      this.handleTextAutoResizeHandlePointerDown(
-        selectedElements,
-        pointerDownState.origin,
-      )
-    ) {
-      return;
-    }
-
     if (this.handleDraggingScrollBar(event, pointerDownState)) {
       return;
     }
@@ -7779,24 +7481,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)
@@ -7985,10 +7680,6 @@ class App extends React.Component<AppProps, AppState> {
     }
 
     this.removePointer(event);
-    this.lastPointerUpIsDoubleClick = this.isDoubleClick(
-      this.lastPointerUpEvent,
-      event,
-    );
     this.lastPointerUpEvent = event;
 
     if (!event.ctrlKey) {
@@ -8785,14 +8476,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
     );
   }
 
@@ -8827,7 +8516,6 @@ class App extends React.Component<AppProps, AppState> {
       insertAtParentCenter: !event.altKey,
       container,
       autoEdit: false,
-      initialCaretSceneCoords: { x: sceneX, y: sceneY },
     });
 
     resetCursor(this.interactiveCanvas);
@@ -9752,27 +9440,25 @@ class App extends React.Component<AppProps, AppState> {
             pointerDownState.lastCoords.x = pointerCoords.x;
             pointerDownState.lastCoords.y = pointerCoords.y;
             pointerDownState.drag.hasOccurred = true;
-            const nextState = this.withStableSnapLines(newState);
 
             // NOTE: Optimize setState calls because it
             // affects history and performance
             if (
-              nextState.suggestedBinding !== this.state.suggestedBinding ||
+              newState.suggestedBinding !== this.state.suggestedBinding ||
               !isShallowEqual(
-                nextState.selectedLinearElement?.selectedPointsIndices ?? [],
+                newState.selectedLinearElement?.selectedPointsIndices ?? [],
                 this.state.selectedLinearElement?.selectedPointsIndices ?? [],
               ) ||
-              nextState.selectedLinearElement?.hoverPointIndex !==
+              newState.selectedLinearElement?.hoverPointIndex !==
                 this.state.selectedLinearElement?.hoverPointIndex ||
-              nextState.selectedLinearElement?.customLineAngle !==
+              newState.selectedLinearElement?.customLineAngle !==
                 this.state.selectedLinearElement?.customLineAngle ||
               this.state.selectedLinearElement.isDragging !==
-                nextState.selectedLinearElement?.isDragging ||
+                newState.selectedLinearElement?.isDragging ||
               this.state.selectedLinearElement?.initialState?.altFocusPoint !==
-                nextState.selectedLinearElement?.initialState?.altFocusPoint ||
+                newState.selectedLinearElement?.initialState?.altFocusPoint
-              nextState.snapLines !== this.state.snapLines
             ) {
-              this.setState(nextState);
+              this.setState(newState);
             }
 
             return;
@@ -10327,7 +10013,6 @@ class App extends React.Component<AppProps, AppState> {
                 this.state.selectionElement,
                 this.scene.getNonDeletedElementsMap(),
                 false,
-                this.state.boxSelectionMode,
               )
             : [];
 
@@ -10461,7 +10146,8 @@ class App extends React.Component<AppProps, AppState> {
       this.lassoTrail.endPath();
       this.previousPointerMoveCoords = null;
 
-      SnapCache.destroy();
+      SnapCache.setReferenceSnapPoints(null);
+      SnapCache.setVisibleGaps(null);
 
       this.savePointer(childEvent.clientX, childEvent.clientY, "up");
 
@@ -11315,35 +11001,6 @@ class App extends React.Component<AppProps, AppState> {
         return;
       }
 
-      const selectedTextEditingContainer =
-        this.getSelectedTextEditingContainerAtPosition(hitElement, sceneCoords);
-
-      if (
-        activeTool.type === this.state.preferredSelectionTool.type &&
-        !this.state.editingTextElement &&
-        !pointerDownState.drag.hasOccurred &&
-        !pointerDownState.hit.wasAddedToSelection &&
-        !childEvent.shiftKey &&
-        !childEvent[KEYS.CTRL_OR_CMD] &&
-        !childEvent.altKey &&
-        childEvent.pointerType !== "touch" &&
-        hitElement &&
-        ((isTextElement(hitElement) &&
-          this.state.selectedElementIds[hitElement.id] &&
-          this.scene.getSelectedElements(this.state).length === 1) ||
-          selectedTextEditingContainer)
-      ) {
-        this.startTextEditing({
-          sceneX: sceneCoords.x,
-          sceneY: sceneCoords.y,
-          container: selectedTextEditingContainer,
-          initialCaretSceneCoords: this.lastPointerUpIsDoubleClick
-            ? undefined
-            : sceneCoords,
-        });
-        return;
-      }
-
       if (!activeTool.locked && activeTool.type !== "freedraw" && newElement) {
         this.setState((prevState) => ({
           selectedElementIds: makeNextSelectedElementIds(

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/HintViewer.tsx

@@ -3,7 +3,6 @@ import { CANVAS_SEARCH_TAB, DEFAULT_SIDEBAR } from "@excalidraw/common";
 import {
   isFlowchartNodeElement,
   isImageElement,
-  isGridModeEnabled,
   isLinearElement,
   isLineElement,
   isTextBindableContainer,
@@ -17,6 +16,7 @@ import type { EditorInterface } from "@excalidraw/common";
 import { t } from "../i18n";
 import { getShortcutKey } from "../shortcut";
 import { isEraserActive } from "../appState";
+import { isGridModeEnabled } from "../snapping";
 
 import "./HintViewer.scss";
 

packages/excalidraw/components/ImageExportDialog.tsx

@@ -1,4 +1,3 @@
-import { exportToCanvas } from "@excalidraw/utils/export";
 import React, { useEffect, useRef, useState } from "react";
 
 import {
@@ -6,6 +5,7 @@ import {
   EXPORT_IMAGE_TYPES,
   isFirefox,
   EXPORT_SCALES,
+  THEME,
   cloneJSON,
 } from "@excalidraw/common";
 
@@ -26,6 +26,7 @@ import { useCopyStatus } from "../hooks/useCopiedIndicator";
 
 import { t } from "../i18n";
 import { isSomeElementSelected } from "../scene";
+import { exportToCanvas } from "../scene/export";
 
 import { copyIcon, downloadIcon, helpIcon } from "./icons";
 import { Dialog } from "./Dialog";
@@ -128,19 +129,26 @@ const ImageExportModal = ({
     };
 
     exportToCanvas({
-      elements: exportedElements,
+      data: {
-      appState: {
+        elements: exportedElements,
-        ...appStateSnapshot,
+        appState: {
-        name: projectName,
+          ...appStateSnapshot,
-        exportBackground: exportWithBackground,
+          name: projectName,
-        exportWithDarkMode,
+          exportBackground: exportWithBackground,
-        exportScale,
+          exportScale,
-        exportEmbedScene: embedScene,
+          exportEmbedScene: embedScene,
+        },
+        files,
+      },
+      config: {
+        padding: DEFAULT_EXPORT_PADDING,
+        maxWidthOrHeight: Math.max(maxWidth, maxHeight),
+        exportingFrame,
+        theme: exportWithDarkMode ? THEME.DARK : THEME.LIGHT,
+        canvasBackgroundColor: exportWithBackground
+          ? appStateSnapshot.viewBackgroundColor
+          : false,
       },
-      files,
-      exportPadding: DEFAULT_EXPORT_PADDING,
-      maxWidthOrHeight: Math.max(maxWidth, maxHeight),
-      exportingFrame,
     })
       .then(async (canvas) => {
         if (isStaleRequest()) {

packages/excalidraw/components/PasteChartDialog.tsx

@@ -72,18 +72,20 @@ const ChartPreviewBtn = (props: {
     const previewNode = previewRef.current!;
 
     (async () => {
-      svg = await exportToSvg(
+      svg = await exportToSvg({
-        elements,
+        data: {
-        {
+          elements,
-          exportBackground: false,
+          appState: {
-          viewBackgroundColor: "#fff",
+            exportBackground: false,
-          exportWithDarkMode: theme === "dark",
+            viewBackgroundColor: "#fff",
+          },
+          files: null,
         },
-        null, // files
+        config: {
-        {
           skipInliningFonts: true,
+          theme,
         },
-      );
+      });
       svg.querySelector(".style-fonts")?.remove();
       previewNode.replaceChildren();
       previewNode.appendChild(svg);
@@ -134,18 +136,20 @@ const PlainTextPreviewBtn = (props: {
     const previewNode = previewRef.current!;
 
     (async () => {
-      const svg = await exportToSvg(
+      const svg = await exportToSvg({
-        [textElement],
+        data: {
-        {
+          elements: [textElement],
-          exportBackground: false,
+          appState: {
-          viewBackgroundColor: "#fff",
+            exportBackground: false,
-          exportWithDarkMode: theme === "dark",
+            viewBackgroundColor: "#fff",
+          },
+          files: null,
         },
-        null,
+        config: {
-        {
           skipInliningFonts: true,
+          theme,
         },
-      );
+      });
       svg.querySelector(".style-fonts")?.remove();
       previewNode.replaceChildren();
       previewNode.appendChild(svg);

packages/excalidraw/components/PublishLibrary.tsx

@@ -1,4 +1,3 @@
-import { exportToCanvas, exportToSvg } from "@excalidraw/utils/export";
 import { useCallback, useEffect, useRef, useState } from "react";
 
 import {
@@ -13,6 +12,7 @@ import {
 import { EditorLocalStorage } from "../data/EditorLocalStorage";
 import { canvasToBlob, resizeImageFile } from "../data/blob";
 import { t } from "../i18n";
+import { exportToCanvas, exportToSvg } from "../scene/export";
 
 import { Dialog } from "./Dialog";
 import DialogActionButton from "./DialogActionButton";
@@ -63,9 +63,14 @@ const generatePreviewImage = async (libraryItems: LibraryItems) => {
   // ---------------------------------------------------------------------------
   for (const [index, item] of libraryItems.entries()) {
     const itemCanvas = await exportToCanvas({
-      elements: item.elements,
+      data: {
-      files: null,
+        elements: item.elements,
-      maxWidthOrHeight: BOX_SIZE,
+        files: null,
+        appState: {},
+      },
+      config: {
+        maxWidthOrHeight: BOX_SIZE,
+      },
     });
 
     const { width, height } = itemCanvas;
@@ -127,14 +132,18 @@ const SingleLibraryItem = ({
     }
     (async () => {
       const svg = await exportToSvg({
-        elements: libItem.elements,
+        data: {
-        appState: {
+          elements: libItem.elements,
-          ...appState,
+          appState: {
-          viewBackgroundColor: "#fff",
+            ...appState,
-          exportBackground: true,
+            viewBackgroundColor: "#fff",
+            exportBackground: true,
+          },
+          files: null,
+        },
+        config: {
+          skipInliningFonts: true,
         },
-        files: null,
-        skipInliningFonts: true,
       });
       node.innerHTML = svg.outerHTML;
     })();

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/Range.tsx

@@ -1,78 +1,74 @@
 import React, { useEffect } from "react";
 
+import { t } from "../i18n";
+
 import "./Range.scss";
 
+import type { AppClassProperties } from "../types";
+
 export type RangeProps = {
-  label: React.ReactNode;
+  updateData: (value: number) => void;
-  value: number;
+  app: AppClassProperties;
-  onChange: (value: number) => void;
-  min?: number;
-  max?: number;
-  step?: number;
-  minLabel?: React.ReactNode;
-  hasCommonValue?: boolean;
   testId?: string;
 };
 
-export const Range = ({
+export const Range = ({ updateData, app, testId }: RangeProps) => {
-  label,
-  value,
-  onChange,
-  min = 0,
-  max = 100,
-  step = 10,
-  minLabel = min,
-  hasCommonValue = true,
-  testId,
-}: RangeProps) => {
   const rangeRef = React.useRef<HTMLInputElement>(null);
   const valueRef = React.useRef<HTMLDivElement>(null);
+  const selectedElements = app.scene.getSelectedElements(app.state);
+  let hasCommonOpacity = true;
+  const firstElement = selectedElements.at(0);
+  const leastCommonOpacity = selectedElements.reduce((acc, element) => {
+    if (acc != null && acc !== element.opacity) {
+      hasCommonOpacity = false;
+    }
+    if (acc == null || acc > element.opacity) {
+      return element.opacity;
+    }
+    return acc;
+  }, firstElement?.opacity ?? null);
+
+  const value = leastCommonOpacity ?? app.state.currentItemOpacity;
 
   useEffect(() => {
     if (rangeRef.current && valueRef.current) {
       const rangeElement = rangeRef.current;
       const valueElement = valueRef.current;
       const inputWidth = rangeElement.offsetWidth;
-      const thumbWidth =
+      const thumbWidth = 15; // 15 is the width of the thumb
-        parseFloat(
-          getComputedStyle(rangeElement).getPropertyValue(
-            "--slider-thumb-size",
-          ),
-        ) || 16;
-      const progress = ((value - min) / (max - min || 1)) * 100;
       const position =
-        (progress / 100) * (inputWidth - thumbWidth) + thumbWidth / 2;
+        (value / 100) * (inputWidth - thumbWidth) + thumbWidth / 2;
       valueElement.style.left = `${position}px`;
-      rangeElement.style.background = `linear-gradient(to right, var(--color-slider-track) 0%, var(--color-slider-track) ${progress}%, var(--button-bg) ${progress}%, var(--button-bg) 100%)`;
+      rangeElement.style.background = `linear-gradient(to right, var(--color-slider-track) 0%, var(--color-slider-track) ${value}%, var(--button-bg) ${value}%, var(--button-bg) 100%)`;
     }
-  }, [max, min, value]);
+  }, [value]);
 
   return (
     <label className="control-label">
-      {label}
+      {t("labels.opacity")}
       <div className="range-wrapper">
         <input
           style={{
-            ["--color-slider-track" as string]: hasCommonValue
+            ["--color-slider-track" as string]: hasCommonOpacity
               ? undefined
               : "var(--button-bg)",
           }}
           ref={rangeRef}
           type="range"
-          min={min}
+          min="0"
-          max={max}
+          max="100"
-          step={step}
+          step="10"
           onChange={(event) => {
-            onChange(+event.target.value);
+            updateData(+event.target.value);
           }}
           value={value}
           className="range-input"
           data-testid={testId}
         />
         <div className="value-bubble" ref={valueRef}>
-          {value !== min ? value : null}
+          {value !== 0 ? value : null}
         </div>
-        <div className="zero-label">{minLabel}</div>
+        <div className="zero-label">0</div>
       </div>
     </label>
   );

packages/excalidraw/components/Stats/index.tsx

@@ -12,11 +12,10 @@ import { frameAndChildrenSelectedTogether } from "@excalidraw/element";
 
 import { elementsAreInSameGroup } from "@excalidraw/element";
 
-import { isGridModeEnabled } from "@excalidraw/element";
-
 import type { NonDeletedExcalidrawElement } from "@excalidraw/element/types";
 
 import { t } from "../../i18n";
+import { isGridModeEnabled } from "../../snapping";
 import { useExcalidrawAppState, useExcalidrawSetAppState } from "../App";
 import { Island } from "../Island";
 import { CloseIcon } from "../icons";

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

@@ -361,10 +361,12 @@ describe("stats for a non-generic element", () => {
     mouse.clickAt(20, 30);
     const editor = await getTextEditor();
     updateTextEditor(editor, "Hello!");
-    Keyboard.exitTextEditor(editor);
+    act(() => {
+      editor.blur();
+    });
 
     const text = h.elements[0] as ExcalidrawTextElement;
-    API.setSelectedElements([text]);
+    mouse.clickOn(text);
 
     elementStats = stats?.querySelector("#elementStats");
 
@@ -750,7 +752,7 @@ describe("frame resizing behavior", () => {
       x: 0,
       y: 0,
       width: 100,
-      height: 103,
+      height: 100,
     });
 
     // Create a rectangle outside the frame

packages/excalidraw/components/TTDDialog/common.ts

@@ -1,8 +1,4 @@
-import {
+import { DEFAULT_EXPORT_PADDING, EDITOR_LS_KEYS } from "@excalidraw/common";
-  DEFAULT_EXPORT_PADDING,
-  EDITOR_LS_KEYS,
-  THEME,
-} from "@excalidraw/common";
 
 import { convertToExcalidrawElements } from "@excalidraw/element";
 
@@ -105,14 +101,16 @@ export const convertMermaidToExcalidraw = async ({
     };
 
     const canvas = await exportToCanvas({
-      elements: data.current.elements,
+      data: {
-      files: data.current.files,
+        elements: data.current.elements,
-      exportPadding: DEFAULT_EXPORT_PADDING,
+        files: data.current.files,
-      maxWidthOrHeight:
+      },
-        Math.max(parent.offsetWidth, parent.offsetHeight) *
+      config: {
-        window.devicePixelRatio,
+        padding: DEFAULT_EXPORT_PADDING,
-      appState: {
+        maxWidthOrHeight:
-        exportWithDarkMode: theme === THEME.DARK,
+          Math.max(parent.offsetWidth, parent.offsetHeight) *
+          window.devicePixelRatio,
+        theme,
       },
     });
 

packages/excalidraw/components/canvases/InteractiveCanvas.tsx

@@ -54,7 +54,6 @@ type InteractiveCanvasProps = {
     DOMAttributes<HTMLCanvasElement | HTMLDivElement>["onContextMenu"],
     undefined
   >;
-  onClick: Exclude<DOMAttributes<HTMLCanvasElement>["onClick"], undefined>;
   onPointerMove: Exclude<
     DOMAttributes<HTMLCanvasElement>["onPointerMove"],
     undefined
@@ -214,7 +213,6 @@ const InteractiveCanvas = (props: InteractiveCanvasProps) => {
       height={props.appState.height * props.scale}
       ref={props.handleCanvasRef}
       onContextMenu={props.onContextMenu}
-      onClick={props.onClick}
       onPointerMove={props.onPointerMove}
       onPointerUp={props.onPointerUp}
       onPointerCancel={props.onPointerCancel}

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/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

@@ -4,9 +4,9 @@ import {
   IMAGE_MIME_TYPES,
   isFirefox,
   MIME_TYPES,
+  THEME,
   cloneJSON,
   SVG_DOCUMENT_PREAMBLE,
-  arrayToMap,
 } from "@excalidraw/common";
 
 import { getNonDeletedElements } from "@excalidraw/element";
@@ -50,7 +50,6 @@ export const prepareElementsForExport = (
   exportSelectionOnly: boolean,
 ) => {
   elements = getNonDeletedElements(elements);
-  const elementsMap = arrayToMap(elements);
 
   const isExportingSelection =
     exportSelectionOnly &&
@@ -73,11 +72,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,
@@ -121,20 +116,29 @@ export const exportCanvas = async (
   if (elements.length === 0) {
     throw new Error(t("alerts.cannotExportEmptyCanvas"));
   }
+
+  const theme = appState.exportWithDarkMode ? THEME.DARK : THEME.LIGHT;
+
   if (type === "svg" || type === "clipboard-svg") {
-    const svgPromise = exportToSvg(
+    const svgPromise = exportToSvg({
-      elements,
+      data: {
-      {
+        elements,
-        exportBackground,
+        appState: {
-        exportWithDarkMode: appState.exportWithDarkMode,
+          ...appState,
-        viewBackgroundColor,
+          exportBackground,
-        exportPadding,
+          exportEmbedScene: appState.exportEmbedScene && type === "svg",
-        exportScale: appState.exportScale,
+        },
-        exportEmbedScene: appState.exportEmbedScene && type === "svg",
+        files,
       },
-      files,
+      config: {
-      { exportingFrame },
+        padding: exportPadding,
-    );
+        exportingFrame,
+        theme,
+        canvasBackgroundColor: exportBackground
+          ? viewBackgroundColor
+          : "transparent",
+      },
+    });
 
     if (type === "svg") {
       return fileSave(
@@ -164,11 +168,19 @@ export const exportCanvas = async (
     }
   }
 
-  const tempCanvas = exportToCanvas(elements, appState, files, {
+  const tempCanvas = exportToCanvas({
-    exportBackground,
+    data: {
-    viewBackgroundColor,
+      elements,
-    exportPadding,
+      appState,
-    exportingFrame,
+      files,
+    },
+    config: {
+      canvasBackgroundColor: exportBackground ? viewBackgroundColor : false,
+      padding: exportPadding,
+      theme,
+      scale: appState.exportScale,
+      exportingFrame,
+    },
   });
 
   if (type === "png") {

packages/excalidraw/data/resave.ts

@@ -20,6 +20,10 @@ export const resaveAsImageWithScene = async (
 ) => {
   const fileHandleType = getFileHandleType(fileHandle);
 
+  if (Math.random() < 1) {
+    throw new Error("OLALALALA");
+  }
+
   if (!isImageFileHandleType(fileHandleType)) {
     throw new Error(
       "fileHandle should exist and should be of type svg or png when resaving",

packages/excalidraw/data/restore.ts

@@ -96,8 +96,6 @@ type RestoredAppState = Omit<
   "offsetTop" | "offsetLeft" | "width" | "height"
 >;
 
-const MAX_ARROW_PX = 75_000;
-
 export const AllowedExcalidrawActiveTools: Record<
   AppState["activeTool"]["type"],
   boolean
@@ -253,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);
   }
@@ -469,8 +465,8 @@ export const restoreElement = (
         element.endArrowhead === undefined
           ? "arrow"
           : normalizeArrowhead(element.endArrowhead);
-      const x = element.x as number | undefined;
+      const x: number | undefined = element.x;
-      const y = element.y as number | undefined;
+      const y: number | undefined = element.y;
       const points: readonly LocalPoint[] | undefined = // migrate old arrow model to new one
         !Array.isArray(element.points) || element.points.length < 2
           ? [pointFrom(0, 0), pointFrom(element.width, element.height)]
@@ -495,8 +491,8 @@ export const restoreElement = (
         startArrowhead,
         endArrowhead,
         points,
-        x: x ?? 0,
+        x,
-        y: y ?? 0,
+        y,
         elbowed: (element as ExcalidrawArrowElement).elbowed,
         ...getSizeFromPoints(points),
       };
@@ -515,44 +511,12 @@ export const restoreElement = (
           })
         : restoreElementWithProperties(element as ExcalidrawArrowElement, base);
 
-      const normalizedRestoredElement = {
+      return {
         ...restoredElement,
         ...LinearElementEditor.getNormalizeElementPointsAndCoords(
           restoredElement,
         ),
       };
-
-      // Last resort fix for extremely large arrows
-      if (
-        normalizedRestoredElement.width > MAX_ARROW_PX ||
-        normalizedRestoredElement.height > MAX_ARROW_PX
-      ) {
-        console.error(
-          `Removing extremely large arrow ${
-            normalizedRestoredElement.id
-          } (type: ${
-            isElbowArrow(normalizedRestoredElement) ? "elbow" : "simple"
-          }, width: ${normalizedRestoredElement.width}, height: ${
-            normalizedRestoredElement.height
-          }, x: ${normalizedRestoredElement.x}, y: ${
-            normalizedRestoredElement.y
-          })`,
-        );
-        return {
-          ...normalizedRestoredElement,
-          x: 0,
-          y: 0,
-          width: 100,
-          height: 100,
-          points: [
-            pointFrom<LocalPoint>(0, 0),
-            pointFrom<LocalPoint>(100, 100),
-          ],
-          isDeleted: true,
-        };
-      }
-
-      return normalizedRestoredElement;
     }
 
     // generic elements
@@ -700,7 +664,6 @@ export const restoreElements = <T extends ExcalidrawElement>(
   const existingElementsMap = existingElements
     ? arrayToMap(existingElements)
     : null;
-
   const restoredElements = syncInvalidIndices(
     (targetElements || []).reduce((elements, element) => {
       // filtering out selection, which is legacy, no longer kept in elements,
@@ -797,7 +760,7 @@ export const restoreElements = <T extends ExcalidrawElement>(
     }
   }
 
-  // NOTE (mtolmacs): Temporary fix for invalid/self-bound elbow arrows
+  // NOTE (mtolmacs): Temporary fix for extremely large arrows
   // Need to iterate again so we have attached text nodes in elementsMap
   return restoredElements.map((element) => {
     if (
@@ -971,12 +934,6 @@ export const restoreAppState = (
         : defaultValue;
   }
 
-  const boxSelectionMode =
-    appState.boxSelectionMode ?? localAppState?.boxSelectionMode;
-  if (boxSelectionMode !== undefined) {
-    nextAppState.boxSelectionMode = boxSelectionMode;
-  }
-
   return {
     ...nextAppState,
     cursorButton: localAppState?.cursorButton || "up",

packages/excalidraw/hooks/useLibraryItemSvg.ts

@@ -1,8 +1,9 @@
-import { exportToSvg } from "@excalidraw/utils/export";
 import { useEffect, useState } from "react";
 
 import { COLOR_PALETTE } from "@excalidraw/common";
 
+import { exportToSvg } from "../scene/export";
+
 import { atom, useAtom } from "../editor-jotai";
 
 import type { LibraryItem } from "../types";
@@ -12,17 +13,18 @@ export type SvgCache = Map<LibraryItem["id"], SVGSVGElement>;
 export const libraryItemSvgsCache = atom<SvgCache>(new Map());
 
 const exportLibraryItemToSvg = async (elements: LibraryItem["elements"]) => {
-  // TODO should pass theme (appState.exportWithDark) - we're still using
-  // CSS filter here
   return await exportToSvg({
-    elements,
+    data: {
-    appState: {
+      elements,
-      exportBackground: false,
+      appState: {
-      viewBackgroundColor: COLOR_PALETTE.white,
+        exportBackground: false,
+        viewBackgroundColor: COLOR_PALETTE.white,
+      },
+      files: null,
+    },
+    config: {
+      skipInliningFonts: true,
     },
-    files: null,
-    renderEmbeddables: false,
-    skipInliningFonts: true,
   });
 };
 

packages/excalidraw/index-node.ts

@@ -1,4 +1,3 @@
-import { getDefaultAppState } from "./appState";
 import { exportToCanvas } from "./scene/export";
 
 const fs = require("fs");
@@ -59,26 +58,23 @@ const elements = [
 registerFont("./public/Virgil.woff2", { family: "Virgil" });
 registerFont("./public/Cascadia.woff2", { family: "Cascadia" });
 
-const canvas = exportToCanvas(
+(async () => {
-  elements as any,
+  const canvas = await exportToCanvas({
-  {
+    data: {
-    ...getDefaultAppState(),
+      elements: elements as any,
-    offsetTop: 0,
+      appState: {},
-    offsetLeft: 0,
+      files: {},
-    width: 0,
+    },
-    height: 0,
+    config: {
-  },
+      canvasBackgroundColor: "#ffffff",
-  {}, // files
+      createCanvas,
-  {
+    },
-    exportBackground: true,
+  });
-    viewBackgroundColor: "#ffffff",
-  },
-  createCanvas,
-);
 
-const out = fs.createWriteStream("test.png");
+  const out = fs.createWriteStream("test.png");
-const stream = (canvas as any).createPNGStream();
+  const stream = (canvas as any).createPNGStream();
-stream.pipe(out);
+  stream.pipe(out);
-out.on("finish", () => {
+  out.on("finish", () => {
-  console.info("test.png was created.");
+    console.info("test.png was created.");
-});
+  });
+})();

packages/excalidraw/index.tsx

@@ -304,7 +304,9 @@ export {
   exportToBlob,
   exportToSvg,
   exportToClipboard,
-} from "@excalidraw/utils/export";
+} from "./scene/export";
+
+export type { ExportSceneData, ExportSceneConfig } from "./scene/export";
 
 export { serializeAsJSON, serializeLibraryAsJSON } from "./data/json";
 export {
@@ -382,8 +384,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

@@ -185,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"
   },
@@ -664,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/renderer/interactiveScene.ts

@@ -41,7 +41,6 @@ import {
   maxBindingDistance_simple,
   isTextElement,
   LinearElementEditor,
-  getActiveTextElement,
 } from "@excalidraw/element";
 
 import { renderSelectionElement } from "@excalidraw/element";
@@ -59,8 +58,6 @@ import {
   isFocusPointVisible,
 } from "@excalidraw/element";
 
-import type { EditorInterface } from "@excalidraw/common";
-
 import type {
   TransformHandles,
   TransformHandleType,
@@ -89,10 +86,6 @@ import {
 } from "../scene/scrollbars";
 
 import { getClientColor, renderRemoteCursors } from "../clients";
-import {
-  getTextAutoResizeHandle,
-  getTextBoxPadding,
-} from "../textAutoResizeHandle";
 
 import {
   bootstrapCanvas,
@@ -1156,7 +1149,6 @@ const renderLinearPointHandles = (
           points[idx],
           idx,
           appState.zoom,
-          elementsMap,
         )
       ) {
         renderSingleLinearPoint(
@@ -1497,58 +1489,21 @@ const renderTextBox = (
   selectionColor: InteractiveCanvasRenderConfig["selectionColor"],
 ) => {
   context.save();
-  const padding = getTextBoxPadding(appState.zoom.value);
+  const padding = (DEFAULT_TRANSFORM_HANDLE_SPACING * 2) / appState.zoom.value;
   const width = text.width + padding * 2;
   const height = text.height + padding * 2;
-  const cx = text.x + text.width / 2;
+  const cx = text.x + width / 2;
-  const cy = text.y + text.height / 2;
+  const cy = text.y + height / 2;
-  const shiftX = -(text.width / 2 + padding);
+  const shiftX = -(width / 2 + padding);
-  const shiftY = -(text.height / 2 + padding);
+  const shiftY = -(height / 2 + padding);
   context.translate(cx + appState.scrollX, cy + appState.scrollY);
   context.rotate(text.angle);
   context.lineWidth = 1 / appState.zoom.value;
   context.strokeStyle = selectionColor;
-  context.globalAlpha = 0.5;
-  context.setLineDash([6 / appState.zoom.value, 4 / appState.zoom.value]);
   context.strokeRect(shiftX, shiftY, width, height);
   context.restore();
 };
 
-const renderResetAutoResizeHandle = (
-  text: NonDeleted<ExcalidrawTextElement>,
-  context: CanvasRenderingContext2D,
-  appState: InteractiveCanvasAppState,
-  selectionColor: InteractiveCanvasRenderConfig["selectionColor"],
-  formFactor: EditorInterface["formFactor"],
-) => {
-  const autoResizeHandle = getTextAutoResizeHandle(
-    text,
-    appState.zoom.value,
-    formFactor,
-  );
-
-  if (!autoResizeHandle) {
-    return;
-  }
-
-  context.save();
-  context.globalAlpha = 0.5;
-  context.lineWidth = 1.5 / appState.zoom.value;
-  context.lineCap = "round";
-  context.strokeStyle = selectionColor;
-  context.beginPath();
-  context.moveTo(
-    autoResizeHandle.start[0] + appState.scrollX,
-    autoResizeHandle.start[1] + appState.scrollY,
-  );
-  context.lineTo(
-    autoResizeHandle.end[0] + appState.scrollX,
-    autoResizeHandle.end[1] + appState.scrollY,
-  );
-  context.stroke();
-  context.restore();
-};
-
 const _renderInteractiveScene = ({
   app,
   canvas,
@@ -1629,19 +1584,10 @@ const _renderInteractiveScene = ({
     }
   }
 
-  const activeTextElement = getActiveTextElement(selectedElements, appState);
+  if (
-
+    appState.editingTextElement &&
-  if (activeTextElement && !activeTextElement.autoResize) {
+    isTextElement(appState.editingTextElement)
-    renderResetAutoResizeHandle(
+  ) {
-      activeTextElement,
-      context,
-      appState,
-      renderConfig.selectionColor,
-      editorInterface.formFactor,
-    );
-  }
-
-  if (appState.editingTextElement) {
     const textElement = allElementsMap.get(appState.editingTextElement.id) as
       | ExcalidrawTextElement
       | undefined;

packages/excalidraw/renderer/renderSnaps.ts

@@ -2,8 +2,7 @@ import { pointFrom, type GlobalPoint, type LocalPoint } from "@excalidraw/math";
 
 import { THEME } from "@excalidraw/common";
 
-import type { PointSnapLine, PointerSnapLine } from "@excalidraw/element";
+import type { PointSnapLine, PointerSnapLine } from "../snapping";
-
 import type { InteractiveCanvasAppState } from "../types";
 
 const SNAP_COLOR_LIGHT = "#ff6b6b";

packages/excalidraw/scene/export.ts

@@ -1,13 +1,13 @@
 import rough from "roughjs/bin/rough";
 
 import {
-  DEFAULT_EXPORT_PADDING,
   FRAME_STYLE,
   FONT_FAMILY,
   SVG_NS,
   THEME,
   MIME_TYPES,
   EXPORT_DATA_TYPES,
+  COLOR_WHITE,
   arrayToMap,
   distance,
   getFontString,
@@ -47,20 +47,33 @@ import type {
   ExcalidrawTextElement,
   NonDeletedExcalidrawElement,
   NonDeletedSceneElementsMap,
+  Theme,
 } from "@excalidraw/element/types";
 
 import { getDefaultAppState } from "../appState";
 import { base64ToString, decode, encode, stringToBase64 } from "../data/encode";
 import { serializeAsJSON } from "../data/json";
+import { restoreAppState } from "../data/restore";
+import { encodePngMetadata } from "../data/image";
 
 import { Fonts } from "../fonts";
 
 import { renderStaticScene } from "../renderer/staticScene";
 import { renderSceneToSvg } from "../renderer/staticSvgScene";
 
+import {
+  copyBlobToClipboardAsPng,
+  copyTextToSystemClipboard,
+  copyToClipboard,
+} from "../clipboard";
+
 import type { RenderableElementsMap } from "./types";
 
-import type { AppState, BinaryFiles } from "../types";
+import type { AppState, BinaryFiles, NormalizedZoomValue } from "../types";
+
+// Default minimum export size in pixels
+const DEFAULT_SMALLEST_EXPORT_SIZE = 20;
+const DEFAULT_ZOOM_VALUE = 1 as NormalizedZoomValue;
 
 const truncateText = (element: ExcalidrawTextElement, maxWidth: number) => {
   if (element.width <= maxWidth) {
@@ -157,11 +170,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,
@@ -173,36 +182,205 @@ const prepareElementsForRender = ({
   return nextElements;
 };
 
-export const exportToCanvas = async (
+// ---------------------------------------------------------------------------
-  elements: readonly NonDeletedExcalidrawElement[],
+// Types for the new API
-  appState: AppState,
+// ---------------------------------------------------------------------------
-  files: BinaryFiles,
+
-  {
+export type ExportSceneData = {
-    exportBackground,
+  elements: readonly NonDeletedExcalidrawElement[];
-    exportPadding = DEFAULT_EXPORT_PADDING,
+  appState?: Partial<
-    viewBackgroundColor,
+    Omit<AppState, "offsetTop" | "offsetLeft" | "exportWithDarkMode">
-    exportingFrame,
+  >;
-  }: {
+  files: BinaryFiles | null;
-    exportBackground: boolean;
+};
-    exportPadding?: number;
+
-    viewBackgroundColor: string;
+export type ExportSceneConfig = {
-    exportingFrame?: ExcalidrawFrameLikeElement | null;
+  theme?: Theme;
-  },
+  /**
-  createCanvas: (
+   * Canvas background. Valid values are:
+   *
+   * - `undefined` - the background of "appState.viewBackgroundColor" is used.
+   * - `false` - no background is used (set to "transparent").
+   * - `string` - should be a valid CSS color.
+   *
+   * @default undefined
+   */
+  canvasBackgroundColor?: string | false;
+  /**
+   * Canvas padding in pixels. Affected by `scale`.
+   *
+   * When `fit` is set to `none`, padding is added to the content bounding box
+   * (including if you set `width` or `height` or `maxWidthOrHeight` or
+   * `widthOrHeight`).
+   *
+   * When `fit` set to `contain`, padding is subtracted from the content
+   * bounding box (ensuring the size doesn't exceed the supplied values, with
+   * the exeception of using alongside `scale` as noted above), and the padding
+   * serves as a minimum distance between the content and the canvas edges, as
+   * it may exceed the supplied padding value from one side or the other in
+   * order to maintain the aspect ratio. It is recommended to set `position`
+   * to `center` when using `fit=contain`.
+   *
+   * When `fit` is set to `none` and either `width` or `height` or
+   * `maxWidthOrHeight` is set, padding is simply adding to the bounding box
+   * and the content may overflow the canvas, thus right or bottom padding
+   * may be ignored.
+   *
+   * @default 0
+   */
+  padding?: number;
+  // -------------------------------------------------------------------------
+  /**
+   * Makes sure the canvas content fits into a frame of width/height no larger
+   * than this value, while maintaining the aspect ratio.
+   *
+   * Final dimensions can get smaller/larger if used in conjunction with
+   * `scale`.
+   */
+  maxWidthOrHeight?: number;
+  /**
+   * Scale the canvas content to be excatly this many pixels wide/tall,
+   * maintaining the aspect ratio.
+   *
+   * Cannot be used in conjunction with `maxWidthOrHeight`.
+   *
+   * Final dimensions can get smaller/larger if used in conjunction with
+   * `scale`.
+   */
+  widthOrHeight?: number;
+  // -------------------------------------------------------------------------
+  /**
+   * Width of the frame. Supply `x` or `y` if you want to ofsset the canvas
+   * content.
+   *
+   * If `width` omitted but `height` supplied, `width` is calculated from the
+   * the content's bounding box to preserve the aspect ratio.
+   *
+   * Defaults to the content bounding box width when both `width` and `height`
+   * are omitted.
+   */
+  width?: number;
+  /**
+   * Height of the frame.
+   *
+   * If `height` omitted but `width` supplied, `height` is calculated from the
+   * content's bounding box to preserve the aspect ratio.
+   *
+   * Defaults to the content bounding box height when both `width` and `height`
+   * are omitted.
+   */
+  height?: number;
+  /**
+   * Left canvas offset. By default the coordinate is relative to the canvas.
+   * You can switch to content coordinates by setting `origin` to `content`.
+   *
+   * Defaults to the `x` postion of the content bounding box.
+   */
+  x?: number;
+  /**
+   * Top canvas offset. By default the coordinate is relative to the canvas.
+   * You can switch to content coordinates by setting `origin` to `content`.
+   *
+   * Defaults to the `y` postion of the content bounding box.
+   */
+  y?: number;
+  /**
+   * Indicates the coordinate system of the `x` and `y` values.
+   *
+   * - `canvas` - `x` and `y` are relative to the canvas [0, 0] position.
+   * - `content` - `x` and `y` are relative to the content bounding box.
+   *
+   * @default "canvas"
+   */
+  origin?: "canvas" | "content";
+  /**
+   * If dimensions specified and `x` and `y` are not specified, this indicates
+   * how the canvas should be scaled.
+   *
+   * Behavior aligns with the `object-fit` CSS property.
+   *
+   * - `none`    - no scaling.
+   * - `contain` - scale to fit the frame. Includes `padding`.
+   *
+   * If `maxWidthOrHeight` or `widthOrHeight` is set, `fit` is ignored.
+   *
+   * @default "contain" unless `width`, `height`, `maxWidthOrHeight`, or
+   * `widthOrHeight` is specified in which case `none` is the default (can be
+   * changed). If `x` or `y` are specified, `none` is forced.
+   */
+  fit?: "none" | "contain";
+  /**
+   * When either `x` or `y` are not specified, indicates how the canvas should
+   * be aligned on the respective axis.
+   *
+   * - `none`   - canvas aligned to top left.
+   * - `center` - canvas is centered on the axis which is not specified
+   *              (or both).
+   *
+   * If `maxWidthOrHeight` or `widthOrHeight` is set, `position` is ignored.
+   *
+   * @default "center"
+   */
+  position?: "center" | "topLeft";
+  // -------------------------------------------------------------------------
+  /**
+   * A multiplier to increase/decrease the frame dimensions
+   * (content resolution).
+   *
+   * For example, if your canvas is 300x150 and you set scale to 2, the
+   * resulting size will be 600x300.
+   *
+   * @default 1
+   */
+  scale?: number;
+  /**
+   * If you need to suply your own canvas, e.g. in test environments or in
+   * Node.js.
+   *
+   * Do not set `canvas.width/height` or modify the canvas context as that's
+   * handled by Excalidraw.
+   *
+   * Defaults to `document.createElement("canvas")`.
+   */
+  createCanvas?: () => HTMLCanvasElement;
+  /**
+   * If you want to supply `width`/`height` dynamically (or derive from the
+   * content bounding box), you can use this function.
+   *
+   * Ignored if `maxWidthOrHeight`, `width`, or `height` is set.
+   */
+  getDimensions?: (
     width: number,
     height: number,
-  ) => { canvas: HTMLCanvasElement; scale: number } = (width, height) => {
+  ) => { width: number; height: number; scale?: number };
-    const canvas = document.createElement("canvas");
+
-    canvas.width = width * appState.exportScale;
+  exportingFrame?: ExcalidrawFrameLikeElement | null;
-    canvas.height = height * appState.exportScale;
+
-    return { canvas, scale: appState.exportScale };
+  loadFonts?: () => Promise<void>;
-  },
+};
-  loadFonts: () => Promise<void> = async () => {
+
-    await Fonts.loadElementsFonts(elements);
+// ---------------------------------------------------------------------------
-  },
+// Internal helper to configure export dimensions
-) => {
+// ---------------------------------------------------------------------------
-  // load font faces before continuing, by default leverages browsers' [FontFace API](https://developer.mozilla.org/en-US/docs/Web/API/FontFace)
+
-  await loadFonts();
+const configExportDimension = async ({
+  data,
+  config,
+}: {
+  data: ExportSceneData;
+  config?: ExportSceneConfig;
+}) => {
+  // clone
+  const cfg = Object.assign({}, config);
+
+  const { exportingFrame } = cfg;
+
+  const elements = data.elements;
+
+  // initialize defaults
+  // ---------------------------------------------------------------------------
+
+  const appState = restoreAppState(data.appState, null);
 
   const frameRendering = getFrameRenderingConfig(
     exportingFrame ?? null,
@@ -222,26 +400,255 @@ export const exportToCanvas = async (
   });
 
   if (exportingFrame) {
-    exportPadding = 0;
+    cfg.padding = 0;
   }
 
-  const [minX, minY, width, height] = getCanvasSize(
+  cfg.fit =
+    cfg.fit ??
+    (cfg.width != null ||
+    cfg.height != null ||
+    cfg.maxWidthOrHeight != null ||
+    cfg.widthOrHeight != null
+      ? "contain"
+      : "none");
+
+  cfg.padding = cfg.padding ?? 0;
+  cfg.scale = cfg.scale ?? 1;
+
+  cfg.origin = cfg.origin ?? "canvas";
+  cfg.position = cfg.position ?? "center";
+
+  if (cfg.maxWidthOrHeight != null && cfg.widthOrHeight != null) {
+    if (!import.meta.env.PROD) {
+      console.warn("`maxWidthOrHeight` is ignored when `widthOrHeight` is set");
+    }
+    cfg.maxWidthOrHeight = undefined;
+  }
+
+  if (
+    (cfg.maxWidthOrHeight != null || cfg.width != null || cfg.height != null) &&
+    cfg.getDimensions
+  ) {
+    if (!import.meta.env.PROD) {
+      console.warn(
+        "`getDimensions` is ignored when `width`, `height`, or `maxWidthOrHeight` is set",
+      );
+    }
+    cfg.getDimensions = undefined;
+  }
+  // ---------------------------------------------------------------------------
+
+  // load font faces before continuing, by default leverages browsers' [FontFace API](https://developer.mozilla.org/en-US/docs/Web/API/FontFace)
+  if (cfg.loadFonts) {
+    await cfg.loadFonts();
+  } else {
+    await Fonts.loadElementsFonts(elements);
+  }
+
+  // value used to scale the canvas context. By default, we use this to
+  // make the canvas fit into the frame (e.g. for `cfg.fit` set to `contain`).
+  // If `cfg.scale` is set, we multiply the resulting canvasScale by it to
+  // scale the output further.
+  let exportScale = 1;
+
+  const origCanvasSize = getCanvasSize(
     exportingFrame ? [exportingFrame] : getRootElements(elementsForRender),
-    exportPadding,
   );
 
-  const { canvas, scale = 1 } = createCanvas(width, height);
+  // variables for original content bounding box
+  const [origX, origY, origWidth, origHeight] = origCanvasSize;
+  // variables for target bounding box
+  let [x, y, width, height] = origCanvasSize;
 
-  const defaultAppState = getDefaultAppState();
+  x = cfg.x ?? x;
+  y = cfg.y ?? y;
+  width = cfg.width ?? width;
+  height = cfg.height ?? height;
+
+  if (cfg.fit === "contain" || cfg.widthOrHeight || cfg.maxWidthOrHeight) {
+    cfg.padding =
+      cfg.padding && cfg.padding > 0
+        ? Math.min(
+            cfg.padding,
+            (width - DEFAULT_SMALLEST_EXPORT_SIZE) / 2,
+            (height - DEFAULT_SMALLEST_EXPORT_SIZE) / 2,
+          )
+        : 0;
+
+    if (cfg.getDimensions != null) {
+      const ret = cfg.getDimensions(width, height);
+
+      width = ret.width;
+      height = ret.height;
+
+      cfg.padding = Math.min(
+        cfg.padding,
+        (width - DEFAULT_SMALLEST_EXPORT_SIZE) / 2,
+        (height - DEFAULT_SMALLEST_EXPORT_SIZE) / 2,
+      );
+    } else if (cfg.widthOrHeight != null) {
+      cfg.padding = Math.min(
+        cfg.padding,
+        (cfg.widthOrHeight - DEFAULT_SMALLEST_EXPORT_SIZE) / 2,
+      );
+    } else if (cfg.maxWidthOrHeight != null) {
+      cfg.padding = Math.min(
+        cfg.padding,
+        (cfg.maxWidthOrHeight - DEFAULT_SMALLEST_EXPORT_SIZE) / 2,
+      );
+    }
+  }
+
+  if (cfg.maxWidthOrHeight != null || cfg.widthOrHeight != null) {
+    if (cfg.padding) {
+      if (cfg.maxWidthOrHeight != null) {
+        cfg.maxWidthOrHeight -= cfg.padding * 2;
+      } else if (cfg.widthOrHeight != null) {
+        cfg.widthOrHeight -= cfg.padding * 2;
+      }
+    }
+
+    const max = Math.max(width, height);
+    if (cfg.widthOrHeight != null) {
+      // calculate by how much do we need to scale the canvas to fit into the
+      // target dimension (e.g. target: max 50px, actual: 70x100px => scale: 0.5)
+      exportScale = cfg.widthOrHeight / max;
+    } else if (cfg.maxWidthOrHeight != null) {
+      exportScale = cfg.maxWidthOrHeight < max ? cfg.maxWidthOrHeight / max : 1;
+    }
+
+    width *= exportScale;
+    height *= exportScale;
+  } else if (cfg.getDimensions) {
+    const ret = cfg.getDimensions(width, height);
+
+    width = ret.width;
+    height = ret.height;
+    cfg.scale = ret.scale ?? cfg.scale;
+  } else if (cfg.fit === "contain") {
+    width -= cfg.padding * 2;
+    height -= cfg.padding * 2;
+
+    const wRatio = width / origWidth;
+    const hRatio = height / origHeight;
+    // scale the orig canvas to fit in the target region
+    exportScale = Math.min(wRatio, hRatio);
+  }
+
+  x = cfg.x ?? origX;
+  y = cfg.y ?? origY;
+
+  // if we switch to "content" coords, we need to offset cfg-supplied
+  // coords by the x/y of content bounding box
+  if (cfg.origin === "content") {
+    if (cfg.x != null) {
+      x += origX;
+    }
+    if (cfg.y != null) {
+      y += origY;
+    }
+  }
+
+  // Centering the content to the frame.
+  // We divide width/height by canvasScale so that we calculate in the original
+  // aspect ratio dimensions.
+  if (cfg.position === "center") {
+    x -=
+      width / exportScale / 2 -
+      (cfg.x == null ? origWidth : width + cfg.padding * 2) / 2;
+    y -=
+      height / exportScale / 2 -
+      (cfg.y == null ? origHeight : height + cfg.padding * 2) / 2;
+  }
+
+  // rescale padding based on current canvasScale factor so that the resulting
+  // padding is kept the same as supplied by user (with the exception of
+  // `cfg.scale` being set, which also scales the padding)
+  const normalizedPadding = cfg.padding / exportScale;
+
+  // scale the whole frame by cfg.scale (on top of whatever canvasScale we
+  // calculated above)
+  exportScale *= cfg.scale;
+
+  width *= cfg.scale;
+  height *= cfg.scale;
+
+  const exportWidth = width + cfg.padding * 2 * cfg.scale;
+  const exportHeight = height + cfg.padding * 2 * cfg.scale;
+
+  return {
+    config: cfg,
+    normalizedPadding,
+    contentWidth: width,
+    contentHeight: height,
+    exportWidth,
+    exportHeight,
+    exportScale,
+    x,
+    y,
+    elementsForRender,
+    appState,
+    frameRendering,
+  };
+};
+
+// ---------------------------------------------------------------------------
+// exportToCanvas
+// ---------------------------------------------------------------------------
+
+/**
+ * This API is usually used as a precursor to searializing to Blob or PNG,
+ * but can also be used to create a canvas for other purposes.
+ */
+export const exportToCanvas = async ({
+  data,
+  config,
+}: {
+  data: ExportSceneData;
+  config?: ExportSceneConfig;
+}) => {
+  const {
+    config: cfg,
+    normalizedPadding,
+    contentWidth: width,
+    contentHeight: height,
+    exportWidth,
+    exportHeight,
+    exportScale,
+    x,
+    y,
+    elementsForRender,
+    appState,
+    frameRendering,
+  } = await configExportDimension({ data, config });
+
+  const canvas = cfg.createCanvas
+    ? cfg.createCanvas()
+    : document.createElement("canvas");
+
+  canvas.width = exportWidth;
+  canvas.height = exportHeight;
 
   const { imageCache } = await updateImageCache({
     imageCache: new Map(),
     fileIds: getInitializedImageElements(elementsForRender).map(
       (element) => element.fileId,
     ),
-    files,
+    files: data.files || {},
   });
 
+  const theme =
+    cfg.theme ?? (appState.exportWithDarkMode ? THEME.DARK : THEME.LIGHT);
+
+  // Determine the background color for the canvas
+  const viewBackgroundColor =
+    cfg.canvasBackgroundColor === false
+      ? // "transparent" triggers clearRect in bootstrapCanvas
+        "transparent"
+      : cfg.canvasBackgroundColor ||
+        appState.viewBackgroundColor ||
+        COLOR_WHITE;
+
   renderStaticScene({
     canvas,
     rc: rough.canvas(canvas),
@@ -249,19 +656,23 @@ export const exportToCanvas = async (
       arrayToMap(elementsForRender),
     ),
     allElementsMap: toBrandedType<NonDeletedSceneElementsMap>(
-      arrayToMap(syncInvalidIndices(elements)),
+      arrayToMap(syncInvalidIndices(data.elements)),
     ),
     visibleElements: elementsForRender,
-    scale,
+    scale: exportScale,
     appState: {
       ...appState,
       frameRendering,
-      viewBackgroundColor: exportBackground ? viewBackgroundColor : null,
+      width,
-      scrollX: -minX + exportPadding,
+      height,
-      scrollY: -minY + exportPadding,
+      offsetLeft: 0,
-      zoom: defaultAppState.zoom,
+      offsetTop: 0,
+      scrollX: -x + normalizedPadding,
+      scrollY: -y + normalizedPadding,
+      zoom: { value: DEFAULT_ZOOM_VALUE },
       shouldCacheIgnoreZoom: false,
-      theme: appState.exportWithDarkMode ? THEME.DARK : THEME.LIGHT,
+      theme,
+      viewBackgroundColor,
     },
     renderConfig: {
       canvasBackgroundColor: viewBackgroundColor,
@@ -272,13 +683,44 @@ export const exportToCanvas = async (
       embedsValidationStatus: new Map(),
       elementsPendingErasure: new Set(),
       pendingFlowchartNodes: null,
-      theme: appState.exportWithDarkMode ? THEME.DARK : THEME.LIGHT,
+      theme,
     },
   });
 
   return canvas;
 };
 
+// ---------------------------------------------------------------------------
+// exportToSvg
+// ---------------------------------------------------------------------------
+
+type ExportToSvgConfig = Pick<
+  ExportSceneConfig,
+  | "canvasBackgroundColor"
+  | "padding"
+  | "theme"
+  | "exportingFrame"
+  | "scale"
+  | "width"
+  | "height"
+  | "x"
+  | "y"
+  | "origin"
+  | "fit"
+  | "position"
+  | "maxWidthOrHeight"
+  | "widthOrHeight"
+  | "getDimensions"
+  | "loadFonts"
+> & {
+  /**
+   * if true, all embeddables passed in will be rendered when possible.
+   */
+  renderEmbeddables?: boolean;
+  skipInliningFonts?: true;
+  reuseImages?: boolean;
+};
+
 const createHTMLComment = (text: string) => {
   // surrounding with spaces to maintain prettified consistency with previous
   // iterations
@@ -286,61 +728,34 @@ const createHTMLComment = (text: string) => {
   return document.createComment(` ${text} `);
 };
 
-export const exportToSvg = async (
+export const exportToSvg = async ({
-  elements: readonly NonDeletedExcalidrawElement[],
+  data,
-  appState: {
+  config,
-    exportBackground: boolean;
+}: {
-    exportPadding?: number;
+  data: ExportSceneData;
-    exportScale?: number;
+  config?: ExportToSvgConfig;
-    viewBackgroundColor: string;
+}) => {
-    exportWithDarkMode?: boolean;
+  const {
-    exportEmbedScene?: boolean;
+    config: cfg,
-    frameRendering?: AppState["frameRendering"];
+    normalizedPadding,
-  },
+    exportWidth,
-  files: BinaryFiles | null,
+    exportHeight,
-  opts?: {
+    exportScale,
-    /**
+    x,
-     * if true, all embeddables passed in will be rendered when possible.
+    y,
-     */
+    elementsForRender,
-    renderEmbeddables?: boolean;
+    appState,
-    exportingFrame?: ExcalidrawFrameLikeElement | null;
-    skipInliningFonts?: true;
-    reuseImages?: boolean;
-  },
-): Promise<SVGSVGElement> => {
-  const frameRendering = getFrameRenderingConfig(
-    opts?.exportingFrame ?? null,
-    appState.frameRendering ?? null,
-  );
-
-  let {
-    exportPadding = DEFAULT_EXPORT_PADDING,
-    exportWithDarkMode = false,
-    viewBackgroundColor,
-    exportScale = 1,
-    exportEmbedScene,
-  } = appState;
-
-  const { exportingFrame = null } = opts || {};
-
-  const elementsForRender = prepareElementsForRender({
-    elements,
-    exportingFrame,
-    exportWithDarkMode,
     frameRendering,
-  });
+  } = await configExportDimension({ data, config });
 
-  if (exportingFrame) {
+  const offsetX = -(x - normalizedPadding);
-    exportPadding = 0;
+  const offsetY = -(y - normalizedPadding);
-  }
 
-  const [minX, minY, width, height] = getCanvasSize(
+  const { elements } = data;
-    exportingFrame ? [exportingFrame] : getRootElements(elementsForRender),
-    exportPadding,
-  );
 
-  const offsetX = -minX + exportPadding;
+  const theme =
-  const offsetY = -minY + exportPadding;
+    cfg.theme ?? (appState.exportWithDarkMode ? THEME.DARK : THEME.LIGHT);
+  const exportWithDarkMode = theme === THEME.DARK;
 
   // ---------------------------------------------------------------------------
   // initialize SVG root element
@@ -350,9 +765,12 @@ export const exportToSvg = async (
 
   svgRoot.setAttribute("version", "1.1");
   svgRoot.setAttribute("xmlns", SVG_NS);
-  svgRoot.setAttribute("viewBox", `0 0 ${width} ${height}`);
+  svgRoot.setAttribute(
-  svgRoot.setAttribute("width", `${width * exportScale}`);
+    "viewBox",
-  svgRoot.setAttribute("height", `${height * exportScale}`);
+    `0 0 ${exportWidth / exportScale} ${exportHeight / exportScale}`,
+  );
+  svgRoot.setAttribute("width", `${exportWidth}`);
+  svgRoot.setAttribute("height", `${exportHeight}`);
 
   const defsElement = svgRoot.ownerDocument.createElementNS(SVG_NS, "defs");
 
@@ -371,7 +789,7 @@ export const exportToSvg = async (
 
   // we need to serialize the "original" elements before we put them through
   // the tempScene hack which duplicates and regenerates ids
-  if (exportEmbedScene) {
+  if (appState.exportEmbedScene) {
     try {
       encodeSvgBase64Payload({
         metadataElement,
@@ -379,7 +797,7 @@ export const exportToSvg = async (
         // elements which don't contain the temp frame labels.
         // But it also requires that the exportToSvg is being supplied with
         // only the elements that we're exporting, and no extra.
-        payload: serializeAsJSON(elements, appState, files || {}, "local"),
+        payload: serializeAsJSON(elements, appState, data.files || {}, "local"),
       });
     } catch (error: any) {
       console.error(error);
@@ -417,7 +835,7 @@ export const exportToSvg = async (
       rect.setAttribute("width", `${frame.width}`);
       rect.setAttribute("height", `${frame.height}`);
 
-      if (!exportingFrame) {
+      if (!cfg.exportingFrame) {
         rect.setAttribute("rx", `${FRAME_STYLE.radius}`);
         rect.setAttribute("ry", `${FRAME_STYLE.radius}`);
       }
@@ -432,9 +850,10 @@ export const exportToSvg = async (
   // inline font faces
   // ---------------------------------------------------------------------------
 
-  const fontFaces = !opts?.skipInliningFonts
+  const fontFaces =
-    ? await Fonts.generateFontFaceDeclarations(elements)
+    config?.skipInliningFonts !== true
-    : [];
+      ? await Fonts.generateFontFaceDeclarations(elements)
+      : [];
 
   const delimiter = "\n      "; // 6 spaces
 
@@ -451,17 +870,16 @@ export const exportToSvg = async (
   // ---------------------------------------------------------------------------
 
   // render background rect
-  if (appState.exportBackground && viewBackgroundColor) {
+  if (appState.exportBackground && appState.viewBackgroundColor) {
+    const bgColor = cfg.canvasBackgroundColor || appState.viewBackgroundColor;
     const rect = svgRoot.ownerDocument.createElementNS(SVG_NS, "rect");
     rect.setAttribute("x", "0");
     rect.setAttribute("y", "0");
-    rect.setAttribute("width", `${width}`);
+    rect.setAttribute("width", `${exportWidth / exportScale}`);
-    rect.setAttribute("height", `${height}`);
+    rect.setAttribute("height", `${exportHeight / exportScale}`);
     rect.setAttribute(
       "fill",
-      exportWithDarkMode
+      exportWithDarkMode ? applyDarkModeFilter(bgColor) : bgColor,
-        ? applyDarkModeFilter(viewBackgroundColor)
-        : viewBackgroundColor,
     );
     svgRoot.appendChild(rect);
   }
@@ -472,14 +890,14 @@ export const exportToSvg = async (
 
   const rsvg = rough.svg(svgRoot);
 
-  const renderEmbeddables = opts?.renderEmbeddables ?? false;
+  const renderEmbeddables = config?.renderEmbeddables ?? false;
 
   renderSceneToSvg(
     elementsForRender,
     toBrandedType<RenderableElementsMap>(arrayToMap(elementsForRender)),
     rsvg,
     svgRoot,
-    files || {},
+    data.files || {},
     {
       offsetX,
       offsetY,
@@ -487,7 +905,7 @@ export const exportToSvg = async (
       exportWithDarkMode,
       renderEmbeddables,
       frameRendering,
-      canvasBackgroundColor: viewBackgroundColor,
+      canvasBackgroundColor: appState.viewBackgroundColor,
       embedsValidationStatus: renderEmbeddables
         ? new Map(
             elementsForRender
@@ -495,8 +913,8 @@ export const exportToSvg = async (
               .map((element) => [element.id, true]),
           )
         : new Map(),
-      reuseImages: opts?.reuseImages ?? true,
+      reuseImages: config?.reuseImages ?? true,
-      theme: exportWithDarkMode ? THEME.DARK : THEME.LIGHT,
+      theme,
     },
   );
 
@@ -505,6 +923,10 @@ export const exportToSvg = async (
   return svgRoot;
 };
 
+// ---------------------------------------------------------------------------
+// SVG payload encoding/decoding
+// ---------------------------------------------------------------------------
+
 export const encodeSvgBase64Payload = ({
   payload,
   metadataElement,
@@ -560,26 +982,149 @@ export const decodeSvgBase64Payload = ({ svg }: { svg: string }) => {
   throw new Error("INVALID");
 };
 
+// ---------------------------------------------------------------------------
+// getCanvasSize
+// ---------------------------------------------------------------------------
+
 // calculate smallest area to fit the contents in
-const getCanvasSize = (
+export const getCanvasSize = (
   elements: readonly NonDeletedExcalidrawElement[],
-  exportPadding: number,
 ): Bounds => {
   const [minX, minY, maxX, maxY] = getCommonBounds(elements);
-  const width = distance(minX, maxX) + exportPadding * 2;
+  const width = distance(minX, maxX);
-  const height = distance(minY, maxY) + exportPadding * 2;
+  const height = distance(minY, maxY);
 
   return [minX, minY, width, height];
 };
 
+/**
+ * Gets the export dimensions for a set of elements.
+ *
+ * @param elements - Elements to calculate size for
+ * @param exportPadding - Padding to add around the elements
+ * @param scale - Scale factor
+ * @returns [width, height] tuple
+ */
 export const getExportSize = (
   elements: readonly NonDeletedExcalidrawElement[],
   exportPadding: number,
   scale: number,
 ): [number, number] => {
-  const [, , width, height] = getCanvasSize(elements, exportPadding).map(
+  const [, , width, height] = getCanvasSize(elements);
-    (dimension) => Math.trunc(dimension * scale),
-  );
 
-  return [width, height];
+  return [
+    Math.trunc((width + exportPadding * 2) * scale),
+    Math.trunc((height + exportPadding * 2) * scale),
+  ];
+};
+
+// ---------------------------------------------------------------------------
+// exportToBlob
+// ---------------------------------------------------------------------------
+
+export { MIME_TYPES };
+
+type ExportToBlobConfig = ExportSceneConfig & {
+  mimeType?: string;
+  quality?: number;
+};
+
+export const exportToBlob = async ({
+  data,
+  config,
+}: {
+  data: ExportSceneData;
+  config?: ExportToBlobConfig;
+}): Promise<Blob> => {
+  let { mimeType = MIME_TYPES.png, quality } = config || {};
+
+  if (mimeType === MIME_TYPES.png && typeof quality === "number") {
+    console.warn(`"quality" will be ignored for "${MIME_TYPES.png}" mimeType`);
+  }
+
+  // typo in MIME type (should be "jpeg")
+  if (mimeType === "image/jpg") {
+    mimeType = MIME_TYPES.jpg;
+  }
+
+  if (mimeType === MIME_TYPES.jpg && config?.canvasBackgroundColor !== false) {
+    if (config?.canvasBackgroundColor === undefined) {
+      console.warn(
+        `Defaulting "canvasBackgroundColor" for "${MIME_TYPES.jpg}" mimeType`,
+      );
+      config = {
+        ...config,
+        canvasBackgroundColor:
+          data.appState?.viewBackgroundColor || COLOR_WHITE,
+      };
+    }
+  }
+
+  const canvas = await exportToCanvas({ data, config });
+
+  quality = quality ? quality : /image\/jpe?g/.test(mimeType) ? 0.92 : 0.8;
+
+  return new Promise((resolve, reject) => {
+    canvas.toBlob(
+      async (blob) => {
+        if (!blob) {
+          return reject(new Error("couldn't export to blob"));
+        }
+        if (
+          blob &&
+          mimeType === MIME_TYPES.png &&
+          data.appState?.exportEmbedScene
+        ) {
+          blob = await encodePngMetadata({
+            blob,
+            metadata: serializeAsJSON(
+              // NOTE as long as we're using the Scene hack, we need to ensure
+              // we pass the original, uncloned elements when serializing
+              // so that we keep ids stable
+              data.elements,
+              data.appState,
+              data.files || {},
+              "local",
+            ),
+          });
+        }
+        resolve(blob);
+      },
+      mimeType,
+      quality,
+    );
+  });
+};
+
+// ---------------------------------------------------------------------------
+// exportToClipboard
+// ---------------------------------------------------------------------------
+
+export const exportToClipboard = async ({
+  type,
+  data,
+  config,
+}: {
+  data: ExportSceneData;
+} & (
+  | { type: "png"; config?: ExportToBlobConfig }
+  | { type: "svg"; config?: ExportToSvgConfig }
+  | { type: "json"; config?: never }
+)) => {
+  if (type === "svg") {
+    const svg = await exportToSvg({
+      data: {
+        ...data,
+        appState: restoreAppState(data.appState, null),
+      },
+      config,
+    });
+    await copyTextToSystemClipboard(svg.outerHTML);
+  } else if (type === "png") {
+    await copyBlobToClipboardAsPng(exportToBlob({ data, config }));
+  } else if (type === "json") {
+    await copyToClipboard(data.elements, data.files);
+  } else {
+    throw new Error("Invalid export type");
+  }
 };

packages/excalidraw/snapping.ts

@@ -1,8 +1,4 @@
 import {
-  isCloseTo,
-  line,
-  linesIntersectAt,
-  pointDistance,
   pointFrom,
   pointRotateRads,
   rangeInclusive,
@@ -17,7 +13,7 @@ import {
   getDraggedElementsBounds,
   getElementAbsoluteCoords,
 } from "@excalidraw/element";
-import { isBoundToContainer, isElbowArrow } from "@excalidraw/element";
+import { isBoundToContainer } from "@excalidraw/element";
 
 import { getMaximumGroups } from "@excalidraw/element";
 
@@ -33,18 +29,14 @@ import type { MaybeTransformHandleType } from "@excalidraw/element";
 import type {
   ElementsMap,
   ExcalidrawElement,
-  ExcalidrawLinearElement,
   NonDeletedExcalidrawElement,
-  NonDeleted,
 } from "@excalidraw/element/types";
 
 import type {
   AppClassProperties,
   AppState,
   KeyboardModifiersObject,
-} from "@excalidraw/excalidraw/types";
+} from "./types";
-
-import { LinearElementEditor } from "./linearElementEditor";
 
 const SNAP_DISTANCE = 8;
 
@@ -130,11 +122,6 @@ export type SnapLine = PointSnapLine | GapSnapLine | PointerSnapLine;
 export class SnapCache {
   private static referenceSnapPoints: GlobalPoint[] | null = null;
 
-  private static linearElementAxisSnapTargets: {
-    editingElementId: ExcalidrawElement["id"];
-    snapTargets: GlobalPoint[];
-  } | null = null;
-
   private static visibleGaps: {
     verticalGaps: Gap[];
     horizontalGaps: Gap[];
@@ -148,27 +135,6 @@ export class SnapCache {
     return SnapCache.referenceSnapPoints;
   };
 
-  public static setLinearElementAxisSnapTargets = (
-    editingElementId: ExcalidrawElement["id"],
-    snapTargets: GlobalPoint[] | null,
-  ) => {
-    SnapCache.linearElementAxisSnapTargets = snapTargets
-      ? {
-          editingElementId,
-          snapTargets,
-        }
-      : null;
-  };
-
-  public static getLinearElementAxisSnapTargets = (
-    editingElementId: ExcalidrawElement["id"],
-  ) => {
-    return SnapCache.linearElementAxisSnapTargets?.editingElementId ===
-      editingElementId
-      ? SnapCache.linearElementAxisSnapTargets.snapTargets
-      : null;
-  };
-
   public static setVisibleGaps = (
     gaps: {
       verticalGaps: Gap[];
@@ -184,7 +150,6 @@ export class SnapCache {
 
   public static destroy = () => {
     SnapCache.referenceSnapPoints = null;
-    SnapCache.linearElementAxisSnapTargets = null;
     SnapCache.visibleGaps = null;
   };
 }
@@ -270,19 +235,6 @@ export const getElementsCorners = (
     const halfHeight = (y2 - y1) / 2;
 
     if (
-      (element.type === "line" || element.type === "arrow") &&
-      !boundingBoxCorners
-    ) {
-      // For linear elements, use actual points instead of bounding box
-      const linearPoints = LinearElementEditor.getPointsGlobalCoordinates(
-        element as NonDeleted<ExcalidrawLinearElement>,
-        elementsMap,
-        {
-          dragOffset,
-        },
-      );
-      result = linearPoints;
-    } else if (
       (element.type === "diamond" || element.type === "ellipse") &&
       !boundingBoxCorners
     ) {
@@ -681,227 +633,6 @@ export const getReferenceSnapPoints = (
     .flatMap((elementGroup) => getElementsCorners(elementGroup, elementsMap));
 };
 
-const getExternalAxisSnapTargets = (
-  elements: readonly NonDeletedExcalidrawElement[],
-  editingElement: ExcalidrawLinearElement,
-  appState: AppState,
-  elementsMap: ElementsMap,
-) => {
-  const cachedAxisSnapTargets = SnapCache.getLinearElementAxisSnapTargets(
-    editingElement.id,
-  );
-
-  const externalAxisSnapTargets =
-    cachedAxisSnapTargets ??
-    getReferenceSnapPoints(elements, [editingElement], appState, elementsMap);
-
-  if (!cachedAxisSnapTargets) {
-    SnapCache.setLinearElementAxisSnapTargets(
-      editingElement.id,
-      externalAxisSnapTargets,
-    );
-  }
-
-  return externalAxisSnapTargets;
-};
-
-const getOwnAxisSnapTargets = (
-  editingElement: ExcalidrawLinearElement,
-  elementsMap: ElementsMap,
-  selectedPointsIndices?: readonly number[],
-) => {
-  return LinearElementEditor.getPointsGlobalCoordinates(
-    editingElement as NonDeleted<ExcalidrawLinearElement>,
-    elementsMap,
-    {
-      excludePointsIndices: selectedPointsIndices,
-    },
-  );
-};
-
-export const getAxisSnapTargets = (
-  elements: readonly NonDeletedExcalidrawElement[],
-  editingElement: ExcalidrawLinearElement,
-  appState: AppState,
-  elementsMap: ElementsMap,
-  options: {
-    includeSelfPoints?: boolean;
-    selectedPointsIndices?: readonly number[];
-  } = {},
-) => {
-  const externalAxisSnapTargets = getExternalAxisSnapTargets(
-    elements,
-    editingElement,
-    appState,
-    elementsMap,
-  );
-
-  if (!options.includeSelfPoints) {
-    return externalAxisSnapTargets;
-  }
-
-  return externalAxisSnapTargets.concat(
-    getOwnAxisSnapTargets(
-      editingElement,
-      elementsMap,
-      options.selectedPointsIndices,
-    ),
-  );
-};
-
-const collectNearestAxisSnapCandidates = (
-  axisSnapTargets: readonly GlobalPoint[],
-  pointerPosition: GlobalPoint,
-  nearestSnapsX: Snaps,
-  nearestSnapsY: Snaps,
-  minOffset: Vector2D,
-) => {
-  for (const snapTarget of axisSnapTargets) {
-    const offsetX = snapTarget[0] - pointerPosition[0];
-    const offsetY = snapTarget[1] - pointerPosition[1];
-    const absOffsetX = Math.abs(offsetX);
-    const absOffsetY = Math.abs(offsetY);
-
-    if (absOffsetX > minOffset.x && absOffsetY > minOffset.y) {
-      continue;
-    }
-
-    if (absOffsetX <= minOffset.x) {
-      if (absOffsetX < minOffset.x) {
-        nearestSnapsX.length = 0;
-      }
-
-      nearestSnapsX.push({
-        type: "point",
-        points: [pointerPosition, snapTarget],
-        offset: offsetX,
-      });
-
-      minOffset.x = absOffsetX;
-    }
-
-    if (absOffsetY <= minOffset.y) {
-      if (absOffsetY < minOffset.y) {
-        nearestSnapsY.length = 0;
-      }
-
-      nearestSnapsY.push({
-        type: "point",
-        points: [pointerPosition, snapTarget],
-        offset: offsetY,
-      });
-
-      minOffset.y = absOffsetY;
-    }
-  }
-};
-
-export const snapLinearElementPoint = (
-  elements: readonly NonDeletedExcalidrawElement[],
-  editingElement: ExcalidrawLinearElement,
-  pointerPosition: GlobalPoint,
-  app: AppClassProperties,
-  event: KeyboardModifiersObject,
-  elementsMap: ElementsMap,
-  options: {
-    includeExternalPoints?: boolean;
-    includeSelfPoints?: boolean;
-    selectedPointsIndices?: readonly number[];
-  } = {},
-) => {
-  if (
-    !isSnappingEnabled({ app, event, selectedElements: [editingElement] }) ||
-    isElbowArrow(editingElement)
-  ) {
-    return {
-      snapOffset: { x: 0, y: 0 },
-      snapLines: [],
-    };
-  }
-
-  const snapDistance = getSnapDistance(app.state.zoom.value);
-  const minOffset = {
-    x: snapDistance,
-    y: snapDistance,
-  };
-
-  const nearestSnapsX: Snaps = [];
-  const nearestSnapsY: Snaps = [];
-
-  if (options.includeExternalPoints !== false) {
-    collectNearestAxisSnapCandidates(
-      getExternalAxisSnapTargets(
-        elements,
-        editingElement,
-        app.state,
-        elementsMap,
-      ),
-      pointerPosition,
-      nearestSnapsX,
-      nearestSnapsY,
-      minOffset,
-    );
-  }
-
-  if (options.includeSelfPoints) {
-    collectNearestAxisSnapCandidates(
-      getOwnAxisSnapTargets(
-        editingElement,
-        elementsMap,
-        options.selectedPointsIndices,
-      ),
-      pointerPosition,
-      nearestSnapsX,
-      nearestSnapsY,
-      minOffset,
-    );
-  }
-
-  const snapOffset = {
-    x: nearestSnapsX[0]?.offset ?? 0,
-    y: nearestSnapsY[0]?.offset ?? 0,
-  };
-
-  // Create snap lines using the snapped position (fixed position)
-  let pointSnapLines: SnapLine[] = [];
-
-  if (snapOffset.x !== 0 || snapOffset.y !== 0) {
-    const snappedPosition = pointFrom<GlobalPoint>(
-      pointerPosition[0] + snapOffset.x,
-      pointerPosition[1] + snapOffset.y,
-    );
-
-    const snappedSnapsX = nearestSnapsX
-      .filter(
-        (snap): snap is PointSnap =>
-          snap.type === "point" && isCloseTo(snap.offset, snapOffset.x, 0.01),
-      )
-      .map((snap) => ({
-        type: "point" as const,
-        points: [snappedPosition, snap.points[1]] as [GlobalPoint, GlobalPoint],
-        offset: 0,
-      }));
-
-    const snappedSnapsY = nearestSnapsY
-      .filter(
-        (snap): snap is PointSnap =>
-          snap.type === "point" && isCloseTo(snap.offset, snapOffset.y, 0.01),
-      )
-      .map((snap) => ({
-        type: "point" as const,
-        points: [snappedPosition, snap.points[1]] as [GlobalPoint, GlobalPoint],
-        offset: 0,
-      }));
-
-    pointSnapLines = createPointSnapLines(snappedSnapsX, snappedSnapsY);
-  }
-
-  return {
-    snapOffset,
-    snapLines: pointSnapLines,
-  };
-};
-
 const getPointSnaps = (
   selectedElements: ExcalidrawElement[],
   selectionSnapPoints: GlobalPoint[],
@@ -1681,79 +1412,3 @@ export const isActiveToolNonLinearSnappable = (
     activeToolType === TOOL_TYPE.text
   );
 };
-
-/**
- * Snaps to discrete angle rotation logic.
- * This function handles the common pattern of finding intersections between
- * angle lines and snap lines, and updating the snap lines accordingly.
- *
- * @param snapLines - The original snap lines from snapping
- * @param angleLine - The line representing the discrete angle constraint
- * @param gridPosition - The grid position (original pointer position)
- * @param referencePosition - The reference position (usually the start point)
- * @returns Object containing updated snap lines and position deltas
- */
-export const snapToDiscreteAngle = (
-  snapLines: SnapLine[],
-  angleLine: [GlobalPoint, GlobalPoint],
-  gridPosition: GlobalPoint,
-  referencePosition: GlobalPoint,
-): {
-  snapLines: SnapLine[];
-  dxFromReference: number;
-  dyFromReference: number;
-} => {
-  if (snapLines.length === 0) {
-    return {
-      snapLines: [],
-      dxFromReference: gridPosition[0] - referencePosition[0],
-      dyFromReference: gridPosition[1] - referencePosition[1],
-    };
-  }
-
-  const firstSnapLine = snapLines[0];
-  if (firstSnapLine.type === "points" && firstSnapLine.points.length > 1) {
-    const snapLine = line(firstSnapLine.points[0], firstSnapLine.points[1]);
-    const intersection = linesIntersectAt<GlobalPoint>(
-      line(angleLine[0], angleLine[1]),
-      snapLine,
-    );
-
-    if (intersection) {
-      const dxFromReference = intersection[0] - referencePosition[0];
-      const dyFromReference = intersection[1] - referencePosition[1];
-
-      const furthestPoint = firstSnapLine.points.reduce(
-        (furthest, point) => {
-          const distance = pointDistance(intersection, point);
-          if (distance > furthest.distance) {
-            return { point, distance };
-          }
-          return furthest;
-        },
-        {
-          point: firstSnapLine.points[0],
-          distance: pointDistance(intersection, firstSnapLine.points[0]),
-        },
-      );
-
-      const updatedSnapLine: PointSnapLine = {
-        type: "points",
-        points: [furthestPoint.point, intersection],
-      };
-
-      return {
-        snapLines: [updatedSnapLine],
-        dxFromReference,
-        dyFromReference,
-      };
-    }
-  }
-
-  // If no intersection found, return original snap lines with grid position
-  return {
-    snapLines,
-    dxFromReference: gridPosition[0] - referencePosition[0],
-    dyFromReference: gridPosition[1] - referencePosition[1],
-  };
-};

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,
@@ -8665,14 +8636,7 @@ exports[`regression tests > key 5 selects arrow tool > [end of test] appState 1`
   "openMenu": null,
   "openPopup": null,
   "openSidebar": null,
-  "originSnapOffset": {
+  "originSnapOffset": null,
-    "x": 0,
-    "y": 0,
-  },
-  "pasteDialog": {
-    "data": null,
-    "shown": false,
-  },
   "penDetected": false,
   "penMode": false,
   "preferredSelectionTool": {
@@ -8843,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,
@@ -9074,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,
@@ -9267,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,
@@ -9329,14 +9290,7 @@ exports[`regression tests > key a selects arrow tool > [end of test] appState 1`
   "openMenu": null,
   "openPopup": null,
   "openSidebar": null,
-  "originSnapOffset": {
+  "originSnapOffset": null,
-    "x": 0,
-    "y": 0,
-  },
-  "pasteDialog": {
-    "data": null,
-    "shown": false,
-  },
   "penDetected": false,
   "penMode": false,
   "preferredSelectionTool": {
@@ -9507,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,
@@ -9688,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,
@@ -9919,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,
@@ -10100,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,
@@ -10293,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,
@@ -10474,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,
@@ -11006,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,
@@ -11287,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,
@@ -11411,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,
@@ -11612,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,
@@ -11932,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,
@@ -12362,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,
@@ -13003,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,
@@ -13130,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,
@@ -13762,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,
@@ -14102,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,
@@ -14367,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,
@@ -14491,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,
@@ -14856,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,
@@ -14980,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/export.test.tsx

@@ -83,11 +83,13 @@ describe("export", () => {
   });
 
   it("export svg-embedded scene", async () => {
-    const svg = await exportToSvg(
+    const svg = await exportToSvg({
-      testElements,
+      data: {
-      { ...getDefaultAppState(), exportEmbedScene: true },
+        elements: testElements,
-      {},
+        appState: { ...getDefaultAppState(), exportEmbedScene: true },
-    );
+        files: {},
+      },
+    });
     const svgText = svg.outerHTML;
 
     expect(svgText).toMatchSnapshot(`svg-embdedded scene export output`);
@@ -205,7 +207,13 @@ describe("export", () => {
       },
     } as const;
 
-    const svg = await exportToSvg(elements, appState, files);
+    const svg = await exportToSvg({
+      data: {
+        elements,
+        appState,
+        files,
+      },
+    });
 
     const svgText = svg.outerHTML;
 

packages/excalidraw/tests/helpers/ui.ts

@@ -4,7 +4,6 @@ import {
   elementCenterPoint,
   getCommonBounds,
   getElementPointsCoords,
-  getLineHeightInPx,
 } from "@excalidraw/element";
 import { cropElement } from "@excalidraw/element";
 import {
@@ -21,7 +20,7 @@ import {
   isTextElement,
   isFrameLikeElement,
 } from "@excalidraw/element";
-import { KEYS, arrayToMap, getLineHeight } from "@excalidraw/common";
+import { KEYS, arrayToMap } from "@excalidraw/common";
 
 import type { GlobalPoint, LocalPoint, Radians } from "@excalidraw/math";
 
@@ -517,17 +516,8 @@ export class UI {
     UI.clickTool(type);
 
     if (type === "text") {
-      const clickY = h.state.gridModeEnabled
-        ? y
-        : y +
-          getLineHeightInPx(
-            h.state.currentItemFontSize,
-            getLineHeight(h.state.currentItemFontFamily),
-          ) /
-            2;
-
       mouse.reset();
-      mouse.click(x, clickY);
+      mouse.click(x, y);
     } else if ((type === "line" || type === "arrow") && points.length > 2) {
       points.forEach((point) => {
         mouse.reset();

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/scene/export.test.ts

@@ -1,9 +1,10 @@
-import { exportToCanvas, exportToSvg } from "@excalidraw/utils";
+import { exportToCanvas, exportToSvg } from "../../scene/export";
 
 import {
   applyDarkModeFilter,
   FONT_FAMILY,
   FRAME_STYLE,
+  THEME,
 } from "@excalidraw/common";
 
 import type {
@@ -53,39 +54,42 @@ describe("exportToSvg", () => {
     },
   ] as NonDeletedExcalidrawElement[];
 
-  const DEFAULT_OPTIONS = {
+  const DEFAULT_APP_STATE = {
     exportBackground: false,
     viewBackgroundColor: "#ffffff",
-    files: {},
   };
 
   it("with default arguments", async () => {
-    const svgElement = await exportUtils.exportToSvg(
+    const svgElement = await exportUtils.exportToSvg({
-      ELEMENTS,
+      data: {
-      DEFAULT_OPTIONS,
+        elements: ELEMENTS,
-      null,
+        appState: DEFAULT_APP_STATE,
-    );
+        files: {},
+      },
+    });
 
     expect(svgElement).toMatchSnapshot();
   });
 
   it("with a CJK font", async () => {
-    const svgElement = await exportUtils.exportToSvg(
+    const svgElement = await exportUtils.exportToSvg({
-      [
+      data: {
-        ...ELEMENTS,
+        elements: [
-        {
+          ...ELEMENTS,
-          ...textFixture,
+          {
-          height: ELEMENT_HEIGHT,
+            ...textFixture,
-          width: ELEMENT_WIDTH,
+            height: ELEMENT_HEIGHT,
-          text: "中国你好！这是一个测试。中国你好！日本こんにちは！これはテストです。한국 안녕하세요! 이것은 테스트입니다.",
+            width: ELEMENT_WIDTH,
-          originalText:
+            text: "中国你好！这是一个测试。中国你好！日本こんにちは！これはテストです。한국 안녕하세요! 이것은 테스트입니다.",
-            "中国你好！这是一个测试。中国你好！日本こんにちは！これはテストです。한국 안녕하세요! 이것은 테스트입니다.",
+            originalText:
-          index: "a4" as FractionalIndex,
+              "中国你好！这是一个测试。中国你好！日本こんにちは！これはテストです。한국 안녕하세요! 이것은 테스트입니다.",
-        } as ExcalidrawTextElement,
+            index: "a4" as FractionalIndex,
-      ],
+          } as ExcalidrawTextElement,
-      DEFAULT_OPTIONS,
+        ],
-      null,
+        appState: DEFAULT_APP_STATE,
-    );
+        files: {},
+      },
+    });
 
     expect(svgElement).toMatchSnapshot();
     // extend the timeout, as it needs to first load the fonts from disk and then perform whole woff2 decode, subset and encode (without workers)
@@ -94,15 +98,17 @@ describe("exportToSvg", () => {
   it("with background color", async () => {
     const BACKGROUND_COLOR = "#abcdef";
 
-    const svgElement = await exportUtils.exportToSvg(
+    const svgElement = await exportUtils.exportToSvg({
-      ELEMENTS,
+      data: {
-      {
+        elements: ELEMENTS,
-        ...DEFAULT_OPTIONS,
+        appState: {
-        exportBackground: true,
+          ...DEFAULT_APP_STATE,
-        viewBackgroundColor: BACKGROUND_COLOR,
+          exportBackground: true,
+          viewBackgroundColor: BACKGROUND_COLOR,
+        },
+        files: {},
       },
-      null,
+    });
-    );
 
     expect(svgElement.querySelector("rect")).toHaveAttribute(
       "fill",
@@ -111,14 +117,18 @@ describe("exportToSvg", () => {
   });
 
   it("with dark mode", async () => {
-    const svgElement = await exportUtils.exportToSvg(
+    const svgElement = await exportUtils.exportToSvg({
-      ELEMENTS,
+      data: {
-      {
+        elements: ELEMENTS,
-        ...DEFAULT_OPTIONS,
+        appState: {
-        exportWithDarkMode: true,
+          ...DEFAULT_APP_STATE,
+        },
+        files: {},
       },
-      null,
+      config: {
-    );
+        theme: THEME.DARK,
+      },
+    });
 
     const textElements = svgElement.querySelectorAll("text");
     expect(textElements.length).toBeGreaterThan(0);
@@ -132,14 +142,16 @@ describe("exportToSvg", () => {
   });
 
   it("with exportPadding", async () => {
-    const svgElement = await exportUtils.exportToSvg(
+    const svgElement = await exportUtils.exportToSvg({
-      ELEMENTS,
+      data: {
-      {
+        elements: ELEMENTS,
-        ...DEFAULT_OPTIONS,
+        appState: DEFAULT_APP_STATE,
-        exportPadding: 0,
+        files: {},
       },
-      null,
+      config: {
-    );
+        padding: 0,
+      },
+    });
 
     expect(svgElement).toHaveAttribute("height", ELEMENT_HEIGHT.toString());
     expect(svgElement).toHaveAttribute("width", ELEMENT_WIDTH.toString());
@@ -152,15 +164,17 @@ describe("exportToSvg", () => {
   it("with scale", async () => {
     const SCALE = 2;
 
-    const svgElement = await exportUtils.exportToSvg(
+    const svgElement = await exportUtils.exportToSvg({
-      ELEMENTS,
+      data: {
-      {
+        elements: ELEMENTS,
-        ...DEFAULT_OPTIONS,
+        appState: DEFAULT_APP_STATE,
-        exportPadding: 0,
+        files: {},
-        exportScale: SCALE,
       },
-      null,
+      config: {
-    );
+        padding: 0,
+        scale: SCALE,
+      },
+    });
 
     expect(svgElement).toHaveAttribute(
       "height",
@@ -173,23 +187,27 @@ describe("exportToSvg", () => {
   });
 
   it("with exportEmbedScene", async () => {
-    const svgElement = await exportUtils.exportToSvg(
+    const svgElement = await exportUtils.exportToSvg({
-      ELEMENTS,
+      data: {
-      {
+        elements: ELEMENTS,
-        ...DEFAULT_OPTIONS,
+        appState: {
-        exportEmbedScene: true,
+          ...DEFAULT_APP_STATE,
+          exportEmbedScene: true,
+        },
+        files: {},
       },
-      null,
+    });
-    );
     expect(svgElement.innerHTML).toMatchSnapshot();
   });
 
   it("with elements that have a link", async () => {
-    const svgElement = await exportUtils.exportToSvg(
+    const svgElement = await exportUtils.exportToSvg({
-      [rectangleWithLinkFixture],
+      data: {
-      DEFAULT_OPTIONS,
+        elements: [rectangleWithLinkFixture],
-      null,
+        appState: DEFAULT_APP_STATE,
-    );
+        files: {},
+      },
+    });
     expect(svgElement.innerHTML).toMatchSnapshot();
   });
 });
@@ -229,9 +247,14 @@ describe("exporting frames", () => {
       ];
 
       const canvas = await exportToCanvas({
-        elements,
+        data: {
-        files: null,
+          elements,
-        exportPadding: 0,
+          appState: {},
+          files: null,
+        },
+        config: {
+          padding: 0,
+        },
       });
 
       expect(canvas.width).toEqual(200);
@@ -258,10 +281,15 @@ describe("exporting frames", () => {
       ];
 
       const canvas = await exportToCanvas({
-        elements,
+        data: {
-        files: null,
+          elements,
-        exportPadding: 0,
+          appState: {},
-        exportingFrame: frame,
+          files: null,
+        },
+        config: {
+          padding: 0,
+          exportingFrame: frame,
+        },
       });
 
       expect(canvas.width).toEqual(frame.width);
@@ -297,10 +325,15 @@ describe("exporting frames", () => {
       });
 
       const svg = await exportToSvg({
-        elements: [rectOverlapping, frame, frameChild],
+        data: {
-        files: null,
+          elements: [rectOverlapping, frame, frameChild],
-        exportPadding: 0,
+          appState: {},
-        exportingFrame: frame,
+          files: null,
+        },
+        config: {
+          padding: 0,
+          exportingFrame: frame,
+        },
       });
 
       // frame itself isn't exported
@@ -341,10 +374,15 @@ describe("exporting frames", () => {
       });
 
       const svg = await exportToSvg({
-        elements: [frameChild, frame, elementOutside],
+        data: {
-        files: null,
+          elements: [frameChild, frame, elementOutside],
-        exportPadding: 0,
+          appState: {},
-        exportingFrame: frame,
+          files: null,
+        },
+        config: {
+          padding: 0,
+          exportingFrame: frame,
+        },
       });
 
       // frame itself isn't exported
@@ -409,10 +447,15 @@ describe("exporting frames", () => {
       );
 
       const svg = await exportToSvg({
-        elements: exportedElements,
+        data: {
-        files: null,
+          elements: exportedElements,
-        exportPadding: 0,
+          appState: {},
-        exportingFrame,
+          files: null,
+        },
+        config: {
+          padding: 0,
+          exportingFrame,
+        },
       });
 
       // frames themselves should be exported when multiple frames selected
@@ -454,10 +497,15 @@ describe("exporting frames", () => {
       );
 
       const svg = await exportToSvg({
-        elements: exportedElements,
+        data: {
-        files: null,
+          elements: exportedElements,
-        exportPadding: 0,
+          appState: {},
-        exportingFrame,
+          files: null,
+        },
+        config: {
+          padding: 0,
+          exportingFrame,
+        },
       });
 
       // frame itself isn't exported
@@ -513,10 +561,15 @@ describe("exporting frames", () => {
       );
 
       const svg = await exportToSvg({
-        elements: exportedElements,
+        data: {
-        files: null,
+          elements: exportedElements,
-        exportPadding: 0,
+          appState: {},
-        exportingFrame,
+          files: null,
+        },
+        config: {
+          padding: 0,
+          exportingFrame,
+        },
       });
 
       // frame shouldn't be exported

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/textAutoResizeHandle.ts

@@ -1,88 +0,0 @@
-import { DEFAULT_TRANSFORM_HANDLE_SPACING } from "@excalidraw/common";
-import {
-  pointFrom,
-  pointRotateRads,
-  type GlobalPoint,
-  type Radians,
-} from "@excalidraw/math";
-
-import type { EditorInterface } from "@excalidraw/common";
-
-import type { ExcalidrawTextElement } from "@excalidraw/element/types";
-
-const TEXT_AUTO_RESIZE_HANDLE_GAP = 12;
-const TEXT_AUTO_RESIZE_HANDLE_LENGTH = 16;
-const TEXT_AUTO_RESIZE_HANDLE_HITBOX_WIDTH = 10;
-const TEXT_AUTO_RESIZE_HANDLE_HITBOX_HEIGHT =
-  TEXT_AUTO_RESIZE_HANDLE_LENGTH + 2;
-const MAX_HANDLE_HEIGHT_RATIO = 0.8;
-
-export const getTextBoxPadding = (zoomValue: number) =>
-  (DEFAULT_TRANSFORM_HANDLE_SPACING * 2) / zoomValue;
-
-export const getTextAutoResizeHandle = (
-  textElement: ExcalidrawTextElement,
-  zoomValue: number,
-  formFactor: EditorInterface["formFactor"],
-) => {
-  if (
-    formFactor !== "desktop" ||
-    TEXT_AUTO_RESIZE_HANDLE_LENGTH >
-      textElement.height * zoomValue * MAX_HANDLE_HEIGHT_RATIO
-  ) {
-    return null;
-  }
-
-  const padding = getTextBoxPadding(zoomValue);
-  const gap = TEXT_AUTO_RESIZE_HANDLE_GAP / zoomValue;
-  const length = TEXT_AUTO_RESIZE_HANDLE_LENGTH / zoomValue;
-  const center = pointFrom(
-    textElement.x + textElement.width / 2,
-    textElement.y + textElement.height / 2,
-  );
-  const handleCenter = pointRotateRads(
-    pointFrom(center[0] + textElement.width / 2 + padding + gap, center[1]),
-    center,
-    textElement.angle,
-  );
-
-  return {
-    center: handleCenter,
-    start: pointRotateRads(
-      pointFrom(handleCenter[0], handleCenter[1] - length / 2),
-      handleCenter,
-      textElement.angle,
-    ) as GlobalPoint,
-    end: pointRotateRads(
-      pointFrom(handleCenter[0], handleCenter[1] + length / 2),
-      handleCenter,
-      textElement.angle,
-    ) as GlobalPoint,
-    hitboxWidth: TEXT_AUTO_RESIZE_HANDLE_HITBOX_WIDTH / zoomValue,
-    hitboxHeight: TEXT_AUTO_RESIZE_HANDLE_HITBOX_HEIGHT / zoomValue,
-  };
-};
-
-export const isPointHittingTextAutoResizeHandle = (
-  point: Readonly<{ x: number; y: number }>,
-  textElement: ExcalidrawTextElement,
-  zoomValue: number,
-  formFactor: EditorInterface["formFactor"],
-) => {
-  const handle = getTextAutoResizeHandle(textElement, zoomValue, formFactor);
-
-  if (!handle) {
-    return false;
-  }
-
-  const unrotatedPoint = pointRotateRads(
-    pointFrom(point.x, point.y),
-    handle.center,
-    -textElement.angle as Radians,
-  );
-
-  return (
-    Math.abs(unrotatedPoint[0] - handle.center[0]) <= handle.hitboxWidth / 2 &&
-    Math.abs(unrotatedPoint[1] - handle.center[1]) <= handle.hitboxHeight / 2
-  );
-};

packages/excalidraw/types.ts

@@ -10,8 +10,6 @@ import type { LinearElementEditor } from "@excalidraw/element";
 
 import type { MaybeTransformHandleType } from "@excalidraw/element";
 
-import type { SnapLine } from "@excalidraw/element";
-
 import type {
   PointerType,
   ExcalidrawLinearElement,
@@ -34,7 +32,6 @@ import type {
   OrderedExcalidrawElement,
   ExcalidrawNonSelectionElement,
   BindMode,
-  ExcalidrawTextElement,
 } from "@excalidraw/element/types";
 
 import type {
@@ -57,6 +54,7 @@ import type { ClipboardData } from "./clipboard";
 import type App from "./components/App";
 import type Library from "./data/library";
 import type { ContextMenuItems } from "./components/ContextMenu";
+import type { SnapLine } from "./snapping";
 import type { ImportedDataState } from "./data/types";
 
 import type { Language } from "./i18n";
@@ -270,8 +268,6 @@ export type ObservedElementsAppState = {
   activeLockedId: AppState["activeLockedId"];
 };
 
-export type BoxSelectionMode = "contain" | "overlap";
-
 export interface AppState {
   contextMenu: {
     items: ContextMenuItems;
@@ -310,8 +306,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 */
@@ -333,7 +327,7 @@ export interface AppState {
   /**
    * set when a new text is created or when an existing text is being edited
    */
-  editingTextElement: ExcalidrawTextElement | null;
+  editingTextElement: NonDeletedExcalidrawElement | null;
   activeTool: {
     /**
      * indicates a previous tool we should revert back to if we deselect the
@@ -882,8 +876,9 @@ export type PointerDownState = Readonly<{
     // by default same as PointerDownState.origin. On alt-duplication, reset
     // to current pointer position at time of duplication.
     origin: { x: number; y: number };
-    // explicit flag for specific scenarios such as:
+    // Whether to block drag after lasso selection
-    // - after lasso selection until the next pointer down
+    // this is meant to be used to block dragging after lasso selection on PCs
+    // until the next pointer down
     blockDragging: boolean;
   };
   // We need to have these in the state so that we can unsubscribe them

packages/excalidraw/wysiwyg/textWysiwyg.test.tsx

@@ -1,10 +1,7 @@
 import { queryByText } from "@testing-library/react";
 
 import { pointFrom } from "@excalidraw/math";
-import {
+import { getOriginalContainerHeightFromCache } from "@excalidraw/element";
-  getLineHeightInPx,
-  getOriginalContainerHeightFromCache,
-} from "@excalidraw/element";
 
 import {
   CODES,
@@ -45,28 +42,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;
@@ -235,42 +210,6 @@ describe("textWysiwyg", () => {
       expect(h.elements.length).toBe(1);
     });
 
-    it("should vertically center newly created text on the cursor when clicked with text tool", async () => {
-      API.setAppState({
-        currentItemFontFamily: FONT_FAMILY.Cascadia,
-        currentItemFontSize: 40,
-      });
-      UI.clickTool("text");
-
-      mouse.clickAt(120, 80);
-
-      const editor = await getTextEditor();
-      const text = h.elements[0] as ExcalidrawTextElement;
-      const lineHeightPx = getLineHeightInPx(text.fontSize, text.lineHeight);
-
-      expect(editor).not.toBe(null);
-      expect(text.y + lineHeightPx / 2).toBe(80);
-    });
-
-    it("should snap newly created text top-left to the current grid cell when clicked with text tool in grid mode", async () => {
-      API.setAppState({
-        currentItemFontFamily: FONT_FAMILY.Cascadia,
-        currentItemFontSize: 40,
-        gridModeEnabled: true,
-        gridSize: 24,
-      });
-      UI.clickTool("text");
-
-      mouse.clickAt(113, 86);
-
-      const editor = await getTextEditor();
-      const text = h.elements[0] as ExcalidrawTextElement;
-
-      expect(editor).not.toBe(null);
-      expect(text.x).toBe(96);
-      expect(text.y).toBe(72);
-    });
-
     it("should edit text under cursor when double-clicked with selection tool", async () => {
       const text = API.createElement({
         type: "text",
@@ -293,94 +232,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",
-        width: 160,
-        height: 70,
-        boundElements: [],
-      });
-      const text = API.createElement({
-        type: "text",
-        text: "Hello World!",
-        x: container.x + 20,
-        y: container.y + 20,
-        width: 120,
-        height: 25,
-        containerId: container.id,
-      });
-
-      API.setElements([container, text]);
-      API.updateElement(container, {
-        boundElements: [{ type: "text", id: text.id }],
-      });
-      API.setSelectedElements([container]);
-      UI.clickTool("selection");
-
-      mouse.clickAt(text.x + 26, text.y + 10);
-
-      const editor = await getTextEditor();
-
-      expect(editor).not.toBe(null);
-    });
-
-    it("should not edit selected bound text container when only the container was single-clicked", async () => {
-      const container = API.createElement({
-        type: "rectangle",
-        width: 160,
-        height: 70,
-        boundElements: [],
-      });
-      const text = API.createElement({
-        type: "text",
-        text: "Hello World!",
-        x: container.x + 20,
-        y: container.y + 20,
-        width: 120,
-        height: 25,
-        containerId: container.id,
-      });
-
-      API.setElements([container, text]);
-      API.updateElement(container, {
-        boundElements: [{ type: "text", id: text.id }],
-      });
-      API.setSelectedElements([container]);
-      UI.clickTool("selection");
-
-      mouse.clickAt(container.x + 5, container.y + 10);
-
-      expect(h.state.editingTextElement).toBe(null);
-      expect(await getTextEditor({ waitForEditor: false })).toBe(null);
-    });
-
     // FIXME too flaky. No one knows why.
     it.skip("should bump the version of a labeled arrow when the label is updated", async () => {
       const arrow = UI.createElement("arrow", {
@@ -1354,40 +1205,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",
@@ -1694,7 +1511,7 @@ describe("textWysiwyg", () => {
           version: 2,
           width: 610,
           x: 15,
-          y: 12.5,
+          y: 25,
         }),
       );
       expect(h.elements[2] as ExcalidrawTextElement).toEqual(

packages/excalidraw/wysiwyg/textWysiwyg.tsx

@@ -10,9 +10,7 @@ import {
   isTestEnv,
   MIME_TYPES,
   applyDarkModeFilter,
-  isRTL,
 } from "@excalidraw/common";
-import { pointFrom, pointRotateRads, type Radians } from "@excalidraw/math";
 
 import {
   getTextFromElements,
@@ -35,11 +33,8 @@ import {
   getBoundTextElement,
 } from "@excalidraw/element";
 import { getTextWidth } from "@excalidraw/element";
-import { getLineHeightInPx } from "@excalidraw/element";
-import { getLineWidth } from "@excalidraw/element";
 import { normalizeText } from "@excalidraw/element";
 import { wrapText } from "@excalidraw/element";
-import { getWrappedTextLines } from "@excalidraw/element";
 import {
   isArrowElement,
   isBoundToContainer,
@@ -96,103 +91,6 @@ const getTransform = (
   return `translate(${translateX}px, ${translateY}px) scale(${zoom.value}) rotate(${degree}deg)`;
 };
 
-const getLineDirection = (text: string, offset: number) => {
-  const hardLineStart = text.lastIndexOf("\n", Math.max(0, offset - 1)) + 1;
-  const hardLineEnd = text.indexOf("\n", offset);
-  const hardLineText = text.slice(
-    hardLineStart,
-    hardLineEnd === -1 ? text.length : hardLineEnd,
-  );
-
-  return isRTL(hardLineText) ? "rtl" : "ltr";
-};
-
-const getCaretBoundaryOffsets = (text: string) => {
-  const offsets = [0];
-  let offset = 0;
-
-  for (const char of Array.from(text)) {
-    offset += char.length;
-    offsets.push(offset);
-  }
-
-  return offsets;
-};
-
-const getLineCaretOffsetFromNativeLayout = ({
-  text,
-  font,
-  lineHeightPx,
-  direction,
-  targetX,
-}: {
-  text: string;
-  font: ReturnType<typeof getFontString>;
-  lineHeightPx: number;
-  direction: "ltr" | "rtl";
-  targetX: number;
-}) => {
-  if (!text || !document.body || typeof document.createRange !== "function") {
-    return null;
-  }
-
-  const offsets = getCaretBoundaryOffsets(text);
-  const mirror = document.createElement("div");
-  const textNode = document.createTextNode(text);
-  const range = document.createRange();
-  const positions: number[] = [];
-
-  mirror.dir = direction;
-  Object.assign(mirror.style, {
-    position: "fixed",
-    top: "0",
-    left: "0",
-    margin: 0,
-    padding: 0,
-    border: 0,
-    opacity: "0",
-    pointerEvents: "none",
-    whiteSpace: "pre",
-    font,
-    lineHeight: `${lineHeightPx}px`,
-  });
-  mirror.append(textNode);
-  document.body.append(mirror);
-
-  try {
-    for (const offset of offsets) {
-      range.setStart(textNode, offset);
-      range.setEnd(textNode, offset);
-      const caretRect = range.getBoundingClientRect();
-
-      if (!Number.isFinite(caretRect.left)) {
-        return null;
-      }
-
-      positions.push(caretRect.left);
-    }
-  } catch {
-    return null;
-  } finally {
-    mirror.remove();
-  }
-
-  const leftEdge = Math.min(...positions);
-  let closestOffset = offsets[0];
-  let closestDistance = Infinity;
-
-  for (let index = 0; index < offsets.length; index++) {
-    const distance = Math.abs(positions[index] - leftEdge - targetX);
-
-    if (distance < closestDistance) {
-      closestDistance = distance;
-      closestOffset = offsets[index];
-    }
-  }
-
-  return closestOffset;
-};
-
 type SubmitHandler = () => void;
 
 export const textWysiwyg = ({
@@ -205,7 +103,6 @@ export const textWysiwyg = ({
   excalidrawContainer,
   app,
   autoSelect = true,
-  initialCaretSceneCoords = null,
 }: {
   id: ExcalidrawElement["id"];
   /**
@@ -222,19 +119,7 @@ export const textWysiwyg = ({
   excalidrawContainer: HTMLDivElement | null;
   app: App;
   autoSelect?: boolean;
-  initialCaretSceneCoords?: { x: number; y: number } | null;
 }): SubmitHandler => {
-  let currentTextLayout: {
-    angle: Radians;
-    font: ReturnType<typeof getFontString>;
-    height: number;
-    lineHeightPx: number;
-    textAlign: ExcalidrawTextElement["textAlign"];
-    width: number;
-    x: number;
-    y: number;
-  } | null = null;
-
   const textPropertiesUpdated = (
     updatedTextElement: ExcalidrawTextElement,
     editable: HTMLTextAreaElement,
@@ -369,7 +254,6 @@ export const textWysiwyg = ({
       height *= 1.05;
 
       const font = getFontString(updatedTextElement);
-      const angle = getTextElementAngle(updatedTextElement, container);
 
       // Make sure text editor height doesn't go beyond viewport
       const editorMaxHeight =
@@ -385,7 +269,7 @@ export const textWysiwyg = ({
         transform: getTransform(
           width,
           height,
-          angle,
+          getTextElementAngle(updatedTextElement, container),
           appState,
           maxWidth,
           editorMaxHeight,
@@ -399,19 +283,6 @@ export const textWysiwyg = ({
         opacity: updatedTextElement.opacity / 100,
         maxHeight: `${editorMaxHeight}px`,
       });
-      currentTextLayout = {
-        angle: angle as Radians,
-        font,
-        height: updatedTextElement.height,
-        lineHeightPx: getLineHeightInPx(
-          updatedTextElement.fontSize,
-          updatedTextElement.lineHeight,
-        ),
-        textAlign,
-        width: updatedTextElement.width,
-        x: coordX,
-        y: coordY,
-      };
       editable.scrollTop = 0;
       // For some reason updating font attribute doesn't set font family
       // hence updating font family explicitly for test environment
@@ -462,71 +333,6 @@ export const textWysiwyg = ({
   editable.value = element.originalText;
   updateWysiwygStyle();
 
-  const getCaretIndexFromInitialSceneCoords = () => {
-    if (!initialCaretSceneCoords || !currentTextLayout) {
-      return null;
-    }
-
-    const layout = currentTextLayout;
-    const center = pointFrom(
-      layout.x + layout.width / 2,
-      layout.y + layout.height / 2,
-    );
-    const [unrotatedX, unrotatedY] = pointRotateRads(
-      pointFrom(initialCaretSceneCoords.x, initialCaretSceneCoords.y),
-      center,
-      -layout.angle as Radians,
-    );
-    const localX = unrotatedX - layout.x;
-    const localY = unrotatedY - layout.y;
-    const lines = getWrappedTextLines(
-      editable.value,
-      layout.font,
-      whiteSpace === "pre-wrap" ? layout.width : Infinity,
-    );
-    const lineIndex = Math.max(
-      0,
-      Math.min(lines.length - 1, Math.floor(localY / layout.lineHeightPx)),
-    );
-    const line = lines[lineIndex];
-    const direction = getLineDirection(editable.value, line.start);
-    const lineWidth = getLineWidth(line.text, layout.font);
-    const lineStartX =
-      layout.textAlign === "center"
-        ? (layout.width - lineWidth) / 2
-        : layout.textAlign === "right"
-        ? layout.width - lineWidth
-        : 0;
-    const relativeX = localX - lineStartX;
-
-    if (!line.text) {
-      return line.start;
-    }
-
-    const lineCaretOffset = getLineCaretOffsetFromNativeLayout({
-      text: line.text,
-      font: layout.font,
-      lineHeightPx: layout.lineHeightPx,
-      direction,
-      targetX: relativeX,
-    });
-
-    return line.start + (lineCaretOffset || 0);
-  };
-
-  let pendingInitialSelection = (() => {
-    const caretIndex = getCaretIndexFromInitialSceneCoords();
-
-    if (caretIndex === null) {
-      return null;
-    }
-
-    return {
-      start: caretIndex,
-      end: caretIndex,
-    };
-  })();
-
   if (onChange) {
     editable.onpaste = async (event) => {
       // we need to synchronously get the MIME types so we can preventDefault()
@@ -890,13 +696,6 @@ export const textWysiwyg = ({
       // Otherwise, re-enable submit on blur and refocus the editor.
       editable.onblur = handleSubmit;
       editable.focus();
-      if (pendingInitialSelection) {
-        editable.setSelectionRange(
-          pendingInitialSelection.start,
-          pendingInitialSelection.end,
-        );
-        pendingInitialSelection = null;
-      }
     });
   };
 
@@ -987,7 +786,7 @@ export const textWysiwyg = ({
 
   let isDestroyed = false;
 
-  if (autoSelect && !pendingInitialSelection) {
+  if (autoSelect) {
     // select on init (focusing is done separately inside the bindBlurEvent()
     // because we need it to happen *after* the blur event from `pointerdown`)
     editable.select();

packages/math/src/constants.ts

@@ -1,3 +1,5 @@
+export const PRECISION = 10e-5;
+
 // Legendre-Gauss abscissae (x values) and weights for n=24
 // Refeerence: https://pomax.github.io/bezierinfo/legendre-gauss.html
 export const LegendreGaussN24TValues = [

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/point.ts

@@ -123,15 +123,10 @@ export function pointsEqual<Point extends GlobalPoint | LocalPoint>(
  * @returns The rotated point
  */
 export function pointRotateRads<Point extends GlobalPoint | LocalPoint>(
-  point: Point,
+  [x, y]: Point,
-  center: Point,
+  [cx, cy]: Point,
   angle: Radians,
 ): Point {
-  if (!angle) {
-    return point;
-  }
-  const [x, y] = point;
-  const [cx, cy] = center;
   return pointFrom(
     (x - cx) * Math.cos(angle) - (y - cy) * Math.sin(angle) + cx,
     (x - cx) * Math.sin(angle) + (y - cy) * Math.cos(angle) + cy,

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/export.ts

@@ -1,216 +0,0 @@
-import { MIME_TYPES } from "@excalidraw/common";
-import { getDefaultAppState } from "@excalidraw/excalidraw/appState";
-import {
-  copyBlobToClipboardAsPng,
-  copyTextToSystemClipboard,
-  copyToClipboard,
-} from "@excalidraw/excalidraw/clipboard";
-import { encodePngMetadata } from "@excalidraw/excalidraw/data/image";
-import { serializeAsJSON } from "@excalidraw/excalidraw/data/json";
-import {
-  restoreAppState,
-  restoreElements,
-} from "@excalidraw/excalidraw/data/restore";
-import {
-  exportToCanvas as _exportToCanvas,
-  exportToSvg as _exportToSvg,
-} from "@excalidraw/excalidraw/scene/export";
-
-import type {
-  ExcalidrawElement,
-  ExcalidrawFrameLikeElement,
-  NonDeleted,
-} from "@excalidraw/element/types";
-import type { AppState, BinaryFiles } from "@excalidraw/excalidraw/types";
-
-export { MIME_TYPES };
-
-type ExportOpts = {
-  elements: readonly NonDeleted<ExcalidrawElement>[];
-  appState?: Partial<Omit<AppState, "offsetTop" | "offsetLeft">>;
-  files: BinaryFiles | null;
-  maxWidthOrHeight?: number;
-  exportingFrame?: ExcalidrawFrameLikeElement | null;
-  getDimensions?: (
-    width: number,
-    height: number,
-  ) => { width: number; height: number; scale?: number };
-};
-
-export const exportToCanvas = ({
-  elements,
-  appState,
-  files,
-  maxWidthOrHeight,
-  getDimensions,
-  exportPadding,
-  exportingFrame,
-}: ExportOpts & {
-  exportPadding?: number;
-}) => {
-  const restoredElements = restoreElements(elements, null, {
-    deleteInvisibleElements: true,
-  });
-  const restoredAppState = restoreAppState(appState, null);
-
-  const { exportBackground, viewBackgroundColor } = restoredAppState;
-  return _exportToCanvas(
-    restoredElements,
-    { ...restoredAppState, offsetTop: 0, offsetLeft: 0, width: 0, height: 0 },
-    files || {},
-    { exportBackground, exportPadding, viewBackgroundColor, exportingFrame },
-    (width: number, height: number) => {
-      const canvas = document.createElement("canvas");
-
-      if (maxWidthOrHeight) {
-        if (typeof getDimensions === "function") {
-          console.warn(
-            "`getDimensions()` is ignored when `maxWidthOrHeight` is supplied.",
-          );
-        }
-
-        const max = Math.max(width, height);
-
-        // if content is less then maxWidthOrHeight, fallback on supplied scale
-        const scale =
-          maxWidthOrHeight < max
-            ? maxWidthOrHeight / max
-            : appState?.exportScale ?? 1;
-
-        canvas.width = width * scale;
-        canvas.height = height * scale;
-
-        return {
-          canvas,
-          scale,
-        };
-      }
-
-      const ret = getDimensions?.(width, height) || { width, height };
-
-      canvas.width = ret.width;
-      canvas.height = ret.height;
-
-      return {
-        canvas,
-        scale: ret.scale ?? 1,
-      };
-    },
-  );
-};
-
-export const exportToBlob = async (
-  opts: ExportOpts & {
-    mimeType?: string;
-    quality?: number;
-    exportPadding?: number;
-  },
-): Promise<Blob> => {
-  let { mimeType = MIME_TYPES.png, quality } = opts;
-
-  if (mimeType === MIME_TYPES.png && typeof quality === "number") {
-    console.warn(`"quality" will be ignored for "${MIME_TYPES.png}" mimeType`);
-  }
-
-  // typo in MIME type (should be "jpeg")
-  if (mimeType === "image/jpg") {
-    mimeType = MIME_TYPES.jpg;
-  }
-
-  if (mimeType === MIME_TYPES.jpg && !opts.appState?.exportBackground) {
-    console.warn(
-      `Defaulting "exportBackground" to "true" for "${MIME_TYPES.jpg}" mimeType`,
-    );
-    opts = {
-      ...opts,
-      appState: { ...opts.appState, exportBackground: true },
-    };
-  }
-
-  const canvas = await exportToCanvas(opts);
-
-  quality = quality ? quality : /image\/jpe?g/.test(mimeType) ? 0.92 : 0.8;
-
-  return new Promise((resolve, reject) => {
-    canvas.toBlob(
-      async (blob) => {
-        if (!blob) {
-          return reject(new Error("couldn't export to blob"));
-        }
-        if (
-          blob &&
-          mimeType === MIME_TYPES.png &&
-          opts.appState?.exportEmbedScene
-        ) {
-          blob = await encodePngMetadata({
-            blob,
-            metadata: serializeAsJSON(
-              // NOTE as long as we're using the Scene hack, we need to ensure
-              // we pass the original, uncloned elements when serializing
-              // so that we keep ids stable
-              opts.elements,
-              opts.appState,
-              opts.files || {},
-              "local",
-            ),
-          });
-        }
-        resolve(blob);
-      },
-      mimeType,
-      quality,
-    );
-  });
-};
-
-export const exportToSvg = async ({
-  elements,
-  appState = getDefaultAppState(),
-  files = {},
-  exportPadding,
-  renderEmbeddables,
-  exportingFrame,
-  skipInliningFonts,
-  reuseImages,
-}: Omit<ExportOpts, "getDimensions"> & {
-  exportPadding?: number;
-  renderEmbeddables?: boolean;
-  skipInliningFonts?: true;
-  reuseImages?: boolean;
-}): Promise<SVGSVGElement> => {
-  const restoredElements = restoreElements(elements, null, {
-    deleteInvisibleElements: true,
-  });
-  const restoredAppState = restoreAppState(appState, null);
-
-  const exportAppState = {
-    ...restoredAppState,
-    exportPadding,
-  };
-
-  return _exportToSvg(restoredElements, exportAppState, files, {
-    exportingFrame,
-    renderEmbeddables,
-    skipInliningFonts,
-    reuseImages,
-  });
-};
-
-export const exportToClipboard = async (
-  opts: ExportOpts & {
-    mimeType?: string;
-    quality?: number;
-    type: "png" | "svg" | "json";
-  },
-) => {
-  if (opts.type === "svg") {
-    const svg = await exportToSvg(opts);
-    await copyTextToSystemClipboard(svg.outerHTML);
-  } else if (opts.type === "png") {
-    await copyBlobToClipboardAsPng(exportToBlob(opts));
-  } else if (opts.type === "json") {
-    await copyToClipboard(opts.elements, opts.files);
-  } else {
-    throw new Error("Invalid export type");
-  }
-};

packages/utils/src/index.ts

@@ -1,4 +1,17 @@
-export * from "./export";
+// Re-export from @excalidraw/excalidraw for backwards compatibility
+export {
+  exportToCanvas,
+  exportToBlob,
+  exportToSvg,
+  exportToClipboard,
+  MIME_TYPES,
+} from "@excalidraw/excalidraw/scene/export";
+
+export type {
+  ExportSceneData,
+  ExportSceneConfig,
+} from "@excalidraw/excalidraw/scene/export";
+
 export * from "./withinBounds";
 export * from "./bbox";
 export { getCommonBounds } from "@excalidraw/element";

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,

packages/utils/tests/export.test.ts

@@ -10,9 +10,22 @@ const exportToSvgSpy = vi.spyOn(mockedSceneExportUtils, "exportToSvg");
 describe("exportToCanvas", async () => {
   const EXPORT_PADDING = 10;
 
-  it("with default arguments", async () => {
+  it("with default arguments (no padding)", async () => {
     const canvas = await utils.exportToCanvas({
-      ...diagramFactory({ elementOverrides: { width: 100, height: 100 } }),
+      data: diagramFactory({ elementOverrides: { width: 100, height: 100 } }),
+    });
+
+    // New API has no default padding - call sites must explicitly set it
+    expect(canvas.width).toBe(100);
+    expect(canvas.height).toBe(100);
+  });
+
+  it("with padding", async () => {
+    const canvas = await utils.exportToCanvas({
+      data: diagramFactory({ elementOverrides: { width: 100, height: 100 } }),
+      config: {
+        padding: EXPORT_PADDING,
+      },
     });
 
     expect(canvas.width).toBe(100 + 2 * EXPORT_PADDING);
@@ -21,8 +34,10 @@ describe("exportToCanvas", async () => {
 
   it("when custom width and height", async () => {
     const canvas = await utils.exportToCanvas({
-      ...diagramFactory({ elementOverrides: { width: 100, height: 100 } }),
+      data: diagramFactory({ elementOverrides: { width: 100, height: 100 } }),
-      getDimensions: () => ({ width: 200, height: 200, scale: 1 }),
+      config: {
+        getDimensions: () => ({ width: 200, height: 200, scale: 1 }),
+      },
     });
 
     expect(canvas.width).toBe(200);
@@ -33,20 +48,27 @@ describe("exportToCanvas", async () => {
 describe("exportToBlob", async () => {
   describe("mime type", () => {
     it("should change image/jpg to image/jpeg", async () => {
+      const diagramData = diagramFactory();
       const blob = await utils.exportToBlob({
-        ...diagramFactory(),
+        data: {
-        getDimensions: (width, height) => ({ width, height, scale: 1 }),
+          elements: diagramData.elements,
-        // testing typo in MIME type (jpg → jpeg)
+          appState: {
-        mimeType: "image/jpg",
+            ...diagramData.appState,
-        appState: {
+            exportBackground: true,
-          exportBackground: true,
+          },
+          files: diagramData.files,
+        },
+        config: {
+          getDimensions: (width, height) => ({ width, height, scale: 1 }),
+          // testing typo in MIME type (jpg → jpeg)
+          mimeType: "image/jpg",
         },
       });
       expect(blob?.type).toBe(MIME_TYPES.jpg);
     });
     it("should default to image/png", async () => {
       const blob = await utils.exportToBlob({
-        ...diagramFactory(),
+        data: diagramFactory(),
       });
       expect(blob?.type).toBe(MIME_TYPES.png);
     });
@@ -56,9 +78,11 @@ describe("exportToBlob", async () => {
         .spyOn(console, "warn")
         .mockImplementationOnce(() => void 0);
       await utils.exportToBlob({
-        ...diagramFactory(),
+        data: diagramFactory(),
-        mimeType: MIME_TYPES.png,
+        config: {
-        quality: 1,
+          mimeType: MIME_TYPES.png,
+          quality: 1,
+        },
       });
       expect(consoleSpy).toHaveBeenCalledWith(
         `"quality" will be ignored for "${MIME_TYPES.png}" mimeType`,
@@ -68,8 +92,9 @@ describe("exportToBlob", async () => {
 });
 
 describe("exportToSvg", () => {
-  const passedElements = () => exportToSvgSpy.mock.calls[0][0];
+  const getPassedArg = () => exportToSvgSpy.mock.calls[0][0];
-  const passedOptions = () => exportToSvgSpy.mock.calls[0][1];
+  const passedData = () => getPassedArg().data;
+  const passedConfig = () => getPassedArg().config;
 
   afterEach(() => {
     vi.clearAllMocks();
@@ -77,18 +102,14 @@ describe("exportToSvg", () => {
 
   it("with default arguments", async () => {
     await utils.exportToSvg({
-      ...diagramFactory({
+      data: diagramFactory({
         overrides: { appState: void 0 },
       }),
     });
 
-    const passedOptionsWhenDefault = {
+    const data = passedData();
-      ...passedOptions(),
+    expect(data.elements.length).toBe(3);
-      // To avoid varying snapshots
+    expect(passedConfig()).toMatchSnapshot();
-      name: "name",
-    };
-    expect(passedElements().length).toBe(3);
-    expect(passedOptionsWhenDefault).toMatchSnapshot();
   });
 
   // FIXME the utils.exportToSvg no longer filters out deleted elements.
@@ -96,37 +117,39 @@ describe("exportToSvg", () => {
   // type-checking for it correctly.
   it.skip("with deleted elements", async () => {
     await utils.exportToSvg({
-      ...diagramFactory({
+      data: diagramFactory({
         overrides: { appState: void 0 },
         elementOverrides: { isDeleted: true },
       }),
     });
 
-    expect(passedElements().length).toBe(0);
+    expect(passedData().elements.length).toBe(0);
   });
 
-  it("with exportPadding", async () => {
+  it("with padding", async () => {
     await utils.exportToSvg({
-      ...diagramFactory({ overrides: { appState: { name: "diagram name" } } }),
+      data: diagramFactory({ overrides: { appState: { name: "diagram name" } } }),
-      exportPadding: 0,
+      config: {
+        padding: 0,
+      },
     });
 
-    expect(passedElements().length).toBe(3);
+    expect(passedData().elements.length).toBe(3);
-    expect(passedOptions()).toEqual(
+    expect(passedConfig()).toEqual(
-      expect.objectContaining({ exportPadding: 0 }),
+      expect.objectContaining({ padding: 0 }),
     );
   });
 
   it("with exportEmbedScene", async () => {
     await utils.exportToSvg({
-      ...diagramFactory({
+      data: diagramFactory({
         overrides: {
           appState: { name: "diagram name", exportEmbedScene: true },
         },
       }),
     });
 
-    expect(passedElements().length).toBe(3);
+    expect(passedData().elements.length).toBe(3);
-    expect(passedOptions().exportEmbedScene).toBe(true);
+    expect(passedData().appState?.exportEmbedScene).toBe(true);
   });
 });

packages/utils/tests/utils.unmocked.test.ts

@@ -19,13 +19,15 @@ describe("embedding scene data", () => {
       const sourceElements = [rectangle, ellipse];
 
       const svgNode = await utils.exportToSvg({
-        elements: sourceElements,
+        data: {
-        appState: {
+          elements: sourceElements,
-          viewBackgroundColor: "#ffffff",
+          appState: {
-          gridModeEnabled: false,
+            viewBackgroundColor: "#ffffff",
-          exportEmbedScene: true,
+            gridModeEnabled: false,
+            exportEmbedScene: true,
+          },
+          files: null,
         },
-        files: null,
       });
 
       const svg = svgNode.outerHTML;
@@ -49,14 +51,18 @@ describe("embedding scene data", () => {
       const sourceElements = [rectangle, ellipse];
 
       const blob = await utils.exportToBlob({
-        mimeType: "image/png",
+        data: {
-        elements: sourceElements,
+          elements: sourceElements,
-        appState: {
+          appState: {
-          viewBackgroundColor: "#ffffff",
+            viewBackgroundColor: "#ffffff",
-          gridModeEnabled: false,
+            gridModeEnabled: false,
-          exportEmbedScene: true,
+            exportEmbedScene: true,
+          },
+          files: null,
+        },
+        config: {
+          mimeType: "image/png",
         },
-        files: null,
       });
 
       const parsedString = await decodePngMetadata(blob);

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.1":
-  version "2.2.2"
+  version "2.1.1"
-  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.1.tgz#659c934a607dd2cf57f2a69282588ee2b0722959"
-  integrity sha512-5VKQq5CdRocC82vOIUpQ5ufJOVV9FpBTdHGA+ULqazeIVV+cr299877omQCibsdS3Bpitz2fsnTwnIXEmLVDSg==
+  integrity sha512-jU+frqcxazsY+t5yOBf2mgrQy+WUrbrzA36if3SQB/Vwaf2qOJjnWxucNafgZZk/3+9xGmRotUeOviSOJG+wYA==
   dependencies:
     "@excalidraw/markdown-to-text" "0.1.2"
     "@mermaid-js/parser" "^0.6.3"