@tldraw/editor 4.6.0-next.d15997ff5a4b → 4.6.0-next.d8328a2dcc3d

package/src/lib/editor/managers/UserPreferencesManager/UserPreferencesManager.ts

@@ -1,5 +1,5 @@
 import { atom, computed } from '@tldraw/state'
-import { TLUser } from '../../../config/createTLUser'
+import { TLCurrentUser } from '../../../config/createTLCurrentUser'
 import { TLUserPreferences, defaultUserPreferences } from '../../../config/TLUserPreferences'
 import { getGlobalWindow } from '../../../utils/dom'
 
@@ -11,7 +11,7 @@ export class UserPreferencesManager {
 		this.disposables.forEach((d) => d())
 	}
 	constructor(
-		private readonly user: TLUser,
+		private readonly user: TLCurrentUser,
 		private readonly inferDarkMode: boolean
 	) {
 		if (typeof window === 'undefined' || !getGlobalWindow().matchMedia) return

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

@@ -590,6 +590,17 @@ export abstract class ShapeUtil<Shape extends TLShape = TLShape> {
 		return undefined
 	}
 
+	/**
+	 * Return user IDs referenced in shape-specific props.
+	 * Used when copying shapes to include referenced users on the clipboard.
+	 * Override this if your shape stores user IDs in custom props.
+	 *
+	 * @public
+	 */
+	getReferencedUserIds(shape: Shape): string[] {
+		return EMPTY_ARRAY
+	}
+
 	getAriaDescriptor(shape: Shape): string | undefined {
 		return undefined
 	}

package/src/lib/editor/types/clipboard-types.ts

@@ -1,5 +1,5 @@
 import { SerializedSchema } from '@tldraw/store'
-import { TLAsset, TLBinding, TLShape, TLShapeId } from '@tldraw/tlschema'
+import { TLAsset, TLBinding, TLShape, TLShapeId, TLUser } from '@tldraw/tlschema'
 
 /** @public */
 export interface TLContent {
@@ -8,4 +8,5 @@ export interface TLContent {
 	rootShapeIds: TLShapeId[]
 	assets: TLAsset[]
 	schema: SerializedSchema
+	users?: TLUser[]
 }

package/src/lib/hooks/useGestureEvents.ts

@@ -1,7 +1,6 @@
-import type { AnyHandlerEventTypes, EventTypes, GestureKey, Handler } from '@use-gesture/core/types'
-import { createUseGesture, pinchAction, wheelAction } from '@use-gesture/react'
 import * as React from 'react'
 import { TLWheelEventInfo } from '../editor/types/event-types'
+import { tlenv } from '../globals/environment'
 import { Vec } from '../primitives/Vec'
 import { preventDefault } from '../utils/dom'
 import { isAccelKey } from '../utils/keyboard'
@@ -12,27 +11,27 @@ import { useEditor } from './useEditor'
 
 # How does pinching work?
 
-The pinching handler is fired under two circumstances: 
+The pinching handler is fired under two circumstances:
 - when a user is on a MacBook trackpad and is ZOOMING with a two-finger pinch
 - when a user is on a touch device and is ZOOMING with a two-finger pinch
 - when a user is on a touch device and is PANNING with two fingers
 
-Zooming is much more expensive than panning (because it causes shapes to render), 
-so we want to be sure that we don't zoom while two-finger panning. 
+Zooming is much more expensive than panning (because it causes shapes to render),
+so we want to be sure that we don't zoom while two-finger panning.
 
 In order to do this, we keep track of a "pinchState", which is either:
 - "zooming"
 - "panning"
 - "not sure"
 
-If a user is on a trackpad, the pinchState will be set to "zooming". 
+If a user is on a trackpad, the pinchState will be set to "zooming".
 
 If the user is on a touch screen, then we start in the "not sure" state and switch back and forth
 between "zooming", "panning", and "not sure" based on what the user is doing with their fingers.
 
 In the "not sure" state, we examine whether the user has moved the center of the gesture far enough
 to suggest that they're panning; or else that they've moved their fingers further apart or closer
-together enough to suggest that they're zooming. 
+together enough to suggest that they're zooming.
 
 In the "panning" state, we check whether the user's fingers have moved far enough apart to suggest
 that they're zooming. If they have, we switch to the "zooming" state.
@@ -42,62 +41,37 @@ In the "zooming" state, we just stay zooming—it's not YET possible to switch b
 todo: compare velocities of change in order to determine whether the user has switched back to panning
 */
 
-type check<T extends AnyHandlerEventTypes, Key extends GestureKey> = undefined extends T[Key]
-	? EventTypes[Key]
-	: T[Key]
-type PinchHandler = Handler<'pinch', check<EventTypes, 'pinch'>>
-
-const useGesture = createUseGesture([wheelAction, pinchAction])
-
-/**
- * GOTCHA
- *
- * UseGesture fires a wheel event 140ms after the gesture actually ends, with a momentum-adjusted
- * delta. This creates a messed up interaction where after you stop scrolling suddenly the dang page
- * jumps a tick. why do they do this? you are asking the wrong person. it seems intentional though.
- * anyway we want to ignore that last event, but there's no way to directly detect it so we need to
- * keep track of timestamps. Yes this is awful, I am sorry.
- */
-let lastWheelTime = undefined as undefined | number
-
-const isWheelEndEvent = (time: number) => {
-	if (lastWheelTime === undefined) {
-		lastWheelTime = time
-		return false
-	}
-
-	if (time - lastWheelTime > 120 && time - lastWheelTime < 160) {
-		lastWheelTime = time
-		return true
-	}
-
-	lastWheelTime = time
-	return false
+/** Safari's non-standard GestureEvent */
+interface GestureEvent extends Event {
+	scale: number
+	rotation: number
+	clientX: number
+	clientY: number
+	shiftKey: boolean
+	altKey: boolean
+	metaKey: boolean
+	ctrlKey: boolean
 }
 
 export function useGestureEvents(ref: React.RefObject<HTMLDivElement | null>) {
 	const editor = useEditor()
 
-	const events = React.useMemo(() => {
+	React.useEffect(() => {
+		const elm = ref.current
+		if (!elm) return
+
 		let pinchState = 'not sure' as 'not sure' | 'zooming' | 'panning'
 
-		const onWheel: Handler<'wheel', WheelEvent> = ({ event }) => {
+		// --- Wheel handling ---
+
+		function onWheel(event: WheelEvent) {
 			if (!editor.getInstanceState().isFocused) {
 				return
 			}
 
 			pinchState = 'not sure'
 
-			if (isWheelEndEvent(Date.now())) {
-				// ignore wheelEnd events
-				return
-			}
-
-			// Awful tht we need to put this logic here, but basically
-			// we don't want to handle the the wheel event (or call prevent
-			// default on the evnet) if the user is wheeling over an a shape
-			// that is scrollable which they're currently editing.
-
+			// Don't handle wheel events over a scrollable editing shape
 			const editingShapeId = editor.getEditingShapeId()
 			if (editingShapeId) {
 				const shape = editor.getShape(editingShapeId)
@@ -133,43 +107,38 @@ export function useGestureEvents(ref: React.RefObject<HTMLDivElement | null>) {
 			editor.dispatch(info)
 		}
 
+		// --- Touch pinch handling ---
+
 		let initDistanceBetweenFingers = 1 // the distance between the two fingers when the pinch starts
-		let initZoom = 1 // the browser's zoom level when the pinch starts
+		let initZoom = 1 // the zoom level when the pinch starts
 		let currDistanceBetweenFingers = 0
 		const initPointBetweenFingers = new Vec()
 		const prevPointBetweenFingers = new Vec()
 
-		const onPinchStart: PinchHandler = (gesture) => {
-			const elm = ref.current
-			pinchState = 'not sure'
-
-			const { event, origin, da } = gesture
-
-			if (event instanceof WheelEvent) return
-			if (!(event.target === elm || elm?.contains(event.target as Node))) return
-
-			prevPointBetweenFingers.x = origin[0]
-			prevPointBetweenFingers.y = origin[1]
-			initPointBetweenFingers.x = origin[0]
-			initPointBetweenFingers.y = origin[1]
-			initDistanceBetweenFingers = da[0]
-			initZoom = editor.getZoomLevel()
+		// Track active touches
+		let activeTouches: Touch[] = []
+
+		function getScaleBounds() {
+			const baseZoom = editor.getBaseZoom()
+			const { zoomSteps, zoomSpeed } = editor.getCameraOptions()
+			const zoomMin = zoomSteps[0] * baseZoom
+			const zoomMax = zoomSteps[zoomSteps.length - 1] * baseZoom
+			return {
+				min: zoomMin ** (1 / zoomSpeed),
+				max: zoomMax ** (1 / zoomSpeed),
+			}
+		}
 
-			editor.dispatch({
-				type: 'pinch',
-				name: 'pinch_start',
-				point: { x: origin[0], y: origin[1], z: editor.getZoomLevel() },
-				delta: { x: 0, y: 0 },
-				shiftKey: event.shiftKey,
-				altKey: event.altKey,
-				ctrlKey: event.metaKey || event.ctrlKey,
-				metaKey: event.metaKey,
-				accelKey: isAccelKey(event),
-			})
+		function getScaleFrom() {
+			const { zoomSpeed } = editor.getCameraOptions()
+			return editor.getZoomLevel() ** (1 / zoomSpeed)
 		}
 
-		// let timeout: any
-		const updatePinchState = (isSafariTrackpadPinch: boolean) => {
+		// Accumulated scale offset, clamped to bounds — replaces @use-gesture's offset[0]
+		let scaleOffset = 1
+		let initScaleFrom = 1 // the scale-space zoom level when the pinch started
+
+		function updatePinchState(isSafariTrackpadPinch: boolean) {
 			if (isSafariTrackpadPinch) {
 				pinchState = 'zooming'
 			}
@@ -183,7 +152,7 @@ export function useGestureEvents(ref: React.RefObject<HTMLDivElement | null>) {
 			//                          |----|     |------------|
 			//             originDistance ^           ^ touchDistance
 
-			// How far have the two touch points moved towards or away from eachother?
+			// How far have the two touch points moved towards or away from each other?
 			const touchDistance = Math.abs(currDistanceBetweenFingers - initDistanceBetweenFingers)
 			// How far has the point between the touches moved?
 			const originDistance = Vec.Dist(initPointBetweenFingers, prevPointBetweenFingers)
@@ -207,123 +176,226 @@ export function useGestureEvents(ref: React.RefObject<HTMLDivElement | null>) {
 			}
 		}
 
-		const onPinch: PinchHandler = (gesture) => {
-			const elm = ref.current
-			const { event, origin, offset, da } = gesture
+		function dispatchPinchEvent(
+			name: 'pinch_start' | 'pinch' | 'pinch_end',
+			origin: { x: number; y: number },
+			delta: { x: number; y: number },
+			zoom: number,
+			event: TouchEvent | GestureEvent
+		) {
+			editor.dispatch({
+				type: 'pinch',
+				name,
+				point: { x: origin.x, y: origin.y, z: zoom },
+				delta,
+				shiftKey: event.shiftKey,
+				altKey: event.altKey,
+				ctrlKey: event.metaKey || event.ctrlKey,
+				metaKey: event.metaKey,
+				accelKey: isAccelKey(event),
+			})
+		}
+
+		function getOriginAndDistance(t0: Touch, t1: Touch) {
+			const origin = {
+				x: (t0.clientX + t1.clientX) / 2,
+				y: (t0.clientY + t1.clientY) / 2,
+			}
+			const distance = Math.hypot(t1.clientX - t0.clientX, t1.clientY - t0.clientY)
+			return { origin, distance }
+		}
 
-			if (event instanceof WheelEvent) return
+		function onTouchStart(event: TouchEvent) {
 			if (!(event.target === elm || elm?.contains(event.target as Node))) return
 
-			// In (desktop) Safari, a two finger trackpad pinch will be a "gesturechange" event
-			// and will have 0 touches; on iOS, a two-finger pinch will be a "pointermove" event
-			// with two touches.
-			const isSafariTrackpadPinch =
-				gesture.type === 'gesturechange' || gesture.type === 'gestureend'
+			activeTouches = Array.from(event.touches)
+
+			if (activeTouches.length === 2) {
+				// Two fingers down — start pinch
+				pinchState = 'not sure'
+				const { origin, distance } = getOriginAndDistance(activeTouches[0], activeTouches[1])
+
+				prevPointBetweenFingers.x = origin.x
+				prevPointBetweenFingers.y = origin.y
+				initPointBetweenFingers.x = origin.x
+				initPointBetweenFingers.y = origin.y
+				initDistanceBetweenFingers = Math.max(distance, 1)
+				currDistanceBetweenFingers = distance
+				initZoom = editor.getZoomLevel()
+				initScaleFrom = getScaleFrom()
+				scaleOffset = initScaleFrom
 
-			// The distance between the two touch points
-			currDistanceBetweenFingers = da[0]
+				dispatchPinchEvent('pinch_start', origin, { x: 0, y: 0 }, editor.getZoomLevel(), event)
+			}
+		}
+
+		function onTouchMove(event: TouchEvent) {
+			activeTouches = Array.from(event.touches)
+
+			if (activeTouches.length < 2) return
+
+			const { origin, distance } = getOriginAndDistance(activeTouches[0], activeTouches[1])
+			currDistanceBetweenFingers = distance
+
+			const dx = origin.x - prevPointBetweenFingers.x
+			const dy = origin.y - prevPointBetweenFingers.y
+
+			prevPointBetweenFingers.x = origin.x
+			prevPointBetweenFingers.y = origin.y
+
+			updatePinchState(false)
 
 			// Only update the zoom if the pointers are far enough apart;
 			// a very small touchDistance means that the user has probably
 			// pinched out and their fingers are touching; this produces
 			// very unstable zooming behavior.
-
-			const dx = origin[0] - prevPointBetweenFingers.x
-			const dy = origin[1] - prevPointBetweenFingers.y
-
-			prevPointBetweenFingers.x = origin[0]
-			prevPointBetweenFingers.y = origin[1]
-
-			updatePinchState(isSafariTrackpadPinch)
+			const bounds = getScaleBounds()
+			const rawScale = initScaleFrom * (distance / initDistanceBetweenFingers)
+			scaleOffset = Math.min(bounds.max, Math.max(bounds.min, rawScale))
 
 			switch (pinchState) {
 				case 'zooming': {
-					const currZoom = offset[0] ** editor.getCameraOptions().zoomSpeed
-
-					editor.dispatch({
-						type: 'pinch',
-						name: 'pinch',
-						point: { x: origin[0], y: origin[1], z: currZoom },
-						delta: { x: dx, y: dy },
-						shiftKey: event.shiftKey,
-						altKey: event.altKey,
-						ctrlKey: event.metaKey || event.ctrlKey,
-						metaKey: event.metaKey,
-						accelKey: isAccelKey(event),
-					})
+					const currZoom = scaleOffset ** editor.getCameraOptions().zoomSpeed
+					dispatchPinchEvent('pinch', origin, { x: dx, y: dy }, currZoom, event)
 					break
 				}
 				case 'panning': {
-					editor.dispatch({
-						type: 'pinch',
-						name: 'pinch',
-						point: { x: origin[0], y: origin[1], z: initZoom },
-						delta: { x: dx, y: dy },
-						shiftKey: event.shiftKey,
-						altKey: event.altKey,
-						ctrlKey: event.metaKey || event.ctrlKey,
-						metaKey: event.metaKey,
-						accelKey: isAccelKey(event),
-					})
+					dispatchPinchEvent('pinch', origin, { x: dx, y: dy }, initZoom, event)
 					break
 				}
 			}
 		}
 
-		const onPinchEnd: PinchHandler = (gesture) => {
-			const elm = ref.current
-			const { event, origin, offset } = gesture
+		function onTouchEnd(event: TouchEvent) {
+			const wasPinching = activeTouches.length >= 2
+			activeTouches = Array.from(event.touches)
 
-			if (event instanceof WheelEvent) return
-			if (!(event.target === elm || elm?.contains(event.target as Node))) return
+			if (wasPinching && activeTouches.length < 2) {
+				// Pinch ended
+				const scale = scaleOffset ** editor.getCameraOptions().zoomSpeed
+				const origin = { ...prevPointBetweenFingers }
+				pinchState = 'not sure'
+
+				editor.timers.requestAnimationFrame(() => {
+					dispatchPinchEvent('pinch_end', origin, { x: origin.x, y: origin.y }, scale, event)
+				})
+			}
+		}
+
+		// --- Safari trackpad pinch (GestureEvent) ---
+
+		let safariGestureInitialScale = 1
+
+		function onGestureStart(event: Event) {
+			const e = event as GestureEvent
+			if (!(e.target === elm || elm?.contains(e.target as Node))) return
+
+			preventDefault(e)
+			e.stopPropagation()
+
+			pinchState = 'not sure'
+			safariGestureInitialScale = getScaleFrom()
+			scaleOffset = safariGestureInitialScale
+			initZoom = editor.getZoomLevel()
+
+			prevPointBetweenFingers.x = e.clientX
+			prevPointBetweenFingers.y = e.clientY
+			initPointBetweenFingers.x = e.clientX
+			initPointBetweenFingers.y = e.clientY
+			initDistanceBetweenFingers = 1
+			currDistanceBetweenFingers = 1
+
+			dispatchPinchEvent(
+				'pinch_start',
+				{ x: e.clientX, y: e.clientY },
+				{ x: 0, y: 0 },
+				editor.getZoomLevel(),
+				e
+			)
+		}
+
+		function onGestureChange(event: Event) {
+			const e = event as GestureEvent
+			if (!(e.target === elm || elm?.contains(e.target as Node))) return
+
+			preventDefault(e)
+			e.stopPropagation()
+
+			const dx = e.clientX - prevPointBetweenFingers.x
+			const dy = e.clientY - prevPointBetweenFingers.y
+
+			prevPointBetweenFingers.x = e.clientX
+			prevPointBetweenFingers.y = e.clientY
+
+			// Safari GestureEvent.scale is a multiplier relative to gesture start
+			const bounds = getScaleBounds()
+			const rawScale = safariGestureInitialScale * e.scale
+			scaleOffset = Math.min(bounds.max, Math.max(bounds.min, rawScale))
+
+			// Update distance tracking for pinch state (treat scale change as distance change)
+			currDistanceBetweenFingers = e.scale * initDistanceBetweenFingers
+
+			updatePinchState(true)
 
-			const scale = offset[0] ** editor.getCameraOptions().zoomSpeed
+			const currZoom = scaleOffset ** editor.getCameraOptions().zoomSpeed
 
+			dispatchPinchEvent('pinch', { x: e.clientX, y: e.clientY }, { x: dx, y: dy }, currZoom, e)
+		}
+
+		function onGestureEnd(event: Event) {
+			const e = event as GestureEvent
+			if (!(e.target === elm || elm?.contains(e.target as Node))) return
+
+			preventDefault(e)
+			e.stopPropagation()
+
+			const scale = scaleOffset ** editor.getCameraOptions().zoomSpeed
 			pinchState = 'not sure'
 
 			editor.timers.requestAnimationFrame(() => {
-				editor.dispatch({
-					type: 'pinch',
-					name: 'pinch_end',
-					point: { x: origin[0], y: origin[1], z: scale },
-					delta: { x: origin[0], y: origin[1] },
-					shiftKey: event.shiftKey,
-					altKey: event.altKey,
-					ctrlKey: event.metaKey || event.ctrlKey,
-					metaKey: event.metaKey,
-					accelKey: isAccelKey(event),
-				})
+				dispatchPinchEvent(
+					'pinch_end',
+					{ x: e.clientX, y: e.clientY },
+					{ x: e.clientX, y: e.clientY },
+					scale,
+					e
+				)
 			})
 		}
 
-		return {
-			onWheel,
-			onPinchStart,
-			onPinchEnd,
-			onPinch,
+		// --- Attach event listeners ---
+
+		elm.addEventListener('wheel', onWheel, { passive: false })
+
+		// On touch devices (iOS), use pointer events for pinch.
+		// On non-touch Safari (macOS trackpad), use GestureEvent.
+		// Never use both simultaneously — on iOS Safari, both event types fire
+		// for the same pinch gesture, causing conflicting state updates.
+		const useGestureEvents = !tlenv.isIos && 'GestureEvent' in window
+
+		if (useGestureEvents) {
+			elm.addEventListener('gesturestart', onGestureStart)
+			elm.addEventListener('gesturechange', onGestureChange)
+			elm.addEventListener('gestureend', onGestureEnd)
+		} else {
+			elm.addEventListener('touchstart', onTouchStart)
+			elm.addEventListener('touchmove', onTouchMove)
+			elm.addEventListener('touchend', onTouchEnd)
+			elm.addEventListener('touchcancel', onTouchEnd)
 		}
-	}, [editor, ref])
 
-	useGesture(events, {
-		target: ref,
-		eventOptions: { passive: false },
-		pinch: {
-			from: () => {
-				const { zoomSpeed } = editor.getCameraOptions()
-				const level = editor.getZoomLevel() ** (1 / zoomSpeed)
-				return [level, 0]
-			}, // Return the camera z to use when pinch starts
-			scaleBounds: () => {
-				const baseZoom = editor.getBaseZoom()
-				const { zoomSteps, zoomSpeed } = editor.getCameraOptions()
-				const zoomMin = zoomSteps[0] * baseZoom
-				const zoomMax = zoomSteps[zoomSteps.length - 1] * baseZoom
-
-				return {
-					max: zoomMax ** (1 / zoomSpeed),
-					min: zoomMin ** (1 / zoomSpeed),
-				}
-			},
-		},
-	})
+		return () => {
+			elm.removeEventListener('wheel', onWheel)
+			if (useGestureEvents) {
+				elm.removeEventListener('gesturestart', onGestureStart)
+				elm.removeEventListener('gesturechange', onGestureChange)
+				elm.removeEventListener('gestureend', onGestureEnd)
+			} else {
+				elm.removeEventListener('touchstart', onTouchStart)
+				elm.removeEventListener('touchmove', onTouchMove)
+				elm.removeEventListener('touchend', onTouchEnd)
+				elm.removeEventListener('touchcancel', onTouchEnd)
+			}
+		}
+	}, [editor, ref])
 }

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

@@ -728,4 +728,34 @@ describe('Box', () => {
 			expect(result).not.toBe(zeroBox) // different object
 		})
 	})
+
+	describe('Box.isValid', () => {
+		it('returns true for normal box', () => {
+			expect(new Box(10, 20, 100, 200).isValid()).toBe(true)
+		})
+
+		it('returns false when x is NaN', () => {
+			expect(new Box(NaN, 0, 100, 100).isValid()).toBe(false)
+		})
+
+		it('returns false when y is NaN', () => {
+			expect(new Box(0, NaN, 100, 100).isValid()).toBe(false)
+		})
+
+		it('returns false when w is NaN', () => {
+			expect(new Box(0, 0, NaN, 100).isValid()).toBe(false)
+		})
+
+		it('returns false when h is NaN', () => {
+			expect(new Box(0, 0, 100, NaN).isValid()).toBe(false)
+		})
+
+		it('returns false for Infinity', () => {
+			expect(new Box(Infinity, 0, 100, 100).isValid()).toBe(false)
+		})
+
+		it('returns true for zero-sized box', () => {
+			expect(new Box(0, 0, 0, 0).isValid()).toBe(true)
+		})
+	})
 })

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

@@ -1,5 +1,6 @@
 import { Mat } from '../Mat'
 import { Vec, VecLike } from '../Vec'
+import { Edge2d } from './Edge2d'
 import { Geometry2dFilters } from './Geometry2d'
 import { Group2d } from './Group2d'
 import { Rectangle2d } from './Rectangle2d'
@@ -456,6 +457,26 @@ describe('Group2d getBoundsVertices', () => {
 	})
 })
 
+describe('interpolateAlongEdge', () => {
+	it('returns vertex when segment has zero length', () => {
+		const edge = new Edge2d({ start: new Vec(5, 5), end: new Vec(5, 5) })
+		const result = edge.interpolateAlongEdge(0.5)
+		expect(result.x).toBe(5)
+		expect(result.y).toBe(5)
+		expect(Number.isFinite(result.x)).toBe(true)
+		expect(Number.isFinite(result.y)).toBe(true)
+	})
+})
+
+describe('uninterpolateAlongEdge', () => {
+	it('returns 0 when geometry has zero length', () => {
+		const edge = new Edge2d({ start: new Vec(5, 5), end: new Vec(5, 5) })
+		const result = edge.uninterpolateAlongEdge(new Vec(5, 5))
+		expect(result).toBe(0)
+		expect(Number.isFinite(result)).toBe(true)
+	})
+})
+
 function expectApproxMatch(a: VecLike, b: VecLike) {
 	expect(a.x).toBeCloseTo(b.x, 0.0001)
 	expect(a.y).toBeCloseTo(b.y, 0.0001)

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 = '4.6.0-next.d15997ff5a4b'
+export const version = '4.6.0-next.d8328a2dcc3d'
 export const publishDates = {
 	major: '2025-09-18T14:39:22.803Z',
-	minor: '2026-03-26T11:23:28.088Z',
-	patch: '2026-03-26T11:23:28.088Z',
+	minor: '2026-04-02T09:41:44.660Z',
+	patch: '2026-04-02T09:41:44.660Z',
 }

package/dist-cjs/lib/config/createTLUser.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/lib/config/createTLUser.ts"],
-  "sourcesContent": ["import { Signal, computed, isSignal } from '@tldraw/state'\nimport { useAtom } from '@tldraw/state-react'\nimport { useEffect, useMemo } from 'react'\nimport { useShallowObjectIdentity } from '../hooks/useIdentity'\nimport { TLUserPreferences, getUserPreferences, setUserPreferences } from './TLUserPreferences'\n\n/** @public */\nexport interface TLUser {\n\treadonly userPreferences: Signal<TLUserPreferences>\n\t// eslint-disable-next-line tldraw/method-signature-style\n\treadonly setUserPreferences: (userPreferences: TLUserPreferences) => void\n}\n\nconst defaultLocalStorageUserPrefs = computed('defaultLocalStorageUserPrefs', () =>\n\tgetUserPreferences()\n)\n\n/** @public */\nexport function createTLUser(\n\topts = {} as {\n\t\tuserPreferences?: Signal<TLUserPreferences>\n\t\t// eslint-disable-next-line tldraw/method-signature-style\n\t\tsetUserPreferences?: (userPreferences: TLUserPreferences) => void\n\t}\n): TLUser {\n\treturn {\n\t\tuserPreferences: opts.userPreferences ?? defaultLocalStorageUserPrefs,\n\t\tsetUserPreferences: opts.setUserPreferences ?? setUserPreferences,\n\t}\n}\n\n/**\n * @public\n */\nexport function useTldrawUser(opts: {\n\tuserPreferences?: Signal<TLUserPreferences> | TLUserPreferences\n\t// eslint-disable-next-line tldraw/method-signature-style\n\tsetUserPreferences?: (userPreferences: TLUserPreferences) => void\n}): TLUser {\n\tconst prefs = useShallowObjectIdentity(opts.userPreferences ?? defaultLocalStorageUserPrefs)\n\tconst userAtom = useAtom<TLUserPreferences | Signal<TLUserPreferences>>('userAtom', prefs)\n\tuseEffect(() => {\n\t\tuserAtom.set(prefs)\n\t}, [prefs, userAtom])\n\n\treturn useMemo(\n\t\t() =>\n\t\t\tcreateTLUser({\n\t\t\t\tuserPreferences: computed('userPreferences', () => {\n\t\t\t\t\tconst userStuff = userAtom.get()\n\t\t\t\t\treturn isSignal(userStuff) ? userStuff.get() : userStuff\n\t\t\t\t}),\n\t\t\t\tsetUserPreferences: opts.setUserPreferences,\n\t\t\t}),\n\t\t[userAtom, opts.setUserPreferences]\n\t)\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAA2C;AAC3C,yBAAwB;AACxB,mBAAmC;AACnC,yBAAyC;AACzC,+BAA0E;AAS1E,MAAM,mCAA+B;AAAA,EAAS;AAAA,EAAgC,UAC7E,6CAAmB;AACpB;AAGO,SAAS,aACf,OAAO,CAAC,GAKC;AACT,SAAO;AAAA,IACN,iBAAiB,KAAK,mBAAmB;AAAA,IACzC,oBAAoB,KAAK,sBAAsB;AAAA,EAChD;AACD;AAKO,SAAS,cAAc,MAInB;AACV,QAAM,YAAQ,6CAAyB,KAAK,mBAAmB,4BAA4B;AAC3F,QAAM,eAAW,4BAAuD,YAAY,KAAK;AACzF,8BAAU,MAAM;AACf,aAAS,IAAI,KAAK;AAAA,EACnB,GAAG,CAAC,OAAO,QAAQ,CAAC;AAEpB,aAAO;AAAA,IACN,MACC,aAAa;AAAA,MACZ,qBAAiB,uBAAS,mBAAmB,MAAM;AAClD,cAAM,YAAY,SAAS,IAAI;AAC/B,mBAAO,uBAAS,SAAS,IAAI,UAAU,IAAI,IAAI;AAAA,MAChD,CAAC;AAAA,MACD,oBAAoB,KAAK;AAAA,IAC1B,CAAC;AAAA,IACF,CAAC,UAAU,KAAK,kBAAkB;AAAA,EACnC;AACD;",
-  "names": []
-}

package/dist-esm/lib/config/createTLUser.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/lib/config/createTLUser.ts"],
-  "sourcesContent": ["import { Signal, computed, isSignal } from '@tldraw/state'\nimport { useAtom } from '@tldraw/state-react'\nimport { useEffect, useMemo } from 'react'\nimport { useShallowObjectIdentity } from '../hooks/useIdentity'\nimport { TLUserPreferences, getUserPreferences, setUserPreferences } from './TLUserPreferences'\n\n/** @public */\nexport interface TLUser {\n\treadonly userPreferences: Signal<TLUserPreferences>\n\t// eslint-disable-next-line tldraw/method-signature-style\n\treadonly setUserPreferences: (userPreferences: TLUserPreferences) => void\n}\n\nconst defaultLocalStorageUserPrefs = computed('defaultLocalStorageUserPrefs', () =>\n\tgetUserPreferences()\n)\n\n/** @public */\nexport function createTLUser(\n\topts = {} as {\n\t\tuserPreferences?: Signal<TLUserPreferences>\n\t\t// eslint-disable-next-line tldraw/method-signature-style\n\t\tsetUserPreferences?: (userPreferences: TLUserPreferences) => void\n\t}\n): TLUser {\n\treturn {\n\t\tuserPreferences: opts.userPreferences ?? defaultLocalStorageUserPrefs,\n\t\tsetUserPreferences: opts.setUserPreferences ?? setUserPreferences,\n\t}\n}\n\n/**\n * @public\n */\nexport function useTldrawUser(opts: {\n\tuserPreferences?: Signal<TLUserPreferences> | TLUserPreferences\n\t// eslint-disable-next-line tldraw/method-signature-style\n\tsetUserPreferences?: (userPreferences: TLUserPreferences) => void\n}): TLUser {\n\tconst prefs = useShallowObjectIdentity(opts.userPreferences ?? defaultLocalStorageUserPrefs)\n\tconst userAtom = useAtom<TLUserPreferences | Signal<TLUserPreferences>>('userAtom', prefs)\n\tuseEffect(() => {\n\t\tuserAtom.set(prefs)\n\t}, [prefs, userAtom])\n\n\treturn useMemo(\n\t\t() =>\n\t\t\tcreateTLUser({\n\t\t\t\tuserPreferences: computed('userPreferences', () => {\n\t\t\t\t\tconst userStuff = userAtom.get()\n\t\t\t\t\treturn isSignal(userStuff) ? userStuff.get() : userStuff\n\t\t\t\t}),\n\t\t\t\tsetUserPreferences: opts.setUserPreferences,\n\t\t\t}),\n\t\t[userAtom, opts.setUserPreferences]\n\t)\n}\n"],
-  "mappings": "AAAA,SAAiB,UAAU,gBAAgB;AAC3C,SAAS,eAAe;AACxB,SAAS,WAAW,eAAe;AACnC,SAAS,gCAAgC;AACzC,SAA4B,oBAAoB,0BAA0B;AAS1E,MAAM,+BAA+B;AAAA,EAAS;AAAA,EAAgC,MAC7E,mBAAmB;AACpB;AAGO,SAAS,aACf,OAAO,CAAC,GAKC;AACT,SAAO;AAAA,IACN,iBAAiB,KAAK,mBAAmB;AAAA,IACzC,oBAAoB,KAAK,sBAAsB;AAAA,EAChD;AACD;AAKO,SAAS,cAAc,MAInB;AACV,QAAM,QAAQ,yBAAyB,KAAK,mBAAmB,4BAA4B;AAC3F,QAAM,WAAW,QAAuD,YAAY,KAAK;AACzF,YAAU,MAAM;AACf,aAAS,IAAI,KAAK;AAAA,EACnB,GAAG,CAAC,OAAO,QAAQ,CAAC;AAEpB,SAAO;AAAA,IACN,MACC,aAAa;AAAA,MACZ,iBAAiB,SAAS,mBAAmB,MAAM;AAClD,cAAM,YAAY,SAAS,IAAI;AAC/B,eAAO,SAAS,SAAS,IAAI,UAAU,IAAI,IAAI;AAAA,MAChD,CAAC;AAAA,MACD,oBAAoB,KAAK;AAAA,IAC1B,CAAC;AAAA,IACF,CAAC,UAAU,KAAK,kBAAkB;AAAA,EACnC;AACD;",
-  "names": []
-}