@tldraw/editor 5.3.0-next.299378752aaf → 5.3.0-next.75e2874c4b3f

package/src/lib/editor/managers/TextManager/TextManager.ts

@@ -183,6 +183,9 @@ export class TextManager extends EditorManager {
 			'font-weight': opts.fontWeight,
 			'font-size': opts.fontSize + 'px',
 			'line-height': `${resolveLineHeightPx(opts.fontSize, opts.lineHeight)}px`,
+			// Unitless multiplier consumed by the .tl-rich-text h1–h6 rule (see editor.css),
+			// so heading measurement matches on-canvas rendering.
+			'--tl-rich-text-heading-line-height': `${opts.lineHeight}`,
 			padding: opts.padding,
 			'max-width': opts.maxWidth ? opts.maxWidth + 'px' : undefined,
 			'min-width': opts.minWidth ? opts.minWidth + 'px' : undefined,

package/src/lib/editor/shapes/ShapeUtil.ts

@@ -669,6 +669,30 @@ export abstract class ShapeUtil<Shape extends TLShape = TLShape> {
 	 */
 	onBeforeCreate?(next: Shape): Shape | void
 
+	/**
+	 * A callback called when a shape is reproduced from an existing shape, either by duplicating
+	 * ({@link Editor.duplicateShapes}) or by pasting/putting content onto the page
+	 * ({@link Editor.putContentOntoCurrentPage}). This provides a last chance to modify the copy
+	 * before it's created — for example, to re-stamp attribution so the copy is credited to the
+	 * current user rather than the original author. It is not called when content is put with
+	 * `preserveIds` (e.g. {@link Editor.moveShapesToPage}), since the shape keeps its identity
+	 * and no copy is made.
+	 *
+	 * @example
+	 *
+	 * ```ts
+	 * onBeforeDuplicate = (source, duplicate) => {
+	 * 	return { ...duplicate, props: { ...duplicate.props, editedBy: this.editor.getAttributionUserId() } }
+	 * }
+	 * ```
+	 *
+	 * @param source - The shape being copied from.
+	 * @param duplicate - The new copy (with its own id), before it's created.
+	 * @returns The next shape or void.
+	 * @public
+	 */
+	onBeforeDuplicate?(source: Shape, duplicate: Shape): Shape | void
+
 	/**
 	 * A callback called just before a shape is updated. This method provides a last chance to modify
 	 * the updated shape.

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

@@ -510,6 +510,60 @@ describe('LicenseManager', () => {
 		})
 	})
 
+	describe('Expiry date timezone handling', () => {
+		afterEach(() => {
+			vi.useRealTimers()
+		})
+
+		// The named expiry date is minted as a date-only string and should mean "the license
+		// is fully usable through the end of that day in UTC", giving every user the same
+		// cutoff regardless of their local timezone.
+		async function makeEvaluationLicenseWithExpiry(expiry: string) {
+			const licenseInfo = JSON.parse(STANDARD_LICENSE_INFO)
+			licenseInfo[PROPERTIES.FLAGS] = FLAGS.EVALUATION_LICENSE
+			licenseInfo[PROPERTIES.EXPIRY_DATE] = expiry
+			return generateLicenseKey(JSON.stringify(licenseInfo), keyPair)
+		}
+
+		it('Keeps the license valid through the end of the named expiry day (UTC)', async () => {
+			const key = await makeEvaluationLicenseWithExpiry('2026-06-26')
+
+			// The final moment of the named day is still valid.
+			vi.useFakeTimers()
+			vi.setSystemTime(new Date('2026-06-26T23:59:59.000Z'))
+			expect(
+				((await licenseManager.getLicenseFromKey(key)) as ValidLicenseKeyResult)
+					.isEvaluationLicenseExpired
+			).toBe(false)
+		})
+
+		it('Expires the license at the start of the day after the named expiry day (UTC)', async () => {
+			const key = await makeEvaluationLicenseWithExpiry('2026-06-26')
+
+			vi.useFakeTimers()
+			vi.setSystemTime(new Date('2026-06-27T00:00:01.000Z'))
+			expect(
+				((await licenseManager.getLicenseFromKey(key)) as ValidLicenseKeyResult)
+					.isEvaluationLicenseExpired
+			).toBe(true)
+		})
+
+		it('Does not expire early for users west of UTC who are still on the named day locally', async () => {
+			const key = await makeEvaluationLicenseWithExpiry('2026-06-26')
+
+			// Under the old logic a user west of UTC parsed the date one calendar day early and
+			// expired at the *start* of that day, losing most of a day. With the uniform UTC
+			// cutoff the license stays valid all through June 26 for everyone, no matter their
+			// local offset. 1pm UTC on June 26 is well before the cutoff, so it is still valid.
+			vi.useFakeTimers()
+			vi.setSystemTime(new Date('2026-06-26T13:00:00.000Z'))
+			expect(
+				((await licenseManager.getLicenseFromKey(key)) as ValidLicenseKeyResult)
+					.isEvaluationLicenseExpired
+			).toBe(false)
+		})
+	})
+
 	describe('License expiry and grace period', () => {
 		it('Fails if the license key has expired beyond grace period', async () => {
 			const expiredLicenseInfo = JSON.parse(STANDARD_LICENSE_INFO)
@@ -540,38 +594,54 @@ describe('LicenseManager', () => {
 		})
 
 		it('Handles grace period correctly - 20 days expired should still be within grace period', async () => {
-			const expiredLicenseInfo = JSON.parse(STANDARD_LICENSE_INFO)
-			const expiredDate = new Date(now.getFullYear(), now.getMonth(), now.getDate() - 20) // 20 days ago
-			expiredLicenseInfo[PROPERTIES.EXPIRY_DATE] = expiredDate.toISOString()
-
-			const expiredLicenseKey = await generateLicenseKey(
-				JSON.stringify(expiredLicenseInfo),
-				keyPair
-			)
-
-			// Test the getLicenseFromKey method to verify grace period calculation
-			const result = (await licenseManager.getLicenseFromKey(
-				expiredLicenseKey
-			)) as ValidLicenseKeyResult
-			expect(result.isAnnualLicense).toBe(true)
-			expect(result.isAnnualLicenseExpired).toBe(false) // Within 30-day grace period
-			expect(result.daysSinceExpiry).toBe(20)
+			// Pin the clock and use a date-only UTC expiry so the calculation is timezone
+			// independent. The named day is fully usable, so an expiry 20 calendar days before
+			// "now" has been past its usable window for 19 full days.
+			vi.useFakeTimers()
+			vi.setSystemTime(new Date('2026-06-26T12:00:00.000Z'))
+			try {
+				const expiredLicenseInfo = JSON.parse(STANDARD_LICENSE_INFO)
+				expiredLicenseInfo[PROPERTIES.EXPIRY_DATE] = '2026-06-06' // 20 days before now
+
+				const expiredLicenseKey = await generateLicenseKey(
+					JSON.stringify(expiredLicenseInfo),
+					keyPair
+				)
+
+				// Test the getLicenseFromKey method to verify grace period calculation
+				const result = (await licenseManager.getLicenseFromKey(
+					expiredLicenseKey
+				)) as ValidLicenseKeyResult
+				expect(result.isAnnualLicense).toBe(true)
+				expect(result.isAnnualLicenseExpired).toBe(false) // Within 30-day grace period
+				expect(result.daysSinceExpiry).toBe(19)
+			} finally {
+				vi.useRealTimers()
+			}
 		})
 
 		it('Calculates days since expiry correctly', async () => {
-			const expiredLicenseInfo = JSON.parse(STANDARD_LICENSE_INFO)
-			const expiredDate = new Date(now.getFullYear(), now.getMonth(), now.getDate() - 15) // 15 days ago
-			expiredLicenseInfo[PROPERTIES.EXPIRY_DATE] = expiredDate.toISOString()
-
-			const expiredLicenseKey = await generateLicenseKey(
-				JSON.stringify(expiredLicenseInfo),
-				keyPair
-			)
-
-			const result = (await licenseManager.getLicenseFromKey(
-				expiredLicenseKey
-			)) as ValidLicenseKeyResult
-			expect(result.daysSinceExpiry).toBe(15)
+			// Pin the clock and use a date-only UTC expiry so the calculation is timezone
+			// independent. The named day is fully usable, so an expiry 15 calendar days before
+			// "now" has been past its usable window for 14 full days.
+			vi.useFakeTimers()
+			vi.setSystemTime(new Date('2026-06-26T12:00:00.000Z'))
+			try {
+				const expiredLicenseInfo = JSON.parse(STANDARD_LICENSE_INFO)
+				expiredLicenseInfo[PROPERTIES.EXPIRY_DATE] = '2026-06-11' // 15 days before now
+
+				const expiredLicenseKey = await generateLicenseKey(
+					JSON.stringify(expiredLicenseInfo),
+					keyPair
+				)
+
+				const result = (await licenseManager.getLicenseFromKey(
+					expiredLicenseKey
+				)) as ValidLicenseKeyResult
+				expect(result.daysSinceExpiry).toBe(14)
+			} finally {
+				vi.useRealTimers()
+			}
 		})
 	})
 

package/src/lib/license/LicenseManager.ts

@@ -372,14 +372,26 @@ export class LicenseManager {
 	}
 
 	private getExpirationDateWithoutGracePeriod(expiryDate: Date) {
-		return new Date(expiryDate.getFullYear(), expiryDate.getMonth(), expiryDate.getDate())
+		// The named expiry date is the last day the license is fully usable, so the license
+		// expires at the end of that day, i.e. the start of the following day. We work in UTC
+		// (the expiry date is minted and parsed as a UTC date-only string) so the cutoff is a
+		// single predictable instant for every user regardless of their local timezone.
+		return new Date(
+			Date.UTC(
+				expiryDate.getUTCFullYear(),
+				expiryDate.getUTCMonth(),
+				expiryDate.getUTCDate() + 1 // Add 1 day so the named date is fully usable
+			)
+		)
 	}
 
 	private getExpirationDateWithGracePeriod(expiryDate: Date) {
 		return new Date(
-			expiryDate.getFullYear(),
-			expiryDate.getMonth(),
-			expiryDate.getDate() + GRACE_PERIOD_DAYS + 1 // Add 1 day to include the expiration day
+			Date.UTC(
+				expiryDate.getUTCFullYear(),
+				expiryDate.getUTCMonth(),
+				expiryDate.getUTCDate() + GRACE_PERIOD_DAYS + 1 // Add 1 day to include the expiration day
+			)
 		)
 	}
 

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 = '5.3.0-next.299378752aaf'
+export const version = '5.3.0-next.75e2874c4b3f'
 export const publishDates = {
 	major: '2026-05-06T16:28:18.473Z',
-	minor: '2026-07-13T13:51:04.172Z',
-	patch: '2026-07-13T13:51:04.172Z',
+	minor: '2026-07-24T17:23:32.181Z',
+	patch: '2026-07-24T17:23:32.181Z',
 }