@tldraw/editor 4.2.2 → 4.2.3

package/src/lib/editor/managers/TickManager/TickManager.test.ts

@@ -21,17 +21,6 @@ describe('TickManager', () => {
 	let tickManager: TickManager
 	let mockEmit: Mock
 	let mockDisposablesAdd: Mock
-	let mockInputs: {
-		_currentScreenPoint: Vec
-		getCurrentScreenPoint(): Vec
-		currentScreenPoint: Vec
-		setCurrentScreenPoint(value: Vec): void
-		_pointerVelocity: Vec
-		getPointerVelocity(): Vec
-		pointerVelocity: Vec
-		setPointerVelocity(value: Vec): void
-		updatePointerVelocity(elapsed: number): void
-	}
 
 	beforeEach(() => {
 		vi.clearAllMocks()
@@ -52,40 +41,16 @@ describe('TickManager', () => {
 		mockEmit = vi.fn()
 		mockDisposablesAdd = vi.fn()
 
-		// Create a mock inputs object with getters and setters
-		mockInputs = {
-			_currentScreenPoint: new Vec(100, 100),
-			getCurrentScreenPoint() {
-				return this._currentScreenPoint
-			},
-			get currentScreenPoint() {
-				return this.getCurrentScreenPoint()
-			},
-			setCurrentScreenPoint(value: Vec) {
-				this._currentScreenPoint = value
-			},
-			_pointerVelocity: new Vec(0, 0),
-			getPointerVelocity() {
-				return this._pointerVelocity
-			},
-			get pointerVelocity() {
-				return this.getPointerVelocity()
-			},
-			setPointerVelocity(value: Vec) {
-				this._pointerVelocity = value
-			},
-			updatePointerVelocity(_elapsed: number) {
-				// Mock implementation - no-op for tests
-			},
-		}
-
 		editor = {
 			emit: mockEmit,
 			disposables: {
 				add: mockDisposablesAdd,
 			},
-			inputs: mockInputs as unknown as Editor['inputs'],
-		} as unknown as Mocked<Editor>
+			inputs: {
+				currentScreenPoint: new Vec(100, 100),
+				pointerVelocity: new Vec(0, 0),
+			},
+		} as any
 
 		tickManager = new TickManager(editor)
 	})
@@ -178,6 +143,16 @@ describe('TickManager', () => {
 			expect(mockEmit).toHaveBeenCalledTimes(2)
 		})
 
+		it('should update pointer velocity', () => {
+			const updatePointerVelocitySpy = vi.spyOn(tickManager as any, 'updatePointerVelocity')
+			tickManager.now = 1000
+			mockDateNow.mockReturnValue(1016)
+
+			tickManager.tick()
+
+			expect(updatePointerVelocitySpy).toHaveBeenCalledWith(16)
+		})
+
 		it('should schedule next RAF', () => {
 			tickManager.tick()
 			expect(mockRequestAnimationFrame).toHaveBeenCalled()
@@ -217,6 +192,98 @@ describe('TickManager', () => {
 		})
 	})
 
+	describe('updatePointerVelocity method', () => {
+		let updatePointerVelocity: any
+
+		beforeEach(() => {
+			// Access private method for testing
+			updatePointerVelocity = (tickManager as any).updatePointerVelocity.bind(tickManager)
+			// Reset the prevPoint to a known state
+			;(tickManager as any).prevPoint = new Vec(50, 50)
+		})
+
+		it('should return early if elapsed time is 0', () => {
+			const originalVelocity = editor.inputs.pointerVelocity.clone()
+
+			updatePointerVelocity(0)
+
+			expect(editor.inputs.pointerVelocity).toEqual(originalVelocity)
+		})
+
+		it('should calculate velocity based on pointer movement', () => {
+			editor.inputs.currentScreenPoint = new Vec(150, 150)
+			;(tickManager as any).prevPoint = new Vec(50, 50)
+			editor.inputs.pointerVelocity = new Vec(0, 0)
+
+			updatePointerVelocity(100) // 100ms elapsed
+
+			// Delta should be (100, 100), length = ~141.42, direction = (~0.707, ~0.707)
+			// Velocity should be length/elapsed = ~1.414 per ms in each direction
+			// But with linear interpolation (lrp factor 0.5), it will be halved
+			const expectedVelocity = new Vec(0.5, 0.5) // With lrp factor 0.5
+			expect(editor.inputs.pointerVelocity.x).toBeCloseTo(expectedVelocity.x, 1)
+			expect(editor.inputs.pointerVelocity.y).toBeCloseTo(expectedVelocity.y, 1)
+		})
+
+		it('should update prevPoint to current screen point', () => {
+			const newPoint = new Vec(200, 200)
+			editor.inputs.currentScreenPoint = newPoint
+
+			updatePointerVelocity(16)
+
+			expect((tickManager as any).prevPoint).toEqual(newPoint)
+		})
+
+		it('should use linear interpolation to smooth velocity', () => {
+			editor.inputs.currentScreenPoint = new Vec(150, 50)
+			;(tickManager as any).prevPoint = new Vec(50, 50)
+			editor.inputs.pointerVelocity = new Vec(2, 2)
+
+			updatePointerVelocity(100)
+
+			// Should interpolate between current velocity (2,2) and new velocity (1,0)
+			// lrp with factor 0.5 should give us something between them
+			expect(editor.inputs.pointerVelocity.x).toBeGreaterThan(0.5)
+			expect(editor.inputs.pointerVelocity.x).toBeLessThan(2)
+		})
+
+		it('should set very small velocity components to 0', () => {
+			editor.inputs.currentScreenPoint = new Vec(50.005, 50.005)
+			;(tickManager as any).prevPoint = new Vec(50, 50)
+			editor.inputs.pointerVelocity = new Vec(0, 0)
+
+			updatePointerVelocity(1000) // Long elapsed time = very small velocity
+
+			expect(editor.inputs.pointerVelocity.x).toBe(0)
+			expect(editor.inputs.pointerVelocity.y).toBe(0)
+		})
+
+		it('should handle zero movement (stationary pointer)', () => {
+			editor.inputs.currentScreenPoint = new Vec(100, 100)
+			;(tickManager as any).prevPoint = new Vec(100, 100)
+			editor.inputs.pointerVelocity = new Vec(1, 1)
+
+			updatePointerVelocity(16)
+
+			// Should interpolate towards zero velocity
+			expect(editor.inputs.pointerVelocity.x).toBeLessThan(1)
+			expect(editor.inputs.pointerVelocity.y).toBeLessThan(1)
+		})
+
+		it('should only update pointerVelocity if it actually changes', () => {
+			// Setup scenario where velocity won't change
+			editor.inputs.currentScreenPoint = new Vec(100, 100)
+			;(tickManager as any).prevPoint = new Vec(100, 100)
+			editor.inputs.pointerVelocity = new Vec(0, 0)
+
+			const originalVelocity = editor.inputs.pointerVelocity
+			updatePointerVelocity(16)
+
+			// Should still be the same object reference since no change occurred
+			expect(editor.inputs.pointerVelocity).toBe(originalVelocity)
+		})
+	})
+
 	describe('RAF throttling behavior', () => {
 		it('should use test-specific RAF behavior in test environment', () => {
 			// The TickManager should detect test environment and use requestAnimationFrame directly

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

@@ -1,4 +1,5 @@
 import { throttleToNextFrame as _throttleToNextFrame, bind } from '@tldraw/utils'
+import { Vec } from '../../../primitives/Vec'
 import { Editor } from '../../Editor'
 
 const throttleToNextFrame =
@@ -12,7 +13,6 @@ const throttleToNextFrame =
 			}
 		: _throttleToNextFrame
 
-/** @internal */
 export class TickManager {
 	constructor(public editor: Editor) {
 		this.editor.disposables.add(this.dispose)
@@ -40,7 +40,7 @@ export class TickManager {
 		const elapsed = now - this.now
 		this.now = now
 
-		this.editor.inputs.updatePointerVelocity(elapsed)
+		this.updatePointerVelocity(elapsed)
 		this.editor.emit('frame', elapsed)
 		this.editor.emit('tick', elapsed)
 		this.cancelRaf = throttleToNextFrame(this.tick)
@@ -53,4 +53,34 @@ export class TickManager {
 
 		this.cancelRaf?.()
 	}
+
+	private prevPoint = new Vec()
+
+	updatePointerVelocity(elapsed: number) {
+		const {
+			prevPoint,
+			editor: {
+				inputs: { currentScreenPoint, pointerVelocity },
+			},
+		} = this
+
+		if (elapsed === 0) return
+
+		const delta = Vec.Sub(currentScreenPoint, prevPoint)
+		this.prevPoint = currentScreenPoint.clone()
+
+		const length = delta.len()
+		const direction = length ? delta.div(length) : new Vec(0, 0)
+
+		// consider adjusting this with an easing rather than a linear interpolation
+		const next = pointerVelocity.clone().lrp(direction.mul(length / elapsed), 0.5)
+
+		// if the velocity is very small, just set it to 0
+		if (Math.abs(next.x) < 0.01) next.x = 0
+		if (Math.abs(next.y) < 0.01) next.y = 0
+
+		if (!pointerVelocity.equals(next)) {
+			this.editor.inputs.pointerVelocity = next
+		}
+	}
 }

package/src/lib/editor/shapes/BaseBoxShapeUtil.tsx

@@ -1,4 +1,4 @@
-import { ExtractShapeByProps } from '@tldraw/tlschema'
+import { TLBaseShape } from '@tldraw/tlschema'
 import { lerp } from '@tldraw/utils'
 import { Geometry2d } from '../../primitives/geometry/Geometry2d'
 import { Rectangle2d } from '../../primitives/geometry/Rectangle2d'
@@ -7,7 +7,7 @@ import { ShapeUtil, TLResizeInfo } from './ShapeUtil'
 import { resizeBox } from './shared/resizeBox'
 
 /** @public */
-export type TLBaseBoxShape = ExtractShapeByProps<{ w: number; h: number }>
+export type TLBaseBoxShape = TLBaseShape<string, { w: number; h: number }>
 
 /** @public */
 export abstract class BaseBoxShapeUtil<Shape extends TLBaseBoxShape> extends ShapeUtil<Shape> {

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

@@ -26,7 +26,10 @@ import { TLClickEventInfo } from '../types/event-types'
 import { TLResizeHandle } from '../types/selection-types'
 
 /** @public */
-export interface TLShapeUtilConstructor<T extends TLShape, U extends ShapeUtil<T> = ShapeUtil<T>> {
+export interface TLShapeUtilConstructor<
+	T extends TLUnknownShape,
+	U extends ShapeUtil<T> = ShapeUtil<T>,
+> {
 	new (editor: Editor): U
 	type: T['type']
 	props?: RecordProps<T>
@@ -39,11 +42,11 @@ export interface TLShapeUtilConstructor<T extends TLShape, U extends ShapeUtil<T
  *
  * @public
  */
-export interface TLShapeUtilCanBindOpts<Shape extends TLShape = TLShape> {
+export interface TLShapeUtilCanBindOpts<Shape extends TLUnknownShape = TLUnknownShape> {
 	/** The type of shape referenced by the `fromId` of the binding. */
-	fromShapeType: TLShape['type']
+	fromShapeType: string
 	/** The type of shape referenced by the `toId` of the binding. */
-	toShapeType: TLShape['type']
+	toShapeType: string
 	/** The type of binding. */
 	bindingType: string
 }
@@ -76,7 +79,7 @@ export interface TLShapeUtilCanvasSvgDef {
 }
 
 /** @public */
-export abstract class ShapeUtil<Shape extends TLShape = TLShape> {
+export abstract class ShapeUtil<Shape extends TLUnknownShape = TLUnknownShape> {
 	/** Configure this shape utils {@link ShapeUtil.options | `options`}. */
 	static configure<T extends TLShapeUtilConstructor<any, any>>(
 		this: T,
@@ -190,7 +193,7 @@ export abstract class ShapeUtil<Shape extends TLShape = TLShape> {
 	 * @param shape - The shape.
 	 * @public
 	 */
-	canSnap(shape: Shape): boolean {
+	canSnap(_shape: Shape): boolean {
 		return true
 	}
 
@@ -200,7 +203,7 @@ export abstract class ShapeUtil<Shape extends TLShape = TLShape> {
 	 * @param shape - The shape.
 	 * @public
 	 */
-	canTabTo(shape: Shape): boolean {
+	canTabTo(_shape: Shape): boolean {
 		return true
 	}
 
@@ -209,7 +212,7 @@ export abstract class ShapeUtil<Shape extends TLShape = TLShape> {
 	 *
 	 * @public
 	 */
-	canScroll(shape: Shape): boolean {
+	canScroll(_shape: Shape): boolean {
 		return false
 	}
 
@@ -227,7 +230,7 @@ export abstract class ShapeUtil<Shape extends TLShape = TLShape> {
 	 *
 	 * @public
 	 */
-	canEdit(shape: Shape, info: TLEditStartInfo): boolean {
+	canEdit(_shape: Shape): boolean {
 		return false
 	}
 
@@ -236,7 +239,7 @@ export abstract class ShapeUtil<Shape extends TLShape = TLShape> {
 	 *
 	 * @public
 	 */
-	canResize(shape: Shape): boolean {
+	canResize(_shape: Shape): boolean {
 		return true
 	}
 
@@ -245,7 +248,7 @@ export abstract class ShapeUtil<Shape extends TLShape = TLShape> {
 	 *
 	 * @public
 	 */
-	canResizeChildren(shape: Shape): boolean {
+	canResizeChildren(_shape: Shape): boolean {
 		return true
 	}
 
@@ -254,16 +257,7 @@ export abstract class ShapeUtil<Shape extends TLShape = TLShape> {
 	 *
 	 * @public
 	 */
-	canEditInReadonly(shape: Shape): boolean {
-		return false
-	}
-
-	/**
-	 * Whether the shape can be edited while locked or while an ancestor is locked.
-	 *
-	 * @public
-	 */
-	canEditWhileLocked(shape: Shape): boolean {
+	canEditInReadonly(_shape: Shape): boolean {
 		return false
 	}
 
@@ -272,7 +266,7 @@ export abstract class ShapeUtil<Shape extends TLShape = TLShape> {
 	 *
 	 * @public
 	 */
-	canCrop(shape: Shape): boolean {
+	canCrop(_shape: Shape): boolean {
 		return false
 	}
 
@@ -285,7 +279,7 @@ export abstract class ShapeUtil<Shape extends TLShape = TLShape> {
 	 *
 	 * @public
 	 */
-	canBeLaidOut(shape: Shape, info: TLShapeUtilCanBeLaidOutOpts): boolean {
+	canBeLaidOut(_shape: Shape, _info: TLShapeUtilCanBeLaidOutOpts): boolean {
 		return true
 	}
 
@@ -296,7 +290,7 @@ export abstract class ShapeUtil<Shape extends TLShape = TLShape> {
 	 *
 	 * @param shape - The shape.
 	 */
-	canCull(shape: Shape): boolean {
+	canCull(_shape: Shape): boolean {
 		return true
 	}
 
@@ -309,33 +303,13 @@ export abstract class ShapeUtil<Shape extends TLShape = TLShape> {
 	 *
 	 * @internal
 	 */
-	providesBackgroundForChildren(shape: Shape): boolean {
+	providesBackgroundForChildren(_shape: Shape): boolean {
 		return false
 	}
 
 	/**
 	 * Get the clip path to apply to this shape's children.
 	 *
-	 * The returned points should define the **inner** clip boundary - the area where
-	 * children will be visible. If your shape has a stroke, you should inset the clip
-	 * path by half the stroke width so children are clipped to the inner edge of the
-	 * stroke rather than its center line.
-	 *
-	 * @example
-	 * ```ts
-	 * override getClipPath(shape: MyShape): Vec[] | undefined {
-	 *   const strokeWidth = 2
-	 *   const inset = strokeWidth / 2
-	 *   // Return points inset by half the stroke width
-	 *   return [
-	 *     new Vec(inset, inset),
-	 *     new Vec(shape.props.w - inset, inset),
-	 *     new Vec(shape.props.w - inset, shape.props.h - inset),
-	 *     new Vec(inset, shape.props.h - inset),
-	 *   ]
-	 * }
-	 * ```
-	 *
 	 * @param shape - The shape to get the clip path for
 	 * @returns Array of points defining the clipping polygon in local coordinates, or undefined if no clipping
 	 * @public
@@ -362,14 +336,14 @@ export abstract class ShapeUtil<Shape extends TLShape = TLShape> {
 	 * @returns boolean indicating if this shape should hide in the minimap
 	 * @public
 	 */
-	hideInMinimap?(shape: Shape): boolean
+	hideInMinimap?(_shape: Shape): boolean
 
 	/**
 	 * Whether the shape should hide its resize handles when selected.
 	 *
 	 * @public
 	 */
-	hideResizeHandles(shape: Shape): boolean {
+	hideResizeHandles(_shape: Shape): boolean {
 		return false
 	}
 
@@ -378,7 +352,7 @@ export abstract class ShapeUtil<Shape extends TLShape = TLShape> {
 	 *
 	 * @public
 	 */
-	hideRotateHandle(shape: Shape): boolean {
+	hideRotateHandle(_shape: Shape): boolean {
 		return false
 	}
 
@@ -387,7 +361,7 @@ export abstract class ShapeUtil<Shape extends TLShape = TLShape> {
 	 *
 	 * @public
 	 */
-	hideSelectionBoundsBg(shape: Shape): boolean {
+	hideSelectionBoundsBg(_shape: Shape): boolean {
 		return false
 	}
 
@@ -396,7 +370,7 @@ export abstract class ShapeUtil<Shape extends TLShape = TLShape> {
 	 *
 	 * @public
 	 */
-	hideSelectionBoundsFg(shape: Shape): boolean {
+	hideSelectionBoundsFg(_shape: Shape): boolean {
 		return false
 	}
 
@@ -405,7 +379,7 @@ export abstract class ShapeUtil<Shape extends TLShape = TLShape> {
 	 *
 	 * @public
 	 */
-	isAspectRatioLocked(shape: Shape): boolean {
+	isAspectRatioLocked(_shape: Shape): boolean {
 		return false
 	}
 
@@ -416,10 +390,10 @@ export abstract class ShapeUtil<Shape extends TLShape = TLShape> {
 	 * useful in cases like annotating on top of an image, where you usually want to avoid extra
 	 * padding around the image if you don't need it.
 	 *
-	 * @param shape - The shape to check
+	 * @param _shape - The shape to check
 	 * @returns True if this shape should be treated as an export bounds container
 	 */
-	isExportBoundsContainer(shape: Shape): boolean {
+	isExportBoundsContainer(_shape: Shape): boolean {
 		return false
 	}
 
@@ -468,7 +442,7 @@ export abstract class ShapeUtil<Shape extends TLShape = TLShape> {
 	 * @param type - The shape type.
 	 * @public
 	 */
-	canReceiveNewChildrenOfType(shape: Shape, _type: TLShape['type']) {
+	canReceiveNewChildrenOfType(_shape: Shape, _type: TLShape['type']) {
 		return false
 	}
 
@@ -516,7 +490,7 @@ export abstract class ShapeUtil<Shape extends TLShape = TLShape> {
 	 * Get the geometry to use when snapping to this this shape in translate/resize operations. See
 	 * {@link BoundsSnapGeometry} for details.
 	 */
-	getBoundsSnapGeometry(shape: Shape): BoundsSnapGeometry {
+	getBoundsSnapGeometry(_shape: Shape): BoundsSnapGeometry {
 		return {}
 	}
 
@@ -524,15 +498,15 @@ export abstract class ShapeUtil<Shape extends TLShape = TLShape> {
 	 * Get the geometry to use when snapping handles to this shape. See {@link HandleSnapGeometry}
 	 * for details.
 	 */
-	getHandleSnapGeometry(shape: Shape): HandleSnapGeometry {
+	getHandleSnapGeometry(_shape: Shape): HandleSnapGeometry {
 		return {}
 	}
 
-	getText(shape: Shape): string | undefined {
+	getText(_shape: Shape): string | undefined {
 		return undefined
 	}
 
-	getAriaDescriptor(shape: Shape): string | undefined {
+	getAriaDescriptor(_shape: Shape): string | undefined {
 		return undefined
 	}
 
@@ -960,17 +934,3 @@ export interface TLHandleDragInfo<T extends TLShape> {
 	isCreatingShape: boolean
 	initial?: T | undefined
 }
-
-/* --------------------------------- Editing -------------------------------- */
-
-/** @public */
-export interface TLEditStartInfo {
-	type:
-		| 'press_enter'
-		| 'click'
-		| 'double-click'
-		| 'double-click-edge'
-		| 'double-click-corner'
-		| 'click-header'
-		| 'unknown'
-}

package/src/lib/editor/shapes/group/DashedOutlineBox.tsx

@@ -6,7 +6,7 @@ import { getPerfectDashProps } from '../shared/getPerfectDashProps'
 export function DashedOutlineBox({ bounds, className }: { bounds: Box; className: string }) {
 	const editor = useEditor()
 
-	const zoomLevel = useValue('zoom level', () => editor.getEfficientZoomLevel(), [editor])
+	const zoomLevel = useValue('zoom level', () => editor.getZoomLevel(), [editor])
 
 	return (
 		<g className={className} pointerEvents="none" strokeLinecap="round" strokeLinejoin="round">

package/src/lib/editor/shapes/group/GroupShapeUtil.tsx

@@ -55,7 +55,9 @@ export class GroupShapeUtil extends ShapeUtil<TLGroupShape> {
 		const isHintingOtherGroup =
 			hintingShapeIds.length > 0 &&
 			hintingShapeIds.some(
-				(id) => id !== shape.id && this.editor.isShapeOfType(this.editor.getShape(id)!, 'group')
+				(id) =>
+					id !== shape.id &&
+					this.editor.isShapeOfType<TLGroupShape>(this.editor.getShape(id)!, 'group')
 			)
 
 		const isFocused = this.editor.getCurrentPageState().focusedGroupId !== shape.id

package/src/lib/editor/tools/BaseBoxShapeTool/BaseBoxShapeTool.ts

@@ -1,5 +1,4 @@
 import { TLShape } from '@tldraw/tlschema'
-import { TLBaseBoxShape } from '../../shapes/BaseBoxShapeUtil'
 import { StateNode, TLStateNodeConstructor } from '../StateNode'
 import { Idle } from './children/Idle'
 import { Pointing } from './children/Pointing'
@@ -12,7 +11,7 @@ export abstract class BaseBoxShapeTool extends StateNode {
 		return [Idle, Pointing]
 	}
 
-	abstract override shapeType: TLBaseBoxShape['type']
+	abstract override shapeType: string
 
 	onCreate?(_shape: TLShape | null): void | null
 }

package/src/lib/editor/tools/BaseBoxShapeTool/children/Pointing.ts

@@ -12,8 +12,8 @@ export class Pointing extends StateNode {
 
 	override onPointerMove(info: TLPointerEventInfo) {
 		const { editor } = this
-		if (editor.inputs.getIsDragging()) {
-			const originPagePoint = editor.inputs.getOriginPagePoint()
+		if (editor.inputs.isDragging) {
+			const { originPagePoint } = editor.inputs
 
 			const shapeType = (this.parent as BaseBoxShapeTool)!.shapeType
 
@@ -23,7 +23,7 @@ export class Pointing extends StateNode {
 			const newPoint = maybeSnapToGrid(originPagePoint, editor)
 
 			// Allow this to trigger the max shapes reached alert
-			this.editor.createShapes([
+			this.editor.createShapes<TLBaseBoxShape>([
 				{
 					id,
 					type: shapeType,
@@ -78,7 +78,7 @@ export class Pointing extends StateNode {
 	}
 
 	complete() {
-		const originPagePoint = this.editor.inputs.getOriginPagePoint()
+		const { originPagePoint } = this.editor.inputs
 
 		const shapeType = (this.parent as BaseBoxShapeTool)!.shapeType as TLBaseBoxShape['type']
 
@@ -88,7 +88,7 @@ export class Pointing extends StateNode {
 
 		// Allow this to trigger the max shapes reached alert
 		// todo: add scale here when dynamic size is enabled (is this still needed?)
-		this.editor.createShapes([
+		this.editor.createShapes<TLBaseBoxShape>([
 			{
 				id,
 				type: shapeType,
@@ -127,7 +127,7 @@ export class Pointing extends StateNode {
 			;(next as TLBaseBoxShape & { props: { scale: number } }).props.scale = scale
 		}
 
-		this.editor.updateShape(next)
+		this.editor.updateShape<TLBaseBoxShape>(next)
 
 		this.editor.setSelectedShapes([id])
 

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

@@ -1,5 +1,5 @@
 import { HistoryEntry } from '@tldraw/store'
-import { BoxModel, TLPageId, TLRecord, TLShapeId } from '@tldraw/tlschema'
+import { TLPageId, TLRecord, TLShapeId } from '@tldraw/tlschema'
 import { TLEventInfo } from './event-types'
 
 /** @public */
@@ -16,14 +16,12 @@ export interface TLEventMap {
 	event: [TLEventInfo]
 	tick: [number]
 	frame: [number]
-	resize: [BoxModel]
 	'select-all-text': [{ shapeId: TLShapeId }]
 	'place-caret': [{ shapeId: TLShapeId; point: { x: number; y: number } }]
 	'created-shapes': [TLRecord[]]
 	'edited-shapes': [TLRecord[]]
 	'deleted-shapes': [TLShapeId[]]
 	edit: []
-	dispose: []
 }
 
 /** @public */

package/src/lib/exports/getSvgJsx.test.ts

@@ -1,21 +1,30 @@
-import { Geometry2d, RecordProps, Rectangle2d, ShapeUtil, T, TLShape, createShapeId } from '../..'
+import {
+	Geometry2d,
+	RecordProps,
+	Rectangle2d,
+	ShapeUtil,
+	T,
+	TLBaseShape,
+	createShapeId,
+} from '../..'
 import { createTLStore } from '../config/createTLStore'
 import { Editor } from '../editor/Editor'
 import { Box } from '../primitives/Box'
 import { getExportDefaultBounds } from './getSvgJsx'
 
-const TEST_SHAPE_TYPE = 'test-shape'
-
-declare module '@tldraw/tlschema' {
-	export interface TLGlobalShapePropsMap {
-		[TEST_SHAPE_TYPE]: { w: number; h: number; x: number; y: number; isContainer?: boolean }
+type ITestShape = TLBaseShape<
+	'test-shape',
+	{
+		w: number
+		h: number
+		x: number
+		y: number
+		isContainer?: boolean
 	}
-}
-
-type ITestShape = TLShape<typeof TEST_SHAPE_TYPE>
+>
 
 class TestShape extends ShapeUtil<ITestShape> {
-	static override type = TEST_SHAPE_TYPE
+	static override type = 'test-shape' as const
 	static override props: RecordProps<ITestShape> = {
 		w: T.number,
 		h: T.number,