tldraw 3.16.0-canary.7f4043b128a3 → 3.16.0-canary.887377ec7acc

package/src/lib/ui/components/primitives/TldrawUiSlider.tsx

@@ -1,7 +1,9 @@
+import { tltime } from '@tldraw/editor'
 import { Slider as _Slider } from 'radix-ui'
 import React, { useCallback, useEffect, useState } from 'react'
 import { TLUiTranslationKey } from '../../hooks/useTranslation/TLUiTranslationKey'
 import { useTranslation } from '../../hooks/useTranslation/useTranslation'
+import { TldrawUiTooltip, tooltipManager } from './TldrawUiTooltip'
 
 /** @public */
 export interface TLUiSliderProps {
@@ -11,7 +13,7 @@ export interface TLUiSliderProps {
 	label: string
 	title: string
 	onValueChange(value: number): void
-	onHistoryMark(id: string): void
+	onHistoryMark?(id: string): void
 	'data-testid'?: string
 	ariaValueModifier?: number
 }
@@ -32,6 +34,7 @@ export const TldrawUiSlider = React.forwardRef<HTMLDivElement, TLUiSliderProps>(
 	ref
 ) {
 	const msg = useTranslation()
+	const [titleAndLabel, setTitleAndLabel] = useState('')
 
 	// XXX: Radix starts out our slider with a tabIndex of 0
 	// This causes some tab focusing issues, most prevelant in MobileStylePanel,
@@ -49,9 +52,25 @@ export const TldrawUiSlider = React.forwardRef<HTMLDivElement, TLUiSliderProps>(
 	)
 
 	const handlePointerDown = useCallback(() => {
-		onHistoryMark('click slider')
+		tooltipManager.hideAllTooltips()
+		onHistoryMark?.('click slider')
 	}, [onHistoryMark])
 
+	// N.B. This is a bit silly. The Radix slider auto-focuses which
+	// triggers TldrawUiTooltip handleFocus when we dbl-click to edit an image,
+	// which in turn makes the tooltip display prematurely.
+	// This makes it wait until we've focused to show the tooltip.
+	useEffect(() => {
+		const timeout = tltime.setTimeout(
+			'set title and label',
+			() => {
+				setTitleAndLabel(title + ' — ' + msg(label as TLUiTranslationKey))
+			},
+			0
+		)
+		return () => clearTimeout(timeout)
+	}, [label, msg, title])
+
 	// N.B. Annoying. For a11y purposes, we need Tab to work.
 	// For some reason, Radix has some custom behavior here
 	// that interferes with tabbing past the slider and then
@@ -64,36 +83,37 @@ export const TldrawUiSlider = React.forwardRef<HTMLDivElement, TLUiSliderProps>(
 
 	return (
 		<div className="tlui-slider__container">
-			<_Slider.Root
-				data-testid={testId}
-				className="tlui-slider"
-				dir="ltr"
-				min={min ?? 0}
-				max={steps}
-				step={1}
-				value={value !== null ? [value] : undefined}
-				onPointerDown={handlePointerDown}
-				onValueChange={handleValueChange}
-				onKeyDownCapture={handleKeyEvent}
-				onKeyUpCapture={handleKeyEvent}
-				title={title + ' — ' + msg(label as TLUiTranslationKey)}
-			>
-				<_Slider.Track className="tlui-slider__track" dir="ltr">
-					{value !== null && <_Slider.Range className="tlui-slider__range" dir="ltr" />}
-				</_Slider.Track>
-				{value !== null && (
-					<_Slider.Thumb
-						aria-valuemin={(min ?? 0) * ariaValueModifier}
-						aria-valuenow={value * ariaValueModifier}
-						aria-valuemax={steps * ariaValueModifier}
-						aria-label={title + ' — ' + msg(label as TLUiTranslationKey)}
-						className="tlui-slider__thumb"
-						dir="ltr"
-						ref={ref}
-						tabIndex={tabIndex}
-					/>
-				)}
-			</_Slider.Root>
+			<TldrawUiTooltip content={titleAndLabel}>
+				<_Slider.Root
+					data-testid={testId}
+					className="tlui-slider"
+					dir="ltr"
+					min={min ?? 0}
+					max={steps}
+					step={1}
+					value={value !== null ? [value] : undefined}
+					onPointerDown={handlePointerDown}
+					onValueChange={handleValueChange}
+					onKeyDownCapture={handleKeyEvent}
+					onKeyUpCapture={handleKeyEvent}
+				>
+					<_Slider.Track className="tlui-slider__track" dir="ltr">
+						{value !== null && <_Slider.Range className="tlui-slider__range" dir="ltr" />}
+					</_Slider.Track>
+					{value !== null && (
+						<_Slider.Thumb
+							aria-valuemin={(min ?? 0) * ariaValueModifier}
+							aria-valuenow={value * ariaValueModifier}
+							aria-valuemax={steps * ariaValueModifier}
+							aria-label={titleAndLabel}
+							className="tlui-slider__thumb"
+							dir="ltr"
+							ref={ref}
+							tabIndex={tabIndex}
+						/>
+					)}
+				</_Slider.Root>
+			</TldrawUiTooltip>
 		</div>
 	)
 })

package/src/lib/ui/components/primitives/TldrawUiToolbar.tsx

@@ -94,6 +94,7 @@ export interface TLUiToolbarToggleGroupProps extends React.HTMLAttributes<HTMLDi
 	// TODO: fix up this type later
 	defaultValue?: any
 	type: 'single' | 'multiple'
+	asChild?: boolean
 }
 
 /** @public @react */
@@ -101,10 +102,12 @@ export const TldrawUiToolbarToggleGroup = ({
 	children,
 	className,
 	type,
+	asChild,
 	...props
 }: TLUiToolbarToggleGroupProps) => {
 	return (
 		<_Toolbar.ToggleGroup
+			asChild={asChild}
 			type={type}
 			{...props}
 			// TODO: this fixes a bug in Radix until they fix it.

package/src/lib/ui/components/primitives/TldrawUiTooltip.tsx

@@ -1,7 +1,15 @@
-import { assert, Editor, uniqueId, useMaybeEditor, Vec } from '@tldraw/editor'
+import { assert, Atom, atom, Editor, uniqueId, useMaybeEditor, useValue } from '@tldraw/editor'
 import { Tooltip as _Tooltip } from 'radix-ui'
-import React, { createContext, forwardRef, useContext, useEffect, useRef, useState } from 'react'
-import { usePrefersReducedMotion } from '../../../shapes/shared/usePrefersReducedMotion'
+import React, {
+	createContext,
+	forwardRef,
+	ReactNode,
+	useContext,
+	useEffect,
+	useLayoutEffect,
+	useRef,
+	useState,
+} from 'react'
 import { useTldrawUiOrientation } from './layout'
 
 const DEFAULT_TOOLTIP_DELAY_MS = 700
@@ -13,19 +21,25 @@ export interface TldrawUiTooltipProps {
 	side?: 'top' | 'right' | 'bottom' | 'left'
 	sideOffset?: number
 	disabled?: boolean
+	showOnMobile?: boolean
+	delayDuration?: number
+}
+
+interface CurrentTooltip {
+	id: string
+	content: ReactNode
+	side: 'top' | 'right' | 'bottom' | 'left'
+	sideOffset: number
+	showOnMobile: boolean
+	targetElement: HTMLElement
+	delayDuration: number
 }
 
 // Singleton tooltip manager
 class TooltipManager {
 	private static instance: TooltipManager | null = null
-	private currentTooltipId: string | null = null
-	private currentContent: string | React.ReactNode = ''
-	private currentSide: 'top' | 'right' | 'bottom' | 'left' = 'bottom'
-	private currentSideOffset: number = 5
+	private currentTooltip = atom<CurrentTooltip | null>('current tooltip', null)
 	private destroyTimeoutId: number | null = null
-	private subscribers: Set<() => void> = new Set()
-	private activeElement: HTMLElement | null = null
-	private editor: Editor | null = null
 
 	static getInstance(): TooltipManager {
 		if (!TooltipManager.instance) {
@@ -34,25 +48,14 @@ class TooltipManager {
 		return TooltipManager.instance
 	}
 
-	setEditor(editor: Editor | null) {
-		this.editor = editor
-	}
-
-	subscribe(callback: () => void): () => void {
-		this.subscribers.add(callback)
-		return () => this.subscribers.delete(callback)
-	}
-
-	private notify() {
-		this.subscribers.forEach((callback) => callback())
-	}
-
 	showTooltip(
 		tooltipId: string,
 		content: string | React.ReactNode,
-		element: HTMLElement,
-		side: 'top' | 'right' | 'bottom' | 'left' = 'bottom',
-		sideOffset: number = 5
+		targetElement: HTMLElement,
+		side: 'top' | 'right' | 'bottom' | 'left',
+		sideOffset: number,
+		showOnMobile: boolean,
+		delayDuration: number
 	) {
 		// Clear any existing destroy timeout
 		if (this.destroyTimeoutId) {
@@ -61,51 +64,66 @@ class TooltipManager {
 		}
 
 		// Update current tooltip
-		this.currentTooltipId = tooltipId
-		this.currentContent = content
-		this.currentSide = side
-		this.currentSideOffset = sideOffset
-		this.activeElement = element
+		this.currentTooltip.set({
+			id: tooltipId,
+			content,
+			side,
+			sideOffset,
+			showOnMobile,
+			targetElement,
+			delayDuration,
+		})
+	}
 
-		this.notify()
+	updateCurrentTooltip(tooltipId: string, update: (tooltip: CurrentTooltip) => CurrentTooltip) {
+		this.currentTooltip.update((tooltip) => {
+			if (tooltip?.id === tooltipId) {
+				return update(tooltip)
+			}
+			return tooltip
+		})
 	}
 
-	hideTooltip(tooltipId: string, instant: boolean = false) {
+	hideTooltip(editor: Editor | null, tooltipId: string, instant: boolean = false) {
 		const hide = () => {
 			// Only hide if this is the current tooltip
-			if (this.currentTooltipId === tooltipId) {
-				this.currentTooltipId = null
-				this.currentContent = ''
-				this.activeElement = null
+			if (this.currentTooltip.get()?.id === tooltipId) {
+				this.currentTooltip.set(null)
 				this.destroyTimeoutId = null
-				this.notify()
 			}
 		}
 
-		if (instant) {
-			hide()
-		} else if (this.editor) {
+		if (editor && !instant) {
 			// Start destroy timeout (1 second)
-			this.destroyTimeoutId = this.editor.timers.setTimeout(hide, 300)
+			this.destroyTimeoutId = editor.timers.setTimeout(hide, 300)
+		} else {
+			hide()
 		}
 	}
 
 	hideAllTooltips() {
-		this.currentTooltipId = null
-		this.currentContent = ''
-		this.activeElement = null
+		this.currentTooltip.set(null)
 		this.destroyTimeoutId = null
-		this.notify()
 	}
 
 	getCurrentTooltipData() {
-		return {
-			id: this.currentTooltipId,
-			content: this.currentContent,
-			side: this.currentSide,
-			sideOffset: this.currentSideOffset,
-			element: this.activeElement,
+		const currentTooltip = this.currentTooltip.get()
+		if (!currentTooltip) return null
+		if (!this.supportsHover() && !currentTooltip.showOnMobile) return null
+		return currentTooltip
+	}
+
+	private supportsHoverAtom: Atom<boolean> | null = null
+	supportsHover() {
+		if (!this.supportsHoverAtom) {
+			const mediaQuery = window.matchMedia('(hover: hover)')
+			const supportsHover = atom('has hover', mediaQuery.matches)
+			this.supportsHoverAtom = supportsHover
+			mediaQuery.addEventListener('change', (e) => {
+				supportsHover.set(e.matches)
+			})
 		}
+		return this.supportsHoverAtom.get()
 	}
 }
 
@@ -133,66 +151,34 @@ export function TldrawUiTooltipProvider({ children }: TldrawUiTooltipProviderPro
 
 // The singleton tooltip component that renders once
 function TooltipSingleton() {
-	const editor = useMaybeEditor()
-	const [, forceUpdate] = useState({})
 	const [isOpen, setIsOpen] = useState(false)
 	const triggerRef = useRef<HTMLDivElement>(null)
-	const previousPositionRef = useRef<{ x: number; y: number } | null>(null)
-	const prefersReducedMotion = usePrefersReducedMotion()
-	const [shouldAnimate, setShouldAnimate] = useState(false)
 	const isFirstShowRef = useRef(true)
-	const showTimeoutRef = useRef<number | null>(null)
-
-	// Set editor in tooltip manager
-	useEffect(() => {
-		tooltipManager.setEditor(editor)
-	}, [editor])
+	const editor = useMaybeEditor()
 
-	// Subscribe to tooltip manager updates
-	useEffect(() => {
-		const unsubscribe = tooltipManager.subscribe(() => {
-			forceUpdate({})
-		})
-		return unsubscribe
-	}, [])
+	const currentTooltip = useValue(
+		'current tooltip',
+		() => tooltipManager.getCurrentTooltipData(),
+		[]
+	)
 
-	const tooltipData = tooltipManager.getCurrentTooltipData()
+	const cameraState = useValue('camera state', () => editor?.getCameraState(), [editor])
 
-	// Update open state and trigger position
+	// Hide tooltip when camera is moving (panning/zooming)
 	useEffect(() => {
-		const shouldBeOpen = Boolean(tooltipData.id && tooltipData.element)
-
-		// Clear any existing show timeout
-		if (showTimeoutRef.current) {
-			clearTimeout(showTimeoutRef.current)
-			showTimeoutRef.current = null
+		if (cameraState === 'moving' && isOpen && currentTooltip) {
+			tooltipManager.hideTooltip(editor, currentTooltip.id, true)
 		}
+	}, [cameraState, isOpen, currentTooltip, editor])
 
-		if (shouldBeOpen && tooltipData.element && triggerRef.current) {
+	// Update open state and trigger position
+	useEffect(() => {
+		let timer: ReturnType<typeof setTimeout> | null = null
+		if (currentTooltip && triggerRef.current) {
 			// Position the invisible trigger element over the active element
-			const activeRect = tooltipData.element.getBoundingClientRect()
+			const activeRect = currentTooltip.targetElement.getBoundingClientRect()
 			const trigger = triggerRef.current
 
-			const newPosition = {
-				x: activeRect.left + activeRect.width / 2,
-				y: activeRect.top + activeRect.height / 2,
-			}
-
-			// Determine if we should animate
-			let shouldAnimateCheck = false
-			if (previousPositionRef.current) {
-				const isNearPrevious = Vec.DistMin(previousPositionRef.current, newPosition, 200)
-				// Only animate if the distance is less than 200px (nearby tooltips)
-				shouldAnimateCheck =
-					!prefersReducedMotion &&
-					isNearPrevious &&
-					Math.abs(newPosition.y - previousPositionRef.current.y) < 50
-			}
-			// Don't animate on initial show (previousPositionRef.current is null)
-
-			setShouldAnimate(isFirstShowRef.current ? false : shouldAnimateCheck)
-			previousPositionRef.current = newPosition
-
 			trigger.style.position = 'fixed'
 			trigger.style.left = `${activeRect.left}px`
 			trigger.style.top = `${activeRect.top}px`
@@ -202,27 +188,31 @@ function TooltipSingleton() {
 			trigger.style.zIndex = '9999'
 
 			// Handle delay for first show
-			if (isFirstShowRef.current && editor) {
-				showTimeoutRef.current = editor.timers.setTimeout(() => {
+			if (isFirstShowRef.current) {
+				// eslint-disable-next-line no-restricted-globals
+				timer = setTimeout(() => {
 					setIsOpen(true)
 					isFirstShowRef.current = false
-				}, editor.options.tooltipDelayMs)
+				}, currentTooltip.delayDuration)
 			} else {
 				// Subsequent tooltips show immediately
 				setIsOpen(true)
 			}
-		} else if (!shouldBeOpen) {
+		} else {
 			// Hide tooltip immediately
 			setIsOpen(false)
-			// Reset position tracking when tooltip closes
-			previousPositionRef.current = null
-			setShouldAnimate(false)
 			// Reset first show state after tooltip is hidden
 			isFirstShowRef.current = true
 		}
-	}, [tooltipData.id, tooltipData.element, editor, prefersReducedMotion])
 
-	if (!tooltipData.id) {
+		return () => {
+			if (timer !== null) {
+				clearTimeout(timer)
+			}
+		}
+	}, [currentTooltip])
+
+	if (!currentTooltip) {
 		return null
 	}
 
@@ -233,14 +223,13 @@ function TooltipSingleton() {
 			</_Tooltip.Trigger>
 			<_Tooltip.Content
 				className="tlui-tooltip"
-				data-should-animate={shouldAnimate}
-				side={tooltipData.side}
-				sideOffset={tooltipData.sideOffset}
+				side={currentTooltip.side}
+				sideOffset={currentTooltip.sideOffset}
 				avoidCollisions
 				collisionPadding={8}
 				dir="ltr"
 			>
-				{tooltipData.content}
+				{currentTooltip.content}
 				<_Tooltip.Arrow className="tlui-tooltip__arrow" />
 			</_Tooltip.Content>
 		</_Tooltip.Root>
@@ -249,10 +238,22 @@ function TooltipSingleton() {
 
 /** @public @react */
 export const TldrawUiTooltip = forwardRef<HTMLButtonElement, TldrawUiTooltipProps>(
-	({ children, content, side, sideOffset = 5, disabled = false }, ref) => {
+	(
+		{
+			children,
+			content,
+			side,
+			sideOffset = 5,
+			disabled = false,
+			showOnMobile = false,
+			delayDuration,
+		},
+		ref
+	) => {
 		const editor = useMaybeEditor()
 		const tooltipId = useRef<string>(uniqueId())
 		const hasProvider = useContext(TooltipSingletonContext)
+		const showUiLabels = useValue('showUiLabels', () => editor?.user.getShowUiLabels(), [editor])
 
 		const orientationCtx = useTldrawUiOrientation()
 		const sideToUse = side ?? orientationCtx.tooltipSide
@@ -261,23 +262,40 @@ export const TldrawUiTooltip = forwardRef<HTMLButtonElement, TldrawUiTooltipProp
 			const currentTooltipId = tooltipId.current
 			return () => {
 				if (hasProvider) {
-					tooltipManager.hideTooltip(currentTooltipId, true)
+					tooltipManager.hideTooltip(editor, currentTooltipId, true)
 				}
 			}
-		}, [hasProvider])
+		}, [editor, hasProvider])
+
+		useLayoutEffect(() => {
+			if (hasProvider && tooltipManager.getCurrentTooltipData()?.id === tooltipId.current) {
+				tooltipManager.updateCurrentTooltip(tooltipId.current, (tooltip) => ({
+					...tooltip,
+					content,
+					side: sideToUse,
+					sideOffset,
+					showOnMobile,
+				}))
+			}
+		}, [content, sideToUse, sideOffset, showOnMobile, hasProvider])
 
 		// Don't show tooltip if disabled, no content, or UI labels are disabled
 		if (disabled || !content) {
 			return <>{children}</>
 		}
 
+		let delayDurationToUse
+		if (showUiLabels) {
+			delayDurationToUse = 0
+		} else {
+			delayDurationToUse =
+				delayDuration ?? (editor?.options.tooltipDelayMs || DEFAULT_TOOLTIP_DELAY_MS)
+		}
+
 		// Fallback to old behavior if no provider
 		if (!hasProvider) {
 			return (
-				<_Tooltip.Root
-					delayDuration={editor?.options.tooltipDelayMs || DEFAULT_TOOLTIP_DELAY_MS}
-					disableHoverableContent
-				>
+				<_Tooltip.Root delayDuration={delayDurationToUse} disableHoverableContent>
 					<_Tooltip.Trigger asChild ref={ref}>
 						{children}
 					</_Tooltip.Trigger>
@@ -306,13 +324,15 @@ export const TldrawUiTooltip = forwardRef<HTMLButtonElement, TldrawUiTooltipProp
 				content,
 				event.currentTarget as HTMLElement,
 				sideToUse,
-				sideOffset
+				sideOffset,
+				showOnMobile,
+				delayDurationToUse
 			)
 		}
 
 		const handleMouseLeave = (event: React.MouseEvent<HTMLElement>) => {
 			child.props.onMouseLeave?.(event)
-			tooltipManager.hideTooltip(tooltipId.current)
+			tooltipManager.hideTooltip(editor, tooltipId.current)
 		}
 
 		const handleFocus = (event: React.FocusEvent<HTMLElement>) => {
@@ -322,13 +342,15 @@ export const TldrawUiTooltip = forwardRef<HTMLButtonElement, TldrawUiTooltipProp
 				content,
 				event.currentTarget as HTMLElement,
 				sideToUse,
-				sideOffset
+				sideOffset,
+				showOnMobile,
+				delayDurationToUse
 			)
 		}
 
 		const handleBlur = (event: React.FocusEvent<HTMLElement>) => {
 			child.props.onBlur?.(event)
-			tooltipManager.hideTooltip(tooltipId.current)
+			tooltipManager.hideTooltip(editor, tooltipId.current)
 		}
 
 		const childrenWithHandlers = React.cloneElement(children as React.ReactElement, {

package/src/lib/ui/components/primitives/menus/TldrawUiMenuContext.tsx

@@ -3,7 +3,6 @@ import { TLUiEventSource } from '../../../context/events'
 
 /** @public */
 export type TLUiMenuContextType =
-	| 'panel'
 	| 'menu'
 	| 'small-icons'
 	| 'context-menu'

package/src/lib/ui/components/primitives/menus/TldrawUiMenuGroup.tsx

@@ -27,16 +27,6 @@ export function TldrawUiMenuGroup({ id, label, className, children }: TLUiMenuGr
 	const labelStr = labelToUse ? msg(labelToUse as TLUiTranslationKey) : undefined
 
 	switch (menu.type) {
-		case 'panel': {
-			return (
-				<div
-					className={classNames('tlui-menu__group', className)}
-					data-testid={`${menu.sourceId}-group.${id}`}
-				>
-					{children}
-				</div>
-			)
-		}
 		case 'menu': {
 			return (
 				<TldrawUiDropdownMenuGroup