Merge branch 'master' into mtolmacs/chore/rename-inside-binding

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

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

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

packages/element/src/arrows/focus.ts

@@ -125,7 +125,7 @@ const focusPointUpdate = (
     if (switchToInsideBinding || boundToSameElement) {
       currentBinding = {
         ...currentBinding,
-        mode: "inside",
+        mode: "fixed",
       };
     } else {
       currentBinding = {
@@ -166,7 +166,7 @@ const focusPointUpdate = (
       if (switchToInsideBinding || boundToSameElementAfterUpdate) {
         adjacentBinding = {
           ...adjacentBinding,
-          mode: "inside",
+          mode: "fixed",
         };
       } else {
         adjacentBinding = {
@@ -256,8 +256,8 @@ export const handleFocusPointDrag = (
     // Handle binding mode switch
     const newMode =
       switchToInsideBinding && arrow[bindingField]?.mode === "orbit"
-        ? "inside"
+        ? "fixed"
-        : !switchToInsideBinding && arrow[bindingField]?.mode === "inside"
+        : !switchToInsideBinding && arrow[bindingField]?.mode === "fixed"
         ? "orbit"
         : null;
 

packages/element/src/binding.ts

@@ -328,7 +328,7 @@ const bindingStrategyForNewSimpleArrowEndpointDragging = (
     if (hit) {
       start = {
         element: hit,
-        mode: "inside",
+        mode: "fixed",
         focusPoint: point,
       };
     } else {
@@ -353,13 +353,13 @@ const bindingStrategyForNewSimpleArrowEndpointDragging = (
         start: isMultiPoint
           ? { mode: undefined }
           : {
-              mode: "inside",
+              mode: "fixed",
               element: hit,
               focusPoint: origin ?? center,
             },
         end: isMultiPoint
           ? { mode: "orbit", element: hit, focusPoint: point }
-          : { mode: "inside", element: hit, focusPoint: point },
+          : { mode: "fixed", element: hit, focusPoint: point },
       };
     }
 
@@ -379,7 +379,7 @@ const bindingStrategyForNewSimpleArrowEndpointDragging = (
           start: isMultiPoint
             ? { mode: undefined }
             : {
-                mode: otherElement.id !== hit.id ? "orbit" : "inside",
+                mode: otherElement.id !== hit.id ? "orbit" : "fixed",
                 element: otherElement,
                 focusPoint: origin ?? pointFrom<GlobalPoint>(arrow.x, arrow.y),
               },
@@ -402,7 +402,7 @@ const bindingStrategyForNewSimpleArrowEndpointDragging = (
       const otherIsInsideBinding =
         !!appState.selectedLinearElement?.initialState.arrowStartIsInside;
       const other: BindingStrategy = {
-        mode: otherIsInsideBinding ? "inside" : "orbit",
+        mode: otherIsInsideBinding ? "fixed" : "orbit",
         element: otherElement,
         focusPoint: shiftKey
           ? elementCenterPoint(otherElement, elementsMap)
@@ -416,9 +416,9 @@ const bindingStrategyForNewSimpleArrowEndpointDragging = (
       let current: BindingStrategy;
       if (hit) {
         const isInsideBinding =
-          globalBindMode === "inside" || globalBindMode === "skip";
+          globalBindMode === "fixed" || globalBindMode === "skip";
         current = {
-          mode: isInsideBinding && !isNested ? "inside" : "orbit",
+          mode: isInsideBinding && !isNested ? "fixed" : "orbit",
           element: hit,
           focusPoint: isInsideBinding || isNested ? point : point,
         };
@@ -436,10 +436,10 @@ const bindingStrategyForNewSimpleArrowEndpointDragging = (
     if (!arrow.startBinding) {
       if (hit) {
         const isInsideBinding =
-          globalBindMode === "inside" || globalBindMode === "skip";
+          globalBindMode === "fixed" || globalBindMode === "skip";
 
         end = {
-          mode: isInsideBinding ? "inside" : "orbit",
+          mode: isInsideBinding ? "fixed" : "orbit",
           element: hit,
           focusPoint: point,
         };
@@ -488,7 +488,7 @@ const bindingStrategyForSimpleArrowEndpointDragging_complex = (
 
   // If the global bind mode is in free binding mode, just bind
   // where the pointer is and keep the other end intact
-  if (globalBindMode === "inside" || globalBindMode === "skip") {
+  if (globalBindMode === "fixed" || globalBindMode === "skip") {
     current = hit
       ? {
           element:
@@ -496,7 +496,7 @@ const bindingStrategyForSimpleArrowEndpointDragging_complex = (
               ? hit
               : oppositeElement,
           focusPoint: point,
-          mode: "inside",
+          mode: "fixed",
         }
       : { mode: null };
     other =
@@ -514,12 +514,9 @@ const bindingStrategyForSimpleArrowEndpointDragging_complex = (
   }
 
   // Already inside binding over the same hit element should remain inside bound
-  if (
+  if (hit.id === currentBinding?.elementId && currentBinding.mode === "fixed") {
-    hit.id === currentBinding?.elementId &&
-    currentBinding.mode === "inside"
-  ) {
     return {
-      current: { mode: "inside", focusPoint: point, element: hit },
+      current: { mode: "fixed", focusPoint: point, element: hit },
       other,
     };
   }
@@ -538,7 +535,7 @@ const bindingStrategyForSimpleArrowEndpointDragging_complex = (
       // The opposite binding is inside the same element
       // eslint-disable-next-line no-else-return
       else {
-        current = { element: hit, mode: "inside", focusPoint: point };
+        current = { element: hit, mode: "fixed", focusPoint: point };
 
         return { current, other: isMultiPoint ? { mode: undefined } : other };
       }
@@ -550,7 +547,7 @@ const bindingStrategyForSimpleArrowEndpointDragging_complex = (
       if (isOverlapping && oppositeElement && !otherIsTransparent) {
         current = {
           element: oppositeElement,
-          mode: "inside",
+          mode: "fixed",
           focusPoint: point,
         };
       } else {
@@ -741,7 +738,7 @@ const getBindingStrategyForDraggingBindingElementEndpoints_simple = (
   ) {
     return {
       start: {
-        mode: "inside",
+        mode: "fixed",
         element: hit,
         focusPoint: startDragged
           ? globalPoint
@@ -755,7 +752,7 @@ const getBindingStrategyForDraggingBindingElementEndpoints_simple = (
             ), // startFixedPoint,
       },
       end: {
-        mode: "inside",
+        mode: "fixed",
         element: hit,
         focusPoint: endDragged
           ? globalPoint
@@ -774,7 +771,7 @@ const getBindingStrategyForDraggingBindingElementEndpoints_simple = (
       start: startDragged
         ? hit
           ? {
-              mode: "inside",
+              mode: "fixed",
               element: hit,
               focusPoint: globalPoint,
             }
@@ -783,7 +780,7 @@ const getBindingStrategyForDraggingBindingElementEndpoints_simple = (
       end: endDragged
         ? hit
           ? {
-              mode: "inside",
+              mode: "fixed",
               element: hit,
               focusPoint: globalPoint,
             }
@@ -796,7 +793,7 @@ const getBindingStrategyForDraggingBindingElementEndpoints_simple = (
   const current: BindingStrategy = hit
     ? pointInElement
       ? {
-          mode: "inside",
+          mode: "fixed",
           element: hit,
           focusPoint: globalPoint,
         }
@@ -833,7 +830,7 @@ const getBindingStrategyForDraggingBindingElementEndpoints_simple = (
     });
   const otherNeverOverride = opts?.newArrow
     ? appState.selectedLinearElement?.initialState.arrowStartIsInside
-    : otherBinding?.mode === "inside";
+    : otherBinding?.mode === "fixed";
   const other: BindingStrategy = !otherNeverOverride
     ? otherBindableElement &&
       !otherFocusPointIsInElement &&
@@ -1772,7 +1769,7 @@ export const updateBoundPoint = (
 
   // 0. Short-circuit for inside binding as it doesn't require any
   // calculations and is not affected by other bindings
-  if (binding.mode === "inside") {
+  if (binding.mode === "fixed") {
     return LinearElementEditor.createPointAt(
       arrow,
       elementsMap,

packages/element/src/bounds.ts

@@ -790,41 +790,27 @@ export const getArrowheadPoints = (
     p0 = pointFrom(prevOp.data[4], prevOp.data[5]);
   }
 
-  // We know the last point of the arrow (or the first, if start arrowhead).
+  // B(t) = p0 * (1-t)^3 + 3p1 * t * (1-t)^2 + 3p2 * t^2 * (1-t) + p3 * t^3
+  const equation = (t: number, idx: number) =>
+    Math.pow(1 - t, 3) * p3[idx] +
+    3 * t * Math.pow(1 - t, 2) * p2[idx] +
+    3 * Math.pow(t, 2) * (1 - t) * p1[idx] +
+    p0[idx] * Math.pow(t, 3);
+
+  // Ee know the last point of the arrow (or the first, if start arrowhead).
   const [x2, y2] = position === "start" ? p0 : p3;
 
-  // Use the analytic tangent at the Bézier endpoint for a precise arrowhead
+  // By using cubic bezier equation (B(t)) and the given parameters,
-  // direction. For a cubic Bézier B(t) with control points p0p3:
+  // we calculate a point that is closer to the last point.
-  //   B'(1): (p3 − p2) tangent at the end
+  // The value 0.3 is chosen arbitrarily and it works best for all
-  //   B'(0): (p1 − p0) for start arrowhead, arrow points away: (p0 − p1)
+  // the tested cases.
-  let dx: number;
+  const [x1, y1] = [equation(0.3, 0), equation(0.3, 1)];
-  let dy: number;
+
-  if (position === "end") {
+  // Find the normalized direction vector based on the
-    dx = p3[0] - p2[0];
+  // previously calculated points.
-    dy = p3[1] - p2[1];
+  const distance = Math.hypot(x2 - x1, y2 - y1);
-    if (Math.hypot(dx, dy) < 1e-6) {
+  const nx = (x2 - x1) / distance;
-      dx = p3[0] - p1[0];
+  const ny = (y2 - y1) / distance;
-      dy = p3[1] - p1[1];
-    }
-    if (Math.hypot(dx, dy) < 1e-6) {
-      dx = p3[0] - p0[0];
-      dy = p3[1] - p0[1];
-    }
-  } else {
-    dx = p0[0] - p1[0];
-    dy = p0[1] - p1[1];
-    if (Math.hypot(dx, dy) < 1e-6) {
-      dx = p0[0] - p2[0];
-      dy = p0[1] - p2[1];
-    }
-    if (Math.hypot(dx, dy) < 1e-6) {
-      dx = p0[0] - p3[0];
-      dy = p0[1] - p3[1];
-    }
-  }
-  const distance = Math.hypot(dx, dy);
-  const nx = dx / distance;
-  const ny = dy / distance;
 
   const size = getArrowheadSize(arrowhead);
 
@@ -894,10 +880,30 @@ export const getArrowheadPoints = (
   );
 
   if (arrowhead === "diamond" || arrowhead === "diamond_outline") {
-    // point opposite to the arrowhead point, just mirrored across the (tx, ty)
+    // point opposite to the arrowhead point
-    // point
+    let ox;
-    const ox = tx - nx * minSize * 2;
+    let oy;
-    const oy = ty - ny * minSize * 2;
+
+    if (position === "start") {
+      const [px, py] = element.points.length > 1 ? element.points[1] : [0, 0];
+
+      [ox, oy] = pointRotateRads(
+        pointFrom(tx + minSize * 2, ty),
+        pointFrom(tx, ty),
+        Math.atan2(py - ty, px - tx) as Radians,
+      );
+    } else {
+      const [px, py] =
+        element.points.length > 1
+          ? element.points[element.points.length - 2]
+          : [0, 0];
+
+      [ox, oy] = pointRotateRads(
+        pointFrom(tx - minSize * 2, ty),
+        pointFrom(tx, ty),
+        Math.atan2(ty - py, tx - px) as Radians,
+      );
+    }
 
     return [tx, ty, x3, y3, ox, oy, x4, y4];
   }

packages/element/src/collision.ts

@@ -762,7 +762,7 @@ export const isPointInElement = (
     (isLinearElement(element) || isFreeDrawElement(element)) &&
     !isPathALoop(element.points)
   ) {
-    // There isn't any "inside" for a non-looping path
+    // There isn't any "fixed" for a non-looping path
     return false;
   }
 

packages/element/src/linearElementEditor.ts

@@ -790,20 +790,9 @@ export class LinearElementEditor {
       elementsMap,
     );
 
-    const [lines, segCurves] = deconstructLinearOrFreeDrawElement(
-      element,
-      elementsMap,
-    );
-    const segmentCount = lines.length + segCurves.length;
-
     let index = 0;
     const midpoints: (GlobalPoint | null)[] = [];
     while (index < points.length - 1) {
-      if (segmentCount > 0 && index >= segmentCount) {
-        midpoints.push(null);
-        index++;
-        continue;
-      }
       if (
         LinearElementEditor.isSegmentTooShort(
           element,
@@ -1094,7 +1083,7 @@ export class LinearElementEditor {
           },
           arrowStartIsInside:
             !!app.state.newElement &&
-            (app.state.bindMode === "inside" || app.state.bindMode === "skip"),
+            (app.state.bindMode === "fixed" || app.state.bindMode === "skip"),
           altFocusPoint: null,
         },
         selectedPointsIndices: [element.points.length - 1],
@@ -1156,7 +1145,7 @@ export class LinearElementEditor {
         },
         arrowStartIsInside:
           !!app.state.newElement &&
-          (app.state.bindMode === "inside" || app.state.bindMode === "skip"),
+          (app.state.bindMode === "fixed" || app.state.bindMode === "skip"),
         altFocusPoint: null,
       },
       selectedPointsIndices: nextSelectedPointsIndices,
@@ -2423,7 +2412,7 @@ const pointDraggingUpdates = (
   const endLocalPoint = startIsDraggingOverEndElement
     ? nextArrow.points[nextArrow.points.length - 1]
     : endIsDraggingOverStartElement &&
-      app.state.bindMode !== "inside" &&
+      app.state.bindMode !== "fixed" &&
       getFeatureFlag("COMPLEX_BINDINGS")
     ? nextArrow.points[0]
     : endBindable
@@ -2454,7 +2443,7 @@ const pointDraggingUpdates = (
     endIsDraggingOverStartElement && getFeatureFlag("COMPLEX_BINDINGS")
       ? nextArrow.points[0]
       : startIsDraggingOverEndElement &&
-        app.state.bindMode !== "inside" &&
+        app.state.bindMode !== "fixed" &&
         getFeatureFlag("COMPLEX_BINDINGS")
       ? endLocalPoint
       : startBindable
@@ -2472,7 +2461,7 @@ const pointDraggingUpdates = (
     !startIsDraggingOverEndElement &&
     !(
       endIsDraggingOverStartElement &&
-      app.state.bindMode !== "inside" &&
+      app.state.bindMode !== "fixed" &&
       getFeatureFlag("COMPLEX_BINDINGS")
     ) &&
     !!endBindable;

packages/element/src/shape.ts

@@ -78,18 +78,6 @@ import type {
 import type { Drawable, Options } from "roughjs/bin/core";
 import type { Point as RoughPoint } from "roughjs/bin/geometry";
 
-// Controls how handle distance scales with chord length.
-// At 1.0 handles are exactly h/3 (standard Hermite). Values below 1 make
-// short segments curvier and long segments more taut (sub-linear scaling).
-const CP_CHORD_POWER = 1;
-
-// At curved knots the C2 spline tangent can be tilted away from the
-// bisector direction, making one side of the knot tight and the other taut.
-// This factor [0, 1] controls how far the tangent direction is pulled toward
-// the bisector (the chord-bisector normal) linearly with turn sharpness.
-// 0 = pure C2 spline; 1 = tangent fully aligned with the bisector.
-const CP_ANGLE_CORRECTION = 1;
-
 export class ShapeCache {
   private static rg = new RoughGenerator();
   private static cache = new WeakMap<
@@ -637,144 +625,60 @@ export const generateLinearCollisionShape = (
         });
       }
 
-      // Generate collision ops using the same bisector-based cubic Bézier
+      return generator
-      // algorithm as generateRoundedSimpleArrowShape so hit-testing matches rendering.
+        .curve(points as unknown as RoughPoint[], options)
-      const rotateLocal = (lx: number, ly: number): LocalPoint => {
+        .sets[0].ops.slice(0, element.points.length)
-        const g = pointRotateRads<GlobalPoint>(
+        .map((op, i) => {
-          pointFrom<GlobalPoint>(element.x + lx, element.y + ly),
+          if (i === 0) {
-          center,
+            const p = pointRotateRads<GlobalPoint>(
-          element.angle,
+              pointFrom<GlobalPoint>(
-        );
+                element.x + op.data[0],
-        return pointFrom<LocalPoint>(g[0] - element.x, g[1] - element.y);
+                element.y + op.data[1],
-      };
+              ),
+              center,
+              element.angle,
+            );
 
-      const collisionOps: Array<{
+            return {
-        op: string;
+              op: "move",
-        data: number[] | LocalPoint;
+              data: pointFrom<LocalPoint>(p[0] - element.x, p[1] - element.y),
-      }> = [];
+            };
-      collisionOps.push({
-        op: "move",
-        data: rotateLocal(points[0][0], points[0][1]),
-      });
-
-      if (points.length === 2) {
-        collisionOps.push({
-          op: "lineTo",
-          data: rotateLocal(points[1][0], points[1][1]),
-        });
-      } else {
-        // Chord-length C2 spline. Mirrors generateRoundedSimpleArrowShape
-        // exactly so hit-testing matches rendering.
-        const n = points.length - 1;
-        const h = new Float64Array(n);
-        for (let i = 0; i < n; i++) {
-          h[i] = Math.max(
-            1e-10,
-            Math.hypot(
-              points[i + 1][0] - points[i][0],
-              points[i + 1][1] - points[i][1],
-            ),
-          );
-        }
-
-        const mx = new Float64Array(n + 1);
-        const my = new Float64Array(n + 1);
-        const diag = new Float64Array(n + 1);
-        const rhsX = new Float64Array(n + 1);
-        const rhsY = new Float64Array(n + 1);
-
-        diag[0] = 2;
-        rhsX[0] = (3 * (points[1][0] - points[0][0])) / h[0];
-        rhsY[0] = (3 * (points[1][1] - points[0][1])) / h[0];
-        for (let i = 1; i < n; i++) {
-          diag[i] = 2 * (h[i - 1] + h[i]);
-          rhsX[i] =
-            3 *
-            ((h[i] * (points[i][0] - points[i - 1][0])) / h[i - 1] +
-              (h[i - 1] * (points[i + 1][0] - points[i][0])) / h[i]);
-          rhsY[i] =
-            3 *
-            ((h[i] * (points[i][1] - points[i - 1][1])) / h[i - 1] +
-              (h[i - 1] * (points[i + 1][1] - points[i][1])) / h[i]);
-        }
-        diag[n] = 2;
-        rhsX[n] = (3 * (points[n][0] - points[n - 1][0])) / h[n - 1];
-        rhsY[n] = (3 * (points[n][1] - points[n - 1][1])) / h[n - 1];
-
-        for (let i = 1; i <= n; i++) {
-          const sub = i < n ? h[i] : 1;
-          const supPrev = i === 1 ? 1 : h[i - 2];
-          const w = sub / diag[i - 1];
-          diag[i] -= w * supPrev;
-          rhsX[i] -= w * rhsX[i - 1];
-          rhsY[i] -= w * rhsY[i - 1];
-        }
-        mx[n] = rhsX[n] / diag[n];
-        my[n] = rhsY[n] / diag[n];
-        for (let i = n - 1; i >= 0; i--) {
-          const sup = i === 0 ? 1 : h[i - 1];
-          mx[i] = (rhsX[i] - sup * mx[i + 1]) / diag[i];
-          my[i] = (rhsY[i] - sup * my[i + 1]) / diag[i];
-        }
-
-        // Normalised tangent directions; handle length scales sub-linearly with chord.
-        const mlen = new Float64Array(n + 1);
-        for (let i = 0; i <= n; i++) {
-          mlen[i] = Math.max(1e-10, Math.hypot(mx[i], my[i]));
-        }
-
-        // At interior knots, blend the C2 tangent direction toward the
-        // bisector direction by a factor proportional to turn sharpness *
-        // CP_ANGLE_CORRECTION
-        for (let k = 1; k < n; k++) {
-          const d1x = (points[k][0] - points[k - 1][0]) / h[k - 1];
-          const d1y = (points[k][1] - points[k - 1][1]) / h[k - 1];
-          const d2x = (points[k + 1][0] - points[k][0]) / h[k];
-          const d2y = (points[k + 1][1] - points[k][1]) / h[k];
-          const dot = d1x * d2x + d1y * d2y;
-          const t = ((1 - dot) / 2) * CP_ANGLE_CORRECTION;
-          if (t < 1e-6) {
-            continue;
           }
-          const bx = d1x + d2x;
-          const by = d1y + d2y;
-          const blen = Math.hypot(bx, by);
-          if (blen < 1e-10) {
-            continue;
-          }
-          let px = bx / blen;
-          let py = by / blen;
-          const tx = mx[k] / mlen[k];
-          const ty = my[k] / mlen[k];
-          if (tx * px + ty * py < 0) {
-            px = -px;
-            py = -py;
-          }
-          const blendX = tx + t * (px - tx);
-          const blendY = ty + t * (py - ty);
-          const blendLen = Math.max(1e-10, Math.hypot(blendX, blendY));
-          mx[k] = (blendX / blendLen) * mlen[k];
-          my[k] = (blendY / blendLen) * mlen[k];
-        }
 
-        for (let i = 0; i < n; i++) {
+          return {
-          const cpDist = Math.pow(h[i], CP_CHORD_POWER) / 3;
-          const cp1x = points[i][0] + (mx[i] / mlen[i]) * cpDist;
-          const cp1y = points[i][1] + (my[i] / mlen[i]) * cpDist;
-          const cp2x = points[i + 1][0] - (mx[i + 1] / mlen[i + 1]) * cpDist;
-          const cp2y = points[i + 1][1] - (my[i + 1] / mlen[i + 1]) * cpDist;
-
-          const rcp1 = rotateLocal(cp1x, cp1y);
-          const rcp2 = rotateLocal(cp2x, cp2y);
-          const rend = rotateLocal(points[i + 1][0], points[i + 1][1]);
-
-          collisionOps.push({
             op: "bcurveTo",
-            data: [rcp1[0], rcp1[1], rcp2[0], rcp2[1], rend[0], rend[1]],
+            data: [
-          });
+              pointRotateRads(
-        }
+                pointFrom<GlobalPoint>(
-      }
+                  element.x + op.data[0],
-      return collisionOps;
+                  element.y + op.data[1],
+                ),
+                center,
+                element.angle,
+              ),
+              pointRotateRads(
+                pointFrom<GlobalPoint>(
+                  element.x + op.data[2],
+                  element.y + op.data[3],
+                ),
+                center,
+                element.angle,
+              ),
+              pointRotateRads(
+                pointFrom<GlobalPoint>(
+                  element.x + op.data[4],
+                  element.y + op.data[5],
+                ),
+                center,
+                element.angle,
+              ),
+            ]
+              .map((p) =>
+                pointFrom<LocalPoint>(p[0] - element.x, p[1] - element.y),
+              )
+              .flat(),
+          };
+        });
     }
     case "freedraw": {
       if (element.points.length < 2) {
@@ -1016,12 +920,7 @@ const _generateElementShape = (
           ];
         }
       } else {
-        shape = [
+        shape = [generator.curve(points as unknown as RoughPoint[], options)];
-          generator.path(
-            generateRoundedSimpleArrowShape(points),
-            generateRoughOptions(element, true, isDarkMode),
-          ),
-        ];
       }
 
       // add lines only in arrow
@@ -1105,162 +1004,10 @@ const _generateElementShape = (
   }
 };
 
-const generateRoundedSimpleArrowShape = (
-  points: readonly LocalPoint[],
-): string => {
-  if (points.length < 2) {
-    return "";
-  }
-
-  if (points.length === 2) {
-    return `M ${points[0][0]} ${points[0][1]} L ${points[1][0]} ${points[1][1]}`;
-  }
-
-  // Chord-length parameterised C2 natural cubic spline (Thomas's algorithm).
-  //
-  // Unknowns: tangent vectors m[0..n] at each knot (n = number of segments).
-  // Chord lengths h[i] = |K[i+1] − K[i]| act as the parameter intervals so
-  // that tightly-spaced knots don't over-influence distant ones.
-  //
-  //   Row 0:         2·m₀  +           m₁              = 3·(K₁−K₀)/h₀
-  //   Row i:  h[i]·mᵢ₋₁ + 2·(h[i−1]+h[i])·mᵢ + h[i−1]·mᵢ₊₁
-  //                                   = 3·(h[i]·(Kᵢ−Kᵢ₋₁)/h[i−1]
-  //                                      + h[i−1]·(Kᵢ₊₁−Kᵢ)/h[i])  1≤i≤n−1
-  //   Row n:           mₙ₋₁ +  2·mₙ                    = 3·(Kₙ−Kₙ₋₁)/h[n−1]
-  //
-  // Bézier control points from Hermite→Bézier identity:
-  //   cp1ᵢ = Kᵢ   + mᵢ   · h[i] / 3
-  //   cp2ᵢ = Kᵢ₊₁ − mᵢ₊₁ · h[i] / 3
-  const n = points.length - 1; // number of segments
-  const h = new Float64Array(n);
-  for (let i = 0; i < n; i++) {
-    h[i] = Math.max(
-      1e-10,
-      Math.hypot(
-        points[i + 1][0] - points[i][0],
-        points[i + 1][1] - points[i][1],
-      ),
-    );
-  }
-
-  const mx = new Float64Array(n + 1);
-  const my = new Float64Array(n + 1);
-  const diag = new Float64Array(n + 1);
-  const rhsX = new Float64Array(n + 1);
-  const rhsY = new Float64Array(n + 1);
-
-  // Row 0 – natural BC (zero second derivative at start)
-  diag[0] = 2;
-  rhsX[0] = (3 * (points[1][0] - points[0][0])) / h[0];
-  rhsY[0] = (3 * (points[1][1] - points[0][1])) / h[0];
-
-  // Interior rows
-  for (let i = 1; i < n; i++) {
-    diag[i] = 2 * (h[i - 1] + h[i]);
-    rhsX[i] =
-      3 *
-      ((h[i] * (points[i][0] - points[i - 1][0])) / h[i - 1] +
-        (h[i - 1] * (points[i + 1][0] - points[i][0])) / h[i]);
-    rhsY[i] =
-      3 *
-      ((h[i] * (points[i][1] - points[i - 1][1])) / h[i - 1] +
-        (h[i - 1] * (points[i + 1][1] - points[i][1])) / h[i]);
-  }
-
-  // Row n – natural BC (zero second derivative at end)
-  diag[n] = 2;
-  rhsX[n] = (3 * (points[n][0] - points[n - 1][0])) / h[n - 1];
-  rhsY[n] = (3 * (points[n][1] - points[n - 1][1])) / h[n - 1];
-
-  // Forward sweep
-  // sub[i] = h[i] for i=1..n−1, sub[n] = 1
-  // sup[i] = 1 for i=0, h[i−1] for i=1..n−1  (never modified)
-  for (let i = 1; i <= n; i++) {
-    const sub = i < n ? h[i] : 1;
-    const supPrev = i === 1 ? 1 : h[i - 2];
-    const w = sub / diag[i - 1];
-    diag[i] -= w * supPrev;
-    rhsX[i] -= w * rhsX[i - 1];
-    rhsY[i] -= w * rhsY[i - 1];
-  }
-
-  // Back substitution
-  mx[n] = rhsX[n] / diag[n];
-  my[n] = rhsY[n] / diag[n];
-  for (let i = n - 1; i >= 0; i--) {
-    const sup = i === 0 ? 1 : h[i - 1];
-    mx[i] = (rhsX[i] - sup * mx[i + 1]) / diag[i];
-    my[i] = (rhsY[i] - sup * my[i + 1]) / diag[i];
-  }
-
-  // Normalised tangent directions; handle length scales sub-linearly with chord.
-  const mlen = new Float64Array(n + 1);
-  for (let i = 0; i <= n; i++) {
-    mlen[i] = Math.max(1e-10, Math.hypot(mx[i], my[i]));
-  }
-
-  // At interior knots, blend the C2 tangent direction toward the
-  // perpendicular-to-bisector (the perfectly symmetric tangent) by a factor
-  // proportional to turn sharpness × CP_ANGLE_CORRECTION.
-  // Both cp2 (incoming) and cp1 (outgoing) at the knot share the same adjusted
-  // direction, so collinear (aligned) handles are preserved.
-  for (let k = 1; k < n; k++) {
-    const d1x = (points[k][0] - points[k - 1][0]) / h[k - 1];
-    const d1y = (points[k][1] - points[k - 1][1]) / h[k - 1];
-    const d2x = (points[k + 1][0] - points[k][0]) / h[k];
-    const d2y = (points[k + 1][1] - points[k][1]) / h[k];
-    const dot = d1x * d2x + d1y * d2y;
-    // t: 0 = straight, 1 = hairpin
-    const t = ((1 - dot) / 2) * CP_ANGLE_CORRECTION;
-    if (t < 1e-6) {
-      continue;
-    }
-    // Bisector of the two chord directions as the "normal" at the knot.
-    // Its perpendicular is the ideal symmetric tangent direction.
-    const bx = d1x + d2x;
-    const by = d1y + d2y;
-    const blen = Math.hypot(bx, by);
-    if (blen < 1e-10) {
-      continue; // 180° hairpin – bisector undefined, skip
-    }
-    // Blend target: bisector direction (pick sign aligning with current tangent)
-    let px = bx / blen;
-    let py = by / blen;
-    const tx = mx[k] / mlen[k];
-    const ty = my[k] / mlen[k];
-    if (tx * px + ty * py < 0) {
-      px = -px;
-      py = -py;
-    }
-    // Linear blend of unit directions, then renormalize to preserve magnitude.
-    const blendX = tx + t * (px - tx);
-    const blendY = ty + t * (py - ty);
-    const blendLen = Math.max(1e-10, Math.hypot(blendX, blendY));
-    mx[k] = (blendX / blendLen) * mlen[k];
-    my[k] = (blendY / blendLen) * mlen[k];
-  }
-
-  const path: string[] = [`M ${points[0][0]} ${points[0][1]}`];
-  for (let i = 0; i < n; i++) {
-    const cpDist = Math.pow(h[i], CP_CHORD_POWER) / 3;
-    const cp1x = points[i][0] + (mx[i] / mlen[i]) * cpDist;
-    const cp1y = points[i][1] + (my[i] / mlen[i]) * cpDist;
-    const cp2x = points[i + 1][0] - (mx[i + 1] / mlen[i + 1]) * cpDist;
-    const cp2y = points[i + 1][1] - (my[i + 1] / mlen[i + 1]) * cpDist;
-    path.push(
-      `C ${cp1x} ${cp1y} ${cp2x} ${cp2y} ${points[i + 1][0]} ${
-        points[i + 1][1]
-      }`,
-    );
-  }
-
-  return path.join(" ");
-};
-
 const generateElbowArrowShape = (
   points: readonly LocalPoint[],
   radius: number,
-): string => {
+) => {
   const subpoints = [] as [number, number][];
   for (let i = 1; i < points.length - 1; i += 1) {
     const prev = points[i - 1];

packages/element/src/types.ts

@@ -279,7 +279,7 @@ export type ExcalidrawTextElementWithContainer = {
 
 export type FixedPoint = [number, number];
 
-export type BindMode = "inside" | "orbit" | "skip";
+export type BindMode = "fixed" | "orbit" | "skip";
 
 export type FixedPointBinding = {
   elementId: ExcalidrawBindableElement["id"];

packages/element/tests/binding.test.tsx

@@ -72,14 +72,14 @@ describe("binding for simple arrows", () => {
       expect(startBinding.fixedPoint[0]).toBeLessThanOrEqual(1);
       expect(startBinding.fixedPoint[1]).toBeGreaterThanOrEqual(0);
       expect(startBinding.fixedPoint[1]).toBeLessThanOrEqual(1);
-      expect(startBinding.mode).toBe("inside");
+      expect(startBinding.mode).toBe("fixed");
 
       const endBinding = arrow.endBinding as FixedPointBinding;
       expect(endBinding.fixedPoint[0]).toBeGreaterThanOrEqual(0);
       expect(endBinding.fixedPoint[0]).toBeLessThanOrEqual(1);
       expect(endBinding.fixedPoint[1]).toBeGreaterThanOrEqual(0);
       expect(endBinding.fixedPoint[1]).toBeLessThanOrEqual(1);
-      expect(endBinding.mode).toBe("inside");
+      expect(endBinding.mode).toBe("fixed");
 
       // Move the bindable
       mouse.downAt(100, 150);

packages/element/tests/bounds.test.ts

@@ -135,9 +135,9 @@ describe("getElementBounds", () => {
     } as ExcalidrawLinearElement;
 
     const [x1, y1, x2, y2] = getElementBounds(element, arrayToMap([element]));
-    expect(x1).toEqual(366.0476290709661);
+    expect(x1).toEqual(360.9291017525165);
-    expect(y1).toEqual(186.59818534770224);
+    expect(y1).toEqual(185.24770129343722);
-    expect(x2).toEqual(494.6034220048372);
+    expect(x2).toEqual(481.4815539037601);
-    expect(y2).toEqual(324.16489799221546);
+    expect(y2).toEqual(319.8162855827246);
   });
 });

packages/element/tests/collision.test.tsx

@@ -30,7 +30,7 @@ describe("check rotated elements can be hit:", () => {
       ] as LocalPoint[],
     });
     const hit = hitElementItself({
-      point: pointFrom<GlobalPoint>(90, -70),
+      point: pointFrom<GlobalPoint>(88, -68),
       element: window.h.elements[0],
       threshold: 10,
       elementsMap: window.h.scene.getNonDeletedElementsMap(),

packages/element/tests/linearElementEditor.test.tsx

@@ -434,12 +434,12 @@ describe("Test Linear Elements", () => {
       expect(midPointsWithRoundEdge).toMatchInlineSnapshot(`
         [
           [
-            "51.36383",
+            "54.27552",
-            "54.86323",
+            "46.16120",
           ],
           [
-            "81.64884",
+            "76.95494",
-            "43.04575",
+            "44.56052",
           ],
         ]
       `);
@@ -499,12 +499,12 @@ describe("Test Linear Elements", () => {
       expect(newMidPoints).toMatchInlineSnapshot(`
         [
           [
-            "101.36383",
+            "104.27552",
-            "74.86323",
+            "66.16120",
           ],
           [
-            "131.64884",
+            "126.95494",
-            "63.04575",
+            "64.56052",
           ],
         ]
       `);
@@ -707,8 +707,14 @@ describe("Test Linear Elements", () => {
       // This is the expected midpoint for line with round edge
       // hence hardcoding it so if later some bug is introduced
       // this will fail and we can fix it
-      const firstSegmentMidpoint = pointFrom<GlobalPoint>(47.30521, 57.2734);
+      const firstSegmentMidpoint = pointFrom<GlobalPoint>(
-      const lastSegmentMidpoint = pointFrom<GlobalPoint>(83.70877, 40.46424);
+        55.9697848965255,
+        47.442326230998205,
+      );
+      const lastSegmentMidpoint = pointFrom<GlobalPoint>(
+        76.08587175006699,
+        43.294165939653226,
+      );
       let line: ExcalidrawLinearElement;
 
       beforeEach(() => {
@@ -753,16 +759,16 @@ describe("Test Linear Elements", () => {
                 0,
               ],
               [
-                "77.30521",
+                "85.96978",
-                "87.27340",
+                "77.44233",
               ],
               [
                 70,
                 50,
               ],
               [
-                "113.70877",
+                "106.08587",
-                "70.46424",
+                "73.29417",
               ],
               [
                 40,
@@ -809,12 +815,12 @@ describe("Test Linear Elements", () => {
         expect(newMidPoints).toMatchInlineSnapshot(`
           [
             [
-              "22.32088",
+              "29.28349",
-              "37.43003",
+              "20.91105",
             ],
             [
-              "81.55727",
+              "78.86048",
-              "43.21091",
+              "46.12277",
             ],
           ]
         `);
@@ -898,12 +904,12 @@ describe("Test Linear Elements", () => {
         expect(newMidPoints).toMatchInlineSnapshot(`
           [
             [
-              "51.36383",
+              "54.27552",
-              "54.86323",
+              "46.16120",
             ],
             [
-              "81.64884",
+              "76.95494",
-              "43.04575",
+              "44.56052",
             ],
           ]
         `);
@@ -1065,8 +1071,8 @@ describe("Test Linear Elements", () => {
         );
         expect(position).toMatchInlineSnapshot(`
           {
-            "x": "86.53100",
+            "x": "86.17305",
-            "y": "72.83556",
+            "y": "76.11251",
           }
         `);
       });
@@ -1185,8 +1191,8 @@ describe("Test Linear Elements", () => {
           20,
           105,
           80,
-          "56.68277",
+          "55.45894",
-          "47.27188",
+          45,
         ]
       `);
 
@@ -1196,7 +1202,7 @@ describe("Test Linear Elements", () => {
         .toMatchInlineSnapshot(`
           {
             "height": 130,
-            "width": "368.53316",
+            "width": "366.11716",
           }
         `);
 
@@ -1208,7 +1214,7 @@ describe("Test Linear Elements", () => {
         ),
       ).toMatchInlineSnapshot(`
         {
-          "x": "273.53316",
+          "x": "271.11716",
           "y": 45,
         }
       `);
@@ -1225,10 +1231,10 @@ describe("Test Linear Elements", () => {
         [
           20,
           35,
-          "503.53316",
+          "501.11716",
-          "119.02540",
+          95,
-          "204.47758",
+          "205.45894",
-          "77.01270",
+          "52.50000",
         ]
       `);
     });

packages/excalidraw/actions/actionProperties.tsx

@@ -1940,7 +1940,7 @@ export const actionChangeArrowType = register<keyof typeof ARROW_TYPE>({
             bindBindingElement(
               newElement,
               startElement,
-              appState.bindMode === "inside" ? "inside" : "orbit",
+              appState.bindMode === "fixed" ? "fixed" : "orbit",
               "start",
               app.scene,
             );
@@ -1954,7 +1954,7 @@ export const actionChangeArrowType = register<keyof typeof ARROW_TYPE>({
             bindBindingElement(
               newElement,
               endElement,
-              appState.bindMode === "inside" ? "inside" : "orbit",
+              appState.bindMode === "fixed" ? "fixed" : "orbit",
               "end",
               app.scene,
             );

packages/excalidraw/components/App.tsx

@@ -1095,7 +1095,7 @@ class App extends React.Component<AppProps, AppState> {
           );
 
           this.setState({
-            bindMode: "inside",
+            bindMode: "fixed",
             selectedLinearElement: {
               ...this.state.selectedLinearElement,
               initialState: {
@@ -1176,16 +1176,16 @@ class App extends React.Component<AppProps, AppState> {
       : null;
     const isAlreadyInsideBindingToSameElement =
       (otherBinding &&
-        arrow[otherBinding]?.mode === "inside" &&
+        arrow[otherBinding]?.mode === "fixed" &&
         arrow[otherBinding]?.elementId === hoveredElement?.id) ||
       (currentBinding &&
-        arrow[currentBinding]?.mode === "inside" &&
+        arrow[currentBinding]?.mode === "fixed" &&
         hoveredElement?.id === arrow[currentBinding]?.elementId);
 
     if (
       currentBinding &&
       otherBinding &&
-      arrow[currentBinding]?.mode === "inside" &&
+      arrow[currentBinding]?.mode === "fixed" &&
       hoveredElement?.id !== arrow[currentBinding]?.elementId &&
       arrow[otherBinding]?.elementId !== arrow[currentBinding]?.elementId
     ) {
@@ -1217,7 +1217,7 @@ class App extends React.Component<AppProps, AppState> {
       }
 
       // Clear the inside binding mode too
-      if (this.state.bindMode === "inside") {
+      if (this.state.bindMode === "fixed") {
         flushSync(() => {
           this.setState({
             bindMode: "orbit",

packages/excalidraw/data/restore.ts

@@ -239,8 +239,8 @@ const repairBinding = <T extends ExcalidrawArrowElement>(
       if (binding.elementId) {
         return {
           elementId: binding.elementId,
-          mode: binding.mode,
+          mode: (binding.mode as string) === "inside" ? "fixed" : binding.mode,
-          fixedPoint: normalizeFixedPoint(binding.fixedPoint),
+          fixedPoint: normalizeFixedPoint(binding.fixedPoint || [0.5, 0.5]),
         } as FixedPointBinding | null;
       }
       return null;
@@ -269,7 +269,7 @@ const repairBinding = <T extends ExcalidrawArrowElement>(
         elementsMap,
       );
       const mode = isPointInElement(p, boundElement, elementsMap)
-        ? "inside"
+        ? "fixed"
         : "orbit";
       const safeElement = {
         ...element,
@@ -289,7 +289,7 @@ const repairBinding = <T extends ExcalidrawArrowElement>(
           : null,
       };
       const focusPoint =
-        mode === "inside"
+        mode === "fixed"
           ? p
           : projectFixedPointOntoDiagonal(
               safeElement,

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

@@ -857,7 +857,7 @@ describe("repairing bindings", () => {
       endBinding: {
         elementId: container.id,
         fixedPoint: [0.5, 0.5],
-        mode: "inside",
+        mode: "fixed",
       },
     });
 

packages/utils/src/shape.ts

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