@cognitap/radiant 0.0.63 → 0.0.64
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 +4 -0
- 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/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 +2 -0
- 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/NavigationMenu.tsx +650 -0
- package/src/cn.ts +5 -0
- package/src/index.ts +24 -0
- 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/cn.ts
CHANGED
|
@@ -113,6 +113,7 @@ export const cn: CnFunction = createCn({
|
|
|
113
113
|
],
|
|
114
114
|
mb: ['mb-(--rad-multi-select-gap)', 'mb-(--rad-fieldset-gap)'],
|
|
115
115
|
gap: [
|
|
116
|
+
'gap-(--rad-navigation-menu-gap)',
|
|
116
117
|
'gap-(--rad-code-block-header-gap)',
|
|
117
118
|
'gap-(--rad-empty-state-gap)',
|
|
118
119
|
'gap-(--rad-empty-state-actions-gap)',
|
|
@@ -168,6 +169,7 @@ export const cn: CnFunction = createCn({
|
|
|
168
169
|
'px-(--rad-tabs-trigger-padding)'
|
|
169
170
|
],
|
|
170
171
|
p: [
|
|
172
|
+
'p-(--rad-navigation-menu-padding)',
|
|
171
173
|
'p-(--rad-code-block-padding)',
|
|
172
174
|
'p-(--rad-code-block-header-padding)',
|
|
173
175
|
'p-(--rad-empty-state-padding)',
|
|
@@ -186,6 +188,7 @@ export const cn: CnFunction = createCn({
|
|
|
186
188
|
'p-(--rad-tabs-content-padding)'
|
|
187
189
|
],
|
|
188
190
|
rounded: [
|
|
191
|
+
'rounded-(--rad-navigation-menu-radius)',
|
|
189
192
|
'rounded-(--rad-code-block-radius)',
|
|
190
193
|
'rounded-(--rad-inline-code-radius)',
|
|
191
194
|
'rounded-(--rad-empty-state-radius)',
|
|
@@ -228,6 +231,7 @@ export const cn: CnFunction = createCn({
|
|
|
228
231
|
'rounded-(--rad-tabs-content-radius)'
|
|
229
232
|
],
|
|
230
233
|
'border-w': [
|
|
234
|
+
'border-(--rad-navigation-menu-border-width)',
|
|
231
235
|
'border-(--rad-code-block-border-width)',
|
|
232
236
|
'border-(--rad-empty-state-border-width)',
|
|
233
237
|
'border-(--rad-meter-border-width)',
|
|
@@ -266,6 +270,7 @@ export const cn: CnFunction = createCn({
|
|
|
266
270
|
'border-(--rad-switch-border-style)'
|
|
267
271
|
],
|
|
268
272
|
shadow: [
|
|
273
|
+
'shadow-(--rad-navigation-menu-shadow)',
|
|
269
274
|
'shadow-(--_rad-native-select-shadow)',
|
|
270
275
|
'shadow-(--rad-native-select-shadow)',
|
|
271
276
|
'shadow-(--_rad-kbd-shadow)',
|