sheer-ui 0.4.2 → 0.5.0

package/dist/components/menu/types.d.ts

@@ -0,0 +1,195 @@
+import type { Expand } from '../../internal/tools/index.js';
+import type { PopperLayerProps, PopperLayerStaticProps } from '../../internal/popper-layer/types.js';
+import type { FloatingLayerArrowProps, FloatingLayerArrowPropsWithoutHTML } from '../../internal/floating-layer/types.js';
+import type { OnChangeFn, WithChild, WithChildNoChildrenSnippetProps, WithChildren, Without } from '../../internal/types.js';
+import type { BitsPrimitiveButtonAttributes, BitsPrimitiveDivAttributes } from '../../internal/attribute-types.js';
+import type { Direction } from '../../internal/index.js';
+import type { Snippet } from 'svelte';
+import type { OpenCell } from '../../internal/open-cell.svelte.js';
+import type { PortalProps } from '../../internal/portal/index.js';
+import type { FloatingContentSnippetProps, StaticContentSnippetProps } from '../../internal/types.js';
+export type MenuRootPropsWithoutHTML = {
+    /**
+     * The derivation source for the menu's open state: the internal cell
+     * re-derives whenever this prop changes, and interactions (trigger, Escape,
+     * a snippet-cell write) override it until the next change. Reconcile
+     * dismissals via onOpenChangeComplete. Plain value — not bindable.
+     */
+    open?: boolean;
+    /**
+     * A callback that is called when the menu finishes opening/closing animations.
+     * This is an occurrence (animation settled), not a state mirror — depend on the cell instead.
+     */
+    onOpenChangeComplete?: OnChangeFn<boolean>;
+    /**
+     * A caller-constructed cell (own source and, optionally, a delegate writer)
+     * used instead of building one from `open`. When given, `open` is ignored.
+     */
+    state?: OpenCell;
+    /**
+     * The direction of the site.
+     *
+     * @defaultValue "ltr"
+     */
+    dir?: Direction;
+    /** Children receive the state cell, typed and guaranteed within the tree. */
+    children?: Snippet<[OpenCell]>;
+};
+export type MenuRootProps = MenuRootPropsWithoutHTML;
+export type _SharedMenuContentProps = {
+    /**
+     * When `true`, the menu will loop through items when navigating with the keyboard.
+     *
+     * @defaultValue false
+     */
+    loop?: boolean;
+};
+export type MenuContentPropsWithoutHTML = Expand<WithChildNoChildrenSnippetProps<Omit<PopperLayerProps, 'content'> & _SharedMenuContentProps, FloatingContentSnippetProps>>;
+export type MenuContentProps = MenuContentPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, MenuContentPropsWithoutHTML>;
+export type MenuContentStaticPropsWithoutHTML = Expand<WithChildNoChildrenSnippetProps<Omit<PopperLayerStaticProps, 'content'> & _SharedMenuContentProps, StaticContentSnippetProps>>;
+export type MenuContentStaticProps = MenuContentStaticPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, MenuContentStaticPropsWithoutHTML>;
+export type MenuItemPropsWithoutHTML<U extends Record<PropertyKey, unknown> = {
+    _default: never;
+}> = WithChild<{
+    /**
+     * When `true`, the user will not be able to interact with the menu item.
+     *
+     * @defaultValue false
+     */
+    disabled?: boolean;
+    /**
+     * A callback fired when the menu item is selected.
+     *
+     * Calling `event.preventDefault()` keeps a plain or radio item from closing the
+     * menu; the radio item still selects. A checkbox item never closes it.
+     */
+    onSelect?: (event: Event) => void;
+}, U>;
+export type MenuItemProps = MenuItemPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, MenuItemPropsWithoutHTML>;
+export type MenuCheckboxItemSnippetProps = {
+    checked: boolean;
+    indeterminate: boolean;
+};
+export type MenuCheckboxItemPropsWithoutHTML = MenuItemPropsWithoutHTML<MenuCheckboxItemSnippetProps> & {
+    /**
+     * The checked state of the checkbox. It can be one of:
+     * - `true` for checked
+     * - `false` for unchecked
+     *
+     * @defaultValue false
+     */
+    checked?: boolean;
+    /**
+     * A callback that is fired when the checked state changes.
+     */
+    onCheckedChange?: OnChangeFn<boolean>;
+    /**
+     * Whether the checkbox is in an indeterminate state or not.
+     *
+     * @defaultValue false
+     */
+    indeterminate?: boolean;
+    /**
+     * A callback function called when the indeterminate state changes.
+     */
+    onIndeterminateChange?: OnChangeFn<boolean>;
+    /**
+     * The value of the checkbox item when used in a checkbox group.
+     */
+    value?: string;
+};
+export type MenuCheckboxItemProps = MenuCheckboxItemPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, MenuCheckboxItemPropsWithoutHTML>;
+export type MenuCheckboxGroupPropsWithoutHTML = WithChild<{
+    /**
+     * The values of the selected checkbox items.
+     *
+     * Supports two-way binding with `bind:value`.
+     */
+    value?: string[];
+    /**
+     * A callback that is fired when the selected checkbox items change.
+     */
+    onValueChange?: OnChangeFn<string[]>;
+}>;
+export type MenuCheckboxGroupProps = MenuCheckboxGroupPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, MenuCheckboxGroupPropsWithoutHTML>;
+export type MenuTriggerPropsWithoutHTML = WithChild<{
+    /**
+     * Whether the trigger is disabled.
+     *
+     * @defaultValue false
+     */
+    disabled?: boolean | null | undefined;
+}>;
+export type MenuTriggerProps = MenuTriggerPropsWithoutHTML & Without<BitsPrimitiveButtonAttributes, MenuTriggerPropsWithoutHTML>;
+export type MenuSubPropsWithoutHTML = WithChildren<{
+    /**
+     * The open state of the menu.
+     */
+    open?: boolean;
+    /**
+     * A callback that is called when the menu is opened or closed.
+     */
+    onOpenChange?: OnChangeFn<boolean>;
+    /**
+     * A callback that is called when the menu finishes opening/closing animations.
+     */
+    onOpenChangeComplete?: OnChangeFn<boolean>;
+}>;
+export type MenuSubProps = MenuSubPropsWithoutHTML;
+export type MenuSubContentPropsWithoutHTML = Expand<WithChildNoChildrenSnippetProps<Omit<PopperLayerProps, 'content' | 'preventScroll'> & _SharedMenuContentProps, FloatingContentSnippetProps>>;
+export type MenuSubContentProps = MenuSubContentPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, MenuSubContentPropsWithoutHTML>;
+export type MenuSubContentStaticPropsWithoutHTML = Expand<WithChildNoChildrenSnippetProps<Omit<PopperLayerStaticProps, 'content' | 'preventScroll'> & _SharedMenuContentProps, StaticContentSnippetProps>>;
+export type MenuSubContentStaticProps = MenuSubContentStaticPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, MenuSubContentStaticPropsWithoutHTML>;
+export type MenuSubTriggerPropsWithoutHTML = Omit<MenuItemPropsWithoutHTML, 'onSelect'> & {
+    /**
+     * A callback fired when the sub-trigger is selected, right before its submenu opens.
+     * `event.preventDefault()` has no effect here: the submenu opens either way and the
+     * parent menu never closes on a sub-trigger.
+     */
+    onSelect?: (event: Event) => void;
+    /**
+     * The amount of time in ms from when the mouse enters the subtrigger until
+     * the submenu opens. This is useful for preventing the submenu from opening
+     * as a user is moving their mouse through the menu without a true intention to open that
+     * submenu.
+     *
+     * To disable the behavior, set it to `0`.
+     *
+     * @default 100
+     */
+    openDelay?: number;
+};
+export type MenuSubTriggerProps = MenuSubTriggerPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, MenuSubTriggerPropsWithoutHTML>;
+export type MenuSeparatorPropsWithoutHTML = WithChild;
+export type MenuSeparatorProps = MenuSeparatorPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, MenuSeparatorPropsWithoutHTML>;
+export type MenuArrowPropsWithoutHTML = FloatingLayerArrowPropsWithoutHTML;
+export type MenuArrowProps = FloatingLayerArrowProps;
+export type MenuGroupPropsWithoutHTML = WithChild;
+export type MenuGroupProps = MenuGroupPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, MenuGroupPropsWithoutHTML>;
+export type MenuGroupHeadingPropsWithoutHTML = WithChild;
+export type MenuGroupHeadingProps = MenuGroupHeadingPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, MenuGroupHeadingPropsWithoutHTML>;
+export type MenuRadioGroupPropsWithoutHTML = WithChild<{
+    /**
+     * The value of the selected radio item.
+     *
+     * Supports two-way binding with `bind:value`.
+     */
+    value?: string;
+    /**
+     * A callback that is fired when the selected radio item changes.
+     */
+    onValueChange?: OnChangeFn<string>;
+}>;
+export type MenuRadioGroupProps = MenuRadioGroupPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, MenuRadioGroupPropsWithoutHTML>;
+export type MenuRadioItemSnippetProps = {
+    checked: boolean;
+};
+export type MenuRadioItemPropsWithoutHTML = MenuItemPropsWithoutHTML<MenuRadioItemSnippetProps> & {
+    /**
+     * The value of the radio item.
+     */
+    value: string;
+};
+export type MenuRadioItemProps = MenuRadioItemPropsWithoutHTML & Without<BitsPrimitiveDivAttributes, MenuRadioItemPropsWithoutHTML>;
+export type MenuPortalPropsWithoutHTML = PortalProps;
+export type MenuPortalProps = MenuPortalPropsWithoutHTML;

package/dist/components/menu/types.js

@@ -0,0 +1 @@
+export {};

package/dist/components/menu/utils.d.ts

@@ -0,0 +1,20 @@
+import type { Direction } from "../../internal/index.js";
+import type { MenuContentState } from './menu.svelte.js';
+export type CheckedState = boolean | "indeterminate";
+export declare const SUB_OPEN_KEYS: Record<Direction, string[]>;
+export declare const SUB_CLOSE_KEYS: Record<Direction, string[]>;
+export declare const isIndeterminate: (checked?: CheckedState) => checked is "indeterminate";
+export declare const getCheckedState: (checked: CheckedState) => "checked" | "unchecked" | "indeterminate";
+export declare const isMouseEvent: (event: PointerEvent) => boolean;
+type SubmenuHandlerOptions = {
+    onInteractOutside: () => (event: PointerEvent) => void;
+    onEscapeKeydown: () => (event: KeyboardEvent) => void;
+    onFocusOutside: () => (event: FocusEvent) => void;
+};
+export declare function createSubmenuHandlers(state: MenuContentState, options: SubmenuHandlerOptions): {
+    onkeydown: (event: KeyboardEvent) => void;
+    handleInteractOutside: (event: PointerEvent) => void;
+    handleEscapeKeydown: (event: KeyboardEvent) => void;
+    handleOnFocusOutside: (event: FocusEvent) => void;
+};
+export {};

package/dist/components/menu/utils.js

@@ -0,0 +1,54 @@
+import { kbd, SELECTION_KEYS } from "../../internal/kbd.js";
+import { isHTMLElement } from '../../internal/tools/utils/dom.js';
+export const SUB_OPEN_KEYS = {
+    ltr: [...SELECTION_KEYS, kbd.ARROW_RIGHT],
+    rtl: [...SELECTION_KEYS, kbd.ARROW_LEFT],
+};
+export const SUB_CLOSE_KEYS = {
+    ltr: [kbd.ARROW_LEFT],
+    rtl: [kbd.ARROW_RIGHT],
+};
+export const isIndeterminate = (checked) => checked === "indeterminate";
+export const getCheckedState = (checked) => isIndeterminate(checked) ? "indeterminate" : checked ? "checked" : "unchecked";
+export const isMouseEvent = (event) => event.pointerType === "mouse";
+export function createSubmenuHandlers(state, options) {
+    const onkeydown = (event) => {
+        const inside = event.currentTarget.contains(event.target);
+        const closeKey = SUB_CLOSE_KEYS[state.parentMenu.root.opts.dir.current].includes(event.key);
+        if (!inside || !closeKey)
+            return;
+        state.parentMenu.onClose();
+        state.parentMenu.triggerNode?.focus();
+        event.preventDefault();
+    };
+    const handleInteractOutside = (event) => {
+        options.onInteractOutside()(event);
+        if (!event.defaultPrevented)
+            state.parentMenu.onClose();
+    };
+    const handleEscapeKeydown = (event) => {
+        options.onEscapeKeydown()(event);
+        if (!event.defaultPrevented)
+            state.parentMenu.onClose();
+    };
+    const handleOnFocusOutside = (event) => {
+        options.onFocusOutside()(event);
+        if (event.defaultPrevented || !isHTMLElement(event.target))
+            return;
+        if (event.target.id === state.parentMenu.triggerNode?.id)
+            return;
+        const parentContent = state.parentMenu.parentMenu?.contentNode;
+        if (parentContent?.contains(event.target)) {
+            state.parentMenu.onClose();
+            event.preventDefault();
+            return;
+        }
+        const subContentSelector = `[${state.parentMenu.root.getBitsAttr('sub-content')}]`;
+        if (event.target.closest(subContentSelector)) {
+            event.preventDefault();
+            return;
+        }
+        state.parentMenu.onClose();
+    };
+    return { onkeydown, handleInteractOutside, handleEscapeKeydown, handleOnFocusOutside };
+}

package/dist/components/menubar/components/menubar-content-static.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { MenubarContentStaticProps } from '../types.js';
+declare const MenubarContentStatic: import("svelte").Component<MenubarContentStaticProps, {}, "ref">;
+type MenubarContentStatic = ReturnType<typeof MenubarContentStatic>;
+export default MenubarContentStatic;

package/dist/components/menubar/components/menubar-content.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { MenubarContentProps } from '../types.js';
+declare const MenubarContent: import("svelte").Component<MenubarContentProps, {}, "ref">;
+type MenubarContent = ReturnType<typeof MenubarContent>;
+export default MenubarContent;

package/dist/components/menubar/components/menubar-menu.svelte.d.ts

@@ -0,0 +1,3 @@
+declare const MenubarMenu: import("svelte").Component<import("../types.js").MenubarMenuPropsWithoutHTML, {}, "">;
+type MenubarMenu = ReturnType<typeof MenubarMenu>;
+export default MenubarMenu;

package/dist/components/menubar/components/menubar-trigger.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { MenubarTriggerProps } from '../types.js';
+declare const MenubarTrigger: import("svelte").Component<MenubarTriggerProps, {}, "ref">;
+type MenubarTrigger = ReturnType<typeof MenubarTrigger>;
+export default MenubarTrigger;

package/dist/components/menubar/components/menubar.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { MenubarRootProps } from '../types.js';
+declare const Menubar: import("svelte").Component<MenubarRootProps, {}, "ref" | "value">;
+type Menubar = ReturnType<typeof Menubar>;
+export default Menubar;

package/dist/components/menubar/exports.d.ts

@@ -0,0 +1,21 @@
+export { default as Root } from "./components/menubar.svelte";
+export { default as Menu } from "./components/menubar-menu.svelte";
+export { default as Content } from "./components/menubar-content.svelte";
+export { default as ContentStatic } from "./components/menubar-content-static.svelte";
+export { default as Trigger } from "./components/menubar-trigger.svelte";
+export { default as Sub } from "../menu/components/menu-sub.svelte";
+export { default as Item } from "../menu/components/menu-item.svelte";
+export { default as Group } from "../menu/components/menu-group.svelte";
+export { default as GroupHeading } from "../menu/components/menu-group-heading.svelte";
+export { default as Arrow } from "../menu/components/menu-arrow.svelte";
+export { default as RadioItem } from "../menu/components/menu-radio-item.svelte";
+export { default as Separator } from "../menu/components/menu-separator.svelte";
+export { default as SubContent } from "../menu/components/menu-sub-content.svelte";
+export { default as SubContentStatic } from "../menu/components/menu-sub-content-static.svelte";
+export { default as SubTrigger } from "../menu/components/menu-sub-trigger.svelte";
+export { default as RadioGroup } from "../menu/components/menu-radio-group.svelte";
+export { default as CheckboxItem } from "../menu/components/menu-checkbox-item.svelte";
+export { default as Portal } from "../../internal/portal/portal.svelte";
+export { default as CheckboxGroup } from "../menu/components/menu-checkbox-group.svelte";
+export type { MenubarRootProps as RootProps, MenubarMenuProps as MenuProps, MenubarTriggerProps as TriggerProps, MenubarContentProps as ContentProps, MenubarContentStaticProps as ContentStaticProps, MenubarPortalProps as PortalProps, } from "./types.js";
+export type { MenuSubPropsWithoutHTML as SubProps, MenuItemProps as ItemProps, MenuGroupProps as GroupProps, MenuGroupHeadingProps as GroupHeadingProps, MenuArrowProps as ArrowProps, MenuRadioItemProps as RadioItemProps, MenuSeparatorProps as SeparatorProps, MenuSubContentProps as SubContentProps, MenuSubTriggerProps as SubTriggerProps, MenuRadioGroupProps as RadioGroupProps, MenuCheckboxItemProps as CheckboxItemProps, MenuSubContentStaticProps as SubContentStaticProps, MenuCheckboxGroupProps as CheckboxGroupProps, } from "../menu/types.js";

package/dist/components/menubar/exports.js

@@ -0,0 +1,19 @@
+export { default as Root } from "./components/menubar.svelte";
+export { default as Menu } from "./components/menubar-menu.svelte";
+export { default as Content } from "./components/menubar-content.svelte";
+export { default as ContentStatic } from "./components/menubar-content-static.svelte";
+export { default as Trigger } from "./components/menubar-trigger.svelte";
+export { default as Sub } from "../menu/components/menu-sub.svelte";
+export { default as Item } from "../menu/components/menu-item.svelte";
+export { default as Group } from "../menu/components/menu-group.svelte";
+export { default as GroupHeading } from "../menu/components/menu-group-heading.svelte";
+export { default as Arrow } from "../menu/components/menu-arrow.svelte";
+export { default as RadioItem } from "../menu/components/menu-radio-item.svelte";
+export { default as Separator } from "../menu/components/menu-separator.svelte";
+export { default as SubContent } from "../menu/components/menu-sub-content.svelte";
+export { default as SubContentStatic } from "../menu/components/menu-sub-content-static.svelte";
+export { default as SubTrigger } from "../menu/components/menu-sub-trigger.svelte";
+export { default as RadioGroup } from "../menu/components/menu-radio-group.svelte";
+export { default as CheckboxItem } from "../menu/components/menu-checkbox-item.svelte";
+export { default as Portal } from "../../internal/portal/portal.svelte";
+export { default as CheckboxGroup } from "../menu/components/menu-checkbox-group.svelte";

package/dist/components/menubar/index.js

@@ -0,0 +1,2 @@
+export * as Menubar from './exports.js';
+export * from './exports.js';

package/dist/components/menubar/menubar.svelte.d.ts

@@ -0,0 +1,138 @@
+import { type ReadableBox, type ReadableBoxedValues, type WritableBoxedValues } from '../../internal/tools/index.js';
+import type { InteractOutsideBehaviorType } from '../../internal/dismissible-layer/types.js';
+import type { Direction } from '../../internal/index.js';
+import type { OnChangeFn, RefAttachment, WithRefOpts } from '../../internal/types.js';
+import type { FocusEventHandler, KeyboardEventHandler, PointerEventHandler } from 'svelte/elements';
+import { RovingFocusGroup } from '../../internal/roving-focus-group.svelte.js';
+import { RovingFocusItem } from '../../internal/roving-focus-item.svelte.js';
+interface MenubarRootStateOpts extends WithRefOpts, ReadableBoxedValues<{
+    dir: Direction;
+    loop: boolean;
+}>, WritableBoxedValues<{
+    value: string;
+}> {
+}
+export declare class MenubarRootState {
+    static create(opts: MenubarRootStateOpts): MenubarRootState;
+    readonly opts: MenubarRootStateOpts;
+    readonly rovingFocusGroup: RovingFocusGroup;
+    readonly attachment: RefAttachment;
+    wasOpenedByKeyboard: boolean;
+    triggerIds: string[];
+    /** Outgoing menu id when swapping to another top-level menu... skip exit animation wait only then */
+    skipExitAnimationForMenuValue: string | null;
+    valueToChangeHandler: Map<string, ReadableBox<OnChangeFn<boolean>>>;
+    constructor(opts: MenubarRootStateOpts);
+    /**
+     * @param id - the id of the trigger to register
+     * @returns - a function to de-register the trigger
+     */
+    registerTrigger: (id: string) => () => void;
+    /**
+     * @param value - the value of the menu to register
+     * @param contentId - the content id to associate with the value
+     * @returns - a function to de-register the menu
+     */
+    registerMenu: (value: string, onOpenChange: ReadableBox<OnChangeFn<boolean>>) => () => void;
+    updateValue: (value: string) => void;
+    getTriggers: () => HTMLButtonElement[];
+    onMenuOpen: (id: string, triggerId: string) => void;
+    onMenuClose: () => void;
+    onMenuToggle: (id: string) => void;
+    readonly props: {
+        readonly id: string;
+        readonly role: "menubar";
+    };
+}
+interface MenubarMenuStateOpts extends ReadableBoxedValues<{
+    value: string;
+    onOpenChange: OnChangeFn<boolean>;
+}> {
+}
+export declare class MenubarMenuState {
+    static create(opts: MenubarMenuStateOpts): MenubarMenuState;
+    readonly opts: MenubarMenuStateOpts;
+    readonly root: MenubarRootState;
+    open: boolean;
+    wasOpenedByKeyboard: boolean;
+    triggerNode: HTMLElement | null;
+    triggerId: string | undefined;
+    contentId: string | undefined;
+    contentNode: HTMLElement | null;
+    constructor(opts: MenubarMenuStateOpts, root: MenubarRootState);
+    getTriggerNode(): HTMLElement | null;
+    toggleMenu(): void;
+    openMenu(): void;
+}
+interface MenubarTriggerStateOpts extends WithRefOpts, ReadableBoxedValues<{
+    disabled: boolean;
+}> {
+}
+export declare class MenubarTriggerState {
+    static create(opts: MenubarTriggerStateOpts): MenubarTriggerState;
+    readonly opts: MenubarTriggerStateOpts;
+    readonly menu: MenubarMenuState;
+    readonly root: MenubarRootState;
+    readonly rovingItem: RovingFocusItem;
+    isFocused: boolean;
+    constructor(opts: MenubarTriggerStateOpts, menu: MenubarMenuState);
+    onpointerdown: PointerEventHandler<HTMLElement>;
+    onpointerenter: PointerEventHandler<HTMLElement>;
+    onkeydown: KeyboardEventHandler<HTMLElement>;
+    onfocus: FocusEventHandler<HTMLElement>;
+    onblur: FocusEventHandler<HTMLElement>;
+    readonly props: {
+        readonly tabindex: number;
+        readonly type: "button";
+        readonly role: "menuitem";
+        readonly id: string;
+        readonly 'aria-haspopup': "menu";
+        readonly 'aria-expanded': "true" | "false";
+        readonly 'aria-controls': string | undefined;
+        readonly 'data-highlighted': "" | undefined;
+        readonly 'data-state': "closed" | "open";
+        readonly 'data-disabled': "" | undefined;
+        readonly 'data-menu-value': string;
+        readonly disabled: true | undefined;
+        readonly onpointerdown: PointerEventHandler<HTMLElement>;
+        readonly onpointerenter: PointerEventHandler<HTMLElement>;
+        readonly onkeydown: KeyboardEventHandler<HTMLElement>;
+        readonly onfocus: FocusEventHandler<HTMLElement>;
+        readonly onblur: FocusEventHandler<HTMLElement>;
+    };
+}
+interface MenubarContentStateOpts extends WithRefOpts, ReadableBoxedValues<{
+    interactOutsideBehavior: InteractOutsideBehaviorType;
+    onOpenAutoFocus: (e: Event) => void;
+    onCloseAutoFocus: (e: Event) => void;
+    onFocusOutside: (e: FocusEvent) => void;
+    onInteractOutside: (e: PointerEvent) => void;
+}> {
+}
+export declare class MenubarContentState {
+    static create(opts: MenubarContentStateOpts): MenubarContentState;
+    readonly opts: MenubarContentStateOpts;
+    readonly menu: MenubarMenuState;
+    readonly root: MenubarRootState;
+    readonly attachment: RefAttachment;
+    constructor(opts: MenubarContentStateOpts, menu: MenubarMenuState);
+    onCloseAutoFocus: (e: Event) => void;
+    onFocusOutside: (e: FocusEvent) => void;
+    onInteractOutside: (e: PointerEvent) => void;
+    onOpenAutoFocus: (e: Event) => void;
+    onkeydown: KeyboardEventHandler<HTMLElement>;
+    props: {
+        readonly id: string;
+        readonly 'aria-labelledby': string | undefined;
+        readonly style: Record<string, string>;
+        readonly onkeydown: KeyboardEventHandler<HTMLElement>;
+        readonly 'data-menu-content': "";
+    };
+    popperProps: {
+        onCloseAutoFocus: (e: Event) => void;
+        onFocusOutside: (e: FocusEvent) => void;
+        onInteractOutside: (e: PointerEvent) => void;
+        onOpenAutoFocus: (e: Event) => void;
+    };
+}
+export {};