@radix-ui/react-menubar 1.0.5-rc.9 → 1.1.0-rc.2
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/dist/index.d.mts +89 -77
- package/dist/index.d.ts +89 -77
- package/dist/index.js +435 -522
- package/dist/index.js.map +7 -1
- package/dist/index.mjs +437 -477
- package/dist/index.mjs.map +7 -1
- package/package.json +11 -12
- package/dist/index.d.ts.map +0 -1
package/dist/index.mjs
CHANGED
|
@@ -1,508 +1,468 @@
|
|
|
1
|
-
|
|
2
|
-
import {forwardRef as $jLgaT$forwardRef, useState as $jLgaT$useState, createElement as $jLgaT$createElement, useCallback as $jLgaT$useCallback, useRef as $jLgaT$useRef, useEffect as $jLgaT$useEffect} from "react";
|
|
3
|
-
import {createCollection as $jLgaT$createCollection} from "@radix-ui/react-collection";
|
|
4
|
-
import {useDirection as $jLgaT$useDirection} from "@radix-ui/react-direction";
|
|
5
|
-
import {composeEventHandlers as $jLgaT$composeEventHandlers} from "@radix-ui/primitive";
|
|
6
|
-
import {useComposedRefs as $jLgaT$useComposedRefs} from "@radix-ui/react-compose-refs";
|
|
7
|
-
import {createContextScope as $jLgaT$createContextScope} from "@radix-ui/react-context";
|
|
8
|
-
import {useId as $jLgaT$useId} from "@radix-ui/react-id";
|
|
9
|
-
import {createMenuScope as $jLgaT$createMenuScope, Root as $jLgaT$Root, Anchor as $jLgaT$Anchor, Portal as $jLgaT$Portal, Content as $jLgaT$Content, Group as $jLgaT$Group, Label as $jLgaT$Label, Item as $jLgaT$Item, CheckboxItem as $jLgaT$CheckboxItem, RadioGroup as $jLgaT$RadioGroup, RadioItem as $jLgaT$RadioItem, ItemIndicator as $jLgaT$ItemIndicator, Separator as $jLgaT$Separator, Arrow as $jLgaT$Arrow, Sub as $jLgaT$Sub, SubTrigger as $jLgaT$SubTrigger, SubContent as $jLgaT$SubContent} from "@radix-ui/react-menu";
|
|
10
|
-
import {createRovingFocusGroupScope as $jLgaT$createRovingFocusGroupScope, Root as $jLgaT$Root1, Item as $jLgaT$Item1} from "@radix-ui/react-roving-focus";
|
|
11
|
-
import {Primitive as $jLgaT$Primitive} from "@radix-ui/react-primitive";
|
|
12
|
-
import {useControllableState as $jLgaT$useControllableState} from "@radix-ui/react-use-controllable-state";
|
|
1
|
+
"use client";
|
|
13
2
|
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
$jLgaT$createRovingFocusGroupScope
|
|
3
|
+
// packages/react/menubar/src/Menubar.tsx
|
|
4
|
+
import * as React from "react";
|
|
5
|
+
import { createCollection } from "@radix-ui/react-collection";
|
|
6
|
+
import { useDirection } from "@radix-ui/react-direction";
|
|
7
|
+
import { composeEventHandlers } from "@radix-ui/primitive";
|
|
8
|
+
import { useComposedRefs } from "@radix-ui/react-compose-refs";
|
|
9
|
+
import { createContextScope } from "@radix-ui/react-context";
|
|
10
|
+
import { useId } from "@radix-ui/react-id";
|
|
11
|
+
import * as MenuPrimitive from "@radix-ui/react-menu";
|
|
12
|
+
import { createMenuScope } from "@radix-ui/react-menu";
|
|
13
|
+
import * as RovingFocusGroup from "@radix-ui/react-roving-focus";
|
|
14
|
+
import { createRovingFocusGroupScope } from "@radix-ui/react-roving-focus";
|
|
15
|
+
import { Primitive } from "@radix-ui/react-primitive";
|
|
16
|
+
import { useControllableState } from "@radix-ui/react-use-controllable-state";
|
|
17
|
+
import { jsx } from "react/jsx-runtime";
|
|
18
|
+
var MENUBAR_NAME = "Menubar";
|
|
19
|
+
var [Collection, useCollection, createCollectionScope] = createCollection(MENUBAR_NAME);
|
|
20
|
+
var [createMenubarContext, createMenubarScope] = createContextScope(MENUBAR_NAME, [
|
|
21
|
+
createCollectionScope,
|
|
22
|
+
createRovingFocusGroupScope
|
|
35
23
|
]);
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
const
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
|
|
50
|
-
const
|
|
51
|
-
|
|
24
|
+
var useMenuScope = createMenuScope();
|
|
25
|
+
var useRovingFocusGroupScope = createRovingFocusGroupScope();
|
|
26
|
+
var [MenubarContextProvider, useMenubarContext] = createMenubarContext(MENUBAR_NAME);
|
|
27
|
+
var Menubar = React.forwardRef(
|
|
28
|
+
(props, forwardedRef) => {
|
|
29
|
+
const {
|
|
30
|
+
__scopeMenubar,
|
|
31
|
+
value: valueProp,
|
|
32
|
+
onValueChange,
|
|
33
|
+
defaultValue,
|
|
34
|
+
loop = true,
|
|
35
|
+
dir,
|
|
36
|
+
...menubarProps
|
|
37
|
+
} = props;
|
|
38
|
+
const direction = useDirection(dir);
|
|
39
|
+
const rovingFocusGroupScope = useRovingFocusGroupScope(__scopeMenubar);
|
|
40
|
+
const [value = "", setValue] = useControllableState({
|
|
41
|
+
prop: valueProp,
|
|
42
|
+
onChange: onValueChange,
|
|
43
|
+
defaultProp: defaultValue
|
|
44
|
+
});
|
|
45
|
+
const [currentTabStopId, setCurrentTabStopId] = React.useState(null);
|
|
46
|
+
return /* @__PURE__ */ jsx(
|
|
47
|
+
MenubarContextProvider,
|
|
48
|
+
{
|
|
52
49
|
scope: __scopeMenubar,
|
|
53
|
-
value
|
|
54
|
-
onMenuOpen:
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
|
|
61
|
-
, [
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
}, [
|
|
70
|
-
setValue
|
|
71
|
-
]),
|
|
72
|
-
dir: direction,
|
|
73
|
-
loop: loop
|
|
74
|
-
}, /*#__PURE__*/ $jLgaT$createElement($0520064cdfc1bd2d$var$Collection.Provider, {
|
|
75
|
-
scope: __scopeMenubar
|
|
76
|
-
}, /*#__PURE__*/ $jLgaT$createElement($0520064cdfc1bd2d$var$Collection.Slot, {
|
|
77
|
-
scope: __scopeMenubar
|
|
78
|
-
}, /*#__PURE__*/ $jLgaT$createElement($jLgaT$Root1, $jLgaT$babelruntimehelpersesmextends({
|
|
79
|
-
asChild: true
|
|
80
|
-
}, rovingFocusGroupScope, {
|
|
81
|
-
orientation: "horizontal",
|
|
82
|
-
loop: loop,
|
|
50
|
+
value,
|
|
51
|
+
onMenuOpen: React.useCallback(
|
|
52
|
+
(value2) => {
|
|
53
|
+
setValue(value2);
|
|
54
|
+
setCurrentTabStopId(value2);
|
|
55
|
+
},
|
|
56
|
+
[setValue]
|
|
57
|
+
),
|
|
58
|
+
onMenuClose: React.useCallback(() => setValue(""), [setValue]),
|
|
59
|
+
onMenuToggle: React.useCallback(
|
|
60
|
+
(value2) => {
|
|
61
|
+
setValue((prevValue) => Boolean(prevValue) ? "" : value2);
|
|
62
|
+
setCurrentTabStopId(value2);
|
|
63
|
+
},
|
|
64
|
+
[setValue]
|
|
65
|
+
),
|
|
83
66
|
dir: direction,
|
|
84
|
-
|
|
85
|
-
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
|
|
95
|
-
/*
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
|
|
102
|
-
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
|
|
109
|
-
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
|
|
67
|
+
loop,
|
|
68
|
+
children: /* @__PURE__ */ jsx(Collection.Provider, { scope: __scopeMenubar, children: /* @__PURE__ */ jsx(Collection.Slot, { scope: __scopeMenubar, children: /* @__PURE__ */ jsx(
|
|
69
|
+
RovingFocusGroup.Root,
|
|
70
|
+
{
|
|
71
|
+
asChild: true,
|
|
72
|
+
...rovingFocusGroupScope,
|
|
73
|
+
orientation: "horizontal",
|
|
74
|
+
loop,
|
|
75
|
+
dir: direction,
|
|
76
|
+
currentTabStopId,
|
|
77
|
+
onCurrentTabStopIdChange: setCurrentTabStopId,
|
|
78
|
+
children: /* @__PURE__ */ jsx(Primitive.div, { role: "menubar", ...menubarProps, ref: forwardedRef })
|
|
79
|
+
}
|
|
80
|
+
) }) })
|
|
81
|
+
}
|
|
82
|
+
);
|
|
83
|
+
}
|
|
84
|
+
);
|
|
85
|
+
Menubar.displayName = MENUBAR_NAME;
|
|
86
|
+
var MENU_NAME = "MenubarMenu";
|
|
87
|
+
var [MenubarMenuProvider, useMenubarMenuContext] = createMenubarContext(MENU_NAME);
|
|
88
|
+
var MenubarMenu = (props) => {
|
|
89
|
+
const { __scopeMenubar, value: valueProp, ...menuProps } = props;
|
|
90
|
+
const autoValue = useId();
|
|
91
|
+
const value = valueProp || autoValue || "LEGACY_REACT_AUTO_VALUE";
|
|
92
|
+
const context = useMenubarContext(MENU_NAME, __scopeMenubar);
|
|
93
|
+
const menuScope = useMenuScope(__scopeMenubar);
|
|
94
|
+
const triggerRef = React.useRef(null);
|
|
95
|
+
const wasKeyboardTriggerOpenRef = React.useRef(false);
|
|
96
|
+
const open = context.value === value;
|
|
97
|
+
React.useEffect(() => {
|
|
98
|
+
if (!open) wasKeyboardTriggerOpenRef.current = false;
|
|
99
|
+
}, [open]);
|
|
100
|
+
return /* @__PURE__ */ jsx(
|
|
101
|
+
MenubarMenuProvider,
|
|
102
|
+
{
|
|
103
|
+
scope: __scopeMenubar,
|
|
104
|
+
value,
|
|
105
|
+
triggerId: useId(),
|
|
106
|
+
triggerRef,
|
|
107
|
+
contentId: useId(),
|
|
108
|
+
wasKeyboardTriggerOpenRef,
|
|
109
|
+
children: /* @__PURE__ */ jsx(
|
|
110
|
+
MenuPrimitive.Root,
|
|
111
|
+
{
|
|
112
|
+
...menuScope,
|
|
113
|
+
open,
|
|
114
|
+
onOpenChange: (open2) => {
|
|
115
|
+
if (!open2) context.onMenuClose();
|
|
116
|
+
},
|
|
117
|
+
modal: false,
|
|
118
|
+
dir: context.dir,
|
|
119
|
+
...menuProps
|
|
120
|
+
}
|
|
121
|
+
)
|
|
122
|
+
}
|
|
123
|
+
);
|
|
131
124
|
};
|
|
132
|
-
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
|
|
136
|
-
|
|
137
|
-
|
|
138
|
-
const
|
|
139
|
-
const
|
|
140
|
-
const
|
|
141
|
-
const
|
|
142
|
-
const
|
|
143
|
-
const
|
|
144
|
-
const ref = $jLgaT$useRef(null);
|
|
145
|
-
const composedRefs = $jLgaT$useComposedRefs(forwardedRef, ref, menuContext.triggerRef);
|
|
146
|
-
const [isFocused, setIsFocused] = $jLgaT$useState(false);
|
|
125
|
+
MenubarMenu.displayName = MENU_NAME;
|
|
126
|
+
var TRIGGER_NAME = "MenubarTrigger";
|
|
127
|
+
var MenubarTrigger = React.forwardRef(
|
|
128
|
+
(props, forwardedRef) => {
|
|
129
|
+
const { __scopeMenubar, disabled = false, ...triggerProps } = props;
|
|
130
|
+
const rovingFocusGroupScope = useRovingFocusGroupScope(__scopeMenubar);
|
|
131
|
+
const menuScope = useMenuScope(__scopeMenubar);
|
|
132
|
+
const context = useMenubarContext(TRIGGER_NAME, __scopeMenubar);
|
|
133
|
+
const menuContext = useMenubarMenuContext(TRIGGER_NAME, __scopeMenubar);
|
|
134
|
+
const ref = React.useRef(null);
|
|
135
|
+
const composedRefs = useComposedRefs(forwardedRef, ref, menuContext.triggerRef);
|
|
136
|
+
const [isFocused, setIsFocused] = React.useState(false);
|
|
147
137
|
const open = context.value === menuContext.value;
|
|
148
|
-
return
|
|
149
|
-
|
|
150
|
-
|
|
151
|
-
|
|
152
|
-
|
|
153
|
-
asChild: true
|
|
154
|
-
}, rovingFocusGroupScope, {
|
|
138
|
+
return /* @__PURE__ */ jsx(Collection.ItemSlot, { scope: __scopeMenubar, value: menuContext.value, disabled, children: /* @__PURE__ */ jsx(
|
|
139
|
+
RovingFocusGroup.Item,
|
|
140
|
+
{
|
|
141
|
+
asChild: true,
|
|
142
|
+
...rovingFocusGroupScope,
|
|
155
143
|
focusable: !disabled,
|
|
156
|
-
tabStopId: menuContext.value
|
|
157
|
-
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
|
|
165
|
-
|
|
166
|
-
|
|
167
|
-
|
|
168
|
-
|
|
169
|
-
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
|
|
173
|
-
|
|
174
|
-
|
|
175
|
-
if (!disabled && event.button === 0 && event.ctrlKey === false) {
|
|
176
|
-
context.onMenuOpen(menuContext.value); // prevent trigger focusing when opening
|
|
177
|
-
// this allows the content to be given focus without competition
|
|
144
|
+
tabStopId: menuContext.value,
|
|
145
|
+
children: /* @__PURE__ */ jsx(MenuPrimitive.Anchor, { asChild: true, ...menuScope, children: /* @__PURE__ */ jsx(
|
|
146
|
+
Primitive.button,
|
|
147
|
+
{
|
|
148
|
+
type: "button",
|
|
149
|
+
role: "menuitem",
|
|
150
|
+
id: menuContext.triggerId,
|
|
151
|
+
"aria-haspopup": "menu",
|
|
152
|
+
"aria-expanded": open,
|
|
153
|
+
"aria-controls": open ? menuContext.contentId : void 0,
|
|
154
|
+
"data-highlighted": isFocused ? "" : void 0,
|
|
155
|
+
"data-state": open ? "open" : "closed",
|
|
156
|
+
"data-disabled": disabled ? "" : void 0,
|
|
157
|
+
disabled,
|
|
158
|
+
...triggerProps,
|
|
159
|
+
ref: composedRefs,
|
|
160
|
+
onPointerDown: composeEventHandlers(props.onPointerDown, (event) => {
|
|
161
|
+
if (!disabled && event.button === 0 && event.ctrlKey === false) {
|
|
162
|
+
context.onMenuOpen(menuContext.value);
|
|
178
163
|
if (!open) event.preventDefault();
|
|
179
|
-
|
|
180
|
-
|
|
181
|
-
|
|
182
|
-
|
|
183
|
-
|
|
184
|
-
var _ref$current;
|
|
164
|
+
}
|
|
165
|
+
}),
|
|
166
|
+
onPointerEnter: composeEventHandlers(props.onPointerEnter, () => {
|
|
167
|
+
const menubarOpen = Boolean(context.value);
|
|
168
|
+
if (menubarOpen && !open) {
|
|
185
169
|
context.onMenuOpen(menuContext.value);
|
|
186
|
-
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
|
|
190
|
-
|
|
191
|
-
|
|
192
|
-
|
|
193
|
-
|
|
194
|
-
].includes(event.key)) context.onMenuToggle(menuContext.value);
|
|
195
|
-
if (event.key === 'ArrowDown') context.onMenuOpen(menuContext.value); // prevent keydown from scrolling window / first focused item to execute
|
|
196
|
-
// that keydown (inadvertently closing the menu)
|
|
197
|
-
if ([
|
|
198
|
-
'Enter',
|
|
199
|
-
' ',
|
|
200
|
-
'ArrowDown'
|
|
201
|
-
].includes(event.key)) {
|
|
170
|
+
ref.current?.focus();
|
|
171
|
+
}
|
|
172
|
+
}),
|
|
173
|
+
onKeyDown: composeEventHandlers(props.onKeyDown, (event) => {
|
|
174
|
+
if (disabled) return;
|
|
175
|
+
if (["Enter", " "].includes(event.key)) context.onMenuToggle(menuContext.value);
|
|
176
|
+
if (event.key === "ArrowDown") context.onMenuOpen(menuContext.value);
|
|
177
|
+
if (["Enter", " ", "ArrowDown"].includes(event.key)) {
|
|
202
178
|
menuContext.wasKeyboardTriggerOpenRef.current = true;
|
|
203
179
|
event.preventDefault();
|
|
204
|
-
|
|
205
|
-
|
|
206
|
-
|
|
207
|
-
|
|
208
|
-
|
|
209
|
-
)
|
|
210
|
-
|
|
211
|
-
});
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
|
|
216
|
-
|
|
217
|
-
|
|
218
|
-
const
|
|
219
|
-
|
|
220
|
-
const menuScope = $0520064cdfc1bd2d$var$useMenuScope(__scopeMenubar);
|
|
221
|
-
return /*#__PURE__*/ $jLgaT$createElement($jLgaT$Portal, $jLgaT$babelruntimehelpersesmextends({}, menuScope, portalProps));
|
|
180
|
+
}
|
|
181
|
+
}),
|
|
182
|
+
onFocus: composeEventHandlers(props.onFocus, () => setIsFocused(true)),
|
|
183
|
+
onBlur: composeEventHandlers(props.onBlur, () => setIsFocused(false))
|
|
184
|
+
}
|
|
185
|
+
) })
|
|
186
|
+
}
|
|
187
|
+
) });
|
|
188
|
+
}
|
|
189
|
+
);
|
|
190
|
+
MenubarTrigger.displayName = TRIGGER_NAME;
|
|
191
|
+
var PORTAL_NAME = "MenubarPortal";
|
|
192
|
+
var MenubarPortal = (props) => {
|
|
193
|
+
const { __scopeMenubar, ...portalProps } = props;
|
|
194
|
+
const menuScope = useMenuScope(__scopeMenubar);
|
|
195
|
+
return /* @__PURE__ */ jsx(MenuPrimitive.Portal, { ...menuScope, ...portalProps });
|
|
222
196
|
};
|
|
223
|
-
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
|
|
228
|
-
|
|
229
|
-
const
|
|
230
|
-
const
|
|
231
|
-
const
|
|
232
|
-
const
|
|
233
|
-
|
|
234
|
-
|
|
235
|
-
|
|
236
|
-
return /*#__PURE__*/ $jLgaT$createElement($jLgaT$Content, $jLgaT$babelruntimehelpersesmextends({
|
|
197
|
+
MenubarPortal.displayName = PORTAL_NAME;
|
|
198
|
+
var CONTENT_NAME = "MenubarContent";
|
|
199
|
+
var MenubarContent = React.forwardRef(
|
|
200
|
+
(props, forwardedRef) => {
|
|
201
|
+
const { __scopeMenubar, align = "start", ...contentProps } = props;
|
|
202
|
+
const menuScope = useMenuScope(__scopeMenubar);
|
|
203
|
+
const context = useMenubarContext(CONTENT_NAME, __scopeMenubar);
|
|
204
|
+
const menuContext = useMenubarMenuContext(CONTENT_NAME, __scopeMenubar);
|
|
205
|
+
const getItems = useCollection(__scopeMenubar);
|
|
206
|
+
const hasInteractedOutsideRef = React.useRef(false);
|
|
207
|
+
return /* @__PURE__ */ jsx(
|
|
208
|
+
MenuPrimitive.Content,
|
|
209
|
+
{
|
|
237
210
|
id: menuContext.contentId,
|
|
238
211
|
"aria-labelledby": menuContext.triggerId,
|
|
239
|
-
"data-radix-menubar-content": ""
|
|
240
|
-
|
|
212
|
+
"data-radix-menubar-content": "",
|
|
213
|
+
...menuScope,
|
|
214
|
+
...contentProps,
|
|
241
215
|
ref: forwardedRef,
|
|
242
|
-
align
|
|
243
|
-
onCloseAutoFocus:
|
|
244
|
-
|
|
245
|
-
|
|
246
|
-
|
|
247
|
-
|
|
248
|
-
|
|
249
|
-
|
|
250
|
-
event.preventDefault();
|
|
216
|
+
align,
|
|
217
|
+
onCloseAutoFocus: composeEventHandlers(props.onCloseAutoFocus, (event) => {
|
|
218
|
+
const menubarOpen = Boolean(context.value);
|
|
219
|
+
if (!menubarOpen && !hasInteractedOutsideRef.current) {
|
|
220
|
+
menuContext.triggerRef.current?.focus();
|
|
221
|
+
}
|
|
222
|
+
hasInteractedOutsideRef.current = false;
|
|
223
|
+
event.preventDefault();
|
|
251
224
|
}),
|
|
252
|
-
onFocusOutside:
|
|
253
|
-
|
|
254
|
-
|
|
255
|
-
|
|
256
|
-
return (_item$ref$current = item.ref.current) === null || _item$ref$current === void 0 ? void 0 : _item$ref$current.contains(target);
|
|
257
|
-
});
|
|
258
|
-
if (isMenubarTrigger) event.preventDefault();
|
|
225
|
+
onFocusOutside: composeEventHandlers(props.onFocusOutside, (event) => {
|
|
226
|
+
const target = event.target;
|
|
227
|
+
const isMenubarTrigger = getItems().some((item) => item.ref.current?.contains(target));
|
|
228
|
+
if (isMenubarTrigger) event.preventDefault();
|
|
259
229
|
}),
|
|
260
|
-
onInteractOutside:
|
|
261
|
-
|
|
230
|
+
onInteractOutside: composeEventHandlers(props.onInteractOutside, () => {
|
|
231
|
+
hasInteractedOutsideRef.current = true;
|
|
262
232
|
}),
|
|
263
|
-
onEntryFocus: (event)=>{
|
|
264
|
-
|
|
233
|
+
onEntryFocus: (event) => {
|
|
234
|
+
if (!menuContext.wasKeyboardTriggerOpenRef.current) event.preventDefault();
|
|
265
235
|
},
|
|
266
|
-
onKeyDown:
|
|
267
|
-
|
|
268
|
-
|
|
269
|
-
|
|
270
|
-
|
|
271
|
-
|
|
272
|
-
|
|
273
|
-
|
|
274
|
-
|
|
275
|
-
|
|
276
|
-
|
|
277
|
-
|
|
278
|
-
|
|
279
|
-
|
|
280
|
-
|
|
281
|
-
|
|
282
|
-
|
|
283
|
-
|
|
284
|
-
|
|
285
|
-
candidateValues = context.loop ? $0520064cdfc1bd2d$var$wrapArray(candidateValues, currentIndex + 1) : candidateValues.slice(currentIndex + 1);
|
|
286
|
-
const [nextValue] = candidateValues;
|
|
287
|
-
if (nextValue) context.onMenuOpen(nextValue);
|
|
236
|
+
onKeyDown: composeEventHandlers(
|
|
237
|
+
props.onKeyDown,
|
|
238
|
+
(event) => {
|
|
239
|
+
if (["ArrowRight", "ArrowLeft"].includes(event.key)) {
|
|
240
|
+
const target = event.target;
|
|
241
|
+
const targetIsSubTrigger = target.hasAttribute("data-radix-menubar-subtrigger");
|
|
242
|
+
const isKeyDownInsideSubMenu = target.closest("[data-radix-menubar-content]") !== event.currentTarget;
|
|
243
|
+
const prevMenuKey = context.dir === "rtl" ? "ArrowRight" : "ArrowLeft";
|
|
244
|
+
const isPrevKey = prevMenuKey === event.key;
|
|
245
|
+
const isNextKey = !isPrevKey;
|
|
246
|
+
if (isNextKey && targetIsSubTrigger) return;
|
|
247
|
+
if (isKeyDownInsideSubMenu && isPrevKey) return;
|
|
248
|
+
const items = getItems().filter((item) => !item.disabled);
|
|
249
|
+
let candidateValues = items.map((item) => item.value);
|
|
250
|
+
if (isPrevKey) candidateValues.reverse();
|
|
251
|
+
const currentIndex = candidateValues.indexOf(menuContext.value);
|
|
252
|
+
candidateValues = context.loop ? wrapArray(candidateValues, currentIndex + 1) : candidateValues.slice(currentIndex + 1);
|
|
253
|
+
const [nextValue] = candidateValues;
|
|
254
|
+
if (nextValue) context.onMenuOpen(nextValue);
|
|
288
255
|
}
|
|
289
|
-
|
|
290
|
-
|
|
291
|
-
|
|
256
|
+
},
|
|
257
|
+
{ checkForDefaultPrevented: false }
|
|
258
|
+
),
|
|
292
259
|
style: {
|
|
293
|
-
|
|
294
|
-
|
|
295
|
-
|
|
296
|
-
|
|
297
|
-
|
|
298
|
-
|
|
260
|
+
...props.style,
|
|
261
|
+
// re-namespace exposed content custom properties
|
|
262
|
+
...{
|
|
263
|
+
"--radix-menubar-content-transform-origin": "var(--radix-popper-transform-origin)",
|
|
264
|
+
"--radix-menubar-content-available-width": "var(--radix-popper-available-width)",
|
|
265
|
+
"--radix-menubar-content-available-height": "var(--radix-popper-available-height)",
|
|
266
|
+
"--radix-menubar-trigger-width": "var(--radix-popper-anchor-width)",
|
|
267
|
+
"--radix-menubar-trigger-height": "var(--radix-popper-anchor-height)"
|
|
268
|
+
}
|
|
299
269
|
}
|
|
300
|
-
|
|
301
|
-
|
|
302
|
-
|
|
303
|
-
|
|
304
|
-
|
|
305
|
-
|
|
306
|
-
|
|
307
|
-
|
|
308
|
-
const
|
|
309
|
-
const
|
|
310
|
-
|
|
311
|
-
|
|
312
|
-
|
|
313
|
-
|
|
314
|
-
|
|
315
|
-
|
|
316
|
-
|
|
317
|
-
}
|
|
318
|
-
|
|
319
|
-
|
|
320
|
-
|
|
321
|
-
|
|
322
|
-
|
|
323
|
-
|
|
324
|
-
|
|
325
|
-
|
|
326
|
-
}
|
|
327
|
-
|
|
328
|
-
|
|
329
|
-
|
|
330
|
-
|
|
331
|
-
|
|
332
|
-
|
|
333
|
-
|
|
334
|
-
|
|
335
|
-
const { __scopeMenubar
|
|
336
|
-
const menuScope =
|
|
337
|
-
return
|
|
338
|
-
|
|
339
|
-
|
|
340
|
-
|
|
341
|
-
|
|
342
|
-
|
|
343
|
-
|
|
344
|
-
|
|
345
|
-
|
|
346
|
-
|
|
347
|
-
|
|
348
|
-
|
|
349
|
-
|
|
350
|
-
|
|
351
|
-
|
|
352
|
-
|
|
353
|
-
}
|
|
354
|
-
|
|
355
|
-
|
|
356
|
-
}
|
|
357
|
-
|
|
358
|
-
|
|
359
|
-
|
|
360
|
-
|
|
361
|
-
|
|
362
|
-
|
|
363
|
-
|
|
364
|
-
ref: forwardedRef
|
|
365
|
-
}));
|
|
366
|
-
});
|
|
367
|
-
/*#__PURE__*/ Object.assign($0520064cdfc1bd2d$export$94dfa2322f330fdb, {
|
|
368
|
-
displayName: $0520064cdfc1bd2d$var$RADIO_GROUP_NAME
|
|
369
|
-
});
|
|
370
|
-
/* -------------------------------------------------------------------------------------------------
|
|
371
|
-
* MenubarRadioItem
|
|
372
|
-
* -----------------------------------------------------------------------------------------------*/ const $0520064cdfc1bd2d$var$RADIO_ITEM_NAME = 'MenubarRadioItem';
|
|
373
|
-
const $0520064cdfc1bd2d$export$7d2f467b4a7f68d8 = /*#__PURE__*/ $jLgaT$forwardRef((props, forwardedRef)=>{
|
|
374
|
-
const { __scopeMenubar: __scopeMenubar , ...radioItemProps } = props;
|
|
375
|
-
const menuScope = $0520064cdfc1bd2d$var$useMenuScope(__scopeMenubar);
|
|
376
|
-
return /*#__PURE__*/ $jLgaT$createElement($jLgaT$RadioItem, $jLgaT$babelruntimehelpersesmextends({}, menuScope, radioItemProps, {
|
|
377
|
-
ref: forwardedRef
|
|
378
|
-
}));
|
|
379
|
-
});
|
|
380
|
-
/*#__PURE__*/ Object.assign($0520064cdfc1bd2d$export$7d2f467b4a7f68d8, {
|
|
381
|
-
displayName: $0520064cdfc1bd2d$var$RADIO_ITEM_NAME
|
|
382
|
-
});
|
|
383
|
-
/* -------------------------------------------------------------------------------------------------
|
|
384
|
-
* MenubarItemIndicator
|
|
385
|
-
* -----------------------------------------------------------------------------------------------*/ const $0520064cdfc1bd2d$var$INDICATOR_NAME = 'MenubarItemIndicator';
|
|
386
|
-
const $0520064cdfc1bd2d$export$63e15a0e2af5a57 = /*#__PURE__*/ $jLgaT$forwardRef((props, forwardedRef)=>{
|
|
387
|
-
const { __scopeMenubar: __scopeMenubar , ...itemIndicatorProps } = props;
|
|
388
|
-
const menuScope = $0520064cdfc1bd2d$var$useMenuScope(__scopeMenubar);
|
|
389
|
-
return /*#__PURE__*/ $jLgaT$createElement($jLgaT$ItemIndicator, $jLgaT$babelruntimehelpersesmextends({}, menuScope, itemIndicatorProps, {
|
|
390
|
-
ref: forwardedRef
|
|
391
|
-
}));
|
|
392
|
-
});
|
|
393
|
-
/*#__PURE__*/ Object.assign($0520064cdfc1bd2d$export$63e15a0e2af5a57, {
|
|
394
|
-
displayName: $0520064cdfc1bd2d$var$INDICATOR_NAME
|
|
395
|
-
});
|
|
396
|
-
/* -------------------------------------------------------------------------------------------------
|
|
397
|
-
* MenubarSeparator
|
|
398
|
-
* -----------------------------------------------------------------------------------------------*/ const $0520064cdfc1bd2d$var$SEPARATOR_NAME = 'MenubarSeparator';
|
|
399
|
-
const $0520064cdfc1bd2d$export$588aef9e7b5183b5 = /*#__PURE__*/ $jLgaT$forwardRef((props, forwardedRef)=>{
|
|
400
|
-
const { __scopeMenubar: __scopeMenubar , ...separatorProps } = props;
|
|
401
|
-
const menuScope = $0520064cdfc1bd2d$var$useMenuScope(__scopeMenubar);
|
|
402
|
-
return /*#__PURE__*/ $jLgaT$createElement($jLgaT$Separator, $jLgaT$babelruntimehelpersesmextends({}, menuScope, separatorProps, {
|
|
403
|
-
ref: forwardedRef
|
|
404
|
-
}));
|
|
405
|
-
});
|
|
406
|
-
/*#__PURE__*/ Object.assign($0520064cdfc1bd2d$export$588aef9e7b5183b5, {
|
|
407
|
-
displayName: $0520064cdfc1bd2d$var$SEPARATOR_NAME
|
|
408
|
-
});
|
|
409
|
-
/* -------------------------------------------------------------------------------------------------
|
|
410
|
-
* MenubarArrow
|
|
411
|
-
* -----------------------------------------------------------------------------------------------*/ const $0520064cdfc1bd2d$var$ARROW_NAME = 'MenubarArrow';
|
|
412
|
-
const $0520064cdfc1bd2d$export$474b9891f5b9e633 = /*#__PURE__*/ $jLgaT$forwardRef((props, forwardedRef)=>{
|
|
413
|
-
const { __scopeMenubar: __scopeMenubar , ...arrowProps } = props;
|
|
414
|
-
const menuScope = $0520064cdfc1bd2d$var$useMenuScope(__scopeMenubar);
|
|
415
|
-
return /*#__PURE__*/ $jLgaT$createElement($jLgaT$Arrow, $jLgaT$babelruntimehelpersesmextends({}, menuScope, arrowProps, {
|
|
416
|
-
ref: forwardedRef
|
|
417
|
-
}));
|
|
418
|
-
});
|
|
419
|
-
/*#__PURE__*/ Object.assign($0520064cdfc1bd2d$export$474b9891f5b9e633, {
|
|
420
|
-
displayName: $0520064cdfc1bd2d$var$ARROW_NAME
|
|
270
|
+
}
|
|
271
|
+
);
|
|
272
|
+
}
|
|
273
|
+
);
|
|
274
|
+
MenubarContent.displayName = CONTENT_NAME;
|
|
275
|
+
var GROUP_NAME = "MenubarGroup";
|
|
276
|
+
var MenubarGroup = React.forwardRef(
|
|
277
|
+
(props, forwardedRef) => {
|
|
278
|
+
const { __scopeMenubar, ...groupProps } = props;
|
|
279
|
+
const menuScope = useMenuScope(__scopeMenubar);
|
|
280
|
+
return /* @__PURE__ */ jsx(MenuPrimitive.Group, { ...menuScope, ...groupProps, ref: forwardedRef });
|
|
281
|
+
}
|
|
282
|
+
);
|
|
283
|
+
MenubarGroup.displayName = GROUP_NAME;
|
|
284
|
+
var LABEL_NAME = "MenubarLabel";
|
|
285
|
+
var MenubarLabel = React.forwardRef(
|
|
286
|
+
(props, forwardedRef) => {
|
|
287
|
+
const { __scopeMenubar, ...labelProps } = props;
|
|
288
|
+
const menuScope = useMenuScope(__scopeMenubar);
|
|
289
|
+
return /* @__PURE__ */ jsx(MenuPrimitive.Label, { ...menuScope, ...labelProps, ref: forwardedRef });
|
|
290
|
+
}
|
|
291
|
+
);
|
|
292
|
+
MenubarLabel.displayName = LABEL_NAME;
|
|
293
|
+
var ITEM_NAME = "MenubarItem";
|
|
294
|
+
var MenubarItem = React.forwardRef(
|
|
295
|
+
(props, forwardedRef) => {
|
|
296
|
+
const { __scopeMenubar, ...itemProps } = props;
|
|
297
|
+
const menuScope = useMenuScope(__scopeMenubar);
|
|
298
|
+
return /* @__PURE__ */ jsx(MenuPrimitive.Item, { ...menuScope, ...itemProps, ref: forwardedRef });
|
|
299
|
+
}
|
|
300
|
+
);
|
|
301
|
+
MenubarItem.displayName = ITEM_NAME;
|
|
302
|
+
var CHECKBOX_ITEM_NAME = "MenubarCheckboxItem";
|
|
303
|
+
var MenubarCheckboxItem = React.forwardRef(
|
|
304
|
+
(props, forwardedRef) => {
|
|
305
|
+
const { __scopeMenubar, ...checkboxItemProps } = props;
|
|
306
|
+
const menuScope = useMenuScope(__scopeMenubar);
|
|
307
|
+
return /* @__PURE__ */ jsx(MenuPrimitive.CheckboxItem, { ...menuScope, ...checkboxItemProps, ref: forwardedRef });
|
|
308
|
+
}
|
|
309
|
+
);
|
|
310
|
+
MenubarCheckboxItem.displayName = CHECKBOX_ITEM_NAME;
|
|
311
|
+
var RADIO_GROUP_NAME = "MenubarRadioGroup";
|
|
312
|
+
var MenubarRadioGroup = React.forwardRef(
|
|
313
|
+
(props, forwardedRef) => {
|
|
314
|
+
const { __scopeMenubar, ...radioGroupProps } = props;
|
|
315
|
+
const menuScope = useMenuScope(__scopeMenubar);
|
|
316
|
+
return /* @__PURE__ */ jsx(MenuPrimitive.RadioGroup, { ...menuScope, ...radioGroupProps, ref: forwardedRef });
|
|
317
|
+
}
|
|
318
|
+
);
|
|
319
|
+
MenubarRadioGroup.displayName = RADIO_GROUP_NAME;
|
|
320
|
+
var RADIO_ITEM_NAME = "MenubarRadioItem";
|
|
321
|
+
var MenubarRadioItem = React.forwardRef(
|
|
322
|
+
(props, forwardedRef) => {
|
|
323
|
+
const { __scopeMenubar, ...radioItemProps } = props;
|
|
324
|
+
const menuScope = useMenuScope(__scopeMenubar);
|
|
325
|
+
return /* @__PURE__ */ jsx(MenuPrimitive.RadioItem, { ...menuScope, ...radioItemProps, ref: forwardedRef });
|
|
326
|
+
}
|
|
327
|
+
);
|
|
328
|
+
MenubarRadioItem.displayName = RADIO_ITEM_NAME;
|
|
329
|
+
var INDICATOR_NAME = "MenubarItemIndicator";
|
|
330
|
+
var MenubarItemIndicator = React.forwardRef((props, forwardedRef) => {
|
|
331
|
+
const { __scopeMenubar, ...itemIndicatorProps } = props;
|
|
332
|
+
const menuScope = useMenuScope(__scopeMenubar);
|
|
333
|
+
return /* @__PURE__ */ jsx(MenuPrimitive.ItemIndicator, { ...menuScope, ...itemIndicatorProps, ref: forwardedRef });
|
|
421
334
|
});
|
|
422
|
-
|
|
423
|
-
|
|
424
|
-
|
|
425
|
-
|
|
426
|
-
const { __scopeMenubar
|
|
427
|
-
const menuScope =
|
|
428
|
-
|
|
429
|
-
|
|
430
|
-
|
|
431
|
-
|
|
432
|
-
|
|
433
|
-
|
|
434
|
-
|
|
435
|
-
|
|
436
|
-
|
|
335
|
+
MenubarItemIndicator.displayName = INDICATOR_NAME;
|
|
336
|
+
var SEPARATOR_NAME = "MenubarSeparator";
|
|
337
|
+
var MenubarSeparator = React.forwardRef(
|
|
338
|
+
(props, forwardedRef) => {
|
|
339
|
+
const { __scopeMenubar, ...separatorProps } = props;
|
|
340
|
+
const menuScope = useMenuScope(__scopeMenubar);
|
|
341
|
+
return /* @__PURE__ */ jsx(MenuPrimitive.Separator, { ...menuScope, ...separatorProps, ref: forwardedRef });
|
|
342
|
+
}
|
|
343
|
+
);
|
|
344
|
+
MenubarSeparator.displayName = SEPARATOR_NAME;
|
|
345
|
+
var ARROW_NAME = "MenubarArrow";
|
|
346
|
+
var MenubarArrow = React.forwardRef(
|
|
347
|
+
(props, forwardedRef) => {
|
|
348
|
+
const { __scopeMenubar, ...arrowProps } = props;
|
|
349
|
+
const menuScope = useMenuScope(__scopeMenubar);
|
|
350
|
+
return /* @__PURE__ */ jsx(MenuPrimitive.Arrow, { ...menuScope, ...arrowProps, ref: forwardedRef });
|
|
351
|
+
}
|
|
352
|
+
);
|
|
353
|
+
MenubarArrow.displayName = ARROW_NAME;
|
|
354
|
+
var SUB_NAME = "MenubarSub";
|
|
355
|
+
var MenubarSub = (props) => {
|
|
356
|
+
const { __scopeMenubar, children, open: openProp, onOpenChange, defaultOpen } = props;
|
|
357
|
+
const menuScope = useMenuScope(__scopeMenubar);
|
|
358
|
+
const [open = false, setOpen] = useControllableState({
|
|
359
|
+
prop: openProp,
|
|
360
|
+
defaultProp: defaultOpen,
|
|
361
|
+
onChange: onOpenChange
|
|
362
|
+
});
|
|
363
|
+
return /* @__PURE__ */ jsx(MenuPrimitive.Sub, { ...menuScope, open, onOpenChange: setOpen, children });
|
|
437
364
|
};
|
|
438
|
-
|
|
439
|
-
|
|
440
|
-
|
|
441
|
-
|
|
442
|
-
|
|
443
|
-
|
|
444
|
-
|
|
445
|
-
|
|
446
|
-
|
|
447
|
-
|
|
448
|
-
|
|
449
|
-
|
|
365
|
+
MenubarSub.displayName = SUB_NAME;
|
|
366
|
+
var SUB_TRIGGER_NAME = "MenubarSubTrigger";
|
|
367
|
+
var MenubarSubTrigger = React.forwardRef(
|
|
368
|
+
(props, forwardedRef) => {
|
|
369
|
+
const { __scopeMenubar, ...subTriggerProps } = props;
|
|
370
|
+
const menuScope = useMenuScope(__scopeMenubar);
|
|
371
|
+
return /* @__PURE__ */ jsx(
|
|
372
|
+
MenuPrimitive.SubTrigger,
|
|
373
|
+
{
|
|
374
|
+
"data-radix-menubar-subtrigger": "",
|
|
375
|
+
...menuScope,
|
|
376
|
+
...subTriggerProps,
|
|
450
377
|
ref: forwardedRef
|
|
451
|
-
|
|
452
|
-
|
|
453
|
-
|
|
454
|
-
|
|
455
|
-
|
|
456
|
-
|
|
457
|
-
|
|
458
|
-
|
|
459
|
-
const
|
|
460
|
-
const
|
|
461
|
-
|
|
462
|
-
|
|
463
|
-
|
|
464
|
-
|
|
378
|
+
}
|
|
379
|
+
);
|
|
380
|
+
}
|
|
381
|
+
);
|
|
382
|
+
MenubarSubTrigger.displayName = SUB_TRIGGER_NAME;
|
|
383
|
+
var SUB_CONTENT_NAME = "MenubarSubContent";
|
|
384
|
+
var MenubarSubContent = React.forwardRef(
|
|
385
|
+
(props, forwardedRef) => {
|
|
386
|
+
const { __scopeMenubar, ...subContentProps } = props;
|
|
387
|
+
const menuScope = useMenuScope(__scopeMenubar);
|
|
388
|
+
return /* @__PURE__ */ jsx(
|
|
389
|
+
MenuPrimitive.SubContent,
|
|
390
|
+
{
|
|
391
|
+
...menuScope,
|
|
392
|
+
"data-radix-menubar-content": "",
|
|
393
|
+
...subContentProps,
|
|
465
394
|
ref: forwardedRef,
|
|
466
395
|
style: {
|
|
467
|
-
|
|
468
|
-
|
|
469
|
-
|
|
470
|
-
|
|
471
|
-
|
|
472
|
-
|
|
396
|
+
...props.style,
|
|
397
|
+
// re-namespace exposed content custom properties
|
|
398
|
+
...{
|
|
399
|
+
"--radix-menubar-content-transform-origin": "var(--radix-popper-transform-origin)",
|
|
400
|
+
"--radix-menubar-content-available-width": "var(--radix-popper-available-width)",
|
|
401
|
+
"--radix-menubar-content-available-height": "var(--radix-popper-available-height)",
|
|
402
|
+
"--radix-menubar-trigger-width": "var(--radix-popper-anchor-width)",
|
|
403
|
+
"--radix-menubar-trigger-height": "var(--radix-popper-anchor-height)"
|
|
404
|
+
}
|
|
473
405
|
}
|
|
474
|
-
|
|
475
|
-
});
|
|
476
|
-
/*#__PURE__*/ Object.assign($0520064cdfc1bd2d$export$1b21e255bb3e4f7f, {
|
|
477
|
-
displayName: $0520064cdfc1bd2d$var$SUB_CONTENT_NAME
|
|
478
|
-
});
|
|
479
|
-
/* -----------------------------------------------------------------------------------------------*/ /**
|
|
480
|
-
* Wraps an array around itself at a given start index
|
|
481
|
-
* Example: `wrapArray(['a', 'b', 'c', 'd'], 2) === ['c', 'd', 'a', 'b']`
|
|
482
|
-
*/ function $0520064cdfc1bd2d$var$wrapArray(array, startIndex) {
|
|
483
|
-
return array.map((_, index)=>array[(startIndex + index) % array.length]
|
|
406
|
+
}
|
|
484
407
|
);
|
|
408
|
+
}
|
|
409
|
+
);
|
|
410
|
+
MenubarSubContent.displayName = SUB_CONTENT_NAME;
|
|
411
|
+
function wrapArray(array, startIndex) {
|
|
412
|
+
return array.map((_, index) => array[(startIndex + index) % array.length]);
|
|
485
413
|
}
|
|
486
|
-
|
|
487
|
-
|
|
488
|
-
|
|
489
|
-
|
|
490
|
-
|
|
491
|
-
|
|
492
|
-
|
|
493
|
-
|
|
494
|
-
|
|
495
|
-
|
|
496
|
-
|
|
497
|
-
|
|
498
|
-
|
|
499
|
-
|
|
500
|
-
|
|
501
|
-
|
|
502
|
-
|
|
503
|
-
|
|
504
|
-
|
|
505
|
-
|
|
506
|
-
|
|
507
|
-
|
|
414
|
+
var Root3 = Menubar;
|
|
415
|
+
var Menu = MenubarMenu;
|
|
416
|
+
var Trigger = MenubarTrigger;
|
|
417
|
+
var Portal2 = MenubarPortal;
|
|
418
|
+
var Content2 = MenubarContent;
|
|
419
|
+
var Group2 = MenubarGroup;
|
|
420
|
+
var Label2 = MenubarLabel;
|
|
421
|
+
var Item3 = MenubarItem;
|
|
422
|
+
var CheckboxItem2 = MenubarCheckboxItem;
|
|
423
|
+
var RadioGroup2 = MenubarRadioGroup;
|
|
424
|
+
var RadioItem2 = MenubarRadioItem;
|
|
425
|
+
var ItemIndicator2 = MenubarItemIndicator;
|
|
426
|
+
var Separator2 = MenubarSeparator;
|
|
427
|
+
var Arrow2 = MenubarArrow;
|
|
428
|
+
var Sub2 = MenubarSub;
|
|
429
|
+
var SubTrigger2 = MenubarSubTrigger;
|
|
430
|
+
var SubContent2 = MenubarSubContent;
|
|
431
|
+
export {
|
|
432
|
+
Arrow2 as Arrow,
|
|
433
|
+
CheckboxItem2 as CheckboxItem,
|
|
434
|
+
Content2 as Content,
|
|
435
|
+
Group2 as Group,
|
|
436
|
+
Item3 as Item,
|
|
437
|
+
ItemIndicator2 as ItemIndicator,
|
|
438
|
+
Label2 as Label,
|
|
439
|
+
Menu,
|
|
440
|
+
Menubar,
|
|
441
|
+
MenubarArrow,
|
|
442
|
+
MenubarCheckboxItem,
|
|
443
|
+
MenubarContent,
|
|
444
|
+
MenubarGroup,
|
|
445
|
+
MenubarItem,
|
|
446
|
+
MenubarItemIndicator,
|
|
447
|
+
MenubarLabel,
|
|
448
|
+
MenubarMenu,
|
|
449
|
+
MenubarPortal,
|
|
450
|
+
MenubarRadioGroup,
|
|
451
|
+
MenubarRadioItem,
|
|
452
|
+
MenubarSeparator,
|
|
453
|
+
MenubarSub,
|
|
454
|
+
MenubarSubContent,
|
|
455
|
+
MenubarSubTrigger,
|
|
456
|
+
MenubarTrigger,
|
|
457
|
+
Portal2 as Portal,
|
|
458
|
+
RadioGroup2 as RadioGroup,
|
|
459
|
+
RadioItem2 as RadioItem,
|
|
460
|
+
Root3 as Root,
|
|
461
|
+
Separator2 as Separator,
|
|
462
|
+
Sub2 as Sub,
|
|
463
|
+
SubContent2 as SubContent,
|
|
464
|
+
SubTrigger2 as SubTrigger,
|
|
465
|
+
Trigger,
|
|
466
|
+
createMenubarScope
|
|
467
|
+
};
|
|
508
468
|
//# sourceMappingURL=index.mjs.map
|