@tldraw/editor 3.16.0-canary.6074088f67bd → 3.16.0-canary.62bc202550a3

package/src/lib/license/LicenseManager.test.ts

@@ -4,7 +4,7 @@ import { publishDates } from '../../version'
 import { str2ab } from '../utils/licensing'
 import {
 	FLAGS,
-	isEditorUnlicensed,
+	getLicenseState,
 	LicenseManager,
 	PROPERTIES,
 	ValidLicenseKeyResult,
@@ -487,115 +487,122 @@ function getDefaultLicenseResult(overrides: Partial<ValidLicenseKeyResult>): Val
 	}
 }
 
-describe(isEditorUnlicensed, () => {
-	it('shows watermark when license is not parseable', () => {
+describe('getLicenseState', () => {
+	it('returns "unlicensed" for unparseable license', () => {
 		const licenseResult = getDefaultLicenseResult({
 			// @ts-ignore
 			isLicenseParseable: false,
 		})
-		expect(isEditorUnlicensed(licenseResult)).toBe(true)
+		expect(getLicenseState(licenseResult)).toBe('unlicensed')
 	})
 
-	it('shows watermark when domain is not valid', () => {
+	it('returns "unlicensed" for invalid domain in production', () => {
 		const licenseResult = getDefaultLicenseResult({
 			isDomainValid: false,
+			isDevelopment: false,
 		})
-		expect(isEditorUnlicensed(licenseResult)).toBe(true)
+		expect(getLicenseState(licenseResult)).toBe('unlicensed')
 	})
 
-	it('shows watermark when annual license has expired', () => {
+	it('returns "licensed" for invalid domain in development mode', () => {
+		const licenseResult = getDefaultLicenseResult({
+			isDomainValid: false,
+			isDevelopment: true,
+		})
+		expect(getLicenseState(licenseResult)).toBe('licensed')
+	})
+
+	it('returns "unlicensed" for expired annual license', () => {
 		const licenseResult = getDefaultLicenseResult({
 			isAnnualLicense: true,
 			isAnnualLicenseExpired: true,
+			isInternalLicense: false,
 		})
-		expect(isEditorUnlicensed(licenseResult)).toBe(true)
+		expect(getLicenseState(licenseResult)).toBe('unlicensed')
 	})
 
-	it('shows watermark when annual license has expired, even if dev mode', () => {
+	it('returns "unlicensed" for expired annual license even in dev mode', () => {
 		const licenseResult = getDefaultLicenseResult({
 			isAnnualLicense: true,
 			isAnnualLicenseExpired: true,
 			isDevelopment: true,
+			isInternalLicense: false,
 		})
-		expect(isEditorUnlicensed(licenseResult)).toBe(true)
+		expect(getLicenseState(licenseResult)).toBe('unlicensed')
 	})
 
-	it('shows watermark when perpetual license has expired', () => {
+	it('returns "unlicensed" for expired perpetual license', () => {
 		const licenseResult = getDefaultLicenseResult({
 			isPerpetualLicense: true,
 			isPerpetualLicenseExpired: true,
+			isInternalLicense: false,
 		})
-		expect(isEditorUnlicensed(licenseResult)).toBe(true)
+		expect(getLicenseState(licenseResult)).toBe('unlicensed')
 	})
 
-	it('does not show watermark when license is valid and not expired', () => {
+	it('returns "internal-expired" for expired internal annual license with valid domain', () => {
+		const expiryDate = new Date(2023, 1, 1)
 		const licenseResult = getDefaultLicenseResult({
 			isAnnualLicense: true,
-			isAnnualLicenseExpired: false,
-			isInternalLicense: false,
+			isAnnualLicenseExpired: true,
+			isInternalLicense: true,
+			isDomainValid: true,
+			expiryDate,
 		})
-		expect(isEditorUnlicensed(licenseResult)).toBe(false)
+		expect(getLicenseState(licenseResult)).toBe('internal-expired')
 	})
 
-	it('does not show watermark when perpetual license is valid and not expired', () => {
+	it('returns "internal-expired" for expired internal perpetual license with valid domain', () => {
+		const expiryDate = new Date(2023, 1, 1)
 		const licenseResult = getDefaultLicenseResult({
 			isPerpetualLicense: true,
-			isPerpetualLicenseExpired: false,
-			isInternalLicense: false,
-		})
-		expect(isEditorUnlicensed(licenseResult)).toBe(false)
-	})
-
-	it('does not show watermark when in development mode', () => {
-		const licenseResult = getDefaultLicenseResult({
-			isDevelopment: true,
+			isPerpetualLicenseExpired: true,
+			isInternalLicense: true,
+			isDomainValid: true,
+			expiryDate,
 		})
-		expect(isEditorUnlicensed(licenseResult)).toBe(false)
+		expect(getLicenseState(licenseResult)).toBe('internal-expired')
 	})
 
-	it('does not show watermark when license is parseable and domain is valid', () => {
+	it('returns "unlicensed" for expired internal license with invalid domain', () => {
+		const expiryDate = new Date(2023, 1, 1)
 		const licenseResult = getDefaultLicenseResult({
-			isLicenseParseable: true,
-			isDomainValid: true,
+			isAnnualLicense: true,
+			isAnnualLicenseExpired: true,
+			isInternalLicense: true,
+			isDomainValid: false,
+			expiryDate,
 		})
-		expect(isEditorUnlicensed(licenseResult)).toBe(false)
+		expect(getLicenseState(licenseResult)).toBe('unlicensed')
 	})
 
-	it('does not show watermark when license is parseable and domain is not valid and dev mode', () => {
+	it('returns "licensed-with-watermark" for watermarked license', () => {
 		const licenseResult = getDefaultLicenseResult({
-			isLicenseParseable: true,
-			isDomainValid: false,
-			isDevelopment: true,
+			isLicensedWithWatermark: true,
 		})
-		expect(isEditorUnlicensed(licenseResult)).toBe(false)
+		expect(getLicenseState(licenseResult)).toBe('licensed-with-watermark')
 	})
 
-	it('throws when an internal annual license has expired', () => {
-		const expiryDate = new Date(2023, 1, 1)
+	it('returns "licensed" for valid annual license', () => {
 		const licenseResult = getDefaultLicenseResult({
 			isAnnualLicense: true,
-			isAnnualLicenseExpired: true,
-			isInternalLicense: true,
-			expiryDate,
+			isAnnualLicenseExpired: false,
 		})
-		expect(() => isEditorUnlicensed(licenseResult)).toThrow(/License: Internal license expired/)
+		expect(getLicenseState(licenseResult)).toBe('licensed')
 	})
 
-	it('throws when an internal perpetual license has expired', () => {
-		const expiryDate = new Date(2023, 1, 1)
+	it('returns "licensed" for valid perpetual license', () => {
 		const licenseResult = getDefaultLicenseResult({
 			isPerpetualLicense: true,
-			isPerpetualLicenseExpired: true,
-			isInternalLicense: true,
-			expiryDate,
+			isPerpetualLicenseExpired: false,
 		})
-		expect(() => isEditorUnlicensed(licenseResult)).toThrow(/License: Internal license expired/)
+		expect(getLicenseState(licenseResult)).toBe('licensed')
 	})
 
-	it('shows watermark when license has that flag specified', () => {
+	it('returns "licensed" for valid license in development mode', () => {
 		const licenseResult = getDefaultLicenseResult({
-			isLicensedWithWatermark: true,
+			isDevelopment: true,
 		})
-		expect(isEditorUnlicensed(licenseResult)).toBe(false)
+		expect(getLicenseState(licenseResult)).toBe('licensed')
 	})
 })

package/src/lib/license/LicenseManager.ts

@@ -33,6 +33,14 @@ export interface LicenseInfo {
 	flags: number
 	expiryDate: string
 }
+
+/** @internal */
+export type LicenseState =
+	| 'pending'
+	| 'licensed'
+	| 'licensed-with-watermark'
+	| 'unlicensed'
+	| 'internal-expired'
 /** @internal */
 export type InvalidLicenseReason =
 	| 'invalid-license-key'
@@ -73,10 +81,7 @@ export class LicenseManager {
 	public isDevelopment: boolean
 	public isTest: boolean
 	public isCryptoAvailable: boolean
-	state = atom<'pending' | 'licensed' | 'licensed-with-watermark' | 'unlicensed'>(
-		'license state',
-		'pending'
-	)
+	state = atom<LicenseState>('license state', 'pending')
 	public verbose = true
 
 	constructor(
@@ -89,21 +94,20 @@ export class LicenseManager {
 		this.publicKey = testPublicKey || this.publicKey
 		this.isCryptoAvailable = !!crypto.subtle
 
-		this.getLicenseFromKey(licenseKey).then((result) => {
-			const isUnlicensed = isEditorUnlicensed(result)
+		this.getLicenseFromKey(licenseKey)
+			.then((result) => {
+				const licenseState = getLicenseState(result)
 
-			if (!this.isDevelopment && isUnlicensed) {
-				fetch(WATERMARK_TRACK_SRC)
-			}
+				if (!this.isDevelopment && licenseState === 'unlicensed') {
+					fetch(WATERMARK_TRACK_SRC)
+				}
 
-			if (isUnlicensed) {
+				this.state.set(licenseState)
+			})
+			.catch((error) => {
+				console.error('License validation failed:', error)
 				this.state.set('unlicensed')
-			} else if ((result as ValidLicenseKeyResult).isLicensedWithWatermark) {
-				this.state.set('licensed-with-watermark')
-			} else {
-				this.state.set('licensed')
-			}
-		})
+			})
 	}
 
 	private getIsDevelopment(testEnvironment?: TestEnvironment) {
@@ -367,15 +371,19 @@ export class LicenseManager {
 	static className = 'tl-watermark_SEE-LICENSE'
 }
 
-export function isEditorUnlicensed(result: LicenseFromKeyResult) {
-	if (!result.isLicenseParseable) return true
-	if (!result.isDomainValid && !result.isDevelopment) return true
+export function getLicenseState(result: LicenseFromKeyResult): LicenseState {
+	if (!result.isLicenseParseable) return 'unlicensed'
+	if (!result.isDomainValid && !result.isDevelopment) return 'unlicensed'
 	if (result.isPerpetualLicenseExpired || result.isAnnualLicenseExpired) {
-		if (result.isInternalLicense) {
-			throw new Error('License: Internal license expired.')
-		}
-		return true
+		// Check if it's an expired internal license with valid domain
+		const internalExpired = result.isInternalLicense && result.isDomainValid
+		return internalExpired ? 'internal-expired' : 'unlicensed'
+	}
+
+	// License is valid, determine if it has watermark
+	if (result.isLicensedWithWatermark) {
+		return 'licensed-with-watermark'
 	}
 
-	return false
+	return 'licensed'
 }

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/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.6074088f67bd'
+export const version = '3.16.0-canary.62bc202550a3'
 export const publishDates = {
 	major: '2024-09-13T14:36:29.063Z',
-	minor: '2025-08-28T08:54:13.475Z',
-	patch: '2025-08-28T08:54:13.475Z',
+	minor: '2025-09-03T09:39:32.548Z',
+	patch: '2025-09-03T09:39:32.548Z',
 }