@m4l/components 7.0.0 → 7.1.2

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

@@ -1,7 +1,7 @@
-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';
+import { WritableDraft } from 'immer/dist/internal';
+import { GetLabelType } from '@m4l/core';
+import { Field, FilterFieldApplied, FilterToEditApply, InitialFilterApplied, OwnerState } from '../types';
+export type OpenFor = 'add' | 'edit';
 export interface PopoverFilterDataBase {
     /**
      *  Motivo de apertura del popup
@@ -30,17 +30,13 @@ export interface PopoverFilterDataEdit extends PopoverFilterDataBase {
 /**
  * Tipo usado para cuado se va agregar o modificar un filtro
  */
-export declare type PopoverFilterData = PopoverFilterDataAdd | PopoverFilterDataEdit;
+export type PopoverFilterData = PopoverFilterDataAdd | PopoverFilterDataEdit;
 /**
  * Estados que se actulizan por fuera del store, a través de hooks
- *
- * @type
  */
-export declare type ExternalOwnerState = Pick<OwnerState, 'isMobile' | 'isSkeleton'>;
+export type ExternalOwnerState = Pick<OwnerState, 'isMobile' | 'isSkeleton'>;
 /**
  * Interface que define el estado del componente
- *
- * @interface
  */
 export interface DynamicFilterState {
     /**
@@ -64,7 +60,7 @@ export interface DynamicFilterState {
      */
     automatic: boolean;
     /**
-     * @description  Funcion que retorna el elemento (inputFilter) desde donde se desprende el listado de campos
+     *  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
      */
@@ -74,7 +70,7 @@ export interface DynamicFilterState {
      */
     inputData: string;
     /**
-     * @description Campos disponibles para filtrar
+     * Campos disponibles para filtrar
      */
     availableFields: Array<Field>;
     /**
@@ -100,18 +96,18 @@ export interface DynamicFilterState {
 export interface DynamicFilterStateWithActions extends DynamicFilterState {
     actions: {
         /**
-         * @description inicializa el estado del componente con los filtros que provienen desde afuera
+         * inicializa el estado del componente con los filtros que provienen desde afuera
          * @param initialFiltersApplied Filtros iniciales
          */
         init: (initialFiltersApplied: Array<InitialFilterApplied>) => void;
         /**
-         * @description Obtiene el Campo dado el nombre
+         * Obtiene el Campo dado el nombre
          * @param name
          * @returns Field o undefined si no se encuentra
          */
         getFieldByName: (name: string) => Field;
         /**
-         * @description remueve un filtro si existe, y dispara el trigger de onChangeFilters
+         * remueve un filtro si existe, y dispara el trigger de onChangeFilters
          * @param id //identificador unico de un filtro
          */
         removeFilter: (id: number) => void;
@@ -123,79 +119,78 @@ export interface DynamicFilterStateWithActions extends DynamicFilterState {
          */
         showPopoverFilterForAdd: (anchorEl: Element, field: Field) => void;
         /**
-         * @description Muestra la ventan de edición de un filtro aplicado
+         * 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: (anchorEl: Element, filterToEdit: FilterFieldApplied) => void;
         /**
-         * @description Oculta la ventana de edición
+         * Oculta la ventana de edición
          * @param stayInEdition determina si continua en edicióin
          */
         hidePopoverFilter: (stayInEdition: boolean) => void;
         /**
-         * @description Limpia todos los filtros aplicados menos los fixed
+         * Limpia todos los filtros aplicados menos los fixed
          */
         clearFilters: VoidFunction;
         /**
-         * @description llama al onChangeFilters proporcionado en los props del componente
+         * llama al onChangeFilters proporcionado en los props del componente
          */
         fireOnChangeFilters: VoidFunction;
         /**
-         * @description Función encargada de encontrar un Id par un nuevo filtro
+         * Función encargada de encontrar un Id par un nuevo filtro
          * @returns Id de filtro
          */
         getNewId: () => number;
         /**
-         * @description Agrega un filtro setedo y correcto a los filtros aplicados (applyedFilters)
+         * Agrega un filtro setedo y correcto a los filtros aplicados (applyedFilters)
          * @param newFilter Filtro a agregar
          * @returns
          */
         addFilter: (newFilter: FilterFieldApplied) => void;
         /**
-         * @description Modifica un filtro que se encuentra en applyedFilters
+         * Modifica un filtro que se encuentra en applyedFilters
          * @param filterToEdit filtro a editar
          * @returns
          */
         updateFilter: (filterToEdit: FilterToEditApply) => void;
         /**
-         * @description Modifica el texto que se visuliza en el InputFilter
+         * Modifica el texto que se visuliza en el InputFilter
          * @param text texto en el input
          * @returns
          */
         setInputData: (inputData: string) => void;
         /**
-         * @description Modifica el estado de edición del componente
+         * Modifica el estado de edición del componente
          * @param newInEdition Estado de edición
          * @returns
          */
         setInEdition: (newInEdition: boolean) => void;
         /**
-         * @description Modifica los estados que se actualizan externamente al Store
+         * Modifica los estados que se actualizan externamente al Store
          * @param newIsMobile
          * @returns
          */
         setExternalState: (newExternalState: ExternalOwnerState) => void;
         /**
-         * @description Establece la función de apertura del menuu de campos
+         * Establece la función de apertura del menuu de campos
          * @param anchorEl
          * @returns
          */
         openPopoverMenuFields: (anchorEl: Element) => void;
         /**
-         * @description Limpia la función de apertura del menu de campos (por el valor anchorEl = undefined)
+         * Limpia la función de apertura del menu de campos (por el valor anchorEl = undefined)
          */
         closePopoverMenuFields: (newInEdition?: boolean) => void;
     };
 }
-declare type InitialStoreProps = Pick<DynamicFilterState, 'automatic' | 'fields' | 'withAllField' | 'getLabel' | 'allField' | 'ownerState' | 'dataTestId'>;
+type InitialStoreProps = Pick<DynamicFilterState, 'automatic' | 'fields' | 'withAllField' | 'getLabel' | 'allField' | 'ownerState' | 'dataTestId'>;
 /**
  * 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"> & {
+export declare const createAreaStore: (initProps: InitialStoreProps) => Omit<Omit<import('zustand').StoreApi<DynamicFilterStateWithActions>, "setState"> & {
     setState<A extends string | {
         type: unknown;
     }>(partial: DynamicFilterStateWithActions | Partial<DynamicFilterStateWithActions> | ((state: DynamicFilterStateWithActions) => DynamicFilterStateWithActions | Partial<DynamicFilterStateWithActions>), replace?: boolean | undefined, action?: A | undefined): void;
@@ -204,5 +199,5 @@ export declare const createAreaStore: (initProps: InitialStoreProps) => Omit<Omi
         type: unknown;
     } | undefined): void;
 };
-export declare type DynamicFilterStore = ReturnType<typeof createAreaStore>;
+export type DynamicFilterStore = ReturnType<typeof createAreaStore>;
 export {};

package/components/DynamicFilter/store/DynamicFilterStore.js

@@ -0,0 +1,219 @@
+import { createStore } from "zustand";
+import { devtools } from "zustand/middleware";
+import { immer } from "zustand/middleware/immer";
+import { g as getPurgedInitialFiltersApplied } from "../helpers/getPurgedInitialFiltersApplied.js";
+function updateAvailableFields(state) {
+  state.availableFields = state.fields.filter((field) => {
+    if (field.multiple === void 0 || field.multiple) {
+      return true;
+    }
+    const appliedFilterNames = new Set(state.appliedFilters.map((f) => f.field.name));
+    return !appliedFilterNames.has(field.name);
+  });
+}
+function updateOwnerStateIsValid(state) {
+  state.ownerState.isValid = state.appliedFilters.every((filter) => filter.isSet);
+}
+const updateAutomatic = (state) => {
+  updateOwnerStateIsValid(state);
+  updateAvailableFields(state);
+  if (state.ownerState.isValid && state.automatic) {
+    state.ownerState.isDirty = false;
+    state.countOnChangeFiltersApplied++;
+  }
+};
+const createAreaStore = (initProps) => {
+  const startProps = {
+    countOnChangeFiltersApplied: 0,
+    appliedFilters: [],
+    availableFields: [],
+    fnAnchorEl: void 0,
+    popoverFilterData: void 0,
+    inputData: "",
+    ...initProps
+  };
+  return createStore(
+    devtools(
+      immer((set, get) => ({
+        ...startProps,
+        actions: {
+          /**
+           * TODO: Documentar
+           */
+          init: (initialFiltersApplied) => {
+            set((state) => {
+              state.appliedFilters = getPurgedInitialFiltersApplied(
+                state.fields,
+                initialFiltersApplied,
+                state.actions.getFieldByName
+              );
+              state.ownerState.isEmpty = state.appliedFilters.length <= 0;
+              updateAutomatic(state);
+            });
+          },
+          /**
+           * TODO: Documentar
+           */
+          getFieldByName: (name) => {
+            const field = (get().withAllField ? get().fields.concat(get().allField) : get().fields).find((f) => {
+              return f.name === name;
+            });
+            if (field) {
+              return field;
+            }
+            throw new Error("No exist field");
+          },
+          /**
+           * TODO: Documentar
+           */
+          removeFilter: (id) => {
+            set((state) => {
+              const indexToRemoved = state.appliedFilters.findIndex((f) => id === f.id && !f.fixed);
+              if (indexToRemoved > -1) {
+                state.appliedFilters.splice(indexToRemoved, 1);
+                state.ownerState.isEmpty = state.appliedFilters.length === 0;
+                updateAutomatic(state);
+              }
+            });
+          },
+          /**
+           * TODO: Documentar
+           */
+          showPopoverFilterForAdd: (anchorEl, field) => {
+            set((state) => {
+              state.fnAnchorEl = void 0;
+              state.inputData = "";
+              state.popoverFilterData = {
+                openFor: "add",
+                fnAnchorEl: () => anchorEl,
+                field
+              };
+            });
+            get().actions.setInEdition(true);
+          },
+          /**
+           * TODO: Documentar
+           */
+          showPopoverFilterForEdit: (anchorEl, filterToEdit) => {
+            set((state) => {
+              state.popoverFilterData = {
+                openFor: "edit",
+                fnAnchorEl: () => anchorEl,
+                filter: filterToEdit,
+                field: filterToEdit.field
+              };
+            });
+            get().actions.setInEdition(true);
+          },
+          /**
+           * TODO: Documentar
+           */
+          hidePopoverFilter: (stayInEdition) => {
+            set((state) => {
+              state.popoverFilterData = void 0;
+            });
+            get().actions.setInEdition(stayInEdition);
+          },
+          /**
+           * TODO: Documentar
+           */
+          clearFilters: () => {
+            set((state) => {
+              state.appliedFilters = state.appliedFilters.filter((f) => f.fixed);
+              state.ownerState.isEmpty = state.appliedFilters.length === 0;
+              updateAvailableFields(state);
+            });
+          },
+          /**
+           * TODO: Documentar
+           */
+          fireOnChangeFilters: () => {
+            set((state) => {
+              if (state.ownerState.isValid) {
+                state.ownerState.isDirty = false;
+                state.countOnChangeFiltersApplied++;
+              }
+            });
+          },
+          /**
+           * TODO: Documentar
+           */
+          getNewId: () => {
+            return get().appliedFilters.reduce((prev, filterField) => {
+              return filterField.id > prev ? filterField.id : prev;
+            }, 0) + 1;
+          },
+          /**
+           * TODO: Documentar
+           */
+          addFilter: (newFilter) => {
+            set((state) => {
+              state.appliedFilters.push(newFilter);
+              state.ownerState.isEmpty = state.appliedFilters.length === 0;
+              updateAutomatic(state);
+            });
+          },
+          /**
+           * TODO: Documentar
+           */
+          updateFilter: (editFilter) => {
+            set((state) => {
+              const index = state.appliedFilters.findIndex(
+                (filterField) => filterField.id === editFilter.id
+              );
+              if (index > -1) {
+                state.appliedFilters[index] = editFilter;
+              }
+              updateAutomatic(state);
+            });
+          },
+          /**
+           * TODO: Documentar
+           */
+          setInputData: (inputData) => {
+            set((state) => {
+              state.inputData = inputData;
+            });
+          },
+          /**
+           * TODO: Documentar
+           */
+          setInEdition: (newInEdition) => {
+            set((state) => {
+              state.ownerState.inEdition = newInEdition;
+            });
+          },
+          /**
+           * TODO: Documentar
+           */
+          setExternalState: (newExternalState) => {
+            set((state) => {
+              state.ownerState = { ...state.ownerState, ...newExternalState };
+            });
+          },
+          /**
+           * TODO: Documentar
+           */
+          openPopoverMenuFields: (anchorEl) => {
+            set((state) => {
+              state.fnAnchorEl = () => anchorEl;
+            });
+          },
+          /**
+           * TODO: Documentar
+           */
+          closePopoverMenuFields: (newInEdition) => {
+            set((state) => {
+              state.fnAnchorEl = void 0;
+              state.ownerState.inEdition = newInEdition || false;
+            });
+          }
+        }
+      })),
+      { name: `Dynamic filter` }
+    )
+  );
+};
+export {
+  createAreaStore as c
+};

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

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

package/components/DynamicFilter/store/useDynamicFilterStore.js

@@ -0,0 +1,14 @@
+import { useContext } from "react";
+import { useStore } from "zustand";
+import { shallow } from "zustand/shallow";
+import { a as DynamicFilterContext } from "./DynamicFilterContext.js";
+function useDynamicFilterStore(selector, equalityFn) {
+  const store = useContext(DynamicFilterContext);
+  if (!store) {
+    throw new Error("useDynamicFilterStore context must be use inside DynamicFilterContext");
+  }
+  return useStore(store, selector, shallow);
+}
+export {
+  useDynamicFilterStore as u
+};

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

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

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

@@ -0,0 +1,28 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { u as useAppliedFilterChip } from "./useAppliedFilterChip.js";
+import { A as AppliedFilterChipStyled, a as AppliedFilterChipIconStyled, b as AppliedFilterChipInfoStyled, c as AppliedFilterChipInfoFieldNameStyled, d as AppliedFilterChipInfoOperatorStyled, e as AppliedFilterChipInfoOperandsStyled, f as AppliedFilterChipRemoveButtonStyled } from "../../slots/dynamicFilterSlots.js";
+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: {} }),
+    /* @__PURE__ */ jsxs(AppliedFilterChipInfoStyled, { onClick: onEditFilter, ownerState: {}, children: [
+      /* @__PURE__ */ jsx(AppliedFilterChipInfoFieldNameStyled, { ownerState: {}, children: labels.labelField }),
+      /* @__PURE__ */ jsx(AppliedFilterChipInfoOperatorStyled, { ownerState: {}, children: labels.labelOperator }),
+      /* @__PURE__ */ jsx(AppliedFilterChipInfoOperandsStyled, { ownerState: {}, children: labels.labelOperands })
+    ] }),
+    !fixed && /* @__PURE__ */ jsx(
+      AppliedFilterChipRemoveButtonStyled,
+      {
+        src: removeIconUrl,
+        size: "small",
+        dictionaryTooltipId: "dynamic_filter.tooltip_clear_filter",
+        onClick: onDelete,
+        ownerState: {}
+      }
+    )
+  ] });
+}
+export {
+  AppliedFilterChip as A
+};

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

@@ -0,0 +1 @@
+

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

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

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

@@ -0,0 +1,36 @@
+import { useMemo } from "react";
+import { useEnvironment, useModuleDictionary } from "@m4l/core";
+import { useFormatter } from "@m4l/graphics";
+import { u as useDynamicFilterStore } from "../../store/useDynamicFilterStore.js";
+import { f as fieldFactory } from "../FieldTypes/fieldFactory.js";
+function useAppliedFilterChip(filter) {
+  const { host_static_assets, environment_assets } = useEnvironment();
+  const { getLabel } = useModuleDictionary();
+  const formatters = useFormatter();
+  const { hidePopoverFilter, removeFilter, showPopoverFilterForEdit } = useDynamicFilterStore(
+    (state) => state.actions
+  );
+  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);
+  }, [filter, getLabel]);
+  function onDelete() {
+    hidePopoverFilter(false);
+    removeFilter(filter.id);
+  }
+  function onEditFilter(event) {
+    hidePopoverFilter(false);
+    const currentTarget = event.currentTarget;
+    setTimeout(() => showPopoverFilterForEdit(currentTarget, filter), 10);
+  }
+  return {
+    onDelete,
+    onEditFilter,
+    removeIconUrl,
+    iconFieldUrl: filter.field?.urlIcon,
+    labels
+  };
+}
+export {
+  useAppliedFilterChip as u
+};

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

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

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

@@ -0,0 +1,15 @@
+import { jsx } from "react/jsx-runtime";
+import { S as ScrollBar } from "../../../ScrollBar/index.js";
+import { u as useAppliedFilters } from "./useAppliedFilters.js";
+import { g as AppliedFiltersStyled, h as AppliedFilterInnerContainerStyled } from "../../slots/dynamicFilterSlots.js";
+import { A as AppliedFilterChip } from "../AppliedFilterChip/AppliedFilterChip.js";
+function AppliedFilters() {
+  const { appliedFiltersSorted, isSkeleton } = useAppliedFilters();
+  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)) }) }) });
+}
+export {
+  AppliedFilters as A
+};

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

@@ -0,0 +1 @@
+

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

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

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

@@ -0,0 +1,15 @@
+import { u as useDynamicFilterStore } from "../../store/useDynamicFilterStore.js";
+function useAppliedFilters() {
+  const appliedFilter = useDynamicFilterStore((state) => state.appliedFilters);
+  const isSkeleton = useDynamicFilterStore((state) => state.ownerState.isSkeleton);
+  const appliedFiltersSorted = [...appliedFilter].sort(
+    (filterA, filterB) => filterA.isSet !== filterB.isSet ? Number(filterA.isSet) - Number(filterB.isSet) : filterB.id - filterA.id
+  );
+  return {
+    appliedFiltersSorted,
+    isSkeleton
+  };
+}
+export {
+  useAppliedFilters as u
+};

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

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

package/components/DynamicFilter/subcomponents/DynamicFilterBase/DynamicFilterBase.js

@@ -0,0 +1,35 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { u as useDynamicFilterBase } from "./useDynamicFilterBase.js";
+import { a as getPropDataTestId } from "../../../../test/getNameDataTestId.js";
+import { R as RootStyled, I as InnerContainerStyled } from "../../slots/dynamicFilterSlots.js";
+import { D as DynamicFilterSlots } from "../../slots/SlotsEnum.js";
+import { I as InputFilter } from "../InputFilter/InputFilter.js";
+import { A as AppliedFilters } from "../AppliedFilters/AppliedFilters.js";
+import { F as FilterActions } from "../FilterActions/FilterActions.js";
+import { P as PopoverFilter } from "../PopoverFilter/PopoverFilter.js";
+function DynamicFilterBase() {
+  const { ownerState, dataTestId } = useDynamicFilterBase();
+  return /* @__PURE__ */ jsx(
+    RootStyled,
+    {
+      ownerState: { ...ownerState },
+      ...getPropDataTestId(dataTestId, DynamicFilterSlots.root),
+      children: /* @__PURE__ */ jsxs(
+        InnerContainerStyled,
+        {
+          ownerState: { ...ownerState },
+          ...getPropDataTestId(dataTestId, DynamicFilterSlots.innerContainer),
+          children: [
+            /* @__PURE__ */ jsx(InputFilter, {}),
+            /* @__PURE__ */ jsx(AppliedFilters, {}),
+            /* @__PURE__ */ jsx(FilterActions, {}),
+            /* @__PURE__ */ jsx(PopoverFilter, {})
+          ]
+        }
+      )
+    }
+  );
+}
+export {
+  DynamicFilterBase as D
+};

package/components/DynamicFilter/subcomponents/DynamicFilterBase/index.js

@@ -0,0 +1 @@
+

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

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

package/components/DynamicFilter/subcomponents/DynamicFilterBase/useDynamicFilterBase.js

@@ -0,0 +1,9 @@
+import { u as useDynamicFilterStore } from "../../store/useDynamicFilterStore.js";
+function useDynamicFilterBase() {
+  const ownerState = useDynamicFilterStore((state) => state.ownerState);
+  const dataTestId = useDynamicFilterStore((state) => state.dataTestId);
+  return { ownerState, dataTestId };
+}
+export {
+  useDynamicFilterBase as u
+};

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

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