@tldraw/editor 3.11.0 → 3.11.1

package/src/lib/editor/Editor.ts

@@ -9849,12 +9849,12 @@ export class Editor extends EventEmitter<TLEventMap> {
 
 						const { x: cx, y: cy, z: cz } = unsafe__withoutCapture(() => this.getCamera())
 
-						const { panSpeed, zoomSpeed } = cameraOptions
+						const { panSpeed } = cameraOptions
 						this._setCamera(
 							new Vec(
-								cx + (dx * panSpeed) / cz - x / cz + x / (z * zoomSpeed),
-								cy + (dy * panSpeed) / cz - y / cz + y / (z * zoomSpeed),
-								z * zoomSpeed
+								cx + (dx * panSpeed) / cz - x / cz + x / z,
+								cy + (dy * panSpeed) / cz - y / cz + y / z,
+								z
 							),
 							{ immediate: true }
 						)
@@ -9929,14 +9929,9 @@ export class Editor extends EventEmitter<TLEventMap> {
 							}
 
 							const zoom = cz + (delta ?? 0) * zoomSpeed * cz
-							this._setCamera(
-								new Vec(
-									cx + (x / zoom - x) - (x / cz - x),
-									cy + (y / zoom - y) - (y / cz - y),
-									zoom
-								),
-								{ immediate: true }
-							)
+							this._setCamera(new Vec(cx + x / zoom - x / cz, cy + y / zoom - y / cz, zoom), {
+								immediate: true,
+							})
 							this.maybeTrackPerformance('Zooming')
 							return
 						}

package/src/lib/exports/StyleEmbedder.ts

@@ -1,5 +1,6 @@
-import { assertExists, objectMapValues, uniqueId } from '@tldraw/utils'
+import { assertExists, getOwnProperty, objectMapValues, uniqueId } from '@tldraw/utils'
 import { FontEmbedder } from './FontEmbedder'
+import { ReadonlyStyles, Styles, cssRules } from './cssRules'
 import {
 	elementStyle,
 	getComputedStyle,
@@ -7,15 +8,8 @@ import {
 	getRenderedChildren,
 } from './domUtils'
 import { resourceToDataUrl } from './fetchCache'
-import {
-	isPropertyCoveredByCurrentColor,
-	isPropertyInherited,
-	parseCssValueUrls,
-	shouldIncludeCssProperty,
-} from './parseCss'
-
-type Styles = { [K in string]?: string }
-type ReadonlyStyles = { readonly [K in string]?: string }
+import { parseCssValueUrls, shouldIncludeCssProperty } from './parseCss'
+
 const NO_STYLES = {} as const
 
 interface ElementStyleInfo {
@@ -239,15 +233,22 @@ function styleFromComputedStyleMap(
 	{ defaultStyles, parentStyles }: ReadStyleOpts
 ) {
 	const styles: Record<string, string> = {}
+	const currentColor = style.get('color')?.toString() || ''
+	const ruleOptions = {
+		currentColor,
+		parentStyles,
+		defaultStyles,
+		getStyle: (property: string) => style.get(property)?.toString() ?? '',
+	}
 	for (const property of style.keys()) {
 		if (!shouldIncludeCssProperty(property)) continue
 
 		const value = style.get(property)!.toString()
 
 		if (defaultStyles[property] === value) continue
-		if (parentStyles[property] === value && isPropertyInherited(property)) continue
-		if (isPropertyCoveredByCurrentColor(style.get('color')?.toString() || '', property, value))
-			continue
+
+		const rule = getOwnProperty(cssRules, property)
+		if (rule && rule(value, property, ruleOptions)) continue
 
 		styles[property] = value
 	}
@@ -260,14 +261,23 @@ function styleFromComputedStyle(
 	{ defaultStyles, parentStyles }: ReadStyleOpts
 ) {
 	const styles: Record<string, string> = {}
+	const currentColor = style.color
+	const ruleOptions = {
+		currentColor,
+		parentStyles,
+		defaultStyles,
+		getStyle: (property: string) => style.getPropertyValue(property),
+	}
+
 	for (const property in style) {
 		if (!shouldIncludeCssProperty(property)) continue
 
 		const value = style.getPropertyValue(property)
 
 		if (defaultStyles[property] === value) continue
-		if (parentStyles[property] === value && isPropertyInherited(property)) continue
-		if (isPropertyCoveredByCurrentColor(style.color, property, value)) continue
+
+		const rule = getOwnProperty(cssRules, property)
+		if (rule && rule(value, property, ruleOptions)) continue
 
 		styles[property] = value
 	}

package/src/lib/exports/cssRules.ts

@@ -0,0 +1,126 @@
+export type Styles = { [K in string]?: string }
+export type ReadonlyStyles = { readonly [K in string]?: string }
+
+type CanSkipRule = (
+	value: string,
+	property: string,
+	options: {
+		getStyle(property: string): string
+		parentStyles: ReadonlyStyles
+		defaultStyles: ReadonlyStyles
+		currentColor: string
+	}
+) => boolean
+
+const isCoveredByCurrentColor: CanSkipRule = (value, property, { currentColor }) => {
+	return value === 'currentColor' || value === currentColor
+}
+
+const isInherited: CanSkipRule = (value, property, { parentStyles }) => {
+	return parentStyles[property] === value
+}
+
+// see comment below about why we exclude border styles
+const isExcludedBorder =
+	(borderDirection: string): CanSkipRule =>
+	(value, property, { getStyle }) => {
+		const borderWidth = getStyle(`border-${borderDirection}-width`)
+		const borderStyle = getStyle(`border-${borderDirection}-style`)
+
+		if (borderWidth === '0px') return true
+		if (borderStyle === 'none') return true
+		return false
+	}
+
+export const cssRules = {
+	// currentColor properties:
+	'border-block-end-color': isCoveredByCurrentColor,
+	'border-block-start-color': isCoveredByCurrentColor,
+	'border-bottom-color': isCoveredByCurrentColor,
+	'border-inline-end-color': isCoveredByCurrentColor,
+	'border-inline-start-color': isCoveredByCurrentColor,
+	'border-left-color': isCoveredByCurrentColor,
+	'border-right-color': isCoveredByCurrentColor,
+	'border-top-color': isCoveredByCurrentColor,
+	'caret-color': isCoveredByCurrentColor,
+	'column-rule-color': isCoveredByCurrentColor,
+	'outline-color': isCoveredByCurrentColor,
+	'text-decoration': (value, property, { currentColor }) => {
+		return value === 'none solid currentColor' || value === 'none solid ' + currentColor
+	},
+	'text-decoration-color': isCoveredByCurrentColor,
+	'text-emphasis-color': isCoveredByCurrentColor,
+
+	// inherited properties:
+	'border-collapse': isInherited,
+	'border-spacing': isInherited,
+	'caption-side': isInherited,
+	// N.B. We shouldn't inherit 'color' because there's some UA styling, e.g. `mark` elements
+	// 'color': isInherited,
+	cursor: isInherited,
+	direction: isInherited,
+	'empty-cells': isInherited,
+	'font-family': isInherited,
+	'font-size': isInherited,
+	'font-style': isInherited,
+	'font-variant': isInherited,
+	'font-weight': isInherited,
+	'font-size-adjust': isInherited,
+	'font-stretch': isInherited,
+	font: isInherited,
+	'letter-spacing': isInherited,
+	'line-height': isInherited,
+	'list-style-image': isInherited,
+	'list-style-position': isInherited,
+	'list-style-type': isInherited,
+	'list-style': isInherited,
+	orphans: isInherited,
+	'overflow-wrap': isInherited,
+	quotes: isInherited,
+	'stroke-linecap': isInherited,
+	'stroke-linejoin': isInherited,
+	'tab-size': isInherited,
+	'text-align': isInherited,
+	'text-align-last': isInherited,
+	'text-indent': isInherited,
+	'text-justify': isInherited,
+	'text-shadow': isInherited,
+	'text-transform': isInherited,
+	visibility: isInherited,
+	'white-space': isInherited,
+	'white-space-collapse': isInherited,
+	widows: isInherited,
+	'word-break': isInherited,
+	'word-spacing': isInherited,
+	'word-wrap': isInherited,
+
+	// special border cases - we have a weird case (tailwind seems to trigger this) where all
+	// border-styles sometimes get set to 'solid', but the border-width is 0 so they don't render.
+	// but in SVGs, **sometimes**, the border-width defaults (i think from a UA style-sheet? but
+	// honestly can't tell) to 1.5px so the border displays. we work around this by only including
+	// border styles at all if both the border-width and border-style are set to something that
+	// would show a border.
+	'border-top': isExcludedBorder('top'),
+	'border-right': isExcludedBorder('right'),
+	'border-bottom': isExcludedBorder('bottom'),
+	'border-left': isExcludedBorder('left'),
+	'border-block-end': isExcludedBorder('block-end'),
+	'border-block-start': isExcludedBorder('block-start'),
+	'border-inline-end': isExcludedBorder('inline-end'),
+	'border-inline-start': isExcludedBorder('inline-start'),
+	'border-top-style': isExcludedBorder('top'),
+	'border-right-style': isExcludedBorder('right'),
+	'border-bottom-style': isExcludedBorder('bottom'),
+	'border-left-style': isExcludedBorder('left'),
+	'border-block-end-style': isExcludedBorder('block-end'),
+	'border-block-start-style': isExcludedBorder('block-start'),
+	'border-inline-end-style': isExcludedBorder('inline-end'),
+	'border-inline-start-style': isExcludedBorder('inline-start'),
+	'border-top-width': isExcludedBorder('top'),
+	'border-right-width': isExcludedBorder('right'),
+	'border-bottom-width': isExcludedBorder('bottom'),
+	'border-left-width': isExcludedBorder('left'),
+	'border-block-end-width': isExcludedBorder('block-end'),
+	'border-block-start-width': isExcludedBorder('block-start'),
+	'border-inline-end-width': isExcludedBorder('inline-end'),
+} satisfies Record<string, CanSkipRule>

package/src/lib/exports/parseCss.ts

@@ -110,82 +110,3 @@ export function parseCssValueUrls(value: string) {
 		url: m[1] || m[2] || m[3],
 	}))
 }
-
-const currentColorProperties = new Set([
-	'border-block-end-color',
-	'border-block-start-color',
-	'border-bottom-color',
-	'border-inline-end-color',
-	'border-inline-start-color',
-	'border-left-color',
-	'border-right-color',
-	'border-top-color',
-	'caret-color',
-	'column-rule-color',
-	'outline-color',
-	'text-decoration',
-	'text-decoration-color',
-	'text-emphasis-color',
-])
-
-export function isPropertyCoveredByCurrentColor(
-	currentColor: string,
-	property: string,
-	value: string
-) {
-	if (currentColorProperties.has(property)) {
-		return (
-			value === 'currentColor' ||
-			value === currentColor ||
-			(property === 'text-decoration' && value === `none solid ${currentColor}`)
-		)
-	}
-}
-
-const inheritedProperties = new Set([
-	'border-collapse',
-	'border-spacing',
-	'caption-side',
-	// N.B. We shouldn't inherit 'color' because there's some UA styling, e.g. `mark` elements
-	// 'color',
-	'cursor',
-	'direction',
-	'empty-cells',
-	'font-family',
-	'font-size',
-	'font-style',
-	'font-variant',
-	'font-weight',
-	'font-size-adjust',
-	'font-stretch',
-	'font',
-	'letter-spacing',
-	'line-height',
-	'list-style-image',
-	'list-style-position',
-	'list-style-type',
-	'list-style',
-	'orphans',
-	'overflow-wrap',
-	'quotes',
-	'stroke-linecap',
-	'stroke-linejoin',
-	'tab-size',
-	'text-align',
-	'text-align-last',
-	'text-indent',
-	'text-justify',
-	'text-shadow',
-	'text-transform',
-	'visibility',
-	'white-space',
-	'white-space-collapse',
-	'widows',
-	'word-break',
-	'word-spacing',
-	'word-wrap',
-])
-
-export function isPropertyInherited(property: string) {
-	return inheritedProperties.has(property)
-}

package/src/lib/hooks/useGestureEvents.ts

@@ -135,7 +135,6 @@ export function useGestureEvents(ref: React.RefObject<HTMLDivElement>) {
 
 		let initDistanceBetweenFingers = 1 // the distance between the two fingers when the pinch starts
 		let initZoom = 1 // the browser's zoom level when the pinch starts
-		let currZoom = 1 // the current zoom level according to the pinch gesture recognizer
 		let currDistanceBetweenFingers = 0
 		const initPointBetweenFingers = new Vec()
 		const prevPointBetweenFingers = new Vec()
@@ -239,7 +238,7 @@ export function useGestureEvents(ref: React.RefObject<HTMLDivElement>) {
 
 			switch (pinchState) {
 				case 'zooming': {
-					currZoom = offset[0]
+					const currZoom = offset[0] ** editor.getCameraOptions().zoomSpeed
 
 					editor.dispatch({
 						type: 'pinch',
@@ -278,7 +277,7 @@ export function useGestureEvents(ref: React.RefObject<HTMLDivElement>) {
 			if (event instanceof WheelEvent) return
 			if (!(event.target === elm || elm?.contains(event.target as Node))) return
 
-			const scale = offset[0]
+			const scale = offset[0] ** editor.getCameraOptions().zoomSpeed
 
 			pinchState = 'not sure'
 
@@ -309,14 +308,21 @@ export function useGestureEvents(ref: React.RefObject<HTMLDivElement>) {
 		target: ref,
 		eventOptions: { passive: false },
 		pinch: {
-			from: () => [editor.getZoomLevel(), 0], // Return the camera z to use when pinch starts
+			from: () => {
+				const { zoomSpeed } = editor.getCameraOptions()
+				const level = editor.getZoomLevel() ** (1 / zoomSpeed)
+				return [level, 0]
+			}, // Return the camera z to use when pinch starts
 			scaleBounds: () => {
 				const baseZoom = editor.getBaseZoom()
-				const zoomSteps = editor.getCameraOptions().zoomSteps
+				const { zoomSteps, zoomSpeed } = editor.getCameraOptions()
 				const zoomMin = zoomSteps[0] * baseZoom
 				const zoomMax = zoomSteps[zoomSteps.length - 1] * baseZoom
 
-				return { from: editor.getZoomLevel(), max: zoomMax, min: zoomMin }
+				return {
+					max: zoomMax ** (1 / zoomSpeed),
+					min: zoomMin ** (1 / zoomSpeed),
+				}
 			},
 		},
 	})

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.11.0'
+export const version = '3.11.1'
 export const publishDates = {
 	major: '2024-09-13T14:36:29.063Z',
 	minor: '2025-03-20T14:45:59.625Z',
-	patch: '2025-03-20T14:45:59.625Z',
+	patch: '2025-04-03T10:34:39.217Z',
 }