@tldraw/editor 3.15.0-canary.2fa0050cd4a6 → 3.15.0-canary.30a6212789b4

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

@@ -1,5 +1,4 @@
 import { BoxModel, TLDefaultHorizontalAlignStyle } from '@tldraw/tlschema'
-import { objectMapKeys } from '@tldraw/utils'
 import { Editor } from '../../Editor'
 
 const fixNewLines = /\r?\n|\r/g
@@ -61,18 +60,10 @@ export interface TLMeasureTextSpanOpts {
 
 const spaceCharacterRegex = /\s/
 
-const initialDefaultStyles = Object.freeze({
-	'overflow-wrap': 'break-word',
-	'word-break': 'auto',
-	width: null,
-	height: null,
-	'max-width': null,
-	'min-width': null,
-})
-
 /** @public */
 export class TextManager {
 	private elm: HTMLDivElement
+	private defaultStyles: Record<string, string | null>
 
 	constructor(public editor: Editor) {
 		const elm = document.createElement('div')
@@ -82,34 +73,31 @@ export class TextManager {
 		elm.tabIndex = -1
 		this.editor.getContainer().appendChild(elm)
 
-		this.elm = elm
-
-		for (const key of objectMapKeys(initialDefaultStyles)) {
-			elm.style.setProperty(key, initialDefaultStyles[key])
+		// we need to save the default styles so that we can restore them when we're done
+		// these must be the css names, not the js names for the styles
+		this.defaultStyles = {
+			'overflow-wrap': 'break-word',
+			'word-break': 'auto',
+			width: null,
+			height: null,
+			'max-width': null,
+			'min-width': null,
 		}
-	}
 
-	private setElementStyles(styles: Record<string, string | undefined>) {
-		const stylesToReinstate = {} as any
-		for (const key of objectMapKeys(styles)) {
-			if (typeof styles[key] === 'string') {
-				const oldValue = this.elm.style.getPropertyValue(key)
-				if (oldValue === styles[key]) continue
-				stylesToReinstate[key] = oldValue
-				this.elm.style.setProperty(key, styles[key])
-			}
-		}
-		return () => {
-			for (const key of objectMapKeys(stylesToReinstate)) {
-				this.elm.style.setProperty(key, stylesToReinstate[key])
-			}
-		}
+		this.elm = elm
 	}
 
 	dispose() {
 		return this.elm.remove()
 	}
 
+	private resetElmStyles() {
+		const { elm, defaultStyles } = this
+		for (const key in defaultStyles) {
+			elm.style.setProperty(key, defaultStyles[key])
+		}
+	}
+
 	measureText(textToMeasure: string, opts: TLMeasureTextOpts): BoxModel & { scrollWidth: number } {
 		const div = document.createElement('div')
 		div.textContent = normalizeTextForDom(textToMeasure)
@@ -119,36 +107,54 @@ export class TextManager {
 	measureHtml(html: string, opts: TLMeasureTextOpts): BoxModel & { scrollWidth: number } {
 		const { elm } = this
 
-		const newStyles = {
-			'font-family': opts.fontFamily,
-			'font-style': opts.fontStyle,
-			'font-weight': opts.fontWeight,
-			'font-size': opts.fontSize + 'px',
-			'line-height': opts.lineHeight.toString(),
-			padding: opts.padding,
-			'max-width': opts.maxWidth ? opts.maxWidth + 'px' : undefined,
-			'min-width': opts.minWidth ? opts.minWidth + 'px' : undefined,
-			'overflow-wrap': opts.disableOverflowWrapBreaking ? 'normal' : undefined,
-			...opts.otherStyles,
+		if (opts.otherStyles) {
+			for (const key in opts.otherStyles) {
+				if (!this.defaultStyles[key]) {
+					// we need to save the original style so that we can restore it when we're done
+					this.defaultStyles[key] = elm.style.getPropertyValue(key)
+				}
+			}
 		}
 
-		const restoreStyles = this.setElementStyles(newStyles)
+		elm.innerHTML = html
 
-		try {
-			elm.innerHTML = html
+		// Apply the default styles to the element (for all styles here or that were ever seen in opts.otherStyles)
+		this.resetElmStyles()
 
-			const scrollWidth = opts.measureScrollWidth ? elm.scrollWidth : 0
-			const rect = elm.getBoundingClientRect()
+		elm.style.setProperty('font-family', opts.fontFamily)
+		elm.style.setProperty('font-style', opts.fontStyle)
+		elm.style.setProperty('font-weight', opts.fontWeight)
+		elm.style.setProperty('font-size', opts.fontSize + 'px')
+		elm.style.setProperty('line-height', opts.lineHeight.toString())
+		elm.style.setProperty('padding', opts.padding)
 
-			return {
-				x: 0,
-				y: 0,
-				w: rect.width,
-				h: rect.height,
-				scrollWidth,
+		if (opts.maxWidth) {
+			elm.style.setProperty('max-width', opts.maxWidth + 'px')
+		}
+
+		if (opts.minWidth) {
+			elm.style.setProperty('min-width', opts.minWidth + 'px')
+		}
+
+		if (opts.disableOverflowWrapBreaking) {
+			elm.style.setProperty('overflow-wrap', 'normal')
+		}
+
+		if (opts.otherStyles) {
+			for (const [key, value] of Object.entries(opts.otherStyles)) {
+				elm.style.setProperty(key, value)
 			}
-		} finally {
-			restoreStyles()
+		}
+
+		const scrollWidth = opts.measureScrollWidth ? elm.scrollWidth : 0
+		const rect = elm.getBoundingClientRect()
+
+		return {
+			x: 0,
+			y: 0,
+			w: rect.width,
+			h: rect.height,
+			scrollWidth,
 		}
 	}
 
@@ -268,68 +274,82 @@ export class TextManager {
 
 		const { elm } = this
 
+		if (opts.otherStyles) {
+			for (const key in opts.otherStyles) {
+				if (!this.defaultStyles[key]) {
+					// we need to save the original style so that we can restore it when we're done
+					this.defaultStyles[key] = elm.style.getPropertyValue(key)
+				}
+			}
+		}
+
+		this.resetElmStyles()
+
+		elm.style.setProperty('font-family', opts.fontFamily)
+		elm.style.setProperty('font-style', opts.fontStyle)
+		elm.style.setProperty('font-weight', opts.fontWeight)
+		elm.style.setProperty('font-size', opts.fontSize + 'px')
+		elm.style.setProperty('line-height', opts.lineHeight.toString())
+
+		const elementWidth = Math.ceil(opts.width - opts.padding * 2)
+		elm.style.setProperty('width', `${elementWidth}px`)
+		elm.style.setProperty('height', 'min-content')
+		elm.style.setProperty('text-align', textAlignmentsForLtr[opts.textAlign])
+
 		const shouldTruncateToFirstLine =
 			opts.overflow === 'truncate-ellipsis' || opts.overflow === 'truncate-clip'
-		const elementWidth = Math.ceil(opts.width - opts.padding * 2)
-		const newStyles = {
-			'font-family': opts.fontFamily,
-			'font-style': opts.fontStyle,
-			'font-weight': opts.fontWeight,
-			'font-size': opts.fontSize + 'px',
-			'line-height': opts.lineHeight.toString(),
-			width: `${elementWidth}px`,
-			height: 'min-content',
-			'text-align': textAlignmentsForLtr[opts.textAlign],
-			'overflow-wrap': shouldTruncateToFirstLine ? 'anywhere' : undefined,
-			'word-break': shouldTruncateToFirstLine ? 'break-all' : undefined,
-			...opts.otherStyles,
+
+		if (shouldTruncateToFirstLine) {
+			elm.style.setProperty('overflow-wrap', 'anywhere')
+			elm.style.setProperty('word-break', 'break-all')
 		}
-		const restoreStyles = this.setElementStyles(newStyles)
 
-		try {
-			const normalizedText = normalizeTextForDom(textToMeasure)
+		if (opts.otherStyles) {
+			for (const [key, value] of Object.entries(opts.otherStyles)) {
+				elm.style.setProperty(key, value)
+			}
+		}
 
-			// Render the text into the measurement element:
-			elm.textContent = normalizedText
+		const normalizedText = normalizeTextForDom(textToMeasure)
 
-			// actually measure the text:
-			const { spans, didTruncate } = this.measureElementTextNodeSpans(elm, {
-				shouldTruncateToFirstLine,
-			})
+		// Render the text into the measurement element:
+		elm.textContent = normalizedText
 
-			if (opts.overflow === 'truncate-ellipsis' && didTruncate) {
-				// we need to measure the ellipsis to know how much space it takes up
-				elm.textContent = '…'
-				const ellipsisWidth = Math.ceil(this.measureElementTextNodeSpans(elm).spans[0].box.w)
-
-				// then, we need to subtract that space from the width we have and measure again:
-				elm.style.setProperty('width', `${elementWidth - ellipsisWidth}px`)
-				elm.textContent = normalizedText
-				const truncatedSpans = this.measureElementTextNodeSpans(elm, {
-					shouldTruncateToFirstLine: true,
-				}).spans
-
-				// Finally, we add in our ellipsis at the end of the last span. We
-				// have to do this after measuring, not before, because adding the
-				// ellipsis changes how whitespace might be getting collapsed by the
-				// browser.
-				const lastSpan = truncatedSpans[truncatedSpans.length - 1]!
-				truncatedSpans.push({
-					text: '…',
-					box: {
-						x: Math.min(lastSpan.box.x + lastSpan.box.w, opts.width - opts.padding - ellipsisWidth),
-						y: lastSpan.box.y,
-						w: ellipsisWidth,
-						h: lastSpan.box.h,
-					},
-				})
-
-				return truncatedSpans
-			}
+		// actually measure the text:
+		const { spans, didTruncate } = this.measureElementTextNodeSpans(elm, {
+			shouldTruncateToFirstLine,
+		})
 
-			return spans
-		} finally {
-			restoreStyles()
+		if (opts.overflow === 'truncate-ellipsis' && didTruncate) {
+			// we need to measure the ellipsis to know how much space it takes up
+			elm.textContent = '…'
+			const ellipsisWidth = Math.ceil(this.measureElementTextNodeSpans(elm).spans[0].box.w)
+
+			// then, we need to subtract that space from the width we have and measure again:
+			elm.style.setProperty('width', `${elementWidth - ellipsisWidth}px`)
+			elm.textContent = normalizedText
+			const truncatedSpans = this.measureElementTextNodeSpans(elm, {
+				shouldTruncateToFirstLine: true,
+			}).spans
+
+			// Finally, we add in our ellipsis at the end of the last span. We
+			// have to do this after measuring, not before, because adding the
+			// ellipsis changes how whitespace might be getting collapsed by the
+			// browser.
+			const lastSpan = truncatedSpans[truncatedSpans.length - 1]!
+			truncatedSpans.push({
+				text: '…',
+				box: {
+					x: Math.min(lastSpan.box.x + lastSpan.box.w, opts.width - opts.padding - ellipsisWidth),
+					y: lastSpan.box.y,
+					w: ellipsisWidth,
+					h: lastSpan.box.h,
+				},
+			})
+
+			return truncatedSpans
 		}
+
+		return spans
 	}
 }

package/src/lib/editor/managers/UserPreferencesManager/UserPreferencesManager.test.ts

@@ -24,7 +24,6 @@ describe('UserPreferencesManager', () => {
 		color: '#FF802B',
 		locale: 'en',
 		animationSpeed: 1,
-		areKeyboardShortcutsEnabled: true,
 		edgeScrollSpeed: 1,
 		colorScheme: 'light',
 		isSnapMode: false,
@@ -230,7 +229,6 @@ describe('UserPreferencesManager', () => {
 				locale: mockUserPreferences.locale,
 				color: mockUserPreferences.color,
 				animationSpeed: mockUserPreferences.animationSpeed,
-				areKeyboardShortcutsEnabled: mockUserPreferences.areKeyboardShortcutsEnabled,
 				isSnapMode: mockUserPreferences.isSnapMode,
 				colorScheme: mockUserPreferences.colorScheme,
 				isDarkMode: false, // light mode
@@ -364,21 +362,6 @@ describe('UserPreferencesManager', () => {
 			})
 		})
 
-		describe('getAreKeyboardShortcutsEnabled', () => {
-			it('should return user keyboard shortcuts', () => {
-				expect(userPreferencesManager.getAreKeyboardShortcutsEnabled()).toBe(
-					mockUserPreferences.areKeyboardShortcutsEnabled
-				)
-			})
-
-			it('should return default keyboard shortcuts when null', () => {
-				userPreferencesAtom.set({ ...mockUserPreferences, areKeyboardShortcutsEnabled: null })
-				expect(userPreferencesManager.getAreKeyboardShortcutsEnabled()).toBe(
-					defaultUserPreferences.areKeyboardShortcutsEnabled
-				)
-			})
-		})
-
 		describe('getEdgeScrollSpeed', () => {
 			it('should return user edge scroll speed', () => {
 				expect(userPreferencesManager.getEdgeScrollSpeed()).toBe(
@@ -500,7 +483,6 @@ describe('UserPreferencesManager', () => {
 				color: null,
 				locale: null,
 				animationSpeed: null,
-				areKeyboardShortcutsEnabled: null,
 				edgeScrollSpeed: null,
 				isSnapMode: null,
 				isWrapMode: null,
@@ -514,9 +496,6 @@ describe('UserPreferencesManager', () => {
 			expect(userPreferencesManager.getColor()).toBe(defaultUserPreferences.color)
 			expect(userPreferencesManager.getLocale()).toBe(defaultUserPreferences.locale)
 			expect(userPreferencesManager.getAnimationSpeed()).toBe(defaultUserPreferences.animationSpeed)
-			expect(userPreferencesManager.getAreKeyboardShortcutsEnabled()).toBe(
-				defaultUserPreferences.areKeyboardShortcutsEnabled
-			)
 			expect(userPreferencesManager.getEdgeScrollSpeed()).toBe(
 				defaultUserPreferences.edgeScrollSpeed
 			)

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

@@ -43,7 +43,6 @@ export class UserPreferencesManager {
 			locale: this.getLocale(),
 			color: this.getColor(),
 			animationSpeed: this.getAnimationSpeed(),
-			areKeyboardShortcutsEnabled: this.getAreKeyboardShortcutsEnabled(),
 			isSnapMode: this.getIsSnapMode(),
 			colorScheme: this.user.userPreferences.get().colorScheme,
 			isDarkMode: this.getIsDarkMode(),
@@ -76,13 +75,6 @@ export class UserPreferencesManager {
 		return this.user.userPreferences.get().animationSpeed ?? defaultUserPreferences.animationSpeed
 	}
 
-	@computed getAreKeyboardShortcutsEnabled() {
-		return (
-			this.user.userPreferences.get().areKeyboardShortcutsEnabled ??
-			defaultUserPreferences.areKeyboardShortcutsEnabled
-		)
-	}
-
 	@computed getId() {
 		return this.user.userPreferences.get().id
 	}

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

@@ -417,7 +417,7 @@ function importPrivateKey(pemContents: string) {
 	// base64 decode the string to get the binary data
 	const binaryDerString = atob(pemContents)
 	// convert from a binary string to an ArrayBuffer
-	const binaryDer = str2ab(binaryDerString)
+	const binaryDer = str2ab(binaryDerString) as Uint8Array
 
 	return crypto.subtle.importKey(
 		'pkcs8',

package/src/lib/primitives/intersect.ts

@@ -1,5 +1,5 @@
 import { Box } from './Box'
-import { approximately, approximatelyLte, pointInPolygon } from './utils'
+import { pointInPolygon } from './utils'
 import { Vec, VecLike } from './Vec'
 
 // need even more intersections? See https://gist.github.com/steveruizok/35c02d526c707003a5c79761bfb89a52
@@ -17,8 +17,7 @@ export function intersectLineSegmentLineSegment(
 	a1: VecLike,
 	a2: VecLike,
 	b1: VecLike,
-	b2: VecLike,
-	precision = 1e-10
+	b2: VecLike
 ) {
 	const ABx = a1.x - b1.x
 	const ABy = a1.y - b1.y
@@ -30,19 +29,14 @@ export function intersectLineSegmentLineSegment(
 	const ub_t = AVx * ABy - AVy * ABx
 	const u_b = BVy * AVx - BVx * AVy
 
-	if (approximately(ua_t, 0, precision) || approximately(ub_t, 0, precision)) return null // coincident
+	if (ua_t === 0 || ub_t === 0) return null // coincident
 
-	if (approximately(u_b, 0, precision)) return null // parallel
+	if (u_b === 0) return null // parallel
 
 	if (u_b !== 0) {
 		const ua = ua_t / u_b
 		const ub = ub_t / u_b
-		if (
-			approximatelyLte(0, ua, precision) &&
-			approximatelyLte(ua, 1, precision) &&
-			approximatelyLte(0, ub, precision) &&
-			approximatelyLte(ub, 1, precision)
-		) {
+		if (0 <= ua && ua <= 1 && 0 <= ub && ub <= 1) {
 			return Vec.AddXY(a1, ua * AVx, ua * AVy)
 		}
 	}
@@ -131,7 +125,6 @@ export function intersectLineSegmentPolygon(a1: VecLike, a2: VecLike, points: Ve
 			points[i - 1],
 			points[i % points.length]
 		)
-
 		if (segmentIntersection) result.push(segmentIntersection)
 	}
 

package/src/lib/primitives/utils.ts

@@ -77,17 +77,6 @@ export function approximately(a: number, b: number, precision = 0.000001) {
 	return Math.abs(a - b) <= precision
 }
 
-/**
- * Whether a number is approximately less than or equal to another number.
- *
- * @param a - The first number.
- * @param b - The second number.
- * @public
- */
-export function approximatelyLte(a: number, b: number, precision = 0.000001) {
-	return a < b || approximately(a, b, precision)
-}
-
 /**
  * Find the approximate perimeter of an ellipse.
  *

package/src/lib/utils/sync/TLLocalSyncClient.ts

@@ -266,6 +266,7 @@ export class TLLocalSyncClient {
 
 	private isPersisting = false
 	private didLastWriteError = false
+	// eslint-disable-next-line no-restricted-globals
 	private scheduledPersistTimeout: ReturnType<typeof setTimeout> | null = null
 
 	/**

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.15.0-canary.2fa0050cd4a6'
+export const version = '3.15.0-canary.30a6212789b4'
 export const publishDates = {
 	major: '2024-09-13T14:36:29.063Z',
-	minor: '2025-07-10T08:17:03.263Z',
-	patch: '2025-07-10T08:17:03.263Z',
+	minor: '2025-07-03T09:11:17.820Z',
+	patch: '2025-07-03T09:11:17.820Z',
 }