@tldraw/editor 4.5.2 → 4.6.0-canary.4ec045c286e1

package/src/lib/primitives/geometry/geometry.bench.ts

@@ -0,0 +1,179 @@
+import { bench, describe } from 'vitest'
+import { Vec } from '../Vec'
+import { Arc2d } from './Arc2d'
+import { Circle2d } from './Circle2d'
+import { Edge2d } from './Edge2d'
+import { Polyline2d } from './Polyline2d'
+import { Rectangle2d } from './Rectangle2d'
+
+// --- Vec line segment utilities ---
+
+const lsA = new Vec(0, 0)
+const lsB = new Vec(100, 50)
+const lsP = new Vec(30, 60)
+
+describe('Vec line segment', () => {
+	bench('NearestPointOnLineSegment', () => {
+		Vec.NearestPointOnLineSegment(lsA, lsB, lsP, true)
+	})
+
+	bench('DistanceToLineSegment', () => {
+		Vec.DistanceToLineSegment(lsA, lsB, lsP, true)
+	})
+})
+
+// --- Vec utilities ---
+
+const vecA = new Vec(3, 4)
+const vecB = new Vec(-1, 2)
+const lineOrigin = new Vec(10, 10)
+const lineDir = new Vec(0.7071, 0.7071) // ~unit vector at 45°
+const lineTestP = new Vec(20, 15)
+
+describe('Vec utilities', () => {
+	bench('Lrp', () => {
+		Vec.Lrp(lsA, lsB, 0.35)
+	})
+
+	bench('AngleBetween', () => {
+		Vec.AngleBetween(vecA, vecB)
+	})
+
+	bench('NearestPointOnLineThroughPoint', () => {
+		Vec.NearestPointOnLineThroughPoint(lineOrigin, lineDir, lineTestP)
+	})
+
+	bench('DistanceToLineThroughPoint', () => {
+		Vec.DistanceToLineThroughPoint(lineOrigin, lineDir, lineTestP)
+	})
+})
+
+// --- Intersections ---
+
+import { intersectLineSegmentCircle, intersectLineSegmentLineSegment } from '../intersect'
+
+const intA1 = new Vec(0, 0)
+const intA2 = new Vec(100, 100)
+const intB1 = new Vec(100, 0)
+const intB2 = new Vec(0, 100)
+const intB1Miss = new Vec(200, 0)
+const intB2Miss = new Vec(200, 100)
+const intCenter = new Vec(50, 50)
+
+describe('Intersections', () => {
+	bench('lineSegment-lineSegment (hit)', () => {
+		intersectLineSegmentLineSegment(intA1, intA2, intB1, intB2)
+	})
+
+	bench('lineSegment-lineSegment (miss)', () => {
+		intersectLineSegmentLineSegment(intA1, intA2, intB1Miss, intB2Miss)
+	})
+
+	bench('lineSegment-circle (hit)', () => {
+		intersectLineSegmentCircle(intA1, intA2, intCenter, 30)
+	})
+
+	bench('lineSegment-circle (miss)', () => {
+		intersectLineSegmentCircle(intA1, intA2, intCenter, 5)
+	})
+})
+
+// --- Edge2d ---
+
+const edge = new Edge2d({ start: new Vec(0, 0), end: new Vec(100, 50) })
+const edgePoint = new Vec(30, 60)
+
+describe('Edge2d', () => {
+	bench('nearestPoint', () => {
+		edge.nearestPoint(edgePoint)
+	})
+
+	bench('distanceToPoint', () => {
+		edge.distanceToPoint(edgePoint)
+	})
+})
+
+// --- Circle2d ---
+
+const circle = new Circle2d({ radius: 50, isFilled: true })
+const circlePoint = new Vec(80, 60)
+const circlePointInside = new Vec(50, 50)
+
+describe('Circle2d', () => {
+	bench('nearestPoint', () => {
+		circle.nearestPoint(circlePoint)
+	})
+
+	bench('distanceToPoint', () => {
+		circle.distanceToPoint(circlePoint)
+	})
+
+	bench('hitTestPoint (outside)', () => {
+		circle.hitTestPoint(circlePoint, 5)
+	})
+
+	bench('hitTestPoint (inside)', () => {
+		circle.hitTestPoint(circlePointInside, 5, true)
+	})
+})
+
+// --- Arc2d ---
+
+const arc = new Arc2d({
+	center: new Vec(50, 50),
+	start: new Vec(100, 50),
+	end: new Vec(50, 100),
+	sweepFlag: 1,
+	largeArcFlag: 0,
+})
+const arcPoint = new Vec(90, 90)
+
+describe('Arc2d', () => {
+	bench('nearestPoint', () => {
+		arc.nearestPoint(arcPoint)
+	})
+})
+
+// --- Polyline2d (20 segments) ---
+
+const polyPoints: Vec[] = []
+for (let i = 0; i <= 20; i++) {
+	const t = i / 20
+	polyPoints.push(new Vec(t * 200, Math.sin(t * Math.PI * 2) * 50 + 50))
+}
+const polyline = new Polyline2d({ points: polyPoints })
+const polyPoint = new Vec(100, 80)
+
+describe('Polyline2d', () => {
+	bench('nearestPoint', () => {
+		polyline.nearestPoint(polyPoint)
+	})
+
+	bench('distanceToPoint', () => {
+		polyline.distanceToPoint(polyPoint)
+	})
+})
+
+// --- Rectangle2d (Geometry2d base) ---
+
+const rect = new Rectangle2d({ width: 100, height: 80, isFilled: true })
+const rectPointOutside = new Vec(120, 40)
+const rectPointInside = new Vec(50, 40)
+
+describe('Rectangle2d (Geometry2d)', () => {
+	bench('hitTestPoint (outside)', () => {
+		rect.hitTestPoint(rectPointOutside, 5)
+	})
+
+	bench('hitTestPoint (inside)', () => {
+		rect.hitTestPoint(rectPointInside, 5, true)
+	})
+
+	bench('distanceToPoint (outside)', () => {
+		rect.distanceToPoint(rectPointOutside)
+	})
+
+	bench('distanceToPoint (inside)', () => {
+		rect.distanceToPoint(rectPointInside, true)
+	})
+})

package/src/lib/primitives/intersect.ts

@@ -1,5 +1,5 @@
 import { Box } from './Box'
-import { approximately, approximatelyLte, pointInPolygon } from './utils'
+import { pointInPolygon } from './utils'
 import { Vec, VecLike } from './Vec'
 
 // need even more intersections? See https://gist.github.com/steveruizok/35c02d526c707003a5c79761bfb89a52
@@ -30,21 +30,18 @@ export function intersectLineSegmentLineSegment(
 	const ub_t = AVx * ABy - AVy * ABx
 	const u_b = BVy * AVx - BVx * AVy
 
-	if (approximately(ua_t, 0, precision) || approximately(ub_t, 0, precision)) return null // coincident
+	// These comparisons inline approximately(x, 0) and approximatelyLte(x, 0/1)
+	// to avoid 7+ function calls per invocation.
+	if (Math.abs(ua_t) <= precision || Math.abs(ub_t) <= precision) return null // coincident
 
-	if (approximately(u_b, 0, precision)) return null // parallel
+	if (Math.abs(u_b) <= precision) return null // parallel
 
-	if (u_b !== 0) {
-		const ua = ua_t / u_b
-		const ub = ub_t / u_b
-		if (
-			approximatelyLte(0, ua, precision) &&
-			approximatelyLte(ua, 1, precision) &&
-			approximatelyLte(0, ub, precision) &&
-			approximatelyLte(ub, 1, precision)
-		) {
-			return Vec.AddXY(a1, ua * AVx, ua * AVy)
-		}
+	const ua = ua_t / u_b
+	const ub = ub_t / u_b
+	// Inlined: approximately(ua, 0) && approximatelyLte(ua, 1) && same for ub
+	if (ua >= -precision && ua <= 1 + precision && ub >= -precision && ub <= 1 + precision) {
+		// Inlined: Vec.Lrp(a1, a2, ua) — i.e. a1 + ua * (a2 - a1)
+		return new Vec(a1.x + ua * AVx, a1.y + ua * AVy)
 	}
 
 	return null // no intersection
@@ -60,32 +57,35 @@ export function intersectLineSegmentLineSegment(
  * @public
  */
 export function intersectLineSegmentCircle(a1: VecLike, a2: VecLike, c: VecLike, r: number) {
-	const a = (a2.x - a1.x) * (a2.x - a1.x) + (a2.y - a1.y) * (a2.y - a1.y)
-	const b = 2 * ((a2.x - a1.x) * (a1.x - c.x) + (a2.y - a1.y) * (a1.y - c.y))
-	const cc =
-		c.x * c.x + c.y * c.y + a1.x * a1.x + a1.y * a1.y - 2 * (c.x * a1.x + c.y * a1.y) - r * r
+	// Precompute segment delta (dx, dy) and origin-to-center offset (ocx, ocy)
+	// to avoid repeated (a2.x - a1.x) and (a1.x - c.x) subexpressions.
+	const dx = a2.x - a1.x
+	const dy = a2.y - a1.y
+	const ocx = a1.x - c.x
+	const ocy = a1.y - c.y
+
+	const a = dx * dx + dy * dy
+	const b = 2 * (dx * ocx + dy * ocy)
+	const cc = ocx * ocx + ocy * ocy - r * r
 	const deter = b * b - 4 * a * cc
 
-	if (deter < 0) return null // outside
-	if (deter === 0) return null // tangent
+	if (deter <= 0) return null // outside or tangent
 
 	const e = Math.sqrt(deter)
 	const u1 = (-b + e) / (2 * a)
 	const u2 = (-b - e) / (2 * a)
 
 	if ((u1 < 0 || u1 > 1) && (u2 < 0 || u2 > 1)) {
-		return null // outside or inside
-		// if ((u1 < 0 && u2 < 0) || (u1 > 1 && u2 > 1)) {
-		// 	return null // outside
-		// } else return null // inside'
+		return null
 	}
 
 	const result: VecLike[] = []
 
-	if (0 <= u1 && u1 <= 1) result.push(Vec.Lrp(a1, a2, u1))
-	if (0 <= u2 && u2 <= 1) result.push(Vec.Lrp(a1, a2, u2))
+	// Inlined: Vec.Lrp(a1, a2, u) — i.e. a1 + u * (a2 - a1)
+	if (u1 >= 0 && u1 <= 1) result.push(new Vec(a1.x + dx * u1, a1.y + dy * u1))
+	if (u2 >= 0 && u2 <= 1) result.push(new Vec(a1.x + dx * u2, a1.y + dy * u2))
 
-	if (result.length === 0) return null // no intersection
+	if (result.length === 0) return null
 
 	return result
 }

package/src/lib/primitives/utils.ts

@@ -317,20 +317,20 @@ function cross(x: VecLike, y: VecLike, z: VecLike): number {
  * @public
  */
 export function pointInPolygon(A: VecLike, points: VecLike[]): boolean {
+	// Uses winding number algorithm. Previously also had a per-edge check:
+	//   if (Vec.Dist(A, a) + Vec.Dist(A, b) === Vec.Dist(a, b)) return true
+	// which tested if A lies exactly on edge (a, b). Removed because it cost 3 sqrts per vertex
+	// and exact float equality with sqrt results essentially never fires in practice.
 	let windingNumber = 0
 	let a: VecLike
 	let b: VecLike
 
 	for (let i = 0; i < points.length; i++) {
 		a = points[i]
-		// Point is the same as one of the corners of the polygon
 		if (a.x === A.x && a.y === A.y) return true
 
 		b = points[(i + 1) % points.length]
 
-		// Point is on the polygon edge
-		if (Vec.Dist(A, a) + Vec.Dist(A, b) === Vec.Dist(a, b)) return true
-
 		if (a.y <= A.y) {
 			if (b.y > A.y && cross(a, b, A) > 0) {
 				windingNumber += 1

package/src/lib/test/TestEditor.ts

@@ -8,6 +8,7 @@ class CustomTool extends StateNode {
 
 export class TestEditor extends Editor {
 	constructor(options: Partial<Omit<TLEditorOptions, 'store'>> = {}) {
+		// eslint-disable-next-line no-restricted-globals
 		const elm = document.createElement('div')
 		elm.tabIndex = 0
 

package/src/lib/utils/browserCanvasMaxSize.ts

@@ -1,3 +1,5 @@
+import { getGlobalDocument } from './dom'
+
 /** @internal */
 export interface CanvasMaxSize {
 	maxWidth: number
@@ -94,7 +96,7 @@ const TEST_SIZES = {
  * @returns The maximum size of the canvas for the given dimension.
  */
 function getCanvasSize(dimension: 'width' | 'height' | 'area'): number {
-	const cropCvs = document.createElement('canvas')
+	const cropCvs = getGlobalDocument().createElement('canvas')
 	cropCvs.width = 1
 	cropCvs.height = 1
 	const cropCtx = cropCvs.getContext('2d')!
@@ -103,7 +105,7 @@ function getCanvasSize(dimension: 'width' | 'height' | 'area'): number {
 		const w = dimension === 'height' ? 1 : size
 		const h = dimension === 'width' ? 1 : size
 
-		const testCvs = document.createElement('canvas')
+		const testCvs = getGlobalDocument().createElement('canvas')
 		testCvs.width = w
 		testCvs.height = h
 		const testCtx = testCvs.getContext('2d')!

package/src/lib/utils/dom.ts

@@ -112,7 +112,39 @@ export function elementShouldCaptureKeys(el: Element | null, includeButtonsAndMe
 	)
 }
 
+/**
+ * Returns the global `document`. Use this instead of bare `document` to satisfy lint rules.
+ *
+ * When you have a DOM node or editor instance, prefer the scoped versions instead:
+ * - `getOwnerDocument(node)` – the document that owns a specific DOM node
+ * - `editor.getContainerDocument()` – the document where the editor is mounted
+ *
+ * @internal
+ */
+export function getGlobalDocument(): Document {
+	// eslint-disable-next-line no-restricted-globals
+	if (typeof document !== 'undefined') return document
+	return globalThis.document
+}
+
+/**
+ * Returns the global `window`. Use this instead of bare `window` to satisfy lint rules.
+ *
+ * When you have a DOM node or editor instance, prefer the scoped versions instead:
+ * - `getOwnerWindow(node)` – the window that owns a specific DOM node
+ * - `editor.getContainerWindow()` – the window where the editor is mounted
+ *
+ * @internal
+ */
+export function getGlobalWindow(): Window & typeof globalThis {
+	if (typeof window !== 'undefined') return window as Window & typeof globalThis
+	return globalThis as Window & typeof globalThis
+}
+
 /** @internal */
-export function activeElementShouldCaptureKeys(includeButtonsAndMenus = true) {
-	return elementShouldCaptureKeys(document.activeElement, includeButtonsAndMenus)
+export function activeElementShouldCaptureKeys(includeButtonsAndMenus = true, doc?: Document) {
+	return elementShouldCaptureKeys(
+		(doc ?? getGlobalDocument()).activeElement,
+		includeButtonsAndMenus
+	)
 }

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.5.2'
+export const version = '4.6.0-canary.4ec045c286e1'
 export const publishDates = {
 	major: '2025-09-18T14:39:22.803Z',
-	minor: '2026-03-18T11:05:13.340Z',
-	patch: '2026-03-18T12:00:45.366Z',
+	minor: '2026-03-18T11:50:21.657Z',
+	patch: '2026-03-18T11:50:21.657Z',
 }