@tldraw/editor 3.16.0-canary.bf9fb05eb8ef → 3.16.0-canary.c2c4563957ce

package/src/lib/license/LicenseProvider.tsx

@@ -1,3 +1,4 @@
+import { useValue } from '@tldraw/state-react'
 import { createContext, ReactNode, useContext, useState } from 'react'
 import { LicenseManager } from './LicenseManager'
 
@@ -16,5 +17,12 @@ export function LicenseProvider({
 	children: ReactNode
 }) {
 	const [licenseManager] = useState(() => new LicenseManager(licenseKey))
+	const licenseState = useValue(licenseManager.state)
+
+	// If internal license has expired, don't render the editor at all
+	if (licenseState === 'internal-expired') {
+		return <div data-testid="tl-license-expired" style={{ display: 'none' }} />
+	}
+
 	return <LicenseContext.Provider value={licenseManager}>{children}</LicenseContext.Provider>
 }

package/src/lib/license/Watermark.tsx

@@ -86,8 +86,8 @@ To remove the watermark, please purchase a license at tldraw.dev.
 
 	.${className} {
 		position: absolute;
-		bottom: var(--tl-space-2);
-		right: var(--tl-space-2);
+		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;
@@ -116,12 +116,12 @@ To remove the watermark, please purchase a license at tldraw.dev.
 	}
 
 	.${className}[data-debug='true'] {
-		bottom: 46px;
+		bottom: max(46px, env(safe-area-inset-bottom));
 	}
 
 	.${className}[data-mobile='true'] {
 		border-radius: 4px 0px 0px 4px;
-		right: -2px;
+		right: max(-2px, calc(env(safe-area-inset-right) - 2px));
 		width: 8px;
 		height: 48px;
 	}

package/src/lib/license/useLicenseManagerState.ts

@@ -1,7 +1,7 @@
 import { useValue } from '@tldraw/state-react'
-import { LicenseManager } from './LicenseManager'
+import { LicenseManager, LicenseState } from './LicenseManager'
 
 /** @internal */
-export function useLicenseManagerState(licenseManager: LicenseManager) {
+export function useLicenseManagerState(licenseManager: LicenseManager): LicenseState {
 	return useValue('watermarkState', () => licenseManager.state.get(), [licenseManager])
 }

package/src/lib/primitives/Vec.ts

@@ -240,11 +240,6 @@ export class Vec {
 		return Vec.EqualsXY(this, x, y)
 	}
 
-	/** @deprecated use `uni` instead */
-	norm() {
-		return this.uni()
-	}
-
 	toFixed() {
 		this.x = toFixed(this.x)
 		this.y = toFixed(this.y)

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

@@ -9,6 +9,8 @@ import {
 	intersectLineSegmentPolyline,
 	intersectPolys,
 	linesIntersect,
+	polygonIntersectsPolyline,
+	polygonsIntersect,
 } from '../intersect'
 import { approximately, pointInPolygon } from '../utils'
 
@@ -227,25 +229,6 @@ export abstract class Geometry2d {
 		return distanceAlongRoute / length
 	}
 
-	/** @deprecated Iterate the vertices instead. */
-	nearestPointOnLineSegment(A: VecLike, B: VecLike): Vec {
-		const { vertices } = this
-		let nearest: Vec | undefined
-		let dist = Infinity
-		let d: number, p: Vec, q: Vec
-		for (let i = 0; i < vertices.length; i++) {
-			p = vertices[i]
-			q = Vec.NearestPointOnLineSegment(A, B, p, true)
-			d = Vec.Dist2(p, q)
-			if (d < dist) {
-				dist = d
-				nearest = q
-			}
-		}
-		if (!nearest) throw Error('nearest point not found')
-		return nearest
-	}
-
 	isPointInBounds(point: VecLike, margin = 0) {
 		const { bounds } = this
 		return !(
@@ -256,6 +239,53 @@ export abstract class Geometry2d {
 		)
 	}
 
+	overlapsPolygon(_polygon: VecLike[]): boolean {
+		const polygon = _polygon.map((v) => Vec.From(v))
+
+		// Otherwise, check if the geometry itself overlaps the polygon
+		const { vertices, center, isFilled, isEmptyLabel, isClosed } = this
+
+		// We'll do things in order of cheapest to most expensive checks
+
+		// Skip empty labels
+		if (isEmptyLabel) return false
+
+		// If any of the geometry's vertices are inside the polygon, it's inside
+		if (vertices.some((v) => pointInPolygon(v, polygon))) {
+			return true
+		}
+
+		// If the geometry is filled and closed and its center is inside the polygon, it's inside
+		if (isClosed) {
+			if (isFilled) {
+				// If closed and filled, check if the center is inside the polygon
+				if (pointInPolygon(center, polygon)) {
+					return true
+				}
+
+				// ..then, slightly more expensive check, see the geometry covers the entire polygon but not its center
+				if (polygon.every((v) => pointInPolygon(v, vertices))) {
+					return true
+				}
+			}
+
+			// If any the geometry's vertices intersect the edge of the polygon, it's inside.
+			// for example when a rotated rectangle is moved over the corner of a parent rectangle
+			// If the geometry is closed, intersect as a polygon
+			if (polygonsIntersect(polygon, vertices)) {
+				return true
+			}
+		} else {
+			// If the geometry is not closed, intersect as a polyline
+			if (polygonIntersectsPolyline(polygon, vertices)) {
+				return true
+			}
+		}
+
+		// If none of the above checks passed, the geometry is outside the polygon
+		return false
+	}
+
 	transform(transform: MatModel, opts?: TransformedGeometry2dOptions): Geometry2d {
 		return new TransformedGeometry2d(this, transform, opts)
 	}

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

@@ -236,4 +236,8 @@ export class Group2d extends Geometry2d {
 	getSvgPathData(): string {
 		return this.children.map((c, i) => (c.isLabel ? '' : c.getSvgPathData(i === 0))).join(' ')
 	}
+
+	overlapsPolygon(polygon: VecLike[]): boolean {
+		return this.children.some((child) => child.overlapsPolygon(polygon))
+	}
 }

package/src/lib/utils/reparenting.ts

@@ -2,15 +2,7 @@ import { EMPTY_ARRAY } from '@tldraw/state'
 import { TLGroupShape, TLParentId, TLShape, TLShapeId } from '@tldraw/tlschema'
 import { IndexKey, compact, getIndexAbove, getIndexBetween } from '@tldraw/utils'
 import { Editor } from '../editor/Editor'
-import { Vec } from '../primitives/Vec'
-import { Geometry2d } from '../primitives/geometry/Geometry2d'
-import { Group2d } from '../primitives/geometry/Group2d'
-import {
-	intersectPolygonPolygon,
-	polygonIntersectsPolyline,
-	polygonsIntersect,
-} from '../primitives/intersect'
-import { pointInPolygon } from '../primitives/utils'
+import { intersectPolygonPolygon } from '../primitives/intersect'
 
 /**
  * Reparents shapes that are no longer contained within their parent shapes.
@@ -189,68 +181,10 @@ function getOverlappingShapes<T extends TLShape[] | TLShapeId[]>(
 
 		const geometry = editor.getShapeGeometry(childId)
 
-		return doesGeometryOverlapPolygon(geometry, parentPolygonInShapeShape)
+		return geometry.overlapsPolygon(parentPolygonInShapeShape)
 	})
 }
 
-/**
- * @public
- */
-export function doesGeometryOverlapPolygon(
-	geometry: Geometry2d,
-	parentCornersInShapeSpace: Vec[]
-): boolean {
-	// If the child is a group, check if any of its children overlap the box
-	if (geometry instanceof Group2d) {
-		return geometry.children.some((childGeometry) =>
-			doesGeometryOverlapPolygon(childGeometry, parentCornersInShapeSpace)
-		)
-	}
-
-	// Otherwise, check if the geometry overlaps the box
-	const { vertices, center, isFilled, isEmptyLabel, isClosed } = geometry
-
-	// We'll do things in order of cheapest to most expensive checks
-
-	// Skip empty labels
-	if (isEmptyLabel) return false
-
-	// If any of the shape's vertices are inside the occluder, it's inside
-	if (vertices.some((v) => pointInPolygon(v, parentCornersInShapeSpace))) {
-		return true
-	}
-
-	// If the shape is filled and closed and its center is inside the parent, it's inside
-	if (isClosed) {
-		if (isFilled) {
-			// If closed and filled, check if the center is inside the parent
-			if (pointInPolygon(center, parentCornersInShapeSpace)) {
-				return true
-			}
-
-			// ..then, slightly more expensive check, see the shape covers the entire parent but not its center
-			if (parentCornersInShapeSpace.every((v) => pointInPolygon(v, vertices))) {
-				return true
-			}
-		}
-
-		// If any the shape's vertices intersect the edge of the occluder, it's inside.
-		// for example when a rotated rectangle is moved over the corner of a parent rectangle
-		// If the child shape is closed, intersect as a polygon
-		if (polygonsIntersect(parentCornersInShapeSpace, vertices)) {
-			return true
-		}
-	} else {
-		// if the child shape is not closed, intersect as a polyline
-		if (polygonIntersectsPolyline(parentCornersInShapeSpace, vertices)) {
-			return true
-		}
-	}
-
-	// If none of the above checks passed, the shape is outside the parent
-	return false
-}
-
 /**
  * Get the shapes that will be reparented to new parents when the shapes are dropped.
  *
@@ -354,7 +288,7 @@ export function getDroppedShapesToNewParents(
 				.applyToPoints(parentPagePolygon)
 
 			// If the shape overlaps the parent polygon, reparent it to that parent
-			if (doesGeometryOverlapPolygon(editor.getShapeGeometry(shape), parentPolygonInShapeSpace)) {
+			if (editor.getShapeGeometry(shape).overlapsPolygon(parentPolygonInShapeSpace)) {
 				// Use the util to check if the shape can be reparented to the parent
 				if (
 					!editor.getShapeUtil(parentShape).canReceiveNewChildrenOfType?.(parentShape, shape.type)

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.bf9fb05eb8ef'
+export const version = '3.16.0-canary.c2c4563957ce'
 export const publishDates = {
 	major: '2024-09-13T14:36:29.063Z',
-	minor: '2025-08-26T14:23:01.958Z',
-	patch: '2025-08-26T14:23:01.958Z',
+	minor: '2025-09-03T11:25:43.960Z',
+	patch: '2025-09-03T11:25:43.960Z',
 }