@iress-oss/ids-components 5.20.2 → 6.0.0-alpha.1

package/dist/src/components/Placeholder/Placeholder.styles.d.ts

@@ -0,0 +1 @@
+export declare const placeholder: import('../../styled-system/types').SlotRecipeRuntimeFn<"svg" | "line" | "root", import('../../styled-system/types').SlotRecipeVariantRecord<"svg" | "line" | "root">>;

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

@@ -0,0 +1,2 @@
+export * from './Placeholder';
+export * from './Placeholder.styles';

package/dist/src/components/Placeholder/meta/Thumbnail.d.ts

@@ -0,0 +1,2 @@
+declare const Thumbnail: () => import("react/jsx-runtime").JSX.Element;
+export default Thumbnail;

package/dist/src/components/Placeholder/meta/index.d.ts

@@ -0,0 +1,7 @@
+declare const _default: {
+    heading: string;
+    href: string;
+    tags: string[];
+    Thumbnail: import('react').LazyExoticComponent<() => import("react/jsx-runtime").JSX.Element>;
+};
+export default _default;

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

@@ -0,0 +1,21 @@
+import { InputPopoverActivatorProps } from './InputPopoverActivator';
+import { IressPopoverProps } from '../Popover';
+import { PopoverRef } from '../hooks/usePopoverImperativeHandle';
+export interface IressInputPopoverProps extends Omit<IressPopoverProps, 'fluid' | 'matchActivatorWidth' | 'virtualFocus'>, Omit<InputPopoverActivatorProps, 'children'> {
+    /**
+     * Content for an activator element, usually an `IressInput`.
+     */
+    activator: InputPopoverActivatorProps['children'];
+    /**
+     * If true, the first supported is automatically highlighted.
+     * @default true
+     */
+    autoHighlight?: boolean;
+    /**
+     * Describes the type of content contained in the popover.
+     * If `listbox`, it will add the combobox role to the popover activator.
+     * @default listbox
+     */
+    type?: IressPopoverProps['type'];
+}
+export declare const IressInputPopover: import('react').ForwardRefExoticComponent<IressInputPopoverProps & import('react').RefAttributes<PopoverRef>>;

package/dist/src/components/Popover/InputPopover/InputPopoverActivator.d.ts

@@ -0,0 +1,9 @@
+import { PopoverActivatorProps } from '../components/PopoverActivator';
+export interface InputPopoverActivatorProps extends PopoverActivatorProps {
+    /**
+     * Min length of input activator before popover is shown, if input activator has minLength
+     * prop it will use that as a fallback. Defaults to 1 if not provided and not found in activator.
+     */
+    minLength?: number;
+}
+export declare const InputPopoverActivator: ({ children, minLength, ...restProps }: InputPopoverActivatorProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,91 @@
+import { ReactNode } from 'react';
+import { PopoverActivatorProps } from './components/PopoverActivator';
+import { DisplayModes, FloatingUIAligns, FloatingUIContainer, IressStyledProps } from '../../types';
+import { OpenChangeReason } from '@floating-ui/react';
+import { PopoverRef } from './hooks/usePopoverImperativeHandle';
+import { IressCustomiseSlot } from '../../interfaces';
+import { PopoverHookReturn } from './hooks/usePopover';
+export interface IressPopoverProps extends IressStyledProps {
+    /**
+     * Content for an activator element, usually an `IressButton`.
+     */
+    activator: PopoverActivatorProps['children'];
+    /**
+     * Sets the alignment of the popover relative to the activator element.
+     * @default auto
+     */
+    align?: FloatingUIAligns;
+    /**
+     * The content to render within the popover.
+     */
+    children?: ReactNode;
+    /**
+     * The container element to render the popover into.
+     * By default, the popover will render where its parent is rendered.
+     *
+     * **Note:** If the `container` doesn’t exist when the popover is mounted, ensure you pass an element directly (not a ref) and specify null as the default value before it is set. This lets it wait for the root to be available. For example, if you reference the parent element of a popover.
+     */
+    container?: FloatingUIContainer;
+    /**
+     * Class name of the popover content.
+     * @deprecated Use `contentStyle` instead.
+     */
+    contentClassName?: string;
+    /**
+     * This allows you to customise the content styling specifically, which is the floating element.
+     * It accepts an object with any of the styling properties available on `IressCSSProps`, as well as `className` and `style`.
+     */
+    contentStyle?: IressCustomiseSlot;
+    /**
+     * When set to `true` the popover will be visible by default. Use for uncontrolled popovers.
+     */
+    defaultShow?: boolean;
+    /**
+     * Sets the display mode of popover.
+     * @default overlay
+     */
+    displayMode?: DisplayModes;
+    /**
+     * Popovers can be fluid, meaning they will take up the full width of their container.
+     */
+    fluid?: boolean;
+    /**
+     * Which index to start the focus on when the popover is opened. Only works with `type` listbox and menu.
+     * Note: The index must exist in the list of items, otherwise it will not work.
+     * @default 0
+     */
+    focusStartIndex?: number;
+    /**
+     * Sets the popover to match the width of the activator.
+     * Note: This only works when `displayMode="overlay"`.
+     */
+    matchActivatorWidth?: boolean;
+    /**
+     * Is called when popover is activated.
+     */
+    onActivated?: (e?: Event, reason?: OpenChangeReason, activeIndex?: number | null) => void;
+    /**
+     * Is called when popover is deactivated.
+     */
+    onDeactivated?: (e?: Event, reason?: OpenChangeReason, activeIndex?: number | null) => void;
+    /**
+     * Is called when registered popover items are navigated using arrow keys. Only works with `type` listbox and menu.
+     */
+    onNavigate?: (activeIndex: number | null) => void;
+    /**
+     * When set to `true` the modal will be visible. Use for controlled popovers.
+     */
+    show?: boolean;
+    /**
+     * Describes the type of content contained in the popover.
+     */
+    type?: PopoverHookReturn['type'];
+    /**
+     * Whether the focus is virtual (using `aria-activedescendant`).
+     * Use this if you need focus to remain on the reference element (such as an input), but allow arrow keys to navigate items.
+     * Note: This is only applicable when type is set to: `listbox` or `menu`, and only works out of the box with `IressMenu` and its subcomponents.
+     * @default false
+     */
+    virtualFocus?: boolean;
+}
+export declare const IressPopover: import('react').ForwardRefExoticComponent<IressPopoverProps & import('react').RefAttributes<PopoverRef>>;

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

@@ -0,0 +1,27 @@
+export declare const popover: import('../../styled-system/types').SlotRecipeRuntimeFn<"content" | "root" | "activator", {
+    fluid: {
+        true: {
+            root: {
+                display: "block";
+            };
+        };
+    };
+    hasInputActivator: {
+        true: {
+            root: {
+                display: "block";
+            };
+            content: {
+                minWidth: "input.12";
+                maxWidth: "auto";
+            };
+        };
+    };
+    matchActivatorWidth: {
+        false: {
+            content: {
+                maxWidth: "[none]";
+            };
+        };
+    };
+}>;

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

@@ -0,0 +1,5 @@
+import { PropsWithChildren } from 'react';
+import { PopoverHookReturn } from '../hooks/usePopover';
+export declare const NestedPopoverActivator: ({ children, parentPopover, }: PropsWithChildren & {
+    parentPopover?: PopoverHookReturn;
+}) => string | number | bigint | boolean | Iterable<import('react').ReactNode> | Promise<string | number | bigint | boolean | import('react').ReactPortal | import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>> | Iterable<import('react').ReactNode> | null | undefined> | import("react/jsx-runtime").JSX.Element | null | undefined;

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

@@ -0,0 +1,6 @@
+import { ReactElement } from 'react';
+import { IressUnstyledProps } from '../../../types';
+export interface PopoverActivatorProps extends IressUnstyledProps {
+    children?: ReactElement;
+}
+export declare const PopoverActivator: ({ children, ...restProps }: PopoverActivatorProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,7 @@
+import { DisplayModes, FloatingUIContainer, IressStyledProps } from '../../../types';
+export interface PopoverContentProps extends IressStyledProps {
+    container?: FloatingUIContainer;
+    displayMode?: DisplayModes;
+    virtualFocus?: boolean;
+}
+export declare const PopoverContent: (props: PopoverContentProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,16 @@
+import { CSSProperties } from 'react';
+import { DisplayModes, IressUnstyledProps } from '../../../types';
+import { PopoverHookReturn } from '../hooks/usePopover';
+/**
+ * This adds additional props to the Floating UI floatingProps to better suit the requirements of IressPopover.
+ * Some are slight tweaks to the UX to ensure it behaves according to IDS standards, as well as fix some issues found when using Floating UI.
+ *
+ * See: https://floating-ui.com/docs/useFloating#floatingstyles
+ *
+ * @param {PopoverHookReturn} popover the popover context
+ * @param {DisplayModes} displayMode how the content is to be displayed, whether inline (static, underneath activator) or overlay (floating, anchored to the activator)
+ * @param {CSSProperties} style any custom styles for the popover, it will be appended to the Floating UI styles
+ * @param {string} customId optional custom ID to override the floating ID - used to prevent ID conflicts
+ * @returns {IressUnstyledProps} the props to be passed to the floating content
+ */
+export declare const composePopoverFloatingProps: (popover: PopoverHookReturn, displayMode?: DisplayModes, style?: CSSProperties, customId?: string) => IressUnstyledProps;

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

@@ -0,0 +1,8 @@
+import { KeyboardEvent } from 'react';
+import { PopoverHookReturn } from '../hooks/usePopover';
+/**
+ * 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 {PopoverHookReturn} 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: PopoverHookReturn, e: KeyboardEvent) => Promise<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/helpers/waitUntilTrue.d.ts

@@ -0,0 +1 @@
+export declare const waitUntilTrue: (condition: () => boolean, timeout?: number, interval?: number) => Promise<void>;

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

@@ -0,0 +1,124 @@
+import { MutableRefObject } from 'react';
+import { ControlledStateProps } from '../../../hooks/useControlledState';
+import { OpenChangeReason, UseFloatingReturn, useInteractions } from '@floating-ui/react';
+import { FloatingUIAligns } from '../../../types';
+import { PopoverVirtualNode } from './usePopoverItem';
+import { PopoverAriaHookReturn } from './usePopoverAria';
+export interface PopoverHookProps {
+    align?: FloatingUIAligns;
+    autoHighlight?: boolean;
+    component?: ControlledStateProps['component'];
+    defaultShow?: boolean;
+    focusStartIndex?: number;
+    hasInputActivator?: boolean;
+    matchActivatorWidth?: boolean;
+    onActivated?: (e?: Event, reason?: OpenChangeReason, activeIndex?: number | null) => void;
+    onDeactivated?: (e?: Event, reason?: OpenChangeReason, activeIndex?: number | null) => void;
+    onNavigate?: (activeIndex: number | null) => void;
+    show?: boolean;
+    type?: 'menu' | 'listbox' | 'tree' | 'grid' | 'dialog';
+    virtualFocus?: boolean;
+}
+export interface PopoverHookReturn extends PopoverAriaHookReturn {
+    /**
+     * The index of the currently active item in the popover (ie. which item is currently focused or virtually focused).
+     */
+    activeIndex: number | null;
+    /**
+     * The API returned by the useFloating hook.
+     */
+    api: UseFloatingReturn;
+    /**
+     * A function that returns the truly focusable activator element.
+     * It is normally used to set the focus on the activator when the popover is closed and ensure a relationship between the activator and the popover.
+     */
+    getFocusableActivator: () => HTMLElement | undefined;
+    /**
+     * A function that returns the virtually focused item in the popover.
+     * It is normally used to trigger onClick and onKeyDown events on the item as if it was focused.
+     */
+    getVirtualFocus?: () => PopoverVirtualNode | null;
+    /**
+     * A function that checks whether there is a nested element assuming the role of the popover.
+     * It is used by `IressMenu` to force the popover to a certain role so that the screen reader can navigate it correctly.
+     */
+    hasInnerRole: () => boolean;
+    /**
+     * The interactions returned by the useInteractions hook.
+     * It is used to manage the interactions of the popover activator and content, such as click and dismiss.
+     */
+    interactions: ReturnType<typeof useInteractions>;
+    /**
+     * This function checks whether an element is the same as the activator element.
+     * It is used by components such as `IressButton` to style the activator when the popover is open.
+     */
+    isActiveActivator: (element: HTMLElement | null) => boolean;
+    /**
+     * If controlled, this will return true, meaning the popover is controlled by the parent component and will not change its state on its own.
+     * It is used by components such as `IressRichSelect` to manage the state of the popover using other methods.
+     */
+    isControlled: boolean;
+    /**
+     * If virtually focused, this will return true, meaning the popover is using virtual focus to manage the focus state of the items in the popover.
+     * It is used by components such as `useMenuItem` to check whether it should set the tab index of an item or not.
+     */
+    isVirtualFocus: boolean;
+    /**
+     * The list of items in the popover.
+     * It is used by other components to manage the aria attributes and keyboard navigation of the items.
+     */
+    list: MutableRefObject<(HTMLElement | null)[]>;
+    /**
+     * Resets the active index of the popover items, either to the `focusStartIndex` or null
+     */
+    resetActiveIndex: () => void;
+    /**
+     * Set the current active index of the popover items.
+     */
+    setActiveIndex: (newActiveIndex: number | null) => void;
+    /**
+     * This function is used to set the state of the popover without triggering the Floating UI handlers such as focus handling as well as onActivated and onDeactivated.
+     * It is used by `useMenuItem` to close the popover when an item is selected.
+     *
+     * For most cases, you should use the `setShowWithReason` function instead.
+     */
+    setShow: (flag?: boolean) => void;
+    /**
+     * This function is used to set the state of the popover and trigger the Floating UI handlers such as focus handling.
+     * Depending on the reason, it will change the way focus is handled.
+     */
+    setShowWithReason: (flag: boolean, e?: Event, reason?: OpenChangeReason) => void;
+    /**
+     * This function is used to set the state of the popover to have an inner role.
+     * It is used by components such as `IressMenu` to force the popover to a certain role so that the screen reader can navigate it correctly.
+     */
+    setHasInnerRole: (flag: boolean) => void;
+    /**
+     * This function is used to set the virtual focus of the popover.
+     * It is used by components such as `IressRichSelect` with searchable options to manage the focus state of the items in the popover.
+     */
+    setVirtualFocus?: (node: PopoverVirtualNode | null) => void;
+    /**
+     * The state of the popover, whether it is open or closed.
+     */
+    show: boolean;
+    /**
+     * The type of the popover, which is used to determine the role of the popover.
+     * It is used by components such as `IressMenu` to manage the aria attributes and keyboard navigation of the items.
+     */
+    type?: PopoverHookProps['type'];
+}
+/**
+ * This is a wrapper around the useFloating hook from Floating UI specifically for popover components.
+ * - It manages the state of the popover, including whether it is open or closed, and provides a controlled state for the popover.
+ * - It also manages the middleware for the popover, including the size middleware to match the activator width.
+ * - It uses the usePopoverNavigation hook to manage the keyboard navigation of popover items.
+ * - It provides a way to set the active index of the popover items, and to manage the focus state of the popover items.
+ * - It provides a way to set the virtual focus of the popover items, and to manage the focus state of the popover items.
+ * - It provides a way to set the hasInnerRole state, which is used to determine whether the popover has an inner role or not.
+ */
+export declare const usePopover: ({ align, autoHighlight, component, defaultShow, focusStartIndex, hasInputActivator, matchActivatorWidth, onActivated, onDeactivated, onNavigate, show: showProp, type, virtualFocus, }: PopoverHookProps) => PopoverHookReturn;
+/**
+ * This context is used to provide the popover state and API to allow items to be navigatable by keyboard and screen readers.
+ */
+export declare const PopoverContext: import('react').Context<PopoverHookReturn | undefined>;

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

@@ -0,0 +1,15 @@
+import { KeyboardEvent, FocusEvent } from 'react';
+import { IressUnstyledProps } from '../../../types';
+import { PopoverHookReturn } from './usePopover';
+/**
+ * This adds additional props to the activator to handle keyboard interactions with a virtually focused item.
+ *
+ * @param {PopoverHookReturn} 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: <E extends keyof HTMLElementTagNameMap = "div">(popover?: PopoverHookReturn, referenceProps?: Omit<IressUnstyledProps<E>, "value">) => {
+    onBlur: (e: FocusEvent<never>) => void;
+    onKeyDown: (e: KeyboardEvent<HTMLElementTagNameMap[E]>) => void;
+};

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

@@ -0,0 +1,9 @@
+export interface PopoverAriaHookReturn {
+    getAriaControls: () => string[];
+    toggleAriaControls: (id: string, addOrRemove?: boolean) => void;
+}
+/**
+ * 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,8 @@
+import { ForwardedRef } from 'react';
+import { PopoverHookReturn } from './usePopover';
+export interface PopoverRef extends Pick<PopoverHookReturn, 'setShow' | 'show' | 'toggleAriaControls'> {
+    getActivator: () => HTMLElement | null;
+    getFocusableActivator?: () => HTMLElement | undefined;
+    getContent: () => HTMLElement | null;
+}
+export declare const usePopoverImperativeHandle: (ref: ForwardedRef<PopoverRef>, context: PopoverHookReturn) => void;

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

@@ -0,0 +1,39 @@
+import { KeyboardEventHandler } from 'react';
+export interface PopoverItemHookReturn {
+    /**
+     * The id to be passed to the item.
+     * It is used to set the aria-activedescendant on virtually focused popovers, allowing screen readers to announce the active item.
+     */
+    id: string;
+    /**
+     * Whether the item is active in the popover.
+     * This is used to set the style of the item when it is active, whether virtual or not.
+     */
+    isActiveInPopover?: boolean;
+    /**
+     * The ref to be passed to the item.
+     * This is used to register the item within Floating UI, allowing it to be focused and managed by the popover.
+     */
+    ref?: (node: HTMLElement | null) => void;
+    /**
+     * The tabIndex to be passed to the item.
+     * - In virtual focus mode, this is always -1, as the item is not focusable.
+     * - In non-virtual focus mode, this is 0 if the item is active, and -1 otherwise.
+     */
+    tabIndex?: number;
+}
+export interface PopoverVirtualNode<T extends HTMLElement = HTMLElement> {
+    onBlur?: KeyboardEventHandler<T>;
+    onKeyDown?: KeyboardEventHandler<T>;
+}
+/**
+ * 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: <T extends HTMLElement = HTMLElement>(typeAheadLabel?: string, virtualNode?: PopoverVirtualNode<T> | null) => PopoverItemHookReturn;

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

@@ -0,0 +1,20 @@
+import { FloatingContext, UseListNavigationProps, VirtualElement } from '@floating-ui/react';
+import { IressPopoverProps } from '../Popover';
+/**
+ * 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 {IressPopoverProps['type']} 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.
+ */
+export declare const usePopoverNavigation: <RT extends VirtualElement = HTMLButtonElement>(context: FloatingContext<RT>, type?: IressPopoverProps["type"], props?: Partial<UseListNavigationProps>, onNavigate?: (activeIndex: number | null) => void, startIndex?: number) => {
+    activeIndex: number | null;
+    list: import('react').RefObject<(HTMLElement | null)[]>;
+    listNav: import('@floating-ui/react').ElementProps;
+    setActiveIndex: import('react').Dispatch<import('react').SetStateAction<number | null>>;
+};

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

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

package/dist/src/components/Popover/meta/Thumbnail.d.ts

@@ -0,0 +1,2 @@
+declare const Thumbnail: () => import("react/jsx-runtime").JSX.Element;
+export default Thumbnail;

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

@@ -0,0 +1,7 @@
+declare const _default: {
+    heading: string;
+    href: string;
+    tags: string[];
+    Thumbnail: import('react').LazyExoticComponent<() => import("react/jsx-runtime").JSX.Element>;
+};
+export default _default;

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

@@ -0,0 +1,44 @@
+import { CSSProperties } from 'react';
+import { IressStyledProps } from '../../types';
+import { UtilityValues } from '../../styled-system/types/prop-type';
+type ProgressElement<TMin extends number | undefined = undefined> = TMin extends number ? 'meter' : 'progress';
+/**
+ * The component will render as a `<progress>` element by default, but if the `min` prop is set, it will render as a `<meter>` element instead. This is useful for indicating a measurement that is not necessarily a progress bar.
+ * If you are using `IressProgressProps` in your own components, make sure to set the correct generic type for `TMin` to ensure that the correct element attributes are used.
+ *
+ * Examples:
+ * - `IressProgressProps<undefined>` will use the attributes of a `<progress />` element.
+ * - `IressProgressProps<0>` will use the attributes of a `<meter />` element.
+ */
+export type IressProgressProps<TMin extends number | undefined = undefined> = Omit<IressStyledProps<ProgressElement<TMin>>, 'borderRadius' | 'value'> & {
+    /**
+     * The **`border-radius`** CSS property rounds the corners of an element's outer border edge using the radius tokens in the design system.
+     * @see https://developer.mozilla.org/docs/Web/CSS/border-radius
+     */
+    borderRadius?: UtilityValues['borderRadius'];
+    /**
+     * The maximum value of the progress indicator.
+     * @default 100
+     **/
+    max?: number;
+    /**
+     * The minimum value of the progress indicator. If `min` is set, the progress indicator will render as a `<meter />` element instead of a `<progress />` element, thereby changing its role to `meter` instead of `progressbar`.
+     * @default 0
+     **/
+    min?: TMin;
+    /**
+     * 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;
+};
+export interface ProgressCustomCSSProperties extends CSSProperties {
+    '--iress-border-radius'?: string;
+}
+export declare const IressProgress: <TMin extends number | undefined = undefined>({ borderRadius, className: classNameProp, max, min, sectionTitle, style: styleProp, value, ...restProps }: IressProgressProps<TMin>) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1 @@
+export declare const progress: import('../../styled-system/types').RecipeRuntimeFn<import('../../styled-system/types').RecipeVariantRecord>;

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

@@ -0,0 +1,2 @@
+export * from './Progress';
+export * from './Progress.styles';

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

@@ -0,0 +1,2 @@
+declare const Thumbnail: () => import("react/jsx-runtime").JSX.Element;
+export default Thumbnail;

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

@@ -0,0 +1,7 @@
+declare const _default: {
+    heading: string;
+    href: string;
+    tags: string[];
+    Thumbnail: import('react').LazyExoticComponent<() => import("react/jsx-runtime").JSX.Element>;
+};
+export default _default;

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

@@ -0,0 +1,24 @@
+import { FloatingUIContainer } from '../../types';
+import { ReactNode } from 'react';
+import { IressToasterProviderProps } from '../Toaster';
+import { IressSlideoutProviderProps } from '../Slideout';
+export interface IressProviderProps extends IressSlideoutProviderProps, Pick<IressToasterProviderProps, 'position'> {
+    /**
+     * The contents of your application, and/or the components which will be calling slideouts, modals and toasts.
+     */
+    children?: ReactNode;
+    /**
+     * Container to render modal, slideouts and toasts into.
+     * If not provided, will render into the body of the document.
+     */
+    container?: FloatingUIContainer;
+    /**
+     * If you don't want to load the default Iress font from the CDN, set this to true.
+     */
+    noDefaultFont?: boolean;
+    /**
+     * If you don't want to load the Iress Icon CSS from the CDN, set this to true.
+     */
+    noIcons?: boolean;
+}
+export declare const IressProvider: ({ children, container, noDefaultFont, noIcons, position, ...restProps }: IressProviderProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1 @@
+export * from './Provider';

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

@@ -0,0 +1,47 @@
+import { ReactNode, Ref, ReactElement, ChangeEvent } from 'react';
+import { FormControlValue, IressStyledProps } from '../../types';
+export interface IressRadioProps<T = FormControlValue> extends Omit<IressStyledProps<'input'>, '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: ChangeEvent<HTMLInputElement>, value?: T) => 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?: T;
+    /**
+     * Add the button-like border and padding to radio when `touch` is true.
+     */
+    touch?: boolean;
+}
+export declare const IressRadio: <T = FormControlValue>(props: IressRadioProps<T> & {
+    ref?: Ref<HTMLInputElement>;
+}) => ReactElement;