@progressiveui/react 1.22.0

package/es/dist/components/MainNavigation/MobileButton.d.ts

@@ -0,0 +1,17 @@
+import React, { PropsWithChildren } from 'react';
+export type MobileButtonProps = PropsWithChildren<{
+    /**
+     * Status of the mobile menu
+     */
+    openMobileMenu?: boolean;
+    /**
+     * Prefix for the component CSS class
+     */
+    prefix?: string;
+    /**
+     * Toggle the Menu
+     */
+    toggleMenu?: () => void;
+}>;
+declare const MobileButton: React.FC<MobileButtonProps>;
+export default MobileButton;

package/es/dist/components/MainNavigation/index.d.ts

@@ -0,0 +1,4 @@
+export { default as MainNavigation } from './MainNavigation';
+export { default as MainNavigationExternal } from './MainNavigationExternal';
+export { default as MainNavigationContext } from './MainNavigationContext';
+export { default as useMainNavigation } from './useMainNavigation';

package/es/dist/components/MainNavigation/useMainNavigation.d.ts

@@ -0,0 +1,7 @@
+import { MainNavigationContextType } from "./MainNavigationContext";
+/** The useMainNavigation() is a hook to access the current state of the MainNavigation and manipulate it. */
+declare function useMainNavigation(): MainNavigationContextType;
+declare namespace useMainNavigation {
+    var displayName: string;
+}
+export default useMainNavigation;

package/es/dist/components/MainNavigationItem/MainNavigationItem.d.ts

@@ -0,0 +1,29 @@
+import React from "react";
+/**
+ * MainNavigationItem component for use with MainNavigation. This component is a wrapper for the `a` element.
+ */
+interface MainNavigationItemProps extends React.ComponentPropsWithRef<"a"> {
+    /**
+     * If defined the `MainNaviationItem` will have a toggleable
+     * SubNavigation. See the `SubNavigation` component for details on usage
+     */
+    subNavigation?: React.ReactNode;
+    /**
+     * If the subNavigation is open, the subNavigation will be as wide as the content
+     */
+    subNavWideAsContent?: boolean;
+    /**
+     * Specify the kind of the subNavigation
+     */
+    kind?: "fullWidth" | "callout";
+    /**
+     * Specify a callback that will be called when the subNavigation is opened or closed
+     */
+    onChangeSub?: (action: string, id?: number, e?: any) => void;
+    /**
+     * Specify if you want to use the external version of the component
+     */
+    external?: boolean;
+}
+declare const MainNavigationItem: ({ className, children, kind, subNavigation, subNavWideAsContent, }: MainNavigationItemProps) => import("react/jsx-runtime").JSX.Element;
+export default MainNavigationItem;

package/es/dist/components/MainNavigationItem/index.d.ts

@@ -0,0 +1 @@
+export { default } from './MainNavigationItem';

package/es/dist/components/MdxComponents/MdxComponentsNew.d.ts

@@ -0,0 +1,2 @@
+declare const mdxComponents: any;
+export default mdxComponents;

package/es/dist/components/MdxComponents/index.d.ts

@@ -0,0 +1 @@
+export { default } from './MdxComponentsNew';

package/es/dist/components/Modal/Modal.d.ts

@@ -0,0 +1,122 @@
+import React from "react";
+export interface ModalProps {
+    /**
+     * Specify the content of the modal header label.
+     */
+    modalLabel?: React.ReactNode;
+    /**
+     * Specify the content of the modal header title.
+     */
+    modalHeading?: React.ReactNode;
+    modalText?: React.ReactNode;
+    /**
+     * Specify whether the modals content should be only loaded when the `Modal` is `open`
+     */
+    lazyLoad?: boolean;
+    /**
+     * Specify whether the modal should be button-less
+     */
+    passiveModal?: boolean;
+    children?: React.ReactNode;
+    components?: {
+        Wrapper?: React.ReactNode;
+        ModalFooter?: React.ReactNode;
+    };
+    /**
+     * Specify a label to be read by screen readers on the modal root node
+     */
+    modalAriaLabel?: string;
+    elementToAppend?: HTMLElement | null;
+    modalSecondaryAction?: React.ReactNode;
+    /**
+     * Specify the text for the secondary button
+     */
+    secondaryButtonText?: React.ReactNode;
+    /**
+     * Specify whether the secondary Button should be disabled, or not
+     */
+    secondaryButtonDisabled?: boolean;
+    /**
+     * Specify a handler for the secondary button.
+     * Useful if separate handler from `onRequestClose` is desirable
+     */
+    onSecondarySubmit?: () => void;
+    /**
+     * Specify the text for the primary button
+     */
+    primaryButtonText?: React.ReactNode;
+    /**
+     * Specify whether the Button should be disabled, or not
+     */
+    primaryButtonDisabled?: boolean;
+    /**
+     * Specify whether the Modal is currently open
+     */
+    open?: boolean;
+    /**
+     * Specify to hide the close button
+     */
+    hideClose?: boolean;
+    warning?: boolean;
+    /**
+     * Specify whether the Modal is for dangerous actions
+     */
+    danger?: boolean;
+    /**
+     * Specify if Enter key should be used as "submit" action
+     */
+    shouldSubmitOnEnter?: boolean;
+    /**
+     * Specify CSS selectors that match DOM elements working as floating menus.
+     * Focusing on those elements won't trigger "focus-wrap" behavior
+     */
+    selectorsFloatingMenus?: string[];
+    /**
+     * Specify a CSS selector that matches the DOM element that should
+     * be focused when the Modal opens. If "false" no selector will be triggered
+     */
+    selectorPrimaryFocus?: boolean | string;
+    /**
+     *  Different styling options are available `info`, `warning`, `danger`
+     */
+    type?: "info" | "warning" | "danger";
+    /**
+     * If true the Modal will be rendered inside a portal at the end of the
+     * body element, otherwise at the position it is placed.
+     */
+    inPortal?: boolean;
+    width?: "narrow" | "wide" | "full";
+    /**
+     * If true the Modal will be wider then the regular Modal
+     */
+    wide?: boolean;
+    /**
+     * Specify a handler for closing modal.
+     * The handler should care of closing modal, e.g. changing `open` prop.
+     */
+    onRequestClose?: (evt: React.UIEvent, trigger: "button" | "key" | "background") => void;
+    /**
+     * Specify a handler for "submitting" modal.
+     * The handler should care of closing modal, e.g. changing `open` prop, if necessary.
+     */
+    onRequestSubmit?: () => void;
+    /**
+     * Provide a description for "close" icon that can be read by screen readers
+     */
+    iconDescription?: string;
+    className?: string;
+    /**
+     * Specify the DOM element ID of the top-level node.
+     */
+    id?: string;
+    backgroundImage?: string;
+    handleBlur?: (obj?: unknown) => void;
+    primaryButtonRef?: React.RefObject<HTMLButtonElement>;
+    secondaryButtonRef?: React.RefObject<HTMLButtonElement>;
+}
+/** Modals focus the user’s attention exclusively on one task or piece of information via a window that sits on top of the page content. */
+declare function Modal(props: ModalProps): import("react/jsx-runtime").JSX.Element | null;
+declare namespace Modal {
+    var displayName: string;
+}
+export default Modal;

package/es/dist/components/Modal/ModalFooter.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+import { ModalProps } from "./Modal";
+export interface ModalFooterProps extends ModalProps {
+    onSecondaryButtonClick?: (evt: React.MouseEvent<HTMLButtonElement, MouseEvent>, trigger: "button" | "background" | "key") => void;
+    prefix?: string;
+}
+declare const ModalFooter: React.FC<ModalFooterProps>;
+export default ModalFooter;

package/es/dist/components/Modal/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './Modal';
+export { default as ModalFooter } from './ModalFooter';

package/es/dist/components/ModalWrapper/ModalWrapper.d.ts

@@ -0,0 +1,53 @@
+import * as React from "react";
+import { ButtonKind } from "../../utils";
+import { ModalProps } from "../Modal/Modal";
+/** Modal Wrapper component to encapsulate your Modal within a button. */
+interface ModalWrapperProps extends ModalProps, React.ComponentPropsWithRef<"div"> {
+    /**
+     * ID of the trigger button.
+     */
+    id?: string;
+    disabled?: boolean;
+    /**
+     * Specify a custom trigger `Button`.
+     */
+    customButton?: React.ReactElement;
+    /**
+     * Specify the text for the trigger `Button`.
+     */
+    buttonTriggerText?: React.ReactNode;
+    /**
+     * Specify a `class` for the trigger `Button`.
+     */
+    buttonTriggerClassName?: string;
+    /**
+     * @param handle - function to open the modal
+     */
+    handleOpen?: () => void;
+    /**
+     * @param handle - function to submit content in the modal
+     */
+    handleSubmit?: (handle: () => void) => void;
+    /**
+     * @param handle - function to close the modal
+     */
+    handleClose?: () => void;
+    /**
+     * Specify the kind of trigger `Button`.
+     */
+    triggerButtonKind?: ButtonKind;
+    /**
+     * Specify whether the Modal should be closed after submit
+     */
+    shouldCloseAfterSubmit?: boolean;
+    /**
+     * Specify whether the primary button should be disabled or not
+     */
+    primaryButtonDisabled?: boolean;
+    /**
+     * A function that is called when the user presses the `Esc` key to close the modal.
+     */
+    onKeyDown?: (evt: React.KeyboardEvent<HTMLDivElement>) => void;
+}
+declare const ModalWrapper: React.FC<ModalWrapperProps>;
+export default ModalWrapper;

package/es/dist/components/ModalWrapper/index.d.ts

@@ -0,0 +1 @@
+export { default } from './ModalWrapper';

package/es/dist/components/Module/Module.d.ts

@@ -0,0 +1,38 @@
+import * as React from "react";
+/** A Module is identifiable as a single, contained unit. */
+interface ModuleProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * * Specify the content of the `Module`, usually a `ModuleHeader` `ModuleBody` and `ModuleFooter`component.
+     */
+    children: React.ReactNode;
+    /**
+     * The CSS class name for the slider.
+     */
+    className?: string;
+    /**
+     * @deprecated Disables the default margin
+     */
+    noMargin?: boolean;
+    /**
+     * Use 100% height of parent container
+     */
+    fullHeight?: boolean;
+    /**
+     * Light appearance (for white backgrounds) @design
+     */
+    light?: boolean;
+    /**
+     * Dark appearance @design
+     */
+    dark?: boolean;
+    /**
+     * Additional hover styling @design
+     */
+    withHover?: boolean;
+    /**
+     * Margin size around the module @design
+     */
+    margin?: "xs" | "md" | "lg";
+}
+declare const Module: React.FC<ModuleProps>;
+export default Module;

package/es/dist/components/Module/ModuleBody.d.ts

@@ -0,0 +1,21 @@
+import * as React from "react";
+interface ModuleBodyProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Optional CSS class to apply to the body of the module. This allows for additional
+     * styling to be applied on top of the default styles. @style
+     */
+    className?: string;
+    /**
+     * Specify whether the content within the ModuleBody should be centered. This can be
+     * used to align content such as text or images in the center of the component for
+     * visual appeal. @layout
+     */
+    centered?: boolean;
+    /**
+     * Specify whether the ModuleBody should have no padding. This can be useful for
+     * scenarios where edge-to-edge content display is needed within the module. @layout
+     */
+    noPadding?: boolean;
+}
+declare const ModuleBody: React.FC<ModuleBodyProps>;
+export default ModuleBody;

package/es/dist/components/Module/ModuleFooter.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+interface ModuleFooterProps extends React.AllHTMLAttributes<HTMLDivElement> {
+    /**
+     * Optional CSS class to apply to the header. This allows for additional
+     * styling to be applied on top of the default styles. @style
+     */
+    className?: string;
+}
+declare const ModuleFooter: React.FC<ModuleFooterProps>;
+export default ModuleFooter;

package/es/dist/components/Module/ModuleHeader.d.ts

@@ -0,0 +1,16 @@
+import * as React from "react";
+interface ModuleHeaderProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Optional CSS class to apply to the header. This allows for additional
+     * styling to be applied on top of the default styles. @style
+     */
+    className?: string;
+    /**
+     * Optional filter element to be included in the header. This can be used
+     * to incorporate interactive elements like dropdowns, search inputs, etc.,
+     * providing additional functionality to the header component. @functionality
+     */
+    filter?: React.ReactNode;
+}
+declare const ModuleHeader: React.FC<ModuleHeaderProps>;
+export default ModuleHeader;

package/es/dist/components/Module/index.d.ts

@@ -0,0 +1,4 @@
+export { default as Module } from './Module';
+export { default as ModuleBody } from './ModuleBody';
+export { default as ModuleHeader } from './ModuleHeader';
+export { default as ModuleFooter } from './ModuleFooter';

package/es/dist/components/Notification/Callout.d.ts

@@ -0,0 +1,59 @@
+import * as React from "react";
+export interface CalloutProps extends Omit<React.ComponentPropsWithRef<"div">, "title"> {
+    /**
+     * Pass in the action nodes that will be rendered within the Notification
+     */
+    actions?: React.ReactNode;
+    /**
+     * Provide a function that is called when menu is closed
+     */
+    onClose?: any;
+    /**
+     * Specify the close button should be disabled, or not
+     */
+    hideCloseButton?: boolean;
+    /**
+     * Pass in the icon that will be rendered within the Notification or set icon to false to hide
+     */
+    icon?: React.ReactNode | boolean;
+    /**
+     * Provide a description for "close" icon that can be read by screen readers
+     */
+    iconDescription?: string;
+    /**
+     * Specify what state the notification represents
+     */
+    kind?: "error" | "info" | "success" | "warning" | "warning-alt";
+    /**
+     * Specify whether you are using the low contrast variant of the Notification.
+     */
+    lowContrast?: boolean;
+    /**
+     * By default, this value is "inline". You can also provide an alternate type
+     * if it makes sense for the underlying `<NotificationTextDetails>` and `<NotificationButton>`
+     */
+    notificationType?: "toast" | "inline";
+    /**
+     * Provide a function that is called when menu is closed
+     */
+    onCloseButtonClick?: (e: any) => void;
+    /**
+     * By default, this value is "alert". You can also provide an alternate
+     * role if it makes sense from the accessibility-side
+     */
+    role?: string;
+    /**
+     * Provide a description for "status" icon that can be read by screen readers
+     */
+    statusIconDescription?: string;
+    /**
+     * Specify the sub-title
+     */
+    subtitle?: React.ReactNode;
+    /**
+     * Specify the title
+     */
+    title?: React.ReactNode;
+}
+export declare const Callout: React.FC<CalloutProps>;
+export default Callout;

package/es/dist/components/Notification/NotificationActionButton.d.ts

@@ -0,0 +1,18 @@
+import * as React from "react";
+interface NotificationActionButton {
+    /**
+     * Specify the content of the notification action button.
+     */
+    children?: React.ReactNode;
+    /**
+     * Specify an optional className to be applied to the notification action button
+     */
+    className?: string;
+    /**
+     * Optionally specify a click handler for the notification action button.
+     */
+    onClick?: () => void;
+}
+/** Notifications are messages that communicate information to the user. The two main types of notifications are toast notifications and inline notifications. */
+export declare const NotificationActionButton: React.FC<NotificationActionButton>;
+export {};

package/es/dist/components/Notification/NotificationButton.d.ts

@@ -0,0 +1,36 @@
+import * as React from "react";
+import { InputProps } from "../Input";
+interface NotificationButtonProps extends InputProps, React.ComponentPropsWithRef<"button"> {
+    /**
+     * Specify a label to be read by screen readers on the notification button
+     */
+    ariaLabel?: string;
+    /**
+     * Specify an optional className to be applied to the notification button
+     */
+    className?: string;
+    /**
+     * Provide a description for "close" icon that can be read by screen readers
+     */
+    iconDescription?: string;
+    /**
+     * Specify an optional icon for the Button through a string,
+     * if something but regular "close" icon is desirable
+     */
+    name?: string;
+    /**
+     * Specify the notification type
+     */
+    notificationType?: "toast" | "inline";
+    /**
+     * Optional prop to allow overriding the icon rendering.
+     * Can be a React component class
+     */
+    renderIcon?: any;
+    /**
+     * Optional prop to specify the type of the Button
+     */
+    type?: "button" | "submit" | "reset" | undefined;
+}
+export declare const NotificationButton: React.FC<NotificationButtonProps>;
+export {};

package/es/dist/components/Notification/NotificationIcon.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+interface NotificationIconProps {
+    iconDescription?: string;
+    kind: "error" | "info" | "success" | "warning" | "warning-alt";
+    notificationType: "toast" | "inline";
+}
+export declare const NotificationIcon: React.FC<NotificationIconProps>;
+export {};

package/es/dist/components/Notification/NotificationTextDetails.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+interface NotificationTextDetailsProps {
+    title?: React.ReactNode;
+    subtitle?: React.ReactNode;
+    caption?: React.ReactNode;
+    notificationType?: "toast" | "inline";
+    children?: React.ReactNode;
+}
+export declare const NotificationTextDetails: React.FC<NotificationTextDetailsProps>;
+export {};

package/es/dist/components/Notification/ToastNotification.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+import { CalloutProps } from "./Callout";
+interface ToastNotificationProps extends CalloutProps {
+    /**
+     * Specify the timeout in milliseconds
+     */
+    timeout?: number;
+}
+export declare const ToastNotification: React.FC<ToastNotificationProps>;
+export {};

package/es/dist/components/Notification/index.d.ts

@@ -0,0 +1,5 @@
+export * from './NotificationButton';
+export * from './NotificationActionButton';
+export * from './NotificationTextDetails';
+export * from './ToastNotification';
+export { Callout } from './Callout';

package/es/dist/components/NumberInput/NumberInput.Skeleton.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+interface NumberInputSkeletonProps {
+    /**
+     * Specify whether the label should be hidden, or not
+     **/
+    hideLabel?: boolean;
+    id?: string;
+}
+declare const NumberInputSkeleton: React.FC<NumberInputSkeletonProps>;
+export default NumberInputSkeleton;

package/es/dist/components/NumberInput/NumberInput.d.ts

@@ -0,0 +1,64 @@
+import * as React from "react";
+import { InputProps } from "../Input";
+interface NumberInputProps extends InputProps, Omit<React.ComponentPropsWithRef<"input">, "onChange" | "value"> {
+    /**
+     * The maximum value.
+     */
+    max?: string | number;
+    /**
+     * The minimum value.
+     */
+    min?: string | number;
+    /**
+     * Specify how much the valus should increase/decrease upon clicking on up/down button
+     */
+    step?: number;
+    /**
+     * `true` to allow empty string.
+     */
+    allowEmpty?: boolean;
+    /**
+     * Specify if the control should be disabled, or not
+     */
+    disabled?: boolean;
+    /**
+     * Specify a custom `id` for the input
+     */
+    id?: string;
+    /**
+     * Provide text that is used alongside the control label for additional help
+     */
+    helperText?: string;
+    /**
+     * Specify whether you want the underlying label to be visually hidden
+     */
+    hideLabel?: boolean;
+    /**
+     * Specify whether you want the up/down buttons to be hidden
+     */
+    hideControls?: boolean;
+    /**
+     * `true` to use the light version.
+     */
+    light?: boolean;
+    /**
+     * Specify the regular expression that the value should match using the html pattern attribute
+     */
+    pattern?: string;
+    /**
+     * The new value is available in 'imaginaryTarget.value'
+     * i.e. to get the value: evt.imaginaryTarget.value or in th second argument provided to the onChange prop
+     */
+    onChange?: (evt?: React.ChangeEvent | any, value?: number, direction?: string) => void;
+    /**
+     * Provide an optional function to be called when the up/down button is clicked
+     */
+    onClick?: (evt?: React.MouseEvent, value?: number, direction?: string) => void;
+    /**
+     * Specify the value of the input, if undefined or null the value is empty
+     */
+    value?: "" | number | string;
+}
+/** The number input component is used for entering numeric values and includes controls for incrementally increasing or decreasing the value */
+declare const NumberInput: React.FC<NumberInputProps>;
+export default NumberInput;

package/es/dist/components/NumberInput/index.d.ts

@@ -0,0 +1,2 @@
+export * from './NumberInput.Skeleton';
+export { default } from './NumberInput';