@tldraw/editor 3.16.0-canary.ea008b31887f → 3.16.0-canary.eb473ba53051

package/src/lib/utils/dom.test.ts

@@ -0,0 +1,94 @@
+import { markEventAsHandled, wasEventAlreadyHandled } from './dom'
+
+describe('Event handling utilities', () => {
+	describe('markEventAsHandled and wasEventAlreadyHandled', () => {
+		it('should track events as handled', () => {
+			const mockEvent = new PointerEvent('pointerdown', { pointerId: 1 })
+
+			// Initially, event should not be marked as handled
+			expect(wasEventAlreadyHandled(mockEvent)).toBe(false)
+
+			// Mark the event as handled
+			markEventAsHandled(mockEvent)
+
+			// Now it should be marked as handled
+			expect(wasEventAlreadyHandled(mockEvent)).toBe(true)
+		})
+
+		it('should work with React synthetic events', () => {
+			const nativeEvent = new PointerEvent('pointerdown', { pointerId: 1 })
+			const syntheticEvent = { nativeEvent }
+
+			// Initially not handled
+			expect(wasEventAlreadyHandled(syntheticEvent)).toBe(false)
+			expect(wasEventAlreadyHandled(nativeEvent)).toBe(false)
+
+			// Mark synthetic event as handled
+			markEventAsHandled(syntheticEvent)
+
+			// Both synthetic and native should be marked as handled
+			expect(wasEventAlreadyHandled(syntheticEvent)).toBe(true)
+			expect(wasEventAlreadyHandled(nativeEvent)).toBe(true)
+		})
+
+		it('should handle multiple different events independently', () => {
+			const event1 = new PointerEvent('pointerdown', { pointerId: 1 })
+			const event2 = new PointerEvent('pointerup', { pointerId: 2 })
+			const event3 = new MouseEvent('click')
+
+			// Mark only event1 as handled
+			markEventAsHandled(event1)
+
+			expect(wasEventAlreadyHandled(event1)).toBe(true)
+			expect(wasEventAlreadyHandled(event2)).toBe(false)
+			expect(wasEventAlreadyHandled(event3)).toBe(false)
+
+			// Mark event2 as handled
+			markEventAsHandled(event2)
+
+			expect(wasEventAlreadyHandled(event1)).toBe(true)
+			expect(wasEventAlreadyHandled(event2)).toBe(true)
+			expect(wasEventAlreadyHandled(event3)).toBe(false)
+		})
+
+		it('should not interfere with event properties', () => {
+			const event = new PointerEvent('pointerdown', {
+				pointerId: 1,
+				clientX: 100,
+				clientY: 200,
+			})
+
+			// Mark as handled
+			markEventAsHandled(event)
+
+			// Event properties should remain unchanged
+			expect(event.pointerId).toBe(1)
+			expect(event.clientX).toBe(100)
+			expect(event.clientY).toBe(200)
+			expect(event.type).toBe('pointerdown')
+		})
+
+		it('should work with touch events', () => {
+			const touchEvent = new TouchEvent('touchstart', {
+				touches: [
+					{
+						clientX: 50,
+						clientY: 60,
+					} as Touch,
+				],
+			})
+
+			expect(wasEventAlreadyHandled(touchEvent)).toBe(false)
+			markEventAsHandled(touchEvent)
+			expect(wasEventAlreadyHandled(touchEvent)).toBe(true)
+		})
+
+		it('should work with keyboard events', () => {
+			const keyEvent = new KeyboardEvent('keydown', { key: 'Enter' })
+
+			expect(wasEventAlreadyHandled(keyEvent)).toBe(false)
+			markEventAsHandled(keyEvent)
+			expect(wasEventAlreadyHandled(keyEvent)).toBe(true)
+		})
+	})
+})

package/src/lib/utils/dom.ts

@@ -78,9 +78,46 @@ export function releasePointerCapture(
 	}
 }
 
-/** @public */
+/**
+ * Calls `event.stopPropagation()`.
+ *
+ * @deprecated Use {@link markEventAsHandled} instead, or manually call `event.stopPropagation()` if
+ * that's what you really want.
+ *
+ * @public
+ */
 export const stopEventPropagation = (e: any) => e.stopPropagation()
 
+const handledEvents = new WeakSet<Event>()
+
+/**
+ * In tldraw, events are sometimes handled by multiple components. For example, the shapes might
+ * have events, but the canvas handles events too. The way that the canvas handles events can
+ * interfere with the with the shapes event handlers - for example, it calls `.preventDefault()` on
+ * `pointerDown`, which also prevents `click` events from firing on the shapes.
+ *
+ * You can use `.stopPropagation()` to prevent the event from propagating to the rest of the DOM,
+ * but that can impact non-tldraw event handlers set up elsewhere. By using `markEventAsHandled`,
+ * you'll stop other parts of tldraw from handling the event without impacting other, non-tldraw
+ * event handlers. See also {@link wasEventAlreadyHandled}.
+ *
+ * @public
+ */
+export function markEventAsHandled(e: Event | { nativeEvent: Event }) {
+	const nativeEvent = 'nativeEvent' in e ? e.nativeEvent : e
+	handledEvents.add(nativeEvent)
+}
+
+/**
+ * Checks if an event has already been handled. See {@link markEventAsHandled}.
+ *
+ * @public
+ */
+export function wasEventAlreadyHandled(e: Event | { nativeEvent: Event }) {
+	const nativeEvent = 'nativeEvent' in e ? e.nativeEvent : e
+	return handledEvents.has(nativeEvent)
+}
+
 /** @internal */
 export const setStyleProperty = (
 	elm: HTMLElement | null,

package/src/lib/utils/getPointerInfo.ts

@@ -1,8 +1,9 @@
+import { markEventAsHandled } from './dom'
 import { isAccelKey } from './keyboard'
 
 /** @public */
 export function getPointerInfo(e: React.PointerEvent | PointerEvent) {
-	;(e as any).isKilled = true
+	markEventAsHandled(e)
 
 	return {
 		point: {

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.ea008b31887f'
+export const version = '3.16.0-canary.eb473ba53051'
 export const publishDates = {
 	major: '2024-09-13T14:36:29.063Z',
-	minor: '2025-09-12T09:57:41.475Z',
-	patch: '2025-09-12T09:57:41.475Z',
+	minor: '2025-09-17T08:53:11.486Z',
+	patch: '2025-09-17T08:53:11.486Z',
 }