@m4l/components 3.1.9 → 4.0.0

package/components/DragResizeWindow/DragResizeWindow-Z2CHiH4f.js

@@ -0,0 +1,429 @@
+import { jsx } from "react/jsx-runtime";
+import React__default, { forwardRef, useState, useRef, useCallback, useEffect, useMemo } from "react";
+import { D as DraggableCore_1 } from "../../react-draggable-lPKOvvDX.js";
+import clsx from "clsx";
+import { W as WrapperDragResizeWindowRoot } from "./styled-UWXrBRaK.js";
+import { d as draggableWindowClasses } from "./classes/index-0-6CStrp.js";
+import { D as DEFAULT_TRANSFORM_SCALE } from "./constants-DwokrcI4.js";
+import { s as setTransform } from "./utils-DECvGPap.js";
+import { R as Resizable } from "../../react-resizable-Dpx4PV2R.js";
+import { useForkRef } from "@mui/material";
+import { g as getInitialSize } from "./helpers/index-3o_XEYfS.js";
+const DragResizeWindow = forwardRef((props, ref) => {
+  const {
+    //Comunes
+    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,
+    //Draggable
+    draggableHandle = `.${draggableWindowClasses.draggableHandle}`,
+    draggableCancel = `.${draggableWindowClasses.draggableCancel}`,
+    draggable = true,
+    onDragStart,
+    onDrag,
+    onDragStop,
+    onMouseDown,
+    //ResizeAble
+    resizeable = true,
+    resizeHandles = ["se", "nw"],
+    resizeHandle,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    onResizeStart,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    onResize,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    onResizeStop,
+    hidden,
+    //Otras
+    ...others
+  } = props;
+  const [currentState, setCurrentState] = useState(
+    getInitialSize(containerSize, defaultPosition)
+  );
+  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
+  });
+  const wrapperRef = useRef(null);
+  const handleAllRefs = useForkRef(wrapperRef, ref);
+  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,
+      //Cancelar los flags de memoria de encogimiento del contenedor padre
+      shrinkTopAt: void 0,
+      //Cancelar los flags de memoria de encogimiento del contenedor padre
+      overflowWidthAt: void 0,
+      //Cancelar los flags de memoria de encogimiento del contenedor padre
+      overflowHeightAt: void 0,
+      //Cancelar los flags de memoria de encogimiento del contenedor padre
+      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;
+      }
+    }
+    const top = stateRef.current.dragging.top + deltaY;
+    const 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];
+      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,
+          //Cancelar los flags de memoria de encogimiento del contenedor padre
+          shrinkTopAt: void 0,
+          //Cancelar los flags de memoria de encogimiento del contenedor padre
+          overflowWidthAt: void 0,
+          //Cancelar los flags de memoria de encogimiento del contenedor padre
+          overflowHeightAt: void 0
+          //Cancelar los flags de memoria de encogimiento del contenedor padre
+        } : {},
+        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;
+      const 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 {
+                newState[leftTop] = boundsLefTop;
+                newState[lDimension] = stateRef.current.initialPostion[lDimension];
+              }
+            } else if (dif < 0) {
+              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) {
+        const 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": draggable,
+    //Requerido para el componente Draggable
+    [draggableWindowClasses.hidden]: hidden
+    // dropping: Boolean(droppingPosition),
+  });
+  const styleFinal = {
+    ...style,
+    ...setTransform(currentState),
+    prop2: 1
+  };
+  const memoChildren = useMemo(() => {
+    return children;
+  }, [children]);
+  const wrapperRoot = /* @__PURE__ */ jsx(
+    WrapperDragResizeWindowRoot,
+    {
+      className: classNameFinal,
+      ref: handleAllRefs,
+      style: styleFinal,
+      role: "none",
+      children: memoChildren
+    }
+  );
+  const dragResizeWindow = mixinDraggable(mixinResizable(wrapperRoot, currentState));
+  return /* @__PURE__ */ jsx(React__default.Fragment, { children: dragResizeWindow });
+});
+export {
+  DragResizeWindow as D
+};

package/components/DragResizeWindow/DragResizeWindow.d.ts

@@ -13,7 +13,7 @@ import type { DraggableWindowProps } from './types';
  *     Por lo tanto todo el estilo, va directamente a WrapperWindowRoot.
  * Consideraciones:
  *
-
+
  * @param props
  * @returns
  */

package/components/DragResizeWindow/classes/index-0-6CStrp.js

@@ -0,0 +1,18 @@
+import { generateUtilityClasses } from "@mui/material";
+import "@mui/base";
+import { C as COMPONENT_CLASS_NAME } from "../constants-DwokrcI4.js";
+const draggableWindowClasses = generateUtilityClasses(
+  COMPONENT_CLASS_NAME,
+  [
+    /* elements */
+    "root",
+    "draggableHandle",
+    "draggableCancel",
+    // state
+    "dragging",
+    "hidden"
+  ]
+);
+export {
+  draggableWindowClasses as d
+};

package/components/DragResizeWindow/constants-DwokrcI4.js

@@ -0,0 +1,6 @@
+const COMPONENT_CLASS_NAME = "M4LDraggableWindow";
+const DEFAULT_TRANSFORM_SCALE = 1;
+export {
+  COMPONENT_CLASS_NAME as C,
+  DEFAULT_TRANSFORM_SCALE as D
+};

package/components/DragResizeWindow/helpers/index-3o_XEYfS.js

@@ -0,0 +1,40 @@
+const getInitialSize = (containerSize, defaultPosition) => {
+  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;
+  }
+  console.log("containerSize", containerSize);
+  const containerHeight = containerSize?.containerHeight || 200;
+  const containerWidth = containerSize?.containerWidth || 200;
+  return {
+    top: top ?? (bottom ? containerHeight - bottom - (height || 0) : 0),
+    height: height ?? containerHeight - (top || 0) - (bottom || 0),
+    // 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)
+  };
+};
+export {
+  getInitialSize as g
+};

package/components/DragResizeWindow/index-l0sNRNKZ.js

@@ -0,0 +1 @@
+

package/components/DragResizeWindow/styled-UWXrBRaK.js

@@ -0,0 +1,18 @@
+import { styled } from "@mui/material";
+const WrapperDragResizeWindowRoot = styled("div")`
+  position: absolute;
+  left: 0px;
+  top: 0px;
+  background-color: gray;
+  prop2: 1;
+
+  &.M4LDraggableWindow-hidden {
+    visibility: hidden;
+    pointerevents: none;
+  }
+
+  ${(props) => props.theme.components?.M4LDragResizeWindow?.styleOverrides}
+`;
+export {
+  WrapperDragResizeWindowRoot as W
+};

package/components/DragResizeWindow/utils-DECvGPap.js

@@ -0,0 +1,17 @@
+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
+  };
+}
+export {
+  setTransform as s
+};

package/components/DynamicFilter/DynamicFilter-vZR24GvS.js

@@ -0,0 +1,14 @@
+import { jsx } from "react/jsx-runtime";
+import { useFlagsPresent, CommonFlags } from "@m4l/core";
+import { D as DynamicFilterProvider } from "./store/DynamicFilterContext-CS7_IuRy.js";
+import { D as DynamicFilterBase } from "./subcomponents/DynamicFilterBase/DynamicFilterBase-C5n2TZpu.js";
+function DynamicFilter(props) {
+  const hasPresentFlags = useFlagsPresent([CommonFlags.FLAG_DICTIONARY_LOADED]);
+  if (!hasPresentFlags) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(DynamicFilterProvider, { ...props, children: /* @__PURE__ */ jsx(DynamicFilterBase, {}) });
+}
+export {
+  DynamicFilter as D
+};

package/components/DynamicFilter/constants-ByqmFATV.js

@@ -0,0 +1,31 @@
+const DYNAMIC_FILTER_KEY_COMPONENT = "M4LDynamicFilter";
+const ALL_FIELD = {
+  name: "all",
+  dictionaryId: "dynamic_filter.all_fields",
+  urlIcon: "",
+  type: "string",
+  multiple: true,
+  presence: "optional"
+};
+const STRING_OPERATORS = ["c", "nc"];
+const NUMBER_OPERATORS = ["b", "e", "ne", "gt", "gte", "lt", "lte"];
+const BOOLEAN_OPERATORS = ["e", "ne"];
+const SELECT_OPERATORS = ["in", "nin"];
+const DATE_TIME_OPERATORS = [
+  "b",
+  "e",
+  "ne",
+  "gt",
+  "gte",
+  "lt",
+  "lte"
+];
+export {
+  ALL_FIELD as A,
+  BOOLEAN_OPERATORS as B,
+  DYNAMIC_FILTER_KEY_COMPONENT as D,
+  NUMBER_OPERATORS as N,
+  SELECT_OPERATORS as S,
+  DATE_TIME_OPERATORS as a,
+  STRING_OPERATORS as b
+};

package/components/DynamicFilter/dictionary-CNZO5wD-.js

@@ -0,0 +1,51 @@
+import { g as getCommonActionsDictionary } from "../CommonActions/dictionary-YlCVMypc.js";
+import { g as getRHFAutocompleteComponentsDictionary } from "../hook-form/RHFAutocomplete/dictionary-C5ATeyRM.js";
+const DYNAMIC_FILTER_DICTIONARY_ID = "dynamic_filter";
+function getDynamicFilterComponentsDictionary() {
+  return [DYNAMIC_FILTER_DICTIONARY_ID].concat(
+    getCommonActionsDictionary().concat(getRHFAutocompleteComponentsDictionary())
+  );
+}
+const DICCTIONARY = {
+  input_placeholder: "input_placeholder",
+  operand_true: "operand_true",
+  operand_false: "operand_false",
+  filter_tooltip_refresh: "filter_tooltip_refresh",
+  filter_tooltip_dirty: "filter_tooltip_dirty",
+  filter_tooltip_invalid: "filter_tooltip_invalid",
+  operator_b: "operator_b",
+  operator_e: "operator_e",
+  operator_ne: "operator_ne",
+  operator_gt: "operator_gt",
+  operator_gte: "operator_gte",
+  operator_lt: "operator_lt",
+  operator_lte: "operator_lte",
+  operator_c: "operator_c",
+  operator_nc: "operator_nc",
+  operator_in: "operator_in",
+  operator_nin: "operator_nin",
+  label_boolean_operator: "label_boolean_operator",
+  label_boolean_operand1: "label_boolean_operand1",
+  label_operator_date_time: "label_operator_date_time",
+  label_operand1_date_time: "label_operand1_date_time",
+  label_operand2_date_time: "label_operand2_date_time",
+  label_operator_number: "label_operator_number",
+  label_operand1_number: "label_operand1_number",
+  label_operand2_number: "label_operand2_number",
+  label_operator_string: "label_operator_string",
+  label_operand1_string: "label_operand1_string",
+  operator_required: "operator_required",
+  error_invalid_date: "error_invalid_date",
+  error_less_than_start: "error_less_than_start",
+  label_select_operator: "label_select_operator",
+  label_select_operands_array: "label_select_operands_array",
+  error_operand_required: "error_operand_required"
+};
+const getDynamicFilterDictionary = (key) => {
+  return `${DYNAMIC_FILTER_DICTIONARY_ID}.${key}`;
+};
+export {
+  DICCTIONARY as D,
+  getDynamicFilterComponentsDictionary as a,
+  getDynamicFilterDictionary as g
+};

package/components/DynamicFilter/helpers/formatToInitialFilters-zMnd3Z8B.js

@@ -0,0 +1,31 @@
+import { f as filterValidOperandsArraySelect } from "../subcomponents/FieldTypes/SelectFilter/helpers-jwqBQ3NZ.js";
+function formatToInitialFilters(appliedFilters) {
+  return appliedFilters.map((appliedFilter) => {
+    const ret = {
+      name: appliedFilter.field.name,
+      operator: appliedFilter.operator,
+      operand1: appliedFilter.operand1,
+      operand2: appliedFilter.operator === "b" ? appliedFilter.operand2 : void 0
+    };
+    if (appliedFilter.fieldType === "datetime") {
+      ret.operand1 = appliedFilter.operand1.toISOString();
+      ret.operand2 = appliedFilter.operator === "b" ? appliedFilter.operand2.toISOString() : void 0;
+    }
+    if (appliedFilter.fieldType === "select") {
+      const validOperandsArray = filterValidOperandsArraySelect(
+        appliedFilter.operandsArray,
+        appliedFilter.field
+      );
+      if (validOperandsArray && validOperandsArray?.length > 0) {
+        ret.operandsArray = validOperandsArray;
+      }
+    }
+    if (ret.operand2 === void 0) {
+      delete ret.operand2;
+    }
+    return ret;
+  });
+}
+export {
+  formatToInitialFilters as f
+};