@tldraw/editor 3.12.0-canary.3e2ed74b5e86 → 3.12.0-canary.423f9b4f2a86

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

@@ -1,8 +1,6 @@
-import { EMPTY_ARRAY } from '@tldraw/state'
 import { Box } from '../Box'
-import { Mat } from '../Mat'
-import { Vec, VecLike } from '../Vec'
-import { Geometry2d, Geometry2dFilters, Geometry2dOptions } from './Geometry2d'
+import { Vec } from '../Vec'
+import { Geometry2d, Geometry2dOptions } from './Geometry2d'
 
 /** @public */
 export class Group2d extends Geometry2d {
@@ -27,14 +25,11 @@ export class Group2d extends Geometry2d {
 		if (this.children.length === 0) throw Error('Group2d must have at least one child')
 	}
 
-	override getVertices(filters: Geometry2dFilters): Vec[] {
-		if (this.isExcludedByFilter(filters)) return []
-		return this.children
-			.filter((c) => !c.isExcludedByFilter(filters))
-			.flatMap((c) => c.getVertices(filters))
+	override getVertices(): Vec[] {
+		return this.children.filter((c) => !c.isLabel).flatMap((c) => c.vertices)
 	}
 
-	override nearestPoint(point: Vec, filters?: Geometry2dFilters): Vec {
+	override nearestPoint(point: Vec): Vec {
 		let dist = Infinity
 		let nearest: Vec | undefined
 
@@ -47,8 +42,7 @@ export class Group2d extends Geometry2d {
 		let p: Vec
 		let d: number
 		for (const child of children) {
-			if (child.isExcludedByFilter(filters)) continue
-			p = child.nearestPoint(point, filters)
+			p = child.nearestPoint(point)
 			d = Vec.Dist2(p, point)
 			if (d < dist) {
 				dist = d
@@ -59,75 +53,18 @@ export class Group2d extends Geometry2d {
 		return nearest
 	}
 
-	override distanceToPoint(point: Vec, hitInside = false, filters?: Geometry2dFilters) {
-		let smallestDistance = Infinity
-		for (const child of this.children) {
-			if (child.isExcludedByFilter(filters)) continue
-			const distance = child.distanceToPoint(point, hitInside, filters)
-			if (distance < smallestDistance) {
-				smallestDistance = distance
-			}
-		}
-		return smallestDistance
+	override distanceToPoint(point: Vec, hitInside = false) {
+		return Math.min(...this.children.map((c, i) => c.distanceToPoint(point, hitInside || i > 0)))
 	}
 
-	override hitTestPoint(
-		point: Vec,
-		margin: number,
-		hitInside: boolean,
-		filters = Geometry2dFilters.EXCLUDE_LABELS
-	): boolean {
+	override hitTestPoint(point: Vec, margin: number, hitInside: boolean): boolean {
 		return !!this.children
-			.filter((c) => !c.isExcludedByFilter(filters))
+			.filter((c) => !c.isLabel)
 			.find((c) => c.hitTestPoint(point, margin, hitInside))
 	}
 
-	override hitTestLineSegment(
-		A: Vec,
-		B: Vec,
-		zoom: number,
-		filters = Geometry2dFilters.EXCLUDE_LABELS
-	): boolean {
-		return !!this.children
-			.filter((c) => !c.isExcludedByFilter(filters))
-			.find((c) => c.hitTestLineSegment(A, B, zoom))
-	}
-
-	override intersectLineSegment(A: VecLike, B: VecLike, filters?: Geometry2dFilters) {
-		return this.children.flatMap((child) => {
-			if (child.isExcludedByFilter(filters)) return EMPTY_ARRAY
-			return child.intersectLineSegment(A, B, filters)
-		})
-	}
-
-	override intersectCircle(center: VecLike, radius: number, filters?: Geometry2dFilters) {
-		return this.children.flatMap((child) => {
-			if (child.isExcludedByFilter(filters)) return EMPTY_ARRAY
-			return child.intersectCircle(center, radius, filters)
-		})
-	}
-
-	override intersectPolygon(polygon: VecLike[], filters?: Geometry2dFilters) {
-		return this.children.flatMap((child) => {
-			if (child.isExcludedByFilter(filters)) return EMPTY_ARRAY
-			return child.intersectPolygon(polygon, filters)
-		})
-	}
-
-	override intersectPolyline(polyline: VecLike[], filters?: Geometry2dFilters) {
-		return this.children.flatMap((child) => {
-			if (child.isExcludedByFilter(filters)) return EMPTY_ARRAY
-			return child.intersectPolyline(polyline, filters)
-		})
-	}
-
-	override transform(transform: Mat): Geometry2d {
-		return new Group2d({
-			children: this.children.map((c) => c.transform(transform)),
-			isLabel: this.isLabel,
-			debugColor: this.debugColor,
-			ignore: this.ignore,
-		})
+	override hitTestLineSegment(A: Vec, B: Vec, zoom: number): boolean {
+		return !!this.children.filter((c) => !c.isLabel).find((c) => c.hitTestLineSegment(A, B, zoom))
 	}
 
 	getArea() {
@@ -165,6 +102,6 @@ export class Group2d extends Geometry2d {
 	}
 
 	getSvgPathData(): string {
-		return this.children.map((c, i) => (c.isLabel ? '' : c.getSvgPathData(i === 0))).join(' ')
+		return this.children.map((c) => (c.isLabel ? '' : c.getSvgPathData(true))).join(' ')
 	}
 }

package/src/lib/primitives/intersect.ts

@@ -293,47 +293,6 @@ export function intersectPolygonPolygon(
 	return orderClockwise([...result.values()])
 }
 
-/**
- * Find all the points where `polyA` and `polyB` intersect and returns them in an undefined order.
- * To find the polygon that's the intersection of polyA and polyB, use `intersectPolygonPolygon`
- * instead, which orders the points and includes internal points.
- *
- * @param polyA - The first polygon.
- * @param polyB - The second polygon.
- * @param isAClosed - Whether `polyA` is a closed polygon or a polyline.
- * @param isBClosed - Whether `polyB` is a closed polygon or a polyline.
- * @public
- */
-export function intersectPolys(
-	polyA: VecLike[],
-	polyB: VecLike[],
-	isAClosed: boolean,
-	isBClosed: boolean
-): VecLike[] {
-	const result: Map<string, VecLike> = new Map()
-
-	// Add all intersection points to result
-	for (let i = 0, n = isAClosed ? polyA.length : polyA.length - 1; i < n; i++) {
-		const currentA = polyA[i]
-		const nextA = polyA[(i + 1) % polyA.length]
-
-		for (let j = 0, m = isBClosed ? polyB.length : polyB.length - 1; j < m; j++) {
-			const currentB = polyB[j]
-			const nextB = polyB[(j + 1) % polyB.length]
-			const intersection = intersectLineSegmentLineSegment(currentA, nextA, currentB, nextB)
-
-			if (intersection !== null) {
-				const id = getPointId(intersection)
-				if (!result.has(id)) {
-					result.set(id, intersection)
-				}
-			}
-		}
-	}
-
-	return [...result.values()]
-}
-
 function getPointId(point: VecLike) {
 	return `${point.x},${point.y}`
 }

package/src/lib/utils/reorderShapes.ts

@@ -154,17 +154,24 @@ function reorderToFront(moving: Set<TLShape>, children: TLShape[], changes: TLSh
 	}
 }
 
+function getVerticesInPageSpace(editor: Editor, shape: TLShape) {
+	const geo = editor.getShapeGeometry(shape)
+	const pageTransform = editor.getShapePageTransform(shape)
+	if (!geo || !pageTransform) return null
+	return pageTransform.applyToPoints(geo.vertices)
+}
+
 function getOverlapChecker(editor: Editor, moving: Set<TLShape>) {
 	const movingVertices = Array.from(moving)
 		.map((shape) => {
-			const vertices = editor.getShapePageGeometry(shape).vertices
+			const vertices = getVerticesInPageSpace(editor, shape)
 			if (!vertices) return null
 			return { shape, vertices }
 		})
 		.filter(Boolean) as { shape: TLShape; vertices: Vec[] }[]
 
 	const isOverlapping = (child: TLShape) => {
-		const vertices = editor.getShapePageGeometry(child).vertices
+		const vertices = getVerticesInPageSpace(editor, child)
 		if (!vertices) return false
 		return movingVertices.some((other) => {
 			return polygonsIntersect(other.vertices, vertices)

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.12.0-canary.3e2ed74b5e86'
+export const version = '3.12.0-canary.423f9b4f2a86'
 export const publishDates = {
 	major: '2024-09-13T14:36:29.063Z',
-	minor: '2025-04-03T13:23:30.522Z',
-	patch: '2025-04-03T13:23:30.522Z',
+	minor: '2025-04-03T13:02:18.145Z',
+	patch: '2025-04-03T13:02:18.145Z',
 }