tldraw 3.16.0-canary.b802b60e813f → 3.16.0-canary.ba3bc37d4418

package/src/lib/ui/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.b802b60e813f'
+export const version = '3.16.0-canary.ba3bc37d4418'
 export const publishDates = {
 	major: '2024-09-13T14:36:29.063Z',
-	minor: '2025-08-21T14:37:37.229Z',
-	patch: '2025-08-21T14:37:37.229Z',
+	minor: '2025-09-16T14:55:49.384Z',
+	patch: '2025-09-16T14:55:49.384Z',
 }

package/src/lib/ui.css

@@ -494,6 +494,10 @@
 	-webkit-user-select: auto !important;
 }
 
+.tlui-input::placeholder {
+	color: var(--tl-color-text-3);
+}
+
 .tlui-input__wrapper {
 	width: 100%;
 	height: 44px;
@@ -578,6 +582,12 @@
 	box-shadow: var(--tl-shadow-3);
 }
 
+@media (max-height: 600px) {
+	.tlui-menu {
+		max-height: 70vh;
+	}
+}
+
 .tlui-menu::-webkit-scrollbar {
 	display: none;
 }
@@ -1007,9 +1017,23 @@
 	flex-direction: column;
 }
 
-.tlui-style-panel__section:nth-of-type(n + 2):not(:last-child) {
+/*
+add a border to the bottom of all but the last section. we have to handle empty sections too, which
+are hidden and shouldn't be counted
+*/
+.tlui-style-panel__section:not(:nth-last-child(-n + 1 of .tlui-style-panel__section:not(:empty))) {
 	border-bottom: 1px solid var(--tl-color-divider);
 }
+/*
+if a section ends with a slider and we're adding a border, we need some extra space for visual
+balance. we need to handle empty sections as above. is this the most complex css selector in all of
+tldraw? probably.
+*/
+.tlui-style-panel__section:has(.tlui-slider__container:last-child):not(
+		:nth-last-child(-n + 1 of .tlui-style-panel__section:not(:empty))
+	) {
+	margin-bottom: 7px;
+}
 
 .tlui-style-panel__section:empty {
 	display: none;
@@ -1021,7 +1045,7 @@
 }
 
 .tlui-style-panel__dropdown-picker:only-child {
-	width: 100%;
+	flex: 1;
 }
 
 .tlui-style-panel__double-select-picker {

package/src/lib/utils/export/copyAs.ts

@@ -31,30 +31,7 @@ export interface CopyAsOptions extends TLImageExportOptions {
  *
  * @public
  */
-export function copyAs(editor: Editor, ids: TLShapeId[], opts: CopyAsOptions): Promise<void>
-/**
- * @deprecated The format parameter is now part of the opts object.
- * @public
- */
-export function copyAs(
-	editor: Editor,
-	ids: TLShapeId[],
-	format: TLCopyType,
-	opts?: TLImageExportOptions & { format?: undefined }
-): Promise<void>
-export function copyAs(
-	...args:
-		| [editor: Editor, ids: TLShapeId[], opts: TLImageExportOptions & { format: TLCopyType }]
-		| [
-				editor: Editor,
-				ids: TLShapeId[],
-				format: TLCopyType,
-				opts?: TLImageExportOptions & { format?: undefined },
-		  ]
-) {
-	const [editor, ids, opts] =
-		typeof args[2] === 'string' ? [args[0], args[1], { ...args[3], format: args[2] }] : args
-
+export function copyAs(editor: Editor, ids: TLShapeId[], opts: CopyAsOptions): Promise<void> {
 	// Note:  it's important that this function itself isn't async and doesn't really use promises -
 	// we need to create the relevant `ClipboardItem`s and call navigator.clipboard.write
 	// synchronously to make sure safari knows that the user _wants_ to copy See

package/src/lib/utils/export/export.ts

@@ -1,7 +1,6 @@
 import {
 	Editor,
 	FileHelpers,
-	TLExportType,
 	TLImageExportOptions,
 	TLShapeId,
 	exhaustiveSwitchError,
@@ -35,41 +34,6 @@ export async function exportToString(
 	}
 }
 
-/**
- * Export the given shapes as a blob.
- * @param editor - The editor instance.
- * @param ids - The ids of the shapes to export.
- * @param format - The format to export as.
- * @param opts - Rendering options.
- * @returns A promise that resolves to a blob.
- * @deprecated Use {@link @tldraw/editor#Editor.toImage} instead.
- * @public
- */
-export async function exportToBlob({
-	editor,
-	ids,
-	format,
-	opts = {},
-}: {
-	editor: Editor
-	ids: TLShapeId[]
-	format: TLExportType
-	opts?: TLImageExportOptions
-}): Promise<Blob> {
-	const idsToUse = ids?.length ? ids : [...editor.getCurrentPageShapeIds()]
-	switch (format) {
-		case 'jpeg':
-		case 'png':
-		case 'webp':
-		case 'svg': {
-			return (await editor.toImage(idsToUse, { ...opts, format })).blob
-		}
-		default: {
-			exhaustiveSwitchError(format)
-		}
-	}
-}
-
 const clipboardMimeTypesByFormat = {
 	jpeg: 'image/jpeg',
 	png: 'image/png',

package/src/lib/utils/export/exportAs.ts

@@ -28,38 +28,7 @@ export async function exportAs(
 	editor: Editor,
 	ids: TLShapeId[],
 	opts: ExportAsOptions
-): Promise<void>
-/**
- * @deprecated The format & name parameters are now part of the opts object.
- * @public
- */
-export async function exportAs(
-	editor: Editor,
-	ids: TLShapeId[],
-	format?: TLExportType,
-	name?: string,
-	opts?: TLImageExportOptions
-): Promise<void>
-export async function exportAs(
-	...args:
-		| [
-				editor: Editor,
-				ids: TLShapeId[],
-				opts: TLImageExportOptions & { format: TLExportType; name?: string },
-		  ]
-		| [
-				editor: Editor,
-				ids: TLShapeId[],
-				format?: TLExportType,
-				name?: string,
-				opts?: TLImageExportOptions,
-		  ]
-) {
-	const [editor, ids, opts] =
-		typeof args[2] === 'object'
-			? args
-			: [args[0], args[1], { ...args[4], format: args[2] ?? 'png', name: args[3] }]
-
+): Promise<void> {
 	// If we don't get name then use a predefined one
 	let name = opts.name
 	if (!name) {

package/src/test/custom-clipping.test.ts

@@ -0,0 +1,436 @@
+import {
+	atom,
+	BaseBoxShapeUtil,
+	Circle2d,
+	createShapeId,
+	Geometry2d,
+	RecordProps,
+	resizeBox,
+	StateNode,
+	T,
+	TLBaseShape,
+	TLEventHandlers,
+	TLGeoShape,
+	TLResizeInfo,
+	TLShape,
+	TLTextShape,
+	toRichText,
+	Vec,
+} from '@tldraw/editor'
+import { TestEditor } from './TestEditor'
+
+// Custom Circle Clip Shape Definition
+export type CircleClipShape = TLBaseShape<
+	'circle-clip',
+	{
+		w: number
+		h: number
+	}
+>
+
+export const isClippingEnabled$ = atom('isClippingEnabled', true)
+
+export class CircleClipShapeUtil extends BaseBoxShapeUtil<CircleClipShape> {
+	static override type = 'circle-clip' as const
+	static override props: RecordProps<CircleClipShape> = {
+		w: T.number,
+		h: T.number,
+	}
+
+	override canBind() {
+		return false
+	}
+
+	override canReceiveNewChildrenOfType(shape: TLShape) {
+		return !shape.isLocked
+	}
+
+	override getDefaultProps(): CircleClipShape['props'] {
+		return {
+			w: 200,
+			h: 200,
+		}
+	}
+
+	override getGeometry(shape: CircleClipShape): Geometry2d {
+		const radius = Math.min(shape.props.w, shape.props.h) / 2
+		return new Circle2d({
+			radius,
+			x: shape.props.w / 2 - radius,
+			y: shape.props.h / 2 - radius,
+			isFilled: true,
+		})
+	}
+
+	override getClipPath(shape: CircleClipShape): Vec[] | undefined {
+		// Generate a polygon approximation of the circle
+		const centerX = shape.props.w / 2
+		const centerY = shape.props.h / 2
+		const radius = Math.min(shape.props.w, shape.props.h) / 2
+		const segments = 48 // More segments = smoother circle
+
+		const points: Vec[] = []
+		for (let i = 0; i < segments; i++) {
+			const angle = (i / segments) * Math.PI * 2
+			const x = centerX + Math.cos(angle) * radius
+			const y = centerY + Math.sin(angle) * radius
+			points.push(new Vec(x, y))
+		}
+
+		return points
+	}
+
+	override shouldClipChild(_child: TLShape): boolean {
+		// For now, clip all children - we removed the onlyClipText feature for simplicity
+		return isClippingEnabled$.get()
+	}
+
+	override component(_shape: CircleClipShape) {
+		// For testing purposes, we'll just return null
+		// In a real implementation, this would return JSX
+		return null as any
+	}
+
+	override indicator(_shape: CircleClipShape) {
+		// For testing purposes, we'll just return null
+		// In a real implementation, this would return JSX
+		return null as any
+	}
+
+	override onResize(shape: CircleClipShape, info: TLResizeInfo<CircleClipShape>) {
+		return resizeBox(shape, info)
+	}
+}
+
+export class CircleClipShapeTool extends StateNode {
+	static override id = 'circle-clip'
+
+	override onEnter(): void {
+		this.editor.setCursor({ type: 'cross', rotation: 0 })
+	}
+
+	override onPointerDown(info: Parameters<TLEventHandlers['onPointerDown']>[0]) {
+		if (info.target === 'canvas') {
+			const { originPagePoint } = this.editor.inputs
+
+			this.editor.createShape<CircleClipShape>({
+				type: 'circle-clip',
+				x: originPagePoint.x - 100,
+				y: originPagePoint.y - 100,
+				props: {
+					w: 200,
+					h: 200,
+				},
+			})
+		}
+	}
+}
+
+let editor: TestEditor
+
+afterEach(() => {
+	editor?.dispose()
+})
+
+const ids = {
+	circleClip1: createShapeId('circleClip1'),
+	circleClip2: createShapeId('circleClip2'),
+	text1: createShapeId('text1'),
+	geo1: createShapeId('geo1'),
+	geo2: createShapeId('geo2'),
+}
+
+beforeEach(() => {
+	editor = new TestEditor({
+		shapeUtils: [CircleClipShapeUtil],
+		tools: [CircleClipShapeTool],
+	})
+
+	// Reset clipping state
+	isClippingEnabled$.set(true)
+})
+
+describe('CircleClipShapeUtil', () => {
+	describe('shape creation and properties', () => {
+		it('should create a circle clip shape with default properties', () => {
+			editor.createShape<CircleClipShape>({
+				id: ids.circleClip1,
+				type: 'circle-clip',
+				x: 100,
+				y: 100,
+				props: {
+					w: 200,
+					h: 200,
+				},
+			})
+
+			const shape = editor.getShape<CircleClipShape>(ids.circleClip1)
+			expect(shape).toBeDefined()
+			expect(shape!.type).toBe('circle-clip')
+			expect(shape!.props.w).toBe(200)
+			expect(shape!.props.h).toBe(200)
+		})
+
+		it('should use default props when not specified', () => {
+			editor.createShape<CircleClipShape>({
+				id: ids.circleClip1,
+				type: 'circle-clip',
+				x: 100,
+				y: 100,
+				props: {},
+			})
+
+			const shape = editor.getShape<CircleClipShape>(ids.circleClip1)
+			expect(shape!.props.w).toBe(200) // default from getDefaultProps
+			expect(shape!.props.h).toBe(200) // default from getDefaultProps
+		})
+	})
+
+	describe('geometry and clipping', () => {
+		it('should generate correct circle geometry', () => {
+			editor.createShape<CircleClipShape>({
+				id: ids.circleClip1,
+				type: 'circle-clip',
+				x: 100,
+				y: 100,
+				props: {
+					w: 200,
+					h: 200,
+				},
+			})
+
+			const shape = editor.getShape<CircleClipShape>(ids.circleClip1)
+			const util = editor.getShapeUtil<CircleClipShape>('circle-clip')
+			const geometry = util.getGeometry(shape!)
+
+			expect(geometry).toBeDefined()
+			expect(geometry.bounds).toBeDefined()
+			expect(geometry.bounds.width).toBe(200)
+			expect(geometry.bounds.height).toBe(200)
+		})
+
+		it('should generate clip path for circle', () => {
+			editor.createShape<CircleClipShape>({
+				id: ids.circleClip1,
+				type: 'circle-clip',
+				x: 100,
+				y: 100,
+				props: {
+					w: 200,
+					h: 200,
+				},
+			})
+
+			const shape = editor.getShape<CircleClipShape>(ids.circleClip1)
+			const util = editor.getShapeUtil<CircleClipShape>('circle-clip')
+			const clipPath = util.getClipPath?.(shape!)
+			if (!clipPath) throw new Error('Clip path is undefined')
+
+			expect(clipPath).toBeDefined()
+			expect(Array.isArray(clipPath)).toBe(true)
+			expect(clipPath.length).toBeGreaterThan(0)
+
+			// Should be a polygon approximation of a circle
+			// Check that points are roughly in a circle pattern
+			const centerX = 100 // shape.x
+			const centerY = 100 // shape.y
+			const radius = 100 // min(w, h) / 2
+
+			clipPath.forEach((point) => {
+				const distance = Math.sqrt(Math.pow(point.x - centerX, 2) + Math.pow(point.y - centerY, 2))
+				expect(distance).toBeCloseTo(radius, 0)
+			})
+		})
+	})
+
+	describe('child clipping behavior', () => {
+		it('should clip children when clipping is enabled', () => {
+			editor.createShape<CircleClipShape>({
+				id: ids.circleClip1,
+				type: 'circle-clip',
+				x: 100,
+				y: 100,
+				props: {
+					w: 200,
+					h: 200,
+				},
+			})
+
+			editor.createShape<TLTextShape>({
+				id: ids.text1,
+				type: 'text',
+				x: 0,
+				y: 0,
+				parentId: ids.circleClip1,
+				props: {
+					richText: toRichText('Test text'),
+				},
+			})
+
+			const util = editor.getShapeUtil<CircleClipShape>('circle-clip')
+			const textShape = editor.getShape<TLTextShape>(ids.text1)
+
+			// Clipping should be enabled by default
+			expect(isClippingEnabled$.get()).toBe(true)
+			expect(util.shouldClipChild?.(textShape!)).toBe(true)
+			expect(editor.getShapeClipPath(ids.text1)).toBeDefined()
+		})
+
+		it('should not clip children when clipping is disabled', () => {
+			isClippingEnabled$.set(false)
+
+			editor.createShape<CircleClipShape>({
+				id: ids.circleClip1,
+				type: 'circle-clip',
+				x: 100,
+				y: 100,
+				props: {
+					w: 200,
+					h: 200,
+				},
+			})
+
+			editor.createShape<TLTextShape>({
+				id: ids.text1,
+				type: 'text',
+				x: 0,
+				y: 0,
+				parentId: ids.circleClip1,
+				props: {
+					richText: toRichText('Test text'),
+				},
+			})
+
+			const util = editor.getShapeUtil<CircleClipShape>('circle-clip')
+			const textShape = editor.getShape<TLTextShape>(ids.text1)
+
+			expect(isClippingEnabled$.get()).toBe(false)
+			expect(util.shouldClipChild?.(textShape!)).toBe(false)
+			expect(editor.getShapeClipPath(ids.text1)).toBeUndefined()
+		})
+	})
+})
+
+describe('Integration tests', () => {
+	it('should create and manage circle clip shapes with children', () => {
+		// Create circle clip shape
+		editor.createShape<CircleClipShape>({
+			id: ids.circleClip1,
+			type: 'circle-clip',
+			x: 100,
+			y: 100,
+			props: {
+				w: 200,
+				h: 200,
+			},
+		})
+
+		// Add text child
+		editor.createShape<TLTextShape>({
+			id: ids.text1,
+			type: 'text',
+			x: 50,
+			y: 50,
+			parentId: ids.circleClip1,
+			props: {
+				richText: toRichText('Clipped text'),
+			},
+		})
+
+		// Add geo child
+		editor.createShape<TLGeoShape>({
+			id: ids.geo1,
+			type: 'geo',
+			x: 150,
+			y: 150,
+			parentId: ids.circleClip1,
+			props: {
+				w: 50,
+				h: 50,
+			},
+		})
+
+		const circleClipShape = editor.getShape<CircleClipShape>(ids.circleClip1)
+		const textShape = editor.getShape<TLTextShape>(ids.text1)
+		const geoShape = editor.getShape<TLGeoShape>(ids.geo1)
+
+		expect(circleClipShape).toBeDefined()
+		expect(textShape!.parentId).toBe(ids.circleClip1)
+		expect(geoShape!.parentId).toBe(ids.circleClip1)
+
+		// Verify clipping behavior
+		const util = editor.getShapeUtil<CircleClipShape>('circle-clip')
+		expect(util.shouldClipChild?.(textShape!)).toBe(true)
+		expect(util.shouldClipChild?.(geoShape!)).toBe(true)
+		expect(editor.getShapeClipPath(ids.text1)).toBeDefined()
+		expect(editor.getShapeClipPath(ids.geo1)).toBeDefined()
+
+		// Test clipping toggle
+		isClippingEnabled$.set(false)
+		expect(util.shouldClipChild?.(textShape!)).toBe(false)
+		expect(util.shouldClipChild?.(geoShape!)).toBe(false)
+		expect(editor.getShapeClipPath(ids.text1)).toBeUndefined()
+		expect(editor.getShapeClipPath(ids.geo1)).toBeUndefined()
+	})
+
+	it('should handle multiple circle clip shapes independently', () => {
+		// Create two circle clip shapes
+		editor.createShape<CircleClipShape>({
+			id: ids.circleClip1,
+			type: 'circle-clip',
+			x: 100,
+			y: 100,
+			props: {
+				w: 200,
+				h: 200,
+			},
+		})
+
+		editor.createShape<CircleClipShape>({
+			id: ids.circleClip2,
+			type: 'circle-clip',
+			x: 400,
+			y: 100,
+			props: {
+				w: 150,
+				h: 150,
+			},
+		})
+
+		// Add children to both
+		editor.createShape<TLTextShape>({
+			id: ids.text1,
+			type: 'text',
+			x: 0,
+			y: 0,
+			parentId: ids.circleClip1,
+			props: {
+				richText: toRichText('First clip'),
+			},
+		})
+
+		editor.createShape<TLTextShape>({
+			id: ids.geo1,
+			type: 'text',
+			x: 0,
+			y: 0,
+			parentId: ids.circleClip2,
+			props: {
+				richText: toRichText('Second clip'),
+			},
+		})
+
+		const util = editor.getShapeUtil<CircleClipShape>('circle-clip')
+		const text1 = editor.getShape<TLTextShape>(ids.text1)
+		const text2 = editor.getShape<TLTextShape>(ids.geo1)
+
+		// Both should be clipped when enabled
+		expect(util.shouldClipChild?.(text1!)).toBe(true)
+		expect(util.shouldClipChild?.(text2!)).toBe(true)
+
+		// Both should not be clipped when disabled
+		isClippingEnabled$.set(false)
+		expect(util.shouldClipChild?.(text1!)).toBe(false)
+		expect(util.shouldClipChild?.(text2!)).toBe(false)
+	})
+})

package/src/test/getCulledShapes.test.tsx

@@ -1,12 +1,50 @@
-import { Box, TLShapeId, createShapeId } from '@tldraw/editor'
+import {
+	BaseBoxShapeUtil,
+	Box,
+	RecordProps,
+	T,
+	TLBaseShape,
+	TLShapeId,
+	createShapeId,
+} from '@tldraw/editor'
 import { vi } from 'vitest'
 import { TestEditor } from './TestEditor'
 import { TL } from './test-jsx'
 
+// Custom uncullable shape type for testing canCull override
+type UncullableShape = TLBaseShape<'uncullable', { w: number; h: number }>
+
+class UncullableShapeUtil extends BaseBoxShapeUtil<UncullableShape> {
+	static override type = 'uncullable' as const
+	static override props: RecordProps<UncullableShape> = {
+		w: T.number,
+		h: T.number,
+	}
+
+	override canCull() {
+		return false
+	}
+
+	override getDefaultProps(): UncullableShape['props'] {
+		return {
+			w: 100,
+			h: 100,
+		}
+	}
+
+	override component() {
+		return <div>Uncullable shape</div>
+	}
+
+	override indicator() {
+		return <div>Uncullable shape</div>
+	}
+}
+
 let editor: TestEditor
 
 beforeEach(() => {
-	editor = new TestEditor()
+	editor = new TestEditor({ shapeUtils: [UncullableShapeUtil] })
 	editor.setScreenBounds({ x: 0, y: 0, w: 1800, h: 900 })
 })
 
@@ -203,3 +241,34 @@ it('works for shapes that are outside of the viewport, but are then moved inside
 	// Arrow should also not be culled
 	expect(editor.getCulledShapes()).toEqual(new Set())
 })
+
+it('respects canCull override - shapes that cannot be culled are never culled', () => {
+	const cullableShapeId = createShapeId()
+	const uncullableShapeId = createShapeId()
+
+	// Create both shapes outside the viewport
+	editor.createShapes([
+		{
+			id: cullableShapeId,
+			type: 'geo',
+			x: -2000, // Way outside viewport
+			y: -2000,
+			props: { w: 100, h: 100 },
+		},
+		{
+			id: uncullableShapeId,
+			type: 'uncullable',
+			x: -2000, // Way outside viewport
+			y: -2000,
+			props: { w: 100, h: 100 },
+		},
+	])
+
+	const culledShapes = editor.getCulledShapes()
+
+	// The regular geo shape should be culled since it's outside the viewport
+	expect(culledShapes).toContain(cullableShapeId)
+
+	// The uncullable shape should NOT be culled even though it's outside the viewport
+	expect(culledShapes).not.toContain(uncullableShapeId)
+})