@boxcustodia/library 1.2.0 → 1.2.1

package/dist/src/hooks/useIsVisible/useIsVisible.d.ts

@@ -0,0 +1,11 @@
+import { RefObject } from 'react';
+
+interface UseIsVisibleProps extends IntersectionObserverInit {
+    onVisible?: () => void;
+}
+interface UseIsVisibleReturn<T> {
+    ref: RefObject<T | null>;
+    isVisible: boolean;
+}
+declare function useIsVisible<T extends HTMLElement>({ onVisible, root, rootMargin, threshold, }?: UseIsVisibleProps): UseIsVisibleReturn<T>;
+export default useIsVisible;

package/dist/src/hooks/useLocalStorage/__doc__/useLocalStorage.stories.d.ts

@@ -0,0 +1,33 @@
+import { Meta } from '@storybook/react';
+
+/**
+ * Hook que proporciona una interfaz sencilla para interactuar con el localStorage de manera tipada.
+ *
+ * Este hook permite almacenar, recuperar y eliminar valores en el localStorage de manera segura,
+ * utilizando una API genérica que asegura la consistencia de tipos en TypeScript. Es compatible con cualquier
+ * tipo de dato, desde strings hasta objetos complejos.
+ *
+ * @param key - La clave del localStorage donde se almacenará el valor.
+ * @param initialValue - El valor inicial que se utilizará si no hay datos almacenados bajo la clave proporcionada.
+ * @returns Una tupla con el valor almacenado, una función para actualizarlo y otra para eliminarlo.
+ *
+ * @example
+ * const [name, setName, removeName] = useLocalStorage<string>("name", "John Doe");
+ *
+ * @example
+ * const [count, setCount, removeCount] = useLocalStorage<number>("count", 0);
+ *
+ * @example
+ * const [items, setItems, removeItems] = useLocalStorage<string[]>("items", ["apple", "banana"]);
+ */
+declare const meta: Meta;
+export default meta;
+export declare const Default: {
+    render: () => import("react/jsx-runtime").JSX.Element;
+};
+export declare const WithNumber: {
+    render: () => import("react/jsx-runtime").JSX.Element;
+};
+export declare const WithArray: {
+    render: () => import("react/jsx-runtime").JSX.Element;
+};

package/dist/src/hooks/useLocalStorage/__test__/useLocalStorage.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/useLocalStorage/index.d.ts

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

package/dist/src/hooks/useLocalStorage/useLocalStorage.d.ts

@@ -0,0 +1,3 @@
+declare function useLocalStorage<T>(key: string): [T | undefined, (value: T) => void, () => void];
+declare function useLocalStorage<T>(key: string, initialValue: T): [T, (value: T) => void, () => void];
+export default useLocalStorage;

package/dist/src/hooks/useMediaQuery/__doc__/useMediaQuery.stories.d.ts

@@ -0,0 +1,5 @@
+import { Meta } from '@storybook/react';
+
+declare const meta: Meta;
+export default meta;
+export declare const Default: () => import("react/jsx-runtime").JSX.Element;

package/dist/src/hooks/useMediaQuery/index.d.ts

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

package/dist/src/hooks/useMediaQuery/useMediaQuery.d.ts

@@ -0,0 +1,2 @@
+declare const useMediaQuery: (query: string) => boolean;
+export default useMediaQuery;

package/dist/src/hooks/useMemoizedFn/index.d.ts

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

package/dist/src/hooks/useMemoizedFn/useMemoizedFn.d.ts

@@ -0,0 +1,3 @@
+type noop = (this: any, ...args: any[]) => any;
+declare function useMemoizedFn<T extends noop>(fn: T): T;
+export default useMemoizedFn;

package/dist/src/hooks/useMutation/__doc__/useMutation.stories.d.ts

@@ -0,0 +1,22 @@
+import { Meta } from '@storybook/react';
+
+/**
+ * El hook `useMutation` permite manejar operaciones de mutación asincrónicas, proporcionando estados de carga, error y éxito.
+ *
+ * Opciones de configuración:
+ * - `fn`: La función de mutación que se ejecutará.
+ * - `onError`: Callback opcional que se llama cuando ocurre un error.
+ * - `onSuccess`: Callback opcional que se llama cuando la mutación es exitosa.
+ * - `onFinish`: Callback opcional que se llama cuando la mutación termina, sin importar si tuvo éxito o error. Es útil para hacer un `refetch` (de `useAsync`)
+ *
+ * Devuelve un objeto con las siguientes propiedades:
+ * - `mutate`: Función para ejecutar la mutación.
+ * - `loading`: Indica si la mutación está en progreso.
+ * - `error`: Contiene el error si la mutación falla.
+ * - `data`: Contiene los datos si la mutación es exitosa.
+ */
+declare const meta: Meta;
+export default meta;
+export declare const Form: {
+    render: () => import("react/jsx-runtime").JSX.Element;
+};

package/dist/src/hooks/useMutation/__test__/useMutation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/useMutation/index.d.ts

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

package/dist/src/hooks/useMutation/useMutation.d.ts

@@ -0,0 +1,15 @@
+type Mutation<TArgs extends any[], TReturn> = (...args: TArgs) => Promise<TReturn>;
+interface UseMutationOptions<TArgs extends any[], TReturn> {
+    fn: Mutation<TArgs, TReturn>;
+    onError?: (error: Error) => void;
+    onSuccess?: (data: TReturn) => void;
+    onFinish?: () => void;
+}
+interface UseMutationReturn<TArgs extends any[], TReturn> {
+    mutate: Mutation<TArgs, TReturn>;
+    loading: boolean;
+    error: Error | null;
+    data: TReturn | null;
+}
+export declare const useMutation: <TArgs extends any[], TReturn>(opts: UseMutationOptions<TArgs, TReturn>) => UseMutationReturn<TArgs, TReturn>;
+export default useMutation;

package/dist/src/hooks/useObject/__doc__/useObject.stories.d.ts

@@ -0,0 +1,17 @@
+import { Meta } from '@storybook/react';
+
+/**
+ * Hook para manejar un estado en forma de objeto
+ *
+ * `@param initialValue` - Valor inicial del estado, se recomienda pasar para evitar el caso donde el estado `T` pueda ser `T | undefined`
+ *
+ * `@returns` [state, setState, reset]
+ */
+declare const meta: Meta;
+export default meta;
+export declare const Default: {
+    render: () => import("react/jsx-runtime").JSX.Element;
+};
+export declare const Counter: {
+    render: () => import("react/jsx-runtime").JSX.Element;
+};

package/dist/src/hooks/useObject/__test__/useObject.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/useObject/index.d.ts

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

package/dist/src/hooks/useObject/useObject.d.ts

@@ -0,0 +1,6 @@
+type GenericObject = Record<string, any>;
+type Return<TState, TArgs = ((state: TState) => Partial<TState>) | Partial<TState>> = [TState, (arg: TArgs) => void, () => void];
+type MaybeReturn<TState> = Return<TState | undefined, ((state: TState | undefined) => Partial<TState>) | Partial<TState>>;
+declare function useObject<T extends GenericObject>(): MaybeReturn<T>;
+declare function useObject<T extends GenericObject>(initialValue: T): Return<T>;
+export default useObject;

package/dist/src/hooks/usePagination/__doc__/usePagination.stories.d.ts

@@ -0,0 +1,9 @@
+import { Meta } from '@storybook/react';
+
+/**
+ * Hook que facilita el manejo de paginaciones, recibe como param la cantidad de elementos, la cantidad de elementos por página y una función
+ * que se ejecuta cuando cambia la pagina
+ */
+declare const meta: Meta;
+export default meta;
+export declare const Default: () => import("react/jsx-runtime").JSX.Element;

package/dist/src/hooks/usePagination/__test__/usePagination.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/usePagination/index.d.ts

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

package/dist/src/hooks/usePagination/usePagination.d.ts

@@ -0,0 +1,36 @@
+export type usePaginationProps = {
+    /**
+     * Cantidad total de elementos
+     */
+    totalItems: number;
+    /**
+     * Cantidad de elementos por página
+     */
+    pageSize: number;
+    /**
+     * Pagina inicial
+     */
+    initialCurrentPage?: number;
+    /**
+     * Callback que se ejecuta cuando cambia la pagina
+     */
+    onChange?: (value: {
+        currentPage: number;
+        pageSize: number;
+    }) => void;
+    siblingCount?: number;
+};
+declare function usePagination({ totalItems, pageSize, initialCurrentPage, onChange, }: usePaginationProps): {
+    next: () => void;
+    prev: () => void;
+    goTo: (page: number) => void;
+    currentPage: number;
+    maxPage: number;
+    isFirstPage: boolean;
+    isLastPage: boolean;
+    range: {
+        start: number;
+        end: number;
+    };
+};
+export default usePagination;

package/dist/src/hooks/usePortal/__doc__/usePortal.stories.d.ts

@@ -0,0 +1,7 @@
+import { Meta } from '@storybook/react';
+
+declare const meta: Meta;
+export default meta;
+export declare const Default: {
+    render: () => import('react').ReactPortal | null;
+};

package/dist/src/hooks/usePortal/__test__/usePortal.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/usePortal/index.d.ts

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

package/dist/src/hooks/usePortal/usePortal.d.ts

@@ -0,0 +1,6 @@
+import { ReactPortal, ReactNode } from 'react';
+
+declare function usePortal(id: string): {
+    render: (children: ReactNode) => ReactPortal | null;
+};
+export default usePortal;

package/dist/src/hooks/usePreventCloseWindow/__doc__/usePreventCloseWindow.stories.d.ts

@@ -0,0 +1,11 @@
+import { Meta } from '@storybook/react';
+
+/**
+ * Hook que permite prevenir que se cierre la ventana (muestra mensaje de aviso)
+ * Es útil para evitar que el usuario cierre la ventana accidentalmente mientras tiene cambios pendientes de guardar
+ */
+declare const meta: Meta;
+export default meta;
+export declare const Default: {
+    render: (args: any) => import("react/jsx-runtime").JSX.Element;
+};

package/dist/src/hooks/usePreventCloseWindow/index.d.ts

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

package/dist/src/hooks/usePreventCloseWindow/usePreventCloseWindow.d.ts

@@ -0,0 +1,13 @@
+interface UsePreventUnloadProps {
+    /**
+     * Propiedad que determina si la ventana se puede cerrar o no
+     */
+    shouldPrevent: boolean;
+    /**
+     * Mensaje que se va a mostrar al usuario antes de cerrar la ventana
+     * @deprecated ya no es soportado por los navegadores modernos
+     */
+    message?: string;
+}
+declare function usePreventClose({ shouldPrevent, message, }: UsePreventUnloadProps): void;
+export default usePreventClose;

package/dist/src/hooks/useRangePagination/__test__/useRangePagination.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/useRangePagination/index.d.ts

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

package/dist/src/hooks/useRangePagination/useRangePagination.d.ts

@@ -0,0 +1,24 @@
+import { usePaginationProps } from '..';
+
+export declare const DOTS = "...";
+export type useRangePaginationProps = {
+    /**
+     * Cantidad de elementos visibles al lado de la pagina actual
+     */
+    siblingCount?: number;
+} & usePaginationProps;
+declare const useRangePagination: ({ siblingCount, ...paginationProps }: useRangePaginationProps) => {
+    paginationRange: (string | number)[];
+    next: () => void;
+    prev: () => void;
+    goTo: (page: number) => void;
+    currentPage: number;
+    maxPage: number;
+    isFirstPage: boolean;
+    isLastPage: boolean;
+    range: {
+        start: number;
+        end: number;
+    };
+};
+export default useRangePagination;

package/dist/src/hooks/useSelection/__doc__/useSelection.stories.d.ts

@@ -0,0 +1,12 @@
+import { Meta, StoryObj } from '@storybook/react';
+
+/**
+ * Gestión de la selección de elementos en una lista.
+ * Optimizado para un rendimiento eficiente, utiliza un conjunto (Set) interno para almacenar los elementos seleccionados, permitiendo consultas rápidas para verificar si un elemento está seleccionado.
+ * Proporciona funciones simples para seleccionar, deseleccionar, alternar la selección de un elemento, seleccionar todos los elementos, limpiar la selección y obtener el estado actual de la selección
+ */
+declare const meta: Meta;
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const Default: Story;
+export declare const DynamicArray: Story;

package/dist/src/hooks/useSelection/__test__/useSelection.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/useSelection/index.d.ts

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

package/dist/src/hooks/useSelection/useSelection.d.ts

@@ -0,0 +1,50 @@
+type Return<T> = {
+    /**
+     * Indica si todos los elementos están seleccionados.
+     */
+    isAllSelected: boolean;
+    /**
+     * Indica si ningun elemento está seleccionado.
+     */
+    isNoneSelected: boolean;
+    /**
+     * Función que devuelve true si el elemento dado está seleccionado, false de lo contrario.
+     * @param item El elemento a verificar.
+     * @returns true si el elemento está seleccionado, false de lo contrario.
+     */
+    isSelected: (item: T) => boolean;
+    /**
+     * Array de elementos seleccionados.
+     */
+    selected: T[];
+    /**
+     * Establece los elementos seleccionados.
+     * @param items Los elementos seleccionados.
+     */
+    setSelected: (items: T[]) => void;
+    /**
+     * Selecciona un elemento.
+     * @param item El elemento a seleccionar.
+     */
+    select: (item: T) => void;
+    /**
+     * Deselecciona un elemento.
+     * @param item El elemento a deseleccionar.
+     */
+    unselect: (item: T) => void;
+    /**
+     * Alterna la selección de un elemento (si está seleccionado, lo deselecciona y viceversa).
+     * @param item El elemento cuya selección se alternará.
+     */
+    toggle: (item: T) => void;
+    /**
+     * Alterna la selección de todos los elementos (si todos están seleccionados, los deselecciona; de lo contrario, los selecciona).
+     */
+    toggleAll: () => void;
+    /**
+     * Deselecciona todos los elementos.
+     */
+    clear: () => void;
+};
+declare function useSelection<T>(items: T[]): Return<T>;
+export default useSelection;

package/dist/src/hooks/useStep/__doc__/useStep.stories.d.ts

@@ -0,0 +1,10 @@
+import { Meta } from '@storybook/react';
+
+/**
+ * Hook que recibe un array de elementos `T` y facita el manejo de vistas/formularios con múltiples pasos
+ */
+declare const meta: Meta;
+export default meta;
+export declare const Default: {
+    render: () => import("react/jsx-runtime").JSX.Element;
+};

package/dist/src/hooks/useStep/__test__/useStep.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/useStep/index.d.ts

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

package/dist/src/hooks/useStep/useStep.d.ts

@@ -0,0 +1,16 @@
+import { ReactNode } from 'react';
+import { ListIterateeCustom } from 'lodash';
+
+interface Return<T = ReactNode> {
+    currentStepIndex: number;
+    step: T;
+    steps: T[];
+    isFirstStep: boolean;
+    isLastStep: boolean;
+    goTo: (i: number) => void;
+    next: () => void;
+    back: () => void;
+    findAndGo: (callback: ListIterateeCustom<T, boolean>) => void;
+}
+declare function useStep<T = ReactNode>(steps: T[], amountSteps?: number): Return<T>;
+export default useStep;

package/dist/src/hooks/useToggle/__doc__/useToggle.stories.d.ts

@@ -0,0 +1,10 @@
+import { Meta } from '@storybook/react';
+
+/**
+ * Hook que facilita el manejo de un estado booleano. Provee métodos para abrir, cerrar y toggle el estado
+ */
+declare const meta: Meta;
+export default meta;
+export declare const Default: {
+    render: () => import("react/jsx-runtime").JSX.Element;
+};

package/dist/src/hooks/useToggle/__test__/useToggle.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/useToggle/index.d.ts

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

package/dist/src/hooks/useToggle/useToggle.d.ts

@@ -0,0 +1,3 @@
+type Return = [boolean, (newValue?: boolean) => void];
+declare function useToggle(initialValue?: boolean): Return;
+export default useToggle;

package/dist/src/index.d.ts

@@ -0,0 +1,6 @@
+export * from './components';
+export * from './hooks';
+export * from './lib';
+export * from './models';
+export * from './providers';
+export * from './utils';

package/dist/src/lib/cn.d.ts

@@ -0,0 +1,4 @@
+import { ClassValue } from 'clsx';
+
+export declare const twMerge: (...classLists: import('tailwind-merge').ClassNameValue[]) => string;
+export declare function cn(...args: ClassValue[]): string;

package/dist/src/lib/index.d.ts

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

package/dist/src/models/Generic.model.d.ts

@@ -0,0 +1,38 @@
+import { MutableRefObject, Dispatch, SetStateAction, HTMLProps, ReactElement, ReactNode } from 'react';
+
+export interface Option<TValue = string> {
+    label: string;
+    value: TValue;
+    disabled?: boolean;
+}
+export type ClassName = string | undefined;
+export type ClickEvent = React.MouseEvent<HTMLButtonElement, MouseEvent>;
+export type ControllableState<T> = {
+    value?: T;
+    defaultValue?: T;
+    onChange?: (state: T) => void;
+};
+export type Controllable<C, T extends NonNullable<unknown>> = OverrideProps<HTMLProps<C>, ControllableState<T>>;
+export type MaybeRef<T> = T | MutableRefObject<T>;
+export type ArrayUnion<V, T extends ReadonlyArray<V>> = T[number];
+export type ValuesUnion<T extends Record<string, any>> = T[keyof T];
+export type GenericObject<T = any> = {
+    [key: string]: T;
+};
+export type Nullable<T> = T | null;
+export type Maybe<T> = T | undefined | null;
+export type SetState<T> = Dispatch<SetStateAction<T>>;
+export type State<T> = [T, SetState<T>];
+export type ID = string | number;
+export type OverrideProps<T, TOverridden> = Omit<T, keyof TOverridden> & TOverridden;
+export type SafeOmit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+export type AtLeastOne<T> = [T, ...T[]];
+export type Loose<T> = T | (string & {});
+export type Renderable<T> = ReactNode | ((props: T) => ReactElement);
+export type BaseEntity = {
+    id: string;
+    createdAt: Date;
+};
+export type Entity<T> = {
+    [K in keyof T]: T[K];
+} & BaseEntity;

package/dist/src/models/index.d.ts

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

package/dist/src/providers/index.d.ts

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

package/dist/src/providers/theme/ThemeProvider.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from 'react';
+import { Theme } from './types';
+
+export declare const useTheme: () => {
+    theme: Theme;
+};
+type ThemeProviderProps = {
+    children: ReactNode;
+    theme?: Theme;
+};
+export declare const ThemeProvider: ({ children, theme, }: ThemeProviderProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/providers/theme/index.d.ts

@@ -0,0 +1,3 @@
+export * from './ThemeProvider';
+export * from './types';
+export * from './useThemeProps';

package/dist/src/providers/theme/types.d.ts

@@ -0,0 +1,15 @@
+import { Input } from '../../components/input/Input';
+import { Popover } from '../../components/popover/Popover';
+import { Tooltip } from '../../components/tooltip/Tooltip';
+import { ComponentProps } from 'react';
+import { Button } from '../../components/button/Button';
+
+type ThemeProps<T, TOverridden> = Partial<Omit<T, keyof TOverridden>>;
+type PropsWithoutValue<T> = Omit<T, "value" | "onChange" | "defaultValue">;
+export type Theme = {
+    Button?: ThemeProps<ComponentProps<typeof Button>, "asChild" | "loading">;
+    Input?: Partial<PropsWithoutValue<ComponentProps<typeof Input>>>;
+    Tooltip?: ThemeProps<ComponentProps<typeof Tooltip>, "label" | "open" | "defaultOpen" | "onOpenChange">;
+    Popover?: ThemeProps<ComponentProps<typeof Popover>, "open" | "defaultOpen" | "onOpenChange" | "trigger">;
+};
+export {};

package/dist/src/providers/theme/useThemeProps.d.ts

@@ -0,0 +1,11 @@
+import { Theme } from './types';
+
+/**
+ * Hook que permite obtener y combinar las propiedades de un componente con las del tema.
+ *
+ * El orden de prioridad de las propiedades es:
+ * 1. Props pasadas directamente al componente
+ * 2. Props definidas en el ThemeProvider
+ * 3. Props por defecto del componente
+ */
+export declare const useThemeProps: <TComponent extends keyof Theme, TProps>(componentName: TComponent, props: TProps, defaultProps?: Partial<TProps>) => TProps;

package/dist/src/stores/theme.store.d.ts

@@ -0,0 +1,11 @@
+import { Theme } from '../providers/theme/types';
+import { StoreApi } from 'zustand';
+
+interface ThemeStore {
+    theme: Theme;
+    setTheme: (theme: Theme) => void;
+    getComponentProps: <TComponent extends keyof Theme, TProps>(componentName: TComponent, props: TProps, defaultProps?: Partial<TProps>) => TProps;
+}
+export type ThemeStoreApi = StoreApi<ThemeStore>;
+declare const createThemeStore: (initTheme?: Theme) => StoreApi<ThemeStore>;
+export { createThemeStore };

package/dist/src/utils/dates/parseDateRange.utility.d.ts

@@ -0,0 +1,15 @@
+import { DateRange } from '../../components';
+
+/**
+ * @typedef {Object} DateRange
+ * @property {Date} start - The start date of the range.
+ * @property {Date} end - The end date of the range.
+ */
+/**
+ * Parses a date range string in the format "DD/MM/YYYY - DD/MM/YYYY" and returns an object with start and end dates.
+ *
+ * @param {string} dateRange - The date range string to parse.
+ * @returns {DateRange} An object containing the start and end dates.
+ * @throws Will throw an error if the input string is not in the expected format or the dates are invalid.
+ */
+export declare const parseDateRange: (dateRange: string) => DateRange;

package/dist/src/utils/functions/createSafeContext.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+
+export declare const createSafeContext: <T>() => readonly [() => T & ({} | undefined), React.Provider<T | null>];

package/dist/src/utils/functions/ensureReactElement.d.ts

@@ -0,0 +1,10 @@
+import { Renderable } from '../../models';
+import { default as React, ReactElement } from 'react';
+
+type EnsureReactElementProps<P = {}> = {
+    children: Renderable<P>;
+    as?: React.ElementType;
+    props?: P;
+};
+export declare const ensureReactElement: <P>({ children, as: Wrapper, props, }: EnsureReactElementProps<P>) => ReactElement;
+export {};

package/dist/src/utils/functions/getFormData.d.ts

@@ -0,0 +1,3 @@
+import { FormEvent } from 'react';
+
+export declare const getFormData: (event: FormEvent<HTMLFormElement>) => Record<string, string>;

package/dist/src/utils/functions/index.d.ts

@@ -0,0 +1,4 @@
+export * from './mergeRefs';
+export * from './ensureReactElement';
+export * from './createSafeContext';
+export * from './getFormData';

package/dist/src/utils/functions/mergeRefs.d.ts

@@ -0,0 +1,2 @@
+import type * as React from "react";
+export declare function mergeRefs<T = any>(refs: Array<React.MutableRefObject<T> | React.LegacyRef<T> | undefined | null>): React.RefCallback<T>;

package/dist/src/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './strings';
+export * from './functions';
+export * from './tests';

package/dist/src/utils/strings/extractInitials.utility.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Extracts the initials from a string.
+ * @param {string} string - The input string.
+ * @returns {string} The initials extracted from the input string.
+ */
+export declare const extractInitials: (string: string) => string;

package/dist/src/utils/strings/index.d.ts

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

package/dist/src/utils/tests/click.d.ts

@@ -0,0 +1 @@
+export declare const click: (element: HTMLElement) => void;

package/dist/src/utils/tests/index.d.ts

@@ -0,0 +1,2 @@
+export * from './click';
+export * from './type';