@cognitap/radiant 0.0.63 → 0.0.65
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +13 -0
- package/dist/library/ContextMenu.d.ts +2 -1
- package/dist/library/ContextMenu.d.ts.map +1 -1
- package/dist/library/ContextMenu.js.map +1 -1
- package/dist/library/Menu.d.ts +4 -10
- package/dist/library/Menu.d.ts.map +1 -1
- package/dist/library/Menu.js +2 -2
- package/dist/library/Menu.js.map +1 -1
- package/dist/library/Menubar.d.ts +1 -1
- package/dist/library/Menubar.d.ts.map +1 -1
- package/dist/library/Menubar.js.map +1 -1
- package/dist/library/NavigationMenu.d.ts +64 -0
- package/dist/library/NavigationMenu.d.ts.map +1 -0
- package/dist/library/NavigationMenu.js +346 -0
- package/dist/library/NavigationMenu.js.map +1 -0
- package/dist/library/Popover.d.ts +1 -1
- package/dist/library/Popover.d.ts.map +1 -1
- package/dist/library/Popover.js +1 -1
- package/dist/library/Popover.js.map +1 -1
- package/dist/library/ToggleGroup.d.ts +12 -22
- package/dist/library/ToggleGroup.d.ts.map +1 -1
- package/dist/library/ToggleGroup.js +6 -6
- package/dist/library/ToggleGroup.js.map +1 -1
- package/dist/library/Toolbar.d.ts +2 -2
- package/dist/library/Toolbar.d.ts.map +1 -1
- package/dist/library/cn.d.ts.map +1 -1
- package/dist/library/cn.js +5 -0
- package/dist/library/cn.js.map +1 -1
- package/dist/library/index.d.ts +5 -3
- package/dist/library/index.d.ts.map +1 -1
- package/dist/library/index.js +1 -0
- package/dist/library/index.js.map +1 -1
- package/dist/library/react/useHoverSurface.d.ts +1 -0
- package/dist/library/react/useHoverSurface.d.ts.map +1 -1
- package/dist/library/react/useHoverSurface.js +5 -0
- package/dist/library/react/useHoverSurface.js.map +1 -1
- package/dist/library/styles.css +1 -1
- package/dist/library/themes/components.d.ts +10 -0
- package/dist/library/themes/components.d.ts.map +1 -1
- package/dist/library/themes/components.js +10 -0
- package/dist/library/themes/components.js.map +1 -1
- package/docs/architecture.md +3 -2
- package/package.json +1 -1
- package/src/ContextMenu.tsx +3 -1
- package/src/Menu.tsx +7 -20
- package/src/Menubar.tsx +1 -7
- package/src/NavigationMenu.tsx +650 -0
- package/src/Popover.tsx +5 -1
- package/src/ToggleGroup.tsx +21 -24
- package/src/Toolbar.tsx +2 -2
- package/src/cn.ts +5 -0
- package/src/index.ts +29 -4
- package/src/react/useHoverSurface.ts +5 -0
- package/src/themes/components.ts +10 -0
|
@@ -0,0 +1,650 @@
|
|
|
1
|
+
'use client'
|
|
2
|
+
|
|
3
|
+
/* oxlint-disable jsx-a11y/no-noninteractive-element-interactions -- Navigation delegates Escape for real buttons and links; the landmark remains navigation rather than a menu widget. */
|
|
4
|
+
|
|
5
|
+
import {
|
|
6
|
+
createContext,
|
|
7
|
+
useCallback,
|
|
8
|
+
useContext,
|
|
9
|
+
useId,
|
|
10
|
+
useLayoutEffect,
|
|
11
|
+
useRef,
|
|
12
|
+
useState,
|
|
13
|
+
type ComponentProps,
|
|
14
|
+
type RefObject
|
|
15
|
+
} from 'react'
|
|
16
|
+
import { Button, type ButtonProps, type ButtonRenderProps } from './Button.js'
|
|
17
|
+
import {
|
|
18
|
+
ComposedLink,
|
|
19
|
+
type ComposedLinkProps,
|
|
20
|
+
type ComposedLinkRenderProps
|
|
21
|
+
} from './composedLink.js'
|
|
22
|
+
import { cn } from './cn.js'
|
|
23
|
+
import { ScrollArea } from './ScrollArea.js'
|
|
24
|
+
import { composeAction } from './internal/events.js'
|
|
25
|
+
import { joinIds } from './internal/ids.js'
|
|
26
|
+
import { requireAccessibleName, type AccessibleName } from './internal/accessibleName.js'
|
|
27
|
+
import type { DistributiveOmit, WithoutToggle } from './internal/types.js'
|
|
28
|
+
import { useControllableState } from './react/useControllableState.js'
|
|
29
|
+
import { useComposedRefs } from './react/useComposedRefs.js'
|
|
30
|
+
import { useHoverSurface } from './react/useHoverSurface.js'
|
|
31
|
+
import type { ValueOwner } from './react/useNativeOwner.js'
|
|
32
|
+
import { useTransitionHost } from './motion/host.js'
|
|
33
|
+
import type { ControlSize } from './presentation.js'
|
|
34
|
+
import type { ThemeStyle } from './themes/defineTheme.js'
|
|
35
|
+
|
|
36
|
+
export type NavigationMenuItemConfig = { value: string; disabled?: boolean }
|
|
37
|
+
export type NavigationMenuProps = Omit<
|
|
38
|
+
ComponentProps<'nav'>,
|
|
39
|
+
'style' | 'role' | 'onChange' | 'defaultValue'
|
|
40
|
+
> &
|
|
41
|
+
AccessibleName &
|
|
42
|
+
ValueOwner<string | null> & {
|
|
43
|
+
style?: ThemeStyle
|
|
44
|
+
'data-slot'?: string
|
|
45
|
+
items: readonly NavigationMenuItemConfig[]
|
|
46
|
+
onValueChange?: (value: string | null) => void
|
|
47
|
+
openDelay?: number
|
|
48
|
+
closeDelay?: number
|
|
49
|
+
disabled?: boolean
|
|
50
|
+
controlSize?: ControlSize
|
|
51
|
+
}
|
|
52
|
+
export type NavigationMenuState = {
|
|
53
|
+
value: string | null
|
|
54
|
+
controlled: boolean
|
|
55
|
+
disabled: boolean
|
|
56
|
+
setValue: (value: string | null) => void
|
|
57
|
+
}
|
|
58
|
+
type Hover = ReturnType<typeof useHoverSurface>
|
|
59
|
+
type Binding = NavigationMenuState & {
|
|
60
|
+
visible: string | null
|
|
61
|
+
items: readonly NavigationMenuItemConfig[]
|
|
62
|
+
controlSize: ControlSize
|
|
63
|
+
openDelay: number
|
|
64
|
+
closeDelay: number
|
|
65
|
+
root: RefObject<HTMLElement | null>
|
|
66
|
+
viewport: RefObject<HTMLDivElement | null>
|
|
67
|
+
triggers: RefObject<Map<string, HTMLButtonElement>>
|
|
68
|
+
panels: RefObject<Map<string, HTMLDivElement>>
|
|
69
|
+
hover: RefObject<Map<string, Hover>>
|
|
70
|
+
ids: (value: string) => { trigger: string; panel: string }
|
|
71
|
+
requestFocus: (value: string, last: boolean) => void
|
|
72
|
+
cancel: () => void
|
|
73
|
+
registerTrigger: (value: string, node: HTMLButtonElement | null) => void
|
|
74
|
+
registerPanel: (value: string, node: HTMLDivElement | null) => void
|
|
75
|
+
}
|
|
76
|
+
const Context = createContext<Binding | null>(null)
|
|
77
|
+
export function useNavigationMenu(): NavigationMenuState | null {
|
|
78
|
+
return useContext(Context)
|
|
79
|
+
}
|
|
80
|
+
function useBinding() {
|
|
81
|
+
const value = useContext(Context)
|
|
82
|
+
if (!value) throw new Error('NavigationMenu parts must render inside NavigationMenu.')
|
|
83
|
+
return value
|
|
84
|
+
}
|
|
85
|
+
function item(binding: Binding, value: string) {
|
|
86
|
+
const entry = binding.items.find(entry => entry.value === value)
|
|
87
|
+
if (!entry) throw new TypeError('NavigationMenu parts require a registered value.')
|
|
88
|
+
return entry
|
|
89
|
+
}
|
|
90
|
+
function focusable(panel: HTMLElement) {
|
|
91
|
+
return Array.from(
|
|
92
|
+
panel.querySelectorAll<HTMLElement>('a[href],button,input,select,textarea,[tabindex]')
|
|
93
|
+
).filter(
|
|
94
|
+
node =>
|
|
95
|
+
node.tabIndex >= 0 &&
|
|
96
|
+
!node.matches(':disabled') &&
|
|
97
|
+
!node.closest('[inert]') &&
|
|
98
|
+
node.getClientRects().length > 0
|
|
99
|
+
)
|
|
100
|
+
}
|
|
101
|
+
export function NavigationMenu({
|
|
102
|
+
items,
|
|
103
|
+
value,
|
|
104
|
+
defaultValue,
|
|
105
|
+
onValueChange,
|
|
106
|
+
openDelay = 200,
|
|
107
|
+
closeDelay = 150,
|
|
108
|
+
disabled = false,
|
|
109
|
+
controlSize = 'medium',
|
|
110
|
+
ref,
|
|
111
|
+
className,
|
|
112
|
+
onKeyDown,
|
|
113
|
+
onBlurCapture,
|
|
114
|
+
onFocusCapture,
|
|
115
|
+
...props
|
|
116
|
+
}: NavigationMenuProps) {
|
|
117
|
+
requireAccessibleName('NavigationMenu', props)
|
|
118
|
+
if (
|
|
119
|
+
!Array.isArray(items) ||
|
|
120
|
+
items.some(
|
|
121
|
+
entry =>
|
|
122
|
+
typeof entry.value !== 'string' ||
|
|
123
|
+
!entry.value ||
|
|
124
|
+
(entry.disabled !== undefined && typeof entry.disabled !== 'boolean')
|
|
125
|
+
) ||
|
|
126
|
+
new Set(items.map(entry => entry.value)).size !== items.length
|
|
127
|
+
)
|
|
128
|
+
throw new TypeError('NavigationMenu items require unique nonempty values.')
|
|
129
|
+
if (![openDelay, closeDelay].every(n => Number.isFinite(n) && n >= 0))
|
|
130
|
+
throw new TypeError('NavigationMenu delays must be finite and nonnegative.')
|
|
131
|
+
const state = useControllableState<string | null>({
|
|
132
|
+
name: 'NavigationMenu',
|
|
133
|
+
value,
|
|
134
|
+
defaultValue,
|
|
135
|
+
initialValue: null,
|
|
136
|
+
onChange: onValueChange
|
|
137
|
+
})
|
|
138
|
+
const valid = (next: string | null) => {
|
|
139
|
+
if (next !== null && !items.some(entry => entry.value === next))
|
|
140
|
+
throw new TypeError('NavigationMenu value must identify a registered panel.')
|
|
141
|
+
}
|
|
142
|
+
valid(state.value)
|
|
143
|
+
const shown =
|
|
144
|
+
!disabled && state.value !== null && !items.find(entry => entry.value === state.value)?.disabled
|
|
145
|
+
? state.value
|
|
146
|
+
: null
|
|
147
|
+
const root = useRef<HTMLElement>(null),
|
|
148
|
+
viewport = useRef<HTMLDivElement>(null),
|
|
149
|
+
triggers = useRef(new Map<string, HTMLButtonElement>()),
|
|
150
|
+
panels = useRef(new Map<string, HTMLDivElement>()),
|
|
151
|
+
hover = useRef(new Map<string, Hover>()),
|
|
152
|
+
id = useId(),
|
|
153
|
+
latest = useRef(shown),
|
|
154
|
+
pending = useRef<{ value: string; last: boolean } | null>(null),
|
|
155
|
+
focusedPanel = useRef<string | null>(null),
|
|
156
|
+
previous = useRef(shown)
|
|
157
|
+
useLayoutEffect(() => {
|
|
158
|
+
latest.current = shown
|
|
159
|
+
})
|
|
160
|
+
const registerTrigger = useCallback((value: string, node: HTMLButtonElement | null) => {
|
|
161
|
+
if (node) triggers.current.set(value, node)
|
|
162
|
+
else triggers.current.delete(value)
|
|
163
|
+
}, [])
|
|
164
|
+
const registerPanel = useCallback((value: string, node: HTMLDivElement | null) => {
|
|
165
|
+
if (node) panels.current.set(value, node)
|
|
166
|
+
else panels.current.delete(value)
|
|
167
|
+
}, [])
|
|
168
|
+
const host = useComposedRefs(root, ref)
|
|
169
|
+
const cancel = () => hover.current.forEach(binding => binding.cancel())
|
|
170
|
+
const setValue = (next: string | null) => {
|
|
171
|
+
valid(next)
|
|
172
|
+
cancel()
|
|
173
|
+
if (disabled || (next !== null && items.find(entry => entry.value === next)?.disabled)) return
|
|
174
|
+
state.request(next)
|
|
175
|
+
}
|
|
176
|
+
const requestFocus = (next: string, last: boolean) => {
|
|
177
|
+
pending.current = { value: next, last }
|
|
178
|
+
setValue(next)
|
|
179
|
+
root.current?.ownerDocument.defaultView?.queueMicrotask(() => {
|
|
180
|
+
const intent = pending.current
|
|
181
|
+
if (!intent || intent.value !== next) return
|
|
182
|
+
pending.current = null
|
|
183
|
+
if (latest.current !== next) return
|
|
184
|
+
const panel = panels.current.get(next),
|
|
185
|
+
nodes = panel ? focusable(panel) : []
|
|
186
|
+
;(last ? nodes.at(-1) : nodes[0])?.focus()
|
|
187
|
+
})
|
|
188
|
+
}
|
|
189
|
+
useLayoutEffect(() => {
|
|
190
|
+
const node = root.current
|
|
191
|
+
if (!node) return
|
|
192
|
+
const doc = node.ownerDocument
|
|
193
|
+
const close = (event: Event) => {
|
|
194
|
+
if (!event.defaultPrevented && !event.composedPath().includes(node)) setValue(null)
|
|
195
|
+
}
|
|
196
|
+
doc.addEventListener('pointerdown', close)
|
|
197
|
+
doc.addEventListener('focusin', close)
|
|
198
|
+
doc.defaultView?.addEventListener('blur', close)
|
|
199
|
+
return () => {
|
|
200
|
+
doc.removeEventListener('pointerdown', close)
|
|
201
|
+
doc.removeEventListener('focusin', close)
|
|
202
|
+
doc.defaultView?.removeEventListener('blur', close)
|
|
203
|
+
}
|
|
204
|
+
})
|
|
205
|
+
useLayoutEffect(() => {
|
|
206
|
+
if (previous.current !== shown) {
|
|
207
|
+
const old = previous.current,
|
|
208
|
+
doc = root.current?.ownerDocument,
|
|
209
|
+
active = doc?.activeElement
|
|
210
|
+
if (
|
|
211
|
+
old !== null &&
|
|
212
|
+
focusedPanel.current === old &&
|
|
213
|
+
doc &&
|
|
214
|
+
(active === doc.body || root.current?.contains(active ?? null))
|
|
215
|
+
)
|
|
216
|
+
(triggers.current.get(old)?.disabled
|
|
217
|
+
? focusable(root.current!)[0]
|
|
218
|
+
: triggers.current.get(old)
|
|
219
|
+
)?.focus()
|
|
220
|
+
focusedPanel.current = null
|
|
221
|
+
}
|
|
222
|
+
previous.current = shown
|
|
223
|
+
})
|
|
224
|
+
return (
|
|
225
|
+
<Context.Provider
|
|
226
|
+
value={{
|
|
227
|
+
visible: shown,
|
|
228
|
+
value: state.value,
|
|
229
|
+
controlled: state.controlled,
|
|
230
|
+
disabled,
|
|
231
|
+
setValue,
|
|
232
|
+
items,
|
|
233
|
+
controlSize,
|
|
234
|
+
openDelay,
|
|
235
|
+
closeDelay,
|
|
236
|
+
root,
|
|
237
|
+
viewport,
|
|
238
|
+
triggers,
|
|
239
|
+
panels,
|
|
240
|
+
hover,
|
|
241
|
+
cancel,
|
|
242
|
+
requestFocus,
|
|
243
|
+
registerTrigger,
|
|
244
|
+
registerPanel,
|
|
245
|
+
ids: next => ({
|
|
246
|
+
trigger: `${id}-trigger-${items.findIndex(entry => entry.value === next)}`,
|
|
247
|
+
panel: `${id}-panel-${items.findIndex(entry => entry.value === next)}`
|
|
248
|
+
})
|
|
249
|
+
}}
|
|
250
|
+
>
|
|
251
|
+
<nav
|
|
252
|
+
{...props}
|
|
253
|
+
ref={host}
|
|
254
|
+
{...{ role: undefined }}
|
|
255
|
+
data-slot={joinIds('navigation-menu', props['data-slot'])}
|
|
256
|
+
data-state={shown !== null ? 'open' : 'closed'}
|
|
257
|
+
data-disabled={disabled || undefined}
|
|
258
|
+
data-control-size={controlSize}
|
|
259
|
+
className={cn('relative max-w-full', className)}
|
|
260
|
+
onKeyDown={event => {
|
|
261
|
+
onKeyDown?.(event)
|
|
262
|
+
if (event.defaultPrevented) return
|
|
263
|
+
if (
|
|
264
|
+
event.key === 'Escape' &&
|
|
265
|
+
state.value !== null &&
|
|
266
|
+
event.target instanceof root.current!.ownerDocument.defaultView!.HTMLElement &&
|
|
267
|
+
event.target.closest('[data-slot~="navigation-menu"]') === root.current
|
|
268
|
+
) {
|
|
269
|
+
event.preventDefault()
|
|
270
|
+
focusedPanel.current = state.value
|
|
271
|
+
setValue(null)
|
|
272
|
+
}
|
|
273
|
+
}}
|
|
274
|
+
onFocusCapture={event => {
|
|
275
|
+
onFocusCapture?.(event)
|
|
276
|
+
focusedPanel.current = viewport.current?.contains(event.target) ? shown : null
|
|
277
|
+
}}
|
|
278
|
+
onBlurCapture={event => {
|
|
279
|
+
onBlurCapture?.(event)
|
|
280
|
+
if (!event.currentTarget.contains(event.relatedTarget)) {
|
|
281
|
+
cancel()
|
|
282
|
+
}
|
|
283
|
+
}}
|
|
284
|
+
>
|
|
285
|
+
{props.children}
|
|
286
|
+
</nav>
|
|
287
|
+
</Context.Provider>
|
|
288
|
+
)
|
|
289
|
+
}
|
|
290
|
+
export type NavigationMenuListProps = Omit<ComponentProps<'ul'>, 'style' | 'role'> & {
|
|
291
|
+
style?: ThemeStyle
|
|
292
|
+
'data-slot'?: string
|
|
293
|
+
}
|
|
294
|
+
export function NavigationMenuList({ className, ...props }: NavigationMenuListProps) {
|
|
295
|
+
useBinding()
|
|
296
|
+
return (
|
|
297
|
+
<ul
|
|
298
|
+
{...props}
|
|
299
|
+
{...{ role: undefined }}
|
|
300
|
+
data-slot={joinIds('navigation-menu-list', props['data-slot'])}
|
|
301
|
+
className={cn(
|
|
302
|
+
'm-0 flex flex-wrap list-none items-center gap-[var(--rad-navigation-menu-gap,0.25rem)] p-0',
|
|
303
|
+
className
|
|
304
|
+
)}
|
|
305
|
+
/>
|
|
306
|
+
)
|
|
307
|
+
}
|
|
308
|
+
export type NavigationMenuItemProps = Omit<ComponentProps<'li'>, 'style' | 'role'> & {
|
|
309
|
+
style?: ThemeStyle
|
|
310
|
+
'data-slot'?: string
|
|
311
|
+
}
|
|
312
|
+
export function NavigationMenuItem(props: NavigationMenuItemProps) {
|
|
313
|
+
useBinding()
|
|
314
|
+
return (
|
|
315
|
+
<li
|
|
316
|
+
{...props}
|
|
317
|
+
{...{ role: undefined }}
|
|
318
|
+
data-slot={joinIds('navigation-menu-item', props['data-slot'])}
|
|
319
|
+
/>
|
|
320
|
+
)
|
|
321
|
+
}
|
|
322
|
+
export type NavigationMenuRenderProps = ButtonRenderProps
|
|
323
|
+
export type NavigationMenuLinkRenderProps = ComposedLinkRenderProps
|
|
324
|
+
export type NavigationMenuTriggerProps = WithoutToggle<
|
|
325
|
+
DistributiveOmit<
|
|
326
|
+
ButtonProps,
|
|
327
|
+
| 'value'
|
|
328
|
+
| 'aria-expanded'
|
|
329
|
+
| 'aria-controls'
|
|
330
|
+
| 'aria-haspopup'
|
|
331
|
+
| 'id'
|
|
332
|
+
| 'role'
|
|
333
|
+
| 'popoverTarget'
|
|
334
|
+
| 'popoverTargetAction'
|
|
335
|
+
>
|
|
336
|
+
> & { value: string }
|
|
337
|
+
export function NavigationMenuTrigger({
|
|
338
|
+
value,
|
|
339
|
+
ref,
|
|
340
|
+
onClick,
|
|
341
|
+
onPointerEnter,
|
|
342
|
+
onPointerLeave,
|
|
343
|
+
onPointerDown,
|
|
344
|
+
onKeyDown,
|
|
345
|
+
onFocus,
|
|
346
|
+
onBlur,
|
|
347
|
+
disabled,
|
|
348
|
+
controlSize,
|
|
349
|
+
variant = 'ghost',
|
|
350
|
+
tone = 'neutral',
|
|
351
|
+
...props
|
|
352
|
+
}: NavigationMenuTriggerProps) {
|
|
353
|
+
const binding = useBinding(),
|
|
354
|
+
entry = item(binding, value),
|
|
355
|
+
registerTrigger = binding.registerTrigger,
|
|
356
|
+
[node, setNode] = useState<HTMLButtonElement | null>(null),
|
|
357
|
+
register = useCallback(
|
|
358
|
+
(element: HTMLButtonElement | null) => {
|
|
359
|
+
setNode(element)
|
|
360
|
+
registerTrigger(value, element)
|
|
361
|
+
},
|
|
362
|
+
[registerTrigger, value, setNode]
|
|
363
|
+
),
|
|
364
|
+
host = useComposedRefs(register, ref),
|
|
365
|
+
open = binding.visible === value,
|
|
366
|
+
blocked = binding.disabled || entry.disabled || disabled || props.pending
|
|
367
|
+
const hover = useHoverSurface({
|
|
368
|
+
trigger: node,
|
|
369
|
+
content: binding.viewport,
|
|
370
|
+
open,
|
|
371
|
+
request: next => {
|
|
372
|
+
if (next) binding.setValue(value)
|
|
373
|
+
else if (binding.value === value) binding.setValue(null)
|
|
374
|
+
},
|
|
375
|
+
openDelay: binding.value === null ? binding.openDelay : 0,
|
|
376
|
+
closeDelay: binding.closeDelay
|
|
377
|
+
})
|
|
378
|
+
useLayoutEffect(() => {
|
|
379
|
+
const hovers = binding.hover.current
|
|
380
|
+
hovers.set(value, hover)
|
|
381
|
+
if (!open) hover.cancel(true)
|
|
382
|
+
return () => {
|
|
383
|
+
hovers.delete(value)
|
|
384
|
+
}
|
|
385
|
+
})
|
|
386
|
+
return (
|
|
387
|
+
<Button
|
|
388
|
+
{...props}
|
|
389
|
+
ref={host}
|
|
390
|
+
disabled={binding.disabled || entry.disabled || disabled}
|
|
391
|
+
controlSize={controlSize ?? binding.controlSize}
|
|
392
|
+
variant={variant}
|
|
393
|
+
tone={tone}
|
|
394
|
+
pressed={undefined}
|
|
395
|
+
defaultPressed={undefined}
|
|
396
|
+
onPressedChange={undefined}
|
|
397
|
+
aria-pressed={undefined}
|
|
398
|
+
aria-haspopup={undefined}
|
|
399
|
+
popoverTarget={undefined}
|
|
400
|
+
popoverTargetAction={undefined}
|
|
401
|
+
{...{ role: undefined }}
|
|
402
|
+
id={binding.ids(value).trigger}
|
|
403
|
+
aria-expanded={open}
|
|
404
|
+
aria-controls={binding.ids(value).panel}
|
|
405
|
+
data-slot={joinIds('navigation-menu-trigger', props['data-slot'])}
|
|
406
|
+
data-state={open ? 'open' : 'closed'}
|
|
407
|
+
onClick={composeAction(onClick, () => binding.setValue(open ? null : value))}
|
|
408
|
+
onPointerDown={composeAction(onPointerDown, binding.cancel)}
|
|
409
|
+
onPointerEnter={composeAction(onPointerEnter, event => {
|
|
410
|
+
if (!blocked && event.pointerType !== 'touch') hover.enter()
|
|
411
|
+
})}
|
|
412
|
+
onPointerLeave={composeAction(onPointerLeave, event => {
|
|
413
|
+
if (event.pointerType !== 'touch') hover.leave()
|
|
414
|
+
})}
|
|
415
|
+
onFocus={event => {
|
|
416
|
+
onFocus?.(event)
|
|
417
|
+
if (open) hover.enter(true)
|
|
418
|
+
}}
|
|
419
|
+
onBlur={event => {
|
|
420
|
+
onBlur?.(event)
|
|
421
|
+
hover.leave(true)
|
|
422
|
+
}}
|
|
423
|
+
onKeyDown={composeAction(onKeyDown, event => {
|
|
424
|
+
if (blocked || event.altKey || event.metaKey || event.ctrlKey) return
|
|
425
|
+
if (event.key === 'ArrowDown' || event.key === 'ArrowUp') {
|
|
426
|
+
event.preventDefault()
|
|
427
|
+
binding.requestFocus(value, event.key === 'ArrowUp')
|
|
428
|
+
return
|
|
429
|
+
}
|
|
430
|
+
const keys = ['ArrowLeft', 'ArrowRight', 'Home', 'End']
|
|
431
|
+
if (!keys.includes(event.key)) return
|
|
432
|
+
const nodes = binding.items
|
|
433
|
+
.map(entry => binding.triggers.current.get(entry.value))
|
|
434
|
+
.filter(
|
|
435
|
+
(button): button is HTMLButtonElement =>
|
|
436
|
+
!!button && !button.disabled && button.getAttribute('aria-busy') !== 'true'
|
|
437
|
+
)
|
|
438
|
+
const current = nodes.indexOf(event.currentTarget)
|
|
439
|
+
if (current < 0) return
|
|
440
|
+
const rtl = node?.ownerDocument.defaultView?.getComputedStyle(node).direction === 'rtl',
|
|
441
|
+
delta = (event.key === 'ArrowRight' ? 1 : -1) * (rtl ? -1 : 1)
|
|
442
|
+
const next =
|
|
443
|
+
event.key === 'Home'
|
|
444
|
+
? nodes[0]
|
|
445
|
+
: event.key === 'End'
|
|
446
|
+
? nodes.at(-1)
|
|
447
|
+
: nodes[(current + delta + nodes.length) % nodes.length]
|
|
448
|
+
event.preventDefault()
|
|
449
|
+
next?.focus()
|
|
450
|
+
})}
|
|
451
|
+
/>
|
|
452
|
+
)
|
|
453
|
+
}
|
|
454
|
+
export type NavigationMenuLinkProps = Omit<ComposedLinkProps, 'aria-current'> & { active?: boolean }
|
|
455
|
+
export function NavigationMenuLink({
|
|
456
|
+
active = false,
|
|
457
|
+
onClick,
|
|
458
|
+
controlSize,
|
|
459
|
+
variant = 'subtle',
|
|
460
|
+
...props
|
|
461
|
+
}: NavigationMenuLinkProps) {
|
|
462
|
+
const binding = useBinding()
|
|
463
|
+
return (
|
|
464
|
+
<ComposedLink
|
|
465
|
+
{...props}
|
|
466
|
+
identity="navigation-menu-link"
|
|
467
|
+
variant={variant}
|
|
468
|
+
controlSize={controlSize ?? binding.controlSize}
|
|
469
|
+
aria-current={active ? 'page' : undefined}
|
|
470
|
+
onClick={composeAction(onClick, event => {
|
|
471
|
+
if (
|
|
472
|
+
event.button === 0 &&
|
|
473
|
+
!event.metaKey &&
|
|
474
|
+
!event.ctrlKey &&
|
|
475
|
+
!event.shiftKey &&
|
|
476
|
+
!event.altKey
|
|
477
|
+
)
|
|
478
|
+
binding.setValue(null)
|
|
479
|
+
})}
|
|
480
|
+
/>
|
|
481
|
+
)
|
|
482
|
+
}
|
|
483
|
+
export type NavigationMenuContentProps = Omit<
|
|
484
|
+
ComponentProps<'div'>,
|
|
485
|
+
'style' | 'role' | 'id' | 'hidden' | 'inert' | 'aria-labelledby'
|
|
486
|
+
> & { style?: ThemeStyle; value: string; 'data-slot'?: string }
|
|
487
|
+
export function NavigationMenuContent({
|
|
488
|
+
value,
|
|
489
|
+
ref,
|
|
490
|
+
className,
|
|
491
|
+
...props
|
|
492
|
+
}: NavigationMenuContentProps) {
|
|
493
|
+
const binding = useBinding()
|
|
494
|
+
const registerPanel = binding.registerPanel
|
|
495
|
+
item(binding, value)
|
|
496
|
+
const register = useCallback(
|
|
497
|
+
(node: HTMLDivElement | null) => {
|
|
498
|
+
registerPanel(value, node)
|
|
499
|
+
},
|
|
500
|
+
[registerPanel, value]
|
|
501
|
+
),
|
|
502
|
+
host = useComposedRefs(register, ref),
|
|
503
|
+
open = binding.visible === value
|
|
504
|
+
return (
|
|
505
|
+
<div
|
|
506
|
+
{...props}
|
|
507
|
+
ref={host}
|
|
508
|
+
id={binding.ids(value).panel}
|
|
509
|
+
{...{ 'aria-labelledby': undefined }}
|
|
510
|
+
hidden={!open}
|
|
511
|
+
inert={!open}
|
|
512
|
+
data-slot={joinIds('navigation-menu-content', props['data-slot'])}
|
|
513
|
+
data-state={open ? 'open' : 'closed'}
|
|
514
|
+
className={cn(
|
|
515
|
+
'box-border w-max max-w-[var(--_rad-navigation-menu-room,100vw)] p-[var(--rad-navigation-menu-padding,1rem)] [overflow-wrap:anywhere] [hidden]:hidden',
|
|
516
|
+
className
|
|
517
|
+
)}
|
|
518
|
+
/>
|
|
519
|
+
)
|
|
520
|
+
}
|
|
521
|
+
export type NavigationMenuViewportProps = Omit<
|
|
522
|
+
ComponentProps<'div'>,
|
|
523
|
+
| 'style'
|
|
524
|
+
| 'hidden'
|
|
525
|
+
| 'inert'
|
|
526
|
+
| 'role'
|
|
527
|
+
| 'aria-label'
|
|
528
|
+
| 'aria-labelledby'
|
|
529
|
+
| 'contentEditable'
|
|
530
|
+
| 'dangerouslySetInnerHTML'
|
|
531
|
+
> & { style?: ThemeStyle; motion?: 'inherit' | 'off'; sideOffset?: number; 'data-slot'?: string }
|
|
532
|
+
export function NavigationMenuViewport({
|
|
533
|
+
ref,
|
|
534
|
+
className,
|
|
535
|
+
motion = 'inherit',
|
|
536
|
+
sideOffset = 8,
|
|
537
|
+
onPointerEnter,
|
|
538
|
+
onPointerLeave,
|
|
539
|
+
onFocusCapture,
|
|
540
|
+
onBlurCapture,
|
|
541
|
+
...props
|
|
542
|
+
}: NavigationMenuViewportProps) {
|
|
543
|
+
const binding = useBinding(),
|
|
544
|
+
node = useRef<HTMLDivElement>(null),
|
|
545
|
+
localHost = useComposedRefs(node, ref),
|
|
546
|
+
host = useComposedRefs(binding.viewport, localHost),
|
|
547
|
+
{ ref: motionRef } = useTransitionHost('indicator', host, motion === 'off'),
|
|
548
|
+
open = binding.visible !== null
|
|
549
|
+
if (!Number.isFinite(sideOffset) || sideOffset < 0)
|
|
550
|
+
throw new TypeError('NavigationMenu sideOffset must be finite and nonnegative.')
|
|
551
|
+
useLayoutEffect(() => {
|
|
552
|
+
const viewport = node.current,
|
|
553
|
+
root =
|
|
554
|
+
binding.root.current ?? viewport?.closest<HTMLElement>('[data-slot~="navigation-menu"]')
|
|
555
|
+
if (!viewport || !root) return
|
|
556
|
+
const view = root.ownerDocument.defaultView!,
|
|
557
|
+
panel = binding.visible === null ? undefined : binding.panels.current.get(binding.visible),
|
|
558
|
+
trigger = binding.visible === null ? undefined : binding.triggers.current.get(binding.visible)
|
|
559
|
+
if (!open || !panel || !trigger) {
|
|
560
|
+
viewport.removeAttribute('data-rad-indicator-target')
|
|
561
|
+
return
|
|
562
|
+
}
|
|
563
|
+
const measure = () => {
|
|
564
|
+
const border = view.getComputedStyle(viewport),
|
|
565
|
+
inlineBorder = parseFloat(border.borderLeftWidth) + parseFloat(border.borderRightWidth),
|
|
566
|
+
blockBorder = parseFloat(border.borderTopWidth) + parseFloat(border.borderBottomWidth)
|
|
567
|
+
viewport.style.setProperty(
|
|
568
|
+
'--_rad-navigation-menu-room',
|
|
569
|
+
`${Math.max(0, root.clientWidth - inlineBorder - 24)}px`
|
|
570
|
+
)
|
|
571
|
+
const width = panel.offsetWidth + inlineBorder + 24,
|
|
572
|
+
height = panel.offsetHeight + blockBorder + 24,
|
|
573
|
+
rect = root.getBoundingClientRect(),
|
|
574
|
+
anchor = trigger.getBoundingClientRect(),
|
|
575
|
+
scale = root.offsetWidth ? rect.width / root.offsetWidth : 1,
|
|
576
|
+
rtl = view.getComputedStyle(root).direction === 'rtl'
|
|
577
|
+
const start =
|
|
578
|
+
(rtl ? anchor.right - rect.left : anchor.left - rect.left) / scale -
|
|
579
|
+
root.clientLeft -
|
|
580
|
+
(rtl ? width : 0)
|
|
581
|
+
const target = [
|
|
582
|
+
Math.max(0, Math.min(root.clientWidth - width, start)),
|
|
583
|
+
sideOffset,
|
|
584
|
+
width,
|
|
585
|
+
height
|
|
586
|
+
]
|
|
587
|
+
for (const [index, axis] of ['x', 'y', 'width', 'height'].entries())
|
|
588
|
+
viewport.style.setProperty(`--_rad-indicator-target-${axis}`, `${target[index]}px`)
|
|
589
|
+
const serialized = JSON.stringify(target)
|
|
590
|
+
if (viewport.getAttribute('data-rad-indicator-target') !== serialized)
|
|
591
|
+
viewport.setAttribute('data-rad-indicator-target', serialized)
|
|
592
|
+
}
|
|
593
|
+
let frame = 0
|
|
594
|
+
const schedule = () => {
|
|
595
|
+
if (!frame)
|
|
596
|
+
frame = view.requestAnimationFrame(() => {
|
|
597
|
+
frame = 0
|
|
598
|
+
measure()
|
|
599
|
+
})
|
|
600
|
+
}
|
|
601
|
+
const resize = new view.ResizeObserver(schedule)
|
|
602
|
+
;[root, panel, trigger].forEach(element => resize.observe(element))
|
|
603
|
+
const changes = new view.MutationObserver(schedule)
|
|
604
|
+
for (let ancestor: HTMLElement | null = root; ancestor; ancestor = ancestor.parentElement)
|
|
605
|
+
changes.observe(ancestor, { attributes: true, attributeFilter: ['dir', 'class', 'style'] })
|
|
606
|
+
measure()
|
|
607
|
+
view.addEventListener('resize', schedule)
|
|
608
|
+
root.ownerDocument.fonts?.addEventListener('loadingdone', schedule)
|
|
609
|
+
return () => {
|
|
610
|
+
resize.disconnect()
|
|
611
|
+
changes.disconnect()
|
|
612
|
+
view.cancelAnimationFrame(frame)
|
|
613
|
+
view.removeEventListener('resize', schedule)
|
|
614
|
+
root.ownerDocument.fonts?.removeEventListener('loadingdone', schedule)
|
|
615
|
+
}
|
|
616
|
+
})
|
|
617
|
+
const hover = () =>
|
|
618
|
+
binding.value === null ? undefined : binding.hover.current.get(binding.value)
|
|
619
|
+
return (
|
|
620
|
+
<ScrollArea
|
|
621
|
+
{...props}
|
|
622
|
+
ref={motionRef}
|
|
623
|
+
aria-label="Navigation sections"
|
|
624
|
+
aria-labelledby={binding.visible === null ? undefined : binding.ids(binding.visible).trigger}
|
|
625
|
+
hidden={!open}
|
|
626
|
+
inert={!open}
|
|
627
|
+
data-slot={joinIds('navigation-menu-viewport', props['data-slot'])}
|
|
628
|
+
data-state={open ? 'open' : 'closed'}
|
|
629
|
+
data-motion={motion}
|
|
630
|
+
className={cn(
|
|
631
|
+
'absolute top-full left-0 z-20 box-border overflow-auto [translate:var(--_rad-indicator-x,var(--_rad-indicator-target-x,0px))_var(--_rad-indicator-y,var(--_rad-indicator-target-y,0px))] w-[var(--_rad-indicator-width,var(--_rad-indicator-target-width,max-content))] h-[var(--_rad-indicator-height,var(--_rad-indicator-target-height,auto))] max-h-[min(70vh,30rem)] rounded-[var(--rad-navigation-menu-radius,var(--rad-surface-radius,0.75rem))] border-[length:var(--rad-navigation-menu-border-width,var(--rad-border-width,1px))] border-solid border-[var(--rad-navigation-menu-border-color,var(--rad-color-border))] bg-[var(--rad-navigation-menu-background,var(--rad-color-surface))] text-[var(--rad-navigation-menu-color,var(--rad-color-foreground))] [box-shadow:var(--rad-navigation-menu-shadow,var(--rad-surface-shadow,0_4px_16px_#0002))] [hidden]:hidden forced-colors:bg-[Canvas] forced-colors:text-[CanvasText] forced-colors:border-[CanvasText]',
|
|
632
|
+
className
|
|
633
|
+
)}
|
|
634
|
+
onPointerEnter={composeAction(onPointerEnter, event => {
|
|
635
|
+
if (event.pointerType !== 'touch') hover()?.enter()
|
|
636
|
+
})}
|
|
637
|
+
onPointerLeave={composeAction(onPointerLeave, event => {
|
|
638
|
+
if (event.pointerType !== 'touch') hover()?.leave()
|
|
639
|
+
})}
|
|
640
|
+
onFocusCapture={event => {
|
|
641
|
+
onFocusCapture?.(event)
|
|
642
|
+
hover()?.enter(true)
|
|
643
|
+
}}
|
|
644
|
+
onBlurCapture={event => {
|
|
645
|
+
onBlurCapture?.(event)
|
|
646
|
+
if (!event.currentTarget.contains(event.relatedTarget)) hover()?.leave(true)
|
|
647
|
+
}}
|
|
648
|
+
/>
|
|
649
|
+
)
|
|
650
|
+
}
|
package/src/Popover.tsx
CHANGED
|
@@ -103,7 +103,7 @@ export function PopoverRoot({
|
|
|
103
103
|
}
|
|
104
104
|
|
|
105
105
|
export type PopoverTriggerProps = WithoutToggle<ButtonProps>
|
|
106
|
-
export type PopoverCloseProps = ButtonProps
|
|
106
|
+
export type PopoverCloseProps = WithoutToggle<ButtonProps>
|
|
107
107
|
export type PopoverRenderProps = ButtonRenderProps
|
|
108
108
|
export type PopoverPortalProps = { children?: ReactNode }
|
|
109
109
|
export type PopoverContentProps = Omit<ComponentProps<'div'>, 'style' | 'popover' | 'id'> & {
|
|
@@ -158,6 +158,10 @@ export function PopoverCloseRoot({
|
|
|
158
158
|
return (
|
|
159
159
|
<Button
|
|
160
160
|
{...props}
|
|
161
|
+
pressed={undefined}
|
|
162
|
+
defaultPressed={undefined}
|
|
163
|
+
onPressedChange={undefined}
|
|
164
|
+
aria-pressed={undefined}
|
|
161
165
|
popoverTarget={undefined}
|
|
162
166
|
popoverTargetAction={undefined}
|
|
163
167
|
data-slot={joinIds('popover-close', props['data-slot'])}
|