@unifiedsoftware/react-ui 1.0.8-beta → 1.0.10

package/dist/index.d.mts

@@ -0,0 +1,333 @@
+import * as react from 'react';
+import react__default, { Dispatch, SetStateAction } from 'react';
+
+type BadgePlacement = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+
+interface Props$6 {
+    /**
+     * The placement of the badge relative to its content.
+     */
+    placement?: BadgePlacement;
+    /**
+     * The content to display within the badge.
+     */
+    content?: React.ReactNode;
+}
+type NativeAttrs$6 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$6>;
+type BadgeProps = Props$6 & NativeAttrs$6;
+declare const Badge: React.FC<BadgeProps>;
+
+type ButtonVariant = 'filled' | 'outlined' | 'text' | 'plain';
+type ButtonColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger';
+type ButtonSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+
+interface Props$5 {
+    /**
+     * The HTML element type or React component to render as the button.
+     */
+    as?: React.ElementType;
+    /**
+     * The variant style of the button.
+     */
+    variant?: ButtonVariant;
+    /**
+     * The color of the button.
+     */
+    color?: ButtonColor;
+    /**
+     * The size of the button.
+     */
+    size?: ButtonSize;
+    /**
+     * Content to display as an icon within the button. Typically an icon component.
+     */
+    iconOnly?: React.ReactNode;
+    /**
+     * Content to display at the start of the button, before the button's text.
+     */
+    startContent?: React.ReactNode;
+    /**
+     * Content to display at the end of the button, after the button's text.
+     */
+    endContent?: React.ReactNode;
+    /**
+     * Whether the button is in a loading state.
+     */
+    loading?: boolean;
+    /**
+     * Whether the button is disabled.
+     */
+    disabled?: boolean;
+}
+type NativeAttrs$5 = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, keyof Props$5>;
+type ButtonProps = Props$5 & NativeAttrs$5;
+declare const Button: react.ForwardRefExoticComponent<Props$5 & NativeAttrs$5 & react.RefAttributes<HTMLButtonElement>>;
+
+type ChipVariant = 'filled' | 'outlined' | 'text';
+type ChipColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger';
+type ChipSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+
+interface Props$4 {
+    /**
+     * The HTML element type or React component to render as the chip.
+     */
+    as?: React.ElementType;
+    /**
+     * The variant style of the chip.
+     */
+    variant?: ChipVariant;
+    /**
+     * The color of the chip.
+     */
+    color?: ChipColor;
+    /**
+     * The size of the chip.
+     */
+    size?: ChipSize;
+}
+type NativeAttrs$4 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$4>;
+type ChipProps = Props$4 & NativeAttrs$4;
+declare const Chip: react.ForwardRefExoticComponent<Props$4 & NativeAttrs$4 & react.RefAttributes<HTMLDivElement>>;
+
+interface CollapseProps {
+    children: React.ReactNode;
+    isOpen?: boolean;
+    onOpen?: () => void;
+    onClose?: () => void;
+    onToggle?: () => void;
+}
+declare const Collapse: React.FC<CollapseProps>;
+
+interface CollapseContentProps {
+    children: React.ReactNode;
+}
+declare const CollapseContent: React.FC<CollapseContentProps>;
+
+interface CollapseContextValue {
+    collapseRef: React.MutableRefObject<HTMLDivElement | null>;
+    isOpen: boolean;
+    heightAuto: boolean;
+    onOpen: () => void;
+    onClose: () => void;
+    onToggle: () => void;
+}
+declare const CollapseContext: react.Context<CollapseContextValue | null>;
+declare const useCollapse: () => CollapseContextValue;
+
+interface CollapseTriggerProps {
+    children: react__default.ReactNode;
+}
+declare const CollapseTrigger: react__default.FC<CollapseTriggerProps>;
+
+interface IconProps {
+    children: React.ReactNode;
+    color?: 'primary' | 'secondary';
+    size?: 'sm' | 'md' | 'lg';
+}
+declare const Icon: react.ForwardRefExoticComponent<IconProps & react.RefAttributes<unknown>>;
+
+interface Props$3 {
+    /**
+     * The HTML element type or React component to render as the menu item.
+     */
+    as?: React.ElementType;
+    /**
+     * The value associated with the menu item.
+     */
+    value?: any;
+    /**
+     * The title to display for the menu item.
+     */
+    title: string;
+    /**
+     * Optional icon to display with the menu item.
+     */
+    icon?: React.ReactNode;
+    /**
+     * The nesting level of the menu item, for hierarchical menus.
+     */
+    level?: number;
+    /**
+     * Whether the item is disabled.
+     */
+    disabled?: boolean;
+}
+type NativeAttrs$3 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$3 | 'items'>;
+type MenuItemProps = Props$3 & NativeAttrs$3;
+declare const MenuItem: react.ForwardRefExoticComponent<Props$3 & NativeAttrs$3 & {
+    children?: react.ReactNode;
+} & react.RefAttributes<HTMLDivElement>>;
+
+type MenuSubmenuProps = Omit<MenuItemProps, 'items'> & {
+    items?: MenuItemType[];
+};
+declare const MenuSubmenu: React.FC<MenuSubmenuProps>;
+
+type MenuGroupItemType = (MenuItemProps & {
+    type?: 'item';
+}) | (MenuSubmenuProps & {
+    type?: 'submenu';
+});
+type MenuGroupProps = Omit<MenuItemProps, 'items'> & {
+    items?: MenuGroupItemType[];
+};
+declare const MenuGroup: React.FC<MenuGroupProps>;
+
+type MenuItemType = (MenuGroupProps & {
+    type?: 'group';
+}) | (MenuSubmenuProps & {
+    type?: 'submenu';
+}) | (MenuItemProps & {
+    type?: 'item';
+});
+interface Props$2 {
+    /**
+     * The currently selected value of the menu.
+     */
+    value?: any[];
+    /**
+     * The default value of the menu when initially rendered.
+     */
+    defaultValue?: any[];
+    /**
+     * An array of values that represent open submenus in the menu.
+     */
+    openValues?: any[];
+    /**
+     * The expand mode of the menu, which can be 'single' or 'multiple'.
+     */
+    expandMode?: 'single' | 'multiple';
+    /**
+     * The nav mode of the menu, which can be 'manual' or 'automatic'.
+     * Search for the last level of the menu and validate if the value matches.
+     */
+    navMode?: 'manual' | 'automatic';
+    /**
+     * A callback function called when the selected values of the menu change.
+     */
+    onChange?: (value: any[]) => void;
+    /**
+     * A callback function called when submenus are opened.
+     */
+    onOpen?: (values: any[]) => void;
+    /**
+     * A callback function called when a menu item is selected.
+     * @param {MenuItemProps} props - The properties of the selected menu item.
+     */
+    onItemSelect?: (props: MenuItemProps) => void;
+}
+type NativeAttrs$2 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$2 | 'items'>;
+type MenuProps = Props$2 & NativeAttrs$2 & {
+    items: MenuItemType[];
+};
+declare const Menu: React.FC<MenuProps>;
+
+interface MenuContextValue {
+    value: any;
+    originalValue: any;
+    openValues: any[];
+    expandMode: 'single' | 'multiple';
+    navMode: 'manual' | 'automatic';
+    onChange: (value: any) => void;
+    onOpen: (values: any) => void;
+    onItemSelect: (props: MenuItemProps) => void;
+}
+declare const MenuContext: react.Context<MenuContextValue | null>;
+declare const useMenu: () => MenuContextValue;
+
+declare const MenuValueContext: react.Context<string[]>;
+declare const useMenuItemValue: () => string[];
+
+declare const getOpenValuesByPathname: (pathname: string) => string[];
+
+interface Props$1 {
+    /**
+     * The HTML element type or React component to render as the tab.
+     */
+    as?: React.ElementType;
+    /**
+     * The value associated with the tab.
+     */
+    value?: any;
+    /**
+     * Whether the tab can be closed.
+     */
+    closable?: boolean;
+    /**
+     * Whether the tab is disabled.
+     */
+    disabled?: boolean;
+}
+type NativeAttrs$1 = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props$1>;
+type TabProps = Props$1 & NativeAttrs$1;
+declare const Tab: react.ForwardRefExoticComponent<Props$1 & NativeAttrs$1 & {
+    children?: react.ReactNode;
+} & react.RefAttributes<HTMLDivElement>>;
+
+type TabsAlignmet = 'start' | 'center' | 'end' | 'stretch';
+
+interface Props {
+    /**
+     * The currently selected value of the tabs.
+     */
+    value?: any;
+    /**
+     * The default value of the tabs when initially rendered.
+     */
+    defaultValue?: any;
+    /**
+     * The alignment of the tabs.
+     */
+    alignment?: TabsAlignmet;
+    /**
+     * A callback function called when the selected tab value changes.
+     */
+    onChange?: (value: any) => void;
+    /**
+     * A callback function called when a tab is closed.
+     */
+    onClose?: (value: any) => void;
+}
+type NativeAttrs = Omit<React.HTMLAttributes<HTMLDivElement>, keyof Props>;
+type TabsProps = Props & NativeAttrs;
+declare const Tabs: React.FC<TabsProps>;
+
+declare global {
+    interface WindowEventMap {
+        'local-storage': CustomEvent;
+    }
+}
+type SetValue<T> = Dispatch<SetStateAction<T>>;
+/**
+ * It's a React hook that allows you to store and retrieve data from localStorage
+ * @param {string} key - string
+ * @param {T} initialValue - The initial value to use if the key doesn't exist in localStorage.
+ * @returns An array of two items. The first item is the value of the local storage key. The second
+ * item is a function that can be used to set the value of the local storage key.
+ */
+declare function useLocalStorage<T>(key: string, initialValue: T): [T, SetValue<T>];
+
+/**
+ * It returns the previous value of the given value
+ * @param {any} value - any - The value to track.
+ * @returns The previous value of the variable.
+ */
+declare const usePrevious: (value: any) => undefined;
+
+interface Helpers {
+    goToNextStep: () => void;
+    goToPrevStep: () => void;
+    reset: () => void;
+    canGoToNextStep: boolean;
+    canGoToPrevStep: boolean;
+    setStep: Dispatch<SetStateAction<number>>;
+}
+/**
+ * It returns a tuple with the current step and an object with functions to manipulate the step
+ * @param {number} maxStep - number - The maximum number of steps in the stepper.
+ * @returns An array with two elements. The first element is the current step. The second element is an
+ * object with the following properties:
+ */
+declare const useStep: (maxStep: number) => [number, Helpers];
+
+export { Badge, BadgeProps, Button, ButtonColor, ButtonProps, ButtonSize, ButtonVariant, Chip, ChipProps, Collapse, CollapseContent, CollapseContentProps, CollapseContext, CollapseContextValue, CollapseProps, CollapseTrigger, CollapseTriggerProps, Icon, IconProps, Menu, MenuContext, MenuContextValue, MenuGroup, MenuGroupItemType, MenuGroupProps, MenuItem, MenuItemProps, MenuItemType, MenuProps, MenuSubmenu, MenuSubmenuProps, MenuValueContext, Tab, TabProps, Tabs, TabsAlignmet, TabsProps, getOpenValuesByPathname, useCollapse, useLocalStorage, useMenu, useMenuItemValue, usePrevious, useStep };

package/dist/index.d.ts

@@ -196,12 +196,12 @@ interface Props$2 {
     /**
      * The expand mode of the menu, which can be 'single' or 'multiple'.
      */
-    navMode?: 'single' | 'multiple';
+    expandMode?: 'single' | 'multiple';
     /**
      * The nav mode of the menu, which can be 'manual' or 'automatic'.
      * Search for the last level of the menu and validate if the value matches.
      */
-    openMode?: 'manual' | 'automatic';
+    navMode?: 'manual' | 'automatic';
     /**
      * A callback function called when the selected values of the menu change.
      */
@@ -226,8 +226,8 @@ interface MenuContextValue {
     value: any;
     originalValue: any;
     openValues: any[];
-    navMode: 'single' | 'multiple';
-    openMode: 'manual' | 'automatic';
+    expandMode: 'single' | 'multiple';
+    navMode: 'manual' | 'automatic';
     onChange: (value: any) => void;
     onOpen: (values: any) => void;
     onItemSelect: (props: MenuItemProps) => void;