@tldraw/editor 5.4.0-next.ef99ab47e5ce → 5.5.0-next.6d9e51e9f3f7

package/src/lib/primitives/geometry/Arc2d.test.ts

@@ -1,5 +1,237 @@
-describe('Arc2d', () => {
-	it('should be tested', () => {
-		expect(true).toBe(true)
+import { Vec } from '../Vec'
+import { Arc2d } from './Arc2d'
+
+// A quarter circle of radius 10 centred at the origin, from (10, 0) clockwise (in screen
+// space, i.e. with increasing angle) to (0, 10).
+const quarter = () =>
+	new Arc2d({
+		center: new Vec(0, 0),
+		start: new Vec(10, 0),
+		end: new Vec(0, 10),
+		sweepFlag: 1,
+		largeArcFlag: 0,
+	})
+
+// The complementary three-quarter arc between the same points, going the other way round.
+const threeQuarter = () =>
+	new Arc2d({
+		center: new Vec(0, 0),
+		start: new Vec(10, 0),
+		end: new Vec(0, 10),
+		sweepFlag: 0,
+		largeArcFlag: 1,
+	})
+
+function expectVec(actual: Vec, expected: { x: number; y: number }) {
+	expect(actual.x).toBeCloseTo(expected.x)
+	expect(actual.y).toBeCloseTo(expected.y)
+}
+
+describe('Arc2d construction', () => {
+	it('is never closed or filled', () => {
+		expect(quarter()).toMatchObject({ isClosed: false, isFilled: false })
+	})
+
+	it('throws when start and end are the same point', () => {
+		expect(
+			() =>
+				new Arc2d({
+					center: new Vec(0, 0),
+					start: new Vec(10, 0),
+					end: new Vec(10, 0),
+					sweepFlag: 1,
+					largeArcFlag: 0,
+				})
+		).toThrow('Arc must have different start and end points.')
+	})
+})
+
+describe('Arc2d.getLength', () => {
+	it('is the arc measure times the radius', () => {
+		expect(quarter().length).toBeCloseTo((Math.PI / 2) * 10)
+		expect(threeQuarter().length).toBeCloseTo(((3 * Math.PI) / 2) * 10)
+	})
+
+	it('is half a circumference for a semicircle in either direction', () => {
+		const semi = new Arc2d({
+			center: new Vec(25, 25),
+			start: new Vec(25, 50),
+			end: new Vec(25, 0),
+			sweepFlag: 1,
+			largeArcFlag: 1,
+		})
+		expect(semi.length).toBeCloseTo(Math.PI * 25)
+	})
+})
+
+describe('Arc2d.getVertices', () => {
+	it('samples at least eight segments from start to end', () => {
+		const { vertices } = quarter()
+		expect(vertices.length).toBe(9)
+		expectVec(vertices[0], { x: 10, y: 0 })
+		expectVec(vertices[4], { x: 10 / Math.SQRT2, y: 10 / Math.SQRT2 })
+		expectVec(vertices[8], { x: 0, y: 10 })
+	})
+
+	it('keeps every vertex on the circle', () => {
+		for (const v of quarter().vertices) {
+			expect(Vec.Dist(v, new Vec(0, 0))).toBeCloseTo(10)
+		}
+	})
+
+	it('walks the long way round for a large arc', () => {
+		const { vertices } = threeQuarter()
+		expect(vertices.length).toBe(9)
+		expectVec(vertices[0], { x: 10, y: 0 })
+		// the midpoint of the long arc is opposite the midpoint of the short arc
+		expectVec(vertices[4], { x: -10 / Math.SQRT2, y: -10 / Math.SQRT2 })
+		expectVec(vertices[8], { x: 0, y: 10 })
+	})
+
+	it('samples more vertices for longer arcs', () => {
+		const big = new Arc2d({
+			center: new Vec(0, 0),
+			start: new Vec(100, 0),
+			end: new Vec(0, 100),
+			sweepFlag: 1,
+			largeArcFlag: 0,
+		})
+		// length is 50π ≈ 157, one vertex per 20 units -> 8 segments
+		expect(big.vertices.length).toBe(9)
+		const bigger = new Arc2d({
+			center: new Vec(0, 0),
+			start: new Vec(200, 0),
+			end: new Vec(0, 200),
+			sweepFlag: 1,
+			largeArcFlag: 0,
+		})
+		// length is 100π ≈ 314 -> 16 segments
+		expect(bigger.vertices.length).toBe(17)
+	})
+})
+
+describe('Arc2d.bounds', () => {
+	it('is the box around the sampled vertices', () => {
+		const { bounds } = quarter()
+		expect(bounds.x).toBeCloseTo(0)
+		expect(bounds.y).toBeCloseTo(0)
+		expect(bounds.w).toBeCloseTo(10)
+		expect(bounds.h).toBeCloseTo(10)
+	})
+})
+
+describe('Arc2d.nearestPoint', () => {
+	it('projects radially onto the arc when the angle is within the sweep', () => {
+		expectVec(quarter().nearestPoint(new Vec(5, 5)), { x: 10 / Math.SQRT2, y: 10 / Math.SQRT2 })
+		expectVec(quarter().nearestPoint(new Vec(20, 20)), {
+			x: 10 / Math.SQRT2,
+			y: 10 / Math.SQRT2,
+		})
+	})
+
+	it('returns the start point for angles before the arc', () => {
+		expect(quarter().nearestPoint(new Vec(20, -5))).toMatchObject({ x: 10, y: 0 })
+		expect(quarter().nearestPoint(new Vec(20, 0))).toMatchObject({ x: 10, y: 0 })
+	})
+
+	it('returns the end point for angles after the arc', () => {
+		expect(quarter().nearestPoint(new Vec(-5, 20))).toMatchObject({ x: 0, y: 10 })
+		expect(quarter().nearestPoint(new Vec(0, 20))).toMatchObject({ x: 0, y: 10 })
+	})
+
+	it('returns the start point for the centre itself', () => {
+		expect(quarter().nearestPoint(new Vec(0, 0))).toMatchObject({ x: 10, y: 0 })
+	})
+
+	it('projects onto the long arc', () => {
+		expectVec(threeQuarter().nearestPoint(new Vec(-20, 0)), { x: -10, y: 0 })
+		expectVec(threeQuarter().nearestPoint(new Vec(0, -3)), { x: 0, y: -10 })
+		// a point in the gap of the long arc snaps to the nearer end point
+		expect(threeQuarter().nearestPoint(new Vec(20, 5))).toMatchObject({ x: 10, y: 0 })
+	})
+})
+
+describe('Arc2d.distanceToPoint', () => {
+	it('measures to the arc or its end points', () => {
+		expect(quarter().distanceToPoint(new Vec(20, 20))).toBeCloseTo(Math.hypot(20, 20) - 10)
+		expect(quarter().distanceToPoint(new Vec(20, 0))).toBe(10)
+		expect(quarter().distanceToPoint(new Vec(0, 0))).toBe(10)
+	})
+
+	it('is never negative because an arc has no interior', () => {
+		expect(quarter().distanceToPoint(new Vec(1, 1), true)).toBeGreaterThan(0)
+	})
+})
+
+describe('Arc2d.hitTestPoint', () => {
+	it('hits points on the arc within the margin', () => {
+		expect(quarter().hitTestPoint(new Vec(10 / Math.SQRT2, 10 / Math.SQRT2), 0.001)).toBe(true)
+		expect(quarter().hitTestPoint(new Vec(10, 0))).toBe(true)
+		expect(quarter().hitTestPoint(new Vec(5, 5), 3)).toBe(true)
+		expect(quarter().hitTestPoint(new Vec(5, 5), 2)).toBe(false)
+	})
+
+	it('does not hit the sector inside the arc even with hitInside', () => {
+		expect(quarter().hitTestPoint(new Vec(5, 5), 0, true)).toBe(false)
+	})
+})
+
+describe('Arc2d.hitTestLineSegment', () => {
+	it('hits a segment crossing the arc', () => {
+		expect(quarter().hitTestLineSegment(new Vec(5, 0), new Vec(5, 20))).toBe(true)
+	})
+
+	it('misses a segment crossing the circle outside the arc', () => {
+		// crosses the circle at (-5, 8.66), which is at 120° and not on the quarter arc
+		expect(quarter().hitTestLineSegment(new Vec(-5, 0), new Vec(-5, 20))).toBe(false)
+		// but it is on the complementary arc
+		expect(threeQuarter().hitTestLineSegment(new Vec(-5, 0), new Vec(-5, 20))).toBe(true)
+	})
+
+	it('misses a segment that does not reach the circle', () => {
+		expect(quarter().hitTestLineSegment(new Vec(20, 20), new Vec(30, 30))).toBe(false)
+		expect(quarter().hitTestLineSegment(new Vec(1, 1), new Vec(2, 2))).toBe(false)
+	})
+
+	// Locks in current behaviour, see #10555.
+	it('hits crossings just beyond the end points (known quirk)', () => {
+		// (5, -8.66) is at -60°, off the quarter arc, but getPointInArcT clamps it to the start
+		expect(quarter().hitTestLineSegment(new Vec(5, -20), new Vec(5, 0))).toBe(true)
+	})
+
+	it('checks both directions of the long arc', () => {
+		expect(threeQuarter().hitTestLineSegment(new Vec(5, -20), new Vec(5, 0))).toBe(true)
+		expect(threeQuarter().hitTestLineSegment(new Vec(5, 0), new Vec(5, 20))).toBe(false)
+	})
+})
+
+describe('Arc2d.getSvgPathData', () => {
+	it('emits a move and an arc command with the flags', () => {
+		expect(quarter().getSvgPathData()).toBe('M10, 0 A10 10 0 0 1 0, 10')
+		expect(threeQuarter().getSvgPathData()).toBe('M10, 0 A10 10 0 1 0 0, 10')
+	})
+
+	it('omits the move command when not first', () => {
+		expect(quarter().getSvgPathData(false)).toBe(' A10 10 0 0 1 0, 10')
+	})
+
+	it('rounds coordinates to two decimals', () => {
+		const arc = new Arc2d({
+			center: new Vec(0, 0),
+			start: new Vec(10, 0),
+			end: new Vec(10 / Math.SQRT2, 10 / Math.SQRT2),
+			sweepFlag: 1,
+			largeArcFlag: 0,
+		})
+		expect(arc.getSvgPathData()).toBe('M10, 0 A10 10 0 0 1 7.07, 7.07')
+	})
+
+	it('does not mutate the stored points', () => {
+		const start = new Vec(10, 0)
+		const end = new Vec(10 / Math.SQRT2, 10 / Math.SQRT2)
+		const arc = new Arc2d({ center: new Vec(0, 0), start, end, sweepFlag: 1, largeArcFlag: 0 })
+		arc.getSvgPathData()
+		expect(start).toMatchObject({ x: 10, y: 0 })
+		expect(end).toMatchObject({ x: 10 / Math.SQRT2, y: 10 / Math.SQRT2 })
 	})
 })

package/src/lib/primitives/geometry/Arc2d.ts

@@ -105,7 +105,7 @@ export class Arc2d extends Geometry2d {
 			_largeArcFlag: largeArcFlag,
 			_sweepFlag: sweepFlag,
 		} = this
-		return `${first ? `M${start.toFixed()}` : ``} A${radius} ${radius} 0 ${largeArcFlag} ${sweepFlag} ${end.toFixed()}`
+		return `${first ? `M${start}` : ``} A${radius} ${radius} 0 ${largeArcFlag} ${sweepFlag} ${end}`
 	}
 
 	override getLength() {

package/src/lib/primitives/geometry/CubicBezier2d.test.ts

@@ -1,5 +1,188 @@
-describe('CubicBezier2d', () => {
-	it('should be tested', () => {
-		expect(true).toBe(true)
+import { Vec } from '../Vec'
+import { CubicBezier2d } from './CubicBezier2d'
+import { Polyline2d } from './Polyline2d'
+
+// A symmetric arch from (0, 0) to (100, 0) whose control points pull it up to y = 75 at t = 0.5
+const arch = (resolution?: number) =>
+	new CubicBezier2d({
+		start: new Vec(0, 0),
+		cp1: new Vec(0, 100),
+		cp2: new Vec(100, 100),
+		end: new Vec(100, 0),
+		resolution,
+	})
+
+// Control points on the line y = x, so the curve is the straight segment (0,0) -> (30,30)
+const straight = () =>
+	new CubicBezier2d({
+		start: new Vec(0, 0),
+		cp1: new Vec(10, 10),
+		cp2: new Vec(20, 20),
+		end: new Vec(30, 30),
+	})
+
+describe('CubicBezier2d construction', () => {
+	it('is an open, unfilled polyline', () => {
+		const b = arch()
+		expect(b).toBeInstanceOf(Polyline2d)
+		expect(b).toMatchObject({ isClosed: false, isFilled: false })
+	})
+})
+
+describe('CubicBezier2d.GetAtT', () => {
+	it('returns the end points at t = 0 and t = 1', () => {
+		expect(CubicBezier2d.GetAtT(arch(), 0)).toMatchObject({ x: 0, y: 0 })
+		expect(CubicBezier2d.GetAtT(arch(), 1)).toMatchObject({ x: 100, y: 0 })
+	})
+
+	it('returns the weighted control point average in between', () => {
+		// 0.125 a + 0.375 b + 0.375 c + 0.125 d
+		expect(CubicBezier2d.GetAtT(arch(), 0.5)).toMatchObject({ x: 50, y: 75 })
+		const p = CubicBezier2d.GetAtT(arch(), 0.4)
+		expect(p.x).toBeCloseTo(35.2)
+		expect(p.y).toBeCloseTo(72)
+	})
+})
+
+describe('CubicBezier2d.getVertices', () => {
+	it('samples resolution + 1 points along the curve', () => {
+		const { vertices } = arch()
+		expect(vertices.length).toBe(11)
+		expect(vertices[0]).toMatchObject({ x: 0, y: 0 })
+		expect(vertices[5]).toMatchObject({ x: 50, y: 75 })
+		expect(vertices[10]).toMatchObject({ x: 100, y: 0 })
+	})
+
+	it('honours a custom resolution', () => {
+		const { vertices } = arch(4)
+		expect(vertices.length).toBe(5)
+		expect(vertices[2]).toMatchObject({ x: 50, y: 75 })
+	})
+
+	it('is symmetric for symmetric control points', () => {
+		const { vertices } = arch()
+		for (let i = 0; i < 5; i++) {
+			expect(vertices[i].x).toBeCloseTo(100 - vertices[10 - i].x)
+			expect(vertices[i].y).toBeCloseTo(vertices[10 - i].y)
+		}
+	})
+})
+
+describe('CubicBezier2d.bounds', () => {
+	it('spans the sampled vertices', () => {
+		expect(arch().bounds).toMatchObject({ x: 0, y: 0, w: 100, h: 75 })
+		expect(arch().center).toMatchObject({ x: 50, y: 37.5 })
+	})
+})
+
+describe('CubicBezier2d.getLength', () => {
+	it('equals the chord for a straight curve', () => {
+		expect(straight().length).toBeCloseTo(Math.hypot(30, 30))
+	})
+
+	it('sums sampled chords at the given precision', () => {
+		const b = arch()
+		expect(b.getLength(undefined, 1)).toBe(100)
+		expect(b.getLength(undefined, 2)).toBeCloseTo(2 * Math.hypot(50, 75))
+	})
+
+	it('gets longer with finer sampling of a curved path', () => {
+		const b = arch()
+		expect(b.getLength(undefined, 2)).toBeLessThan(b.getLength(undefined, 32))
+		expect(b.length).toBe(b.getLength(undefined, 32))
+	})
+})
+
+describe('CubicBezier2d.nearestPoint', () => {
+	it('returns the peak vertex for a point above the arch', () => {
+		expect(arch().nearestPoint(new Vec(50, 100))).toMatchObject({ x: 50, y: 75 })
+	})
+
+	it('clamps to the end points', () => {
+		expect(arch().nearestPoint(new Vec(-10, 0))).toMatchObject({ x: 0, y: 0 })
+		expect(arch().nearestPoint(new Vec(110, 0))).toMatchObject({ x: 100, y: 0 })
+	})
+
+	it('projects onto the straight curve', () => {
+		const p = straight().nearestPoint(new Vec(20, 10))
+		expect(p.x).toBeCloseTo(15)
+		expect(p.y).toBeCloseTo(15)
+	})
+})
+
+describe('CubicBezier2d.distanceToPoint', () => {
+	it('measures to the sampled polyline', () => {
+		expect(arch().distanceToPoint(new Vec(50, 100))).toBe(25)
+		expect(arch().distanceToPoint(new Vec(-10, 0))).toBe(10)
+		expect(straight().distanceToPoint(new Vec(20, 10))).toBeCloseTo(Math.hypot(5, 5))
+	})
+
+	it('is always positive, even under the arch with hitInside', () => {
+		expect(arch().distanceToPoint(new Vec(50, 30), true)).toBeGreaterThan(0)
+	})
+})
+
+describe('CubicBezier2d.hitTestPoint', () => {
+	it('hits points on the curve', () => {
+		expect(arch().hitTestPoint(new Vec(50, 75))).toBe(true)
+		expect(arch().hitTestPoint(new Vec(0, 0))).toBe(true)
+	})
+
+	it('respects the margin', () => {
+		expect(arch().hitTestPoint(new Vec(50, 80), 5)).toBe(true)
+		expect(arch().hitTestPoint(new Vec(50, 80), 4)).toBe(false)
+	})
+
+	it('does not hit the area under the arch', () => {
+		expect(arch().hitTestPoint(new Vec(50, 30))).toBe(false)
+		expect(arch().hitTestPoint(new Vec(50, 30), 0, true)).toBe(false)
+	})
+})
+
+describe('CubicBezier2d.hitTestLineSegment', () => {
+	it('hits a segment crossing the curve', () => {
+		expect(arch().hitTestLineSegment(new Vec(50, 0), new Vec(50, 100))).toBe(true)
+	})
+
+	it('misses a segment away from the curve', () => {
+		expect(arch().hitTestLineSegment(new Vec(200, 0), new Vec(200, 100))).toBe(false)
+	})
+
+	it('respects the distance', () => {
+		expect(arch().hitTestLineSegment(new Vec(0, 80), new Vec(100, 80), 5)).toBe(true)
+		expect(arch().hitTestLineSegment(new Vec(0, 80), new Vec(100, 80), 4)).toBe(false)
+	})
+})
+
+describe('CubicBezier2d.getSvgPathData', () => {
+	it('emits a move and a cubic command', () => {
+		expect(arch().getSvgPathData()).toBe('M 0, 0  C0, 100 100, 100 100, 0')
+	})
+
+	it('omits the move command when not first', () => {
+		expect(arch().getSvgPathData(false)).toBe(' C0, 100 100, 100 100, 0')
+	})
+
+	it('rounds coordinates to two decimals', () => {
+		const b = new CubicBezier2d({
+			start: new Vec(0.123, 0),
+			cp1: new Vec(1.006, 2),
+			cp2: new Vec(3, 4.999),
+			end: new Vec(10, 10),
+		})
+		expect(b.getSvgPathData()).toBe('M 0.12, 0  C1.01, 2 3, 5 10, 10')
+	})
+
+	it('does not mutate the stored points', () => {
+		const start = new Vec(0.123, 0)
+		const cp1 = new Vec(1.006, 2)
+		const cp2 = new Vec(3, 4.999)
+		const end = new Vec(10, 10.005)
+		const b = new CubicBezier2d({ start, cp1, cp2, end })
+		b.getSvgPathData()
+		expect(start).toMatchObject({ x: 0.123, y: 0 })
+		expect(cp1).toMatchObject({ x: 1.006, y: 2 })
+		expect(cp2).toMatchObject({ x: 3, y: 4.999 })
+		expect(end).toMatchObject({ x: 10, y: 10.005 })
 	})
 })

package/src/lib/primitives/geometry/CubicBezier2d.ts

@@ -81,7 +81,7 @@ export class CubicBezier2d extends Polyline2d {
 
 	getSvgPathData(first = true) {
 		const { _a: a, _b: b, _c: c, _d: d } = this
-		return `${first ? `M ${a.toFixed()} ` : ``} C${b.toFixed()} ${c.toFixed()} ${d.toFixed()}`
+		return `${first ? `M ${a} ` : ``} C${b} ${c} ${d}`
 	}
 
 	static GetAtT(segment: CubicBezier2d, t: number) {

package/src/lib/primitives/geometry/CubicSpline2d.test.ts

@@ -1,5 +1,162 @@
-describe('CubicSpline2d', () => {
-	it('should be tested', () => {
-		expect(true).toBe(true)
+import { Vec } from '../Vec'
+import { CubicBezier2d } from './CubicBezier2d'
+import { CubicSpline2d } from './CubicSpline2d'
+
+// Three collinear points: the spline is the straight line from (0, 0) to (200, 0)
+const line = () => new CubicSpline2d({ points: [new Vec(0, 0), new Vec(100, 0), new Vec(200, 0)] })
+
+// A symmetric peak: (0, 0) up to (100, 100) and back down to (200, 0)
+const peak = () =>
+	new CubicSpline2d({ points: [new Vec(0, 0), new Vec(100, 100), new Vec(200, 0)] })
+
+function expectVec(actual: Vec, expected: { x: number; y: number }) {
+	expect(actual.x).toBeCloseTo(expected.x)
+	expect(actual.y).toBeCloseTo(expected.y)
+}
+
+describe('CubicSpline2d construction', () => {
+	it('is never closed or filled', () => {
+		expect(line()).toMatchObject({ isClosed: false, isFilled: false })
+	})
+})
+
+describe('CubicSpline2d.segments', () => {
+	it('creates one bezier per pair of consecutive points', () => {
+		const { segments } = line()
+		expect(segments.length).toBe(2)
+		expect(segments[0]).toBeInstanceOf(CubicBezier2d)
+		expect(segments[0].vertices[0]).toMatchObject({ x: 0, y: 0 })
+		expect(segments[0].vertices[10]).toMatchObject({ x: 100, y: 0 })
+		expect(segments[1].vertices[0]).toMatchObject({ x: 100, y: 0 })
+		expect(segments[1].vertices[10]).toMatchObject({ x: 200, y: 0 })
+	})
+
+	it('uses the end points as control points at the ends and Catmull-Rom style tangents between', () => {
+		const { segments } = peak()
+		// cp1 of the first segment is the first point; cp2 is pulled back from the second point
+		// along the chord (p3 - p1) / 6 * 1.25
+		expect(segments[0].getSvgPathData()).toBe('M 0, 0  C0, 0 58.33, 100 100, 100')
+		expect(segments[1].getSvgPathData()).toBe('M 100, 100  C141.67, 100 200, 0 200, 0')
+	})
+
+	it('caches the segments', () => {
+		const s = line()
+		expect(s.segments).toBe(s.segments)
+	})
+
+	it('creates a single straight segment for two points', () => {
+		const s = new CubicSpline2d({ points: [new Vec(0, 0), new Vec(100, 0)] })
+		expect(s.segments.length).toBe(1)
+		expect(s.segments[0].getSvgPathData()).toBe('M 0, 0  C0, 0 100, 0 100, 0')
+		expect(s.length).toBeCloseTo(100)
+	})
+
+	it('has no segments for a single point', () => {
+		const s = new CubicSpline2d({ points: [new Vec(5, 5)] })
+		expect(s.segments).toEqual([])
+		expect(s.vertices).toEqual([new Vec(5, 5)])
+		expect(s.length).toBe(0)
+		expect(() => s.nearestPoint(new Vec(0, 0))).toThrow('nearest point not found')
+	})
+})
+
+describe('CubicSpline2d.getVertices', () => {
+	it('concatenates the segment vertices and appends the final point', () => {
+		const { vertices } = line()
+		expect(vertices.length).toBe(11 + 11 + 1)
+		expect(vertices[0]).toMatchObject({ x: 0, y: 0 })
+		expect(vertices[10]).toMatchObject({ x: 100, y: 0 })
+		expect(vertices[11]).toMatchObject({ x: 100, y: 0 })
+		expect(vertices[22]).toMatchObject({ x: 200, y: 0 })
+		for (const v of vertices) expect(v.y).toBe(0)
+	})
+
+	it('passes through every control point', () => {
+		const { vertices } = peak()
+		expect(vertices[0]).toMatchObject({ x: 0, y: 0 })
+		expect(vertices[10]).toMatchObject({ x: 100, y: 100 })
+		expect(vertices[22]).toMatchObject({ x: 200, y: 0 })
+	})
+})
+
+describe('CubicSpline2d.bounds', () => {
+	it('spans the vertices', () => {
+		expect(line().bounds).toMatchObject({ x: 0, y: 0, w: 200, h: 0 })
+		expect(peak().bounds).toMatchObject({ x: 0, y: 0, w: 200, h: 100 })
+		expect(peak().center).toMatchObject({ x: 100, y: 50 })
+	})
+})
+
+describe('CubicSpline2d.getLength', () => {
+	it('sums the segment lengths', () => {
+		const s = line()
+		expect(s.length).toBeCloseTo(200)
+		expect(s.length).toBeCloseTo(s.segments[0].length + s.segments[1].length)
+	})
+
+	it('is longer than the chord for a curved spline', () => {
+		expect(peak().length).toBeGreaterThan(2 * Math.hypot(100, 100))
+	})
+})
+
+describe('CubicSpline2d.nearestPoint', () => {
+	it('projects onto the nearest segment', () => {
+		expectVec(line().nearestPoint(new Vec(50, 10)), { x: 50, y: 0 })
+		expectVec(line().nearestPoint(new Vec(150, -10)), { x: 150, y: 0 })
+	})
+
+	it('clamps to the end points', () => {
+		expect(line().nearestPoint(new Vec(-10, 0))).toMatchObject({ x: 0, y: 0 })
+		expect(line().nearestPoint(new Vec(210, 5))).toMatchObject({ x: 200, y: 0 })
+	})
+
+	it('returns the shared point where two segments meet', () => {
+		expect(peak().nearestPoint(new Vec(100, 120))).toMatchObject({ x: 100, y: 100 })
+	})
+})
+
+describe('CubicSpline2d.distanceToPoint', () => {
+	it('is the distance to the nearest segment', () => {
+		expect(line().distanceToPoint(new Vec(50, 10))).toBeCloseTo(10)
+		expect(line().distanceToPoint(new Vec(150, -10))).toBeCloseTo(10)
+		expect(peak().distanceToPoint(new Vec(100, 120))).toBe(20)
+	})
+
+	it('is never negative', () => {
+		expect(peak().distanceToPoint(new Vec(100, 50), true)).toBeGreaterThan(0)
+	})
+})
+
+describe('CubicSpline2d.hitTestPoint', () => {
+	it('hits points on the spline within the margin', () => {
+		expect(line().hitTestPoint(new Vec(50, 0), 0.001)).toBe(true)
+		expect(line().hitTestPoint(new Vec(50, 10), 10)).toBe(true)
+		expect(line().hitTestPoint(new Vec(50, 10), 9)).toBe(false)
+	})
+
+	it('does not hit the area under a peak', () => {
+		expect(peak().hitTestPoint(new Vec(100, 50), 0, true)).toBe(false)
+	})
+})
+
+describe('CubicSpline2d.hitTestLineSegment', () => {
+	it('hits a segment crossing either bezier', () => {
+		expect(line().hitTestLineSegment(new Vec(50, -10), new Vec(50, 10))).toBe(true)
+		expect(line().hitTestLineSegment(new Vec(150, -10), new Vec(150, 10))).toBe(true)
+	})
+
+	it('misses a segment that does not reach the spline', () => {
+		expect(line().hitTestLineSegment(new Vec(150, 5), new Vec(150, 10))).toBe(false)
+		expect(line().hitTestLineSegment(new Vec(250, -10), new Vec(250, 10))).toBe(false)
+	})
+})
+
+describe('CubicSpline2d.getSvgPathData', () => {
+	it('chains the segment paths with a single move command', () => {
+		expect(line().getSvgPathData()).toBe('M 0, 0  C0, 0 58.33, 0 100, 0 C141.67, 0 200, 0 200, 0')
+	})
+
+	it('is empty for a single point', () => {
+		expect(new CubicSpline2d({ points: [new Vec(5, 5)] }).getSvgPathData()).toBe('')
 	})
 })

package/src/lib/primitives/geometry/Edge2d.test.ts

@@ -1,5 +1,23 @@
-describe('Edge2d', () => {
-	it('should be tested', () => {
-		expect(true).toBe(true)
+import { Vec } from '../Vec'
+import { Edge2d } from './Edge2d'
+
+describe('Edge2d.getSvgPathData', () => {
+	it('emits a move and a line command, rounded to two decimals', () => {
+		const edge = new Edge2d({ start: new Vec(0.123456, 0), end: new Vec(10, 10.987654) })
+		expect(edge.getSvgPathData()).toBe('M0.12, 0 L10, 10.99')
+	})
+
+	it('omits the move command when not first', () => {
+		const edge = new Edge2d({ start: new Vec(0.123456, 0), end: new Vec(10, 10.987654) })
+		expect(edge.getSvgPathData(false)).toBe(' L10, 10.99')
+	})
+
+	it('does not mutate the stored points', () => {
+		const start = new Vec(0.123456, 0)
+		const end = new Vec(10, 10.987654)
+		const edge = new Edge2d({ start, end })
+		edge.getSvgPathData()
+		expect(start).toMatchObject({ x: 0.123456, y: 0 })
+		expect(end).toMatchObject({ x: 10, y: 10.987654 })
 	})
 })

package/src/lib/primitives/geometry/Edge2d.ts

@@ -68,6 +68,6 @@ export class Edge2d extends Geometry2d {
 
 	getSvgPathData(first = true) {
 		const { _start: start, _end: end } = this
-		return `${first ? `M${start.toFixed()}` : ``} L${end.toFixed()}`
+		return `${first ? `M${start}` : ``} L${end}`
 	}
 }