@tldraw/editor 3.16.0-canary.54408756ac9c → 3.16.0-canary.5462c7eac75a

package/src/lib/license/LicenseManager.test.ts

@@ -266,7 +266,7 @@ describe('LicenseManager', () => {
 			delete window.location
 			// @ts-ignore
 			window.location = new URL(
-				'vscode-webview:vscode-webview://1ipd8pun8ud7nd7hv9d112g7evi7m10vak9vviuvia66ou6aibp3/index.html?id=6ec2dc7a-afe9-45d9-bd71-1749f9568d28&origin=955b256f-37e1-4a72-a2f4-ad633e88239c&swVersion=4&extensionId=tldraw-org.tldraw-vscode&platform=electron&vscode-resource-base-authority=vscode-resource.vscode-cdn.net&parentOrigin=vscode-file%3A%2F%2Fvscode-app'
+				'vscode-webview://1ipd8pun8ud7nd7hv9d112g7evi7m10vak9vviuvia66ou6aibp3/index.html?id=6ec2dc7a-afe9-45d9-bd71-1749f9568d28&origin=955b256f-37e1-4a72-a2f4-ad633e88239c&swVersion=4&extensionId=tldraw-org.tldraw-vscode&platform=electron&vscode-resource-base-authority=vscode-resource.vscode-cdn.net&parentOrigin=vscode-file%3A%2F%2Fvscode-app'
 			)
 
 			const permissiveHostsInfo = JSON.parse(STANDARD_LICENSE_INFO)
@@ -286,7 +286,7 @@ describe('LicenseManager', () => {
 			delete window.location
 			// @ts-ignore
 			window.location = new URL(
-				'vscode-webview:vscode-webview://1ipd8pun8ud7nd7hv9d112g7evi7m10vak9vviuvia66ou6aibp3/index.html?id=6ec2dc7a-afe9-45d9-bd71-1749f9568d28&origin=955b256f-37e1-4a72-a2f4-ad633e88239c&swVersion=4&extensionId=tldraw-org.tldraw-vscode&platform=electron&vscode-resource-base-authority=vscode-resource.vscode-cdn.net&parentOrigin=vscode-file%3A%2F%2Fvscode-app'
+				'vscode-webview://1ipd8pun8ud7nd7hv9d112g7evi7m10vak9vviuvia66ou6aibp3/index.html?id=6ec2dc7a-afe9-45d9-bd71-1749f9568d28&origin=955b256f-37e1-4a72-a2f4-ad633e88239c&swVersion=4&extensionId=tldraw-org.tldraw-vscode&platform=electron&vscode-resource-base-authority=vscode-resource.vscode-cdn.net&parentOrigin=vscode-file%3A%2F%2Fvscode-app'
 			)
 
 			const permissiveHostsInfo = JSON.parse(STANDARD_LICENSE_INFO)
@@ -300,6 +300,70 @@ describe('LicenseManager', () => {
 			)) as ValidLicenseKeyResult
 			expect(result.isDomainValid).toBe(false)
 		})
+
+		it('Succeeds if it is a native app', async () => {
+			// @ts-ignore
+			delete window.location
+			// @ts-ignore
+			window.location = new URL('app-bundle://app/index.html')
+
+			const nativeLicenseInfo = JSON.parse(STANDARD_LICENSE_INFO)
+			nativeLicenseInfo[PROPERTIES.FLAGS] = FLAGS.NATIVE_LICENSE
+			nativeLicenseInfo[PROPERTIES.HOSTS] = ['app-bundle:']
+			const nativeLicenseKey = await generateLicenseKey(JSON.stringify(nativeLicenseInfo), keyPair)
+			const result = (await licenseManager.getLicenseFromKey(
+				nativeLicenseKey
+			)) as ValidLicenseKeyResult
+			expect(result.isDomainValid).toBe(true)
+		})
+
+		it('Succeeds if it is a native app with a wildcard', async () => {
+			// @ts-ignore
+			delete window.location
+			// @ts-ignore
+			window.location = new URL('app-bundle://unique-id-123/index.html')
+
+			const nativeLicenseInfo = JSON.parse(STANDARD_LICENSE_INFO)
+			nativeLicenseInfo[PROPERTIES.FLAGS] = FLAGS.NATIVE_LICENSE
+			nativeLicenseInfo[PROPERTIES.HOSTS] = ['^app-bundle://unique-id-123.*']
+			const nativeLicenseKey = await generateLicenseKey(JSON.stringify(nativeLicenseInfo), keyPair)
+			const result = (await licenseManager.getLicenseFromKey(
+				nativeLicenseKey
+			)) as ValidLicenseKeyResult
+			expect(result.isDomainValid).toBe(true)
+		})
+
+		it('Succeeds if it is a native app with a wildcard and search param', async () => {
+			// @ts-ignore
+			delete window.location
+			// @ts-ignore
+			window.location = new URL('app-bundle://app/index.html?unique-id-123')
+
+			const nativeLicenseInfo = JSON.parse(STANDARD_LICENSE_INFO)
+			nativeLicenseInfo[PROPERTIES.FLAGS] = FLAGS.NATIVE_LICENSE
+			nativeLicenseInfo[PROPERTIES.HOSTS] = ['^app-bundle://app.*unique-id-123.*']
+			const nativeLicenseKey = await generateLicenseKey(JSON.stringify(nativeLicenseInfo), keyPair)
+			const result = (await licenseManager.getLicenseFromKey(
+				nativeLicenseKey
+			)) as ValidLicenseKeyResult
+			expect(result.isDomainValid).toBe(true)
+		})
+
+		it('Fails if it is a native app with the wrong protocol', async () => {
+			// @ts-ignore
+			delete window.location
+			// @ts-ignore
+			window.location = new URL('blah-blundle://app/index.html')
+
+			const nativeLicenseInfo = JSON.parse(STANDARD_LICENSE_INFO)
+			nativeLicenseInfo[PROPERTIES.FLAGS] = FLAGS.NATIVE_LICENSE
+			nativeLicenseInfo[PROPERTIES.HOSTS] = ['app-bundle:']
+			const nativeLicenseKey = await generateLicenseKey(JSON.stringify(nativeLicenseInfo), keyPair)
+			const result = (await licenseManager.getLicenseFromKey(
+				nativeLicenseKey
+			)) as ValidLicenseKeyResult
+			expect(result.isDomainValid).toBe(false)
+		})
 	})
 
 	describe('License types and flags', () => {
@@ -316,6 +380,17 @@ describe('LicenseManager', () => {
 			expect(result.isInternalLicense).toBe(true)
 		})
 
+		it('Checks for native license', async () => {
+			const nativeLicenseInfo = JSON.parse(STANDARD_LICENSE_INFO)
+			nativeLicenseInfo[PROPERTIES.FLAGS] = FLAGS.NATIVE_LICENSE
+			const nativeLicenseKey = await generateLicenseKey(JSON.stringify(nativeLicenseInfo), keyPair)
+
+			const result = (await licenseManager.getLicenseFromKey(
+				nativeLicenseKey
+			)) as ValidLicenseKeyResult
+			expect(result.isNativeLicense).toBe(true)
+		})
+
 		it('Checks for license with watermark', async () => {
 			const withWatermarkLicenseInfo = JSON.parse(STANDARD_LICENSE_INFO)
 			withWatermarkLicenseInfo[PROPERTIES.FLAGS] |= FLAGS.WITH_WATERMARK
@@ -553,6 +628,7 @@ function getDefaultLicenseResult(overrides: Partial<ValidLicenseKeyResult>): Val
 		isAnnualLicense: true,
 		isAnnualLicenseExpired: false,
 		isInternalLicense: false,
+		isNativeLicense: false,
 		isDevelopment: false,
 		isDomainValid: true,
 		isPerpetualLicense: false,

package/src/lib/license/LicenseManager.ts

@@ -6,11 +6,22 @@ import { importPublicKey, str2ab } from '../utils/licensing'
 const GRACE_PERIOD_DAYS = 30
 
 export const FLAGS = {
+	// -- MUTUALLY EXCLUSIVE FLAGS --
+	// Annual means the license expires after a time period, usually 1 year.
 	ANNUAL_LICENSE: 1,
+	// Perpetual means the license never expires up to the max supported version.
 	PERPETUAL_LICENSE: 1 << 1,
+
+	// -- ADDITIVE FLAGS --
+	// Internal means the license is for internal use only.
 	INTERNAL_LICENSE: 1 << 2,
+	// Watermark means the product is watermarked.
 	WITH_WATERMARK: 1 << 3,
+	// Evaluation means the license is for evaluation purposes only.
 	EVALUATION_LICENSE: 1 << 4,
+	// Native means the license is for native apps which switches
+	// on special-case logic.
+	NATIVE_LICENSE: 1 << 5,
 }
 const HIGHEST_FLAG = Math.max(...Object.values(FLAGS))
 
@@ -69,6 +80,7 @@ export interface ValidLicenseKeyResult {
 	isPerpetualLicense: boolean
 	isPerpetualLicenseExpired: boolean
 	isInternalLicense: boolean
+	isNativeLicense: boolean
 	isLicensedWithWatermark: boolean
 	isEvaluationLicense: boolean
 	isEvaluationLicenseExpired: boolean
@@ -166,6 +178,9 @@ export class LicenseManager {
 		const url = new URL(WATERMARK_TRACK_SRC)
 		url.searchParams.set('version', version)
 		url.searchParams.set('license_type', trackType)
+		if ('license' in result) {
+			url.searchParams.set('license_id', result.license.id)
+		}
 
 		// eslint-disable-next-line no-restricted-globals
 		fetch(url.toString())
@@ -271,6 +286,7 @@ export class LicenseManager {
 				isPerpetualLicense,
 				isPerpetualLicenseExpired: isPerpetualLicense && this.isPerpetualLicenseExpired(expiryDate),
 				isInternalLicense: this.isFlagEnabled(licenseInfo.flags, FLAGS.INTERNAL_LICENSE),
+				isNativeLicense: this.isNativeLicense(licenseInfo),
 				isLicensedWithWatermark: this.isFlagEnabled(licenseInfo.flags, FLAGS.WITH_WATERMARK),
 				isEvaluationLicense,
 				isEvaluationLicenseExpired:
@@ -291,13 +307,13 @@ export class LicenseManager {
 		const currentHostname = window.location.hostname.toLowerCase()
 
 		return licenseInfo.hosts.some((host) => {
-			const normalizedHost = host.toLowerCase().trim()
+			const normalizedHostOrUrlRegex = host.toLowerCase().trim()
 
 			// Allow the domain if listed and www variations, 'example.com' allows 'example.com' and 'www.example.com'
 			if (
-				normalizedHost === currentHostname ||
-				`www.${normalizedHost}` === currentHostname ||
-				normalizedHost === `www.${currentHostname}`
+				normalizedHostOrUrlRegex === currentHostname ||
+				`www.${normalizedHostOrUrlRegex}` === currentHostname ||
+				normalizedHostOrUrlRegex === `www.${currentHostname}`
 			) {
 				return true
 			}
@@ -308,6 +324,12 @@ export class LicenseManager {
 				return true
 			}
 
+			// Native license support
+			// In this case, `normalizedHost` is actually a protocol, e.g. `app-bundle:`
+			if (this.isNativeLicense(licenseInfo)) {
+				return new RegExp(normalizedHostOrUrlRegex).test(window.location.href)
+			}
+
 			// Glob testing, we only support '*.somedomain.com' right now.
 			if (host.includes('*')) {
 				const globToRegex = new RegExp(host.replace(/\*/g, '.*?'))
@@ -318,7 +340,7 @@ export class LicenseManager {
 			if (window.location.protocol === 'vscode-webview:') {
 				const currentUrl = new URL(window.location.href)
 				const extensionId = currentUrl.searchParams.get('extensionId')
-				if (normalizedHost === extensionId) {
+				if (normalizedHostOrUrlRegex === extensionId) {
 					return true
 				}
 			}
@@ -327,6 +349,10 @@ export class LicenseManager {
 		})
 	}
 
+	private isNativeLicense(licenseInfo: LicenseInfo) {
+		return this.isFlagEnabled(licenseInfo.flags, FLAGS.NATIVE_LICENSE)
+	}
+
 	private getExpirationDateWithoutGracePeriod(expiryDate: Date) {
 		return new Date(expiryDate.getFullYear(), expiryDate.getMonth(), expiryDate.getDate())
 	}

package/src/lib/license/Watermark.tsx

@@ -3,7 +3,7 @@ import { memo, useRef } from 'react'
 import { useCanvasEvents } from '../hooks/useCanvasEvents'
 import { useEditor } from '../hooks/useEditor'
 import { usePassThroughWheelEvents } from '../hooks/usePassThroughWheelEvents'
-import { preventDefault, stopEventPropagation } from '../utils/dom'
+import { markEventAsHandled, preventDefault } from '../utils/dom'
 import { runtime } from '../utils/runtime'
 import { watermarkDesktopSvg, watermarkMobileSvg } from '../watermarks'
 import { LicenseManager } from './LicenseManager'
@@ -64,7 +64,7 @@ const UnlicensedWatermark = memo(function UnlicensedWatermark({
 				draggable={false}
 				role="button"
 				onPointerDown={(e) => {
-					stopEventPropagation(e)
+					markEventAsHandled(e)
 					preventDefault(e)
 				}}
 				title="Unlicensed - click to get a license"
@@ -127,7 +127,7 @@ const WatermarkInner = memo(function WatermarkInner({
 				draggable={false}
 				role="button"
 				onPointerDown={(e) => {
-					stopEventPropagation(e)
+					markEventAsHandled(e)
 					preventDefault(e)
 				}}
 				title="made with tldraw"

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)