Merge branch 'master' into mtolmacs/fix/z-ordering

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

packages/common/src/colors.ts

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

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

packages/element/src/renderElement.ts

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

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<
@@ -230,9 +218,7 @@ export const generateRoughOptions = (
     fillWeight: element.strokeWidth / 2,
     hachureGap: element.strokeWidth * 4,
     roughness: adjustRoughness(element),
-    stroke: isDarkMode
+    stroke: applyDarkModeFilter(element.strokeColor, isDarkMode),
-      ? applyDarkModeFilter(element.strokeColor)
-      : element.strokeColor,
     preserveVertices:
       continuousPath || element.roughness < ROUGHNESS.cartoonist,
   };
@@ -246,9 +232,7 @@ export const generateRoughOptions = (
       options.fillStyle = element.fillStyle;
       options.fill = isTransparent(element.backgroundColor)
         ? undefined
-        : isDarkMode
+        : applyDarkModeFilter(element.backgroundColor, isDarkMode);
-        ? applyDarkModeFilter(element.backgroundColor)
-        : element.backgroundColor;
       if (element.type === "ellipse") {
         options.curveFitting = 1;
       }
@@ -261,9 +245,7 @@ export const generateRoughOptions = (
         options.fill =
           element.backgroundColor === "transparent"
             ? undefined
-            : isDarkMode
+            : applyDarkModeFilter(element.backgroundColor, isDarkMode);
-            ? applyDarkModeFilter(element.backgroundColor)
-            : element.backgroundColor;
       }
       return options;
     }
@@ -398,12 +380,11 @@ const getArrowheadShapes = (
     return [];
   }
 
-  const strokeColor = isDarkMode
+  const strokeColor = applyDarkModeFilter(element.strokeColor, isDarkMode);
-    ? applyDarkModeFilter(element.strokeColor)
+  const backgroundFillColor = applyDarkModeFilter(
-    : element.strokeColor;
+    canvasBackgroundColor,
-  const backgroundFillColor = isDarkMode
+    isDarkMode,
-    ? applyDarkModeFilter(canvasBackgroundColor)
+  );
-    : canvasBackgroundColor;
   const cardinalityOneOrManyOffset = -0.25;
   const cardinalityZeroCircleScale = 0.8;
 
@@ -637,144 +618,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 +913,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 +997,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/zindex.ts

@@ -409,8 +409,10 @@ const shiftElementsToEnd = (
   let trailingIndex: number;
   if (direction === "left") {
     if (containingFrame) {
-      leadingIndex = findIndex(elements, (el) =>
+      leadingIndex = findIndex(
-        isOfTargetFrame(el, containingFrame),
+        elements,
+        (el) =>
+          el.id !== containingFrame && isOfTargetFrame(el, containingFrame),
       );
     } else if (appState.editingGroupId) {
       const groupElements = getElementsInGroup(
@@ -428,8 +430,10 @@ const shiftElementsToEnd = (
     trailingIndex = indicesToMove[indicesToMove.length - 1];
   } else {
     if (containingFrame) {
-      trailingIndex = findLastIndex(elements, (el) =>
+      trailingIndex = findLastIndex(
-        isOfTargetFrame(el, containingFrame),
+        elements,
+        (el) =>
+          el.id !== containingFrame && isOfTargetFrame(el, containingFrame),
       );
     } else if (appState.editingGroupId) {
       const groupElements = getElementsInGroup(
@@ -499,10 +503,7 @@ function shiftElementsAccountingForFrames(
     }),
   );
 
-  const frameAwareContiguousElementsToMove: {
+  const regularElements: ExcalidrawElement[] = [];
-    regularElements: ExcalidrawElement[];
-    frameChildren: Map<ExcalidrawFrameLikeElement["id"], ExcalidrawElement[]>;
-  } = { regularElements: [], frameChildren: new Map() };
 
   const fullySelectedFrames = new Set<ExcalidrawFrameLikeElement["id"]>();
 
@@ -512,51 +513,33 @@ function shiftElementsAccountingForFrames(
     }
   }
 
+  const selectedFrameIds = new Set<ExcalidrawFrameLikeElement["id"]>();
+
   for (const element of allElements) {
     if (elementsToMove.has(element.id)) {
       if (
         isFrameLikeElement(element) ||
         (element.frameId && fullySelectedFrames.has(element.frameId))
       ) {
-        frameAwareContiguousElementsToMove.regularElements.push(element);
+        regularElements.push(element);
       } else if (!element.frameId) {
-        frameAwareContiguousElementsToMove.regularElements.push(element);
+        regularElements.push(element);
-      } else {
+      } else if (!selectedFrameIds.has(element.frameId)) {
-        const frameChildren =
+        selectedFrameIds.add(element.frameId);
-          frameAwareContiguousElementsToMove.frameChildren.get(
+        regularElements.push(element);
-            element.frameId,
-          ) || [];
-        frameChildren.push(element);
-        frameAwareContiguousElementsToMove.frameChildren.set(
-          element.frameId,
-          frameChildren,
-        );
       }
     }
   }
 
-  let nextElements = allElements;
+  const containingFrame =
-
+    selectedFrameIds.size > 0 ? [...selectedFrameIds][0] : null;
-  const frameChildrenSets = Array.from(
-    frameAwareContiguousElementsToMove.frameChildren.entries(),
-  );
-
-  for (const [frameId, children] of frameChildrenSets) {
-    nextElements = shiftFunction(
-      allElements,
-      appState,
-      direction,
-      frameId,
-      children,
-    );
-  }
 
   return shiftFunction(
-    nextElements,
+    allElements,
     appState,
     direction,
-    null,
+    containingFrame,
-    frameAwareContiguousElementsToMove.regularElements,
+    regularElements,
   );
 }
 

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

@@ -1995,9 +1995,10 @@ class App extends React.Component<AppProps, AppState> {
               }
             }}
             style={{
-              background: isDarkTheme
+              background: applyDarkModeFilter(
-                ? applyDarkModeFilter(this.state.viewBackgroundColor)
+                this.state.viewBackgroundColor,
-                : this.state.viewBackgroundColor,
+                isDarkTheme,
+              ),
               zIndex: 2,
               border: "none",
               display: "block",

packages/excalidraw/index.tsx

@@ -7,6 +7,7 @@ import React, {
 } from "react";
 
 import {
+  applyDarkModeFilter,
   DEFAULT_IMAGE_OPTIONS,
   DEFAULT_UI_OPTIONS,
   isShallowEqual,
@@ -450,3 +451,5 @@ export function useExcalidrawStateValue(
 // -----------------------------------------------------------------------------
 
 export { _useOnAppStateChange as useOnExcalidrawStateChange };
+
+export { applyDarkModeFilter };

packages/excalidraw/renderer/helpers.ts

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

packages/excalidraw/renderer/staticSvgScene.ts

@@ -386,9 +386,10 @@ const renderElementToSvg = (
           const path = svgRoot.ownerDocument.createElementNS(SVG_NS, "path");
           path.setAttribute(
             "fill",
-            renderConfig.theme === THEME.DARK
+            applyDarkModeFilter(
-              ? applyDarkModeFilter(element.strokeColor)
+              element.strokeColor,
-              : element.strokeColor,
+              renderConfig.theme === THEME.DARK,
+            ),
           );
           path.setAttribute("d", shape);
           wrapper.appendChild(path);
@@ -621,9 +622,10 @@ const renderElementToSvg = (
         rect.setAttribute("fill", "none");
         rect.setAttribute(
           "stroke",
-          renderConfig.theme === THEME.DARK
+          applyDarkModeFilter(
-            ? applyDarkModeFilter(FRAME_STYLE.strokeColor)
+            FRAME_STYLE.strokeColor,
-            : FRAME_STYLE.strokeColor,
+            renderConfig.theme === THEME.DARK,
+          ),
         );
         rect.setAttribute("stroke-width", FRAME_STYLE.strokeWidth.toString());
 
@@ -677,9 +679,10 @@ const renderElementToSvg = (
           text.setAttribute("font-size", `${element.fontSize}px`);
           text.setAttribute(
             "fill",
-            renderConfig.theme === THEME.DARK
+            applyDarkModeFilter(
-              ? applyDarkModeFilter(element.strokeColor)
+              element.strokeColor,
-              : element.strokeColor,
+              renderConfig.theme === THEME.DARK,
+            ),
           );
           text.setAttribute("text-anchor", textAnchor);
           text.setAttribute("style", "white-space: pre;");

packages/excalidraw/scene/export.ts

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

packages/excalidraw/wysiwyg/textWysiwyg.tsx

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

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]));
+      }
     }
   }