@progressiveui/react 1.22.0

package/es/dist/components/SubNavigation/SubNavigationGroup.d.ts

@@ -0,0 +1,17 @@
+import * as React from "react";
+interface SubNavigationGroupProps extends Omit<React.ComponentPropsWithRef<"div">, "title"> {
+    /**
+     * Specify a the content of the SubNavigationGroup
+     */
+    children?: React.ReactNode;
+    /**
+     * Specify the number of columns
+     */
+    columns?: number;
+    /**
+     * The title of the SubNavigationGroup
+     */
+    title?: React.ReactNode;
+}
+export declare const SubNavigationGroup: ({ children, columns, className, title, ...other }: SubNavigationGroupProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/es/dist/components/SubNavigation/SubNavigationHeader.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+interface SubNavigationHeaderProps extends React.ComponentPropsWithoutRef<"div"> {
+    /**
+     * Specify a the content of the SubNavigationHeader
+     */
+    children?: React.ReactNode;
+}
+export declare const SubNavigationHeader: ({ children, className, ...other }: SubNavigationHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/es/dist/components/SubNavigation/SubNavigationItem.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+interface SubNavigationItemProps extends React.ComponentPropsWithoutRef<"div"> {
+    /**
+     * Specify a the content of the SubNavigationItem
+     */
+    children?: React.ReactNode;
+}
+export declare const SubNavigationItem: ({ children, className, ...other }: SubNavigationItemProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/es/dist/components/SubNavigation/SubNavigationLink.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+interface SubNavigationLinkProps extends React.ComponentPropsWithoutRef<"div"> {
+    /**
+     * Specify a the content of the SubNavigationLink
+     */
+    children?: React.ReactNode;
+}
+export declare const SubNavigationLink: ({ children, className, ...other }: SubNavigationLinkProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/es/dist/components/SubNavigation/SubNavigationList.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+interface SubNavigationListProps extends React.ComponentPropsWithoutRef<"div"> {
+    /**
+     * Specify a the content of the SubNavigationList
+     */
+    children?: React.ReactNode;
+}
+export declare const SubNavigationList: ({ children, className, ...other }: SubNavigationListProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/es/dist/components/SubNavigation/SubNavigationTitle.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+interface SubNavigationTitleProps extends React.ComponentPropsWithoutRef<"div"> {
+    /**
+     * Specify a the content of the SubNavigationTitle
+     */
+    children?: React.ReactNode;
+}
+export declare const SubNavigationTitle: ({ children, className, ...other }: SubNavigationTitleProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,9 @@
+export { SubNavigation } from "./SubNavigation";
+export { SubNavigationItem } from "./SubNavigationItem";
+export { SubNavigationHeader } from "./SubNavigationHeader";
+export { SubNavigationTitle } from "./SubNavigationTitle";
+export { SubNavigationLink } from "./SubNavigationLink";
+export { SubNavigationFilter } from "./SubNavigationFilter";
+export { SubNavigationContent } from "./SubNavigationContent";
+export { SubNavigationList } from "./SubNavigationList";
+export { SubNavigationGroup } from "./SubNavigationGroup";

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

@@ -0,0 +1,83 @@
+import * as React from "react";
+export interface TabProps extends React.ComponentPropsWithRef<"li"> {
+    /**
+     * Optional callback for when a tab is clicked. Provides the index, label, and event details.
+     * @functionality
+     */
+    handleTabClick?: (index?: number, label?: string | React.ReactNode, evt?: React.ChangeEvent<HTMLInputElement>) => void;
+    /**
+     * Optional callback for when a tab gains focus. Provides the index of the focused tab.
+     * @functionality
+     */
+    handleTabAnchorFocus?: (index?: number) => void;
+    /**
+     * Optional callback for when a keydown event occurs on a tab. Provides the index, label, and event details.
+     * @functionality
+     */
+    handleTabKeyDown?: (index?: number, label?: string | React.ReactNode, evt?: React.ChangeEvent<HTMLInputElement>) => void;
+    /**
+     * Href for the tab, useful when each tab is associated with a different URL.
+     * @navigation
+     */
+    href?: string;
+    /**
+     * Index of the tab within the Tabs component.
+     * @navigation
+     */
+    index?: number;
+    /**
+     * Content to be displayed as the label of the tab. Can be a string or React node.
+     * @content
+     */
+    label?: React.ReactNode;
+    /**
+     * ARIA role for the tab element, often set to 'tab'.
+     * @accessibility
+     */
+    role?: string;
+    /**
+     * Indicates whether the tab is currently selected.
+     * @state
+     */
+    selected?: boolean;
+    /**
+     * TabIndex for the tab, useful for accessibility and keyboard navigation.
+     * @accessibility
+     */
+    tabIndex?: number;
+    /**
+     * Optional custom renderer for the anchor element within the tab.
+     * @render
+     */
+    renderAnchor?: (props?: object) => React.ReactNode;
+    /**
+     * Optional custom renderer for the content of the tab.
+     * @render
+     */
+    renderContent?: () => React.ReactNode;
+    /**
+     * Optional custom renderer for the list element of the tab.
+     * @render
+     */
+    renderListElement?: ((props?: object) => React.ReactNode) | React.ReactNode;
+    /**
+     * Optional CSS class to apply to the tab. Allows for additional styling.
+     * @style
+     */
+    className?: string;
+    /**
+     * Indicates whether the tab is disabled.
+     * @state
+     */
+    disabled?: boolean;
+    /**
+     * Optional components to replace default elements of the Tab, such as the Tab itself.
+     * @customization
+     */
+    components?: {
+        Tab?: React.ReactNode;
+    };
+}
+/** Tab to be used inside the Tabs component */
+declare const Tab: React.FC<TabProps>;
+export default Tab;

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

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

package/es/dist/components/Tab/useTab.d.ts

@@ -0,0 +1,12 @@
+export default function useTab(props: any): {
+    liProps: any;
+    anchorProps: {
+        className: string;
+        href: any;
+        label: any;
+        role: string;
+        tabIndex: any;
+        'aria-selected': any;
+    };
+    selectedClasses: string;
+};

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

@@ -0,0 +1,13 @@
+import React, { PropsWithChildren } from 'react';
+interface TabContentProps {
+    /**
+     * Specify whether the TabContent is selected
+     */
+    selected: boolean;
+    /**
+     * Pass in content to render inside of the TabContent
+     */
+    children?: React.ReactNode;
+}
+declare const TabContent: React.FC<PropsWithChildren<TabContentProps>>;
+export default TabContent;

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

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

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

@@ -0,0 +1,8 @@
+import * as React from 'react';
+export interface TableProps extends React.HTMLAttributes<HTMLTableElement> {
+    withBorder?: boolean;
+    responsive?: boolean;
+}
+/** Tables are used to make large volumes of data easy to understand and to access. */
+declare const Table: React.FC<TableProps>;
+export default Table;

package/es/dist/components/Table/TableSorting.d.ts

@@ -0,0 +1,11 @@
+import * as React from "react";
+import type { PropsWithChildren } from "react";
+type TableSortingProps = PropsWithChildren<{
+    isSorted?: boolean;
+    isSortedDesc?: boolean;
+    sortType?: boolean;
+    withBorder?: boolean;
+    className?: string;
+}>;
+declare const TableSorting: React.FC<TableSortingProps>;
+export default TableSorting;

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

@@ -0,0 +1,2 @@
+export { default } from './Table';
+export * as TableSorting from './TableSorting';

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

@@ -0,0 +1,33 @@
+import React from 'react';
+export interface TagProps extends React.HTMLAttributes<HTMLTableElement> {
+    withBorder?: boolean;
+    responsive?: boolean;
+}
+declare const ReactTablePagination: {
+    ({ data, page, pageSizeOptions, paginationClassName, totalItems, style, onPageChange, onPageSizeChange, isLastPage, pages, pageInputDisabled, pageSize, pagesUnknown, backwardText, forwardText, itemsPerPageText, itemsPerPageFollowsText, itemRangeText, pageRangeText, pageSizesDisabled, itemText, pageNumberText, }: {
+        data: any;
+        page: any;
+        pageSizeOptions: any;
+        paginationClassName: any;
+        totalItems: any;
+        style: any;
+        onPageChange: any;
+        onPageSizeChange: any;
+        isLastPage: any;
+        pages: any;
+        pageInputDisabled: any;
+        pageSize: any;
+        pagesUnknown: any;
+        backwardText: any;
+        forwardText: any;
+        itemsPerPageText: any;
+        itemsPerPageFollowsText: any;
+        itemRangeText: any;
+        pageRangeText: any;
+        pageSizesDisabled: any;
+        itemText: any;
+        pageNumberText: any;
+    }): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default ReactTablePagination;

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

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

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

@@ -0,0 +1,67 @@
+import * as React from "react";
+export interface TabsProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Specify the text to be read by screen-readers when visiting the <Tabs>
+     * component
+     */
+    ariaLabel?: string;
+    /**
+     * Pass in a collection of <Tab> children to be rendered depending on the
+     * currently selected tab
+     */
+    children?: React.ReactNode;
+    /**
+     * Provide a className that is applied to the root <nav> component for the
+     * <Tabs>
+     */
+    className?: string;
+    /**
+     * Provide a customTabContent by using independent action triggers
+     * inside the Tabs
+     */
+    customTabContent?: boolean;
+    /**
+     * Specify whether the animation should be used
+     */
+    disableAnimation?: boolean;
+    /**
+     * Specify whether the Tabs are displayed inline
+     */
+    inline?: boolean;
+    /**
+     * Specify whether the Tab content is hidden
+     */
+    hidden?: boolean;
+    /**
+     * By default, this value is "navigation". You can also provide an alternate
+     * role if it makes sense from the accessibility-side
+     */
+    role?: string;
+    /**
+     * Optionally provide an `onClick` handler that is invoked when a <Tab> is
+     * clicked
+     */
+    onClick?: () => void;
+    /**
+     * Optionally provide an `onKeyDown` handler that is invoked when keyed
+     * navigation is triggered
+     */
+    onKeyDown?: () => void;
+    /**
+     * Provide an optional handler that is called whenever the selection
+     * changes. This method is called with the index of the tab that was
+     * selected
+     */
+    onSelectionChange?: () => void;
+    /**
+     * Provide a string that represents the `href` for the triggered <Tab>
+     */
+    triggerHref?: string;
+    /**
+     * Optionally provide an index for the currently selected <Tab>
+     */
+    selected?: string;
+}
+/** Tabs allow users to navigate easily between views within the same context */
+declare const Tabs: React.FC<TabsProps>;
+export default Tabs;

package/es/dist/components/Tabs/TabsContext.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export interface TabsContextType {
+    handleTabClick?: (onSelectionChange?: any) => void;
+    handleTabKeyDown?: (onSelectionChange?: any) => void;
+    handleTabAnchorFocus?: (onSelectionChange?: any) => void;
+}
+declare const TabsContext: React.Context<TabsContextType>;
+export default TabsContext;

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

@@ -0,0 +1 @@
+export { default } from "./Tabs";

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

@@ -0,0 +1,14 @@
+import * as React from "react";
+export interface TagProps extends React.HTMLAttributes<HTMLSpanElement> {
+    /**
+     * Specify the type of Tag @design
+     */
+    type?: "wfp" | "info" | "error" | "success" | "warning" | "custom" | string;
+    /**
+     * Specify if the Tag should be wrapped if it is too long @deprecated
+     */
+    wrap?: boolean;
+}
+/** Tag is used to label, categorize, or organize items using keywords that describe them. */
+declare const Tag: React.FC<TagProps>;
+export default Tag;

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

@@ -0,0 +1,2 @@
+export * from "./Tag";
+export { default } from "./Tag";

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

@@ -0,0 +1,30 @@
+import * as React from "react";
+import { Spacing, TextKind } from "../../utils";
+interface TextProps extends React.AllHTMLAttributes<HTMLDivElement> {
+    /**
+     * Specifies the kind of text to be displayed. This could be an enumeration that defines various text styles or types.
+     */
+    kind?: TextKind;
+    /**
+     * The content of the Text component, typically a string or nested React elements.
+     */
+    children?: React.ReactNode;
+    /**
+     * Spacing to be applied above the Text component. 'Spacing' could be a type that represents predefined spacing values.
+     */
+    spacingTop?: Spacing;
+    /**
+     * Spacing to be applied below the Text component. Similar to spacingTop, it uses the Spacing type for predefined values.
+     */
+    spacingBottom?: Spacing;
+    /**
+     * Additional custom class name(s) that can be applied to the Text component for styling purposes.
+     */
+    className?: string;
+}
+export declare const textLookup: Record<TextKind, keyof JSX.IntrinsicElements>;
+/**
+ *Text is a component for displaying paragraphs. You can use Text to standardize text across your web app. For longer sections or full articles use the <Story /> component instead.
+ */
+declare const Text: React.FC<TextProps>;
+export default Text;

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

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

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

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import { InputProps } from '../Input';
+interface TextAreaProps extends InputProps, React.ComponentPropsWithRef<'textarea'> {
+    fullWidth?: boolean;
+}
+export type Ref = HTMLTextAreaElement;
+export declare const TextArea: React.ForwardRefExoticComponent<Omit<TextAreaProps, "ref"> & React.RefAttributes<HTMLTextAreaElement>>;
+export default TextArea;

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

@@ -0,0 +1 @@
+export { default } from "./TextArea";

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

@@ -0,0 +1,7 @@
+import * as React from "react";
+import { InputProps } from "../Input";
+/** Text inputs enable the user to interact with and input content and data. This component can be used for long and short form entries. */
+interface TextInputProps extends InputProps, React.ComponentPropsWithRef<"input"> {
+}
+declare const TextInput: React.FC<TextInputProps>;
+export default TextInput;

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

@@ -0,0 +1 @@
+export { default } from "./TextInput";

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

@@ -0,0 +1,38 @@
+import * as React from "react";
+import { InputProps } from "../Input";
+/** A toggle is used to quickly switch between two possible states. They are commonly used for “on/off” switches */
+interface ToggleProps extends InputProps, React.ComponentPropsWithRef<"input"> {
+    /**
+     * Specify whether the toggle should be on by default
+     */
+    defaultToggled?: boolean;
+    toggled?: boolean;
+    /**
+     * Specify the label for the "off" position
+     */
+    labelA?: string;
+    /**
+     * Specify the label for the "on" position
+     */
+    labelB?: string;
+    /**
+     * Provide an optional hook that is called when the control is toggled
+     */
+    onToggle?: (value: boolean, htmlFor: string, event: React.ChangeEvent<HTMLInputElement>) => void;
+    className?: string;
+    /**
+     * Provide an id that unique represents the underlying `input`
+     */
+    id?: string;
+    /**
+     * Provide an name that unique represents the underlying `input`
+     */
+    name?: string;
+    /**
+     * Provide a function that is called when a change event occurs on the control
+     */
+    onChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
+}
+export type Ref = HTMLTextAreaElement;
+declare const Toggle: React.FC<ToggleProps>;
+export default Toggle;

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

@@ -0,0 +1 @@
+export { default } from "./Toggle";

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

@@ -0,0 +1,103 @@
+import * as React from "react";
+import { Placement } from "../../utils";
+export interface TooltipProps {
+    /**
+     * React nodes that trigger the tooltip on interaction.
+     */
+    children: React.ReactNode;
+    /**
+     * Content of the tooltip. Can be a React node or a function returning a React node.
+     * The function receives an object with functions to set visibility and handle visibility change.
+     */
+    content?: React.ReactNode | ((options: {
+        setVisibility: React.Dispatch<React.SetStateAction<boolean>>;
+        visibilityChange: (state: boolean) => void;
+    }) => React.ReactNode);
+    /**
+     * @deprecated If true, applies a dark theme to the tooltip.
+     */
+    dark?: boolean;
+    /**
+     * If true, removes padding from the tooltip.
+     */
+    noPadding?: boolean;
+    /**
+     * Position of the tooltip relative to the child element. Uses the Placement type from utils.
+     */
+    placement?: Placement;
+    /**
+     * Trigger action for the tooltip - can be "hover" or "click".
+     */
+    trigger?: "hover" | "click";
+    /**
+     * Popper.js modifiers for advanced tooltip positioning.
+     */
+    modifiers?: [];
+    /**
+     * If true, renders the tooltip in a React portal.
+     */
+    usePortal?: boolean;
+    /**
+     * If true, wraps the child element with a span to attach a ref for the tooltip.
+     */
+    createRefWrapper?: boolean;
+    /**
+     * If true, the tooltip is interactive (hoverable/clickable).
+     */
+    interactive?: boolean;
+    /**
+     * Delay in milliseconds before hiding the tooltip.
+     */
+    delayHide?: number;
+    /**
+     * Additional custom class names for styling the tooltip.
+     */
+    className?: string;
+    /**
+     * If true, closes the tooltip when clicking outside of it.
+     */
+    closeOnOutsideClick?: boolean;
+    /**
+     * Close the tooltip when the trigger element is hidden.
+     */
+    closeOnTriggerHidden?: boolean;
+    /**
+     * If the tooltip should be visible by default.
+     */
+    defaultVisible?: boolean;
+    /**
+     * Delay in milliseconds before showing the tooltip.
+     */
+    delayShow?: number;
+    /**
+     * If true, the tooltip follows the cursor.
+     */
+    followCursor?: boolean;
+    /**
+     * Options for observing DOM changes through a MutationObserver.
+     */
+    mutationObserverOptions?: MutationObserverInit | null;
+    /**
+     * Offset of the tooltip from the trigger element, specified as a tuple [x, y].
+     */
+    offset?: [number, number];
+    /**
+     * Callback function when the visibility state of the tooltip changes.
+     */
+    onVisibleChange?: (state: boolean) => void;
+}
+export declare const tooltipStyle: {
+    duration: number;
+    animation: string;
+    theme: string;
+    arrow: boolean;
+};
+export declare const tooltipStyleDark: {
+    duration: number;
+    animation: string;
+    theme: string;
+    arrow: boolean;
+};
+/** Tooltips display additional information upon click, hover, or focus. The information should be contextual, useful, and nonessential. */
+declare const Tooltip: React.FC<React.PropsWithChildren<TooltipProps>>;
+export default Tooltip;

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

@@ -0,0 +1,2 @@
+export { tooltipStyle, tooltipStyleDark } from './Tooltip';
+export { default } from './Tooltip';

package/es/dist/components/Unit/InvalidUnit.d.ts

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

package/es/dist/components/Unit/SimpleCalc.d.ts

@@ -0,0 +1,17 @@
+type SimpleCalcProps = {
+    calcOnly?: boolean;
+    children?: any;
+    string?: boolean;
+    svg?: boolean;
+    hideUnit?: boolean;
+    className?: string;
+    after?: string;
+    before?: string;
+};
+declare const SimpleCalc: (props: SimpleCalcProps, after?: string, before?: string) => string | import("react/jsx-runtime").JSX.Element | {
+    value: any;
+    before: string | undefined;
+    after: string | undefined;
+    output: string;
+} | undefined;
+export default SimpleCalc;

package/es/dist/components/Unit/StringUnit.d.ts

@@ -0,0 +1,2 @@
+declare const StringUnit: (value: any) => string;
+export default StringUnit;

package/es/dist/components/Unit/SvgUnit.d.ts

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

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

@@ -0,0 +1,54 @@
+import * as React from 'react';
+interface UnitProps extends React.ComponentPropsWithoutRef<'div'> {
+    /**
+      The value which should be displayed
+    */
+    children: string | number;
+    /**
+        Only used for type Percentage will divide value/from string, float
+      */
+    from?: string | number;
+    /**
+        The interface of the input value
+      */
+    input?: string;
+    /**
+     * Display zero values to be displayed
+     */
+    showZero: boolean;
+    /**
+        Hide the Unit if it's value is zero.
+      */
+    hideEmpty: boolean;
+    /**
+        The minimum number of fraction digits to use. Possible values are from 0 to 20. Only used on numeric types
+      */
+    minimumFractionDigits?: number;
+    /**
+        A value between 1-21, The maximum number of significant digits to use. Possible values are from 1 to 21; the default is minimumSignificantDigits.
+      */
+    maximumSignificantDigits?: number;
+    output?: string;
+    string?: boolean;
+    localeStringLanguage?: string;
+    maximumFractionDigits?: number;
+    textAnchor?: string;
+    /**
+     * A string with a BCP 47 language code, or an array of language codes. For the general form and interpretation of the locale argument see the [toLocaleString on developer.mozilla.org](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleString) page.
+     */
+    locale?: string;
+    /**
+        Setup the Unit
+      */
+    setup?: boolean;
+    /**
+        Render output as svg text
+      */
+    svg?: boolean;
+    /**
+        The unit type  */
+    type: 'none' | 'usd' | 'partners' | 'beneficiaries' | 'households' | 'months' | 'mt' | 'metricTons' | 'kg' | 'num' | 'yearMonth' | 'level' | 'people' | 'countries' | 'percentage';
+}
+/** The Unit component method returns a component with a language and unit sensitive representation of this number based on [Numbers and Unit from the Editorial Guidelines](https://cdn.wfp.org/guides/editorial/content/numbers-and-units/) the [Numbers and Units Reference on developer.mozilla.org](http://cdn.wfp.org/guides/editorial/content/numbers-and-units). */
+declare const Unit: React.FC<UnitProps>;
+export default Unit;