@m4l/components 9.1.124 → 9.1.126

package/components/DynamicFilter/store/DynamicFilterStore.js

@@ -2,6 +2,7 @@ import { createStore } from "zustand";
 import { devtools } from "zustand/middleware";
 import { immer } from "zustand/middleware/immer";
 import { g as getPurgedInitialFiltersApplied } from "../helpers/getPurgedInitialFiltersApplied.js";
+import { a as DYNAMIC_FILTER_SOTORE_ID } from "../constants.js";
 function updateAvailableFields(state) {
   state.availableFields = state.fields.filter((field) => {
     if (field.multiple === void 0 || field.multiple) {
@@ -22,18 +23,26 @@ const updateAutomatic = (state) => {
     state.countOnChangeFiltersApplied++;
   }
 };
-const createAreaStore = (initProps) => {
+const createDevtools = (immerMiddlewere, config) => {
+  const { enabled = false } = config;
+  if (enabled && process.env.NODE_ENV === "development") {
+    return devtools(immerMiddlewere, config);
+  }
+  return immerMiddlewere;
+};
+const createDynamicFilterStore = (initProps, storeDevtoolsEnabled = false) => {
   const startProps = {
+    elementRef: null,
     countOnChangeFiltersApplied: 0,
     appliedFilters: [],
     availableFields: [],
-    fnAnchorEl: void 0,
+    // fnAnchorEl: undefined,
     popoverFilterData: void 0,
     inputData: "",
     ...initProps
   };
   return createStore(
-    devtools(
+    createDevtools(
       immer((set, get) => ({
         ...startProps,
         actions: {
@@ -51,6 +60,12 @@ const createAreaStore = (initProps) => {
               updateAutomatic(state);
             });
           },
+          /**
+           *  Actualiza la referencia del elemento (inputFilter) desde donde se desprende el listado de campos
+           */
+          setElementRef: (ref) => {
+            get().elementRef = ref;
+          },
           /**
            * TODO: Documentar
            */
@@ -79,26 +94,24 @@ const createAreaStore = (initProps) => {
           /**
            * TODO: Documentar
            */
-          showPopoverFilterForAdd: (anchorEl, field) => {
+          showPopoverFilterForAdd: (field) => {
             set((state) => {
-              state.fnAnchorEl = void 0;
               state.inputData = "";
               state.popoverFilterData = {
                 openFor: "add",
-                fnAnchorEl: () => anchorEl,
                 field
               };
+              state.isOpenPopoverMenuFields = false;
+              state.ownerState.inEdition = true;
             });
-            get().actions.setInEdition(true);
           },
           /**
            * TODO: Documentar
            */
-          showPopoverFilterForEdit: (anchorEl, filterToEdit) => {
+          showPopoverFilterForEdit: (filterToEdit) => {
             set((state) => {
               state.popoverFilterData = {
                 openFor: "edit",
-                fnAnchorEl: () => anchorEl,
                 filter: filterToEdit,
                 field: filterToEdit.field
               };
@@ -194,9 +207,10 @@ const createAreaStore = (initProps) => {
           /**
            * TODO: Documentar
            */
-          openPopoverMenuFields: (anchorEl) => {
+          openPopoverMenuFields: () => {
             set((state) => {
-              state.fnAnchorEl = () => anchorEl;
+              state.isOpenPopoverMenuFields = true;
+              state.ownerState.inEdition = true;
             });
           },
           /**
@@ -204,16 +218,16 @@ const createAreaStore = (initProps) => {
            */
           closePopoverMenuFields: (newInEdition) => {
             set((state) => {
-              state.fnAnchorEl = void 0;
+              state.isOpenPopoverMenuFields = false;
               state.ownerState.inEdition = newInEdition || false;
             });
           }
         }
       })),
-      { name: `Dynamic filter` }
+      { name: `${DYNAMIC_FILTER_SOTORE_ID}: ${initProps.storeId}`, enabled: storeDevtoolsEnabled }
     )
   );
 };
 export {
-  createAreaStore as c
+  createDynamicFilterStore as c
 };

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

@@ -0,0 +1,200 @@
+import { MutableRefObject } from 'react';
+import { GetLabelType } from '@m4l/core';
+import { FilterField, FilterFieldApplied, FilterToEditApply, InitialFilterApplied, OwnerState } from '../types';
+export type OpenFor = 'add' | 'edit';
+export type FnAnchorEL = () => Element;
+export interface PopoverFilterDataBase {
+    /**
+     *  Motivo de apertura del popup
+     */
+    openFor: OpenFor;
+}
+export interface PopoverFilterDataAdd extends PopoverFilterDataBase {
+    openFor: 'add';
+    /**
+     * Campo por el cual se va a filtrar
+     */
+    field: FilterField;
+}
+export interface PopoverFilterDataEdit extends PopoverFilterDataBase {
+    openFor: 'edit';
+    /**
+     *  Filtro que se va a editar
+     */
+    filter: FilterFieldApplied;
+    field: FilterField;
+}
+/**
+ * Tipo usado para cuado se va agregar o modificar un filtro
+ */
+export type PopoverFilterData = PopoverFilterDataAdd | PopoverFilterDataEdit;
+/**
+ * Estados que se actulizan por fuera del store, a través de hooks
+ */
+export type ExternalOwnerState = Pick<OwnerState, 'isMobile' | 'isSkeleton'>;
+/**
+ * Interface que define el estado del componente
+ */
+export interface DynamicFilterState {
+    /**
+     *  "storeId" identificador del store
+     */
+    storeId?: string;
+    /**
+     *  "fields" Campos por los que se puede filtrar
+     */
+    fields: Array<FilterField>;
+    /**
+     *  "withAllField" indica si permite o no filtrar por todos los campos
+     */
+    withAllField: boolean;
+    /**
+     *  "ownerState" estado a nivel de clases del componente
+     */
+    ownerState: OwnerState;
+    /**
+     *  "allField" Campo que se usa cuando se puede buscar por todos los campos
+     */
+    allField: FilterField;
+    /**
+     *  "automatic" Configura si el filtro se ejecuta automaticamente cuando se agrega o se modifica un filtro
+     */
+    automatic: boolean;
+    /**
+     *  "elementRef" referencia al elemento (inputFilter) desde donde se desprende el listado de campos
+     */
+    elementRef: MutableRefObject<HTMLElement | null> | null;
+    /**
+     *  "isOpenPopoverMenuFields" determina si se debe abrir el menú de campos
+     */
+    isOpenPopoverMenuFields?: boolean;
+    /**
+     *  Funcion que retorna el elemento (inputFilter) desde donde se desprende el listado de campos
+     *               Si no está definida, el menú de campos no se muestra
+     * @returns
+     */
+    /**
+     *  "inputData" texto en el InputFilter
+     */
+    inputData: string;
+    /**
+     * Campos disponibles para filtrar
+     */
+    availableFields: Array<FilterField>;
+    /**
+     *  "applyedFilters" Filtros aplicados actualmente
+     */
+    appliedFilters: Array<FilterFieldApplied>;
+    /**
+     *  "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.
+     */
+    countOnChangeFiltersApplied: number;
+    /**
+     * :popoverFilterData" para emerger el popuup de modificación campos
+     */
+    popoverFilterData?: PopoverFilterData;
+    getLabel: GetLabelType;
+    /**
+     *  dataTestId:
+     *  Esta propiedad sirve para generar identificadores únicos.
+     */
+    dataTestId: string;
+}
+export interface DynamicFilterStateWithActions extends DynamicFilterState {
+    actions: {
+        /**
+         * inicializa el estado del componente con los filtros que provienen desde afuera
+         * @param initialFiltersApplied Filtros iniciales
+         */
+        init: (initialFiltersApplied: Array<InitialFilterApplied>) => void;
+        /**
+         *  "setElementRef" establece la referencia al elemento (inputFilter) desde donde se desprende el listado de campos
+         */
+        setElementRef: (ref: MutableRefObject<HTMLElement | null>) => void;
+        /**
+         * Obtiene el Campo dado el nombre
+         * @param name
+         * @returns Field o undefined si no se encuentra
+         */
+        getFieldByName: (name: string) => FilterField;
+        /**
+         * remueve un filtro si existe, y dispara el trigger de onChangeFilters
+         * @param id //identificador unico de un filtro
+         */
+        removeFilter: (id: number) => void;
+        /**
+         *
+         * @param anchorEl Elemento de donde va emerger el popup
+         * @param field Campo por el cual se va filtrar
+         * @returns
+         */
+        showPopoverFilterForAdd: (field: FilterField) => void;
+        /**
+         * Muestra la ventan de edición de un filtro aplicado
+         * @param anchorEl Anchor de elemento desde donde debe emerger
+         * @param filterToEdit Filtro a editar
+         * @returns
+         */
+        showPopoverFilterForEdit: (filterToEdit: FilterFieldApplied) => void;
+        /**
+         * Oculta la ventana de edición
+         * @param stayInEdition determina si continua en edicióin
+         */
+        hidePopoverFilter: (stayInEdition: boolean) => void;
+        /**
+         * Limpia todos los filtros aplicados menos los fixed
+         */
+        clearFilters: VoidFunction;
+        /**
+         * llama al onChangeFilters proporcionado en los props del componente
+         */
+        fireOnChangeFilters: VoidFunction;
+        /**
+         * Función encargada de encontrar un Id par un nuevo filtro
+         * @returns Id de filtro
+         */
+        getNewId: () => number;
+        /**
+         * Agrega un filtro setedo y correcto a los filtros aplicados (applyedFilters)
+         * @param newFilter Filtro a agregar
+         * @returns
+         */
+        addFilter: (newFilter: FilterFieldApplied) => void;
+        /**
+         * Modifica un filtro que se encuentra en applyedFilters
+         * @param filterToEdit filtro a editar
+         * @returns
+         */
+        updateFilter: (filterToEdit: FilterToEditApply) => void;
+        /**
+         * Modifica el texto que se visuliza en el InputFilter
+         * @param text texto en el input
+         * @returns
+         */
+        setInputData: (inputData: string) => void;
+        /**
+         * Modifica el estado de edición del componente
+         * @param newInEdition Estado de edición
+         * @returns
+         */
+        setInEdition: (newInEdition: boolean) => void;
+        /**
+         * Modifica los estados que se actualizan externamente al Store
+         * @param newIsMobile
+         * @returns
+         */
+        setExternalState: (newExternalState: ExternalOwnerState) => void;
+        /**
+         * Establece la función de apertura del menuu de campos
+         * @param anchorEl
+         * @returns
+         */
+        openPopoverMenuFields: () => void;
+        /**
+         * Limpia la función de apertura del menu de campos (por el valor anchorEl = undefined)
+         */
+        closePopoverMenuFields: (newInEdition?: boolean) => void;
+    };
+}
+export type InitialStoreProps = Pick<DynamicFilterState, 'automatic' | 'fields' | 'withAllField' | 'getLabel' | 'allField' | 'ownerState' | 'dataTestId' | 'storeId'>;

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

@@ -1,4 +1,4 @@
-import { DynamicFilterStateWithActions } from './DynamicFilterStore';
+import { DynamicFilterStateWithActions } from './DynamicFilterStoreTypes';
 /**
  * TODO: Documentar
  */

package/components/DynamicFilter/store/useDynamicFilterStore.js

@@ -7,7 +7,7 @@ function useDynamicFilterStore(selector, equalityFn) {
   if (!store) {
     throw new Error("useDynamicFilterStore context must be use inside DynamicFilterContext");
   }
-  return useStore(store, selector, shallow);
+  return useStore(store, selector, equalityFn ?? shallow);
 }
 export {
   useDynamicFilterStore as u

package/components/DynamicFilter/subcomponents/AppliedFilterChip/AppliedFilterChip.js

@@ -5,7 +5,7 @@ function AppliedFilterChip(props) {
   const { fixed } = props;
   const { onEditFilter, onDelete, iconFieldUrl, removeIconUrl, labels } = useAppliedFilterChip(props);
   return /* @__PURE__ */ jsxs(AppliedFilterChipStyled, { ownerState: {}, children: [
-    iconFieldUrl && /* @__PURE__ */ jsx(AppliedFilterChipIconStyled, { onClick: onEditFilter, src: iconFieldUrl, ownerState: {} }),
+    iconFieldUrl && /* @__PURE__ */ jsx(AppliedFilterChipIconStyled, { onClick: onEditFilter, icon: iconFieldUrl, ownerState: {} }),
     /* @__PURE__ */ jsxs(AppliedFilterChipInfoStyled, { onClick: onEditFilter, ownerState: {}, children: [
       /* @__PURE__ */ jsx(AppliedFilterChipInfoFieldNameStyled, { ownerState: {}, children: labels.labelField }),
       /* @__PURE__ */ jsx(AppliedFilterChipInfoOperatorStyled, { ownerState: {}, children: labels.labelOperator }),
@@ -14,7 +14,7 @@ function AppliedFilterChip(props) {
     !fixed && /* @__PURE__ */ jsx(
       AppliedFilterChipRemoveButtonStyled,
       {
-        src: removeIconUrl,
+        icon: removeIconUrl,
         size: "small",
         dictionaryTooltipId: "dynamic_filter.tooltip_clear_filter",
         onClick: onDelete,

package/components/DynamicFilter/subcomponents/AppliedFilterChip/useAppliedFilterChip.js

@@ -1,4 +1,4 @@
-import { useMemo } from "react";
+import { useRef, useMemo } from "react";
 import { useEnvironment, useModuleDictionary } from "@m4l/core";
 import { useFormatter } from "@m4l/graphics";
 import { u as useDynamicFilterStore } from "../../store/useDynamicFilterStore.js";
@@ -10,6 +10,7 @@ function useAppliedFilterChip(filter) {
   const { hidePopoverFilter, removeFilter, showPopoverFilterForEdit } = useDynamicFilterStore(
     (state) => state.actions
   );
+  const elementRef = useRef(null);
   const removeIconUrl = `${host_static_assets}/${environment_assets}/frontend/components/dynamic_filter/assets/icons/clear.svg`;
   const labels = useMemo(() => {
     return fieldFactory(filter.field.type).getLabels(filter, getLabel, formatters, filter.field);
@@ -20,8 +21,8 @@ function useAppliedFilterChip(filter) {
   }
   function onEditFilter(event) {
     hidePopoverFilter(false);
-    const currentTarget = event.currentTarget;
-    setTimeout(() => showPopoverFilterForEdit(currentTarget, filter), 10);
+    elementRef.current = event.currentTarget;
+    setTimeout(() => showPopoverFilterForEdit(filter), 10);
   }
   return {
     onDelete,

package/components/DynamicFilter/subcomponents/AppliedFilters/AppliedFilters.js

@@ -8,7 +8,7 @@ function AppliedFilters() {
   if (isSkeleton) {
     return /* @__PURE__ */ jsx(AppliedFiltersStyled, { ownerState: {} });
   }
-  return /* @__PURE__ */ jsx(AppliedFiltersStyled, { ownerState: {}, children: /* @__PURE__ */ jsx(ScrollBar, { children: /* @__PURE__ */ jsx(AppliedFilterInnerContainerStyled, { ownerState: {}, children: appliedFiltersSorted?.map((filter) => /* @__PURE__ */ jsx(AppliedFilterChip, { ...filter }, filter.id)) }) }) });
+  return /* @__PURE__ */ jsx(AppliedFiltersStyled, { ownerState: {}, children: /* @__PURE__ */ jsx(ScrollBar, { autoHide: true, children: /* @__PURE__ */ jsx(AppliedFilterInnerContainerStyled, { ownerState: {}, children: appliedFiltersSorted?.map((filter) => /* @__PURE__ */ jsx(AppliedFilterChip, { ...filter }, filter.id)) }) }) });
 }
 export {
   AppliedFilters as A

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

@@ -1,7 +1,7 @@
 import { GetLabelType } from '@m4l/core';
 import { Formatters } from '@m4l/graphics';
 import { IFieldType, YupSchema } from '../FieldTypeInterface';
-import { DataTypeFilerLabels, Field, FilterFieldApplied, FilterValue, FormFilterValueBoolean, InitialFilterApplied } from '../../../types';
+import { DataTypeFilerLabels, FilterField, FilterFieldApplied, FilterValue, FormFilterValueBoolean, InitialFilterApplied } from '../../../types';
 import { BooleanFilter } from './index';
 /**
  * TODO: Documentar
@@ -11,7 +11,7 @@ export declare class BooleanFilterHelpers implements IFieldType<FormFilterValueB
     /**
      * TODO: Documentar
      */
-    getDefaultFilter(field: Field, fixed: boolean): FilterFieldApplied;
+    getDefaultFilter(field: FilterField, fixed: boolean): FilterFieldApplied;
     /**
      * TODO: Documentar
      */
@@ -19,11 +19,11 @@ export declare class BooleanFilterHelpers implements IFieldType<FormFilterValueB
     /**
      * TODO: Documentar
      */
-    getFormValue(field: Field, getLabel: GetLabelType, filterValue?: FilterValue): FormFilterValueBoolean;
+    getFormValue(field: FilterField, getLabel: GetLabelType, filterValue?: FilterValue): FormFilterValueBoolean;
     /**
      * TODO: Documentar
      */
-    getLabels(filter: FilterFieldApplied, getLabel: GetLabelType, _formatters: Formatters, _field: Field): DataTypeFilerLabels;
+    getLabels(filter: FilterFieldApplied, getLabel: GetLabelType, _formatters: Formatters, _field: FilterField): DataTypeFilerLabels;
     /**
      * TODO: Documentar
      */
@@ -31,5 +31,5 @@ export declare class BooleanFilterHelpers implements IFieldType<FormFilterValueB
     /**
      * TODO: Documentar
      */
-    verifyFilter(filter: InitialFilterApplied, _field?: Field): boolean;
+    verifyFilter(filter: InitialFilterApplied, _field?: FilterField): boolean;
 }

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

@@ -1,7 +1,7 @@
 import { GetLabelType } from '@m4l/core';
 import { Formatters } from '@m4l/graphics';
 import { IFieldType, YupSchema } from '../FieldTypeInterface';
-import { DataTypeFilerLabels, Field, FilterFieldApplied, FilterValue, FormFilterValueDateTime, InitialFilterApplied } from '../../../types';
+import { DataTypeFilerLabels, FilterField, FilterFieldApplied, FilterValue, FormFilterValueDateTime, InitialFilterApplied } from '../../../types';
 import { DateTimeFilter } from './index';
 /**
  * TODO: Documentar
@@ -11,11 +11,11 @@ export declare class DateTimeFilterHelpers implements IFieldType<FormFilterValue
     /**
      * TODO: Documentar
      */
-    getDefaultFilter(field: Field, fixed: boolean): FilterFieldApplied;
+    getDefaultFilter(field: FilterField, fixed: boolean): FilterFieldApplied;
     /**
      * TODO: Documentar
      */
-    getFormValue(field: Field, getLabel: GetLabelType, filterValueDateTime?: FilterValue): FormFilterValueDateTime;
+    getFormValue(field: FilterField, getLabel: GetLabelType, filterValueDateTime?: FilterValue): FormFilterValueDateTime;
     /**
      * TODO: Documentar
      */
@@ -23,7 +23,7 @@ export declare class DateTimeFilterHelpers implements IFieldType<FormFilterValue
     /**
      * TODO: Documentar
      */
-    getLabels(filter: FilterFieldApplied, getLabel: GetLabelType, formatters: Formatters, _field: Field): DataTypeFilerLabels;
+    getLabels(filter: FilterFieldApplied, getLabel: GetLabelType, formatters: Formatters, _field: FilterField): DataTypeFilerLabels;
     /**
      * TODO: Documentar
      */
@@ -31,5 +31,5 @@ export declare class DateTimeFilterHelpers implements IFieldType<FormFilterValue
     /**
      * TODO: Documentar
      */
-    verifyFilter(filter: InitialFilterApplied, _field?: Field): boolean;
+    verifyFilter(filter: InitialFilterApplied, _field?: FilterField): boolean;
 }

package/components/DynamicFilter/subcomponents/FieldTypes/DateTimeFilter/helpers.js

@@ -1,8 +1,8 @@
 import * as Yup from "yup";
 import { g as getDynamicFilterDictionary, D as DICCTIONARY } from "../../../dictionary.js";
-import { a as DATE_TIME_OPERATORS } from "../../../constants.js";
+import { b as DATE_TIME_OPERATORS } from "../../../constants.js";
 import { D as DateTimeFilter } from "./index.js";
-import { i as isValidDate } from "../../../../../utils/index.js";
+import { i as isValidDate } from "../../../../../utils/isValidDate.js";
 class DateTimeFilterHelpers {
   getComponent() {
     return DateTimeFilter;

package/components/DynamicFilter/subcomponents/FieldTypes/DateTimeFilter/index.js

@@ -2,7 +2,7 @@ import { jsxs, jsx } from "react/jsx-runtime";
 import { useMemo } from "react";
 import { useFormContext, useWatch } from "react-hook-form";
 import { useModuleDictionary } from "@m4l/core";
-import { a as DATE_TIME_OPERATORS } from "../../../constants.js";
+import { b as DATE_TIME_OPERATORS } from "../../../constants.js";
 import { g as getDynamicFilterDictionary, D as DICCTIONARY } from "../../../dictionary.js";
 import { R as RHFAutocomplete } from "../../../../hook-form/RHFAutocomplete/RHFAutocomplete.js";
 import { R as RHFDateTime } from "../../../../hook-form/RHFDateTime/RHFDateTime.js";

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

@@ -1,7 +1,7 @@
 import { FC } from 'react';
 import { GetLabelType } from '@m4l/core';
 import { Formatters } from '@m4l/graphics';
-import { Field, FilterFieldApplied, DataTypeFilerLabels, FilterValue, InitialFilterApplied } from '../../types';
+import { FilterField, FilterFieldApplied, DataTypeFilerLabels, FilterValue, InitialFilterApplied } from '../../types';
 import * as Yup from 'yup';
 export type YupSchema = Yup.SchemaOf<any>;
 /**
@@ -11,10 +11,10 @@ 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;
+    getDefaultFilter(field: FilterField, fixed: boolean): FilterFieldApplied;
+    getLabels(filter: FilterFieldApplied, getLabel: GetLabelType, formatters: Formatters, field: FilterField): DataTypeFilerLabels;
     getSchema(getLabel: GetLabelType): YupSchema;
-    getFormValue(field: Field, getLabel: GetLabelType, filterValue?: FilterValue): T;
+    getFormValue(field: FilterField, getLabel: GetLabelType, filterValue?: FilterValue): T;
     getFilterFromFormValue(formFilterValue: T): FilterValue;
-    verifyFilter(filter: InitialFilterApplied, field?: Field): boolean;
+    verifyFilter(filter: InitialFilterApplied, field?: FilterField): boolean;
 }

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

@@ -1,7 +1,7 @@
 import { GetLabelType } from '@m4l/core';
 import { Formatters } from '@m4l/graphics';
 import { IFieldType, YupSchema } from '../FieldTypeInterface';
-import { DataTypeFilerLabels, Field, FilterFieldApplied, FilterValue, FormFilterValueNumber, InitialFilterApplied } from '../../../types';
+import { DataTypeFilerLabels, FilterField, FilterFieldApplied, FilterValue, FormFilterValueNumber, InitialFilterApplied } from '../../../types';
 import { NumberFilter } from './index';
 /**
  * TODO: Documentar
@@ -11,11 +11,11 @@ export declare class NumberFilterHelpers implements IFieldType<FormFilterValueNu
     /**
      * TODO: Documentar
      */
-    getDefaultFilter(fieldNumber: Field, fixed: boolean): FilterFieldApplied;
+    getDefaultFilter(fieldNumber: FilterField, fixed: boolean): FilterFieldApplied;
     /**
      * TODO: Documentar
      */
-    getFormValue(field: Field, getLabel: GetLabelType, filterValue?: FilterValue): FormFilterValueNumber;
+    getFormValue(field: FilterField, getLabel: GetLabelType, filterValue?: FilterValue): FormFilterValueNumber;
     /**
      * TODO: Documentar
      */
@@ -23,7 +23,7 @@ export declare class NumberFilterHelpers implements IFieldType<FormFilterValueNu
     /**
      * TODO: Documentar
      */
-    getLabels(filter: FilterFieldApplied, getLabel: GetLabelType, _formatters: Formatters, _field: Field): DataTypeFilerLabels;
+    getLabels(filter: FilterFieldApplied, getLabel: GetLabelType, _formatters: Formatters, _field: FilterField): DataTypeFilerLabels;
     /**
      * TODO: Documentar
      */
@@ -31,5 +31,5 @@ export declare class NumberFilterHelpers implements IFieldType<FormFilterValueNu
     /**
      * TODO: Documentar
      */
-    verifyFilter(filter: InitialFilterApplied, _field?: Field): boolean;
+    verifyFilter(filter: InitialFilterApplied, _field?: FilterField): boolean;
 }

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

@@ -0,0 +1,42 @@
+import { GetLabelType } from '@m4l/core';
+import { Formatters } from '@m4l/graphics';
+import { IFieldType, YupSchema } from '../FieldTypeInterface';
+import { DataTypeFilerLabels, FilterField, FilterFieldApplied, FilterValue, InitialFilterApplied, FormFilterValueSelectAsync, FormOperandSelectAsync } from '../../../types';
+import { SelectAsyncFilter } from './index';
+/**
+ * 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 filterValidOperandsArraySelectAsync(operandsArray: FormOperandSelectAsync[] | FormOperandSelectAsync, field: FilterField): any[];
+/**
+ * TODO: Documentar
+ */
+export declare class SelectAsyncFilterHelpers implements IFieldType<FormFilterValueSelectAsync> {
+    getComponent(): typeof SelectAsyncFilter;
+    /**
+     * TODO: Documentar
+     */
+    getDefaultFilter(field: FilterField, fixed: boolean): FilterFieldApplied;
+    /**
+     * TODO: Documentar
+     */
+    getFormValue(field: FilterField, getLabel: GetLabelType, filterValueSelect?: FilterValue): FormFilterValueSelectAsync;
+    /**
+     * TODO: Documentar
+     */
+    getFilterFromFormValue(formFilterValue: FormFilterValueSelectAsync): FilterValue;
+    /**
+     * TODO: Documentar
+     */
+    getLabels(filter: FilterFieldApplied, getLabel: GetLabelType, _formatters: Formatters, field: FilterField): DataTypeFilerLabels;
+    /**
+     * TODO: Documentar
+     */
+    getSchema(getLabel: GetLabelType): YupSchema;
+    /**
+     * TODO: Documentar
+     */
+    verifyFilter(filter: InitialFilterApplied, field?: FilterField): boolean;
+}