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

package/dist/src/components/Popover/helpers/handlePopoverTabKey.d.ts

@@ -0,0 +1,8 @@
+import { PopoverContextValue } from '../Popover.types';
+import { KeyboardEvent } from 'react';
+/**
+ * This helper function is used to handle the tab key press event when the popover is open, as Floating UI sometimes does not focus on the next element when the user tabs from the popover contents.
+ * @param popover {PopoverContextValue} The popover context value, usually retrieved from the usePopover hook.
+ * @param e {KeyboardEvent} The keyboard event object that triggered the tab key press.
+ */
+export declare const handlePopoverTabKey: (popover: PopoverContextValue, e: KeyboardEvent) => void;

package/dist/src/components/Popover/helpers/hasFocus.d.ts

@@ -0,0 +1 @@
+export declare const hasFocus: (el: HTMLElement) => boolean;

package/dist/src/components/Popover/hooks/usePopover.d.ts

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

package/dist/src/components/Popover/hooks/usePopoverActivatorInteractions.d.ts

@@ -0,0 +1,15 @@
+import { HTMLAttributes, KeyboardEvent, FocusEvent } from 'react';
+import { PopoverContextValue } from '../Popover.types';
+import { IressHTMLAttributes } from '../../../main';
+/**
+ * This adds additional props to the activator to handle keyboard interactions with a virtually focused item.
+ *
+ * @param {PopoverContextValue} popover the popover context
+ * @param {HTMLAttributes<HTMLElement>} referenceProps the props of the activator, allowing them to be drilled down to the virtual reference
+ *
+ * @returns {IressHTMLAttributes} the props to be passed to the floating content
+ */
+export declare const usePopoverActivatorInteractions: <TElement extends HTMLElement = HTMLElement, TProps extends HTMLAttributes<TElement> = IressHTMLAttributes<TElement>>(popover?: PopoverContextValue, referenceProps?: TProps) => {
+    onBlur: (e: FocusEvent<TElement>) => void;
+    onKeyDown: (e: KeyboardEvent<TElement>) => void;
+};

package/dist/src/components/Popover/hooks/usePopoverAria.d.ts

@@ -0,0 +1,6 @@
+import { PopoverAriaHookReturn } from '../Popover.types';
+/**
+ * This is a hook that manages the aria controls for the popover, allowing the popover activator to control multiple items.
+ * @returns getAriaControls and toggleAriaControls functions
+ */
+export declare function usePopoverAria(): PopoverAriaHookReturn;

package/dist/src/components/Popover/hooks/usePopoverImperativeHandle.d.ts

@@ -0,0 +1,4 @@
+import { ForwardedRef } from 'react';
+import { PopoverAriaHookReturn, PopoverContextValue, PopoverRef, PopoverStateHookReturn } from '../Popover.types';
+import { UseFloatingReturn } from '@floating-ui/react';
+export declare const usePopoverImperativeHandle: (ref: ForwardedRef<PopoverRef>, api: UseFloatingReturn, aria: PopoverAriaHookReturn, state: PopoverStateHookReturn, context?: PopoverContextValue) => void;

package/dist/src/components/Popover/hooks/usePopoverItem.d.ts

@@ -0,0 +1,12 @@
+import { PopoverItemHookReturn, PopoverVirtualNode } from '../Popover.types';
+/**
+ * This is a wrapper around the useListItem hook from Floating UI, which is used to manage the focus state of the popover items.
+ * It provides the necessary props to the popover items to manage their focus state, and sets virtual focus if required.
+ *
+ * See: https://floating-ui.com/docs/FloatingList#uselistitem
+ *
+ * @param {string} typeAheadLabel the label to be used when the user is typing to navigate the activator (currently unused in IDS)
+ * @param {PopoverVirtualNode | null} virtualNode the virtual node to use when the item is focused. This contains some interactions to emulate keydown and blur on the popover item.
+ * @returns {IressHTMLAttributes} the props to be passed to the floating content
+ */
+export declare const usePopoverItem: (typeAheadLabel?: string, virtualNode?: PopoverVirtualNode | null) => PopoverItemHookReturn;

package/dist/src/components/Popover/hooks/usePopoverNavigation.d.ts

@@ -0,0 +1,16 @@
+import { FloatingContext, UseListNavigationProps, VirtualElement } from '@floating-ui/react';
+import { PopoverNavigationHookReturn, PopoverTypes } from '../Popover.types';
+/**
+ * This is a wrapper around the useListNavigation hook from Floating UI, which is used to manage the keyboard navigation of popover items.
+ * It stores the active index of the popover items, and provides the necessary props to the popover context to manage the focus state of the popover items.
+ *
+ * See: https://floating-ui.com/docs/useListNavigation
+ *
+ * @param {FloatingContext<RT>} context the popover context
+ * @param {PopoverTypes} type the type of popover, whether it is a menu, listbox, etc.
+ * @param {Partial<UseListNavigationProps>} props props that are passed to the useListNavigation hook
+ * @param {(activeIndex: number | null) => void} onNavigate called when the useListNavigation onNavigate is called
+ * @param {number} startIndex Which index to start the focus on when the popover is opened. The index must exist in the list of items, otherwise it will not work.
+ * @returns {PopoverNavigationHookReturn} activeIndex setters, and the list and listProps passed to other Floating UI hooks
+ */
+export declare const usePopoverNavigation: <RT extends VirtualElement = HTMLButtonElement>(context: FloatingContext<RT>, type?: PopoverTypes, props?: Partial<UseListNavigationProps>, onNavigate?: (activeIndex: number | null) => void, startIndex?: number) => PopoverNavigationHookReturn;

package/dist/src/components/Popover/hooks/usePopoverState.d.ts

@@ -0,0 +1,10 @@
+import { PopoverStateHookProps, PopoverStateHookReturn } from '../Popover.types';
+/**
+ * This stores the popover states into its own hook, and manages the controlled state of the popover.
+ * - hasInnerRole: whether the popover has an inner role. If there is an inner role that matches popover, the popover itself will render with no role.
+ * - show: whether the popover is open or not. this can be controlled/uncontrolled.
+ *
+ * @param {PopoverStateHookProps} props initial props passed by the consumer. This will set whether the popover is controlled or not.
+ * @returns hasInnerRole, isControlled, setShow, setHasInnerRole, show
+ */
+export declare const usePopoverState: ({ defaultShow, show: showProp, }: PopoverStateHookProps) => PopoverStateHookReturn;

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

@@ -0,0 +1,5 @@
+export * from './Popover.types';
+export * from './Popover';
+export * from './hooks/usePopoverItem';
+export * from './InputPopover/InputPopover.types';
+export * from './InputPopover/InputPopover';

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

@@ -0,0 +1,2 @@
+import { IressProgressProps } from './Progress.types';
+export declare const IressProgress: ({ className, max, min, sectionTitle, value, "data-testid": dataTestId, ...restProps }: IressProgressProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,23 @@
+import { IressHTMLAttributes } from '../../interfaces';
+export interface IressProgressProps extends IressHTMLAttributes<HTMLDivElement> {
+    /**
+     * The maximum value of the progress indicator.
+     * @default 100
+     **/
+    max?: number;
+    /**
+     * The minimum value of the progress indicator.
+     * @default 0
+     **/
+    min?: number;
+    /**
+     * The text that is announced by the screen reader. Should contain a description of the section the progress is being measured for. You can use {{current}} and {{max}} as string replacers for the current value and maximum value respectively..
+     * @default "Progress is {{current}} of {{max}}"
+     */
+    sectionTitle?: string;
+    /**
+     * The current value of the progress indicator.
+     * @default 0
+     **/
+    value?: number;
+}

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

@@ -0,0 +1 @@
+export { IressProgress } from './Progress';

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

@@ -0,0 +1,2 @@
+import { IressRadioProps } from './Radio.types';
+export declare const IressRadio: import('react').ForwardRefExoticComponent<IressRadioProps & import('react').RefAttributes<HTMLInputElement>>;

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

@@ -0,0 +1,45 @@
+import { ReactNode } from 'react';
+import { IressInputHTMLAttributes } from '../../interfaces';
+import { FormControlValue } from '../../types';
+export interface IressRadioProps extends Omit<IressInputHTMLAttributes<HTMLInputElement>, 'defaultValue' | 'value'> {
+    /**
+     * Sets the checked state of the radio.
+     * If it is within a radio group, it will be overridden by the radio group's value
+     * and whether it matches this radio's value.
+     */
+    checked?: boolean;
+    /**
+     * Label of the radio
+     */
+    children?: ReactNode;
+    /**
+     * Sets whether the control is hidden. If it is within a radio group,
+     * it will be overridden with the radio group's hiddenControl setting.
+     */
+    hiddenControl?: boolean;
+    /**
+     * Sets the name attribute on the radio input. If it is within a radio group,
+     * it will be overridden with the radio group's name.
+     */
+    name?: string;
+    /**
+     * Handles the onChange event of the radio input.
+     * If you pass in a non-string value, you can access it using the second parameter of the function.
+     */
+    onChange?: (e: React.ChangeEvent<HTMLInputElement>, value?: FormControlValue) => void;
+    /**
+     * If `true`, the radio is a required field and will be validated as such.
+     * If it is within a radio group, it will be overridden with the radio group's
+     * required state.
+     */
+    required?: boolean;
+    /**
+     * The value which is submitted with the form data when this radio button is checked.
+     * To set this radio as checked by default, use the `checked` property.
+     */
+    value?: FormControlValue;
+    /**
+     * Add the button-like border and padding to radio when `touch` is true.
+     */
+    touch?: boolean;
+}

package/dist/src/components/Radio/helpers/mapRadioGroupOptions.d.ts

@@ -0,0 +1,5 @@
+import { LabelValue } from '../../../interfaces';
+/**
+ *  @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 mapRadioGroupOptions: (items: LabelValue[]) => React.ReactNode[] | null;

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

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

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

@@ -0,0 +1,2 @@
+import { RadioGroupWithEnums } from './RadioGroup.types';
+export declare const IressRadioGroup: RadioGroupWithEnums;

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

@@ -0,0 +1,70 @@
+import { ReactNode } from 'react';
+import { IressHTMLAttributes } from '../../interfaces';
+import { FormControlValue } from '../../types';
+export interface IressRadioGroupProps extends Omit<IressHTMLAttributes, 'onChange' | 'defaultValue'> {
+    /**
+     * Content of the radio group, usually multiple `IressRadio` components.
+     */
+    children?: ReactNode;
+    /**
+     * Hides the radio control to allow the creation of custom radio buttons.
+     */
+    hiddenRadio?: boolean;
+    /**
+     * Sets which of the block / inline layout options apply.
+     * @default 'stack'
+     */
+    layout?: RadioGroupLayout | RadioGroupLayouts;
+    /**
+     * Name to be applied to all radios in the group.
+     */
+    name?: string;
+    /**
+     * Called when a user selects one of its children radio buttons.
+     * If you pass in a non-string value, you can access it using the second parameter of the function.
+     */
+    onChange?: (e: React.ChangeEvent<HTMLInputElement>, value?: FormControlValue) => void;
+    /**
+     * When true, marks the field as required
+     */
+    required?: boolean;
+    /**
+     * Initial value of radio group when in uncontrolled mode.
+     */
+    defaultValue?: FormControlValue;
+    /**
+     * Renders a readonly radio group.
+     */
+    readonly?: boolean;
+    /**
+     * Value of radio group when in controlled mode.
+     */
+    value?: FormControlValue;
+    /**
+     * Add the button-like border and padding to radio when `touch` is true.
+     */
+    touch?: boolean;
+}
+export type RadioGroupContextValue = Pick<IressRadioGroupProps, 'name' | 'value' | 'hiddenRadio' | 'required' | 'onChange' | 'readonly' | 'touch'>;
+export interface RadioGroupRef {
+    input?: HTMLDivElement | null;
+    reset: () => void;
+    focus: () => void;
+    blur: () => void;
+}
+export interface RadioGroupWithEnums extends React.ForwardRefExoticComponent<IressRadioGroupProps & React.RefAttributes<HTMLElement>> {
+    /** @deprecated IressRadioGroup.Layout will be removed in future versions of IDS. Please use the value directly. */
+    Layout: typeof RadioGroupLayout;
+}
+/**
+ * @deprecated The RadioGroupLayout enum will be removed in future versions of IDS. Please use the value directly.
+ */
+export declare enum RadioGroupLayout {
+    Stack = "stack",
+    Block = "block",
+    Inline = "inline",
+    InlineFlex = "inlineFlex",
+    InlineEqualWidth = "inlineEqualWidth"
+}
+export declare const RADIO_GROUP_LAYOUTS: readonly ["stack", "block", "inline", "inlineFlex", "inlineEqualWidth"];
+export type RadioGroupLayouts = (typeof RADIO_GROUP_LAYOUTS)[number];

package/dist/src/components/RadioGroup/RadioGroupContext.d.ts

@@ -0,0 +1,2 @@
+import { RadioGroupContextValue } from './RadioGroup.types';
+export declare const RadioGroupContext: import('react').Context<RadioGroupContextValue>;

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

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

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

@@ -0,0 +1,3 @@
+import { IressReadonlyProps } from './Readonly.types';
+import { FormControlValue } from '../../main';
+export declare const IressReadonly: <T extends FormControlValue>(props: IressReadonlyProps<T> & React.RefAttributes<HTMLInputElement | null>) => React.ReactElement;

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

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+import { IressInputProps } from '../Input';
+import { FormControlValue } from '../../types';
+export interface IressReadonlyProps<T extends FormControlValue = FormControlValue> extends Omit<IressInputProps<T>, 'clearable' | 'onClear' | 'onChange' | 'onInput' | 'placeholder' | 'rows'> {
+    /**
+     * The formatted value. If not provided, the value will be displayed.
+     */
+    children?: ReactNode;
+    inline?: boolean;
+}

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

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

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

@@ -0,0 +1,2 @@
+import { IressRichSelectProps, RichSelectRef } from './RichSelect.types';
+export declare const IressRichSelect: import('react').ForwardRefExoticComponent<IressRichSelectProps & import('react').RefAttributes<RichSelectRef>>;

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

@@ -0,0 +1,167 @@
+import { AutocompleteSearchHookProps } from '../Autocomplete';
+import { FloatingUIAligns, FocusableElementRef, FormattedLabelValueMeta, FormElementWidths, IressPopoverProps, LabelValueMeta, PopoverRef, PopoverTypes } from '../../main';
+import { ChangeEvent, ForwardedRef, ReactElement, ReactNode } from 'react';
+export interface IressRichSelectProps extends Omit<AutocompleteSearchHookProps, 'query'>, Omit<IressPopoverProps, 'activator' | 'children' | 'contentClassName' | 'defaultShow' | 'defaultValue' | 'disabledAutoToggle' | 'onChange' | 'matchActivatorWidth' | 'show'> {
+    /**
+     * Sets the alignment of the dropdown relative to the activator element.
+     * @default bottom-start
+     */
+    align?: FloatingUIAligns;
+    /**
+     * Value of selected option for uncontrolled select.
+     */
+    defaultValue?: LabelValueMeta | LabelValueMeta[];
+    /**
+     * Set to true if the user can select multiple options.
+     */
+    multiSelect?: boolean;
+    /**
+     * Name of the select. Used to pass data when submitted within a form.
+     */
+    name?: string;
+    /**
+     * Callback fired when the user has completely blurred away from the RichSelect. This is to kill the blur event bubbling.
+     * (component is no longer in focus and popover is closed).
+     */
+    onBlur?: (event: Event | React.FocusEvent<HTMLElement>) => void;
+    /**
+     * Emitted when the value changes.
+     */
+    onChange?: (event?: ChangeEvent<HTMLElement> & {
+        currentTarget: {
+            value?: LabelValueMeta | LabelValueMeta[];
+        };
+        target: {
+            value?: LabelValueMeta | LabelValueMeta[];
+        };
+    }, value?: LabelValueMeta | LabelValueMeta[]) => void;
+    /**
+     * The available options that the user can select from.
+     */
+    options: LabelValueMeta[] | ((query: string) => Promise<LabelValueMeta[]>);
+    /**
+     * Placeholder, shown when there is nothing selected.
+     */
+    placeholder?: ReactNode;
+    /**
+     * Renders the select as read-only.
+     */
+    readonly?: boolean;
+    /**
+     * Completely customise the rendering of the hidden input.
+     */
+    renderHiddenInput?: (props: SelectHiddenInputRenderProps) => ReactNode;
+    /**
+     * Completely customise the rendering of the select label.
+     */
+    renderLabel?: (props: SelectLabelRenderProps) => ReactElement;
+    /**
+     * Completely customise the rendering of the select options.
+     */
+    renderOptions?: (props: SelectOptionsRenderProps) => ReactNode;
+    /**
+     * Whether its required. Will be passed to the hidden input.
+     */
+    required?: boolean;
+    type?: PopoverTypes;
+    /**
+     * Value of selected option for controlled select.
+     */
+    value?: LabelValueMeta | LabelValueMeta[];
+    /**
+     * The width of the select.
+     * @default 100perc
+     */
+    width?: FormElementWidths;
+    virtualFocus?: boolean;
+}
+export interface IressSelectActivatorProps {
+    /**
+     * Append content.
+     * @default <IressIcon name="chevron-down" size="xs" />
+     */
+    append?: ReactNode;
+    /**
+     * Placeholder, shown when there is nothing selected.
+     */
+    placeholder?: ReactNode;
+    /**
+     * Prepend content.
+     */
+    prepend?: ReactNode;
+    /**
+     * Selected items.
+     */
+    selected?: LabelValueMeta | LabelValueMeta[];
+    /**
+     * Text displayed next to label when two or more options are selected.
+     * @default {{numOptions}} selected
+     */
+    selectedOptionsText?: string;
+}
+export interface SelectHiddenInputRenderProps {
+    /**
+     * Gets the current value as a string, separated by comma. Use this if you are using an uncontrolled select.
+     */
+    getValuesString: () => string;
+    /**
+     * Selected items.
+     */
+    value?: LabelValueMeta | LabelValueMeta[];
+    /**
+     * Set the reference of the hidden input. Required to be set if needed to work with React Hook Forms.
+     */
+    ref?: ForwardedRef<HTMLInputElement>;
+    /**
+     * Whether its required.
+     */
+    required?: boolean;
+}
+export interface SelectLabelRenderProps {
+    /**
+     * Close the popover menu.
+     */
+    close: () => void;
+    /**
+     * Whether the select has errored, use this to show an error state.
+     * Only applies when options are asynchronous.
+     */
+    error: boolean | string;
+    /**
+     * Whether the select is loading, use this to show a loading spinner.
+     */
+    loading: boolean;
+    /**
+     * Sets the value (selected items) of the select. Use this if you are using an uncontrolled select.
+     */
+    setValue: (value?: LabelValueMeta | LabelValueMeta[]) => void;
+    /**
+     * Whether the select dropdown (popover) is showing.
+     */
+    show: boolean;
+    /**
+     * Selected items.
+     */
+    value?: LabelValueMeta | LabelValueMeta[];
+}
+export interface SelectOptionsRenderProps extends SelectLabelRenderProps {
+    /**
+     * The query value that was used to filter the items (may be different from query).
+     */
+    debouncedQuery: string;
+    /**
+     * The query value to filter items by and create search results.
+     */
+    query: string;
+    /**
+     * The results of the search.
+     */
+    results: FormattedLabelValueMeta[];
+    /**
+     * Set the query value to filter the items by.
+     */
+    setQuery: (query: string) => void;
+}
+export interface RichSelectRef extends Partial<PopoverRef>, Partial<FocusableElementRef> {
+    hiddenInput?: HTMLInputElement;
+}

package/dist/src/components/RichSelect/SelectBody/SelectBody.d.ts

@@ -0,0 +1,2 @@
+import { IressSelectBodyProps } from './SelectBody.types';
+export declare const IressSelectBody: ({ children, className, footer, header, ...restProps }: IressSelectBodyProps) => import("react/jsx-runtime").JSX.Element;

package/dist/src/components/RichSelect/SelectBody/SelectBody.types.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from 'react';
+import { IressTextProps } from '../../../main';
+export interface IressSelectBodyProps extends IressTextProps {
+    /**
+     * Footer of the select, it will render as fixed (pinned).
+     */
+    footer?: ReactNode;
+    /**
+     * Header of the select, it will render as fixed (pinned).
+     */
+    header?: ReactNode;
+}

package/dist/src/components/RichSelect/SelectCreate/SelectCreate.d.ts

@@ -0,0 +1,2 @@
+import { IressSelectCreateProps } from './SelectCreate.types';
+export declare const IressSelectCreate: ({ fluid, heading, label, loading, onCreate, prepend, ...restProps }: IressSelectCreateProps) => import("react/jsx-runtime").JSX.Element;

package/dist/src/components/RichSelect/SelectCreate/SelectCreate.types.d.ts

@@ -0,0 +1,29 @@
+import { MouseEvent, ReactNode } from 'react';
+import { IressMenuItemProps, IressMenuProps } from '../../Menu';
+import { ButtonRef } from '../../Button';
+export interface IressSelectCreateProps extends Omit<IressMenuProps, 'changeOnBlur' | 'children' | 'defaultSelected' | 'multiSelect' | 'onChange' | 'role' | 'selected' | 'type'>, Pick<IressMenuItemProps, 'loading'> {
+    /**
+     * If set to true, menu will fill the width of its container.
+     * @default true
+     */
+    fluid?: boolean;
+    /**
+     * Heading slot. Often used for a title or description.
+     * If a string, will automatically provide an id for aria-labelledby.
+     */
+    heading?: ReactNode;
+    /**
+     * Label that will be displayed on the add button.
+     * @default 'New option'
+     */
+    label?: ReactNode;
+    /**
+     * Emitted when the user clicks the add button.
+     */
+    onCreate?: (e: MouseEvent<ButtonRef>) => void;
+    /**
+     * Prepends an element to the add button.
+     * @default <IressIcon name="plus" screenreaderText="Add" />
+     */
+    prepend?: ReactNode;
+}

package/dist/src/components/RichSelect/SelectHeading/SelectHeading.d.ts

@@ -0,0 +1,2 @@
+import { IressSelectHeadingProps } from './SelectHeading.types';
+export declare const IressSelectHeading: ({ children, className, clearAll, onClearAll, role, ...restProps }: IressSelectHeadingProps) => import("react/jsx-runtime").JSX.Element;

package/dist/src/components/RichSelect/SelectHeading/SelectHeading.types.d.ts

@@ -0,0 +1,17 @@
+import { ReactNode, UIEvent } from 'react';
+import { IressMenuTextProps } from '../../Menu';
+import { ButtonRef } from '../../Button';
+export interface IressSelectHeadingProps extends IressMenuTextProps {
+    /**
+     * The content to be rendered; can be a string or a ReactNode (e.g. IressIcon).
+     */
+    children: ReactNode;
+    /**
+     * Adds a clear all button to the heading.
+     */
+    clearAll?: string | boolean;
+    /**
+     * Emitted when the user clicks the clear button, or triggers it using a keyboard.
+     */
+    onClearAll?: (e: UIEvent<ButtonRef>) => void;
+}

package/dist/src/components/RichSelect/SelectLabel/SelectLabel.d.ts

@@ -0,0 +1,2 @@
+import { IressSelectLabelProps } from './SelectLabel.types';
+export declare const IressSelectLabel: ({ append, className, placeholder, prepend, selected, selectedOptionsText, ...restProps }: IressSelectLabelProps) => import("react/jsx-runtime").JSX.Element;

package/dist/src/components/RichSelect/SelectLabel/SelectLabel.types.d.ts

@@ -0,0 +1,3 @@
+import { IressHTMLAttributes } from '../../../interfaces';
+import { IressSelectActivatorProps } from '../RichSelect.types';
+export type IressSelectLabelProps = Omit<IressHTMLAttributes<HTMLButtonElement>, 'children'> & IressSelectActivatorProps;

package/dist/src/components/RichSelect/SelectMenu/SelectMenu.d.ts

@@ -0,0 +1,2 @@
+import { IressSelectMenuProps } from './SelectMenu.types';
+export declare const IressSelectMenu: ({ heading, hideSelectedItems, items, limitDesktop, limitMobile, multiSelect, noResults, onChange, selected, selectedFirst, ...restProps }: IressSelectMenuProps) => import("react/jsx-runtime").JSX.Element;

package/dist/src/components/RichSelect/SelectMenu/SelectMenu.types.d.ts

@@ -0,0 +1,49 @@
+import { ReactNode } from 'react';
+import { IressMenuItemProps, IressMenuProps } from '../../Menu';
+import { FormattedLabelValueMeta, LabelValueMeta } from '../../../interfaces';
+export interface IressSelectMenuProps extends Omit<IressMenuProps, 'children' | 'onChange' | 'role' | 'selected' | 'type'> {
+    /**
+     * Heading slot. Often used for a title or description.
+     * If a string, will automatically provide an id for aria-labelledby.
+     */
+    heading?: ReactNode;
+    /**
+     * Hide selected items from menu.
+     * Useful for autocomplete scenarios.
+     */
+    hideSelectedItems?: boolean;
+    /**
+     * Items to be displayed in the menu, array of FormattedLabelValueMeta.
+     */
+    items?: FormattedLabelValueMeta[];
+    /**
+     * Maximum number of results displayed on mobile screen sizes (< 768).
+     */
+    limitMobile?: number;
+    /**
+     * Maximum number of results displayed on larger screen sizes (>= 768).
+     */
+    limitDesktop?: number;
+    /**
+     * No results text to display when no items are found.
+     */
+    noResults?: ReactNode;
+    /**
+     * Emitted when the value changes when item is selected from the menu
+     */
+    onChange?: (selected?: LabelValueMeta | LabelValueMeta[]) => void;
+    /**
+     * Selected items.
+     */
+    selected?: LabelValueMeta | LabelValueMeta[];
+    /**
+     * Set whether to display selected items first in the menu.
+     */
+    selectedFirst?: boolean;
+}
+export interface IressSelectMenuItemProps extends Omit<IressMenuItemProps, 'value'>, FormattedLabelValueMeta {
+    /**
+     * Set whether this item is hidden on mobile
+     */
+    hiddenOnMobile?: boolean;
+}

package/dist/src/components/RichSelect/SelectMenu/SelectMenuItem.d.ts

@@ -0,0 +1,2 @@
+import { IressSelectMenuItemProps } from './SelectMenu.types';
+export declare const IressSelectMenuItem: ({ className, divider, formattedLabel, hiddenOnMobile, label, meta, value, ...restProps }: IressSelectMenuItemProps) => import("react/jsx-runtime").JSX.Element;

package/dist/src/components/RichSelect/SelectSearch/SelectSearch.d.ts

@@ -0,0 +1,2 @@
+import { IressSelectSearchProps } from './SelectSearch.types';
+export declare const IressSelectSearch: ({ className, contentClassName, onKeyDown, ...restProps }: IressSelectSearchProps) => import("react/jsx-runtime").JSX.Element;

package/dist/src/components/RichSelect/SelectSearch/SelectSearch.types.d.ts

@@ -0,0 +1,2 @@
+import { IressInputPopoverProps } from '../../../main';
+export type IressSelectSearchProps = Omit<IressInputPopoverProps, 'disabledAutoToggle' | 'displayMode' | 'show' | 'width'>;

package/dist/src/components/RichSelect/SelectSearchInput/SelectSearchInput.d.ts

@@ -0,0 +1,3 @@
+import { IressSelectSearchInputProps } from './SelectSearchInput.types';
+import { InputRef } from '../../Input';
+export declare const IressSelectSearchInput: import('react').ForwardRefExoticComponent<IressSelectSearchInputProps & import('react').RefAttributes<InputRef>>;

package/dist/src/components/RichSelect/SelectSearchInput/SelectSearchInput.types.d.ts

@@ -0,0 +1,18 @@
+import { IressInputProps } from '../../../main';
+export interface IressSelectSearchInputProps extends Omit<IressInputProps, 'rows' | 'width'> {
+    /**
+     * Content to place inside the input when it has no value.
+     * @default Search
+     **/
+    placeholder?: string;
+    /**
+     * Content to prepended to the input field, usually an icon.
+     * @default <IressIcon name="search" />
+     **/
+    prepend?: React.ReactNode;
+    /**
+     * When set to `true` add ons will render with a different style. Will be ignored if `prepend` or `append` props are not being used.
+     * @default true
+     */
+    watermark?: boolean;
+}