@burtson-labs/ui 0.13.1 → 0.14.1

package/dist/primitives/vendor/radix/react-focus-scope/focus-scope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"focus-scope.js","names":[],"sources":["../../../../../src/primitives/vendor/radix/react-focus-scope/focus-scope.tsx"],"sourcesContent":["// Vendored from Radix Primitives (c) 2022 WorkOS, MIT. See vendor/LICENSE.radix.\n// Local modification: package imports resolve to the pinned local source.\nimport * as React from 'react';\nimport { useComposedRefs } from '../react-compose-refs';\nimport { Primitive } from '../react-primitive';\nimport { useCallbackRef } from '../react-use-callback-ref';\n\nconst AUTOFOCUS_ON_MOUNT = 'focusScope.autoFocusOnMount';\nconst AUTOFOCUS_ON_UNMOUNT = 'focusScope.autoFocusOnUnmount';\nconst EVENT_OPTIONS = { bubbles: false, cancelable: true };\n\ntype FocusableTarget = HTMLElement | { focus(): void };\n\n/* -------------------------------------------------------------------------------------------------\n * FocusScope\n * -----------------------------------------------------------------------------------------------*/\n\ntype FocusScopeElement = React.ComponentRef<typeof Primitive.div>;\ntype PrimitiveDivProps = React.ComponentPropsWithoutRef<typeof Primitive.div>;\ninterface FocusScopeProps extends PrimitiveDivProps {\n  /**\n   * When `true`, tabbing from last item will focus first tabbable\n   * and shift+tab from first item will focus last tababble.\n   * @defaultValue false\n   */\n  loop?: boolean;\n\n  /**\n   * When `true`, focus cannot escape the focus scope via keyboard,\n   * pointer, or a programmatic focus.\n   * @defaultValue false\n   */\n  trapped?: boolean;\n\n  /**\n   * Event handler called when auto-focusing on mount.\n   * Can be prevented.\n   */\n  onMountAutoFocus?: (event: Event) => void;\n\n  /**\n   * Event handler called when auto-focusing on unmount.\n   * Can be prevented.\n   */\n  onUnmountAutoFocus?: (event: Event) => void;\n}\n\nconst FocusScope = /* @__PURE__ */ React.forwardRef<FocusScopeElement, FocusScopeProps>(\n  function FocusScope(props, forwardedRef) {\n    const {\n      loop = false,\n      trapped = false,\n      onMountAutoFocus: onMountAutoFocusProp,\n      onUnmountAutoFocus: onUnmountAutoFocusProp,\n      ...scopeProps\n    } = props;\n    const [container, setContainer] = React.useState<HTMLElement | null>(null);\n    const onMountAutoFocus = useCallbackRef(onMountAutoFocusProp);\n    const onUnmountAutoFocus = useCallbackRef(onUnmountAutoFocusProp);\n    const lastFocusedElementRef = React.useRef<HTMLElement | null>(null);\n    const composedRefs = useComposedRefs(forwardedRef, setContainer);\n\n    const focusScope = React.useRef({\n      paused: false,\n      pause() {\n        this.paused = true;\n      },\n      resume() {\n        this.paused = false;\n      },\n    }).current;\n\n    // Takes care of trapping focus if focus is moved outside programmatically for example\n    React.useEffect(() => {\n      if (trapped) {\n        function handleFocusIn(event: FocusEvent) {\n          if (focusScope.paused || !container) return;\n          const target = event.target as HTMLElement | null;\n          if (container.contains(target)) {\n            lastFocusedElementRef.current = target;\n          } else {\n            focus(lastFocusedElementRef.current, { select: true });\n          }\n        }\n\n        function handleFocusOut(event: FocusEvent) {\n          if (focusScope.paused || !container) return;\n          const relatedTarget = event.relatedTarget as HTMLElement | null;\n\n          // A `focusout` event with a `null` `relatedTarget` will happen in at least two cases:\n          //\n          // 1. When the user switches app/tabs/windows/the browser itself loses focus.\n          // 2. In Google Chrome, when the focused element is removed from the DOM.\n          //\n          // We let the browser do its thing here because:\n          //\n          // 1. The browser already keeps a memory of what's focused for when the page gets refocused.\n          // 2. In Google Chrome, if we try to focus the deleted focused element (as per below), it\n          //    throws the CPU to 100%, so we avoid doing anything for this reason here too.\n          if (relatedTarget === null) return;\n\n          // If the focus has moved to an actual legitimate element (`relatedTarget !== null`)\n          // that is outside the container, we move focus to the last valid focused element inside.\n          if (!container.contains(relatedTarget)) {\n            focus(lastFocusedElementRef.current, { select: true });\n          }\n        }\n\n        // When the focused element gets removed from the DOM, browsers move focus\n        // back to the document.body. In this case, we move focus to the container\n        // to keep focus trapped correctly.\n        function handleMutations(mutations: MutationRecord[]) {\n          const focusedElement = document.activeElement as HTMLElement | null;\n          if (focusedElement !== document.body) return;\n          for (const mutation of mutations) {\n            if (mutation.removedNodes.length > 0) focus(container);\n          }\n        }\n\n        document.addEventListener('focusin', handleFocusIn);\n        document.addEventListener('focusout', handleFocusOut);\n        const mutationObserver = new MutationObserver(handleMutations);\n        if (container) mutationObserver.observe(container, { childList: true, subtree: true });\n\n        return () => {\n          document.removeEventListener('focusin', handleFocusIn);\n          document.removeEventListener('focusout', handleFocusOut);\n          mutationObserver.disconnect();\n        };\n      }\n    }, [trapped, container, focusScope.paused]);\n\n    React.useEffect(() => {\n      if (container) {\n        focusScopesStack.add(focusScope);\n        const previouslyFocusedElement = document.activeElement as HTMLElement | null;\n        const hasFocusedCandidate = container.contains(previouslyFocusedElement);\n\n        if (!hasFocusedCandidate) {\n          const mountEvent = new CustomEvent(AUTOFOCUS_ON_MOUNT, EVENT_OPTIONS);\n          container.addEventListener(AUTOFOCUS_ON_MOUNT, onMountAutoFocus);\n          container.dispatchEvent(mountEvent);\n          if (!mountEvent.defaultPrevented) {\n            focusFirst(removeLinks(getTabbableCandidates(container)), { select: true });\n            if (document.activeElement === previouslyFocusedElement) {\n              focus(container);\n            }\n          }\n        }\n\n        return () => {\n          container.removeEventListener(AUTOFOCUS_ON_MOUNT, onMountAutoFocus);\n\n          // We hit a react bug (fixed in v17) with focusing in unmount.\n          // We need to delay the focus a little to get around it for now.\n          // See: https://github.com/facebook/react/issues/17894\n          setTimeout(() => {\n            const unmountEvent = new CustomEvent(AUTOFOCUS_ON_UNMOUNT, EVENT_OPTIONS);\n            container.addEventListener(AUTOFOCUS_ON_UNMOUNT, onUnmountAutoFocus);\n            container.dispatchEvent(unmountEvent);\n            if (!unmountEvent.defaultPrevented) {\n              focus(previouslyFocusedElement ?? document.body, { select: true });\n            }\n            // we need to remove the listener after we `dispatchEvent`\n            container.removeEventListener(AUTOFOCUS_ON_UNMOUNT, onUnmountAutoFocus);\n\n            focusScopesStack.remove(focusScope);\n          }, 0);\n        };\n      }\n    }, [container, onMountAutoFocus, onUnmountAutoFocus, focusScope]);\n\n    // Takes care of looping focus (when tabbing whilst at the edges)\n    const handleKeyDown = React.useCallback(\n      (event: React.KeyboardEvent) => {\n        if (!loop && !trapped) return;\n        if (focusScope.paused) return;\n\n        const isTabKey = event.key === 'Tab' && !event.altKey && !event.ctrlKey && !event.metaKey;\n        const focusedElement = document.activeElement as HTMLElement | null;\n\n        if (isTabKey && focusedElement) {\n          const container = event.currentTarget as HTMLElement;\n          const [first, last] = getTabbableEdges(container);\n          const hasTabbableElementsInside = first && last;\n\n          // we can only wrap focus if we have tabbable edges\n          if (!hasTabbableElementsInside) {\n            if (focusedElement === container) event.preventDefault();\n          } else {\n            if (!event.shiftKey && focusedElement === last) {\n              event.preventDefault();\n              if (loop) focus(first, { select: true });\n            } else if (event.shiftKey && focusedElement === first) {\n              event.preventDefault();\n              if (loop) focus(last, { select: true });\n            }\n          }\n        }\n      },\n      [loop, trapped, focusScope.paused],\n    );\n\n    return (\n      <Primitive.div tabIndex={-1} {...scopeProps} ref={composedRefs} onKeyDown={handleKeyDown} />\n    );\n  },\n);\n\n/* -------------------------------------------------------------------------------------------------\n * Utils\n * -----------------------------------------------------------------------------------------------*/\n\n/**\n * Attempts focusing the first element in a list of candidates.\n * Stops when focus has actually moved.\n */\nfunction focusFirst(candidates: HTMLElement[], { select = false } = {}) {\n  const previouslyFocusedElement = document.activeElement;\n  for (const candidate of candidates) {\n    focus(candidate, { select });\n    if (document.activeElement !== previouslyFocusedElement) return;\n  }\n}\n\n/**\n * Returns the first and last tabbable elements inside a container.\n */\nfunction getTabbableEdges(container: HTMLElement) {\n  const candidates = getTabbableCandidates(container);\n  const first = findVisible(candidates, container);\n  const last = findVisible(candidates.reverse(), container);\n  return [first, last] as const;\n}\n\n/**\n * Returns a list of potential tabbable candidates.\n *\n * NOTE: This is only a close approximation. For example it doesn't take into account cases like when\n * elements are not visible. This cannot be worked out easily by just reading a property, but rather\n * necessitate runtime knowledge (computed styles, etc). We deal with these cases separately.\n *\n * See: https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker\n * Credit: https://github.com/discord/focus-layers/blob/master/src/util/wrapFocus.tsx#L1\n */\nfunction getTabbableCandidates(container: HTMLElement) {\n  const nodes: HTMLElement[] = [];\n  const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, {\n    acceptNode: (node: any) => {\n      const isHiddenInput = node.tagName === 'INPUT' && node.type === 'hidden';\n      if (node.disabled || node.hidden || isHiddenInput) return NodeFilter.FILTER_SKIP;\n      // `.tabIndex` is not the same as the `tabindex` attribute. It works on the\n      // runtime's understanding of tabbability, so this automatically accounts\n      // for any kind of element that could be tabbed to.\n      return node.tabIndex >= 0 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;\n    },\n  });\n  while (walker.nextNode()) nodes.push(walker.currentNode as HTMLElement);\n  // we do not take into account the order of nodes with positive `tabIndex` as it\n  // hinders accessibility to have tab order different from visual order.\n  return nodes;\n}\n\n/**\n * Returns the first visible element in a list.\n * NOTE: Only checks visibility up to the `container`.\n */\nfunction findVisible(elements: HTMLElement[], container: HTMLElement) {\n  // `checkVisibility` performs a single native check for `visibility: hidden`\n  // and `display: none` across the ancestor chain. This avoids the repeated\n  // `getComputedStyle` calls per ancestor that the fallback path requires,\n  // which reduces the cost of style resolution triggered by earlier DOM writes\n  // (e.g. react-remove-scroll, DismissableLayer setting body styles).\n  const canUseCheckVisibility =\n    typeof container.checkVisibility === 'function' &&\n    container.checkVisibility({ checkVisibilityCSS: true });\n\n  for (const element of elements) {\n    const hidden = canUseCheckVisibility\n      ? !element.checkVisibility({ checkVisibilityCSS: true })\n      : isHidden(element, { upTo: container });\n    // we stop checking if it's hidden at the `container` level (excluding)\n    if (!hidden) {\n      return element;\n    }\n  }\n}\n\nfunction isHidden(node: HTMLElement, { upTo }: { upTo?: HTMLElement }) {\n  if (getComputedStyle(node).visibility === 'hidden') return true;\n  while (node) {\n    // we stop at `upTo` (excluding it)\n    if (upTo !== undefined && node === upTo) return false;\n    if (getComputedStyle(node).display === 'none') return true;\n    node = node.parentElement as HTMLElement;\n  }\n  return false;\n}\n\nfunction isSelectableInput(element: any): element is FocusableTarget & { select: () => void } {\n  return element instanceof HTMLInputElement && 'select' in element;\n}\n\nfunction focus(element?: FocusableTarget | null, { select = false } = {}) {\n  // only focus if that element is focusable\n  if (element && element.focus) {\n    const previouslyFocusedElement = document.activeElement;\n    // NOTE: we prevent scrolling on focus, to minimize jarring transitions for users\n    element.focus({ preventScroll: true });\n    // only select if its not the same element, it supports selection and we need to select\n    if (element !== previouslyFocusedElement && isSelectableInput(element) && select)\n      element.select();\n  }\n}\n\n/* -------------------------------------------------------------------------------------------------\n * FocusScope stack\n * -----------------------------------------------------------------------------------------------*/\n\ntype FocusScopeAPI = { paused: boolean; pause(): void; resume(): void };\nconst focusScopesStack = createFocusScopesStack();\n\nfunction createFocusScopesStack() {\n  /** A stack of focus scopes, with the active one at the top */\n  let stack: FocusScopeAPI[] = [];\n\n  return {\n    add(focusScope: FocusScopeAPI) {\n      // pause the currently active focus scope (at the top of the stack)\n      const activeFocusScope = stack[0];\n      if (focusScope !== activeFocusScope) {\n        activeFocusScope?.pause();\n      }\n      // remove in case it already exists (because we'll re-add it at the top of the stack)\n      stack = arrayRemove(stack, focusScope);\n      stack.unshift(focusScope);\n    },\n\n    remove(focusScope: FocusScopeAPI) {\n      stack = arrayRemove(stack, focusScope);\n      stack[0]?.resume();\n    },\n  };\n}\n\nfunction arrayRemove<T>(array: T[], item: T) {\n  const updatedArray = [...array];\n  const index = updatedArray.indexOf(item);\n  if (index !== -1) {\n    updatedArray.splice(index, 1);\n  }\n  return updatedArray;\n}\n\nfunction removeLinks(items: HTMLElement[]) {\n  return items.filter((item) => item.tagName !== 'A');\n}\n\nconst Root = FocusScope;\n\nexport {\n  FocusScope,\n  //\n  Root,\n};\nexport type { FocusScopeProps };\n"],"mappings":"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"}

package/dist/primitives/vendor/radix/react-focus-scope/index.d.ts

@@ -0,0 +1 @@
+export * from './focus-scope';

package/dist/primitives/vendor/radix/react-id/id.d.ts

@@ -0,0 +1,2 @@
+declare function useId(deterministicId?: string): string;
+export { useId };

package/dist/primitives/vendor/radix/react-id/id.js

@@ -0,0 +1,17 @@
+"use client";
+import { useLayoutEffect } from "../react-use-layout-effect/use-layout-effect.js";
+import * as React from "react";
+//#region src/primitives/vendor/radix/react-id/id.tsx
+var useReactId = React[" useId ".trim().toString()] || (() => void 0);
+var count = 0;
+function useId(deterministicId) {
+	const [id, setId] = React.useState(useReactId());
+	useLayoutEffect(() => {
+		if (!deterministicId) setId((reactId) => reactId ?? String(count++));
+	}, [deterministicId]);
+	return deterministicId || (id ? `radix-${id}` : "");
+}
+//#endregion
+export { useId };
+
+//# sourceMappingURL=id.js.map

package/dist/primitives/vendor/radix/react-id/id.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"id.js","names":[],"sources":["../../../../../src/primitives/vendor/radix/react-id/id.tsx"],"sourcesContent":["// Vendored from Radix Primitives (c) 2022 WorkOS, MIT. See vendor/LICENSE.radix.\n// Local modification: package imports resolve to the pinned local source.\nimport * as React from 'react';\nimport { useLayoutEffect } from '../react-use-layout-effect';\n\n// We spaces with `.trim().toString()` to prevent bundlers from trying to `import { useId } from 'react';`\nconst useReactId = (React as any)[' useId '.trim().toString()] || (() => undefined);\nlet count = 0;\n\nfunction useId(deterministicId?: string): string {\n  const [id, setId] = React.useState<string | undefined>(useReactId());\n  // React versions older than 18 will have client-side ids only.\n  useLayoutEffect(() => {\n    if (!deterministicId) setId((reactId) => reactId ?? String(count++));\n  }, [deterministicId]);\n  return deterministicId || (id ? `radix-${id}` : '');\n}\n\nexport { useId };\n"],"mappings":";;;;AAMA,IAAM,aAAc,MAAc,UAAU,KAAK,CAAC,CAAC,SAAS,aAAa,KAAA;AACzE,IAAI,QAAQ;AAEZ,SAAS,MAAM,iBAAkC;CAC/C,MAAM,CAAC,IAAI,SAAS,MAAM,SAA6B,WAAW,CAAC;CAEnE,sBAAsB;EACpB,IAAI,CAAC,iBAAiB,OAAO,YAAY,WAAW,OAAO,OAAO,CAAC;CACrE,GAAG,CAAC,eAAe,CAAC;CACpB,OAAO,oBAAoB,KAAK,SAAS,OAAO;AAClD"}

package/dist/primitives/vendor/radix/react-id/index.d.ts

@@ -0,0 +1 @@
+export { useId } from './id';

package/dist/primitives/vendor/radix/react-label/index.d.ts

@@ -0,0 +1,2 @@
+export { Label, Root, } from './label';
+export type { LabelProps } from './label';

package/dist/primitives/vendor/radix/react-label/label.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import { Primitive } from '../react-primitive';
+type PrimitiveLabelProps = React.ComponentPropsWithoutRef<typeof Primitive.label>;
+interface LabelProps extends PrimitiveLabelProps {
+}
+declare const Label: React.ForwardRefExoticComponent<LabelProps & React.RefAttributes<HTMLLabelElement>>;
+declare const Root: React.ForwardRefExoticComponent<LabelProps & React.RefAttributes<HTMLLabelElement>>;
+export { Label, Root, };
+export type { LabelProps };

package/dist/primitives/vendor/radix/react-label/label.js

@@ -0,0 +1,21 @@
+"use client";
+import { Primitive } from "../react-primitive/primitive.js";
+import * as React from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/primitives/vendor/radix/react-label/label.tsx
+var Label = /* @__PURE__ */ React.forwardRef(function Label(props, forwardedRef) {
+	return /* @__PURE__ */ jsx(Primitive.label, {
+		...props,
+		ref: forwardedRef,
+		onMouseDown: (event) => {
+			if (event.target.closest("button, input, select, textarea")) return;
+			props.onMouseDown?.(event);
+			if (!event.defaultPrevented && event.detail > 1) event.preventDefault();
+		}
+	});
+});
+var Root = Label;
+//#endregion
+export { Label, Root };
+
+//# sourceMappingURL=label.js.map

package/dist/primitives/vendor/radix/react-label/label.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"label.js","names":[],"sources":["../../../../../src/primitives/vendor/radix/react-label/label.tsx"],"sourcesContent":["// Vendored from Radix Primitives (c) 2022 WorkOS, MIT. See vendor/LICENSE.radix.\n// Local modification: package imports resolve to the pinned local source.\nimport * as React from 'react';\nimport { Primitive } from '../react-primitive';\n\n/* -------------------------------------------------------------------------------------------------\n * Label\n * -----------------------------------------------------------------------------------------------*/\n\ntype LabelElement = React.ComponentRef<typeof Primitive.label>;\ntype PrimitiveLabelProps = React.ComponentPropsWithoutRef<typeof Primitive.label>;\ninterface LabelProps extends PrimitiveLabelProps {}\n\nconst Label = /* @__PURE__ */ React.forwardRef<LabelElement, LabelProps>(\n  function Label(props, forwardedRef) {\n    return (\n      <Primitive.label\n        {...props}\n        ref={forwardedRef}\n        onMouseDown={(event) => {\n          // only prevent text selection if clicking inside the label itself\n          const target = event.target as HTMLElement;\n          if (target.closest('button, input, select, textarea')) return;\n\n          props.onMouseDown?.(event);\n          // prevent text selection when double clicking label\n          if (!event.defaultPrevented && event.detail > 1) event.preventDefault();\n        }}\n      />\n    );\n  },\n);\n\n/* -----------------------------------------------------------------------------------------------*/\n\nconst Root = Label;\n\nexport {\n  Label,\n  //\n  Root,\n};\nexport type { LabelProps };\n"],"mappings":";;;;;AAaA,IAAM,QAAwB,sBAAM,WAClC,SAAS,MAAM,OAAO,cAAc;CAClC,OACE,oBAAC,UAAU,OAAX;EACE,GAAI;EACJ,KAAK;EACL,cAAc,UAAU;GAGtB,IADe,MAAM,OACV,QAAQ,iCAAiC,GAAG;GAEvD,MAAM,cAAc,KAAK;GAEzB,IAAI,CAAC,MAAM,oBAAoB,MAAM,SAAS,GAAG,MAAM,eAAe;EACxE;CACD,CAAA;AAEL,CACF;AAIA,IAAM,OAAO"}

package/dist/primitives/vendor/radix/react-menu/index.d.ts

@@ -0,0 +1,2 @@
+export { createMenuScope, Menu, MenuAnchor, MenuPortal, MenuContent, MenuGroup, MenuLabel, MenuItem, MenuCheckboxItem, MenuRadioGroup, MenuRadioItem, MenuItemIndicator, MenuSeparator, MenuArrow, MenuSub, MenuSubTrigger, MenuSubContent, Root, Anchor, Portal, Content, Group, Label, Item, CheckboxItem, RadioGroup, RadioItem, ItemIndicator, Separator, Arrow, Sub, SubTrigger, SubContent, } from './menu';
+export type { MenuProps, MenuAnchorProps, MenuPortalProps, MenuContentProps, MenuGroupProps, MenuLabelProps, MenuItemProps, MenuCheckboxItemProps, MenuRadioGroupProps, MenuRadioItemProps, MenuItemIndicatorProps, MenuSeparatorProps, MenuArrowProps, MenuSubProps, MenuSubTriggerProps, MenuSubContentProps, } from './menu';

package/dist/primitives/vendor/radix/react-menu/menu.d.ts

@@ -0,0 +1,173 @@
+import * as React from 'react';
+import { DismissableLayer } from '../react-dismissable-layer';
+import { FocusScope } from '../react-focus-scope';
+import * as PopperPrimitive from '../react-popper';
+import { Portal as PortalPrimitive } from '../react-portal';
+import { Primitive } from '../react-primitive';
+import * as RovingFocusGroup from '../react-roving-focus';
+type Direction = 'ltr' | 'rtl';
+declare const createMenuScope: import("../react-context").CreateScope;
+interface MenuProps {
+    children?: React.ReactNode;
+    open?: boolean;
+    onOpenChange?(open: boolean): void;
+    dir?: Direction;
+    modal?: boolean;
+}
+declare const Menu: React.FC<MenuProps>;
+type PopperAnchorProps = React.ComponentPropsWithoutRef<typeof PopperPrimitive.Anchor>;
+interface MenuAnchorProps extends PopperAnchorProps {
+}
+declare const MenuAnchor: React.ForwardRefExoticComponent<MenuAnchorProps & React.RefAttributes<HTMLDivElement>>;
+type PortalProps = React.ComponentPropsWithoutRef<typeof PortalPrimitive>;
+interface MenuPortalProps {
+    children?: React.ReactNode;
+    /**
+     * Specify a container element to portal the content into.
+     */
+    container?: PortalProps['container'];
+    /**
+     * Used to force mounting when more control is needed. Useful when
+     * controlling animation with React animation libraries.
+     */
+    forceMount?: true;
+}
+declare const MenuPortal: React.FC<MenuPortalProps>;
+/**
+ * We purposefully don't union MenuRootContent and MenuSubContent props here because
+ * they have conflicting prop types. We agreed that we would allow MenuSubContent to
+ * accept props that it would just ignore.
+ */
+interface MenuContentProps extends MenuRootContentTypeProps {
+    /**
+     * Used to force mounting when more control is needed. Useful when
+     * controlling animation with React animation libraries.
+     */
+    forceMount?: true;
+}
+declare const MenuContent: React.ForwardRefExoticComponent<MenuContentProps & React.RefAttributes<HTMLDivElement>>;
+interface MenuRootContentTypeProps extends Omit<MenuContentImplProps, keyof MenuContentImplPrivateProps> {
+}
+type FocusScopeProps = React.ComponentPropsWithoutRef<typeof FocusScope>;
+type DismissableLayerProps = React.ComponentPropsWithoutRef<typeof DismissableLayer>;
+type RovingFocusGroupProps = React.ComponentPropsWithoutRef<typeof RovingFocusGroup.Root>;
+type PopperContentProps = React.ComponentPropsWithoutRef<typeof PopperPrimitive.Content>;
+type MenuContentImplPrivateProps = {
+    onOpenAutoFocus?: FocusScopeProps['onMountAutoFocus'];
+    onDismiss?: DismissableLayerProps['onDismiss'];
+    disableOutsidePointerEvents?: DismissableLayerProps['disableOutsidePointerEvents'];
+    /**
+     * Whether scrolling outside the `MenuContent` should be prevented
+     * (default: `false`)
+     */
+    disableOutsideScroll?: boolean;
+    /**
+     * Whether focus should be trapped within the `MenuContent`
+     * (default: false)
+     */
+    trapFocus?: FocusScopeProps['trapped'];
+};
+interface MenuContentImplProps extends MenuContentImplPrivateProps, Omit<PopperContentProps, 'dir' | 'onPlaced'> {
+    /**
+     * Event handler called when auto-focusing on close.
+     * Can be prevented.
+     */
+    onCloseAutoFocus?: FocusScopeProps['onUnmountAutoFocus'];
+    /**
+     * Whether keyboard navigation should loop around
+     * @defaultValue false
+     */
+    loop?: RovingFocusGroupProps['loop'];
+    onEntryFocus?: RovingFocusGroupProps['onEntryFocus'];
+    onEscapeKeyDown?: DismissableLayerProps['onEscapeKeyDown'];
+    onPointerDownOutside?: DismissableLayerProps['onPointerDownOutside'];
+    onFocusOutside?: DismissableLayerProps['onFocusOutside'];
+    onInteractOutside?: DismissableLayerProps['onInteractOutside'];
+}
+type PrimitiveDivProps = React.ComponentPropsWithoutRef<typeof Primitive.div>;
+interface MenuGroupProps extends PrimitiveDivProps {
+}
+declare const MenuGroup: React.ForwardRefExoticComponent<MenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+interface MenuLabelProps extends PrimitiveDivProps {
+}
+declare const MenuLabel: React.ForwardRefExoticComponent<MenuLabelProps & React.RefAttributes<HTMLDivElement>>;
+interface MenuItemProps extends Omit<MenuItemImplProps, 'onSelect'> {
+    onSelect?: (event: Event) => void;
+}
+declare const MenuItem: React.ForwardRefExoticComponent<MenuItemProps & React.RefAttributes<HTMLDivElement>>;
+interface MenuItemImplProps extends PrimitiveDivProps {
+    disabled?: boolean;
+    textValue?: string;
+}
+type CheckedState = boolean | 'indeterminate';
+interface MenuCheckboxItemProps extends MenuItemProps {
+    checked?: CheckedState;
+    onCheckedChange?: (checked: boolean) => void;
+}
+declare const MenuCheckboxItem: React.ForwardRefExoticComponent<MenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>>;
+interface MenuRadioGroupProps extends MenuGroupProps {
+    value?: string;
+    onValueChange?: (value: string) => void;
+}
+declare const MenuRadioGroup: React.ForwardRefExoticComponent<MenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+interface MenuRadioItemProps extends MenuItemProps {
+    value: string;
+}
+declare const MenuRadioItem: React.ForwardRefExoticComponent<MenuRadioItemProps & React.RefAttributes<HTMLDivElement>>;
+type PrimitiveSpanProps = React.ComponentPropsWithoutRef<typeof Primitive.span>;
+interface MenuItemIndicatorProps extends PrimitiveSpanProps {
+    /**
+     * Used to force mounting when more control is needed. Useful when
+     * controlling animation with React animation libraries.
+     */
+    forceMount?: true;
+}
+declare const MenuItemIndicator: React.ForwardRefExoticComponent<MenuItemIndicatorProps & React.RefAttributes<HTMLSpanElement>>;
+interface MenuSeparatorProps extends PrimitiveDivProps {
+}
+declare const MenuSeparator: React.ForwardRefExoticComponent<MenuSeparatorProps & React.RefAttributes<HTMLDivElement>>;
+type PopperArrowProps = React.ComponentPropsWithoutRef<typeof PopperPrimitive.Arrow>;
+interface MenuArrowProps extends PopperArrowProps {
+}
+declare const MenuArrow: React.ForwardRefExoticComponent<MenuArrowProps & React.RefAttributes<SVGSVGElement>>;
+interface MenuSubProps {
+    children?: React.ReactNode;
+    open?: boolean;
+    onOpenChange?(open: boolean): void;
+}
+declare const MenuSub: React.FC<MenuSubProps>;
+interface MenuSubTriggerProps extends MenuItemImplProps {
+}
+declare const MenuSubTrigger: React.ForwardRefExoticComponent<MenuSubTriggerProps & React.RefAttributes<HTMLDivElement>>;
+type AlignSubContent = Exclude<(typeof PopperPrimitive.ALIGN_OPTIONS)[number], 'center'>;
+interface MenuSubContentProps extends Omit<MenuContentImplProps, keyof MenuContentImplPrivateProps | 'onCloseAutoFocus' | 'onEntryFocus' | 'side' | 'align'> {
+    /**
+     * Used to force mounting when more control is needed. Useful when
+     * controlling animation with React animation libraries.
+     */
+    forceMount?: true;
+    /**
+     * Controls the direction the subcontent appears from its anchor menu item
+     * Default: start
+     */
+    align?: AlignSubContent;
+}
+declare const MenuSubContent: React.ForwardRefExoticComponent<MenuSubContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const Root: React.FC<MenuProps>;
+declare const Anchor: React.ForwardRefExoticComponent<MenuAnchorProps & React.RefAttributes<HTMLDivElement>>;
+declare const Portal: React.FC<MenuPortalProps>;
+declare const Content: React.ForwardRefExoticComponent<MenuContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const Group: React.ForwardRefExoticComponent<MenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const Label: React.ForwardRefExoticComponent<MenuLabelProps & React.RefAttributes<HTMLDivElement>>;
+declare const Item: React.ForwardRefExoticComponent<MenuItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const CheckboxItem: React.ForwardRefExoticComponent<MenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const RadioGroup: React.ForwardRefExoticComponent<MenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const RadioItem: React.ForwardRefExoticComponent<MenuRadioItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const ItemIndicator: React.ForwardRefExoticComponent<MenuItemIndicatorProps & React.RefAttributes<HTMLSpanElement>>;
+declare const Separator: React.ForwardRefExoticComponent<MenuSeparatorProps & React.RefAttributes<HTMLDivElement>>;
+declare const Arrow: React.ForwardRefExoticComponent<MenuArrowProps & React.RefAttributes<SVGSVGElement>>;
+declare const Sub: React.FC<MenuSubProps>;
+declare const SubTrigger: React.ForwardRefExoticComponent<MenuSubTriggerProps & React.RefAttributes<HTMLDivElement>>;
+declare const SubContent: React.ForwardRefExoticComponent<MenuSubContentProps & React.RefAttributes<HTMLDivElement>>;
+export { createMenuScope, Menu, MenuAnchor, MenuPortal, MenuContent, MenuGroup, MenuLabel, MenuItem, MenuCheckboxItem, MenuRadioGroup, MenuRadioItem, MenuItemIndicator, MenuSeparator, MenuArrow, MenuSub, MenuSubTrigger, MenuSubContent, Root, Anchor, Portal, Content, Group, Label, Item, CheckboxItem, RadioGroup, RadioItem, ItemIndicator, Separator, Arrow, Sub, SubTrigger, SubContent, };
+export type { MenuProps, MenuAnchorProps, MenuPortalProps, MenuContentProps, MenuGroupProps, MenuLabelProps, MenuItemProps, MenuCheckboxItemProps, MenuRadioGroupProps, MenuRadioItemProps, MenuItemIndicatorProps, MenuSeparatorProps, MenuArrowProps, MenuSubProps, MenuSubTriggerProps, MenuSubContentProps, };