@m4l/components 0.2.35 → 0.2.36

package/components/DynamicFilter/index.d.ts

@@ -1,4 +1,3 @@
 export * from './DynamicFilter';
 export { getDynamicFilterComponentsDictionary } from './dictionary';
-export type { FilterFieldApplyed as FilterFieldApply, RawFilterFieldApply, InitialFilterApplyed, Field, } from './types';
-export type { DynamicFilterClassesKey } from './classes/types';
+export type { FilterFieldApplied as FilterFieldApply, RawFilterFieldApply, InitialFilterApplied, Field, } from './types';

package/components/DynamicFilter/store/DynamicFilterContext.d.ts

@@ -0,0 +1,16 @@
+import { type ReactNode } from 'react';
+import { DynamicFilterProps } from '../types';
+declare const DynamicFilterContext: import("react").Context<(Omit<Omit<import("zustand").StoreApi<import("./DynamicFilterStore").DynamicFilterStateWithActions>, "setState"> & {
+    setState<A extends string | {
+        type: unknown;
+    }>(partial: import("./DynamicFilterStore").DynamicFilterStateWithActions | Partial<import("./DynamicFilterStore").DynamicFilterStateWithActions> | ((state: import("./DynamicFilterStore").DynamicFilterStateWithActions) => import("./DynamicFilterStore").DynamicFilterStateWithActions | Partial<import("./DynamicFilterStore").DynamicFilterStateWithActions>), replace?: boolean | undefined, action?: A | undefined): void;
+}, "setState"> & {
+    setState(nextStateOrUpdater: import("./DynamicFilterStore").DynamicFilterStateWithActions | Partial<import("./DynamicFilterStore").DynamicFilterStateWithActions> | ((state: import("immer/dist/internal").WritableDraft<import("./DynamicFilterStore").DynamicFilterStateWithActions>) => void), shouldReplace?: boolean | undefined, action?: string | {
+        type: unknown;
+    } | undefined): void;
+}) | null>;
+interface DynamicFilterContextProps extends DynamicFilterProps {
+    children: ReactNode;
+}
+declare function DynamicFilterProvider(props: DynamicFilterContextProps): import("react/jsx-runtime").JSX.Element;
+export { DynamicFilterProvider, DynamicFilterContext };

package/components/DynamicFilter/{contexts/DynamicFilterContext/store.d.ts → store/DynamicFilterStore.d.ts}

@@ -1,79 +1,46 @@
-import { GetLabelType } from '@m4l/core';
-import { Field, FilterFieldApplyed, FilterToEditApply, InitialFilterApplyed } from '../../types';
-import { Classes } from '../../classes';
-import { WritableDraft } from 'immer/dist/internal';
+import type { WritableDraft } from 'immer/dist/internal';
+import type { GetLabelType } from '@m4l/core';
+import type { Field, FilterFieldApplied, FilterToEditApply, InitialFilterApplied, OwnerState } from '../types';
 export declare type OpenFor = 'add' | 'edit';
 export interface PopoverFilterDataBase {
     /**
-     *  "openFor" motivo de apertura del popup
+     *  Motivo de apertura del popup
      */
     openFor: OpenFor;
     /**
-     *  "fnAnchorEl" Anchor para ubicar el popup y se pone como función debido a que Immer no soporta un draft de Element
+     * Anchor para ubicar el popup
      */
     fnAnchorEl: () => Element;
 }
 export interface PopoverFilterDataAdd extends PopoverFilterDataBase {
     openFor: 'add';
     /**
-     *  "field" Campo por el cual se va a filtrar
+     * Campo por el cual se va a filtrar
      */
     field: Field;
 }
 export interface PopoverFilterDataEdit extends PopoverFilterDataBase {
     openFor: 'edit';
     /**
-     *  "filter" filtro que se va a editar
+     *  Filtro que se va a editar
      */
-    filter: FilterFieldApplyed;
+    filter: FilterFieldApplied;
     field: Field;
 }
 /**
- *
- * @description Tipo usado para cuado se va agregar o modificar un filtro
+ * Tipo usado para cuado se va agregar o modificar un filtro
  */
 export declare type PopoverFilterData = PopoverFilterDataAdd | PopoverFilterDataEdit;
 /**
- * @interface
- * @name OwnerState
- * @description Interface que define la variables que se van a usar en clases del componente
- */
-export declare type OwnerState = {
-    /**
-     *  "isSkeleton" indica si el componente está en skeleton.
-     */
-    isSkeleton: boolean;
-    /**
-     *  "inEdition" se establece cuando se está en edición.
-     */
-    inEdition: boolean;
-    /**
-     *  "isDirty" cuando el comnponente tiene filtros por aplicar
-     */
-    isDirty: boolean;
-    /**
-     *  "isValid" cuando el comnponente está en un estado invalido
-     */
-    isValid: boolean;
-    /**
-     *  "isMobile" cuando el navegador está en modo celular
-     */
-    isMobile: boolean;
-    /**
-     *  "isEmpty" Define si existen filtros aplicados
-     */
-    isEmpty: boolean;
-};
-/**
+ * Estados que se actulizan por fuera del store, a través de hooks
+ *
  * @type
- * @name ExternalOwnerState
- * @description Estados que se actulizan por fuera del store, a través de hooks
  */
 export declare type ExternalOwnerState = Pick<OwnerState, 'isMobile' | 'isSkeleton'>;
 /**
- * @interface DynamicFilterState
- * @name DynamicFilterState
- * @description Interface que define el estado del componente
+ * Interface que define el estado del componente
+ *
+ * @interface
  */
 export interface DynamicFilterState {
     /**
@@ -113,15 +80,16 @@ export interface DynamicFilterState {
     /**
      *  "applyedFilters" Filtros aplicados actualmente
      */
-    applyedFilters: Array<FilterFieldApplyed>;
+    appliedFilters: Array<FilterFieldApplied>;
     /**
-     *  "countOnChangeFiltersApplyed" Cantid de veces que el filtro se ha aplicado, sirve para suscribirse y aplicar el filtro.
+     *  "countOnChangeFiltersApplyed" Cantidad de veces que el filtro se ha aplicado, sirve para suscribirse y aplicar el filtro.
      *  Esto se debe hacer porque no se puede lanzar un handler que modifica valores, durante una renderización.
      */
-    countOnChangeFiltersApplyed: number;
-    /** popoverFilterData: para emerger el popuup de modificación campos  */
+    countOnChangeFiltersApplied: number;
+    /**
+     * :popoverFilterData" para emerger el popuup de modificación campos
+     */
     popoverFilterData?: PopoverFilterData;
-    classes: Classes;
     getLabel: GetLabelType;
     /**
      *  dataTestId:
@@ -133,11 +101,11 @@ export interface DynamicFilterStateWithActions extends DynamicFilterState {
     actions: {
         /**
          * @description inicializa el estado del componente con los filtros que provienen desde afuera
-         * @param initialFiltersApplyed Filtros iniciales
+         * @param initialFiltersApplied Filtros iniciales
          */
-        init: (initialFiltersApplyed: Array<InitialFilterApplyed>) => void;
+        init: (initialFiltersApplied: Array<InitialFilterApplied>) => void;
         /**
-         * @description Objetiene el Campo dado el nombre
+         * @description Obtiene el Campo dado el nombre
          * @param name
          * @returns Field o undefined si no se encuentra
          */
@@ -160,7 +128,7 @@ export interface DynamicFilterStateWithActions extends DynamicFilterState {
          * @param filterToEdit Filtro a editar
          * @returns
          */
-        showPopoverFilterForEdit: (anchorEl: Element, filterToEdit: FilterFieldApplyed) => void;
+        showPopoverFilterForEdit: (anchorEl: Element, filterToEdit: FilterFieldApplied) => void;
         /**
          * @description Oculta la ventana de edición
          * @param stayInEdition determina si continua en edicióin
@@ -184,7 +152,7 @@ export interface DynamicFilterStateWithActions extends DynamicFilterState {
          * @param newFilter Filtro a agregar
          * @returns
          */
-        addFilter: (newFilter: FilterFieldApplyed) => void;
+        addFilter: (newFilter: FilterFieldApplied) => void;
         /**
          * @description Modifica un filtro que se encuentra en applyedFilters
          * @param filterToEdit filtro a editar
@@ -223,9 +191,9 @@ export interface DynamicFilterStateWithActions extends DynamicFilterState {
 }
 declare type InitialStoreProps = Pick<DynamicFilterState, 'automatic' | 'fields' | 'withAllField' | 'getLabel' | 'allField' | 'ownerState' | 'dataTestId'>;
 /**
- * @description  Crea el store de zustand para el componente DynamicFilter
- * @param initProps Variables iniciales que necesita store para poder inicializarlo
- * @returns
+ * Crea el store de zustand para el componente DynamicFilter
+ *
+ * @param initProps Variables iniciales que necesita store
  */
 export declare const createAreaStore: (initProps: InitialStoreProps) => Omit<Omit<import("zustand").StoreApi<DynamicFilterStateWithActions>, "setState"> & {
     setState<A extends string | {

package/components/DynamicFilter/store/useDynamicFilterStore.d.ts

@@ -0,0 +1,2 @@
+import { DynamicFilterStateWithActions } from './DynamicFilterStore';
+export declare function useDynamicFilterStore<T>(selector: (state: DynamicFilterStateWithActions) => T, equalityFn?: (left: T, right: T) => boolean): T;

package/components/DynamicFilter/subcomponents/AppliedFilterChip/AppliedFilterChip.d.ts

@@ -0,0 +1,3 @@
+import type { FilterFieldApplied } from '../../types';
+declare function AppliedFilterChip(props: FilterFieldApplied): import("react/jsx-runtime").JSX.Element;
+export default AppliedFilterChip;

package/components/DynamicFilter/subcomponents/AppliedFilterChip/index.d.ts

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

package/components/DynamicFilter/subcomponents/AppliedFilterChip/useAppliedFilterChip.d.ts

@@ -0,0 +1,10 @@
+import { type MouseEvent } from 'react';
+import type { FilterFieldApplied } from '../../types';
+declare function useAppliedFilterChip(filter: FilterFieldApplied): {
+    onDelete: () => void;
+    onEditFilter: (event: MouseEvent<HTMLButtonElement>) => void;
+    removeIconUrl: string;
+    iconFieldUrl: string;
+    labels: import("../../types").DataTypeFilerLabels;
+};
+export default useAppliedFilterChip;

package/components/DynamicFilter/subcomponents/AppliedFilters/AppliedFilters.d.ts

@@ -0,0 +1,2 @@
+declare function AppliedFilters(): import("react/jsx-runtime").JSX.Element;
+export default AppliedFilters;

package/components/DynamicFilter/subcomponents/AppliedFilters/index.d.ts

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

package/components/DynamicFilter/subcomponents/AppliedFilters/useAppliedFilters.d.ts

@@ -0,0 +1,5 @@
+declare function useAppliedFilters(): {
+    appliedFiltersSorted: import("../..").FilterFieldApply<import("../../types").FieldType>[];
+    isSkeleton: boolean;
+};
+export default useAppliedFilters;

package/components/DynamicFilter/subcomponents/DynamicFilterBase/DynamicFilterBase.d.ts

@@ -0,0 +1,2 @@
+declare function DynamicFilterBase(): import("react/jsx-runtime").JSX.Element;
+export default DynamicFilterBase;

package/components/DynamicFilter/subcomponents/DynamicFilterBase/index.d.ts

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

package/components/DynamicFilter/subcomponents/DynamicFilterBase/useDynamicFilterBase.d.ts

@@ -0,0 +1,4 @@
+export default function useDynamicFilterBase(): {
+    ownerState: import("../../types").OwnerState;
+    dataTestId: string;
+};

package/components/DynamicFilter/subcomponents/FieldTypes/BooleanFilter/helpers.d.ts

@@ -0,0 +1,14 @@
+import { GetLabelType } from '@m4l/core';
+import { Formatters } from '@m4l/graphics';
+import type { IFieldType, YupSchema } from '../FieldTypeInterface';
+import type { DataTypeFilerLabels, Field, FilterFieldApplied, FilterValue, FormFilterValueBoolean, InitialFilterApplied } from '../../../types';
+import { BooleanFilter } from './index';
+export declare class BooleanFilterHelpers implements IFieldType<FormFilterValueBoolean> {
+    getComponent(): typeof BooleanFilter;
+    getDefaultFilter(field: Field, fixed: boolean): FilterFieldApplied;
+    getFilterFromFormValue(formFilterValue: FormFilterValueBoolean): FilterValue;
+    getFormValue(field: Field, getLabel: GetLabelType, filterValue?: FilterValue): FormFilterValueBoolean;
+    getLabels(filter: FilterFieldApplied, getLabel: GetLabelType, _formatters: Formatters, _field: Field): DataTypeFilerLabels;
+    getSchema(getLabel: GetLabelType): YupSchema;
+    verifyFilter(filter: InitialFilterApplied, _field?: Field): boolean;
+}

package/components/DynamicFilter/subcomponents/FieldTypes/BooleanFilter/index.d.ts

@@ -0,0 +1 @@
+export declare function BooleanFilter(): import("react/jsx-runtime").JSX.Element;

package/components/DynamicFilter/subcomponents/FieldTypes/DataTypeComponent.d.ts

@@ -0,0 +1,7 @@
+import type { FormFilterFieldApplied } from '../../types';
+import { FormStatusLoad } from '../../../../contexts';
+declare function DataTypeComponent(props: {
+    formFilter: FormFilterFieldApplied;
+    statusLoad: FormStatusLoad;
+}): import("react/jsx-runtime").JSX.Element;
+export default DataTypeComponent;

package/components/DynamicFilter/subcomponents/FieldTypes/DateTimeFilter/helpers.d.ts

@@ -0,0 +1,14 @@
+import { GetLabelType } from '@m4l/core';
+import { Formatters } from '@m4l/graphics';
+import type { IFieldType, YupSchema } from '../FieldTypeInterface';
+import type { DataTypeFilerLabels, Field, FilterFieldApplied, FilterValue, FormFilterValueDateTime, InitialFilterApplied } from '../../../types';
+import { DateTimeFilter } from './index';
+export declare class DateTimeFilterHelpers implements IFieldType<FormFilterValueDateTime> {
+    getComponent(): typeof DateTimeFilter;
+    getDefaultFilter(field: Field, fixed: boolean): FilterFieldApplied;
+    getFormValue(field: Field, getLabel: GetLabelType, filterValueDateTime?: FilterValue): FormFilterValueDateTime;
+    getFilterFromFormValue(formFilterValue: FormFilterValueDateTime): FilterValue;
+    getLabels(filter: FilterFieldApplied, getLabel: GetLabelType, formatters: Formatters, _field: Field): DataTypeFilerLabels;
+    getSchema(getLabel: GetLabelType): YupSchema;
+    verifyFilter(filter: InitialFilterApplied, _field?: Field): boolean;
+}

package/components/DynamicFilter/subcomponents/FieldTypes/FieldTypeInterface.d.ts

@@ -0,0 +1,21 @@
+import { FC } from 'react';
+import * as Yup from 'yup';
+import { GetLabelType } from '@m4l/core';
+import { Formatters } from '@m4l/graphics';
+import type { Field, FilterFieldApplied, DataTypeFilerLabels, FilterValue, InitialFilterApplied } from '../../types';
+export declare type YupSchema = Yup.SchemaOf<any>;
+/**
+ * Interface para crear los helpers de cada tipo de campo
+ * @typeparam T FormFilterValue{Type} de cada tipo de campo
+ */
+export interface IFieldType<T> {
+    getComponent(): FC<{
+        [key: string]: any;
+    }>;
+    getDefaultFilter(field: Field, fixed: boolean): FilterFieldApplied;
+    getLabels(filter: FilterFieldApplied, getLabel: GetLabelType, formatters: Formatters, field: Field): DataTypeFilerLabels;
+    getSchema(getLabel: GetLabelType): YupSchema;
+    getFormValue(field: Field, getLabel: GetLabelType, filterValue?: FilterValue): T;
+    getFilterFromFormValue(formFilterValue: T): FilterValue;
+    verifyFilter(filter: InitialFilterApplied, field?: Field): boolean;
+}

package/components/DynamicFilter/subcomponents/FieldTypes/NumberFilter/helpers.d.ts

@@ -0,0 +1,14 @@
+import { GetLabelType } from '@m4l/core';
+import { Formatters } from '@m4l/graphics';
+import type { IFieldType, YupSchema } from '../FieldTypeInterface';
+import type { DataTypeFilerLabels, Field, FilterFieldApplied, FilterValue, FormFilterValueNumber, InitialFilterApplied } from '../../../types';
+import { NumberFilter } from './index';
+export declare class NumberFilterHelpers implements IFieldType<FormFilterValueNumber> {
+    getComponent(): typeof NumberFilter;
+    getDefaultFilter(fieldNumber: Field, fixed: boolean): FilterFieldApplied;
+    getFormValue(field: Field, getLabel: GetLabelType, filterValue?: FilterValue): FormFilterValueNumber;
+    getFilterFromFormValue(formFilterValue: FormFilterValueNumber): FilterValue;
+    getLabels(filter: FilterFieldApplied, getLabel: GetLabelType, _formatters: Formatters, _field: Field): DataTypeFilerLabels;
+    getSchema(getLabel: GetLabelType): YupSchema;
+    verifyFilter(filter: InitialFilterApplied, _field?: Field): boolean;
+}

package/components/DynamicFilter/subcomponents/FieldTypes/SelectFilter/helpers.d.ts

@@ -0,0 +1,21 @@
+import { GetLabelType } from '@m4l/core';
+import { Formatters } from '@m4l/graphics';
+import type { IFieldType, YupSchema } from '../FieldTypeInterface';
+import type { DataTypeFilerLabels, Field, FilterFieldApplied, FilterValue, InitialFilterApplied, FormFilterValueSelect, FormOperandSelect } from '../../../types';
+import { SelectFilter } from './index';
+/**
+ * @description Filtra los valores de operandArray para que solo tengan valores validos
+ * @param operandsArray valores del OperandsArray
+ * @param field Propiedades del field
+ * @returns FormOperandSelect[] operandArray filtrado con valores validados
+ */
+export declare function filterValidOperandsArraySelect(operandsArray: FormOperandSelect[] | FormOperandSelect, field: Field): FormOperandSelect[];
+export declare class SelectFilterHelpers implements IFieldType<FormFilterValueSelect> {
+    getComponent(): typeof SelectFilter;
+    getDefaultFilter(field: Field, fixed: boolean): FilterFieldApplied;
+    getFormValue(field: Field, getLabel: GetLabelType, filterValueSelect?: FilterValue): FormFilterValueSelect;
+    getFilterFromFormValue(formFilterValue: FormFilterValueSelect): FilterValue;
+    getLabels(filter: FilterFieldApplied, getLabel: GetLabelType, _formatters: Formatters, field: Field): DataTypeFilerLabels;
+    getSchema(getLabel: GetLabelType): YupSchema;
+    verifyFilter(filter: InitialFilterApplied, field?: Field): boolean;
+}

package/components/DynamicFilter/subcomponents/FieldTypes/StringFilter/helpers.d.ts

@@ -0,0 +1,14 @@
+import { GetLabelType } from '@m4l/core';
+import { Formatters } from '@m4l/graphics';
+import type { IFieldType, YupSchema } from '../FieldTypeInterface';
+import type { FilterFieldApplied, FormFilterValueString, Field, DataTypeFilerLabels, FilterValue, InitialFilterApplied } from '../../../types';
+import { StringFilter } from './index';
+export declare class StringFilterHelpers implements IFieldType<FormFilterValueString> {
+    getComponent(): typeof StringFilter;
+    getDefaultFilter(field: Field, fixed: boolean): FilterFieldApplied;
+    getFilterFromFormValue(formFilterValue: FormFilterValueString): FilterValue;
+    getFormValue(field: Field, getLabel: GetLabelType, filterValue?: FilterValue): FormFilterValueString;
+    getLabels(filter: FilterFieldApplied, getLabel: GetLabelType, _formatters: Formatters, _field: Field): DataTypeFilerLabels;
+    getSchema(getLabel: GetLabelType): YupSchema;
+    verifyFilter(filter: InitialFilterApplied, _field?: Field): boolean;
+}

package/components/DynamicFilter/subcomponents/FieldTypes/fieldFactory.d.ts

@@ -0,0 +1,7 @@
+import type { FieldType } from '../../types';
+import { BooleanFilterHelpers } from './BooleanFilter/helpers';
+import { StringFilterHelpers } from './StringFilter/helpers';
+import { DateTimeFilterHelpers } from './DateTimeFilter/helpers';
+import { NumberFilterHelpers } from './NumberFilter/helpers';
+import { SelectFilterHelpers } from './SelectFilter/helpers';
+export declare function fieldFactory(type: FieldType): BooleanFilterHelpers | StringFilterHelpers | NumberFilterHelpers | DateTimeFilterHelpers | SelectFilterHelpers;

package/components/DynamicFilter/subcomponents/FilterActions/FilterActions.d.ts

@@ -0,0 +1,2 @@
+declare function FilterActions(): import("react/jsx-runtime").JSX.Element;
+export default FilterActions;

package/components/DynamicFilter/subcomponents/FilterActions/FilterActionsSkeleton.d.ts

@@ -0,0 +1,2 @@
+declare function FilterActionsSkeleton(): import("react/jsx-runtime").JSX.Element;
+export default FilterActionsSkeleton;

package/components/DynamicFilter/subcomponents/FilterActions/index.d.ts

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

package/components/DynamicFilter/subcomponents/FilterActions/useFilterActions.d.ts

@@ -0,0 +1,18 @@
+export declare const ASSETS_URL = "frontend/components/dynamic_filter/assets/icons";
+export declare const ASSETS: {
+    readonly refresh: "restart.svg";
+    readonly search: "search.svg";
+};
+declare function useFilterActions(): {
+    isSkeleton: boolean;
+    filterIconUrl: string;
+    clearIconUrl: string;
+    canShowRemoveAction: boolean;
+    onClickClearFilters: () => void;
+    onClickFilter: VoidFunction;
+    filterButtonDictionaryTooltip: string;
+    ownerState: {
+        isValid: boolean;
+    };
+};
+export default useFilterActions;

package/components/DynamicFilter/subcomponents/InputFilter/InputFilter.d.ts

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

package/components/DynamicFilter/subcomponents/InputFilter/InputFilterSkeleton.d.ts

@@ -0,0 +1,2 @@
+declare function InputFilterSkeleton(): import("react/jsx-runtime").JSX.Element;
+export default InputFilterSkeleton;

package/components/DynamicFilter/subcomponents/InputFilter/index.d.ts

@@ -1,7 +1 @@
-/**
- * @description Subcomponente encargado de cargar los campos que pueden ser filtrados
- *              Si el componente permite filtrar por todos los campos, al digita algun texto y luego se presiona anter, se aplica un filtro ALL_FIELD
- *              Permite mover la seleccion de campo en el popup a traves del KeyDown, KeyPress, Escape y si está seleccionado un item con Enter se abre el Popover de Menú de campos
- * @returns
- */
-export declare function InputFilter(): import("react/jsx-runtime").JSX.Element | null;
+export { default } from './InputFilter';

package/components/DynamicFilter/subcomponents/InputFilter/useInputFilter.d.ts

@@ -0,0 +1,40 @@
+import { type ChangeEvent, type FocusEvent, type KeyboardEvent } from 'react';
+declare function useInputFilter(): {
+    /**
+     * URL del icono del inputFilter
+     */
+    iconUrl: string;
+    /**
+     * Si es esqueleto mostrar la versión de esqueleton
+     */
+    isSkeleton: boolean;
+    /**
+     * Texto de placeholder del inputFilter
+     */
+    inputPlaceHolder: string;
+    /**
+     * Texto del inputFilter
+     */
+    inputData: string;
+    /**
+     * Props para el handler de eventos del inputFilter
+     */
+    inputHandlersProps: {
+        onFocus: (event: FocusEvent<HTMLInputElement>) => void;
+        onChange: (event: ChangeEvent<HTMLInputElement>) => void;
+        onKeyDown: (event: KeyboardEvent<HTMLInputElement>) => void;
+    };
+    /**
+     * Si no hay campos disponibles y no se permite filtrar por todos, no se renderiza el inputFilter
+     */
+    canRender: boolean;
+    /**
+     * Campos filtrados por el inputFilter
+     */
+    filteredFields: (import("../../types").FieldDictionaryId<"string"> | import("../../types").FieldLabel<"string"> | import("../../types").FieldDictionaryId<"number"> | import("../../types").FieldLabel<"number"> | import("../../types").FieldDictionaryId<"boolean"> | import("../../types").FieldLabel<"boolean"> | (import("../../types").FieldWithSelect<"select"> & (import("../../types").FieldDictionaryId<"select"> | import("../../types").FieldLabel<"select">)) | import("../../types").FieldDictionaryId<"datetime"> | import("../../types").FieldLabel<"datetime">)[];
+    /**
+     * Indice del campo seleccionado
+     */
+    selectedFieldIndex: number;
+};
+export default useInputFilter;

package/components/DynamicFilter/subcomponents/PopoverFilter/PopoverFilter.d.ts

@@ -0,0 +1,2 @@
+declare function PopoverFilter(): import("react/jsx-runtime").JSX.Element | null;
+export default PopoverFilter;

package/components/DynamicFilter/subcomponents/PopoverFilter/index.d.ts

@@ -1,14 +1 @@
-/**
- * @description
- * Subcomponente encargado de permitir agregar o modificar un filtro.
- * El mencanismo para saber si se muestra o no este subcomponente,  es si está o no establecida la variable de estado "popoverFilterData"
- *      popoverFilterData
- *          anchorEl: Funcion que retorna el anchorEl desde donde emerge la ventana
- *          openFor:  'Add' si es un para un nuevo filtro, 'Edit' si para editar un filtro actualmente aplicado
- *
- * Consideraciones:
- *      Internamente se muestra el subcomponente DataTypeComponent, que dependiendo del tipo de dato del Field muestra un subcomponente diferente.
- *      Este componente se puede cargar desde: El PopoverMenuFields (openFor: Add),  o cuando se presiona click en un filtro aplicado (openFor: Edit)
- * @returns JSX
- */
-export declare const PopoverFilter: () => import("react/jsx-runtime").JSX.Element | null;
+export { default } from './PopoverFilter';

package/components/DynamicFilter/subcomponents/PopoverFilter/usePopoverFilter.d.ts

@@ -0,0 +1,24 @@
+import { KeyboardEvent } from 'react';
+import { FieldValues } from 'react-hook-form';
+import type { FormFilterFieldApplied, FormFilterValue } from '../../types';
+declare function usePopoverFilter(): {
+    field: import("../../types").FieldDictionaryId<"string"> | import("../../types").FieldLabel<"string"> | import("../../types").FieldDictionaryId<"number"> | import("../../types").FieldLabel<"number"> | import("../../types").FieldDictionaryId<"boolean"> | import("../../types").FieldLabel<"boolean"> | (import("../../types").FieldWithSelect<"select"> & (import("../../types").FieldDictionaryId<"select"> | import("../../types").FieldLabel<"select">)) | import("../../types").FieldDictionaryId<"datetime"> | import("../../types").FieldLabel<"datetime">;
+    labelField: string;
+    canRender: boolean;
+    anchorEl: Element;
+    handleKeyDownPopper: (event: KeyboardEvent<HTMLDivElement>) => void;
+    handleClosePopover: () => void;
+    onSubmit: (dataFieldValues: FieldValues) => Promise<void>;
+    onClose: () => void;
+    filterFormValue: FormFilterValue;
+    formFilter: FormFilterFieldApplied<import("../../types").FieldType>;
+    popupValidationSchema: import("yup").ArraySchema<import("yup").BaseSchema<unknown, import("yup/lib/object").AnyObject, unknown> | import("yup/lib/Lazy").default<import("yup").BaseSchema<unknown, import("yup/lib/object").AnyObject, unknown>, import("yup/lib/object").AnyObject>, import("yup/lib/types").AnyObject, unknown[] | undefined, unknown[] | undefined> | import("yup").BaseSchema<any, import("yup/lib/object").AnyObject, any> | import("yup").ObjectSchema<{
+        [x: string]: import("yup").ObjectSchema<any, import("yup/lib/object").AnyObject, import("yup/lib/object").TypeOfShape<any>, import("yup/lib/object").AssertsShape<any>> | import("yup").BaseSchema<any, import("yup/lib/object").AnyObject, any> | import("yup").ArraySchema<import("yup").BaseSchema<unknown, import("yup/lib/object").AnyObject, unknown> | import("yup/lib/Lazy").default<import("yup").BaseSchema<unknown, import("yup/lib/object").AnyObject, unknown>, import("yup/lib/object").AnyObject>, import("yup/lib/types").AnyObject, unknown[] | undefined, unknown[] | undefined> | import("yup/lib/Lazy").default<import("yup").ObjectSchema<any, import("yup/lib/object").AnyObject, import("yup/lib/object").TypeOfShape<any>, import("yup/lib/object").AssertsShape<any>>, any>;
+    }, import("yup/lib/object").AnyObject, import("yup/lib/object").TypeOfShape<{
+        [x: string]: import("yup").ObjectSchema<any, import("yup/lib/object").AnyObject, import("yup/lib/object").TypeOfShape<any>, import("yup/lib/object").AssertsShape<any>> | import("yup").BaseSchema<any, import("yup/lib/object").AnyObject, any> | import("yup").ArraySchema<import("yup").BaseSchema<unknown, import("yup/lib/object").AnyObject, unknown> | import("yup/lib/Lazy").default<import("yup").BaseSchema<unknown, import("yup/lib/object").AnyObject, unknown>, import("yup/lib/object").AnyObject>, import("yup/lib/types").AnyObject, unknown[] | undefined, unknown[] | undefined> | import("yup/lib/Lazy").default<import("yup").ObjectSchema<any, import("yup/lib/object").AnyObject, import("yup/lib/object").TypeOfShape<any>, import("yup/lib/object").AssertsShape<any>>, any>;
+    }>, import("yup/lib/object").AssertsShape<{
+        [x: string]: import("yup").ObjectSchema<any, import("yup/lib/object").AnyObject, import("yup/lib/object").TypeOfShape<any>, import("yup/lib/object").AssertsShape<any>> | import("yup").BaseSchema<any, import("yup/lib/object").AnyObject, any> | import("yup").ArraySchema<import("yup").BaseSchema<unknown, import("yup/lib/object").AnyObject, unknown> | import("yup/lib/Lazy").default<import("yup").BaseSchema<unknown, import("yup/lib/object").AnyObject, unknown>, import("yup/lib/object").AnyObject>, import("yup/lib/types").AnyObject, unknown[] | undefined, unknown[] | undefined> | import("yup/lib/Lazy").default<import("yup").ObjectSchema<any, import("yup/lib/object").AnyObject, import("yup/lib/object").TypeOfShape<any>, import("yup/lib/object").AssertsShape<any>>, any>;
+    }>> | undefined;
+    statusLoad: "initial" | "reload_values_provider" | "ready";
+};
+export default usePopoverFilter;

package/components/DynamicFilter/subcomponents/PopoverMenuFields/PopoverMenuFields.d.ts

@@ -0,0 +1,7 @@
+import type { Field } from '../../types';
+export declare type PopoverMenuFieldsProps = {
+    selectFieldIndex: number;
+    fields: Field[];
+};
+declare function PopoverMenuFields(props: PopoverMenuFieldsProps): import("react/jsx-runtime").JSX.Element;
+export default PopoverMenuFields;

package/components/DynamicFilter/subcomponents/PopoverMenuFields/index.d.ts

@@ -1,11 +1 @@
-import { PopoverMenuFieldsProps } from './types';
-/**
- * @description Subcomponente encargado de mostrar los campos disponibles don el esuario selecciona uno en especifico
- *              y lanza el subcomponente PopoverFilter
- *              Su visualización depende del anchorEl, que se activa cuando se digita en subcomponente InputFilter
- * @param props
- *              selectFieldIndex: Indice del menu seleccionado, -1 si no lo está
- *              fields: Field[]:  Listado de campos disponibles
- * @returns
- */
-export declare function PopoverMenuFields(props: PopoverMenuFieldsProps): import("react/jsx-runtime").JSX.Element;
+export { default } from './PopoverMenuFields';

package/components/DynamicFilter/subcomponents/PopoverMenuFields/usePopoverMenuFields.d.ts

@@ -0,0 +1,9 @@
+import type { MouseEvent } from 'react';
+import type { Field } from '../../types';
+declare function usePopoverMenuFields(): {
+    fnAnchorEl: (() => Element) | undefined;
+    getItemLabel: (field: Field) => string;
+    handleClosePopover: () => void;
+    handleOpenPopUpClickItem: (_event: MouseEvent<HTMLLIElement>, field: Field) => void;
+};
+export default usePopoverMenuFields;