@tldraw/editor 3.16.0-canary.7facbd2d2b7f → 3.16.0-canary.806d674b7d7a

package/src/lib/hooks/useCanvasEvents.ts

@@ -1,7 +1,13 @@
 import { useValue } from '@tldraw/state-react'
 import React, { useEffect, useMemo } from 'react'
 import { RIGHT_MOUSE_BUTTON } from '../constants'
-import { preventDefault, releasePointerCapture, setPointerCapture } from '../utils/dom'
+import {
+	markEventAsHandled,
+	preventDefault,
+	releasePointerCapture,
+	setPointerCapture,
+	wasEventAlreadyHandled,
+} from '../utils/dom'
 import { getPointerInfo } from '../utils/getPointerInfo'
 import { useEditor } from './useEditor'
 
@@ -12,14 +18,14 @@ export function useCanvasEvents() {
 	const events = useMemo(
 		function canvasEvents() {
 			function onPointerDown(e: React.PointerEvent) {
-				if (editor.wasEventAlreadyHandled(e)) return
+				if (wasEventAlreadyHandled(e)) return
 
 				if (e.button === RIGHT_MOUSE_BUTTON) {
 					editor.dispatch({
 						type: 'pointer',
 						target: 'canvas',
 						name: 'right_click',
-						...getPointerInfo(editor, e),
+						...getPointerInfo(e),
 					})
 					return
 				}
@@ -32,12 +38,12 @@ export function useCanvasEvents() {
 					type: 'pointer',
 					target: 'canvas',
 					name: 'pointer_down',
-					...getPointerInfo(editor, e),
+					...getPointerInfo(e),
 				})
 			}
 
 			function onPointerUp(e: React.PointerEvent) {
-				if (editor.wasEventAlreadyHandled(e)) return
+				if (wasEventAlreadyHandled(e)) return
 				if (e.button !== 0 && e.button !== 1 && e.button !== 2 && e.button !== 5) return
 
 				releasePointerCapture(e.currentTarget, e)
@@ -46,33 +52,33 @@ export function useCanvasEvents() {
 					type: 'pointer',
 					target: 'canvas',
 					name: 'pointer_up',
-					...getPointerInfo(editor, e),
+					...getPointerInfo(e),
 				})
 			}
 
 			function onPointerEnter(e: React.PointerEvent) {
-				if (editor.wasEventAlreadyHandled(e)) return
+				if (wasEventAlreadyHandled(e)) return
 				if (editor.getInstanceState().isPenMode && e.pointerType !== 'pen') return
 				const canHover = e.pointerType === 'mouse' || e.pointerType === 'pen'
 				editor.updateInstanceState({ isHoveringCanvas: canHover ? true : null })
 			}
 
 			function onPointerLeave(e: React.PointerEvent) {
-				if (editor.wasEventAlreadyHandled(e)) return
+				if (wasEventAlreadyHandled(e)) return
 				if (editor.getInstanceState().isPenMode && e.pointerType !== 'pen') return
 				const canHover = e.pointerType === 'mouse' || e.pointerType === 'pen'
 				editor.updateInstanceState({ isHoveringCanvas: canHover ? false : null })
 			}
 
 			function onTouchStart(e: React.TouchEvent) {
-				if (editor.wasEventAlreadyHandled(e)) return
-				editor.markEventAsHandled(e)
+				if (wasEventAlreadyHandled(e)) return
+				markEventAsHandled(e)
 				preventDefault(e)
 			}
 
 			function onTouchEnd(e: React.TouchEvent) {
-				if (editor.wasEventAlreadyHandled(e)) return
-				editor.markEventAsHandled(e)
+				if (wasEventAlreadyHandled(e)) return
+				markEventAsHandled(e)
 				// check that e.target is an HTMLElement
 				if (!(e.target instanceof HTMLElement)) return
 
@@ -91,12 +97,12 @@ export function useCanvasEvents() {
 			}
 
 			function onDragOver(e: React.DragEvent<Element>) {
-				if (editor.wasEventAlreadyHandled(e)) return
+				if (wasEventAlreadyHandled(e)) return
 				preventDefault(e)
 			}
 
 			async function onDrop(e: React.DragEvent<Element>) {
-				if (editor.wasEventAlreadyHandled(e)) return
+				if (wasEventAlreadyHandled(e)) return
 				preventDefault(e)
 				e.stopPropagation()
 
@@ -123,7 +129,7 @@ export function useCanvasEvents() {
 			}
 
 			function onClick(e: React.MouseEvent) {
-				if (editor.wasEventAlreadyHandled(e)) return
+				if (wasEventAlreadyHandled(e)) return
 				e.stopPropagation()
 			}
 
@@ -151,8 +157,8 @@ export function useCanvasEvents() {
 		let lastX: number, lastY: number
 
 		function onPointerMove(e: PointerEvent) {
-			if (editor.wasEventAlreadyHandled(e)) return
-			editor.markEventAsHandled(e)
+			if (wasEventAlreadyHandled(e)) return
+			markEventAsHandled(e)
 
 			if (e.clientX === lastX && e.clientY === lastY) return
 			lastX = e.clientX
@@ -168,7 +174,7 @@ export function useCanvasEvents() {
 					type: 'pointer',
 					target: 'canvas',
 					name: 'pointer_move',
-					...getPointerInfo(editor, singleEvent),
+					...getPointerInfo(singleEvent),
 				})
 			}
 		}

package/src/lib/hooks/useDocumentEvents.ts

@@ -2,7 +2,12 @@ import { useValue } from '@tldraw/state-react'
 import { useEffect } from 'react'
 import { Editor } from '../editor/Editor'
 import { TLKeyboardEventInfo } from '../editor/types/event-types'
-import { activeElementShouldCaptureKeys, preventDefault } from '../utils/dom'
+import {
+	activeElementShouldCaptureKeys,
+	markEventAsHandled,
+	preventDefault,
+	wasEventAlreadyHandled,
+} from '../utils/dom'
 import { isAccelKey } from '../utils/keyboard'
 import { useContainer } from './useContainer'
 import { useEditor } from './useEditor'
@@ -103,8 +108,8 @@ export function useDocumentEvents() {
 				preventDefault(e)
 			}
 
-			if (editor.wasEventAlreadyHandled(e)) return
-			editor.markEventAsHandled(e)
+			if (wasEventAlreadyHandled(e)) return
+			markEventAsHandled(e)
 			const hasSelectedShapes = !!editor.getSelectedShapeIds().length
 
 			switch (e.key) {
@@ -211,8 +216,8 @@ export function useDocumentEvents() {
 		}
 
 		const handleKeyUp = (e: KeyboardEvent) => {
-			if (editor.wasEventAlreadyHandled(e)) return
-			editor.markEventAsHandled(e)
+			if (wasEventAlreadyHandled(e)) return
+			markEventAsHandled(e)
 
 			if (areShortcutsDisabled(editor)) {
 				return

package/src/lib/hooks/useFixSafariDoubleTapZoomPencilEvents.ts

@@ -1,5 +1,5 @@
 import { useEffect } from 'react'
-import { preventDefault } from '../utils/dom'
+import { markEventAsHandled, preventDefault } from '../utils/dom'
 import { useEditor } from './useEditor'
 
 const IGNORED_TAGS = ['textarea', 'input']
@@ -19,7 +19,7 @@ export function useFixSafariDoubleTapZoomPencilEvents(ref: React.RefObject<HTMLE
 
 		const handleEvent = (e: PointerEvent | TouchEvent) => {
 			if (e instanceof PointerEvent && e.pointerType === 'pen') {
-				editor.markEventAsHandled(e)
+				markEventAsHandled(e)
 				const { target } = e
 
 				// Allow events to propagate if the app is editing a shape, or if the event is occurring in a text area or input

package/src/lib/hooks/useHandleEvents.ts

@@ -1,7 +1,12 @@
 import { TLArrowShape, TLLineShape, TLShapeId } from '@tldraw/tlschema'
 import * as React from 'react'
 import { Editor } from '../editor/Editor'
-import { loopToHtmlElement, releasePointerCapture, setPointerCapture } from '../utils/dom'
+import {
+	loopToHtmlElement,
+	releasePointerCapture,
+	setPointerCapture,
+	wasEventAlreadyHandled,
+} from '../utils/dom'
 import { getPointerInfo } from '../utils/getPointerInfo'
 import { useEditor } from './useEditor'
 
@@ -16,7 +21,7 @@ export function useHandleEvents(id: TLShapeId, handleId: string) {
 
 	return React.useMemo(() => {
 		const onPointerDown = (e: React.PointerEvent) => {
-			if (editor.wasEventAlreadyHandled(e)) return
+			if (wasEventAlreadyHandled(e)) return
 
 			// Must set pointer capture on an HTML element!
 			const target = loopToHtmlElement(e.currentTarget)
@@ -32,7 +37,7 @@ export function useHandleEvents(id: TLShapeId, handleId: string) {
 				handle,
 				shape,
 				name: 'pointer_down',
-				...getPointerInfo(editor, e),
+				...getPointerInfo(e),
 			})
 		}
 
@@ -40,7 +45,7 @@ export function useHandleEvents(id: TLShapeId, handleId: string) {
 		let lastX: number, lastY: number
 
 		const onPointerMove = (e: React.PointerEvent) => {
-			if (editor.wasEventAlreadyHandled(e)) return
+			if (wasEventAlreadyHandled(e)) return
 			if (e.clientX === lastX && e.clientY === lastY) return
 			lastX = e.clientX
 			lastY = e.clientY
@@ -55,12 +60,12 @@ export function useHandleEvents(id: TLShapeId, handleId: string) {
 				handle,
 				shape,
 				name: 'pointer_move',
-				...getPointerInfo(editor, e),
+				...getPointerInfo(e),
 			})
 		}
 
 		const onPointerUp = (e: React.PointerEvent) => {
-			if (editor.wasEventAlreadyHandled(e)) return
+			if (wasEventAlreadyHandled(e)) return
 
 			const target = loopToHtmlElement(e.currentTarget)
 			releasePointerCapture(target, e)
@@ -75,7 +80,7 @@ export function useHandleEvents(id: TLShapeId, handleId: string) {
 				handle,
 				shape,
 				name: 'pointer_up',
-				...getPointerInfo(editor, e),
+				...getPointerInfo(e),
 			})
 		}
 

package/src/lib/hooks/useSelectionEvents.ts

@@ -1,7 +1,13 @@
 import { useMemo } from 'react'
 import { RIGHT_MOUSE_BUTTON } from '../constants'
 import { TLSelectionHandle } from '../editor/types/selection-types'
-import { loopToHtmlElement, releasePointerCapture, setPointerCapture } from '../utils/dom'
+import {
+	loopToHtmlElement,
+	markEventAsHandled,
+	releasePointerCapture,
+	setPointerCapture,
+	wasEventAlreadyHandled,
+} from '../utils/dom'
 import { getPointerInfo } from '../utils/getPointerInfo'
 import { useEditor } from './useEditor'
 
@@ -12,7 +18,7 @@ export function useSelectionEvents(handle: TLSelectionHandle) {
 	const events = useMemo(
 		function selectionEvents() {
 			const onPointerDown: React.PointerEventHandler = (e) => {
-				if (editor.wasEventAlreadyHandled(e)) return
+				if (wasEventAlreadyHandled(e)) return
 
 				if (e.button === RIGHT_MOUSE_BUTTON) {
 					editor.dispatch({
@@ -20,7 +26,7 @@ export function useSelectionEvents(handle: TLSelectionHandle) {
 						target: 'selection',
 						handle,
 						name: 'right_click',
-						...getPointerInfo(editor, e),
+						...getPointerInfo(e),
 					})
 					return
 				}
@@ -47,16 +53,16 @@ export function useSelectionEvents(handle: TLSelectionHandle) {
 					type: 'pointer',
 					target: 'selection',
 					handle,
-					...getPointerInfo(editor, e),
+					...getPointerInfo(e),
 				})
-				editor.markEventAsHandled(e)
+				markEventAsHandled(e)
 			}
 
 			// Track the last screen point
 			let lastX: number, lastY: number
 
 			function onPointerMove(e: React.PointerEvent) {
-				if (editor.wasEventAlreadyHandled(e)) return
+				if (wasEventAlreadyHandled(e)) return
 				if (e.button !== 0) return
 				if (e.clientX === lastX && e.clientY === lastY) return
 				lastX = e.clientX
@@ -67,12 +73,12 @@ export function useSelectionEvents(handle: TLSelectionHandle) {
 					type: 'pointer',
 					target: 'selection',
 					handle,
-					...getPointerInfo(editor, e),
+					...getPointerInfo(e),
 				})
 			}
 
 			const onPointerUp: React.PointerEventHandler = (e) => {
-				if (editor.wasEventAlreadyHandled(e)) return
+				if (wasEventAlreadyHandled(e)) return
 				if (e.button !== 0) return
 
 				editor.dispatch({
@@ -80,7 +86,7 @@ export function useSelectionEvents(handle: TLSelectionHandle) {
 					type: 'pointer',
 					target: 'selection',
 					handle,
-					...getPointerInfo(editor, e),
+					...getPointerInfo(e),
 				})
 			}
 

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 } from '../utils/dom'
+import { markEventAsHandled, preventDefault } from '../utils/dom'
 import { runtime } from '../utils/runtime'
 import { watermarkDesktopSvg, watermarkMobileSvg } from '../watermarks'
 import { LicenseManager } from './LicenseManager'
@@ -43,13 +43,11 @@ const UnlicensedWatermark = memo(function UnlicensedWatermark({
 	isDebugMode: boolean
 	isMobile: boolean
 }) {
-	const editor = useEditor()
 	const events = useCanvasEvents()
 	const ref = useRef<HTMLDivElement>(null)
 	usePassThroughWheelEvents(ref)
 
-	const url =
-		'https://tldraw.dev/pricing?utm_source=dotcom&utm_medium=organic&utm_campaign=watermark'
+	const url = 'https://tldraw.dev/?utm_source=dotcom&utm_medium=organic&utm_campaign=watermark'
 
 	return (
 		<div
@@ -66,13 +64,26 @@ const UnlicensedWatermark = memo(function UnlicensedWatermark({
 				draggable={false}
 				role="button"
 				onPointerDown={(e) => {
-					editor.markEventAsHandled(e)
+					markEventAsHandled(e)
 					preventDefault(e)
 				}}
-				title="The tldraw SDK requires a license key to work in production. You can get a free 100-day trial license at tldraw.dev/pricing."
+				title="Unlicensed - click to get a license"
 				onClick={() => runtime.openWindow(url, '_blank')}
+				style={{
+					position: 'absolute',
+					pointerEvents: 'all',
+					cursor: 'pointer',
+					color: 'var(--tl-color-text)',
+					opacity: 0.8,
+					border: 0,
+					padding: 0,
+					backgroundColor: 'transparent',
+					fontSize: '11px',
+					fontWeight: '600',
+					textAlign: 'center',
+				}}
 			>
-				Get a license for production
+				Unlicensed
 			</button>
 		</div>
 	)
@@ -116,10 +127,10 @@ const WatermarkInner = memo(function WatermarkInner({
 				draggable={false}
 				role="button"
 				onPointerDown={(e) => {
-					editor.markEventAsHandled(e)
+					markEventAsHandled(e)
 					preventDefault(e)
 				}}
-				title="Build infinite canvas applications with the tldraw SDK. Learn more at https://tldraw.dev."
+				title="made with tldraw"
 				onClick={() => runtime.openWindow(url, '_blank')}
 				style={{ mask: maskCss, WebkitMask: maskCss }}
 			/>
@@ -131,8 +142,7 @@ const LicenseStyles = memo(function LicenseStyles() {
 	const editor = useEditor()
 	const className = LicenseManager.className
 
-	const CSS = `
-/* ------------------- SEE LICENSE -------------------
+	const CSS = `/* ------------------- SEE LICENSE -------------------
 The tldraw watermark is part of tldraw's license. It is shown for unlicensed
 or "licensed-with-watermark" users. By using this library, you agree to
 preserve the watermark's behavior, keeping it visible, unobscured, and
@@ -141,105 +151,87 @@ available to user-interaction.
 To remove the watermark, please purchase a license at tldraw.dev.
 */
 
-.${className} {
-	position: absolute;
-	bottom: max(var(--tl-space-2), env(safe-area-inset-bottom));
-	right: max(var(--tl-space-2), env(safe-area-inset-right));
-	width: 96px;
-	height: 32px;
-	display: flex;
-	align-items: center;
-	justify-content: center;
-	z-index: var(--tl-layer-watermark) !important;
-	background-color: color-mix(in srgb, var(--tl-color-background) 62%, transparent);
-	opacity: 1;
-	border-radius: 5px;
-	pointer-events: all;
-	padding: 2px;
-	box-sizing: content-box;
-}
-
-.${className} > button {
-	position: absolute;
-	width: 96px;
-	height: 32px;
-	pointer-events: all;
-	cursor: inherit;
-	color: var(--tl-color-text);
-	opacity: .38;
-	border: 0;
-	padding: 0;
-	background-color: currentColor;
-}
-
-.${className}[data-debug='true'] {
-	bottom: max(46px, env(safe-area-inset-bottom));
-}
-
-.${className}[data-mobile='true'] {
-	border-radius: 4px 0px 0px 4px;
-	right: max(-2px, calc(env(safe-area-inset-right) - 2px));
-	width: 8px;
-	height: 48px;
-}
-
-.${className}[data-mobile='true'] > button {
-	width: 8px;
-	height: 32px;
-}
-
-.${className}[data-unlicensed='true'] > button {
-	font-size: 100px;
-	position: absolute;
-	pointer-events: all;
-	cursor: pointer;
-	color: var(--tl-color-text);
-	opacity: 0.8;
-	border: 0;
-	padding: 0;
-	background-color: transparent;
-	font-size: 11px;
-	font-weight: 600;
-	text-align: center;
-}
-
-.${className}[data-mobile='true'][data-unlicensed='true'] > button {
-	display: none;
-}
-
-@media (hover: hover) {
-	.${className}[data-licensed='false'] > button {
-		pointer-events: none;
+	.${className} {
+		position: absolute;
+		bottom: max(var(--tl-space-2), env(safe-area-inset-bottom));
+		right: max(var(--tl-space-2), env(safe-area-inset-right));
+		width: 96px;
+		height: 32px;
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		z-index: var(--tl-layer-watermark) !important;
+		background-color: color-mix(in srgb, var(--tl-color-background) 62%, transparent);
+		opacity: 1;
+		border-radius: 5px;
+		pointer-events: all;
+		padding: 2px;
+		box-sizing: content-box;
 	}
 
-	.${className}[data-licensed='false']:hover {
-		background-color: var(--tl-color-background);
-		transition: background-color 0.2s ease-in-out;
-		transition-delay: 0.32s;
+	.${className} > button {
+		position: absolute;
+		width: 96px;
+		height: 32px;
+		pointer-events: all;
+		cursor: inherit;
+		color: var(--tl-color-text);
+		opacity: .38;
+		border: 0;
+		padding: 0;
+		background-color: currentColor;
 	}
 
-	.${className}[data-licensed='false']:hover > button {
-		animation: ${className}_delayed_link 0.2s forwards ease-in-out;
-		animation-delay: 0.32s;
+	.${className}[data-debug='true'] {
+		bottom: max(46px, env(safe-area-inset-bottom));
 	}
 
-	.${className}[data-licensed='false'] > button:focus-visible {
-		opacity: 1;
+	.${className}[data-mobile='true'] {
+		border-radius: 4px 0px 0px 4px;
+		right: max(-2px, calc(env(safe-area-inset-right) - 2px));
+		width: 8px;
+		height: 48px;
 	}
-}
 
-@keyframes ${className}_delayed_link {
-	0% {
-		cursor: inherit;
-		opacity: .38;
-		pointer-events: none;
+	.${className}[data-mobile='true'] > button {
+		width: 8px;
+		height: 32px;
 	}
-	100% {
-		cursor: pointer;
-		opacity: 1;
-		pointer-events: all;
+
+	@media (hover: hover) {
+		.${className} > button {
+			pointer-events: none;
+		}
+
+		.${className}:hover {
+			background-color: var(--tl-color-background);
+			transition: background-color 0.2s ease-in-out;
+			transition-delay: 0.32s;
+		}
+
+		.${className}:hover > button {
+			animation: ${className}_delayed_link 0.2s forwards ease-in-out;
+			animation-delay: 0.32s;
+		}
+
+		.${className} > button:focus-visible {
+			opacity: 1;
+		}
 	}
-}`
+
+
+	@keyframes ${className}_delayed_link {
+		0% {
+			cursor: inherit;
+			opacity: .38;
+			pointer-events: none;
+		}
+		100% {
+			cursor: pointer;
+			opacity: 1;
+			pointer-events: all;
+		}
+	}`
 
 	return <style nonce={editor.options.nonce}>{CSS}</style>
 })

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

@@ -1,27 +1,18 @@
-import { TestEditor } from '../test/TestEditor'
+import { markEventAsHandled, wasEventAlreadyHandled } from './dom'
 
 describe('Event handling utilities', () => {
-	let editor: TestEditor
-
-	beforeEach(() => {
-		editor = new TestEditor()
-	})
-
-	afterEach(() => {
-		editor.dispose()
-	})
 	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(editor.wasEventAlreadyHandled(mockEvent)).toBe(false)
+			expect(wasEventAlreadyHandled(mockEvent)).toBe(false)
 
 			// Mark the event as handled
-			editor.markEventAsHandled(mockEvent)
+			markEventAsHandled(mockEvent)
 
 			// Now it should be marked as handled
-			expect(editor.wasEventAlreadyHandled(mockEvent)).toBe(true)
+			expect(wasEventAlreadyHandled(mockEvent)).toBe(true)
 		})
 
 		it('should work with React synthetic events', () => {
@@ -29,15 +20,15 @@ describe('Event handling utilities', () => {
 			const syntheticEvent = { nativeEvent }
 
 			// Initially not handled
-			expect(editor.wasEventAlreadyHandled(syntheticEvent)).toBe(false)
-			expect(editor.wasEventAlreadyHandled(nativeEvent)).toBe(false)
+			expect(wasEventAlreadyHandled(syntheticEvent)).toBe(false)
+			expect(wasEventAlreadyHandled(nativeEvent)).toBe(false)
 
 			// Mark synthetic event as handled
-			editor.markEventAsHandled(syntheticEvent)
+			markEventAsHandled(syntheticEvent)
 
 			// Both synthetic and native should be marked as handled
-			expect(editor.wasEventAlreadyHandled(syntheticEvent)).toBe(true)
-			expect(editor.wasEventAlreadyHandled(nativeEvent)).toBe(true)
+			expect(wasEventAlreadyHandled(syntheticEvent)).toBe(true)
+			expect(wasEventAlreadyHandled(nativeEvent)).toBe(true)
 		})
 
 		it('should handle multiple different events independently', () => {
@@ -46,18 +37,18 @@ describe('Event handling utilities', () => {
 			const event3 = new MouseEvent('click')
 
 			// Mark only event1 as handled
-			editor.markEventAsHandled(event1)
+			markEventAsHandled(event1)
 
-			expect(editor.wasEventAlreadyHandled(event1)).toBe(true)
-			expect(editor.wasEventAlreadyHandled(event2)).toBe(false)
-			expect(editor.wasEventAlreadyHandled(event3)).toBe(false)
+			expect(wasEventAlreadyHandled(event1)).toBe(true)
+			expect(wasEventAlreadyHandled(event2)).toBe(false)
+			expect(wasEventAlreadyHandled(event3)).toBe(false)
 
 			// Mark event2 as handled
-			editor.markEventAsHandled(event2)
+			markEventAsHandled(event2)
 
-			expect(editor.wasEventAlreadyHandled(event1)).toBe(true)
-			expect(editor.wasEventAlreadyHandled(event2)).toBe(true)
-			expect(editor.wasEventAlreadyHandled(event3)).toBe(false)
+			expect(wasEventAlreadyHandled(event1)).toBe(true)
+			expect(wasEventAlreadyHandled(event2)).toBe(true)
+			expect(wasEventAlreadyHandled(event3)).toBe(false)
 		})
 
 		it('should not interfere with event properties', () => {
@@ -68,7 +59,7 @@ describe('Event handling utilities', () => {
 			})
 
 			// Mark as handled
-			editor.markEventAsHandled(event)
+			markEventAsHandled(event)
 
 			// Event properties should remain unchanged
 			expect(event.pointerId).toBe(1)
@@ -87,17 +78,17 @@ describe('Event handling utilities', () => {
 				],
 			})
 
-			expect(editor.wasEventAlreadyHandled(touchEvent)).toBe(false)
-			editor.markEventAsHandled(touchEvent)
-			expect(editor.wasEventAlreadyHandled(touchEvent)).toBe(true)
+			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(editor.wasEventAlreadyHandled(keyEvent)).toBe(false)
-			editor.markEventAsHandled(keyEvent)
-			expect(editor.wasEventAlreadyHandled(keyEvent)).toBe(true)
+			expect(wasEventAlreadyHandled(keyEvent)).toBe(false)
+			markEventAsHandled(keyEvent)
+			expect(wasEventAlreadyHandled(keyEvent)).toBe(true)
 		})
 	})
 })