@m4l/components 0.2.34 → 0.2.36

package/components/DragResizeWindow/index.13ef022e.js

@@ -1,489 +0,0 @@
-import React__default, { forwardRef, useState, useRef, useImperativeHandle, useCallback, useEffect, useMemo } from "react";
-import { D as DraggableCore_1 } from "../../react-draggable.e4725f3a.js";
-import clsx from "clsx";
-import { styled, generateUtilityClasses } from "@mui/material";
-import { M as MAP_ZINDEX_OVER_MAP } from "../maps/components/Map/index.accb1f77.js";
-import "@mui/base";
-import { M as MAP_ZINDEX_OVER_MAP$1 } from "../popups/PopupsViewer/index.1500ce72.js";
-import { R as Resizable } from "../../react-resizable.c07d63fb.js";
-import { jsx } from "react/jsx-runtime";
-const WrapperWindowRoot = styled("div")`
-    position: absolute;
-    left: 0px;
-    top:0px;
-    background-color: gray;
-    z-index: ${MAP_ZINDEX_OVER_MAP};
-    prop2:2;
-
-
-    ${(props) => props.theme.components?.M4LDragResizeWindow?.styleOverrides}
-`;
-const COMPONENT_CLASS_NAME = "M4LDraggableWindow";
-const DEFAULT_TRANSFORM_SCALE = 1;
-const draggableWindowClasses = generateUtilityClasses(COMPONENT_CLASS_NAME, [
-  "root",
-  "draggableHandle",
-  "draggableCancel",
-  "dragging"
-]);
-function setTransform({ top, left, width, height }) {
-  const translate = `translate(${left}px,${top}px)`;
-  return {
-    transform: translate,
-    WebkitTransform: translate,
-    MozTransform: translate,
-    msTransform: translate,
-    OTransform: translate,
-    width: `${width}px`,
-    height: `${height}px`,
-    position: "absolute",
-    prop1: 1
-  };
-}
-const DragResizeWindow = forwardRef((props, ref) => {
-  const {
-    style,
-    className,
-    children,
-    defaultPosition = {
-      vertical: {
-        top: 0,
-        height: 100
-      },
-      horizontal: {
-        left: 0,
-        width: 100
-      }
-    },
-    containerElement,
-    containerSize,
-    transformScale = DEFAULT_TRANSFORM_SCALE,
-    bounds = {
-      left: 5,
-      top: 5,
-      right: -5,
-      bottom: -5
-    },
-    minWindowWidth = 200,
-    minWindowHeight = 100,
-    draggableHandle = `.${draggableWindowClasses.draggableHandle}`,
-    draggableCancel = `.${draggableWindowClasses.draggableCancel}`,
-    draggable = true,
-    onDragStart,
-    onDrag,
-    onDragStop,
-    onMouseDown,
-    resizeable = true,
-    resizeHandles = ["se", "nw"],
-    resizeHandle,
-    onResizeStart,
-    onResize,
-    onResizeStop,
-    ...others
-  } = props;
-  const [currentState, setCurrentState] = useState(() => {
-    let top;
-    let bottom;
-    let height;
-    let left;
-    let right;
-    let width;
-    if ("top" in defaultPosition.vertical) {
-      top = defaultPosition.vertical.top;
-    }
-    if ("bottom" in defaultPosition.vertical) {
-      bottom = defaultPosition.vertical.bottom;
-    }
-    if ("height" in defaultPosition.vertical) {
-      height = defaultPosition.vertical.height;
-    }
-    if ("left" in defaultPosition.horizontal) {
-      left = defaultPosition.horizontal.left;
-    }
-    if ("right" in defaultPosition.horizontal) {
-      right = defaultPosition.horizontal.right;
-    }
-    if ("width" in defaultPosition.horizontal) {
-      width = defaultPosition.horizontal.width;
-    }
-    const containerHeight = containerSize?.containerHeight || 200;
-    const containerWidth = containerSize?.containerWidth || 200;
-    return {
-      top: top || 0,
-      height: height ?? containerHeight - (top || 0) - (bottom || 0),
-      left: left ?? (right ? containerWidth - right - (width || 0) : 0),
-      width: width ?? containerWidth - (left || 0) - (right || 0)
-    };
-  });
-  const stateRef = useRef({
-    bounds,
-    data: void 0,
-    dragging: void 0,
-    containerSize: containerSize ? {
-      ...containerSize
-    } : void 0,
-    left: currentState.left,
-    top: currentState.top,
-    width: currentState.width,
-    height: currentState.height
-  });
-  useImperativeHandle(ref, () => {
-    return {
-      current: wrapperRef.current
-    };
-  });
-  const wrapperRef = useRef(null);
-  const localOnDragStart = useCallback((e, draggableData) => {
-    const {
-      node
-    } = draggableData;
-    const newPosition = {
-      top: 0,
-      left: 0
-    };
-    const parentRect = containerElement.getBoundingClientRect();
-    const clientRect = node.getBoundingClientRect();
-    const cLeft = clientRect.left / transformScale;
-    const pLeft = parentRect.left / transformScale;
-    const cTop = clientRect.top / transformScale;
-    const pTop = parentRect.top / transformScale;
-    newPosition.left = cLeft - pLeft + containerElement.scrollLeft;
-    newPosition.top = cTop - pTop + containerElement.scrollTop;
-    if (onDragStart) {
-      if (onDragStart(e, draggableData) === false) {
-        return false;
-      }
-    }
-    stateRef.current.dragging = newPosition;
-    setCurrentState((prev) => ({
-      ...prev,
-      ...newPosition,
-      shrinkLeftAt: void 0,
-      shrinkTopAt: void 0,
-      overflowWidthAt: void 0,
-      overflowHeightAt: void 0,
-      dragging: newPosition
-    }));
-  }, []);
-  const localOnDrag = useCallback((e, draggableData) => {
-    const {
-      deltaX,
-      deltaY
-    } = draggableData;
-    if (!stateRef.current.dragging) {
-      return;
-    }
-    if (onDrag) {
-      if (onDrag(e, draggableData) === false) {
-        return false;
-      }
-    }
-    let top = stateRef.current.dragging.top + deltaY;
-    let left = stateRef.current.dragging.left + deltaX;
-    const newPosition = {
-      top,
-      left
-    };
-    stateRef.current.dragging = newPosition;
-    setCurrentState((prev) => ({
-      ...prev,
-      ...newPosition,
-      dragging: newPosition
-    }));
-  }, []);
-  const localOnDragStop = useCallback((e, draggableData) => {
-    if (!stateRef.current.dragging) {
-      return;
-    }
-    const {
-      left,
-      top
-    } = stateRef.current.dragging;
-    if (onDragStop) {
-      if (onDragStop(e, draggableData) === false) {
-        return false;
-      }
-    }
-    const newPosition = {
-      top,
-      left
-    };
-    stateRef.current.dragging = void 0;
-    setCurrentState((prev) => ({
-      ...prev,
-      ...newPosition,
-      dragging: void 0
-    }));
-  }, []);
-  const onResizeHandler = useCallback((e, data, handlerName) => {
-    const {
-      size,
-      handle
-    } = data;
-    const handler = props[handlerName];
-    console.log("onResizeHandler", containerElement.getBoundingClientRect());
-    if (handler) {
-      handler(e, data);
-    }
-    if (handlerName === "onResizeStart") {
-      stateRef.current.initialPostion = {
-        left: stateRef.current.left,
-        top: stateRef.current.top,
-        width: stateRef.current.width,
-        height: stateRef.current.height
-      };
-    }
-    const resizing = handlerName === "onResizeStop" ? void 0 : {
-      ...size,
-      handle
-    };
-    setCurrentState((prev) => ({
-      ...prev,
-      ...size,
-      ...handlerName === "onResizeStart" ? {
-        shrinkLeftAt: void 0,
-        shrinkTopAt: void 0,
-        overflowWidthAt: void 0,
-        overflowHeightAt: void 0
-      } : {},
-      resizing
-    }));
-    stateRef.current.resizing = resizing;
-  }, []);
-  const localOnResizeStart = useCallback((e, callbackData) => {
-    onResizeHandler(e, callbackData, "onResizeStart");
-  }, []);
-  const localOnResize = useCallback((e, callbackData) => {
-    onResizeHandler(e, callbackData, "onResize");
-  }, []);
-  const localOnResizeStop = useCallback((e, callbackData) => {
-    onResizeHandler(e, callbackData, "onResizeStop");
-  }, []);
-  const shringkingParentContainer = useCallback((newState, cState, containerDimension, divRoot, dimension) => {
-    const lDimension = dimension === "Width" ? "width" : "height";
-    const leftTop = dimension === "Width" ? "left" : "top";
-    const shrinkLeftTopAt = dimension === "Width" ? "shrinkLeftAt" : "shrinkTopAt";
-    const overflowDimensionAt = dimension === "Width" ? "overflowWidthAt" : "overflowHeightAt";
-    const boundsLefTop = dimension === "Width" ? bounds?.left || 0 : bounds?.top || 0;
-    const boundsRigthBottom = dimension === "Width" ? bounds?.right || 0 : bounds?.bottom || 0;
-    const minWindowDimension = dimension === "Width" ? minWindowWidth : minWindowHeight;
-    const minDimension = containerDimension - boundsLefTop + boundsRigthBottom > minWindowDimension ? containerDimension - boundsLefTop + boundsRigthBottom : minWindowDimension;
-    let maxDimensionElement = containerDimension - cState[leftTop] + boundsRigthBottom;
-    if (divRoot[`client${dimension}`] > maxDimensionElement) {
-      const shrinkedPixels = divRoot[`client${dimension}`] - maxDimensionElement;
-      if (shrinkedPixels < cState[leftTop] - boundsLefTop) {
-        newState[leftTop] = newState[leftTop] - shrinkedPixels;
-        newState[shrinkLeftTopAt] = newState[shrinkLeftTopAt] || cState[leftTop];
-      } else if (shrinkedPixels > cState[leftTop] - boundsLefTop) {
-        newState[leftTop] = boundsLefTop;
-        newState[shrinkLeftTopAt] = newState[shrinkLeftTopAt] || cState[leftTop];
-        maxDimensionElement = containerDimension - boundsLefTop + boundsRigthBottom;
-        if (divRoot[`client${dimension}`] > maxDimensionElement) {
-          newState[lDimension] = maxDimensionElement;
-          newState[overflowDimensionAt] = newState[overflowDimensionAt] || cState[lDimension];
-          if (newState[lDimension] < minDimension) {
-            newState[lDimension] = minDimension;
-          }
-        }
-      }
-    } else {
-      return;
-    }
-  }, []);
-  const expandingParentContainer = useCallback((newState, _currentState, containerDimension, _divRoot, dimension) => {
-    const lDimension = dimension === "Width" ? "width" : "height";
-    const leftTop = dimension === "Width" ? "left" : "top";
-    const shrinkLeftTopAt = dimension === "Width" ? "shrinkLeftAt" : "shrinkTopAt";
-    const overflowDimensionAt = dimension === "Width" ? "overflowWidthAt" : "overflowHeightAt";
-    const boundsLefTop = dimension === "Width" ? bounds?.left || 0 : bounds?.top || 0;
-    const boundsRigthBottom = dimension === "Width" ? bounds?.right || 0 : bounds?.bottom || 0;
-    let maxDimensionElement = containerDimension - boundsLefTop + boundsRigthBottom;
-    const valOverflowDimensionAt = newState[overflowDimensionAt];
-    if (valOverflowDimensionAt) {
-      if (valOverflowDimensionAt > maxDimensionElement) {
-        newState[lDimension] = maxDimensionElement;
-      } else {
-        newState[lDimension] = valOverflowDimensionAt;
-        newState[overflowDimensionAt] = void 0;
-      }
-    }
-    const valShrinkLeftTopAt = newState[shrinkLeftTopAt];
-    if (valShrinkLeftTopAt && !newState[overflowDimensionAt]) {
-      const dimensionAvailable = containerDimension - boundsLefTop - newState[lDimension] + boundsRigthBottom;
-      if (valShrinkLeftTopAt <= dimensionAvailable) {
-        newState[leftTop] = valShrinkLeftTopAt;
-        newState[shrinkLeftTopAt] = void 0;
-      } else {
-        newState[leftTop] = dimensionAvailable;
-      }
-    }
-  }, []);
-  const draggingOrResizingWindow = useCallback((newState, _currentState, containerDimension, divRoot, dimension) => {
-    const lDimension = dimension === "Width" ? "width" : "height";
-    const leftTop = dimension === "Width" ? "left" : "top";
-    const boundsLefTop = dimension === "Width" ? bounds?.left || 0 : bounds?.top || 0;
-    const boundsRigthBottom = dimension === "Width" ? bounds?.right || 0 : bounds?.bottom || 0;
-    const maxDimensionWithoutBounds = containerDimension - boundsLefTop + boundsRigthBottom;
-    let rightBottomBoundary = containerDimension - newState[lDimension] + boundsRigthBottom;
-    if (newState[lDimension] !== divRoot[`client${dimension}`])
-      ;
-    if (newState.resizing && stateRef.current.initialPostion) {
-      if (!newState.resizing.handle.includes("w")) {
-        if (newState[leftTop] + newState[lDimension] > containerDimension + boundsRigthBottom) {
-          newState[lDimension] = containerDimension - newState[leftTop] + boundsRigthBottom;
-        }
-      } else {
-        if (newState[leftTop] < boundsLefTop) {
-          newState[leftTop] = boundsLefTop;
-        } else {
-          const dif = newState[lDimension] - stateRef.current.initialPostion[lDimension];
-          if (dif > 0) {
-            if (newState[leftTop] - dif >= boundsLefTop) {
-              newState[lDimension] = stateRef.current.initialPostion[lDimension] + dif;
-              newState[leftTop] = newState[leftTop] - dif;
-              if (newState[leftTop] + newState[lDimension] > maxDimensionWithoutBounds)
-                ;
-            } else {
-              console.log("Ampliando mover leftTop al bound y dejar la ultima dimension", newState[leftTop], "a", newState[lDimension], stateRef.current.initialPostion[lDimension]);
-              newState[leftTop] = boundsLefTop;
-              newState[lDimension] = stateRef.current.initialPostion[lDimension];
-            }
-          } else if (dif < 0) {
-            console.log("Reeuciendo con W ", newState[leftTop] - dif, boundsLefTop, newState[leftTop] - dif >= boundsLefTop);
-            newState[leftTop] = newState[leftTop] - dif;
-            newState[lDimension] = stateRef.current.initialPostion[lDimension] + dif;
-          }
-        }
-      }
-    }
-    if (newState[lDimension] > maxDimensionWithoutBounds) {
-      newState[lDimension] = maxDimensionWithoutBounds;
-    }
-    if (newState[leftTop] < boundsLefTop) {
-      newState[leftTop] = boundsLefTop;
-    }
-    rightBottomBoundary = containerDimension + boundsRigthBottom;
-    if (newState[leftTop] > rightBottomBoundary) {
-      newState[leftTop] = rightBottomBoundary;
-    }
-    if (!newState.resizing && newState[leftTop] + newState[lDimension] > containerDimension + boundsRigthBottom) {
-      let outWidthHeight = newState[leftTop] + newState[lDimension] - (containerDimension + boundsRigthBottom);
-      if (newState[leftTop] - boundsLefTop > outWidthHeight) {
-        newState[leftTop] = newState[leftTop] - outWidthHeight;
-      }
-    }
-    if (newState.resizing && stateRef.current.initialPostion) {
-      stateRef.current.initialPostion[lDimension] = newState[lDimension];
-      stateRef.current.initialPostion[leftTop] = newState[leftTop];
-    }
-  }, []);
-  useEffect(() => {
-    if (stateRef.current.containerSize === void 0 && containerSize) {
-      stateRef.current.containerSize = containerSize;
-    }
-    if (!(containerSize && wrapperRef?.current && stateRef.current.containerSize)) {
-      return;
-    }
-    if (currentState?.dragging) {
-      return;
-    }
-    const newState = {
-      ...currentState
-    };
-    const handleDimension = (dimension) => {
-      if (stateRef.current?.containerSize && wrapperRef.current) {
-        const containerSizeKey = `container${dimension}`;
-        const containerSizeValue = containerSize[containerSizeKey];
-        const previousContainerSizeValue = stateRef.current.containerSize[containerSizeKey];
-        if (containerSizeValue > previousContainerSizeValue) {
-          expandingParentContainer(newState, currentState, containerSizeValue, wrapperRef.current, dimension);
-        } else if (containerSizeValue < previousContainerSizeValue) {
-          shringkingParentContainer(newState, currentState, containerSizeValue, wrapperRef.current, dimension);
-        } else {
-          draggingOrResizingWindow(newState, currentState, containerSizeValue, wrapperRef.current, dimension);
-        }
-      }
-    };
-    handleDimension("Width");
-    handleDimension("Height");
-    stateRef.current.containerSize = {
-      ...containerSize
-    };
-    if (newState.left !== currentState.left || newState.top !== currentState.top || newState.width !== currentState.width || newState.height !== currentState.height || newState.shrinkLeftAt !== currentState.shrinkLeftAt || newState.shrinkTopAt !== currentState.shrinkTopAt || newState.overflowWidthAt !== currentState.overflowWidthAt || newState.overflowHeightAt !== currentState.overflowHeightAt) {
-      setCurrentState(newState);
-    }
-    if (!newState.resizing) {
-      stateRef.current.left = newState.left;
-      stateRef.current.top = newState.top;
-      stateRef.current.height = newState.height;
-      stateRef.current.width = newState.width;
-    }
-  }, [currentState, wrapperRef.current, bounds?.left, bounds?.top, bounds?.right, bounds?.bottom, containerSize?.containerWidth, containerSize?.containerHeight]);
-  const mixinResizable = useCallback((child, position) => {
-    const minConstraints = [minWindowWidth, minWindowHeight];
-    return /* @__PURE__ */ jsx(
-      Resizable,
-      {
-        draggableOpts: {
-          disabled: !resizeable
-        },
-        className: resizeable ? void 0 : "react-resizable-hide",
-        width: position.width,
-        height: position.height,
-        minConstraints,
-        onResizeStop: localOnResizeStop,
-        onResizeStart: localOnResizeStart,
-        onResize: localOnResize,
-        transformScale,
-        resizeHandles,
-        handle: resizeHandle,
-        children: child
-      }
-    );
-  }, [resizeable, transformScale]);
-  const mixinDraggable = useCallback((child) => {
-    return /* @__PURE__ */ jsx(
-      DraggableCore_1,
-      {
-        onStart: localOnDragStart,
-        onDrag: localOnDrag,
-        onStop: localOnDragStop,
-        handle: draggableHandle,
-        cancel: ".react-resizable-handle" + (draggableCancel ? "," + draggableCancel : ""),
-        scale: transformScale,
-        nodeRef: wrapperRef,
-        onMouseDown,
-        ...others,
-        children: child
-      }
-    );
-  }, [wrapperRef, transformScale, draggableHandle, draggableCancel]);
-  const classNameFinal = clsx(draggableWindowClasses.root, className, {
-    "react-draggable": true
-  });
-  const styleFinal = {
-    ...style,
-    ...setTransform(currentState),
-    zIndex: MAP_ZINDEX_OVER_MAP$1,
-    prop2: 1,
-    backgroundColor: "gray"
-  };
-  const memoChildren = useMemo(() => {
-    return children;
-  }, [children]);
-  const wrapperRoot = /* @__PURE__ */ jsx(WrapperWindowRoot, {
-    className: classNameFinal,
-    ref: wrapperRef,
-    style: styleFinal,
-    role: "none",
-    children: memoChildren
-  });
-  const dragResizeWindow = mixinDraggable(mixinResizable(wrapperRoot, currentState));
-  return /* @__PURE__ */ jsx(React__default.Fragment, {
-    children: dragResizeWindow
-  });
-});
-export {
-  DragResizeWindow as D,
-  draggableWindowClasses as d
-};

package/components/DynamicFilter/classes/index.d.ts

@@ -1,5 +0,0 @@
-import { DynamicFilterClasses } from './types';
-import { OwnerState } from '../contexts/DynamicFilterContext/store';
-export declare const dynamicFilterClasses: DynamicFilterClasses;
-export declare const useUtilityClasses: (ownerState: OwnerState) => Record<"root" | "containerFistRow" | "filterButton" | "containerInputFilter" | "wrapperApplyedFilters" | "containerApplyedFilters" | "containerClearFilter" | "applyedFilter" | "clearFiltersButton" | "popoverMenuFields" | "popoverMenuFieldsPaper" | "popoverMenuFieldsItem" | "classesFilterButton" | "popoverFilter" | "popoverFilterPaper" | "popoverFilterHeader" | "popoverHeaderTitle" | "containerBooleanFilter" | "containerDateTimeFilter" | "containerNumberFilter" | "containerStringFilter" | "containerSelectFilter" | "classespopoverLabelMemuItem" | "popoverContainerFields" | "inputFilter", string>;
-export declare type Classes = ReturnType<typeof useUtilityClasses>;

package/components/DynamicFilter/classes/types.d.ts

@@ -1,35 +0,0 @@
-export interface DynamicFilterClasses {
-    root: string;
-    containerFistRow: string;
-    filterButton: string;
-    containerInputFilter: string;
-    wrapperApplyedFilters: string;
-    containerApplyedFilters: string;
-    containerClearFilter: string;
-    applyedFilter: string;
-    clearFiltersButton: string;
-    popoverMenuFields: string;
-    popoverMenuFieldsPaper: string;
-    popoverMenuFieldsItem: string;
-    classesFilterButton: string;
-    popoverFilter: string;
-    popoverFilterPaper: string;
-    popoverFilterHeader: string;
-    popoverHeaderTitle: string;
-    containerBooleanFilter: string;
-    containerDateTimeFilter: string;
-    containerNumberFilter: string;
-    containerStringFilter: string;
-    containerSelectFilter: string;
-    classespopoverLabelMemuItem: string;
-    popoverContainerFields: string;
-    inputFilter: string;
-    isSkeleton: string;
-    inEdition: string;
-    isInvalid: string;
-    isDirty: string;
-    isMobile: string;
-    noSetted: string;
-    isEmpty: string;
-}
-export declare type DynamicFilterClassesKey = keyof DynamicFilterClasses;

package/components/DynamicFilter/contexts/DynamicFilterContext/helpers.d.ts

@@ -1,23 +0,0 @@
-import { Field, FilterFieldApplyed, InitialFilterApplyed, RawFilterFieldApply } from '../../types';
-/**
- * @description Función formateadora filtros como el DynamicFilter los usa a nivel interno a como se guardan en las cookies
- * @param applyedFilters Filtros actualmente aplicados
- * @returns
- */
-export declare const formatToInitialFilters: (applyedFilters: Array<FilterFieldApplyed>) => Array<InitialFilterApplyed>;
-/**
- * @description Función formateadora filtros como el DynamicFilter los usa a nivel interno a como se envían a la API
- * @param appliedFilters Filtros actualmente aplicados
- * @returns
- */
-export declare const formatToRawFilter: (appliedFilters: Array<FilterFieldApplyed>) => Array<RawFilterFieldApply>;
-/**
- * @name getPurgedInitialFiltersApplyed
- * @description Función encargada de purgar cualquier error que pueda venir del endpoint, por algun cambio de versión
- *
- * @param fields todos los campos que pueden aparecer en el filtro no Inclute el AllField
- * @param initialFilters Filtros que van a ser purgados (Eliminados si tienen errores)
- * @param getFieldByName Funcion para obtener el Field a través del nombre
- * @returns Array de filtros aplicados excluyendo los que tengan errores
- */
-export declare const getPurgedInitialFiltersApplyed: (fields: Array<Field>, initialFilters: Array<InitialFilterApplyed>, getFieldByName: (name: string) => Field) => Array<FilterFieldApplyed>;

package/components/DynamicFilter/contexts/DynamicFilterContext/index.d.ts

@@ -1,18 +0,0 @@
-/// <reference types="react" />
-import { DynamicFilterProviderProps } from './types';
-declare const DynamicFilterContext: import("react").Context<(Omit<Omit<import("zustand").StoreApi<import("./store").DynamicFilterStateWithActions>, "setState"> & {
-    setState<A extends string | {
-        type: unknown;
-    }>(partial: import("./store").DynamicFilterStateWithActions | Partial<import("./store").DynamicFilterStateWithActions> | ((state: import("./store").DynamicFilterStateWithActions) => import("./store").DynamicFilterStateWithActions | Partial<import("./store").DynamicFilterStateWithActions>), replace?: boolean | undefined, action?: A | undefined): void;
-}, "setState"> & {
-    setState(nextStateOrUpdater: import("./store").DynamicFilterStateWithActions | Partial<import("./store").DynamicFilterStateWithActions> | ((state: import("immer/dist/internal").WritableDraft<import("./store").DynamicFilterStateWithActions>) => void), shouldReplace?: boolean | undefined, action?: string | {
-        type: unknown;
-    } | undefined): void;
-}) | null>;
-/**
- * @description Contexto que crea y da alcance al Store (Zustand) para ser usado desde cualquier parte del componente.
- * @param props DynamicFilterProviderProps
- * @returns Proveedor de contexto, y el contexto
- */
-declare function DynamicFilterProvider(props: DynamicFilterProviderProps): import("react/jsx-runtime").JSX.Element;
-export { DynamicFilterProvider, DynamicFilterContext };

package/components/DynamicFilter/contexts/DynamicFilterContext/types.d.ts

@@ -1,5 +0,0 @@
-import type { ReactNode } from 'react';
-import type { DynamicFilterProps } from '../../types';
-export interface DynamicFilterProviderProps extends DynamicFilterProps {
-    children: ReactNode;
-}

package/components/DynamicFilter/hooks/useDynamicFilter.d.ts

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