Virtual whiteboard for sketching hand-drawn like diagrams
fix(editor): Freedraw hit test precision (#11550)
Márk Tolmács2b9da9610083
diff --git a/packages/element/src/collision.ts b/packages/element/src/collision.tsindex 68ff96a08e..7fe6e1f9df 100644--- a/packages/element/src/collision.ts+++ b/packages/element/src/collision.ts@@ -8,6 +8,7 @@ import {pointFromVector,pointRotateRads,pointsEqual,+ polygonIncludesPoint,vectorFromPoint,vectorNormalize,vectorScale,@@ -22,6 +23,7 @@ import type {Curve,GlobalPoint,LineSegment,+ LocalPoint,Radians,} from "@excalidraw/math";@@ -63,6 +65,8 @@ import { getBindingGap } from "./binding";import { hasBackground } from "./comparisons";+import { getFreedrawFillPolygon, getFreedrawMaxStrokeRadius } from "./shape";+import type {ElementsMap,ExcalidrawArrowElement,@@ -177,7 +181,10 @@ export const hitElementItself = ({point,bounds,element.angle,- threshold,+ // Freedraw bounds follow the centerline points, but the ink extends past them+ isFreeDrawElement(element)+ ? threshold + getFreedrawMaxStrokeRadius(element)+ : threshold,);// PERF: Bail out early if the point is not even in the@@ -785,6 +792,26 @@ export const isPointInElement = (return false;}+ if (isFreeDrawElement(element)) {+ // Test before the rotated-bounds check below: the smoothed fill can bulge+ // past the recorded points, and how much of it those bounds would clip+ // depends on the angle. An asymmetric loop's rotated bounds center is also+ // not its rotation pivot.+ const [x1, y1, x2, y2] = getElementBounds(element, elementsMap, true);+ const [px, py] = pointRotateRads(+ point,+ pointFrom<GlobalPoint>((x1 + x2) / 2, (y1 + y2) / 2),+ -element.angle as Radians,+ );++ // The fill follows the centerline rather than the stroke outline, and uses+ // the same even-odd rule as RoughJS's filled curves.+ return polygonIncludesPoint(+ pointFrom<LocalPoint>(px - element.x, py - element.y),+ getFreedrawFillPolygon(element),+ );+ }+const [x1, y1, x2, y2] = getElementBounds(element, elementsMap);if (!isPointWithinBounds(pointFrom(x1, y1), point, pointFrom(x2, y2))) {diff --git a/packages/element/src/distance.ts b/packages/element/src/distance.tsindex b7fc11e953..1206569c3e 100644--- a/packages/element/src/distance.ts+++ b/packages/element/src/distance.ts@@ -2,6 +2,7 @@ import {curvePointDistance,distanceToLineSegment,pointRotateRads,+ polygonIncludesPointNonZero,} from "@excalidraw/math";import { ellipse, ellipseDistanceFromPoint } from "@excalidraw/math/ellipse";@@ -48,8 +49,9 @@ export const distanceToElement = (return distanceToEllipseElement(element, elementsMap, p);case "line":case "arrow":- case "freedraw":return distanceToLinearOrFreeDraElement(element, elementsMap, p);+ case "freedraw":+ return distanceToFreeDrawElement(element, elementsMap, p);}};@@ -142,3 +144,30 @@ const distanceToLinearOrFreeDraElement = (...curves.map((a) => curvePointDistance(a, p)),);};++/**+ * Returns the distance of a point to a freedraw element.+ *+ * @param element The freedraw element+ * @param p The point to consider+ * @returns 0 if the point is within the inked area, otherwise the euclidean+ * distance to the stroke outline+ */+const distanceToFreeDrawElement = (+ element: ExcalidrawFreeDrawElement,+ elementsMap: ElementsMap,+ p: GlobalPoint,+) => {+ const [lines] = deconstructLinearOrFreeDrawElement(element, elementsMap);++ if (lines.length === 0) {+ return Infinity;+ }++ const polygon = lines.map((line) => line[0]);+ if (polygonIncludesPointNonZero(p, polygon)) {+ return 0;+ }++ return Math.min(...lines.map((s) => distanceToLineSegment(p, s)));+};diff --git a/packages/element/src/shape.ts b/packages/element/src/shape.tsindex 7b905b4e07..bf699b5b3c 100644--- a/packages/element/src/shape.ts+++ b/packages/element/src/shape.ts@@ -1,4 +1,4 @@-import { simplify } from "points-on-curve";+import { pointsOnBezierCurves, simplify } from "points-on-curve";import { getStroke, getStrokePoints } from "perfect-freehand";import { LaserPointer } from "@excalidraw/laser-pointer";@@ -16,6 +16,7 @@ import {pointDistance,type LocalPoint,pointRotateRads,+ polygonFromPoints,} from "@excalidraw/math";import {ROUGHNESS,@@ -30,7 +31,7 @@ import {import { RoughGenerator } from "roughjs/bin/generator";-import type { GlobalPoint } from "@excalidraw/math";+import type { GlobalPoint, Polygon } from "@excalidraw/math";import type { Mutable } from "@excalidraw/common/utility-types";@@ -575,6 +576,48 @@ const getArrowheadShapes = (}};+/** The simplified centerline the freedraw fill is drawn along. */+const getFreedrawFillCurvePoints = (element: ExcalidrawFreeDrawElement) =>+ simplify(element.points as Mutable<LocalPoint[]>, 0.75) as [number, number][];++const freedrawFillPolygonCache = new WeakMap<+ ExcalidrawFreeDrawElement,+ { version: number; polygon: Polygon<LocalPoint> }+>();++/**+ * Returns the flattened fill contour of a freedraw loop in local, unrotated+ * coordinates, following the rendered fill rather than the stroke outline.+ */+export const getFreedrawFillPolygon = (element: ExcalidrawFreeDrawElement) => {+ const cached = freedrawFillPolygonCache.get(element);+ if (cached?.version === element.version) {+ return cached.polygon;+ }++ // Same curve as the rendered fill, without roughness jitter. RoughJS also+ // handles inputs simplified to two points.+ const ops = new RoughGenerator().curve(getFreedrawFillCurvePoints(element), {+ roughness: 0,+ disableMultiStroke: true,+ }).sets[0].ops;+ const bezierPoints: LocalPoint[] = [];+ // A single curve pass consists of a move followed by cubic control points.+ for (const { data } of ops) {+ for (let i = 0; i < data.length; i += 2) {+ bezierPoints.push(pointFrom<LocalPoint>(data[i], data[i + 1]));+ }+ }++ // Omit the optional distance argument to avoid simplifying the boundary again.+ const polygon = polygonFromPoints(+ pointsOnBezierCurves(bezierPoints, 0.5) as LocalPoint[],+ );+ freedrawFillPolygonCache.set(element, { version: element.version, polygon });++ return polygon;+};+export const generateLinearCollisionShape = (element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement,elementsMap: ElementsMap,@@ -675,69 +718,44 @@ export const generateLinearCollisionShape = (});}case "freedraw": {- if (element.points.length < 2) {+ const outlinePoints = getFreedrawOutlinePoints(element);++ if (outlinePoints.length < 2) {return [];}- const simplifiedPoints = simplify(- element.points as Mutable<LocalPoint[]>,- 0.75,- );+ const collisionOutline =+ element.strokeOptions?.variability === "constant"+ ? (simplify(+ outlinePoints as Mutable<LocalPoint[]>,+ CONSTANT_WIDTH_FREEDRAW.COLLISION_SIMPLIFY_TOLERANCE,+ ) as [number, number][])+ : outlinePoints;- return generator- .curve(simplifiedPoints as [number, number][], options)- .sets[0].ops.slice(0, element.points.length)- .map((op, i) => {- if (i === 0) {- const p = pointRotateRads<GlobalPoint>(- pointFrom<GlobalPoint>(- element.x + op.data[0],- element.y + op.data[1],- ),- center,- element.angle,- );+ if (collisionOutline.length < 2) {+ return [];+ }- return {- op: "move",- data: pointFrom<LocalPoint>(p[0] - element.x, p[1] - element.y),- };- }+ // Close the outline polygon so its boundary never has a gap at the seam.+ const [firstX, firstY] = collisionOutline[0];+ const [lastX, lastY] = collisionOutline[collisionOutline.length - 1];+ const closedOutline =+ firstX === lastX && firstY === lastY+ ? collisionOutline+ : [...collisionOutline, collisionOutline[0]];++ return closedOutline.map((point, idx) => {+ const p = pointRotateRads<GlobalPoint>(+ pointFrom<GlobalPoint>(element.x + point[0], element.y + point[1]),+ center,+ element.angle,+ );- return {- op: "bcurveTo",- data: [- pointRotateRads(- pointFrom<GlobalPoint>(- element.x + op.data[0],- 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(),- };- });+ return {+ op: idx === 0 ? "move" : "lineTo",+ data: pointFrom<LocalPoint>(p[0] - element.x, p[1] - element.y),+ };+ });}}};@@ -962,12 +980,8 @@ const _generateElementShape = (// (1) background fill (rc shape), optionalif (isPathALoop(element.points)) {// generate rough polygon to fill freedraw shape- const simplifiedPoints = simplify(- element.points as Mutable<LocalPoint[]>,- 0.75,- );shapes.push(- generator.curve(simplifiedPoints as [number, number][], {+ generator.curve(getFreedrawFillCurvePoints(element), {...generateRoughOptions(element, false, isDarkMode),stroke: "none",}),@@ -1193,6 +1207,11 @@ const VARIABLE_WIDTH_FREEDRAW = {const CONSTANT_WIDTH_FREEDRAW = {/** Stroke size relative to `strokeWidth` for uniform (laser) strokes. */SIZE_FACTOR: 1.4,+ /**+ * Max deviation (px) when dropping vertices of the dense laser outline for+ * collision. Perfect-freehand outlines are already thinned by `smoothing`.+ */+ COLLISION_SIMPLIFY_TOLERANCE: 0.2,} as const;const getFreedrawStreamline = (element: ExcalidrawFreeDrawElement) =>@@ -1257,6 +1276,21 @@ export const getFreedrawOutlinePoints = (: getVariableWidthFreedrawOutline(element);};+/**+ * Upper bound on how far a freedraw stroke's ink reaches past its centerline+ * points. Both stroke generators scale the stroke size by at most 1 (easing+ * or pressure), so the size itself bounds the radius, except for+ * perfect-freehand's short strokes: under 3px long, the start cap is drawn+ * around the first point from an outline point of the last one (reaching+ * sqrt(size² + 3²)), and a single point gets a synthetic neighbor 1px away.+ */+export const getFreedrawMaxStrokeRadius = (+ element: ExcalidrawFreeDrawElement,+) =>+ element.strokeOptions?.variability === "constant"+ ? element.strokeWidth * CONSTANT_WIDTH_FREEDRAW.SIZE_FACTOR+ : element.strokeWidth * VARIABLE_WIDTH_FREEDRAW.SIZE_FACTOR + 3;+/*** The streamline-smoothed centerline the freedraw stroke is rendered* around, in element-local coordinates. Boundary-sensitive consumers (e.g.diff --git a/packages/element/tests/collision.test.tsx b/packages/element/tests/collision.test.tsxindex a44f1f7bb0..d2f303ef1e 100644--- a/packages/element/tests/collision.test.tsx+++ b/packages/element/tests/collision.test.tsx@@ -1,5 +1,10 @@-import { arrayToMap, reseed } from "@excalidraw/common";-import { type GlobalPoint, type LocalPoint, pointFrom } from "@excalidraw/math";+import { arrayToMap, getSizeFromPoints, reseed } from "@excalidraw/common";+import {+ type GlobalPoint,+ type LocalPoint,+ pointFrom,+ pointRotateRads,+} from "@excalidraw/math";import { Excalidraw } from "@excalidraw/excalidraw";import { API } from "@excalidraw/excalidraw/tests/helpers/api";import { UI } from "@excalidraw/excalidraw/tests/helpers/ui";@@ -7,7 +12,10 @@ import "@excalidraw/utils/test-utils";import { render } from "@excalidraw/excalidraw/tests/test-utils";import * as distance from "../src/distance";-import { hitElementItself } from "../src/collision";+import { getElementBounds } from "../src/bounds";+import { hitElementItself, isPointInElement } from "../src/collision";+import { mutateElement } from "../src/mutateElement";+import { newFreeDrawElement } from "../src/newElement";describe("check rotated elements can be hit:", () => {beforeEach(async () => {@@ -218,3 +226,397 @@ describe("hitElementItself cache", () => {).toBe(true);});});++describe("freedraw collision matches the rendered stroke width", () => {+ // A straight, horizontal stroke centered on y === 0.+ const points = Array.from({ length: 21 }, (_, i) =>+ pointFrom<LocalPoint>(i * 5, 0),+ );++ const createFreeDraw = (variability: "variable" | "constant") =>+ API.createElement({+ type: "freedraw",+ x: 0,+ y: 0,+ strokeWidth: 10,+ points,+ strokeOptions: { variability, streamline: 0.5 },+ });++ const distanceAt = (+ element: ReturnType<typeof createFreeDraw>,+ x: number,+ y: number,+ ) =>+ distance.distanceToElement(+ element,+ arrayToMap([element]),+ pointFrom<GlobalPoint>(x, y),+ );++ it("treats a point on the centerline as a direct hit for both modes", () => {+ expect(distanceAt(createFreeDraw("variable"), 50, 0)).toBe(0);+ expect(distanceAt(createFreeDraw("constant"), 50, 0)).toBe(0);+ });++ it("hits across the body of a thick stroke, not just near the centerline", () => {+ expect(distanceAt(createFreeDraw("variable"), 50, 20)).toBe(0);+ });++ it("uses a wider hit area for variable-width than for constant-width strokes", () => {+ const offset = 20;+ const variableDistance = distanceAt(createFreeDraw("variable"), 50, offset);+ const constantDistance = distanceAt(createFreeDraw("constant"), 50, offset);++ expect(variableDistance).toBe(0);+ expect(constantDistance).toBeGreaterThan(0);+ expect(variableDistance).toBeLessThan(constantDistance);+ });++ it("does not hit points clearly outside even the widest stroke", () => {+ expect(distanceAt(createFreeDraw("variable"), 50, 45)).toBeGreaterThan(0);+ });++ it("hits thick ink outside the centerline bounds", () => {+ const hitAt = (+ element: ReturnType<typeof createFreeDraw>,+ x: number,+ y: number,+ ) =>+ hitElementItself({+ element,+ elementsMap: arrayToMap([element]),+ point: pointFrom<GlobalPoint>(x, y),+ threshold: 1,+ });++ // The centerline bounds have zero height, far below the ink's reach.+ expect(hitAt(createFreeDraw("variable"), 50, 20)).toBe(true);+ expect(hitAt(createFreeDraw("variable"), 50, -20)).toBe(true);+ expect(hitAt(createFreeDraw("constant"), 50, 10)).toBe(true);+ expect(hitAt(createFreeDraw("constant"), 50, 20)).toBe(false);+ expect(hitAt(createFreeDraw("variable"), 50, 45)).toBe(false);+ });++ it("hits the start cap of a short stroke reaching past its stroke size", () => {+ // Under 3px long, perfect-freehand draws the start cap around the first+ // point from the last point's outline, reaching past the stroke size.+ const element = newFreeDrawElement({+ type: "freedraw",+ x: 0,+ y: 0,+ strokeWidth: 1,+ simulatePressure: false,+ pressures: [1, 1, 1],+ points: [+ pointFrom<LocalPoint>(0, 0),+ pointFrom<LocalPoint>(0.01, 0),+ pointFrom<LocalPoint>(2.9, 0),+ ],+ strokeOptions: { variability: "variable", streamline: 0.5 },+ });+ const elementsMap = arrayToMap([element]);+ const point = pointFrom<GlobalPoint>(0.1, 4.9);++ expect(distance.distanceToElement(element, elementsMap, point)).toBe(0);+ // The hit threshold at 30x zoom.+ expect(+ hitElementItself({ element, elementsMap, point, threshold: 0.6 }),+ ).toBe(true);+ });+});++const createLoop = ({+ angle = 0,+ backgroundColor = "#ffc9c9",+ variability = "variable",+ points = Array.from({ length: 81 }, (_, i) =>+ pointFrom<LocalPoint>(+ 80 + 80 * Math.cos((i / 80) * 2 * Math.PI),+ 40 + 40 * Math.sin((i / 80) * 2 * Math.PI),+ ),+ ),+}: {+ angle?: number;+ backgroundColor?: string;+ variability?: "variable" | "constant";+ points?: LocalPoint[];+} = {}) =>+ API.createElement({+ type: "freedraw",+ x: 300,+ y: 200,+ ...getSizeFromPoints(points),+ angle,+ strokeWidth: 2,+ backgroundColor,+ fillStyle: "solid",+ points,+ strokeOptions: { variability, streamline: 0.5 },+ });++// The fill contour does not depend on the stroke; only its interplay with the+// stroke geometry is tested per stroke variability.+describe.each(["variable", "constant"] as const)(+ "%s freedraw loop containment",+ (variability) => {+ it.each([0, Math.PI / 4])(+ "hits the fill independently of the stroke at angle %s",+ (angle) => {+ const element = createLoop({ angle, variability });+ const elementsMap = arrayToMap([element]);+ const point = pointRotateRads(+ pointFrom<GlobalPoint>(400, 250),+ pointFrom<GlobalPoint>(380, 240),+ element.angle,+ );++ // Checking the fill must not replace the cached stroke geometry.+ expect(+ distance.distanceToElement(element, elementsMap, point),+ ).toBeGreaterThan(10);+ expect(isPointInElement(point, element, elementsMap)).toBe(true);+ expect(+ hitElementItself({ element, elementsMap, point, threshold: 1 }),+ ).toBe(true);+ expect(+ distance.distanceToElement(element, elementsMap, point),+ ).toBeGreaterThan(10);+ },+ );++ it.each([0, Math.PI / 4])(+ "does not hit the interior of a transparent loop at angle %s",+ (angle) => {+ const element = createLoop({+ angle,+ backgroundColor: "transparent",+ variability,+ });+ const elementsMap = arrayToMap([element]);+ const point = pointRotateRads(+ pointFrom<GlobalPoint>(400, 250),+ pointFrom<GlobalPoint>(380, 240),+ element.angle,+ );++ // Warm the fill cache first; it must not replace the stroke geometry.+ isPointInElement(point, element, elementsMap);+ expect(+ hitElementItself({ element, elementsMap, point, threshold: 1 }),+ ).toBe(false);+ },+ );++ it("does not treat the empty corners of the loop bounds as fill", () => {+ const element = createLoop({ variability });+ const elementsMap = arrayToMap([element]);+ const point = pointFrom<GlobalPoint>(310, 210);++ expect(isPointInElement(point, element, elementsMap)).toBe(false);+ expect(+ hitElementItself({ element, elementsMap, point, threshold: 1 }),+ ).toBe(false);+ });+ },+);++describe("freedraw loop fill containment", () => {+ it.each([0, Math.PI / 4])(+ "hits the center and axes of a loop with curve junctions at angle %s",+ (angle) => {+ const element = createLoop({ angle });+ const elementsMap = arrayToMap([element]);+ const center = pointFrom<GlobalPoint>(380, 240);++ for (const point of [+ center,+ pointFrom<GlobalPoint>(400, 240),+ pointFrom<GlobalPoint>(380, 250),+ ]) {+ expect(+ isPointInElement(+ pointRotateRads(point, center, element.angle),+ element,+ elementsMap,+ ),+ ).toBe(true);+ }+ },+ );++ it.each([0, Math.PI / 4])(+ "implicitly closes the fill of an unsnapped loop at angle %s",+ (angle) => {+ const element = createLoop({ angle });+ const elementsMap = arrayToMap([element]);+ mutateElement(element, elementsMap, {+ points: [+ ...element.points.slice(0, -1),+ pointFrom<LocalPoint>(160, 36),+ ],+ });+ const point = pointRotateRads(+ pointFrom<GlobalPoint>(440, 239.5),+ pointFrom<GlobalPoint>(380, 240),+ element.angle,+ );++ expect(isPointInElement(point, element, elementsMap)).toBe(true);+ },+ );++ it("rotates around the unrotated bounds center of an asymmetric loop", () => {+ const element = createLoop({+ angle: Math.PI / 4,+ points: [+ pointFrom<LocalPoint>(0, 0),+ pointFrom<LocalPoint>(200, 0),+ pointFrom<LocalPoint>(0, 100),+ pointFrom<LocalPoint>(0, 0),+ ],+ });+ const point = pointRotateRads(+ pointFrom<GlobalPoint>(330, 205),+ pointFrom<GlobalPoint>(400, 250),+ element.angle,+ );++ expect(isPointInElement(point, element, arrayToMap([element]))).toBe(true);+ });++ it("hits smoothed fill outside the rotated bounds of the points", () => {+ const element = createLoop({+ angle: (2 * Math.PI) / 3,+ points: [+ pointFrom<LocalPoint>(0, 0),+ pointFrom<LocalPoint>(200, 0),+ pointFrom<LocalPoint>(0, 100),+ pointFrom<LocalPoint>(0, 0),+ ],+ });+ const elementsMap = arrayToMap([element]);+ // Outside the raw triangle, inside the curve bulging past its hypotenuse.+ const point = pointRotateRads(+ pointFrom<GlobalPoint>(436, 240),+ pointFrom<GlobalPoint>(400, 250),+ element.angle,+ );+ const [x1, y1, x2, y2] = getElementBounds(element, elementsMap);++ expect(+ point[0] < x1 || point[0] > x2 || point[1] < y1 || point[1] > y2,+ ).toBe(true);+ expect(isPointInElement(point, element, elementsMap)).toBe(true);+ expect(+ hitElementItself({ element, elementsMap, point, threshold: 1 }),+ ).toBe(true);+ });++ it.each([+ {+ name: "a three-point retraced path",+ points: [+ pointFrom<LocalPoint>(0, 0),+ pointFrom<LocalPoint>(100, 100),+ pointFrom<LocalPoint>(0, 0),+ ],+ point: pointFrom<GlobalPoint>(350, 250),+ },+ {+ name: "a loop that simplifies to two identical points",+ points: [+ pointFrom<LocalPoint>(0, 0),+ pointFrom<LocalPoint>(0.3, 0),+ pointFrom<LocalPoint>(0.3, 0.3),+ pointFrom<LocalPoint>(0, 0.3),+ pointFrom<LocalPoint>(0, 0),+ ],+ point: pointFrom<GlobalPoint>(300.15, 200.15),+ },+ ])("contains nothing for $name", ({ points, point }) => {+ const element = createLoop({ points });++ expect(isPointInElement(point, element, arrayToMap([element]))).toBe(false);+ });++ it("preserves the curved fill of a nearly closed three-point path", () => {+ const element = createLoop({+ points: [+ pointFrom<LocalPoint>(0, 0),+ pointFrom<LocalPoint>(100, 100),+ pointFrom<LocalPoint>(3, 0),+ ],+ });++ expect(+ isPointInElement(+ pointFrom<GlobalPoint>(350, 250),+ element,+ arrayToMap([element]),+ ),+ ).toBe(true);+ });++ it("includes the smoothed fill beyond the raw-point polygon", () => {+ const element = createLoop({+ points: [+ pointFrom<LocalPoint>(200, 100),+ pointFrom<LocalPoint>(100, 200),+ pointFrom<LocalPoint>(0, 100),+ pointFrom<LocalPoint>(100, 0),+ pointFrom<LocalPoint>(200, 100),+ ],+ });++ expect(+ isPointInElement(+ pointFrom<GlobalPoint>(305, 285),+ element,+ arrayToMap([element]),+ ),+ ).toBe(true);+ });++ it("uses even-odd fill for a self-intersecting loop", () => {+ const element = createLoop({+ points: Array.from({ length: 6 }, (_, i) => {+ const angle = -Math.PI / 2 + (((i * 2) % 5) / 5) * 2 * Math.PI;+ return pointFrom<LocalPoint>(+ 100 + 95 * Math.cos(angle),+ 100 + 95 * Math.sin(angle),+ );+ }),+ });++ expect(+ isPointInElement(+ pointFrom<GlobalPoint>(400, 300),+ element,+ arrayToMap([element]),+ ),+ ).toBe(false);+ });++ it("invalidates the fill contour when points change on the same element", () => {+ const element = createLoop();+ const elementsMap = arrayToMap([element]);+ const point = pointFrom<GlobalPoint>(415, 255);+ const version = element.version;++ expect(isPointInElement(point, element, elementsMap)).toBe(true);++ // Preserve the bounds so a stale contour cannot hide behind that pre-check.+ mutateElement(element, elementsMap, {+ points: [+ pointFrom<LocalPoint>(0, 0),+ pointFrom<LocalPoint>(160, 0),+ pointFrom<LocalPoint>(0, 80),+ pointFrom<LocalPoint>(0, 0),+ ],+ });++ expect(element.version).toBeGreaterThan(version);+ expect(isPointInElement(point, element, elementsMap)).toBe(false);+ });+});diff --git a/packages/excalidraw/tests/selection.test.tsx b/packages/excalidraw/tests/selection.test.tsxindex 64ec933d90..a016a2eb98 100644--- a/packages/excalidraw/tests/selection.test.tsx+++ b/packages/excalidraw/tests/selection.test.tsx@@ -712,6 +712,41 @@ describe("box-selection overlap mode", () => {assertSelectedElements([]);});+ it.each(["variable", "constant"] as const)(+ "should select and drag a filled %s freedraw loop from its interior",+ (variability) => {+ const freedraw = API.createElement({+ type: "freedraw",+ x: 100,+ y: 100,+ width: 200,+ height: 100,+ backgroundColor: "#ffc9c9",+ fillStyle: "solid",+ strokeOptions: { variability, streamline: 0.5 },+ points: [+ pointFrom<LocalPoint>(0, 0),+ pointFrom<LocalPoint>(200, 0),+ pointFrom<LocalPoint>(200, 100),+ pointFrom<LocalPoint>(0, 100),+ pointFrom<LocalPoint>(0, 0),+ ],+ });++ API.setElements([freedraw]);++ mouse.clickAt(203, 152);+ assertSelectedElements([freedraw.id]);++ mouse.downAt(203, 152);+ mouse.moveTo(233, 172);+ mouse.up();++ expect(API.getElement(freedraw)).toMatchObject({ x: 130, y: 120 });+ assertSelectedElements([freedraw.id]);+ },+ );+it("should not select a freedraw when the selection box only overlaps its bounds", () => {const freedraw = API.createElement({type: "freedraw",