@tldraw/editor 3.16.0-internal.51e99e128bd4 → 3.16.0-internal.71f83a8a571b

package/src/lib/primitives/Box.test.ts

@@ -510,6 +510,132 @@ describe('Box', () => {
 		})
 	})
 
+	describe('Box.ContainsApproximately', () => {
+		it('returns true when first box exactly contains second', () => {
+			const boxA = new Box(0, 0, 100, 100)
+			const boxB = new Box(10, 10, 50, 50)
+			expect(Box.ContainsApproximately(boxA, boxB)).toBe(true)
+		})
+
+		it('returns false when first box clearly does not contain second', () => {
+			const boxA = new Box(0, 0, 50, 50)
+			const boxB = new Box(10, 10, 100, 100)
+			expect(Box.ContainsApproximately(boxA, boxB)).toBe(false)
+		})
+
+		it('returns true when containment is within default precision tolerance', () => {
+			// Box B extends very slightly outside A (within floating-point precision)
+			const boxA = new Box(0, 0, 100, 100)
+			const boxB = new Box(10, 10, 80, 80)
+			// Move B's max edges just slightly outside A's bounds
+			boxB.w = 90.000000000001 // maxX = 100.000000000001 (slightly beyond 100)
+			boxB.h = 90.000000000001 // maxY = 100.000000000001 (slightly beyond 100)
+
+			expect(Box.ContainsApproximately(boxA, boxB)).toBe(true)
+			expect(Box.Contains(boxA, boxB)).toBe(false) // strict contains would fail
+		})
+
+		it('returns false when containment exceeds default precision tolerance', () => {
+			const boxA = new Box(0, 0, 100, 100)
+			const boxB = new Box(10, 10, 80, 80)
+			// Move B's max edges clearly outside A's bounds
+			boxB.w = 95 // maxX = 105 (clearly beyond 100)
+			boxB.h = 95 // maxY = 105 (clearly beyond 100)
+
+			expect(Box.ContainsApproximately(boxA, boxB)).toBe(false)
+		})
+
+		it('respects custom precision parameter', () => {
+			const boxA = new Box(0, 0, 100, 100)
+			const boxB = new Box(10, 10, 85, 85) // maxX=95, maxY=95
+
+			// With loose precision (10), should contain (95 is within 100-10=90 tolerance)
+			expect(Box.ContainsApproximately(boxA, boxB, 10)).toBe(true)
+
+			// With tight precision (4), should still contain (95 is within 100-4=96)
+			expect(Box.ContainsApproximately(boxA, boxB, 4)).toBe(true)
+
+			// Since 95 < 100, the precision parameter doesn't affect containment here
+			expect(Box.ContainsApproximately(boxA, boxB, 4.9)).toBe(true)
+		})
+
+		it('handles negative coordinates correctly', () => {
+			const boxA = new Box(-50, -50, 100, 100) // bounds: (-50,-50) to (50,50)
+			const boxB = new Box(-40, -40, 79.999999999, 79.999999999) // bounds: (-40,-40) to (39.999999999, 39.999999999)
+
+			expect(Box.ContainsApproximately(boxA, boxB)).toBe(true)
+		})
+
+		it('handles edge case where boxes are identical', () => {
+			const boxA = new Box(10, 20, 100, 200)
+			const boxB = new Box(10, 20, 100, 200)
+
+			expect(Box.ContainsApproximately(boxA, boxB)).toBe(true)
+		})
+
+		it('handles edge case where inner box touches outer box edges', () => {
+			const boxA = new Box(0, 0, 100, 100)
+			const boxB = new Box(0, 0, 100, 100) // exactly the same
+
+			expect(Box.ContainsApproximately(boxA, boxB)).toBe(true)
+
+			// Slightly smaller inner box
+			const boxC = new Box(0.000001, 0.000001, 99.999998, 99.999998)
+			expect(Box.ContainsApproximately(boxA, boxC)).toBe(true)
+		})
+
+		it('handles floating-point precision issues in real-world scenarios', () => {
+			// Simulate common floating-point arithmetic issues
+			const containerBox = new Box(0, 0, 100, 100)
+
+			// Box that should be contained but has floating-point errors
+			const innerBox = new Box(10, 10, 80, 80)
+			// Simulate floating-point arithmetic that results in tiny overruns
+			innerBox.w = 90.00000000000001 // maxX = 100.00000000000001 (tiny overrun)
+			innerBox.h = 90.00000000000001 // maxY = 100.00000000000001 (tiny overrun)
+
+			expect(Box.ContainsApproximately(containerBox, innerBox)).toBe(true)
+			expect(Box.Contains(containerBox, innerBox)).toBe(false) // strict contains fails due to precision
+		})
+
+		it('fails when any edge exceeds tolerance', () => {
+			const boxA = new Box(10, 10, 100, 100) // bounds: (10,10) to (110,110)
+
+			// Test each edge exceeding tolerance
+			const testCases = [
+				{ name: 'left edge', box: new Box(5, 20, 80, 80) }, // minX too small
+				{ name: 'top edge', box: new Box(20, 5, 80, 80) }, // minY too small
+				{ name: 'right edge', box: new Box(20, 20, 95, 80) }, // maxX too large (20+95=115 > 110)
+				{ name: 'bottom edge', box: new Box(20, 20, 80, 95) }, // maxY too large (20+95=115 > 110)
+			]
+
+			testCases.forEach(({ box }) => {
+				expect(Box.ContainsApproximately(boxA, box, 1)).toBe(false) // tight precision
+			})
+		})
+
+		it('works with zero-sized dimensions', () => {
+			const boxA = new Box(0, 0, 100, 100)
+			const boxB = new Box(50, 50, 0, 0) // zero-sized box (point)
+
+			expect(Box.ContainsApproximately(boxA, boxB)).toBe(true)
+		})
+
+		it('handles precision parameter edge cases', () => {
+			const boxA = new Box(0, 0, 100, 100)
+			const boxB = new Box(10, 10, 91, 91) // maxX=101, maxY=101 (clearly outside)
+
+			// Zero precision should work like strict Contains
+			expect(Box.ContainsApproximately(boxA, boxB, 0)).toBe(false)
+
+			// Small precision should still fail (101 > 100)
+			expect(Box.ContainsApproximately(boxA, boxB, 0.5)).toBe(false)
+
+			// Sufficient precision should succeed (101 <= 100 + 2)
+			expect(Box.ContainsApproximately(boxA, boxB, 2)).toBe(true)
+		})
+	})
+
 	describe('Box.Includes', () => {
 		it('returns true when boxes collide or contain', () => {
 			const boxA = new Box(0, 0, 50, 50)

package/src/lib/primitives/Box.ts

@@ -1,6 +1,6 @@
 import { BoxModel } from '@tldraw/tlschema'
 import { Vec, VecLike } from './Vec'
-import { PI, PI2, toPrecision } from './utils'
+import { approximatelyLte, PI, PI2, toPrecision } from './utils'
 
 /** @public */
 export type BoxLike = BoxModel | Box
@@ -417,6 +417,15 @@ export class Box {
 		return A.minX < B.minX && A.minY < B.minY && A.maxY > B.maxY && A.maxX > B.maxX
 	}
 
+	static ContainsApproximately(A: Box, B: Box, precision?: number) {
+		return (
+			approximatelyLte(A.minX, B.minX, precision) &&
+			approximatelyLte(A.minY, B.minY, precision) &&
+			approximatelyLte(B.maxX, A.maxX, precision) &&
+			approximatelyLte(B.maxY, A.maxY, precision)
+		)
+	}
+
 	static Includes(A: Box, B: Box) {
 		return Box.Collides(A, B) || Box.Contains(A, B)
 	}

package/src/lib/primitives/Vec.ts

@@ -240,11 +240,6 @@ export class Vec {
 		return Vec.EqualsXY(this, x, y)
 	}
 
-	/** @deprecated use `uni` instead */
-	norm() {
-		return this.uni()
-	}
-
 	toFixed() {
 		this.x = toFixed(this.x)
 		this.y = toFixed(this.y)

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

@@ -1,6 +1,7 @@
 import { Mat } from '../Mat'
 import { Vec, VecLike } from '../Vec'
 import { Geometry2dFilters } from './Geometry2d'
+import { Group2d } from './Group2d'
 import { Rectangle2d } from './Rectangle2d'
 
 describe('TransformedGeometry2d', () => {
@@ -36,6 +37,425 @@ describe('TransformedGeometry2d', () => {
 	})
 })
 
+describe('excludeFromShapeBounds', () => {
+	test('simple geometry with excludeFromShapeBounds flag', () => {
+		const rect = new Rectangle2d({
+			width: 100,
+			height: 50,
+			isFilled: true,
+			excludeFromShapeBounds: true,
+		})
+
+		// The bounds should still be calculated normally for simple geometry
+		const bounds = rect.bounds
+		expect(bounds.width).toBe(100)
+		expect(bounds.height).toBe(50)
+		expect(bounds.x).toBe(0)
+		expect(bounds.y).toBe(0)
+	})
+
+	test('group with excluded child geometry', () => {
+		const mainRect = new Rectangle2d({
+			width: 100,
+			height: 50,
+			isFilled: true,
+		})
+
+		const excludedRect = new Rectangle2d({
+			width: 200,
+			height: 100,
+			isFilled: true,
+			excludeFromShapeBounds: true,
+		})
+
+		const group = new Group2d({
+			children: [mainRect, excludedRect],
+		})
+
+		// The bounds should only include the non-excluded rectangle
+		const bounds = group.bounds
+		expect(bounds.width).toBe(100) // Only the main rectangle width
+		expect(bounds.height).toBe(50) // Only the main rectangle height
+		expect(bounds.x).toBe(0)
+		expect(bounds.y).toBe(0)
+	})
+
+	test('group with multiple excluded children', () => {
+		const rect1 = new Rectangle2d({
+			width: 50,
+			height: 50,
+			isFilled: true,
+		})
+
+		const rect2 = new Rectangle2d({
+			width: 100,
+			height: 30,
+			isFilled: true,
+		})
+
+		const excludedRect1 = new Rectangle2d({
+			width: 200,
+			height: 200,
+			isFilled: true,
+			excludeFromShapeBounds: true,
+		})
+
+		const excludedRect2 = new Rectangle2d({
+			width: 300,
+			height: 300,
+			isFilled: true,
+			excludeFromShapeBounds: true,
+		})
+
+		const group = new Group2d({
+			children: [rect1, excludedRect1, rect2, excludedRect2],
+		})
+
+		// The bounds should include both non-excluded rectangles
+		const bounds = group.bounds
+		expect(bounds.width).toBe(100) // Width of rect2 (larger of the two)
+		expect(bounds.height).toBe(50) // Height of rect1 (larger of the two)
+		expect(bounds.x).toBe(0)
+		expect(bounds.y).toBe(0)
+	})
+
+	test('group with all children excluded', () => {
+		const excludedRect1 = new Rectangle2d({
+			width: 100,
+			height: 50,
+			isFilled: true,
+			excludeFromShapeBounds: true,
+		})
+
+		const excludedRect2 = new Rectangle2d({
+			width: 200,
+			height: 100,
+			isFilled: true,
+			excludeFromShapeBounds: true,
+		})
+
+		const group = new Group2d({
+			children: [excludedRect1, excludedRect2],
+		})
+
+		// The bounds should be empty when all children are excluded
+		const bounds = group.bounds
+		expect(bounds.width).toBe(0)
+		expect(bounds.height).toBe(0)
+		expect(bounds.x).toBe(0)
+		expect(bounds.y).toBe(0)
+	})
+
+	test('nested groups with excluded geometry', () => {
+		const innerRect = new Rectangle2d({
+			width: 50,
+			height: 50,
+			isFilled: true,
+		})
+
+		const excludedRect = new Rectangle2d({
+			width: 200,
+			height: 200,
+			isFilled: true,
+			excludeFromShapeBounds: true,
+		})
+
+		const innerGroup = new Group2d({
+			children: [innerRect, excludedRect],
+		})
+
+		const outerRect = new Rectangle2d({
+			width: 100,
+			height: 30,
+			isFilled: true,
+		})
+
+		const outerGroup = new Group2d({
+			children: [innerGroup, outerRect],
+		})
+
+		// The bounds should include both the inner group (without excluded rect) and outer rect
+		const bounds = outerGroup.bounds
+		expect(bounds.width).toBe(100) // Width of outerRect (larger)
+		expect(bounds.height).toBe(50) // Height of innerRect (larger)
+		expect(bounds.x).toBe(0)
+		expect(bounds.y).toBe(0)
+	})
+
+	test('bounds calculation with transformed geometry', () => {
+		const rect = new Rectangle2d({
+			width: 50,
+			height: 50,
+			isFilled: true,
+		}).transform(Mat.Translate(100, 100))
+
+		const excludedRect = new Rectangle2d({
+			width: 200,
+			height: 200,
+			isFilled: true,
+			excludeFromShapeBounds: true,
+		}).transform(Mat.Translate(50, 50))
+
+		const group = new Group2d({
+			children: [rect, excludedRect],
+		})
+
+		// The bounds should only include the non-excluded rectangle
+		const bounds = group.bounds
+		// Verify that the excluded rectangle doesn't affect the bounds
+		// The bounds should be smaller than if the excluded rect was included
+		expect(bounds.width).toBeLessThan(200) // Should not include the excluded rect's width
+		expect(bounds.height).toBeLessThan(200) // Should not include the excluded rect's height
+		// The bounds should not be empty
+		expect(bounds.width).toBeGreaterThan(0)
+		expect(bounds.height).toBeGreaterThan(0)
+	})
+})
+
+describe('getBoundsVertices', () => {
+	test('basic geometry returns vertices when not excluded from bounds', () => {
+		const rect = new Rectangle2d({
+			width: 100,
+			height: 50,
+			isFilled: true,
+		})
+
+		const boundsVertices = rect.getBoundsVertices()
+		const vertices = rect.getVertices()
+
+		expect(boundsVertices).toEqual(vertices)
+		expect(boundsVertices.length).toBe(4)
+		expect(boundsVertices).toMatchObject([
+			{ x: 0, y: 0, z: 1 },
+			{ x: 100, y: 0, z: 1 },
+			{ x: 100, y: 50, z: 1 },
+			{ x: 0, y: 50, z: 1 },
+		])
+	})
+
+	test('geometry excluded from shape bounds returns empty array', () => {
+		const rect = new Rectangle2d({
+			width: 100,
+			height: 50,
+			isFilled: true,
+			excludeFromShapeBounds: true,
+		})
+
+		const boundsVertices = rect.getBoundsVertices()
+		expect(boundsVertices).toEqual([])
+	})
+
+	test('cached boundsVertices property', () => {
+		const rect = new Rectangle2d({
+			width: 100,
+			height: 50,
+			isFilled: true,
+		})
+
+		// Access the cached property multiple times
+		const boundsVertices1 = rect.boundsVertices
+		const boundsVertices2 = rect.boundsVertices
+
+		// Should return the same reference (cached)
+		expect(boundsVertices1).toBe(boundsVertices2)
+		expect(boundsVertices1.length).toBe(4)
+	})
+})
+
+describe('TransformedGeometry2d getBoundsVertices', () => {
+	test('transforms bounds vertices correctly', () => {
+		const rect = new Rectangle2d({
+			width: 100,
+			height: 50,
+			isFilled: true,
+		})
+
+		const transformed = rect.transform(Mat.Translate(50, 100).scale(2, 2))
+		const boundsVertices = transformed.getBoundsVertices()
+
+		expect(boundsVertices).toMatchObject([
+			{ x: 50, y: 100, z: 1 },
+			{ x: 250, y: 100, z: 1 },
+			{ x: 250, y: 200, z: 1 },
+			{ x: 50, y: 200, z: 1 },
+		])
+	})
+
+	test('transforms empty bounds vertices for excluded geometry', () => {
+		const rect = new Rectangle2d({
+			width: 100,
+			height: 50,
+			isFilled: true,
+			excludeFromShapeBounds: true,
+		})
+
+		const transformed = rect.transform(Mat.Translate(50, 100))
+		const boundsVertices = transformed.getBoundsVertices()
+
+		expect(boundsVertices).toEqual([])
+	})
+
+	test('nested transform preserves bounds vertices behavior', () => {
+		const rect = new Rectangle2d({
+			width: 100,
+			height: 50,
+			isFilled: true,
+		})
+
+		const transformed1 = rect.transform(Mat.Translate(10, 20))
+		const transformed2 = transformed1.transform(Mat.Scale(2, 2))
+		const boundsVertices = transformed2.getBoundsVertices()
+
+		expect(boundsVertices).toMatchObject([
+			{ x: 20, y: 40, z: 1 },
+			{ x: 220, y: 40, z: 1 },
+			{ x: 220, y: 140, z: 1 },
+			{ x: 20, y: 140, z: 1 },
+		])
+	})
+})
+
+describe('Group2d getBoundsVertices', () => {
+	test('flattens children bounds vertices', () => {
+		const rect1 = new Rectangle2d({
+			width: 50,
+			height: 50,
+			isFilled: true,
+		})
+
+		const rect2 = new Rectangle2d({
+			width: 30,
+			height: 30,
+			isFilled: true,
+		}).transform(Mat.Translate(60, 60))
+
+		const group = new Group2d({
+			children: [rect1, rect2],
+		})
+
+		const boundsVertices = group.getBoundsVertices()
+
+		// Should include all vertices from both rectangles
+		expect(boundsVertices.length).toBe(8) // 4 vertices from each rectangle
+
+		// Check that we have vertices from both rectangles
+		expect(boundsVertices).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ x: 0, y: 0 }), // rect1 vertices
+				expect.objectContaining({ x: 50, y: 0 }),
+				expect.objectContaining({ x: 50, y: 50 }),
+				expect.objectContaining({ x: 0, y: 50 }),
+				expect.objectContaining({ x: 60, y: 60 }), // rect2 vertices
+				expect.objectContaining({ x: 90, y: 60 }),
+				expect.objectContaining({ x: 90, y: 90 }),
+				expect.objectContaining({ x: 60, y: 90 }),
+			])
+		)
+	})
+
+	test('excludes children marked as excluded from bounds', () => {
+		const rect1 = new Rectangle2d({
+			width: 50,
+			height: 50,
+			isFilled: true,
+		})
+
+		const rect2 = new Rectangle2d({
+			width: 100,
+			height: 100,
+			isFilled: true,
+			excludeFromShapeBounds: true,
+		})
+
+		const group = new Group2d({
+			children: [rect1, rect2],
+		})
+
+		const boundsVertices = group.getBoundsVertices()
+
+		// Should only include vertices from rect1, not rect2
+		expect(boundsVertices.length).toBe(4) // Only rect1's 4 vertices
+		expect(boundsVertices).toMatchObject([
+			{ x: 0, y: 0, z: 1 },
+			{ x: 50, y: 0, z: 1 },
+			{ x: 50, y: 50, z: 1 },
+			{ x: 0, y: 50, z: 1 },
+		])
+	})
+
+	test('returns empty array when group itself is excluded from bounds', () => {
+		const rect1 = new Rectangle2d({
+			width: 50,
+			height: 50,
+			isFilled: true,
+		})
+
+		const rect2 = new Rectangle2d({
+			width: 30,
+			height: 30,
+			isFilled: true,
+		})
+
+		const group = new Group2d({
+			children: [rect1, rect2],
+			excludeFromShapeBounds: true,
+		})
+
+		const boundsVertices = group.getBoundsVertices()
+		expect(boundsVertices).toEqual([])
+	})
+
+	test('handles nested groups correctly', () => {
+		const rect1 = new Rectangle2d({
+			width: 50,
+			height: 50,
+			isFilled: true,
+		})
+
+		const rect2 = new Rectangle2d({
+			width: 30,
+			height: 30,
+			isFilled: true,
+		})
+
+		const innerGroup = new Group2d({
+			children: [rect2],
+		})
+
+		const outerGroup = new Group2d({
+			children: [rect1, innerGroup],
+		})
+
+		const boundsVertices = outerGroup.getBoundsVertices()
+
+		// Should include vertices from both rectangles
+		expect(boundsVertices.length).toBe(8) // 4 vertices from each rectangle
+	})
+
+	test('handles all children excluded from bounds', () => {
+		const rect1 = new Rectangle2d({
+			width: 50,
+			height: 50,
+			isFilled: true,
+			excludeFromShapeBounds: true,
+		})
+
+		const rect2 = new Rectangle2d({
+			width: 30,
+			height: 30,
+			isFilled: true,
+			excludeFromShapeBounds: true,
+		})
+
+		const group = new Group2d({
+			children: [rect1, rect2],
+		})
+
+		const boundsVertices = group.getBoundsVertices()
+		expect(boundsVertices).toEqual([])
+	})
+})
+
 function expectApproxMatch(a: VecLike, b: VecLike) {
 	expect(a.x).toBeCloseTo(b.x, 0.0001)
 	expect(a.y).toBeCloseTo(b.y, 0.0001)