@iress-oss/ids-components 0.0.1-dev.9 → 5.13.1

package/dist/src/components/Inline/Inline.types.d.ts

@@ -0,0 +1,41 @@
+import { IressHTMLAttributes, ResponsiveSizing } from '../../interfaces';
+import { ReactNode } from 'react';
+import { GutterSize, HorizontalAlign, VerticalAlign } from '../../enums';
+import { GutterSizes, HorizontalAligns, VerticalAligns } from '../../types';
+export interface IressInlineProps extends IressHTMLAttributes {
+    /**
+     * Content to be displayed inline.
+     */
+    children?: ReactNode;
+    /**
+     * Sets the spacing between inline content.
+     */
+    gutter?: GutterSize | GutterSizes | ResponsiveSizing<GutterSize | GutterSizes>;
+    /**
+     * Sets the horizontal alignment of the inline content.
+     */
+    horizontalAlign?: HorizontalAlign | HorizontalAligns;
+    /**
+     * Wraps content when stretches beyond container.
+     */
+    noWrap?: boolean;
+    /**
+     * Sets the vertical alignment of the inline content.
+     */
+    verticalAlign?: VerticalAlign | VerticalAligns;
+}
+export interface InlineWithEnums extends React.FC<IressInlineProps> {
+    /** @deprecated IressInline.Gutter is now deprecated and will be removed in a future version. Please use the value directly instead. */
+    Gutter: typeof GutterSize;
+    /** @deprecated IressInline.HorizontalAlign is now deprecated and will be removed in a future version. Please use the value directly instead. */
+    HorizontalAlign: typeof HorizontalAlign;
+    /** @deprecated IressInline.VerticalAlign is now deprecated and will be removed in a future version. Please use the value directly instead. */
+    VerticalAlign: typeof VerticalAlign;
+}
+export declare enum InlineCssClass {
+    Base = "iress-u-inline",
+    NoWrap = "iress--no-wrap",
+    HorizontalAlign = "iress--h-align",
+    VerticalAlign = "iress--v-align",
+    Gutter = "iress--gutter"
+}

package/dist/src/components/Inline/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Inline.types';
+export * from './Inline';

package/dist/src/components/Input/ClearButton/ClearButton.d.ts

@@ -0,0 +1,4 @@
+import { IressButtonHTMLAttributes } from '../../../main';
+type ClearButtonProps = IressButtonHTMLAttributes<HTMLButtonElement>;
+export declare const ClearButton: React.FC<ClearButtonProps>;
+export {};

package/dist/src/components/Input/Input.d.ts

@@ -0,0 +1,14 @@
+import { FormElementWidth, TextFieldType } from '../../enums';
+import { InputMode, IressInputProps } from './Input.types';
+import { InputRef } from './InputBase/InputBase.types';
+import { FormControlValue } from '../../types';
+declare const ForwardedInput: <T extends FormControlValue>(props: IressInputProps<T> & React.RefAttributes<InputRef | null>) => React.ReactElement;
+export declare const IressInput: typeof ForwardedInput & {
+    /** @deprecated IressInput.Type is now deprecated and will be removed in a future version. Please use the value directly instead. **/
+    Type: typeof TextFieldType;
+    /** @deprecated IressInput.Width is now deprecated and will be removed in a future version. Please use the value directly instead. **/
+    Width: typeof FormElementWidth;
+    /** @deprecated IressInput.InputMode is now deprecated and will be removed in a future version. Please use the value directly instead. **/
+    InputMode: typeof InputMode;
+};
+export {};

package/dist/src/components/Input/Input.types.d.ts

@@ -0,0 +1,73 @@
+import { FormElementWidth } from '../../enums';
+import { FormControlValue, FormElementWidths } from '../../types';
+import { InputBaseElement, InputBaseProps } from './InputBase/InputBase.types';
+export interface IressInputProps<T extends FormControlValue = string | number> extends Omit<InputBaseProps, 'defaultValue' | 'onChange' | 'value'> {
+    /**
+     * Content to append to the input field, usually a button or icon.
+     **/
+    append?: React.ReactNode;
+    /**
+     * If `true`, then user can clear the value of the input. Will be ignored if `rows` prop is in use.
+     */
+    clearable?: boolean;
+    /**
+     * The value of the input. Can be a string or a number. Use for uncontrolled inputs.
+     */
+    defaultValue?: T;
+    /**
+     * Bring your own formatter that will be used to format the value when the input is not focused, allowing you to display the value in a different format.
+     * e.g. User type in value="dsf 987kkk123" => result after formatter: $987,123 (string)
+     */
+    formatter?: (value?: T) => string | number;
+    /**
+     * The loading states of the input field. If provided a string, will use that text as the loading message.
+     */
+    loading?: boolean | string;
+    /**
+     * Emitted when the input value changes with the new changed value.
+     */
+    onChange?: (e: React.ChangeEvent<InputBaseElement>, value: T) => void;
+    /**
+     * Emitted when the input is manually cleared.
+     */
+    onClear?: (e: React.ChangeEvent<InputBaseElement>) => void;
+    /**
+     * Content to prepended to the input field, usually an icon.
+     **/
+    prepend?: React.ReactNode;
+    /**
+     * The value of the input. Can be a string or a number. Use for controlled inputs.
+     */
+    value?: T;
+    /**
+     * When set to `true` add ons will render with a different style. Will be ignored if `prepend` or `append` props are not being used.
+     */
+    watermark?: boolean;
+    /**
+     * The width of the input.
+     */
+    width?: FormElementWidth | FormElementWidths;
+    /**
+     * Make prepend/append element closer to the input content.
+     */
+    inline?: boolean;
+    /**
+     * Set input content align to right.
+     */
+    alignRight?: boolean;
+}
+/** @deprecated InputMode enum is now deprecated and will be removed in a future version. Please use the InputModes type instead. */
+export declare enum InputMode {
+    None = "none",
+    Text = "text",
+    Tel = "tel",
+    Url = "url",
+    Email = "email",
+    Numeric = "numeric",
+    Decimal = "decimal",
+    Search = "search",
+    DateTimeLocal = "datetime-local"
+}
+export declare const INPUT_MODES: readonly ["none", "text", "tel", "url", "email", "numeric", "decimal", "search", "datetime-local"];
+export type InputModes = (typeof INPUT_MODES)[number];
+export type InputElementType = HTMLInputElement & HTMLTextAreaElement;

package/dist/src/components/Input/InputBase/InputBase.d.ts

@@ -0,0 +1,9 @@
+import { InputBaseProps, InputRef } from './InputBase.types';
+/**
+ * `InputBase` is a versatile input field component that can be used as either a text input or a textarea.
+ *
+ * If the `rows` prop is greater than 0, it will render a textarea; otherwise, it will render a regular text input.
+ *
+ * - **Ref Forwarding and Imperative Handle**: This component forwards a ref to the input or textarea element and provides a `focus` method via `useImperativeHandle`. This allows parent components to programmatically focus the input.
+ */
+export declare const InputBase: import('react').ForwardRefExoticComponent<InputBaseProps & import('react').RefAttributes<InputRef>>;

package/dist/src/components/Input/InputBase/InputBase.types.d.ts

@@ -0,0 +1,15 @@
+import { IressInputHTMLAttributes } from '../../../interfaces';
+export type InputBaseElement = HTMLTextAreaElement | HTMLInputElement;
+export interface FocusableElementRef {
+    focus: () => void;
+    blur: () => void;
+}
+export type InputRef = FocusableElementRef & {
+    input?: InputBaseElement | null;
+};
+export interface InputBaseProps extends IressInputHTMLAttributes<InputBaseElement> {
+    /**
+     * Number of rows in the `textarea` (when set the component renders a textarea element)
+     */
+    rows?: number;
+}

package/dist/src/components/Input/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Input';
+export * from './Input.types';
+export * from './InputBase/InputBase.types';

package/dist/src/components/InputCurrency/InputCurrency.d.ts

@@ -0,0 +1,4 @@
+import { IressInputCurrencyProps } from './InputCurrency.types';
+import { InputRef } from '../Input/InputBase/InputBase.types';
+import { default as React } from 'react';
+export declare const IressInputCurrency: React.ForwardRefExoticComponent<IressInputCurrencyProps & React.RefAttributes<InputRef>>;

package/dist/src/components/InputCurrency/InputCurrency.types.d.ts

@@ -0,0 +1,23 @@
+import { IressInputProps } from '../Input/Input.types';
+export interface IressInputCurrencyProps extends IressInputProps {
+    /**
+     * Set the region of the currency, default is `en-AU`.
+     */
+    locale?: Intl.LocalesArgument;
+    /**
+     * Set the currency symbol and appended currency code, default is `AUD`.
+     */
+    currencyCode?: string;
+    /**
+     * Pass more format options, examples in here: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/NumberFormat
+     */
+    formatOptions?: Omit<Intl.NumberFormatOptions, 'currency'>;
+    /**
+     * Set the currency symbol.
+     */
+    withSymbol?: boolean;
+    /**
+     * Set input content align to right.
+     */
+    alignRight?: boolean;
+}

package/dist/src/components/InputCurrency/index.d.ts

@@ -0,0 +1,2 @@
+export * from './InputCurrency';
+export * from './InputCurrency.types';

package/dist/src/components/Label/Label.d.ts

@@ -0,0 +1,2 @@
+import { IressLabelProps } from './Label.types';
+export declare const IressLabel: (props: IressLabelProps) => import("react/jsx-runtime").JSX.Element;

package/dist/src/components/Label/Label.types.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+import { LabelBaseProps } from './LabelBase/LabelBase.types';
+export interface IressLabelProps extends Omit<LabelBaseProps, 'as'> {
+    /**
+     * Content to be displayed in the label.
+     * This can also include error messages to make sure it makes sense in this context.
+     */
+    children: ReactNode;
+    /**
+     * Used to connect it to the input element, it should be the input's id.
+     *
+     * [Learn more](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/for)
+     */
+    htmlFor?: string;
+}

package/dist/src/components/Label/LabelBase/LabelBase.d.ts

@@ -0,0 +1,2 @@
+import { LabelBaseProps } from './LabelBase.types';
+export declare const LabelBase: ({ append, as: BaseTag, children, className, "data-testid": dataTestId, hiddenLabel, optional, required, ...restProps }: LabelBaseProps) => import("react/jsx-runtime").JSX.Element;

package/dist/src/components/Label/LabelBase/LabelBase.types.d.ts

@@ -0,0 +1,35 @@
+import { WithDataAttributes } from '../../../interfaces';
+import { ElementType, ReactNode } from 'react';
+export type LabelBaseProps<T = ElementType, U = LabelHTMLAttributes<T>> = U & {
+    /**
+     * Content to be appended to the label.
+     * This is not affected by the `hiddenLabel` prop.
+     */
+    append?: ReactNode;
+    /**
+     * The base tag of the label.
+     * @default label
+     */
+    as?: T;
+    /**
+     * Content to be displayed in the label.
+     * This can also include error messages to make sure it makes sense in this context.
+     */
+    children: ReactNode;
+    /**
+     * Visually hides the label text, but still available to screen readers.
+     */
+    hiddenLabel?: boolean;
+    /**
+     * When set to true, the text '(optional)' is displayed next to the label text.
+     * Can also be a string to display custom optional text.
+     * Will be ignored if `required` is `true`.
+     */
+    optional?: boolean | string;
+    /**
+     * When set to true, the 'required asterisk (*)' is displayed next to the label text.
+     */
+    required?: boolean;
+};
+type LabelHTMLAttributes<T = HTMLLabelElement> = WithDataAttributes<React.LabelHTMLAttributes<T>>;
+export {};

package/dist/src/components/Label/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Label.types';
+export * from './Label';

package/dist/src/components/Menu/Menu.d.ts

@@ -0,0 +1,2 @@
+import { MenuWithEnums } from './Menu.types';
+export declare const IressMenu: MenuWithEnums;

package/dist/src/components/Menu/Menu.types.d.ts

@@ -0,0 +1,130 @@
+import { IressHTMLAttributes } from '../../interfaces';
+import { FormControlValue } from '../../types';
+import { PropsWithChildren } from 'react';
+export interface IressMenuProps extends Omit<IressHTMLAttributes, 'defaultValue' | 'onChange' | 'value'> {
+    /**
+     * If set to true, change event will be fired with the correctly selected value.
+     */
+    changeOnBlur?: boolean;
+    /**
+     * Content of the menu, usually multiple `IressMenuItem`, `IressMenuHeading` or `IressMenuDivider`.
+     */
+    children?: React.ReactNode;
+    /**
+     * Initially selected values of menu when `role` is listbox.
+     * Used for uncontrolled menus.
+     */
+    defaultSelected?: MenuSelected;
+    /**
+     * If set to true, menu will fill the width of its container.
+     */
+    fluid?: boolean;
+    /**
+     * Unique ID of the menu. If not provided, will be automatically generated.
+     * Used to add aria attributes for accessibility.
+     */
+    id?: string;
+    /**
+     * Sets whether the layout is vertical (stack) or horizontal (inline/inline-equal-width).
+     * @default stack
+     */
+    layout?: MenuLayout | MenuLayouts;
+    /**
+     * If set to true, menu items will contain checkboxes.
+     */
+    multiSelect?: boolean;
+    /**
+     * If set to true, menu items will not wrap onto a separate line when space is exceeded.
+     */
+    noWrap?: boolean;
+    /**
+     * Emitted when the menu value changes
+     */
+    onChange?: (value?: MenuSelected | null) => void;
+    /**
+     * Selected values of menu when `role` is listbox.
+     * Used for controlled menus.
+     */
+    selected?: MenuSelected;
+    /**
+     * Type of menu, corresponding to [aria-roles](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles).
+     * Will be set automatically when used inside popover or when the `multiSelect` prop is set to true.
+     */
+    role?: MenuType | MenuRoles;
+    /**
+     * Type of Menu - will be set automatically when used inside popover or when the multiSelect prop is set to true.
+     * @deprecated Use `role` instead.
+     */
+    type?: MenuType;
+}
+export interface MenuProviderProps extends PropsWithChildren {
+    changeOnBlur?: boolean;
+    defaultSelected?: MenuSelected;
+    id: string;
+    layout: MenuLayouts;
+    multiSelect?: boolean;
+    nav?: boolean;
+    noWrap?: boolean;
+    onChange?: (value?: MenuSelected) => void;
+    role?: MenuRoles;
+    selected?: MenuSelected;
+}
+export interface MenuContextValue {
+    changeOnBlur?: boolean;
+    hasArrowKeyNav?: boolean;
+    id: string;
+    isSelected: (value?: FormControlValue) => boolean;
+    layout: MenuLayouts;
+    multiSelect?: boolean;
+    nav?: boolean;
+    noWrap?: boolean;
+    role?: MenuRoles;
+    selected?: MenuSelected;
+    supportsSelection: boolean;
+    toggle: (value?: FormControlValue, flag?: boolean) => void;
+}
+export interface MenuAriaHookProps {
+    fluid?: boolean;
+    id: string;
+    layout?: MenuLayouts;
+    multiSelect?: boolean;
+    noWrap?: boolean;
+    role?: MenuRoles;
+}
+export interface MenuAriaHookReturn {
+    'aria-multiselectable'?: boolean;
+    'aria-orientation'?: 'horizontal' | 'vertical';
+}
+export interface MenuStylesHookProps {
+    className?: string;
+    fluid?: boolean;
+    layout?: MenuLayouts;
+    role?: MenuRoles;
+}
+export interface MenuStylesHookReturn {
+    className: string;
+}
+export type MenuSelected = FormControlValue | FormControlValue[];
+/** @deprecated MenuType enum is now deprecated and will be removed in a future version. Please use the MenuRoles type instead. **/
+export declare enum MenuType {
+    Menu = "menu",
+    List = "list",
+    Listbox = "listbox",
+    Nav = "nav"
+}
+export declare const MENU_ROLES: readonly ["menu", "list", "listbox", "nav"];
+export type MenuRoles = (typeof MENU_ROLES)[number];
+/** @deprecated MenuLayout enum is now deprecated and will be removed in a future version. Please use the MenuLayouts enum instead. **/
+export declare enum MenuLayout {
+    Stack = "stack",
+    Inline = "inline",
+    InlineEqualWidth = "inline-equal-width"
+}
+export declare const MENU_LAYOUTS: readonly ["stack", "inline", "inline-equal-width"];
+export type MenuLayouts = (typeof MENU_LAYOUTS)[number];
+export interface MenuWithEnums extends React.FC<IressMenuProps> {
+    /** @deprecated IressMenu.Layout enum is now deprecated and will be removed in a future version. Please use the value directly instead. **/
+    Layout: typeof MenuLayout;
+    /** @deprecated IressMenu.Type enum is now deprecated and will be removed in a future version. Please use the value directly, and set it to the menu `role` prop. **/
+    Type: typeof MenuType;
+}

package/dist/src/components/Menu/MenuDivider/MenuDivider.d.ts

@@ -0,0 +1,2 @@
+import { IressDividerProps } from '../../../main';
+export declare const IressMenuDivider: (props: IressDividerProps) => import("react/jsx-runtime").JSX.Element;

package/dist/src/components/Menu/MenuHeading/MenuHeading.d.ts

@@ -0,0 +1,2 @@
+import { MenuHeadingType } from '../MenuItem/MenuItem.types';
+export declare const IressMenuHeading: MenuHeadingType;

package/dist/src/components/Menu/MenuItem/MenuItem.d.ts

@@ -0,0 +1,2 @@
+import { IressMenuItemProps } from './MenuItem.types';
+export declare const IressMenuItem: import('react').ForwardRefExoticComponent<IressMenuItemProps & import('react').RefAttributes<HTMLAnchorElement | HTMLButtonElement>>;

package/dist/src/components/Menu/MenuItem/MenuItem.types.d.ts

@@ -0,0 +1,122 @@
+import { default as React } from 'react';
+import { HeadingLevel } from '../../../enums';
+import { FormControlValue, HeadingLevels } from '../../../types';
+import { ButtonRef, IressButtonProps, IressTextProps, PopoverItemHookReturn } from '../../../main';
+export interface IressMenuItemProps extends MenuItemStyleHookProps, Omit<MenuItemInteractionsHookProps, 'id' | 'onClick' | 'onKeyDown'>, Omit<IressButtonProps, 'mode' | 'fluid'> {
+}
+export type IressMenuTextProps = MenuItemStyleHookProps & IressTextProps;
+export interface IressMenuHeadingProps extends IressMenuTextProps {
+    /**
+     * Renders the heading level (h2 - h6).
+     * @default h2
+     */
+    level?: HeadingLevel | HeadingLevels;
+}
+export interface MenuItemStyleHookProps {
+    /**
+     * Section after menu item content.
+     */
+    append?: React.ReactNode;
+    /**
+     * Adds a divider after any content.
+     * If you would like to add content before the menu item, use a `<hr />` instead.
+     */
+    divider?: boolean;
+    /**
+     * 	Section before menu item content.
+     */
+    prepend?: React.ReactNode;
+}
+export interface MenuItemInteractionsHookProps<T = ButtonRef> {
+    /**
+     * When true, the item can be toggled even in single-select mode.
+     */
+    canToggle?: boolean;
+    /**
+     * Emitted when the menu item is clicked.
+     */
+    onClick?: React.MouseEventHandler<T>;
+    /**
+     * Emitted when a key is pressed while focused on the menu item.
+     */
+    onKeyDown?: React.KeyboardEventHandler<T>;
+    /**
+     * The role of this item, usually passed from the `useMenuItemRole` hook.
+     */
+    role?: IressButtonProps['role'];
+    /**
+     * When true, shows the item in selected state.
+     */
+    selected?: boolean;
+    /**
+     * To be used when menu type is listbox.
+     */
+    value?: FormControlValue;
+}
+export interface MenuItemInteractionsHookReturn<T> extends PopoverItemHookReturn {
+    /**
+     * Changes the value of its parent menu on click.
+     */
+    onClick: (e: React.MouseEvent<T>, value?: FormControlValue) => void;
+    /**
+     * If configured, changes the value of its parent menu on tab.
+     */
+    onKeyDown: (e: React.KeyboardEvent<T>, value?: FormControlValue) => void;
+    /**
+     * When true, the item can be focused.
+     */
+    tabIndex?: number;
+}
+export interface MenuItemAriaHookProps {
+    /**
+     * When true, shows the item in selected state.
+     */
+    selected?: boolean;
+    /**
+     * The value of the menu item.
+     */
+    value?: FormControlValue;
+}
+export interface MenuItemAriaHookReturn {
+    /**
+     * When true, tells screen readers that the item is selected.
+     */
+    'aria-selected'?: boolean;
+    /**
+     * When true, tells screen readers that the item represents the current page.
+     */
+    'aria-current'?: boolean;
+}
+export interface MenuItemButtonHookProps extends Pick<IressButtonProps, 'append' | 'children' | 'className' | 'data-testid' | 'prepend' | 'role' | 'value'> {
+    /**
+     * When true, will render a divider before the item.
+     */
+    divider?: boolean;
+    /**
+     * When true, shows the item in selected state.
+     */
+    selected?: boolean;
+}
+/** @deprecated MenuItemRole enum is now deprecated and will be removed in a future version. Please use the MenuItemRoles type instead. **/
+export declare enum MenuItemRole {
+    ListItem = "listitem",
+    MenuItem = "menuitem",
+    Option = "option"
+}
+export declare const MENU_ITEM_ROLES: readonly ["listitem", "option", "menuitem"];
+export type MenuItemRoles = (typeof MENU_ITEM_ROLES)[number];
+export type MenuItemAriaCurrent = 'true' | 'false' | 'page' | undefined;
+export interface MenuHeadingType extends React.FC<IressMenuHeadingProps> {
+    Level: typeof HeadingLevel;
+}
+export interface MenuItem {
+    label: string | React.JSX.Element;
+    href?: string;
+    onClick?: React.MouseEventHandler;
+    divider?: boolean;
+    headingLevel?: HeadingLevel;
+    selected?: boolean;
+    value?: FormControlValue;
+    testId?: string;
+    key?: string | number;
+}

package/dist/src/components/Menu/MenuItem/hooks/useMenuItemAria.d.ts

@@ -0,0 +1,11 @@
+import { MenuItemAriaHookProps, MenuItemAriaHookReturn } from '../MenuItem.types';
+/**
+ * Calculate aria attributes based on the props of the IressMenuItem.
+ * Inside a menu, it will also change the aria-selected based on the state of the owning IressMenu.
+ *
+ * TODO: Change to a helper and pass menu as an argument
+ *
+ * @param {MenuItemAriaHookProps} props A subset of `IressMenuItemProps` that describe the expected interaction and state of the item.
+ * @returns aria-* attributes to help screen readers understand how to interact with the menu item, and its current state.
+ */
+export declare const useMenuItemAria: ({ selected, value, }: MenuItemAriaHookProps) => MenuItemAriaHookReturn;

package/dist/src/components/Menu/MenuItem/hooks/useMenuItemButtonProps.d.ts

@@ -0,0 +1,14 @@
+import { MenuItemButtonHookProps } from '../MenuItem.types';
+import { IressButtonProps } from '../../../../main';
+/**
+ * Calculate the props required to style the `IressButton` as a menu item.
+ * Exposed as a hook to allow styling of third-party components to look and act like a `IressMenuItem` inside a `IressMenu`.
+ * Inside a menu, it will also change the selected state based on the state of the owning IressMenu.
+ *
+ * TODO: Change to a helper and pass menu as an argument
+ *
+ * @param {MenuItemButtonHookProps} props A subset of `IressMenuItemProps` that describe the state of the `IressButton` and its styling.
+ * @param {MenuItemInteractionsHookReturn<T>} interactions The interactions provided by the consuming component, that set whether the button is tabbable or not.
+ * @returns {MenuItemButtonHookReturn} to help screen readers understand how to interact with the menu item, and its current state.
+ */
+export declare const useMenuItemButtonProps: ({ append, children, className, "data-testid": dataTestId, divider, role, selected: selectedProp, prepend: prependProp, value, }: MenuItemButtonHookProps, isActiveInPopover?: boolean) => IressButtonProps;

package/dist/src/components/Menu/MenuItem/hooks/useMenuItemComposite.d.ts

@@ -0,0 +1,20 @@
+import { ReactElement } from 'react';
+/**
+ * Helps the consuming component decide whether the MenuItem needs to use Floating UI Composite components.
+ * Floating UI composite components manage the keyboard navigation of the menu.
+ *
+ * Scenarios
+ * - If inside a composite menu, wrap the node in a CompositeItem component
+ * - If not inside a composite menu, display the node as is
+ * - If the role is listitem, we cannot assign an interactive item as a listitem, hence wrap the node in a span with role listitem
+ *
+ * See: https://floating-ui.com/docs/Composite
+ * Also see: https://floating-ui.com/docs/useListNavigation
+ *
+ * TODO: Change to a component, and use the new isMenuComposite helper and pass the popover and menu as arguments.
+ *
+ * @param {ReactElement} node the node that will be rendered as a menu item
+ * @param {string} role The role of the item, this is usually calculated with the `composeMenuItemRole` helper.
+ * @returns {ReactNode}
+ */
+export declare const useMenuItemComposite: (node?: ReactElement, role?: string) => import("react/jsx-runtime").JSX.Element | null;

package/dist/src/components/Menu/MenuItem/hooks/useMenuItemInteractions.d.ts

@@ -0,0 +1,11 @@
+import { MenuItemInteractionsHookProps, MenuItemInteractionsHookReturn } from '../MenuItem.types';
+/**
+ * Calculate the event handlers needed to handle the state of the menu item when used inside a menu.
+ * If inside a popover, it will close the popover once the menu item has been selected (in single select mode)
+ *
+ * TODO: Change to a helper and pass menu and popover as arguments
+ *
+ * @param {MenuItemInteractionsHookProps<T>} props A subset of `IressMenuItemProps` that describe the state of the menu item, and additional interactions.
+ * @returns {MenuItemInteractionsHookReturn<T>} to help screen readers understand how to interact with the menu item, and its current state.
+ */
+export declare const useMenuItemInteractions: <T extends HTMLElement>({ canToggle, onClick, onKeyDown, role, selected: selectedProp, value, }: MenuItemInteractionsHookProps<T>) => MenuItemInteractionsHookReturn<T>;

package/dist/src/components/Menu/MenuItem/hooks/useMenuItemRole.d.ts

@@ -0,0 +1,9 @@
+import { MenuItemRoles } from '../MenuItem.types';
+/**
+ * Calculate the role of the menu item. It will change depending on its context (if its inside a menu or popover, and based on their role/type).
+ *
+ * TODO: Change to a helper and pass menu and popover as arguments
+ *
+ * @returns {MenuItemRoles | undefined} final role of the menu item, based on its context.
+ */
+export declare const useMenuItemRole: () => MenuItemRoles | undefined;

package/dist/src/components/Menu/MenuProvider.d.ts

@@ -0,0 +1,3 @@
+import { MenuContextValue, MenuProviderProps } from './Menu.types';
+export declare const MenuContext: import('react').Context<MenuContextValue | undefined>;
+export declare const MenuProvider: ({ changeOnBlur, children, defaultSelected, id, layout, multiSelect, nav, noWrap, onChange, role, selected: selectedProp, }: MenuProviderProps) => import("react/jsx-runtime").JSX.Element;

package/dist/src/components/Menu/MenuText/MenuText.d.ts

@@ -0,0 +1,2 @@
+import { IressMenuTextProps } from '../MenuItem/MenuItem.types';
+export declare const IressMenuText: ({ append, children, className, divider, prepend, role, ...restProps }: IressMenuTextProps) => import("react/jsx-runtime").JSX.Element;

package/dist/src/components/Menu/helpers/mapMenuItems.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+import { MenuItem } from '../MenuItem/MenuItem.types';
+/**
+ *  @deprecated This function has been deprecated and will be removed in a future version of IDS, please map and render the items array directly in your application instead
+ */
+export declare const mapMenuItems: (items: MenuItem[]) => React.JSX.Element[] | null;

package/dist/src/components/Menu/hooks/useMenu.d.ts

@@ -0,0 +1 @@
+export declare const useMenu: () => import('..').MenuContextValue | undefined;

package/dist/src/components/Menu/hooks/useMenuAria.d.ts

@@ -0,0 +1,11 @@
+import { MenuAriaHookProps, MenuAriaHookReturn } from '..';
+/**
+ * Calculate aria attributes based on the props of the IressMenu
+ * Inside a popover, it will also change the aria-controls of the popover's activator.
+ *
+ * TODO: Change to a helper and pass popover as an argument
+ *
+ * @param {MenuAriaHookProps} props A subset of `IressMenuProps` that describe the expected interaction and state of the menu.
+ * @returns aria-* attributes to help screen readers understand how to interact with the menu and its current state.
+ */
+export declare const useMenuAria: ({ id, layout, multiSelect, role, }: MenuAriaHookProps) => MenuAriaHookReturn;