feat: tweak sidebar promo style

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

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
 

excalidraw-app/components/AppSidebar.scss

@@ -4,21 +4,32 @@
     display: flex;
     flex-direction: column;
     text-align: center;
-    gap: 1rem;
+    gap: 1.5rem;
     flex: 1 1 auto;
+
+    .link-button {
+      margin: 0 auto !important;
+      width: 100%;
+      button {
+        width: 100%;
+      }
+    }
   }
 
   .app-sidebar-promo-image {
     margin: 1rem 0;
 
-    height: 16.25rem;
+    height: 295px;
     background-size: contain;
     background-position: center;
     background-repeat: no-repeat;
+    background-size: calc(
+      var(--right-sidebar-width, 100%) - var(--space-factor) * 2
+    );
 
     background-image: radial-gradient(
         circle,
-        transparent 60%,
+        transparent 0%,
         var(--sidebar-bg-color) 100%
       ),
       var(--image-source);
@@ -33,4 +44,49 @@
   .link-button {
     margin: 0 auto;
   }
+
+  .app-sidebar-promo-text {
+    padding: 0 0.5rem;
+    font-size: 0.875rem;
+    font-weight: 700;
+    line-height: 1.4;
+  }
+
+  .app-sidebar-promo-illustration {
+    position: relative;
+    min-height: 7rem;
+    display: flex;
+    align-items: flex-start;
+    justify-content: center;
+    padding-top: 0.125rem;
+
+    .app-sidebar-promo-heart {
+      width: 46px;
+      transform: translateX(-14px);
+      height: auto;
+    }
+
+    .app-sidebar-promo-trial-note {
+      position: absolute;
+      top: 2.75rem;
+      left: 50%;
+      transform: translateX(-56%) rotate(-7deg);
+      font-size: 1rem;
+      line-height: 1.15;
+      color: var(--color-primary);
+
+      white-space: nowrap;
+    }
+
+    .app-sidebar-promo-trial-arrow {
+      position: absolute;
+      top: 3.35rem;
+      left: 55%;
+      width: 4.5rem;
+      height: 3rem;
+      transform: translateX(1.75rem) rotate(10deg);
+      color: var(--color-primary);
+      overflow: visible;
+    }
+  }
 }

excalidraw-app/components/AppSidebar.tsx

@@ -8,6 +8,63 @@ import { useUIAppState } from "@excalidraw/excalidraw/context/ui-appState";
 
 import "./AppSidebar.scss";
 
+type SidebarPromoCopyProps = {
+  text: string;
+};
+
+const SidebarPromoCopy = (props: SidebarPromoCopyProps) => {
+  return (
+    <div className="app-sidebar-promo-copy">
+      <div className="app-sidebar-promo-illustration" aria-hidden="true">
+        <svg
+          xmlns="http://www.w3.org/2000/svg"
+          viewBox="0 0 300 250"
+          className="app-sidebar-promo-heart"
+        >
+          <path
+            d="M 145 75
+           C 110 35, 60 55, 65 120
+           C 70 180, 140 190, 215 200
+           C 225 180, 260 110, 235 55
+           C 210 -5, 140 20, 160 105"
+            fill="none"
+            stroke="#D06B64"
+            strokeWidth="16"
+            strokeLinecap="round"
+          />
+        </svg>
+
+        <div className="app-sidebar-promo-trial-note excalifont">
+          14 days of
+          <br />
+          free trial
+        </div>
+        <svg
+          className="app-sidebar-promo-trial-arrow"
+          viewBox="0 0 72 48"
+          fill="none"
+          xmlns="http://www.w3.org/2000/svg"
+        >
+          <path
+            d="M5 6C23 1 50 8 48 32"
+            stroke="currentColor"
+            strokeWidth="2"
+            strokeLinecap="round"
+          />
+          <path
+            d="M42 26L48 32L54 26"
+            stroke="currentColor"
+            strokeWidth="2"
+            strokeLinecap="round"
+            strokeLinejoin="round"
+          />
+        </svg>
+      </div>
+      <div className="app-sidebar-promo-text">{props.text}</div>
+    </div>
+  );
+};
+
 export const AppSidebar = () => {
   const { theme, openSidebar } = useUIAppState();
 
@@ -32,15 +89,13 @@ export const AppSidebar = () => {
           <div
             className="app-sidebar-promo-image"
             style={{
-              ["--image-source" as any]: `url(/oss_promo_comments_${
+              ["--image-source" as any]: `url(/sidebar-comments-promo-${
                 theme === THEME.DARK ? "dark" : "light"
               }.jpg)`,
-              opacity: 0.7,
+              opacity: 0.9,
             }}
           />
-          <div className="app-sidebar-promo-text">
-            Make comments with Excalidraw+
-          </div>
+          <SidebarPromoCopy text="Make comments with Excalidraw+" />
           <LinkButton
             href={`${
               import.meta.env.VITE_APP_PLUS_LP
@@ -55,16 +110,13 @@ export const AppSidebar = () => {
           <div
             className="app-sidebar-promo-image"
             style={{
-              ["--image-source" as any]: `url(/oss_promo_presentations_${
+              ["--image-source" as any]: `url(/sidebar-presentation-promo-${
                 theme === THEME.DARK ? "dark" : "light"
-              }.svg)`,
-              backgroundSize: "60%",
-              opacity: 0.4,
+              }.jpg)`,
+              opacity: 0.7,
             }}
           />
-          <div className="app-sidebar-promo-text">
-            Create presentations with Excalidraw+
-          </div>
+          <SidebarPromoCopy text="Create presentation with Excalidraw+" />
           <LinkButton
             href={`${
               import.meta.env.VITE_APP_PLUS_LP

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) /
-    Math.max(hoveredElement.width, PRECISION);
+    (nonRotatedPoint[0] - hoveredElement.x) / hoveredElement.width;
   const fixedPointY =
-    (nonRotatedPoint[1] - hoveredElement.y) /
-    Math.max(hoveredElement.height, PRECISION);
+    (nonRotatedPoint[1] - hoveredElement.y) / hoveredElement.height;
 
   return {
     fixedPoint: normalizeFixedPoint([fixedPointX, fixedPointY]),

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][1] < -MAX_POS ||
+    offsetY + points[points.length - 1][0] > MAX_POS ||
+    offsetX + points[points.length - 1][1] < -MAX_POS ||
     offsetY + points[points.length - 1][1] > MAX_POS
   ) {
     console.error(

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<
-    AppState,
-    "suggestedBinding" | "selectedLinearElement" | "snapLines"
-  > | null {
+  ): Pick<AppState, "suggestedBinding" | "selectedLinearElement"> | 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 } =
-      LinearElementEditor._getSnappedPointForLinearElement({
-        app,
-        event,
-        elements,
-        elementsMap,
+    // Determine if point movement should happen and how much
+    let deltaX = 0;
+    let deltaY = 0;
+    if (shouldRotateWithDiscreteAngle(event)) {
+      const [width, height] = LinearElementEditor._getShiftLockedDelta(
         element,
-        pointIndex: idx,
-        scenePointerX,
-        scenePointerY,
-        pointerOffset: linearElementEditor.pointerOffset,
-        referencePoint: shouldRotateWithDiscreteAngle(event)
-          ? pivotPoint
-          : null,
-        selectedPointsIndices: [idx],
+        elementsMap,
+        pivotPoint,
+        pointFrom(scenePointerX, scenePointerY),
+        event[KEYS.CTRL_OR_CMD] ? null : app.getEffectiveGridSize(),
         customLineAngle,
-      });
+      );
+      const target = pointFrom<LocalPoint>(
+        width + pivotPoint[0],
+        height + pivotPoint[1],
+      );
 
-    const deltaX = newDraggingPointPosition[0] - point[0];
-    const deltaY = newDraggingPointPosition[1] - point[1];
+      deltaX = target[0] - point[0];
+      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<
-    AppState,
-    "suggestedBinding" | "selectedLinearElement" | "snapLines"
-  > | null {
+  ): Pick<AppState, "suggestedBinding" | "selectedLinearElement"> | null {
     const elementsMap = app.scene.getNonDeletedElementsMap();
     const elements = app.scene.getNonDeletedElements();
     const { elbowed, elementId, initialState } = linearElementEditor;
@@ -498,6 +493,7 @@ export class LinearElementEditor {
       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 +507,35 @@ export class LinearElementEditor {
       element.points.length - 1,
     );
 
-    const { point: newDraggingPointPosition, snapLines } =
-      LinearElementEditor._getSnappedPointForLinearElement({
-        app,
-        event,
-        elements,
-        elementsMap,
+    // Determine if point movement should happen and how much
+    let deltaX = 0;
+    let deltaY = 0;
+    if (shouldRotateWithDiscreteAngle(event) && singlePointDragged) {
+      const [width, height] = LinearElementEditor._getShiftLockedDelta(
         element,
-        pointIndex: lastClickedPoint,
-        scenePointerX,
-        scenePointerY,
-        pointerOffset: linearElementEditor.pointerOffset,
-        referencePoint:
-          shouldRotateWithDiscreteAngle(event) && singlePointDragged
-            ? pivotPoint
-            : null,
-        selectedPointsIndices,
+        elementsMap,
+        pivotPoint,
+        pointFrom(scenePointerX, scenePointerY),
+        event[KEYS.CTRL_OR_CMD] ? null : app.getEffectiveGridSize(),
         customLineAngle,
-      });
-
-    const deltaX = newDraggingPointPosition[0] - draggingPoint[0];
-    const deltaY = newDraggingPointPosition[1] - draggingPoint[1];
+      );
+      const target = pointFrom<LocalPoint>(
+        width + pivotPoint[0],
+        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 +674,6 @@ export class LinearElementEditor {
     return {
       selectedLinearElement: newLinearElementEditor,
       suggestedBinding,
-      snapLines,
     };
   }
 
@@ -1175,10 +1178,7 @@ export class LinearElementEditor {
     scenePointerX: number,
     scenePointerY: number,
     app: AppClassProperties,
-  ): {
-    editingLinearElement: LinearElementEditor;
-    snapLines: readonly SnapLine[];
-  } | null {
+  ): LinearElementEditor | null {
     const appState = app.state;
     if (!appState.selectedLinearElement?.isEditing) {
       return null;
@@ -1187,10 +1187,7 @@ export class LinearElementEditor {
     const elementsMap = app.scene.getNonDeletedElementsMap();
     const element = LinearElementEditor.getElement(elementId, elementsMap);
     if (!element) {
-      return {
-        editingLinearElement: appState.selectedLinearElement,
-        snapLines: appState.snapLines,
-      };
+      return appState.selectedLinearElement;
     }
 
     const { points } = element;
@@ -1202,37 +1199,36 @@ export class LinearElementEditor {
       }
       return appState.selectedLinearElement?.lastUncommittedPoint
         ? {
-            editingLinearElement: {
-              ...appState.selectedLinearElement,
-              lastUncommittedPoint: null,
-            },
-            snapLines: [],
+            ...appState.selectedLinearElement,
+            lastUncommittedPoint: null,
           }
-        : {
-            editingLinearElement: appState.selectedLinearElement,
-            snapLines: [],
-          };
+        : appState.selectedLinearElement;
     }
 
-    const anchor = points[points.length - 2];
-    const elements = app.scene.getNonDeletedElements();
-    const { point: newPoint, snapLines } =
-      LinearElementEditor._getSnappedPointForLinearElement({
-        app,
-        event,
-        elements,
-        elementsMap,
+    let newPoint: LocalPoint;
+
+    if (shouldRotateWithDiscreteAngle(event) && points.length >= 2) {
+      const anchor = points[points.length - 2];
+      const [width, height] = LinearElementEditor._getShiftLockedDelta(
         element,
-        pointIndex: points.length - 1,
-        scenePointerX,
-        scenePointerY,
-        pointerOffset: appState.selectedLinearElement.pointerOffset,
-        referencePoint:
-          shouldRotateWithDiscreteAngle(event) && points.length >= 2
-            ? anchor
-            : null,
-        selectedPointsIndices: [points.length - 1],
-      });
+        elementsMap,
+        anchor,
+        pointFrom(scenePointerX, scenePointerY),
+        event[KEYS.CTRL_OR_CMD] ? null : app.getEffectiveGridSize(),
+      );
+
+      newPoint = pointFrom(width + anchor[0], height + anchor[1]);
+    } else {
+      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 +1236,7 @@ export class LinearElementEditor {
         app.scene,
         new Map([
           [
-            points.length - 1,
+            element.points.length - 1,
             {
               point: newPoint,
             },
@@ -1250,13 +1246,9 @@ export class LinearElementEditor {
     } else {
       LinearElementEditor.addPoints(element, app.scene, [newPoint]);
     }
-
     return {
-      editingLinearElement: {
-        ...appState.selectedLinearElement,
-        lastUncommittedPoint: element.points[element.points.length - 1],
-      },
-      snapLines,
+      ...appState.selectedLinearElement,
+      lastUncommittedPoint: element.points[element.points.length - 1],
     };
   }
 
@@ -1282,53 +1274,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;
-
-    let elementX = element.x;
-    let elementY = element.y;
-
-    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),
+    return element.points.map((p) => {
+      const { x, y } = element;
+      return pointRotateRads(
+        pointFrom(x + p[0], y + p[1]),
         pointFrom(cx, cy),
         element.angle,
       );
-      globalPoints.push(rotated);
-    }
-
-    return globalPoints;
+    });
   }
 
   static getPointAtIndexGlobalCoordinates(
@@ -1882,222 +1839,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,

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/excalidraw/components/App.tsx

@@ -239,16 +239,6 @@ import {
   hitElementBoundingBox,
   isLineElement,
   isSimpleArrow,
-  isGridModeEnabled,
-  SnapCache,
-  isActiveToolNonLinearSnappable,
-  getSnapLinesAtPointer,
-  isSnappingEnabled,
-  getReferenceSnapPoints,
-  getVisibleGaps,
-  snapDraggedElements,
-  snapNewElement,
-  snapResizingElements,
   StoreDelta,
   type ApplyToOptions,
   positionElementsOnGrid,
@@ -406,6 +396,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,
@@ -783,29 +785,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();
@@ -6807,10 +6786,7 @@ class App extends React.Component<AppProps, AppState> {
 
     if (
       !this.state.newElement &&
-      (isActiveToolNonLinearSnappable(this.state.activeTool.type) ||
-        ((this.state.activeTool.type === "line" ||
-          this.state.activeTool.type === "arrow") &&
-          this.state.currentItemArrowType !== ARROW_TYPE.elbow))
+      isActiveToolNonLinearSnappable(this.state.activeTool.type)
     ) {
       const { originOffset, snapLines } = getSnapLinesAtPointer(
         this.scene.getNonDeletedElements(),
@@ -6859,7 +6835,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 +6844,18 @@ class App extends React.Component<AppProps, AppState> {
             this,
           );
 
-      if (result) {
-        const { editingLinearElement, snapLines } = result;
-        const nextState = this.withStableSnapLines({
-          selectedLinearElement: editingLinearElement,
-          snapLines,
-        });
-
-        if (
-          editingLinearElement &&
-          this.shouldUpdateSelectedLinearElementState(
-            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 &&
+        editingLinearElement !== this.state.selectedLinearElement
+      ) {
+        // 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({
+            selectedLinearElement: editingLinearElement,
           });
-        }
-        if (
-          editingLinearElement.lastUncommittedPoint == null &&
-          this.state.suggestedBinding
-        ) {
-          this.setState({ suggestedBinding: null });
-        }
+        });
       }
     }
 
@@ -9752,27 +9713,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 ||
-              nextState.snapLines !== this.state.snapLines
+                newState.selectedLinearElement?.initialState?.altFocusPoint
             ) {
-              this.setState(nextState);
+              this.setState(newState);
             }
 
             return;
@@ -10461,7 +10420,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");
 

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/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/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
@@ -469,8 +467,8 @@ export const restoreElement = (
         element.endArrowhead === undefined
           ? "arrow"
           : normalizeArrowhead(element.endArrowhead);
-      const x = element.x as number | undefined;
-      const y = element.y as number | undefined;
+      const x: number | undefined = element.x;
+      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 +493,8 @@ export const restoreElement = (
         startArrowhead,
         endArrowhead,
         points,
-        x: x ?? 0,
-        y: y ?? 0,
+        x,
+        y,
         elbowed: (element as ExcalidrawArrowElement).elbowed,
         ...getSizeFromPoints(points),
       };
@@ -515,44 +513,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 +666,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 +762,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 (

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/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";
-
-import { LinearElementEditor } from "./linearElementEditor";
+} from "./types";
 
 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__/regressionTests.test.tsx.snap

@@ -8665,14 +8665,7 @@ exports[`regression tests > key 5 selects arrow tool > [end of test] appState 1`
   "openMenu": null,
   "openPopup": null,
   "openSidebar": null,
-  "originSnapOffset": {
-    "x": 0,
-    "y": 0,
-  },
-  "pasteDialog": {
-    "data": null,
-    "shown": false,
-  },
+  "originSnapOffset": null,
   "penDetected": false,
   "penMode": false,
   "preferredSelectionTool": {
@@ -9329,14 +9322,7 @@ exports[`regression tests > key a selects arrow tool > [end of test] appState 1`
   "openMenu": null,
   "openPopup": null,
   "openSidebar": null,
-  "originSnapOffset": {
-    "x": 0,
-    "y": 0,
-  },
-  "pasteDialog": {
-    "data": null,
-    "shown": false,
-  },
+  "originSnapOffset": null,
   "penDetected": false,
   "penMode": false,
   "preferredSelectionTool": {

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,
@@ -57,6 +55,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";

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 = [