@tldraw/editor 3.16.0-canary.5f82fb812214 → 3.16.0-canary.5f8d98bccb38

package/src/lib/license/LicenseManager.ts

@@ -1,16 +1,16 @@
 import { atom } from '@tldraw/state'
-import { fetch } from '@tldraw/utils'
-import { publishDates } from '../../version'
+import { publishDates, version } from '../../version'
 import { getDefaultCdnBaseUrl } from '../utils/assets'
 import { importPublicKey, str2ab } from '../utils/licensing'
 
-const GRACE_PERIOD_DAYS = 5
+const GRACE_PERIOD_DAYS = 30
 
 export const FLAGS = {
-	ANNUAL_LICENSE: 0x1,
-	PERPETUAL_LICENSE: 0x2,
-	INTERNAL_LICENSE: 0x4,
-	WITH_WATERMARK: 0x8,
+	ANNUAL_LICENSE: 1,
+	PERPETUAL_LICENSE: 1 << 1,
+	INTERNAL_LICENSE: 1 << 2,
+	WITH_WATERMARK: 1 << 3,
+	EVALUATION_LICENSE: 1 << 4,
 }
 const HIGHEST_FLAG = Math.max(...Object.values(FLAGS))
 
@@ -36,11 +36,12 @@ export interface LicenseInfo {
 
 /** @internal */
 export type LicenseState =
-	| 'pending'
-	| 'licensed'
-	| 'licensed-with-watermark'
-	| 'unlicensed'
-	| 'internal-expired'
+	| 'pending' // License validation is in progress
+	| 'licensed' // License is valid and active (no restrictions)
+	| 'licensed-with-watermark' // License is valid but shows watermark (evaluation licenses, WITH_WATERMARK licenses)
+	| 'unlicensed' // No valid license found or license is invalid (development)
+	| 'unlicensed-production' // No valid license in production deployment (missing, invalid, or wrong domain)
+	| 'expired' // License has been expired (30 days past expiration for regular licenses, immediately for evaluation licenses)
 /** @internal */
 export type InvalidLicenseReason =
 	| 'invalid-license-key'
@@ -69,11 +70,17 @@ export interface ValidLicenseKeyResult {
 	isPerpetualLicenseExpired: boolean
 	isInternalLicense: boolean
 	isLicensedWithWatermark: boolean
+	isEvaluationLicense: boolean
+	isEvaluationLicenseExpired: boolean
+	daysSinceExpiry: number
 }
 
 /** @internal */
 export type TestEnvironment = 'development' | 'production'
 
+/** @internal */
+export type TrackType = 'unlicensed' | 'with_watermark' | 'evaluation' | null
+
 /** @internal */
 export class LicenseManager {
 	private publicKey =
@@ -96,11 +103,13 @@ export class LicenseManager {
 
 		this.getLicenseFromKey(licenseKey)
 			.then((result) => {
-				const licenseState = getLicenseState(result)
+				const licenseState = getLicenseState(
+					result,
+					(messages: string[]) => this.outputMessages(messages),
+					this.isDevelopment
+				)
 
-				if (!this.isDevelopment && licenseState === 'unlicensed') {
-					fetch(WATERMARK_TRACK_SRC)
-				}
+				this.maybeTrack(result, licenseState)
 
 				this.state.set(licenseState)
 			})
@@ -121,6 +130,47 @@ export class LicenseManager {
 		)
 	}
 
+	private getTrackType(result: LicenseFromKeyResult, licenseState: LicenseState): TrackType {
+		// Track watermark for unlicensed production deployments
+		if (licenseState === 'unlicensed-production') {
+			return 'unlicensed'
+		}
+
+		if (this.isDevelopment) {
+			return null
+		}
+
+		if (!result.isLicenseParseable) {
+			return null
+		}
+
+		// Track evaluation licenses (for analytics, even though no watermark is shown)
+		if (result.isEvaluationLicense) {
+			return 'evaluation'
+		}
+
+		// Track licenses that show watermarks
+		if (licenseState === 'licensed-with-watermark') {
+			return 'with_watermark'
+		}
+
+		return null
+	}
+
+	private maybeTrack(result: LicenseFromKeyResult, licenseState: LicenseState): void {
+		const trackType = this.getTrackType(result, licenseState)
+		if (!trackType) {
+			return
+		}
+
+		const url = new URL(WATERMARK_TRACK_SRC)
+		url.searchParams.set('version', version)
+		url.searchParams.set('license_type', trackType)
+
+		// eslint-disable-next-line no-restricted-globals
+		fetch(url.toString())
+	}
+
 	private async extractLicenseKey(licenseKey: string): Promise<LicenseInfo> {
 		const [data, signature] = licenseKey.split('.')
 		const [prefix, encodedData] = data.split('/')
@@ -207,6 +257,9 @@ export class LicenseManager {
 			const isAnnualLicense = this.isFlagEnabled(licenseInfo.flags, FLAGS.ANNUAL_LICENSE)
 			const isPerpetualLicense = this.isFlagEnabled(licenseInfo.flags, FLAGS.PERPETUAL_LICENSE)
 
+			const isEvaluationLicense = this.isFlagEnabled(licenseInfo.flags, FLAGS.EVALUATION_LICENSE)
+			const daysSinceExpiry = this.getDaysSinceExpiry(expiryDate)
+
 			const result: ValidLicenseKeyResult = {
 				license: licenseInfo,
 				isLicenseParseable: true,
@@ -219,6 +272,10 @@ export class LicenseManager {
 				isPerpetualLicenseExpired: isPerpetualLicense && this.isPerpetualLicenseExpired(expiryDate),
 				isInternalLicense: this.isFlagEnabled(licenseInfo.flags, FLAGS.INTERNAL_LICENSE),
 				isLicensedWithWatermark: this.isFlagEnabled(licenseInfo.flags, FLAGS.WITH_WATERMARK),
+				isEvaluationLicense,
+				isEvaluationLicenseExpired:
+					isEvaluationLicense && this.isEvaluationLicenseExpired(expiryDate),
+				daysSinceExpiry,
 			}
 			this.outputLicenseInfoIfNeeded(result)
 
@@ -284,15 +341,7 @@ export class LicenseManager {
 
 	private isAnnualLicenseExpired(expiryDate: Date) {
 		const expiration = this.getExpirationDateWithGracePeriod(expiryDate)
-		const isExpired = new Date() >= expiration
-		// If it is not expired yet (including the grace period), but after the expiry date we warn the users
-		if (!isExpired && new Date() >= this.getExpirationDateWithoutGracePeriod(expiryDate)) {
-			this.outputMessages([
-				'tldraw license is about to expire, you are in a grace period.',
-				`Please reach out to ${LICENSE_EMAIL} if you would like to renew your license.`,
-			])
-		}
-		return isExpired
+		return new Date() >= expiration
 	}
 
 	private isPerpetualLicenseExpired(expiryDate: Date) {
@@ -305,6 +354,21 @@ export class LicenseManager {
 		return dates.major >= expiration || dates.minor >= expiration
 	}
 
+	private getDaysSinceExpiry(expiryDate: Date): number {
+		const now = new Date()
+		const expiration = this.getExpirationDateWithoutGracePeriod(expiryDate)
+		const diffTime = now.getTime() - expiration.getTime()
+		const diffDays = Math.floor(diffTime / (1000 * 60 * 60 * 24))
+		return Math.max(0, diffDays)
+	}
+
+	private isEvaluationLicenseExpired(expiryDate: Date): boolean {
+		// Evaluation licenses have no grace period - they expire immediately
+		const now = new Date()
+		const expiration = this.getExpirationDateWithoutGracePeriod(expiryDate)
+		return now >= expiration
+	}
+
 	private isFlagEnabled(flags: number, flag: number) {
 		return (flags & flag) === flag
 	}
@@ -322,19 +386,6 @@ export class LicenseManager {
 	}
 
 	private outputLicenseInfoIfNeeded(result: ValidLicenseKeyResult) {
-		if (result.isAnnualLicenseExpired) {
-			this.outputMessages([
-				'Your tldraw license has expired!',
-				`Please reach out to ${LICENSE_EMAIL} to renew.`,
-			])
-		}
-
-		if (!result.isDomainValid && !result.isDevelopment) {
-			this.outputMessages([
-				'This tldraw license key is not valid for this domain!',
-				`Please reach out to ${LICENSE_EMAIL} if you would like to use tldraw on other domains.`,
-			])
-		}
 		// If we added a new flag it will be twice the value of the currently highest flag.
 		// And if all the current flags are on we would get the `HIGHEST_FLAG * 2 - 1`, so anything higher than that means there are new flags.
 		if (result.license.flags >= HIGHEST_FLAG * 2) {
@@ -371,13 +422,74 @@ export class LicenseManager {
 	static className = 'tl-watermark_SEE-LICENSE'
 }
 
-export function getLicenseState(result: LicenseFromKeyResult): LicenseState {
-	if (!result.isLicenseParseable) return 'unlicensed'
-	if (!result.isDomainValid && !result.isDevelopment) return 'unlicensed'
+export function getLicenseState(
+	result: LicenseFromKeyResult,
+	outputMessages: (messages: string[]) => void,
+	isDevelopment: boolean
+): LicenseState {
+	if (!result.isLicenseParseable) {
+		if (isDevelopment) {
+			return 'unlicensed'
+		}
+
+		// All unlicensed scenarios should not work in production
+		if (result.reason === 'no-key-provided') {
+			outputMessages([
+				'No tldraw license key provided!',
+				'A license is required for production deployments.',
+				`Please reach out to ${LICENSE_EMAIL} to purchase a license.`,
+			])
+		} else {
+			outputMessages([
+				'Invalid license key. tldraw requires a valid license for production use.',
+				`Please reach out to ${LICENSE_EMAIL} to purchase a license.`,
+			])
+		}
+		return 'unlicensed-production'
+	}
+
+	if (!result.isDomainValid && !result.isDevelopment) {
+		outputMessages([
+			'License key is not valid for this domain.',
+			'A license is required for production deployments.',
+			`Please reach out to ${LICENSE_EMAIL} to purchase a license.`,
+		])
+		return 'unlicensed-production'
+	}
+
+	// Handle evaluation licenses - they expire immediately with no grace period
+	if (result.isEvaluationLicense) {
+		if (result.isEvaluationLicenseExpired) {
+			outputMessages([
+				'Your tldraw evaluation license has expired!',
+				`Please reach out to ${LICENSE_EMAIL} to purchase a full license.`,
+			])
+			return 'expired'
+		} else {
+			// Valid evaluation license - tracked but no watermark shown
+			return 'licensed'
+		}
+	}
+
+	// Handle expired regular licenses (both annual and perpetual)
 	if (result.isPerpetualLicenseExpired || result.isAnnualLicenseExpired) {
-		// Check if it's an expired internal license with valid domain
-		const internalExpired = result.isInternalLicense && result.isDomainValid
-		return internalExpired ? 'internal-expired' : 'unlicensed'
+		outputMessages([
+			'Your tldraw license has been expired for more than 30 days!',
+			`Please reach out to ${LICENSE_EMAIL} to renew your license.`,
+		])
+		return 'expired'
+	}
+
+	// Check if license is past expiry date but within grace period
+	const daysSinceExpiry = result.daysSinceExpiry
+	if (daysSinceExpiry > 0 && !result.isEvaluationLicense) {
+		outputMessages([
+			'Your tldraw license has expired.',
+			`License expired ${daysSinceExpiry} days ago.`,
+			`Please reach out to ${LICENSE_EMAIL} to renew your license.`,
+		])
+		// Within 30-day grace period: still licensed (no watermark)
+		return 'licensed'
 	}
 
 	// License is valid, determine if it has watermark

package/src/lib/license/LicenseProvider.tsx

@@ -1,5 +1,5 @@
 import { useValue } from '@tldraw/state-react'
-import { createContext, ReactNode, useContext, useState } from 'react'
+import { createContext, ReactNode, useContext, useEffect, useState } from 'react'
 import { LicenseManager } from './LicenseManager'
 
 /** @internal */
@@ -8,9 +8,16 @@ export const LicenseContext = createContext({} as LicenseManager)
 /** @internal */
 export const useLicenseContext = () => useContext(LicenseContext)
 
+function shouldHideEditorAfterDelay(licenseState: string): boolean {
+	return licenseState === 'expired' || licenseState === 'unlicensed-production'
+}
+
+/** @internal */
+export const LICENSE_TIMEOUT = 5000
+
 /** @internal */
 export function LicenseProvider({
-	licenseKey,
+	licenseKey = getLicenseKeyFromEnv() ?? undefined,
 	children,
 }: {
 	licenseKey?: string
@@ -18,11 +25,68 @@ export function LicenseProvider({
 }) {
 	const [licenseManager] = useState(() => new LicenseManager(licenseKey))
 	const licenseState = useValue(licenseManager.state)
+	const [showEditor, setShowEditor] = useState(true)
 
-	// 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' }} />
+	// When license expires or no license in production, show for 5 seconds then hide
+	useEffect(() => {
+		if (shouldHideEditorAfterDelay(licenseState) && showEditor) {
+			// eslint-disable-next-line no-restricted-globals
+			const timer = setTimeout(() => {
+				setShowEditor(false)
+			}, LICENSE_TIMEOUT)
+
+			return () => clearTimeout(timer)
+		}
+	}, [licenseState, showEditor])
+
+	// If license is expired or no license in production and 5 seconds have passed, don't render anything (blank screen)
+	if (shouldHideEditorAfterDelay(licenseState) && !showEditor) {
+		return <LicenseGate />
 	}
 
 	return <LicenseContext.Provider value={licenseManager}>{children}</LicenseContext.Provider>
 }
+
+// Renders as a hidden div that can be detected by tests
+function LicenseGate() {
+	return <div data-testid="tl-license-expired" style={{ display: 'none' }} />
+}
+
+let envLicenseKey: string | undefined | null = undefined
+function getLicenseKeyFromEnv() {
+	if (envLicenseKey !== undefined) {
+		return envLicenseKey
+	}
+	// it's important here that we write out the full process.env.WHATEVER expression instead of
+	// doing something like process.env[someVariable]. This is because most bundlers do something
+	// like a find-replace inject environment variables, and so won't pick up on dynamic ones. It
+	// also means we can't do checks like `process.env && process.env.WHATEVER`, which is why we use
+	// the `getEnv` try/catch approach.
+
+	// framework-specific prefixes borrowed from the ones vercel uses, but trimmed down to just the
+	// react-y ones: https://vercel.com/docs/environment-variables/framework-environment-variables
+	envLicenseKey =
+		getEnv(() => process.env.TLDRAW_LICENSE_KEY) ||
+		getEnv(() => process.env.NEXT_PUBLIC_TLDRAW_LICENSE_KEY) ||
+		getEnv(() => process.env.REACT_APP_TLDRAW_LICENSE_KEY) ||
+		getEnv(() => process.env.GATSBY_TLDRAW_LICENSE_KEY) ||
+		getEnv(() => process.env.VITE_TLDRAW_LICENSE_KEY) ||
+		getEnv(() => process.env.PUBLIC_TLDRAW_LICENSE_KEY) ||
+		getEnv(() => (import.meta as any).env.TLDRAW_LICENSE_KEY) ||
+		getEnv(() => (import.meta as any).env.NEXT_PUBLIC_TLDRAW_LICENSE_KEY) ||
+		getEnv(() => (import.meta as any).env.REACT_APP_TLDRAW_LICENSE_KEY) ||
+		getEnv(() => (import.meta as any).env.GATSBY_TLDRAW_LICENSE_KEY) ||
+		getEnv(() => (import.meta as any).env.VITE_TLDRAW_LICENSE_KEY) ||
+		getEnv(() => (import.meta as any).env.PUBLIC_TLDRAW_LICENSE_KEY) ||
+		null
+
+	return envLicenseKey
+}
+
+function getEnv(cb: () => string | undefined) {
+	try {
+		return cb()
+	} catch {
+		return undefined
+	}
+}

package/src/lib/license/Watermark.tsx

@@ -28,12 +28,74 @@ export const Watermark = memo(function Watermark() {
 	return (
 		<>
 			<LicenseStyles />
-			<WatermarkInner src={isMobile ? WATERMARK_MOBILE_LOCAL_SRC : WATERMARK_DESKTOP_LOCAL_SRC} />
+			<WatermarkInner
+				src={isMobile ? WATERMARK_MOBILE_LOCAL_SRC : WATERMARK_DESKTOP_LOCAL_SRC}
+				isUnlicensed={licenseManagerState === 'unlicensed'}
+			/>
 		</>
 	)
 })
 
-const WatermarkInner = memo(function WatermarkInner({ src }: { src: string }) {
+const UnlicensedWatermark = memo(function UnlicensedWatermark({
+	isDebugMode,
+	isMobile,
+}: {
+	isDebugMode: boolean
+	isMobile: boolean
+}) {
+	const events = useCanvasEvents()
+	const ref = useRef<HTMLDivElement>(null)
+	usePassThroughWheelEvents(ref)
+
+	const url = 'https://tldraw.dev/?utm_source=dotcom&utm_medium=organic&utm_campaign=watermark'
+
+	return (
+		<div
+			ref={ref}
+			className={LicenseManager.className}
+			data-debug={isDebugMode}
+			data-mobile={isMobile}
+			data-unlicensed={true}
+			data-testid="tl-watermark-unlicensed"
+			draggable={false}
+			{...events}
+		>
+			<button
+				draggable={false}
+				role="button"
+				onPointerDown={(e) => {
+					stopEventPropagation(e)
+					preventDefault(e)
+				}}
+				title="Unlicensed - click to get a license"
+				onClick={() => runtime.openWindow(url, '_blank')}
+				style={{
+					position: 'absolute',
+					pointerEvents: 'all',
+					cursor: 'pointer',
+					color: 'var(--tl-color-text)',
+					opacity: 0.8,
+					border: 0,
+					padding: 0,
+					backgroundColor: 'transparent',
+					fontSize: '11px',
+					fontWeight: '600',
+					textAlign: 'center',
+				}}
+			>
+				Unlicensed
+			</button>
+		</div>
+	)
+})
+
+const WatermarkInner = memo(function WatermarkInner({
+	src,
+	isUnlicensed,
+}: {
+	src: string
+	isUnlicensed: boolean
+}) {
 	const editor = useEditor()
 	const isDebugMode = useValue('debug mode', () => editor.getInstanceState().isDebugMode, [editor])
 	const isMobile = useValue('is mobile', () => editor.getViewportScreenBounds().width < 700, [
@@ -47,12 +109,17 @@ const WatermarkInner = memo(function WatermarkInner({ src }: { src: string }) {
 	const maskCss = `url('${src}') center 100% / 100% no-repeat`
 	const url = 'https://tldraw.dev/?utm_source=dotcom&utm_medium=organic&utm_campaign=watermark'
 
+	if (isUnlicensed) {
+		return <UnlicensedWatermark isDebugMode={isDebugMode} isMobile={isMobile} />
+	}
+
 	return (
 		<div
 			ref={ref}
 			className={LicenseManager.className}
 			data-debug={isDebugMode}
 			data-mobile={isMobile}
+			data-testid="tl-watermark-licensed"
 			draggable={false}
 			{...events}
 		>
@@ -86,8 +153,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 +183,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/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))
+	}
 }