solid-baseui 0.1.0-alpha.0

package/dist/lib/types/menu/root/MenuRoot.d.ts

@@ -0,0 +1,56 @@
+import { type Accessor } from 'solid-js';
+import type { JSX } from '@solidjs/web';
+import { type MenubarContextValue } from '../../menubar/MenubarContext.js';
+import type { BaseUIChangeEventDetails } from '../../internals/createBaseUIEventDetails.js';
+import { REASONS } from '../../internals/reasons.js';
+import type { MenuHandle } from '../store/MenuHandle.js';
+import { MenuStore } from '../store/MenuStore.js';
+export interface MenuRootState {
+}
+export interface MenuRootActions {
+    unmount(): void;
+    close(): void;
+}
+export type MenuRootChangeEventReason = typeof REASONS.triggerHover | typeof REASONS.triggerFocus | typeof REASONS.triggerPress | typeof REASONS.outsidePress | typeof REASONS.focusOut | typeof REASONS.listNavigation | typeof REASONS.escapeKey | typeof REASONS.itemPress | typeof REASONS.closePress | typeof REASONS.siblingOpen | typeof REASONS.cancelOpen | typeof REASONS.imperativeAction | typeof REASONS.none;
+export type MenuRootChangeEventDetails = BaseUIChangeEventDetails<MenuRootChangeEventReason> & {
+    preventUnmountOnClose(): void;
+};
+export type MenuRootOrientation = 'horizontal' | 'vertical';
+export type MenuParent = {
+    type: 'menu';
+    store: MenuStore<unknown>;
+} | {
+    type: 'menubar';
+    context: MenubarContextValue;
+} | {
+    type: undefined;
+};
+export interface MenuRootProps<Payload = unknown> {
+    defaultOpen?: boolean | undefined;
+    loopFocus?: boolean | undefined;
+    highlightItemOnHover?: boolean | undefined;
+    modal?: boolean | undefined;
+    onOpenChange?: ((open: boolean, details: MenuRootChangeEventDetails) => void) | undefined;
+    onOpenChangeComplete?: ((open: boolean) => void) | undefined;
+    open?: boolean | undefined;
+    orientation?: MenuRootOrientation | undefined;
+    disabled?: boolean | undefined;
+    closeParentOnEsc?: boolean | undefined;
+    actionsRef?: ((actions: MenuRootActions) => void) | undefined;
+    triggerId?: string | null | undefined;
+    defaultTriggerId?: string | null | undefined;
+    handle?: MenuHandle<Payload> | undefined;
+    children?: JSX.Element | ((state: {
+        payload: Accessor<Payload | undefined>;
+    }) => JSX.Element);
+}
+/** Groups all parts of the menu without rendering an element. */
+export declare function MenuRoot<Payload = unknown>(props: MenuRoot.Props<Payload>): JSX.Element;
+export declare namespace MenuRoot {
+    type State = MenuRootState;
+    type Props<Payload = unknown> = MenuRootProps<Payload>;
+    type Actions = MenuRootActions;
+    type ChangeEventReason = MenuRootChangeEventReason;
+    type ChangeEventDetails = MenuRootChangeEventDetails;
+    type Orientation = MenuRootOrientation;
+}

package/dist/lib/types/menu/root/MenuRootContext.d.ts

@@ -0,0 +1,23 @@
+import { type Accessor } from 'solid-js';
+import type { ContextMenuRootContextValue } from '../../context-menu/root/ContextMenuRootContext.js';
+import type { FloatingNode, PopupPresence } from '../../internals/overlay/index.js';
+import type { MenuStore } from '../store/MenuStore.js';
+export interface MenuRootContextValue<Payload = unknown> {
+    store: MenuStore<Payload>;
+    node: FloatingNode;
+    nested: boolean;
+    presence: PopupPresence;
+    contextMenu: ContextMenuRootContextValue | undefined;
+    backdropElement: Accessor<HTMLElement | null>;
+    setBackdropElement(element: HTMLElement | null): void;
+    internalBackdropElement: Accessor<HTMLElement | null>;
+    setInternalBackdropElement(element: HTMLElement | null): void;
+    beforeContentGuard: Accessor<HTMLElement | null>;
+    setBeforeContentGuard(element: HTMLElement | null): void;
+    afterTriggerGuard: Accessor<HTMLElement | null>;
+    setAfterTriggerGuard(element: HTMLElement | null): void;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const MenuRootContext: import("solid-js").Context<typeof MISSING_CONTEXT | MenuRootContextValue<unknown>>;
+export declare function useMenuRootContext<Payload = unknown>(optional?: boolean): MenuRootContextValue<Payload> | undefined;
+export {};

package/dist/lib/types/menu/store/MenuCollection.d.ts

@@ -0,0 +1,19 @@
+import { type Accessor } from 'solid-js';
+export interface MenuCollectionItem {
+    token: symbol;
+    element: Accessor<HTMLElement | null>;
+    label: Accessor<string | undefined>;
+}
+export declare class MenuCollection {
+    private readonly registrations;
+    private readonly revision;
+    private readonly setRevision;
+    constructor();
+    register(item: MenuCollectionItem): () => void;
+    touch(): void;
+    items(): MenuCollectionItem[];
+    indexOf(token: symbol): number;
+    labels(): Array<string | null>;
+    elements(): Array<HTMLElement | null>;
+    availableIndices(): number[];
+}

package/dist/lib/types/menu/store/MenuHandle.d.ts

@@ -0,0 +1,10 @@
+import { BasePopupHandle } from '../../internals/overlay/index.js';
+import { MenuStore } from './MenuStore.js';
+/** Imperatively controls a Menu and connects detached triggers to its Root. */
+export declare class MenuHandle<Payload = unknown> extends BasePopupHandle<MenuStore<Payload>> {
+    constructor();
+    open(triggerId: string): void;
+    close(): void;
+    get isOpen(): boolean;
+}
+export declare function createMenuHandle<Payload = unknown>(): MenuHandle<Payload>;

package/dist/lib/types/menu/store/MenuStore.d.ts

@@ -0,0 +1,110 @@
+import { type Accessor } from 'solid-js';
+import type { ContextMenuRootContextValue } from '../../context-menu/root/ContextMenuRootContext.js';
+import type { MenubarContextValue } from '../../menubar/MenubarContext.js';
+import type { BaseUIChangeEventDetails } from '../../internals/createBaseUIEventDetails.js';
+import { PopupStore, type FloatingTreeStore, type InteractionType, type PopupStoreOptions } from '../../internals/overlay/index.js';
+import type { MenuRootChangeEventDetails, MenuRootChangeEventReason, MenuRootOrientation } from '../root/MenuRoot.js';
+import { MenuCollection } from './MenuCollection.js';
+export type MenuInstantType = 'dismiss' | 'click' | 'group' | 'trigger-change' | undefined;
+export interface MenuStoreOptions extends PopupStoreOptions<MenuRootChangeEventDetails> {
+    tree: FloatingTreeStore;
+    parentStore?: MenuStore<unknown> | undefined;
+    parentNodeId: string | null;
+    disabled: Accessor<boolean>;
+    modal: Accessor<boolean>;
+    orientation: Accessor<MenuRootOrientation>;
+    loopFocus: Accessor<boolean>;
+    highlightItemOnHover: Accessor<boolean>;
+    closeParentOnEsc: Accessor<boolean>;
+    direction: Accessor<'ltr' | 'rtl'>;
+    contextMenu?: ContextMenuRootContextValue | undefined;
+    menubar?: MenubarContextValue | undefined;
+}
+export declare class MenuStore<Payload = unknown> extends PopupStore<Payload, MenuRootChangeEventDetails> {
+    readonly parentStore: MenuStore<unknown> | undefined;
+    readonly collection: MenuCollection;
+    readonly disabled: Accessor<boolean>;
+    readonly modal: Accessor<boolean>;
+    readonly orientation: Accessor<MenuRootOrientation>;
+    readonly loopFocus: Accessor<boolean>;
+    readonly highlightItemOnHover: Accessor<boolean>;
+    readonly closeParentOnEsc: Accessor<boolean>;
+    readonly direction: Accessor<'ltr' | 'rtl'>;
+    readonly contextMenu: ContextMenuRootContextValue | undefined;
+    private readonly ownTree;
+    private readonly ownParentNodeId;
+    private readonly menubarAccessor;
+    private readonly setMenubarSignal;
+    private readonly triggerMenubars;
+    private readonly activeIndexAccessor;
+    private readonly setActiveIndexSignal;
+    private readonly activeElementAccessor;
+    private readonly setActiveElementSignal;
+    private readonly openMethodAccessor;
+    private readonly setOpenMethodSignal;
+    private openMethodValue;
+    private readonly openReasonAccessor;
+    private readonly setOpenReasonSignal;
+    private readonly instantTypeAccessor;
+    private readonly setInstantTypeSignal;
+    private readonly typingAccessor;
+    private readonly setTypingSignal;
+    private readonly hoverEnabledAccessor;
+    private readonly setHoverEnabledSignal;
+    private readonly allowMouseEnterAccessor;
+    private readonly setAllowMouseEnterSignal;
+    private readonly beforeContentGuardAccessor;
+    private readonly setBeforeContentGuardSignal;
+    private readonly afterTriggerGuardAccessor;
+    private readonly setAfterTriggerGuardSignal;
+    private pendingFocus;
+    private typed;
+    private typeaheadTimer;
+    private allowTouchToClose;
+    private allowTouchToCloseTimer;
+    private ownAllowMouseUpTrigger;
+    constructor(options: MenuStoreOptions);
+    get allowMouseUpTrigger(): boolean;
+    set allowMouseUpTrigger(value: boolean);
+    menubar(): MenubarContextValue | undefined;
+    tree(): FloatingTreeStore;
+    parentNodeId(): string | null;
+    registerMenubarTrigger(id: string, context: MenubarContextValue | undefined): () => void;
+    forwardMenubarTrigger(id: string, context: MenubarContextValue | undefined): void;
+    activateMenubarTrigger(id: string): void;
+    rootStore(): MenuStore<unknown>;
+    rootNodeId(): string | undefined;
+    relayKeyboardEvent(event: KeyboardEvent): void;
+    activeIndex(): number | null;
+    activeElement(): HTMLElement | null;
+    isItemActive(element: HTMLElement | null): boolean;
+    setActiveIndex(index: number | null, focus?: boolean): void;
+    setActiveElement(element: HTMLElement | null): void;
+    openMethod(): InteractionType | null;
+    setOpenMethod(value: InteractionType | null): void;
+    openChangeReason(): MenuRootChangeEventReason | null;
+    instantType(): MenuInstantType;
+    setInstantType(value: MenuInstantType): void;
+    typing(): boolean;
+    hoverEnabled(): boolean;
+    setHoverEnabled(value: boolean): void;
+    allowMouseEnter(): boolean;
+    setAllowMouseEnter(value: boolean): void;
+    beforeContentGuard(): HTMLElement | null;
+    setBeforeContentGuard(element: HTMLElement | null): void;
+    afterTriggerGuard(): HTMLElement | null;
+    setAfterTriggerGuard(element: HTMLElement | null): void;
+    setPendingFocus(value: 'first' | 'last' | null): void;
+    focusPendingItem(): boolean;
+    navigate(event: KeyboardEvent): boolean;
+    handleTypeahead(event: KeyboardEvent): boolean;
+    handleTriggerKeyDown(event: KeyboardEvent, trigger: Element): void;
+    closeTree(event: Event | undefined, reason: MenuRootChangeEventReason): void;
+    setOpen(open: boolean, details: MenuRootChangeEventDetails): boolean;
+    resetAfterObservedClose(): void;
+    dispose(): void;
+    protected shouldCommitOpenChange(open: boolean, details: MenuRootChangeEventDetails): boolean;
+}
+export type AnyMenuChangeDetails = BaseUIChangeEventDetails<string> & {
+    preventUnmountOnClose(): void;
+};

package/dist/lib/types/menu/submenu-root/MenuSubmenuRoot.d.ts

@@ -0,0 +1,17 @@
+import type { JSX } from '@solidjs/web';
+import { MenuRoot, type MenuRootProps } from '../root/MenuRoot.js';
+export interface MenuSubmenuRootState {
+}
+export type MenuSubmenuRootProps = Omit<MenuRootProps, 'children' | 'defaultTriggerId' | 'handle' | 'modal' | 'triggerId'> & {
+    children?: JSX.Element;
+};
+export type MenuSubmenuRootChangeEventReason = MenuRoot.ChangeEventReason;
+export type MenuSubmenuRootChangeEventDetails = MenuRoot.ChangeEventDetails;
+/** Groups all parts of a submenu without rendering an element. */
+export declare function MenuSubmenuRoot(props: MenuSubmenuRoot.Props): JSX.Element;
+export declare namespace MenuSubmenuRoot {
+    type State = MenuSubmenuRootState;
+    type Props = MenuSubmenuRootProps;
+    type ChangeEventReason = MenuSubmenuRootChangeEventReason;
+    type ChangeEventDetails = MenuSubmenuRootChangeEventDetails;
+}

package/dist/lib/types/menu/submenu-root/MenuSubmenuRootContext.d.ts

@@ -0,0 +1,8 @@
+import type { MenuStore } from '../store/MenuStore.js';
+export interface MenuSubmenuRootContextValue {
+    parentStore: MenuStore<unknown>;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const MenuSubmenuRootContext: import("solid-js").Context<MenuSubmenuRootContextValue | typeof MISSING_CONTEXT>;
+export declare function useMenuSubmenuRootContext(optional?: boolean): MenuSubmenuRootContextValue | undefined;
+export {};

package/dist/lib/types/menu/submenu-trigger/MenuSubmenuTrigger.d.ts

@@ -0,0 +1,33 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface MenuSubmenuTriggerState {
+    disabled: boolean;
+    highlighted: boolean;
+    open: boolean;
+}
+interface MenuSubmenuTriggerOwnProps {
+    label?: string | undefined;
+    disabled?: boolean | undefined;
+    delay?: number | undefined;
+    closeDelay?: number | undefined;
+    openOnHover?: 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;
+    onMouseDown?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+    onMouseMove?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+    onMouseUp?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+    onMouseEnter?: BaseUIEventHandlerUnion<HTMLElement, MouseEvent> | undefined;
+}
+export type MenuSubmenuTriggerProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, MenuSubmenuTriggerState, MenuSubmenuTriggerOwnProps>;
+/** A menu item that opens a submenu. */
+export declare function MenuSubmenuTrigger<Component extends ValidComponent = 'div'>(props: MenuSubmenuTrigger.Props<Component>): JSX.Element;
+export declare namespace MenuSubmenuTrigger {
+    type State = MenuSubmenuTriggerState;
+    type Props<Component extends ValidComponent = 'div'> = MenuSubmenuTriggerProps<Component>;
+}
+export {};

package/dist/lib/types/menu/trigger/MenuTrigger.d.ts

@@ -0,0 +1,36 @@
+import { type ComponentProps, type JSX, type ValidComponent } from '@solidjs/web';
+import { type BaseUIEventHandlerUnion } from '../../internals/composeEventHandlers.js';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { MenuHandle } from '../store/MenuHandle.js';
+export interface MenuTriggerState {
+    disabled: boolean;
+    open: boolean;
+}
+type TriggerEventTarget<Component extends ValidComponent> = ComponentProps<Component> extends {
+    onClick?: JSX.EventHandlerUnion<infer Target, MouseEvent> | undefined;
+} ? Target extends HTMLElement ? Target : HTMLElement : HTMLElement;
+interface MenuTriggerOwnProps<Payload, Component extends ValidComponent> {
+    handle?: MenuHandle<Payload> | undefined;
+    payload?: Payload | undefined;
+    disabled?: boolean | undefined;
+    nativeButton?: boolean | undefined;
+    openOnHover?: boolean | undefined;
+    delay?: number | undefined;
+    closeDelay?: number | undefined;
+    onClick?: BaseUIEventHandlerUnion<TriggerEventTarget<Component>, MouseEvent> | undefined;
+    onBlur?: BaseUIEventHandlerUnion<TriggerEventTarget<Component>, FocusEvent> | undefined;
+    onFocus?: BaseUIEventHandlerUnion<TriggerEventTarget<Component>, FocusEvent> | undefined;
+    onKeyDown?: BaseUIEventHandlerUnion<TriggerEventTarget<Component>, KeyboardEvent> | undefined;
+    onKeyUp?: BaseUIEventHandlerUnion<TriggerEventTarget<Component>, KeyboardEvent> | undefined;
+    onMouseDown?: BaseUIEventHandlerUnion<TriggerEventTarget<Component>, MouseEvent> | undefined;
+    onMouseMove?: BaseUIEventHandlerUnion<TriggerEventTarget<Component>, MouseEvent> | undefined;
+    onPointerDown?: BaseUIEventHandlerUnion<TriggerEventTarget<Component>, PointerEvent> | undefined;
+}
+export type MenuTriggerProps<Payload = unknown, Component extends ValidComponent = 'button'> = BaseUIComponentProps<Component, MenuTriggerState, MenuTriggerOwnProps<Payload, Component>>;
+/** A button that opens the menu. */
+export declare function MenuTrigger<Payload = unknown, Component extends ValidComponent = 'button'>(props: MenuTrigger.Props<Payload, Component>): JSX.Element;
+export declare namespace MenuTrigger {
+    type State = MenuTriggerState;
+    type Props<Payload = unknown, Component extends ValidComponent = 'button'> = MenuTriggerProps<Payload, Component>;
+}
+export {};

package/dist/lib/types/menu/utils/mergeMenuStyles.d.ts

@@ -0,0 +1,2 @@
+import type { JSX } from '@solidjs/web';
+export declare function mergeMenuStyles(internal: JSX.CSSProperties, external: JSX.CSSProperties | string | false | undefined): JSX.CSSProperties | string;

package/dist/lib/types/menu/utils/stateAttributesMapping.d.ts

@@ -0,0 +1,39 @@
+export declare const menuPositionerStateMapping: {
+    nested: (value: boolean) => {
+        'data-nested': string;
+    } | null;
+    open: (value: boolean) => {
+        'data-open': string;
+    } | {
+        'data-closed': string;
+    };
+    anchorHidden: (value: boolean) => {
+        'data-anchor-hidden': string;
+    } | null;
+};
+export declare const menuPopupStateMapping: {
+    nested: (value: boolean) => {
+        'data-nested': string;
+    } | null;
+    transitionStatus(value: import("../../internals/stateAttributesMapping.js").TransitionStatus): Record<string, string> | null;
+    open: (value: boolean) => {
+        'data-open': string;
+    } | {
+        'data-closed': string;
+    };
+    anchorHidden: (value: boolean) => {
+        'data-anchor-hidden': string;
+    } | null;
+};
+export declare const menuViewportStateMapping: {
+    activationDirection: (value: string | undefined) => {
+        'data-activation-direction': string;
+    } | null;
+};
+export declare const menuItemStateMapping: {
+    checked: (value: boolean) => {
+        'data-checked': string;
+    } | {
+        'data-unchecked': string;
+    };
+};

package/dist/lib/types/menu/viewport/MenuViewport.d.ts

@@ -0,0 +1,15 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { MenuInstantType } from '../store/MenuStore.js';
+export interface MenuViewportState {
+    activationDirection: string | undefined;
+    transitioning: boolean;
+    instant: MenuInstantType;
+}
+export type MenuViewportProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, MenuViewportState>;
+/** Displays content transitions when the active menu trigger changes. */
+export declare function MenuViewport<Component extends ValidComponent = 'div'>(props: MenuViewport.Props<Component>): JSX.Element;
+export declare namespace MenuViewport {
+    type State = MenuViewportState;
+    type Props<Component extends ValidComponent = 'div'> = MenuViewportProps<Component>;
+}

package/dist/lib/types/menubar/Menubar.d.ts

@@ -0,0 +1,23 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../types/index.js';
+import type { MenuRootOrientation } from '../menu/root/MenuRoot.js';
+export interface MenubarState {
+    orientation: MenuRootOrientation;
+    modal: boolean;
+    hasSubmenuOpen: boolean;
+}
+interface MenubarOwnProps {
+    children?: JSX.Element;
+    modal?: boolean | undefined;
+    disabled?: boolean | undefined;
+    orientation?: MenuRootOrientation | undefined;
+    loopFocus?: boolean | undefined;
+}
+export type MenubarProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, MenubarState, MenubarOwnProps>;
+/** A menu bar providing commands and options for an application. */
+export declare function Menubar<Component extends ValidComponent = 'div'>(props: Menubar.Props<Component>): JSX.Element;
+export declare namespace Menubar {
+    type State = MenubarState;
+    type Props<Component extends ValidComponent = 'div'> = MenubarProps<Component>;
+}
+export {};

package/dist/lib/types/menubar/MenubarContext.d.ts

@@ -0,0 +1,34 @@
+import { type Accessor } from 'solid-js';
+import type { FloatingTreeStore } from '../internals/overlay/index.js';
+import type { MenuRootOrientation } from '../menu/root/MenuRoot.js';
+export interface MenubarTriggerRegistration {
+    token: symbol;
+    order: number;
+    element: Accessor<HTMLElement | null>;
+    disabled: Accessor<boolean>;
+}
+export interface MenubarContextValue {
+    modal: Accessor<boolean>;
+    disabled: Accessor<boolean>;
+    orientation: Accessor<MenuRootOrientation>;
+    hasSubmenuOpen: Accessor<boolean>;
+    rootElement: Accessor<HTMLElement | null>;
+    rootId: Accessor<string>;
+    tree: FloatingTreeStore;
+    nodeId: string;
+    allowMouseUpTrigger: {
+        value: boolean;
+    };
+    createTriggerId(): string;
+    isTabStop(item: MenubarTriggerRegistration): boolean;
+    notifyItemChange(): void;
+    registerTrigger(item: MenubarTriggerRegistration): () => void;
+    setActiveTrigger(item: MenubarTriggerRegistration): void;
+    relayKeyboardEvent(event: KeyboardEvent): void;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const MenubarContext: import("solid-js").Context<MenubarContextValue | typeof MISSING_CONTEXT>;
+export declare function useMenubarContext(): MenubarContextValue;
+export declare function useMenubarContext(optional: false): MenubarContextValue;
+export declare function useMenubarContext(optional: true): MenubarContextValue | undefined;
+export {};

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

@@ -0,0 +1,2 @@
+export { Menubar } from './Menubar.js';
+export type * from './Menubar.js';

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

@@ -0,0 +1,6 @@
+export * as Meter from './index.parts.js';
+export type { MeterRootProps, MeterRootState } from './root/MeterRoot.js';
+export type { MeterTrackProps, MeterTrackState } from './track/MeterTrack.js';
+export type { MeterIndicatorProps, MeterIndicatorState } from './indicator/MeterIndicator.js';
+export type { MeterValueProps, MeterValueState } from './value/MeterValue.js';
+export type { MeterLabelProps, MeterLabelState } from './label/MeterLabel.js';

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

@@ -0,0 +1,5 @@
+export { MeterRoot as Root } from './root/MeterRoot.js';
+export { MeterTrack as Track } from './track/MeterTrack.js';
+export { MeterIndicator as Indicator } from './indicator/MeterIndicator.js';
+export { MeterValue as Value } from './value/MeterValue.js';
+export { MeterLabel as Label } from './label/MeterLabel.js';

package/dist/lib/types/meter/indicator/MeterIndicator.d.ts

@@ -0,0 +1,12 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { MeterRootState } from '../root/MeterRoot.js';
+export interface MeterIndicatorState extends MeterRootState {
+}
+export type MeterIndicatorProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, MeterIndicatorState>;
+/** Visualizes the current value's position within the meter range. */
+export declare function MeterIndicator<Component extends ValidComponent = 'div'>(props: MeterIndicator.Props<Component>): JSX.Element;
+export declare namespace MeterIndicator {
+    type State = MeterIndicatorState;
+    type Props<Component extends ValidComponent = 'div'> = MeterIndicatorProps<Component>;
+}

package/dist/lib/types/meter/label/MeterLabel.d.ts

@@ -0,0 +1,17 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { MeterRootState } from '../root/MeterRoot.js';
+export interface MeterLabelState extends MeterRootState {
+}
+interface MeterLabelOwnProps {
+    /** The id used to label the meter. */
+    id?: string | undefined;
+}
+export type MeterLabelProps<Component extends ValidComponent = 'span'> = BaseUIComponentProps<Component, MeterLabelState, MeterLabelOwnProps>;
+/** An accessible label that is automatically associated with the meter. */
+export declare function MeterLabel<Component extends ValidComponent = 'span'>(props: MeterLabel.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace MeterLabel {
+    type State = MeterLabelState;
+    type Props<Component extends ValidComponent = 'span'> = MeterLabelProps<Component>;
+}
+export {};

package/dist/lib/types/meter/root/MeterRoot.d.ts

@@ -0,0 +1,28 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+export interface MeterRootState {
+}
+interface MeterRootOwnProps {
+    /** A human-readable text alternative for the current numeric value. */
+    'aria-valuetext'?: string | undefined;
+    /** Options used to format the clamped value. */
+    format?: Intl.NumberFormatOptions | undefined;
+    /** Returns the human-readable text alternative for the current value. */
+    getAriaValueText?: ((formattedValue: string, value: number) => string) | undefined;
+    /** The locale used by `Intl.NumberFormat`. */
+    locale?: Intl.LocalesArgument | undefined;
+    /** The maximum value. @default 100 */
+    max?: number | undefined;
+    /** The minimum value. @default 0 */
+    min?: number | undefined;
+    /** The current value. */
+    value: number;
+}
+export type MeterRootProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, MeterRootState, MeterRootOwnProps>;
+/** Groups all meter parts and exposes the current value to assistive technology. */
+export declare function MeterRoot<Component extends ValidComponent = 'div'>(props: MeterRoot.Props<Component>): JSX.Element;
+export declare namespace MeterRoot {
+    type State = MeterRootState;
+    type Props<Component extends ValidComponent = 'div'> = MeterRootProps<Component>;
+}
+export {};

package/dist/lib/types/meter/root/MeterRootContext.d.ts

@@ -0,0 +1,12 @@
+import { type Accessor, type Setter } from 'solid-js';
+export interface MeterRootContextValue {
+    formattedValue: Accessor<string>;
+    /** The value normalized to a clamped percentage from 0 to 100. */
+    percentageValue: Accessor<number>;
+    setLabelId: Setter<string | undefined>;
+    value: Accessor<number>;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const MeterRootContext: import("solid-js").Context<MeterRootContextValue | typeof MISSING_CONTEXT>;
+export declare function useMeterRootContext(): MeterRootContextValue;
+export {};

package/dist/lib/types/meter/track/MeterTrack.d.ts

@@ -0,0 +1,12 @@
+import { type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { MeterRootState } from '../root/MeterRoot.js';
+export interface MeterTrackState extends MeterRootState {
+}
+export type MeterTrackProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, MeterTrackState>;
+/** Contains the indicator and represents the meter's complete range. */
+export declare function MeterTrack<Component extends ValidComponent = 'div'>(props: MeterTrack.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace MeterTrack {
+    type State = MeterTrackState;
+    type Props<Component extends ValidComponent = 'div'> = MeterTrackProps<Component>;
+}

package/dist/lib/types/meter/value/MeterValue.d.ts

@@ -0,0 +1,16 @@
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import type { BaseUIComponentProps } from '../../types/index.js';
+import type { MeterRootState } from '../root/MeterRoot.js';
+export interface MeterValueState extends MeterRootState {
+}
+interface MeterValueOwnProps {
+    children?: null | ((formattedValue: string, value: number) => JSX.Element) | undefined;
+}
+export type MeterValueProps<Component extends ValidComponent = 'span'> = BaseUIComponentProps<Component, MeterValueState, MeterValueOwnProps>;
+/** Displays the meter's formatted current value. */
+export declare function MeterValue<Component extends ValidComponent = 'span'>(props: MeterValue.Props<Component>): JSX.Element;
+export declare namespace MeterValue {
+    type State = MeterValueState;
+    type Props<Component extends ValidComponent = 'span'> = MeterValueProps<Component>;
+}
+export {};

package/dist/lib/types/navigation-menu/arrow/NavigationMenuArrow.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 NavigationMenuArrowState {
+    open: boolean;
+    side: AnchorSide;
+    align: AnchorAlign;
+    uncentered: boolean;
+}
+export type NavigationMenuArrowProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, NavigationMenuArrowState>;
+/** Displays an element pointing toward the active navigation trigger. */
+export declare function NavigationMenuArrow<Component extends ValidComponent = 'div'>(props: NavigationMenuArrow.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace NavigationMenuArrow {
+    type State = NavigationMenuArrowState;
+    type Props<Component extends ValidComponent = 'div'> = NavigationMenuArrowProps<Component>;
+}

package/dist/lib/types/navigation-menu/backdrop/NavigationMenuBackdrop.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 NavigationMenuBackdropState {
+    open: boolean;
+    transitionStatus: TransitionStatus;
+}
+export type NavigationMenuBackdropProps<Component extends ValidComponent = 'div'> = BaseUIComponentProps<Component, NavigationMenuBackdropState>;
+/** A presentational backdrop beneath the navigation menu popup. */
+export declare function NavigationMenuBackdrop<Component extends ValidComponent = 'div'>(props: NavigationMenuBackdrop.Props<Component>): import("@solidjs/web").JSX.Element;
+export declare namespace NavigationMenuBackdrop {
+    type State = NavigationMenuBackdropState;
+    type Props<Component extends ValidComponent = 'div'> = NavigationMenuBackdropProps<Component>;
+}

package/dist/lib/types/navigation-menu/composite/NavigationMenuCompositeContext.d.ts

@@ -0,0 +1,22 @@
+import { type Accessor } from 'solid-js';
+export interface NavigationMenuCompositeItem {
+    token: symbol;
+    order: number;
+    element: Accessor<HTMLElement | null>;
+    disabled: Accessor<boolean>;
+}
+export interface NavigationMenuCompositeContextValue {
+    isTabStop(item: NavigationMenuCompositeItem): boolean;
+    notifyItemChange(): void;
+    registerItem(item: NavigationMenuCompositeItem): () => void;
+    setActiveItem(item: NavigationMenuCompositeItem): void;
+    handleKeyDown(event: KeyboardEvent): boolean;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const NavigationMenuCompositeContext: import("solid-js").Context<NavigationMenuCompositeContextValue | typeof MISSING_CONTEXT>;
+export declare function useNavigationMenuCompositeContext(): NavigationMenuCompositeContextValue | undefined;
+export declare function createNavigationMenuComposite(options: {
+    orientation: Accessor<'horizontal' | 'vertical'>;
+    direction: Accessor<'ltr' | 'rtl'>;
+}): NavigationMenuCompositeContextValue;
+export {};