@tldraw/editor 3.16.0-canary.8f1957952f19 → 3.16.0-canary.940daaae9993

package/src/lib/editor/Editor.ts

@@ -4680,8 +4680,10 @@ export class Editor extends EventEmitter<TLEventMap> {
 		return this.store.createComputedCache<Box, TLShape>('pageBoundsCache', (shape) => {
 			const pageTransform = this.getShapePageTransform(shape)
 			if (!pageTransform) return undefined
-			const geometry = this.getShapeGeometry(shape)
-			return Box.FromPoints(pageTransform.applyToPoints(geometry.vertices))
+
+			return Box.FromPoints(
+				pageTransform.applyToPoints(this.getShapeGeometry(shape).boundsVertices)
+			)
 		})
 	}
 

package/src/lib/editor/derivations/notVisibleShapes.ts

@@ -7,6 +7,12 @@ function fromScratch(editor: Editor): Set<TLShapeId> {
 	const viewportPageBounds = editor.getViewportPageBounds()
 	const notVisibleShapes = new Set<TLShapeId>()
 	shapesIds.forEach((id) => {
+		const shape = editor.getShape(id)
+		if (!shape) return
+
+		const canCull = editor.getShapeUtil(shape.type).canCull(shape)
+		if (!canCull) return
+
 		// If the shape is fully outside of the viewport page bounds, add it to the set.
 		// We'll ignore masks here, since they're more expensive to compute and the overhead is not worth it.
 		const pageBounds = editor.getShapePageBounds(id)

package/src/lib/editor/shapes/ShapeUtil.ts

@@ -283,6 +283,17 @@ export abstract class ShapeUtil<Shape extends TLUnknownShape = TLUnknownShape> {
 		return true
 	}
 
+	/**
+	 * Whether this shape can be culled. By default, shapes are culled for
+	 * performance reasons when they are outside of the viewport. Culled shapes are still rendered
+	 * to the DOM, but have their `display` property set to `none`.
+	 *
+	 * @param shape - The shape.
+	 */
+	canCull(_shape: Shape): boolean {
+		return true
+	}
+
 	/**
 	 * Does this shape provide a background for its children? If this is true,
 	 * then any children with a `renderBackground` method will have their

package/src/lib/license/LicenseProvider.tsx

@@ -17,7 +17,7 @@ export const LICENSE_TIMEOUT = 5000
 
 /** @internal */
 export function LicenseProvider({
-	licenseKey,
+	licenseKey = getLicenseKeyFromEnv() ?? undefined,
 	children,
 }: {
 	licenseKey?: string
@@ -51,3 +51,42 @@ export function LicenseProvider({
 function LicenseGate() {
 	return <div data-testid="tl-license-expired" style={{ display: 'none' }} />
 }
+
+let envLicenseKey: string | undefined | null = undefined
+function getLicenseKeyFromEnv() {
+	if (envLicenseKey !== undefined) {
+		return envLicenseKey
+	}
+	// it's important here that we write out the full process.env.WHATEVER expression instead of
+	// doing something like process.env[someVariable]. This is because most bundlers do something
+	// like a find-replace inject environment variables, and so won't pick up on dynamic ones. It
+	// also means we can't do checks like `process.env && process.env.WHATEVER`, which is why we use
+	// the `getEnv` try/catch approach.
+
+	// framework-specific prefixes borrowed from the ones vercel uses, but trimmed down to just the
+	// react-y ones: https://vercel.com/docs/environment-variables/framework-environment-variables
+	envLicenseKey =
+		getEnv(() => process.env.TLDRAW_LICENSE_KEY) ||
+		getEnv(() => process.env.NEXT_PUBLIC_TLDRAW_LICENSE_KEY) ||
+		getEnv(() => process.env.REACT_APP_TLDRAW_LICENSE_KEY) ||
+		getEnv(() => process.env.GATSBY_TLDRAW_LICENSE_KEY) ||
+		getEnv(() => process.env.VITE_TLDRAW_LICENSE_KEY) ||
+		getEnv(() => process.env.PUBLIC_TLDRAW_LICENSE_KEY) ||
+		getEnv(() => (import.meta as any).env.TLDRAW_LICENSE_KEY) ||
+		getEnv(() => (import.meta as any).env.NEXT_PUBLIC_TLDRAW_LICENSE_KEY) ||
+		getEnv(() => (import.meta as any).env.REACT_APP_TLDRAW_LICENSE_KEY) ||
+		getEnv(() => (import.meta as any).env.GATSBY_TLDRAW_LICENSE_KEY) ||
+		getEnv(() => (import.meta as any).env.VITE_TLDRAW_LICENSE_KEY) ||
+		getEnv(() => (import.meta as any).env.PUBLIC_TLDRAW_LICENSE_KEY) ||
+		null
+
+	return envLicenseKey
+}
+
+function getEnv(cb: () => string | undefined) {
+	try {
+		return cb()
+	} catch {
+		return undefined
+	}
+}

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)

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

@@ -50,6 +50,7 @@ export interface TransformedGeometry2dOptions {
 	isInternal?: boolean
 	debugColor?: string
 	ignore?: boolean
+	excludeFromShapeBounds?: boolean
 }
 
 /** @public */
@@ -66,11 +67,17 @@ export abstract class Geometry2d {
 	isLabel = false
 	isEmptyLabel = false
 	isInternal = false
+	excludeFromShapeBounds = false
 	debugColor?: string
 	ignore?: boolean
 
 	constructor(opts: Geometry2dOptions) {
-		const { isLabel = false, isEmptyLabel = false, isInternal = false } = opts
+		const {
+			isLabel = false,
+			isEmptyLabel = false,
+			isInternal = false,
+			excludeFromShapeBounds = false,
+		} = opts
 		this.isFilled = opts.isFilled
 		this.isClosed = opts.isClosed
 		this.debugColor = opts.debugColor
@@ -78,6 +85,7 @@ export abstract class Geometry2d {
 		this.isLabel = isLabel
 		this.isEmptyLabel = isEmptyLabel
 		this.isInternal = isInternal
+		this.excludeFromShapeBounds = excludeFromShapeBounds
 	}
 
 	isExcludedByFilter(filters?: Geometry2dFilters) {
@@ -301,8 +309,23 @@ export abstract class Geometry2d {
 		return this._vertices
 	}
 
+	getBoundsVertices(): Vec[] {
+		if (this.excludeFromShapeBounds) return []
+		return this.vertices
+	}
+
+	private _boundsVertices: Vec[] | undefined
+
+	// eslint-disable-next-line no-restricted-syntax
+	get boundsVertices(): Vec[] {
+		if (!this._boundsVertices) {
+			this._boundsVertices = this.getBoundsVertices()
+		}
+		return this._boundsVertices
+	}
+
 	getBounds() {
-		return Box.FromPoints(this.vertices)
+		return Box.FromPoints(this.boundsVertices)
 	}
 
 	private _bounds: Box | undefined
@@ -429,6 +452,10 @@ export class TransformedGeometry2d extends Geometry2d {
 		return this.geometry.getVertices(filters).map((v) => Mat.applyToPoint(this.matrix, v))
 	}
 
+	getBoundsVertices(): Vec[] {
+		return this.geometry.getBoundsVertices().map((v) => Mat.applyToPoint(this.matrix, v))
+	}
+
 	nearestPoint(point: VecLike, filters?: Geometry2dFilters): Vec {
 		return Mat.applyToPoint(
 			this.matrix,

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

@@ -114,6 +114,11 @@ export class Group2d extends Geometry2d {
 		})
 	}
 
+	override getBoundsVertices(): Vec[] {
+		if (this.excludeFromShapeBounds) return []
+		return this.children.flatMap((child) => child.getBoundsVertices())
+	}
+
 	override intersectPolygon(polygon: VecLike[], filters?: Geometry2dFilters) {
 		return this.children.flatMap((child) => {
 			if (child.isExcludedByFilter(filters)) return EMPTY_ARRAY
@@ -205,7 +210,7 @@ export class Group2d extends Geometry2d {
 			path += child.toSimpleSvgPath()
 		}
 
-		const corners = Box.FromPoints(this.vertices).corners
+		const corners = Box.FromPoints(this.boundsVertices).corners
 		// draw just a few pixels around each corner, e.g. an L shape for the bottom left
 
 		for (let i = 0, n = corners.length; i < n; i++) {

package/src/version.ts

@@ -1,9 +1,9 @@
 // This file is automatically generated by internal/scripts/refresh-assets.ts.
 // Do not edit manually. Or do, I'm a comment, not a cop.
 
-export const version = '3.16.0-canary.8f1957952f19'
+export const version = '3.16.0-canary.940daaae9993'
 export const publishDates = {
 	major: '2024-09-13T14:36:29.063Z',
-	minor: '2025-09-06T10:47:06.916Z',
-	patch: '2025-09-06T10:47:06.916Z',
+	minor: '2025-09-11T09:41:08.921Z',
+	patch: '2025-09-11T09:41:08.921Z',
 }