solid-baseui 0.1.0-alpha.0

package/dist/lib/types/internals/overlay/tabbable.d.ts

@@ -0,0 +1,11 @@
+import { type FocusableElement } from './dom.js';
+export declare function isTabbable(element: Element | null): boolean;
+export declare function focusable(container: Element): FocusableElement[];
+export declare function tabbable(container: Element): FocusableElement[];
+export declare function getNextTabbable(reference: Element | null): FocusableElement | null;
+export declare function getPreviousTabbable(reference: Element | null): FocusableElement | null;
+export declare function getTabbableAfterElement(reference: Element | null): FocusableElement | null;
+export declare function getTabbableBeforeElement(reference: Element | null): FocusableElement | null;
+export declare function isOutsideFocusEvent(event: FocusEvent, container: Element): boolean;
+export declare function disableFocusInside(container: HTMLElement): void;
+export declare function enableFocusInside(container: HTMLElement): void;

package/dist/lib/types/internals/platform.d.ts

@@ -0,0 +1 @@
+export declare function isAndroid(): boolean;

package/dist/lib/types/internals/reason-parts.d.ts

@@ -0,0 +1,35 @@
+export declare const none: "none";
+export declare const triggerPress: "trigger-press";
+export declare const triggerHover: "trigger-hover";
+export declare const triggerFocus: "trigger-focus";
+export declare const outsidePress: "outside-press";
+export declare const itemPress: "item-press";
+export declare const closePress: "close-press";
+export declare const linkPress: "link-press";
+export declare const clearPress: "clear-press";
+export declare const chipRemovePress: "chip-remove-press";
+export declare const trackPress: "track-press";
+export declare const incrementPress: "increment-press";
+export declare const decrementPress: "decrement-press";
+export declare const inputChange: "input-change";
+export declare const inputClear: "input-clear";
+export declare const inputBlur: "input-blur";
+export declare const inputPaste: "input-paste";
+export declare const inputPress: "input-press";
+export declare const focusOut: "focus-out";
+export declare const escapeKey: "escape-key";
+export declare const closeWatcher: "close-watcher";
+export declare const listNavigation: "list-navigation";
+export declare const keyboard: "keyboard";
+export declare const pointer: "pointer";
+export declare const drag: "drag";
+export declare const swipe: "swipe";
+export declare const wheel: "wheel";
+export declare const scrub: "scrub";
+export declare const cancelOpen: "cancel-open";
+export declare const siblingOpen: "sibling-open";
+export declare const disabled: "disabled";
+export declare const missing: "missing";
+export declare const initial: "initial";
+export declare const imperativeAction: "imperative-action";
+export declare const windowResize: "window-resize";

package/dist/lib/types/internals/reasons.d.ts

@@ -0,0 +1,4 @@
+import * as REASONS from './reason-parts.js';
+export { REASONS };
+export type BaseUIEventReasons = typeof REASONS;
+export type BaseUIEventReason = BaseUIEventReasons[keyof BaseUIEventReasons];

package/dist/lib/types/internals/resolveClass.d.ts

@@ -0,0 +1,3 @@
+import type { JSX } from '@solidjs/web';
+import type { ClassValue } from '../types/index.js';
+export declare function resolveClass<State>(value: ClassValue<State> | undefined, state: State): JSX.ClassValue;

package/dist/lib/types/internals/resolveStyle.d.ts

@@ -0,0 +1,3 @@
+import type { JSX } from '@solidjs/web';
+import type { StyleValue } from '../types/index.js';
+export declare function resolveStyle<State>(value: StyleValue<State> | undefined, state: State): JSX.CSSProperties | string | false | undefined;

package/dist/lib/types/internals/runOnceAnimationsFinish.d.ts

@@ -0,0 +1,4 @@
+/** Runs a callback after current or replacement animations on an element finish. */
+export declare function runOnceAnimationsFinish(element: Element, callback: () => void, signal?: AbortSignal, options?: {
+    waitForStartingStyleRemoved?: boolean | undefined;
+}): void;

package/dist/lib/types/internals/scrollable.d.ts

@@ -0,0 +1,18 @@
+export type ScrollAxis = 'horizontal' | 'vertical';
+/**
+ * Walks one level up the composed tree. Slotted nodes step into the shadow DOM of their
+ * parent, and a shadow root resolves to its host, so traversal crosses shadow boundaries the
+ * same way Base UI's `getParentNode` does.
+ */
+export declare function getComposedParentNode(node: Node): Node | null;
+export declare function isLastTraversableNode(node: Node): boolean;
+/**
+ * When `allowOverflowIntent` is true, a container that overflows only once extra space is
+ * added (for example drawer keyboard scroll slack) still counts, as long as it has layout
+ * size on the axis.
+ */
+export declare function isScrollableY(element: HTMLElement, allowOverflowIntent?: boolean): boolean;
+export declare function isScrollableX(element: HTMLElement, allowOverflowIntent?: boolean): boolean;
+export declare function isScrollable(element: HTMLElement, axis: ScrollAxis, allowOverflowIntent?: boolean): boolean;
+export declare function hasScrollableAncestor(target: HTMLElement, root: HTMLElement, axes: ScrollAxis[]): boolean;
+export declare function findScrollableTouchTarget(target: EventTarget | Node | null, root: HTMLElement, axis?: ScrollAxis, allowOverflowIntent?: boolean): HTMLElement | null;

package/dist/lib/types/internals/setRef.d.ts

@@ -0,0 +1,2 @@
+import type { Ref } from 'solid-js';
+export declare function setRef<Element>(ref: Ref<Element>, element: Element): void;

package/dist/lib/types/internals/stateAttributesMapping.d.ts

@@ -0,0 +1,8 @@
+export type TransitionStatus = 'starting' | 'ending' | 'idle' | undefined;
+export declare enum TransitionStatusDataAttributes {
+    startingStyle = "data-starting-style",
+    endingStyle = "data-ending-style"
+}
+export declare const transitionStatusMapping: {
+    transitionStatus(value: TransitionStatus): Record<string, string> | null;
+};

package/dist/lib/types/internals/types.d.ts

@@ -0,0 +1,2 @@
+export type { BaseUIComponentProps, BaseUIEvent, ClassValue, HTMLProps, NativeComponentProps, PolymorphicProps, Ref, Simplify, StyleValue, } from '../types/index.js';
+export type Orientation = 'horizontal' | 'vertical';

package/dist/lib/types/internals/valueLabel.d.ts

@@ -0,0 +1,28 @@
+import type { JSX } from '@solidjs/web';
+/** An item that carries its own display label alongside its submitted value. */
+export interface LabeledItem {
+    value: unknown;
+    label: JSX.Element;
+}
+/**
+ * A named collection of items. Only `items` is required; any other keys a caller carries for
+ * its own rendering (a heading, an id) are preserved when the group is filtered.
+ */
+export interface ItemGroup<Item = unknown> {
+    items: ReadonlyArray<Item>;
+}
+export type ItemsInput<Item = unknown> = Record<string, JSX.Element> | ReadonlyArray<Item> | ReadonlyArray<ItemGroup<Item>> | undefined;
+/** Serializes any value to the string a form submits for it. */
+export declare function serializeValue(value: unknown): string;
+export declare function isGroupedItems<Item>(items: ItemsInput<Item>): items is ReadonlyArray<ItemGroup<Item>>;
+export declare function flattenItems<Item>(items: ItemsInput<Item>): ReadonlyArray<Item>;
+/** Whether an explicit `null` item carries a label that should win over a placeholder. */
+export declare function hasNullItemLabel<Item>(items: ItemsInput<Item>): boolean;
+/** The string form of an item as displayed to the user. */
+export declare function stringifyAsLabel<Item>(item: Item, itemToStringLabel?: ((item: Item) => string) | undefined): string;
+/** The string form of an item as submitted with a form. */
+export declare function stringifyAsValue<Item>(item: Item, itemToStringValue?: ((item: Item) => string) | undefined): string;
+/** Resolves the renderable label for one selected value, falling back to its string form. */
+export declare function resolveSelectedLabel<Item>(value: Item, items: ItemsInput<Item>, itemToStringLabel?: ((item: Item) => string) | undefined): JSX.Element;
+/** Renders every selected value as a comma-separated label list. */
+export declare function resolveMultipleLabels<Item>(values: readonly Item[], items: ItemsInput<Item>, itemToStringLabel?: ((item: Item) => string) | undefined): JSX.Element;

package/dist/lib/types/internals/withoutComponentBinding.d.ts

@@ -0,0 +1,7 @@
+import type { ValidComponent } from 'solid-js';
+/**
+ * Solid 2 transport bindings recurse when one polymorphic component is passed
+ * directly to another Dynamic. A stable unbranded wrapper keeps ordinary
+ * client-side component composition on the component's public function.
+ */
+export declare function withoutComponentBinding(component: ValidComponent): ValidComponent;

package/dist/lib/types/menu/arrow/MenuArrow.d.ts

@@ -0,0 +1,16 @@
+import { type ValidComponent } from '@solidjs/web';
+import { type AnchorAlign, type AnchorSide } from '../../internals/overlay/index.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface MenuArrowState {
+    open: boolean;
+    side: AnchorSide;
+    align: AnchorAlign;
+    uncentered: boolean;
+}
+export type MenuArrowProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, MenuArrowState>;
+/** Displays an element positioned against the menu anchor. */
+export declare function MenuArrow<Component extends ValidComponent = 'div'>(props: MenuArrow.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace MenuArrow {
+    type State = MenuArrowState;
+    type Props<Component extends ValidComponent = 'div'> = MenuArrowProps<Component>;
+}

package/dist/lib/types/menu/backdrop/MenuBackdrop.d.ts

@@ -0,0 +1,14 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { TransitionStatus } from '../../internals/stateAttributesMapping.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface MenuBackdropState {
+    open: boolean;
+    transitionStatus: TransitionStatus;
+}
+export type MenuBackdropProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, MenuBackdropState>;
+/** A presentational overlay displayed beneath the menu popup. */
+export declare function MenuBackdrop<Component extends ValidComponent = 'div'>(props: MenuBackdrop.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace MenuBackdrop {
+    type State = MenuBackdropState;
+    type Props<Component extends ValidComponent = 'div'> = MenuBackdropProps<Component>;
+}

package/dist/lib/types/menu/checkbox-item/MenuCheckboxItem.d.ts

@@ -0,0 +1,37 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { MenuRoot } from '../root/MenuRoot.js';
+export interface MenuCheckboxItemState {
+    disabled: boolean;
+    highlighted: boolean;
+    checked: boolean;
+}
+interface MenuCheckboxItemOwnProps {
+    checked?: boolean | undefined;
+    defaultChecked?: boolean | undefined;
+    onCheckedChange?: ((checked: boolean, details: MenuCheckboxItemChangeEventDetails) => void) | undefined;
+    disabled?: boolean | undefined;
+    label?: string | undefined;
+    closeOnClick?: boolean | undefined;
+    nativeButton?: boolean | undefined;
+    onClick?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+    onFocus?: BaseUIEventHandlerUnion<HTMLElement, FocusEvent> | undefined;
+    onBlur?: BaseUIEventHandlerUnion<HTMLElement, FocusEvent> | undefined;
+    onKeyDown?: BaseUIEventHandlerUnion<HTMLElement, KeyboardEvent> | undefined;
+    onKeyUp?: BaseUIEventHandlerUnion<HTMLElement, KeyboardEvent> | undefined;
+    onMouseMove?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+    onMouseUp?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+}
+export type MenuCheckboxItemProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, MenuCheckboxItemState, MenuCheckboxItemOwnProps>;
+/** A menu item that toggles a setting on or off. */
+export declare function MenuCheckboxItem<Component extends ValidComponent = 'div'>(props: MenuCheckboxItem.Props<Component>): JSX.Element;
+export type MenuCheckboxItemChangeEventReason = MenuRoot.ChangeEventReason;
+export type MenuCheckboxItemChangeEventDetails = MenuRoot.ChangeEventDetails;
+export declare namespace MenuCheckboxItem {
+    type State = MenuCheckboxItemState;
+    type Props<Component extends ValidComponent = 'div'> = MenuCheckboxItemProps<Component>;
+    type ChangeEventReason = MenuCheckboxItemChangeEventReason;
+    type ChangeEventDetails = MenuCheckboxItemChangeEventDetails;
+}
+export {};

package/dist/lib/types/menu/checkbox-item/MenuCheckboxItemContext.d.ts

@@ -0,0 +1,6 @@
+import { type Accessor } from 'solid-js';
+import type { MenuCheckboxItemState } from './MenuCheckboxItem.js';
+declare const MISSING_CONTEXT: unique symbol;
+export declare const MenuCheckboxItemContext: import("solid-js").Context<typeof MISSING_CONTEXT | Accessor<MenuCheckboxItemState>>;
+export declare function useMenuCheckboxItemContext(): Accessor<MenuCheckboxItemState>;
+export {};

package/dist/lib/types/menu/checkbox-item-indicator/MenuCheckboxItemIndicator.d.ts

@@ -0,0 +1,18 @@
+import { type ValidComponent } from '@solidjs/web';
+import { type TransitionStatus } from '../../internals/stateAttributesMapping.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { MenuCheckboxItemState } from '../checkbox-item/MenuCheckboxItem.js';
+export interface MenuCheckboxItemIndicatorState extends MenuCheckboxItemState {
+    transitionStatus: TransitionStatus;
+}
+interface OwnProps {
+    keepMounted?: boolean | undefined;
+}
+export type MenuCheckboxItemIndicatorProps<Component extends ValidComponent = 'span'> = BaseUIComponentProps<Component, MenuCheckboxItemIndicatorState, OwnProps>;
+/** Indicates whether the enclosing checkbox item is checked. */
+export declare function MenuCheckboxItemIndicator<Component extends ValidComponent = 'span'>(props: MenuCheckboxItemIndicator.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace MenuCheckboxItemIndicator {
+    type State = MenuCheckboxItemIndicatorState;
+    type Props<Component extends ValidComponent = 'span'> = MenuCheckboxItemIndicatorProps<Component>;
+}
+export {};

package/dist/lib/types/menu/group/MenuGroup.d.ts

@@ -0,0 +1,11 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface MenuGroupState {
+}
+export type MenuGroupProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, MenuGroupState>;
+/** Groups related menu items. */
+export declare function MenuGroup<Component extends ValidComponent = 'div'>(props: MenuGroup.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace MenuGroup {
+    type State = MenuGroupState;
+    type Props<Component extends ValidComponent = 'div'> = MenuGroupProps<Component>;
+}

package/dist/lib/types/menu/group/MenuGroupContext.d.ts

@@ -0,0 +1,9 @@
+import { type Accessor } from 'solid-js';
+export interface MenuGroupContextValue {
+    labelId: Accessor<string | undefined>;
+    setLabelId(id: string | undefined): void;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const MenuGroupContext: import("solid-js").Context<MenuGroupContextValue | typeof MISSING_CONTEXT>;
+export declare function useMenuGroupContext(): MenuGroupContextValue;
+export {};

package/dist/lib/types/menu/group-label/MenuGroupLabel.d.ts

@@ -0,0 +1,11 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface MenuGroupLabelState {
+}
+export type MenuGroupLabelProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, MenuGroupLabelState>;
+/** An accessible label for a menu group. */
+export declare function MenuGroupLabel<Component extends ValidComponent = 'div'>(props: MenuGroupLabel.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace MenuGroupLabel {
+    type State = MenuGroupLabelState;
+    type Props<Component extends ValidComponent = 'div'> = MenuGroupLabelProps<Component>;
+}

package/dist/lib/types/menu/index.d.ts

@@ -0,0 +1,20 @@
+export * as Menu from './index.parts.js';
+export type * from './root/MenuRoot.js';
+export type * from './trigger/MenuTrigger.js';
+export type * from './portal/MenuPortal.js';
+export type * from './backdrop/MenuBackdrop.js';
+export type * from './positioner/MenuPositioner.js';
+export type * from './popup/MenuPopup.js';
+export type * from './viewport/MenuViewport.js';
+export type * from './arrow/MenuArrow.js';
+export type * from './item/MenuItem.js';
+export type * from './link-item/MenuLinkItem.js';
+export type * from './group/MenuGroup.js';
+export type * from './group-label/MenuGroupLabel.js';
+export type * from './checkbox-item/MenuCheckboxItem.js';
+export type * from './checkbox-item-indicator/MenuCheckboxItemIndicator.js';
+export type * from './radio-group/MenuRadioGroup.js';
+export type * from './radio-item/MenuRadioItem.js';
+export type * from './radio-item-indicator/MenuRadioItemIndicator.js';
+export type * from './submenu-root/MenuSubmenuRoot.js';
+export type * from './submenu-trigger/MenuSubmenuTrigger.js';

package/dist/lib/types/menu/index.parts.d.ts

@@ -0,0 +1,21 @@
+export { MenuRoot as Root } from './root/MenuRoot.js';
+export { MenuTrigger as Trigger } from './trigger/MenuTrigger.js';
+export { MenuPortal as Portal } from './portal/MenuPortal.js';
+export { MenuBackdrop as Backdrop } from './backdrop/MenuBackdrop.js';
+export { MenuPositioner as Positioner } from './positioner/MenuPositioner.js';
+export { MenuPopup as Popup } from './popup/MenuPopup.js';
+export { MenuViewport as Viewport } from './viewport/MenuViewport.js';
+export { MenuArrow as Arrow } from './arrow/MenuArrow.js';
+export { MenuItem as Item } from './item/MenuItem.js';
+export { MenuLinkItem as LinkItem } from './link-item/MenuLinkItem.js';
+export { MenuGroup as Group } from './group/MenuGroup.js';
+export { MenuGroupLabel as GroupLabel } from './group-label/MenuGroupLabel.js';
+export { Separator } from '../separator/Separator.js';
+export { MenuCheckboxItem as CheckboxItem } from './checkbox-item/MenuCheckboxItem.js';
+export { MenuCheckboxItemIndicator as CheckboxItemIndicator } from './checkbox-item-indicator/MenuCheckboxItemIndicator.js';
+export { MenuRadioGroup as RadioGroup } from './radio-group/MenuRadioGroup.js';
+export { MenuRadioItem as RadioItem } from './radio-item/MenuRadioItem.js';
+export { MenuRadioItemIndicator as RadioItemIndicator } from './radio-item-indicator/MenuRadioItemIndicator.js';
+export { MenuSubmenuRoot as SubmenuRoot } from './submenu-root/MenuSubmenuRoot.js';
+export { MenuSubmenuTrigger as SubmenuTrigger } from './submenu-trigger/MenuSubmenuTrigger.js';
+export { MenuHandle as Handle, createMenuHandle as createHandle } from './store/MenuHandle.js';

package/dist/lib/types/menu/item/MenuItem.d.ts

@@ -0,0 +1,28 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface MenuItemState {
+    disabled: boolean;
+    highlighted: boolean;
+}
+interface MenuItemOwnProps {
+    disabled?: boolean | undefined;
+    label?: string | undefined;
+    closeOnClick?: boolean | undefined;
+    nativeButton?: boolean | undefined;
+    onClick?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+    onFocus?: BaseUIEventHandlerUnion<HTMLElement, FocusEvent> | undefined;
+    onBlur?: BaseUIEventHandlerUnion<HTMLElement, FocusEvent> | undefined;
+    onKeyDown?: BaseUIEventHandlerUnion<HTMLElement, KeyboardEvent> | undefined;
+    onKeyUp?: BaseUIEventHandlerUnion<HTMLElement, KeyboardEvent> | undefined;
+    onMouseMove?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+    onMouseUp?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+}
+export type MenuItemProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, MenuItemState, MenuItemOwnProps>;
+/** An individual interactive item in the menu. */
+export declare function MenuItem<Component extends ValidComponent = 'div'>(props: MenuItem.Props<Component>): JSX.Element;
+export declare namespace MenuItem {
+    type State = MenuItemState;
+    type Props<Component extends ValidComponent = 'div'> = MenuItemProps<Component>;
+}
+export {};

package/dist/lib/types/menu/item/createMenuItem.d.ts

@@ -0,0 +1,24 @@
+import { type Accessor } from 'solid-js';
+import type { BaseUIEvent } from '../../types/index.js';
+import type { MenuStore } from '../store/MenuStore.js';
+export interface CreateMenuItemOptions {
+    store: MenuStore<unknown>;
+    label: Accessor<string | undefined>;
+    submenu?: boolean | undefined;
+}
+export interface MenuItemBehavior {
+    element: Accessor<HTMLElement | null>;
+    setElement(element: HTMLElement): void;
+    index: Accessor<number>;
+    highlighted: Accessor<boolean>;
+    onFocus(event: FocusEvent): void;
+    onBlur(event: FocusEvent): void;
+    onMouseMove(event: MouseEvent): void;
+    onMouseUp(event: MouseEvent): void;
+    onKeyDown(event: BaseUIEvent<KeyboardEvent>, nativeButton: boolean): void;
+    onKeyUp(event: BaseUIEvent<KeyboardEvent>, nativeButton: boolean): void;
+    close(event: Event): void;
+}
+export declare function createMenuItem(options: CreateMenuItemOptions): MenuItemBehavior;
+export declare function dispatchClickWithModifiers(target: HTMLElement, source: MouseEvent | KeyboardEvent, detail: number, onCreate?: ((event: MouseEvent) => void) | undefined): MouseEvent;
+export declare function preventDisabledMenuItemActivation(event: BaseUIEvent<KeyboardEvent>): void;

package/dist/lib/types/menu/link-item/MenuLinkItem.d.ts

@@ -0,0 +1,25 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface MenuLinkItemState {
+    highlighted: boolean;
+}
+interface MenuLinkItemOwnProps {
+    label?: string | undefined;
+    closeOnClick?: boolean | undefined;
+    onClick?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+    onFocus?: BaseUIEventHandlerUnion<HTMLElement, FocusEvent> | undefined;
+    onBlur?: BaseUIEventHandlerUnion<HTMLElement, FocusEvent> | undefined;
+    onKeyDown?: BaseUIEventHandlerUnion<HTMLElement, KeyboardEvent> | undefined;
+    onKeyUp?: BaseUIEventHandlerUnion<HTMLElement, KeyboardEvent> | undefined;
+    onMouseMove?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+    onMouseUp?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+}
+export type MenuLinkItemProps<Component extends ValidComponent = 'a'> = BaseUIComponentProps<Component, MenuLinkItemState, MenuLinkItemOwnProps>;
+/** A link in the menu that navigates to another page or section. */
+export declare function MenuLinkItem<Component extends ValidComponent = 'a'>(props: MenuLinkItem.Props<Component>): JSX.Element;
+export declare namespace MenuLinkItem {
+    type State = MenuLinkItemState;
+    type Props<Component extends ValidComponent = 'a'> = MenuLinkItemProps<Component>;
+}
+export {};

package/dist/lib/types/menu/popup/MenuPopup.d.ts

@@ -0,0 +1,28 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import { type AnchorAlign, type AnchorSide, type FocusResolver } from '../../internals/overlay/index.js';
+import type { TransitionStatus } from '../../internals/stateAttributesMapping.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { MenuInstantType } from '../store/MenuStore.js';
+export interface MenuPopupState {
+    transitionStatus: TransitionStatus;
+    side: AnchorSide;
+    align: AnchorAlign;
+    open: boolean;
+    nested: boolean;
+    instant: MenuInstantType;
+}
+interface MenuPopupOwnProps {
+    finalFocus?: FocusResolver | undefined;
+    onClick?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+    onKeyDown?: BaseUIEventHandlerUnion<HTMLElement, KeyboardEvent> | undefined;
+    onMouseMove?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+}
+export type MenuPopupProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, MenuPopupState, MenuPopupOwnProps>;
+/** A container for the menu items. */
+export declare function MenuPopup<Component extends ValidComponent = 'div'>(props: MenuPopup.Props<Component>): JSX.Element;
+export declare namespace MenuPopup {
+    type State = MenuPopupState;
+    type Props<Component extends ValidComponent = 'div'> = MenuPopupProps<Component>;
+}
+export {};

package/dist/lib/types/menu/portal/MenuPortal.d.ts

@@ -0,0 +1,17 @@
+import type { JSX, ValidComponent } from '@solidjs/web';
+import { type PopupPortalContainer } from '../../internals/overlay/index.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface MenuPortalState {
+}
+interface MenuPortalOwnProps {
+    keepMounted?: boolean | undefined;
+    container?: PopupPortalContainer | undefined;
+}
+export type MenuPortalProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, MenuPortalState, MenuPortalOwnProps>;
+/** Moves the menu layer into a portal appended to the document body by default. */
+export declare function MenuPortal<Component extends ValidComponent = 'div'>(props: MenuPortal.Props<Component>): JSX.Element;
+export declare namespace MenuPortal {
+    type State = MenuPortalState;
+    type Props<Component extends ValidComponent = 'div'> = MenuPortalProps<Component>;
+}
+export {};

package/dist/lib/types/menu/portal/MenuPortalContext.d.ts

@@ -0,0 +1,8 @@
+import { type Accessor } from 'solid-js';
+export interface MenuPortalContextValue {
+    keepMounted: Accessor<boolean>;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const MenuPortalContext: import("solid-js").Context<MenuPortalContextValue | typeof MISSING_CONTEXT>;
+export declare function useMenuPortalContext(): MenuPortalContextValue;
+export {};

package/dist/lib/types/menu/positioner/MenuPositioner.d.ts

@@ -0,0 +1,39 @@
+import { type Accessor } from 'solid-js';
+import { type ValidComponent } from '@solidjs/web';
+import type { ReferenceElement, Strategy } from '@floating-ui/dom';
+import { type AnchorAlign, type AnchorBoundary, type AnchorSide, type CollisionAvoidance, type OffsetFunction } from '../../internals/overlay/index.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { MenuInstantType } from '../store/MenuStore.js';
+export type MenuAnchor = ReferenceElement | Accessor<ReferenceElement | null> | {
+    current: ReferenceElement | null;
+} | null;
+export interface MenuPositionerState {
+    open: boolean;
+    side: AnchorSide;
+    align: AnchorAlign;
+    anchorHidden: boolean;
+    nested: boolean;
+    instant: MenuInstantType | 'initial';
+}
+interface MenuPositionerOwnProps {
+    anchor?: MenuAnchor | undefined;
+    positionMethod?: Strategy | undefined;
+    side?: AnchorSide | undefined;
+    sideOffset?: number | OffsetFunction | undefined;
+    align?: AnchorAlign | undefined;
+    alignOffset?: number | OffsetFunction | undefined;
+    collisionBoundary?: AnchorBoundary | undefined;
+    collisionPadding?: number | Partial<Record<'top' | 'right' | 'bottom' | 'left', number>> | undefined;
+    arrowPadding?: number | undefined;
+    sticky?: boolean | undefined;
+    disableAnchorTracking?: boolean | undefined;
+    collisionAvoidance?: CollisionAvoidance | undefined;
+}
+export type MenuPositionerProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, MenuPositionerState, MenuPositionerOwnProps>;
+/** Positions the menu popup against its active trigger or a custom anchor. */
+export declare function MenuPositioner<Component extends ValidComponent = 'div'>(props: MenuPositioner.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace MenuPositioner {
+    type State = MenuPositionerState;
+    type Props<Component extends ValidComponent = 'div'> = MenuPositionerProps<Component>;
+}
+export {};

package/dist/lib/types/menu/positioner/MenuPositionerContext.d.ts

@@ -0,0 +1,5 @@
+import type { AnchorPositioning } from '../../internals/overlay/index.js';
+declare const MISSING_CONTEXT: unique symbol;
+export declare const MenuPositionerContext: import("solid-js").Context<AnchorPositioning | typeof MISSING_CONTEXT>;
+export declare function useMenuPositionerContext(optional?: boolean): AnchorPositioning | undefined;
+export {};

package/dist/lib/types/menu/radio-group/MenuRadioGroup.d.ts

@@ -0,0 +1,24 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { MenuRoot } from '../root/MenuRoot.js';
+export interface MenuRadioGroupState {
+    disabled: boolean;
+}
+interface MenuRadioGroupOwnProps {
+    value?: unknown;
+    defaultValue?: unknown;
+    onValueChange?: ((value: unknown, details: MenuRadioGroupChangeEventDetails) => void) | undefined;
+    disabled?: boolean | undefined;
+}
+export type MenuRadioGroupProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, MenuRadioGroupState, MenuRadioGroupOwnProps>;
+/** Groups related radio items. */
+export declare function MenuRadioGroup<Component extends ValidComponent = 'div'>(props: MenuRadioGroup.Props<Component>): import("@solidjs/web").JSX.Element;
+export type MenuRadioGroupChangeEventReason = MenuRoot.ChangeEventReason;
+export type MenuRadioGroupChangeEventDetails = MenuRoot.ChangeEventDetails;
+export declare namespace MenuRadioGroup {
+    type State = MenuRadioGroupState;
+    type Props<Component extends ValidComponent = 'div'> = MenuRadioGroupProps<Component>;
+    type ChangeEventReason = MenuRadioGroupChangeEventReason;
+    type ChangeEventDetails = MenuRadioGroupChangeEventDetails;
+}
+export {};

package/dist/lib/types/menu/radio-group/MenuRadioGroupContext.d.ts

@@ -0,0 +1,11 @@
+import { type Accessor } from 'solid-js';
+import type { MenuRadioGroupChangeEventDetails } from './MenuRadioGroup.js';
+export interface MenuRadioGroupContextValue {
+    value: Accessor<unknown>;
+    setValue(value: unknown, details: MenuRadioGroupChangeEventDetails): void;
+    disabled: Accessor<boolean>;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const MenuRadioGroupContext: import("solid-js").Context<MenuRadioGroupContextValue | typeof MISSING_CONTEXT>;
+export declare function useMenuRadioGroupContext(): MenuRadioGroupContextValue;
+export {};

package/dist/lib/types/menu/radio-item/MenuRadioItem.d.ts

@@ -0,0 +1,30 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface MenuRadioItemState {
+    disabled: boolean;
+    highlighted: boolean;
+    checked: boolean;
+}
+interface MenuRadioItemOwnProps {
+    value: unknown;
+    disabled?: boolean | undefined;
+    label?: string | undefined;
+    closeOnClick?: boolean | undefined;
+    nativeButton?: boolean | undefined;
+    onClick?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+    onFocus?: BaseUIEventHandlerUnion<HTMLElement, FocusEvent> | undefined;
+    onBlur?: BaseUIEventHandlerUnion<HTMLElement, FocusEvent> | undefined;
+    onKeyDown?: BaseUIEventHandlerUnion<HTMLElement, KeyboardEvent> | undefined;
+    onKeyUp?: BaseUIEventHandlerUnion<HTMLElement, KeyboardEvent> | undefined;
+    onMouseMove?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+    onMouseUp?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+}
+export type MenuRadioItemProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, MenuRadioItemState, MenuRadioItemOwnProps>;
+/** A radio item within a menu radio group. */
+export declare function MenuRadioItem<Component extends ValidComponent = 'div'>(props: MenuRadioItem.Props<Component>): JSX.Element;
+export declare namespace MenuRadioItem {
+    type State = MenuRadioItemState;
+    type Props<Component extends ValidComponent = 'div'> = MenuRadioItemProps<Component>;
+}
+export {};

package/dist/lib/types/menu/radio-item/MenuRadioItemContext.d.ts

@@ -0,0 +1,6 @@
+import { type Accessor } from 'solid-js';
+import type { MenuRadioItemState } from './MenuRadioItem.js';
+declare const MISSING_CONTEXT: unique symbol;
+export declare const MenuRadioItemContext: import("solid-js").Context<typeof MISSING_CONTEXT | Accessor<MenuRadioItemState>>;
+export declare function useMenuRadioItemContext(): Accessor<MenuRadioItemState>;
+export {};

package/dist/lib/types/menu/radio-item-indicator/MenuRadioItemIndicator.d.ts

@@ -0,0 +1,18 @@
+import { type ValidComponent } from '@solidjs/web';
+import { type TransitionStatus } from '../../internals/stateAttributesMapping.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { MenuRadioItemState } from '../radio-item/MenuRadioItem.js';
+export interface MenuRadioItemIndicatorState extends MenuRadioItemState {
+    transitionStatus: TransitionStatus;
+}
+interface OwnProps {
+    keepMounted?: boolean | undefined;
+}
+export type MenuRadioItemIndicatorProps<Component extends ValidComponent = 'span'> = BaseUIComponentProps<Component, MenuRadioItemIndicatorState, OwnProps>;
+/** Indicates whether the enclosing radio item is selected. */
+export declare function MenuRadioItemIndicator<Component extends ValidComponent = 'span'>(props: MenuRadioItemIndicator.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace MenuRadioItemIndicator {
+    type State = MenuRadioItemIndicatorState;
+    type Props<Component extends ValidComponent = 'span'> = MenuRadioItemIndicatorProps<Component>;
+}
+export {};