@m4l/components 4.0.0 → 4.1.1

package/components/DynamicFilter/subcomponents/PopoverMenuFields/usePopoverMenuFields-CsmoUVrX.js

@@ -1,29 +0,0 @@
-import { useModuleDictionary } from "@m4l/core";
-import { u as useDynamicFilterStore } from "../../store/useDynamicFilterStore-DD7gt64u.js";
-function usePopoverMenuFields() {
-  const { getLabel } = useModuleDictionary();
-  const fnAnchorEl = useDynamicFilterStore((state) => state.fnAnchorEl);
-  const { showPopoverFilterForAdd, closePopoverMenuFields } = useDynamicFilterStore(
-    (state) => state.actions
-  );
-  function handleOpenPopUpClickItem(_event, field) {
-    if (fnAnchorEl) {
-      showPopoverFilterForAdd(fnAnchorEl(), field);
-    }
-  }
-  function handleClosePopover() {
-    closePopoverMenuFields(false);
-  }
-  function getItemLabel(field) {
-    return field.label ?? getLabel(field.dictionaryId);
-  }
-  return {
-    fnAnchorEl,
-    getItemLabel,
-    handleClosePopover,
-    handleOpenPopUpClickItem
-  };
-}
-export {
-  usePopoverMenuFields as u
-};

package/components/FieldLabel/FieldLabel-B85v09Pe.js

@@ -1,36 +0,0 @@
-import { jsx, jsxs, Fragment } from "react/jsx-runtime";
-import { useEnvironment, useModuleSkeleton } from "@m4l/core";
-import { F as FieldLabelRoot } from "./styles-D7QEXOIM.js";
-import { u as useUtilityClasses } from "./classes/index-CqpbNDZs.js";
-import { Tooltip, Skeleton } from "@mui/material";
-import clsx from "clsx";
-import { T as Typography } from "../mui_extended/Typography/Typography-C_rG8K21.js";
-import { I as Icon } from "../Icon/Icon-_wceDYwV.js";
-const FieldLabel = (props) => {
-  const {
-    helperMessage: message,
-    label,
-    mandatory,
-    mandatoryMessage,
-    htmlFor,
-    className,
-    id
-  } = props;
-  const { host_static_assets, environment_assets } = useEnvironment();
-  const classes = useUtilityClasses();
-  const isSkeleton = useModuleSkeleton();
-  return /* @__PURE__ */ jsx(FieldLabelRoot, { htmlFor, className: clsx(classes.root, className), id, children: !isSkeleton ? /* @__PURE__ */ jsxs(Fragment, { children: [
-    /* @__PURE__ */ jsx(Typography, { variant: "body", className: classes.label, children: label }),
-    mandatory && /* @__PURE__ */ jsx(Typography, { variant: "body", className: classes.mandatory, children: mandatoryMessage ? `(${mandatoryMessage})` : "*" }),
-    message && /* @__PURE__ */ jsx(Tooltip, { title: message, className: classes.tooltip, children: /* @__PURE__ */ jsx("div", { className: classes.containerIcon, children: /* @__PURE__ */ jsx(
-      Icon,
-      {
-        className: classes.tooltipIcon,
-        src: `${host_static_assets}/${environment_assets}/frontend/components/LabelMessage/assets/icons/information.svg`
-      }
-    ) }) })
-  ] }) : /* @__PURE__ */ jsx(Skeleton, { variant: "text", width: "30%", height: "14px" }) });
-};
-export {
-  FieldLabel as F
-};

package/components/FieldLabel/classes/constants-dhh5xNOX.js

@@ -1,4 +0,0 @@
-const componentName = "M4LFieldLabel";
-export {
-  componentName as c
-};

package/components/FieldLabel/classes/index-CqpbNDZs.js

@@ -1,31 +0,0 @@
-import { generateUtilityClasses } from "@mui/material";
-import { unstable_composeClasses } from "@mui/base";
-import { c as componentName } from "./constants-dhh5xNOX.js";
-import { g as getComponentUtilityClass } from "../../../utils/index-WXiWKKyo.js";
-generateUtilityClasses(componentName, [
-  /* elements */
-  "root",
-  "label",
-  "tooltip",
-  "tooltipIcon",
-  "containerIcon",
-  "mandatory"
-  /* states or variants of elements */
-]);
-const useUtilityClasses = () => {
-  const slots = {
-    root: ["root"],
-    label: ["label"],
-    tooltip: ["tooltip"],
-    tooltipIcon: ["tooltipIcon"],
-    containerIcon: ["containerIcon"],
-    mandatory: ["mandatory"]
-  };
-  const composedClasses = unstable_composeClasses(slots, getComponentUtilityClass(componentName), {});
-  return {
-    ...composedClasses
-  };
-};
-export {
-  useUtilityClasses as u
-};

package/components/FieldLabel/index-l0sNRNKZ.js

@@ -1 +0,0 @@
-

package/components/FieldLabel/styles-D7QEXOIM.js

@@ -1,7 +0,0 @@
-import { styled } from "@mui/material";
-const FieldLabelRoot = styled("label")(({ theme }) => ({
-  ...theme.components?.M4LFieldLabel?.styleOverrides
-}));
-export {
-  FieldLabelRoot as F
-};

package/components/GridLayout/GridLayout-CYwAPA42.js

@@ -1,534 +0,0 @@
-import { jsx, jsxs } from "react/jsx-runtime";
-import { useState, useRef, useEffect, useCallback } from "react";
-import clsx from "clsx";
-import { i as isEqualLayout, c as cloneLayout, g as getLayoutItem, a as cloneLayoutItem, b as getLayoutItemH, m as moveElement, d as compact, w as withLayoutItem, e as bottom, n as noop, f as getAllCollisions } from "./utils-CF3BArf2.js";
-import { M as MemonizedGridItem } from "./subcomponents/GridItem/index-B2wGJ3pz.js";
-import { G as GridLayoutRoot } from "./styles-BqM7s5fd.js";
-import { D as DEFAULT_COLS, a as DEFAULT_CONTAINER_PADDING, b as DEFAULT_MARGIN, c as DEFAULT_ROW_HEIGHT, d as DEFAULT_COLAPSED_HEIGHT, e as DEFAULT_CONTAINER_WIDTH, f as DEFAULT_CONTAINER_HEIGHT, g as DEFAULT_TRANSFORM_SCALE } from "./constants-BOQgOrZA.js";
-import { g as gridLayoutClasses } from "./classes/index-qNqBA3Jg.js";
-function GridLayout(props) {
-  const {
-    layoutItemRender,
-    innerRef,
-    //Referencia requerida por el provedor WidthProvider para detectar los cambios de tamaño
-    autoSize = true,
-    cols = DEFAULT_COLS,
-    containerPadding = DEFAULT_CONTAINER_PADDING,
-    margin = DEFAULT_MARGIN,
-    rowHeight = DEFAULT_ROW_HEIGHT,
-    colapsedHeight = DEFAULT_COLAPSED_HEIGHT,
-    containerWidth = DEFAULT_CONTAINER_WIDTH,
-    containerHeight = DEFAULT_CONTAINER_HEIGHT,
-    transformScale = DEFAULT_TRANSFORM_SCALE,
-    className = "",
-    style = {},
-    draggableHandle = "",
-    draggableCancel = "",
-    maxRows = Infinity,
-    // infinite vertical growth
-    layout = [],
-    isBounded = false,
-    isDraggable = true,
-    isResizable = true,
-    allowOverlap = false,
-    useCSSTransforms = true,
-    compactType = "vertical",
-    preventCollision = false,
-    resizeHandles = ["se"],
-    resizeHandle,
-    maximizeId,
-    onLayoutChange = noop,
-    onDragStart = noop,
-    onDrag = noop,
-    onDragStop = noop,
-    onResizeStart = noop,
-    onResize = noop,
-    onResizeStop = noop
-  } = props;
-  const [currentState, setCurrentState] = useState({
-    mounted: false
-  });
-  const [nrOnlayoutChanges, setNrOnlayoutChanges] = useState(0);
-  const [finalLayoutRender, setFinalLayoutRender] = useState(layout);
-  const [zIndexes, setzIndexes] = useState(() => {
-    return layout.filter((li) => li.freeMove).map((lmap) => lmap.i);
-  });
-  const refState = useRef({
-    layout,
-    oldDragItem: void 0,
-    oldLayout: void 0,
-    oldResizeItem: void 0,
-    zIndexes,
-    colapsedHeight,
-    rowHeight
-  });
-  refState.current.colapsedHeight = colapsedHeight;
-  refState.current.rowHeight = rowHeight;
-  useEffect(() => {
-    setCurrentState({ mounted: true });
-  }, []);
-  useEffect(() => {
-    if (nrOnlayoutChanges > 0) {
-      onLayoutChange(refState.current.layout);
-    }
-  }, [nrOnlayoutChanges]);
-  useEffect(() => {
-    if (!isEqualLayout(finalLayoutRender, layout)) {
-      const newLayout = cloneLayout(layout);
-      const newzIndexes = [...zIndexes];
-      for (let index = 0; index < newLayout.length; index++) {
-        const li = newLayout[index];
-        if (li.freeMove && newzIndexes.indexOf(li.i) === -1) {
-          newzIndexes.push(li.i);
-        }
-      }
-      refState.current.layout = newLayout;
-      setFinalLayoutRender(newLayout);
-      if (newzIndexes.length !== zIndexes.length) {
-        setzIndexes(newzIndexes);
-        refState.current.zIndexes = newzIndexes;
-      }
-    }
-  }, [layout]);
-  const onLayoutMaybeChanged = useCallback((newLayout, oldLayout) => {
-    if (!oldLayout) {
-      oldLayout = refState.current.layout;
-    }
-    if (!isEqualLayout(oldLayout, newLayout)) {
-      setNrOnlayoutChanges((prev) => prev + 1);
-    }
-  }, []);
-  const localOnDragStart = useCallback(
-    (i, _x, _y, gridDragEvent) => {
-      const { layout: layout2 } = refState.current;
-      const { e, node } = gridDragEvent;
-      const li = getLayoutItem(layout2, i);
-      if (!li) return;
-      refState.current = {
-        ...refState.current,
-        oldDragItem: cloneLayoutItem(li),
-        oldLayout: layout2
-        //Punto de arranque, layout actual
-      };
-      if (li && li.freeMove) {
-        onClickSetOnTopFreeMove(li.i, "onDragStart");
-      }
-      if (gridDragEvent.e.type !== "touchmove") {
-        gridDragEvent.e.preventDefault();
-      }
-      gridDragEvent.e.stopPropagation();
-      return onDragStart(layout2, li, li, void 0, e, node);
-    },
-    []
-  );
-  const localOnDrag = useCallback(
-    (i, x, y, gridDragEvent) => {
-      const { oldDragItem, layout: layout2 } = refState.current;
-      const { e, node } = gridDragEvent;
-      const li = getLayoutItem(layout2, i);
-      if (!li) return;
-      const newPlaceholder = {
-        w: li.w,
-        h: getLayoutItemH(li, refState.current.colapsedHeight, refState.current.rowHeight),
-        x: li.x,
-        y: li.y,
-        placeholder: true,
-        i
-      };
-      const isUserAction = true;
-      try {
-        let newLayout;
-        if (!li.freeMove) {
-          newLayout = moveElement(
-            layout2,
-            li,
-            x,
-            y,
-            isUserAction,
-            preventCollision,
-            compactType,
-            cols,
-            refState.current.colapsedHeight,
-            refState.current.rowHeight,
-            allowOverlap
-          );
-        } else {
-          li.x = x;
-          li.y = y;
-          newPlaceholder.x = x;
-          newPlaceholder.y = y;
-          newLayout = cloneLayout(layout2);
-        }
-        const finalLayout = allowOverlap || li.freeMove ? newLayout : compact(
-          newLayout,
-          compactType,
-          cols,
-          refState.current.colapsedHeight,
-          refState.current.rowHeight,
-          allowOverlap
-        );
-        refState.current = {
-          ...refState.current,
-          layout: finalLayout,
-          activeDrag: newPlaceholder
-        };
-        setCurrentState((prev) => ({
-          ...prev,
-          activeDrag: newPlaceholder
-        }));
-        setFinalLayoutRender(finalLayout);
-        if (gridDragEvent.e.type !== "touchmove") {
-          gridDragEvent.e.preventDefault();
-        }
-        gridDragEvent.e.stopPropagation();
-        onDrag(newLayout, oldDragItem, li, newPlaceholder, e, node);
-      } catch (error) {
-        console.warn("GridLayout error capturado");
-      }
-    },
-    []
-  );
-  const localOnDragStop = useCallback(
-    (i, x, y, { e, node }) => {
-      if (!refState.current.activeDrag) {
-        return;
-      }
-      const { oldDragItem, layout: layout2, oldLayout } = refState.current;
-      const li = getLayoutItem(layout2, i);
-      if (!li) return;
-      let newLayout;
-      const isUserAction = true;
-      if (!li.freeMove) {
-        newLayout = moveElement(
-          layout2,
-          li,
-          x,
-          y,
-          isUserAction,
-          preventCollision,
-          compactType,
-          cols,
-          refState.current.colapsedHeight,
-          refState.current.rowHeight,
-          allowOverlap
-        );
-      } else {
-        li.x = x;
-        li.y = y;
-        newLayout = cloneLayout(layout2);
-      }
-      const finalLayout = allowOverlap ? newLayout || li.freeMove : compact(
-        newLayout,
-        compactType,
-        cols,
-        refState.current.colapsedHeight,
-        refState.current.rowHeight,
-        allowOverlap
-      );
-      setCurrentState((prev) => ({
-        ...prev,
-        activeDrag: void 0
-      }));
-      setFinalLayoutRender(finalLayout);
-      refState.current = {
-        ...refState.current,
-        layout: finalLayout,
-        oldDragItem: void 0,
-        oldLayout: void 0,
-        activeDrag: void 0
-      };
-      if (e.type !== "touchmove") {
-        e.preventDefault();
-      }
-      e.stopPropagation();
-      onLayoutMaybeChanged(finalLayout, oldLayout);
-      onDragStop(layout2, oldDragItem, li, void 0, e, node);
-    },
-    []
-  );
-  const localOnResizeStart = useCallback(
-    (i, _w, _h, { e, node }) => {
-      const { layout: layout2 } = refState.current;
-      const li = getLayoutItem(layout2, i);
-      if (!li) return;
-      refState.current = {
-        ...refState.current,
-        oldResizeItem: cloneLayoutItem(li),
-        oldLayout: refState.current.layout
-        //Punto de arranque, layout actual
-      };
-      onResizeStart(layout2, li, li, void 0, e, node);
-      if (li && li.freeMove) {
-        onClickSetOnTopFreeMove(li.i, "onResizeStart");
-      }
-    },
-    []
-  );
-  const localOnResize = useCallback(
-    (i, w, h, { e, node }) => {
-      const { layout: layout2, oldResizeItem } = refState.current;
-      let newLayout;
-      let li;
-      if (!oldResizeItem?.freeMove) {
-        const cb = (cbLi) => {
-          let hasCollisions;
-          if (preventCollision && !allowOverlap) {
-            const collisions = getAllCollisions(
-              layout2,
-              { ...cbLi, w, h },
-              refState.current.colapsedHeight,
-              refState.current.rowHeight
-            ).filter((layoutItem) => layoutItem.i !== cbLi.i);
-            hasCollisions = collisions.length > 0;
-            if (hasCollisions) {
-              let leastX = Infinity, leastY = Infinity;
-              collisions.forEach((layoutItem) => {
-                if (layoutItem.x > cbLi.x) leastX = Math.min(leastX, layoutItem.x);
-                if (layoutItem.y > cbLi.y) leastY = Math.min(leastY, layoutItem.y);
-              });
-              if (Number.isFinite(leastX)) cbLi.w = leastX - cbLi.x;
-              if (Number.isFinite(leastY)) cbLi.h = leastY - cbLi.y;
-            }
-          }
-          if (!hasCollisions) {
-            cbLi.w = w;
-            cbLi.h = h;
-          }
-          return cbLi;
-        };
-        const [tempLayout, tempLi] = withLayoutItem(cloneLayout(layout2), i, cb);
-        newLayout = tempLayout;
-        li = tempLi;
-      } else {
-        newLayout = cloneLayout(layout2);
-        li = getLayoutItem(newLayout, i);
-        if (li) {
-          li.w = w;
-          li.h = h;
-        }
-      }
-      if (!li) return;
-      const newPlaceholder = {
-        w: li.w,
-        h: li.h,
-        x: li.x,
-        y: li.y,
-        static: true,
-        i
-      };
-      try {
-        const finalLayout = allowOverlap || li.freeMove ? newLayout : compact(
-          newLayout,
-          compactType,
-          cols,
-          refState.current.colapsedHeight,
-          refState.current.rowHeight,
-          allowOverlap
-        );
-        refState.current = {
-          ...refState.current,
-          layout: finalLayout,
-          activeDrag: newPlaceholder
-        };
-        setFinalLayoutRender(finalLayout);
-        setCurrentState((prev) => ({ ...prev, activeDrag: newPlaceholder }));
-        onResize(newLayout, oldResizeItem, li, newPlaceholder, e, node);
-      } catch (error) {
-      }
-      if (e.type !== "touchmove") {
-        e.preventDefault();
-      }
-      e.stopPropagation();
-    },
-    []
-  );
-  const localOnResizeStop = useCallback(
-    (i, _w, _h, { e, node }) => {
-      if (!refState.current.activeDrag) {
-        return;
-      }
-      const { layout: layout2, oldResizeItem, oldLayout } = refState.current;
-      const l = getLayoutItem(layout2, i);
-      refState.current = {
-        ...refState.current,
-        // layout: finalLayout,
-        oldResizeItem: void 0,
-        oldLayout: void 0,
-        activeDrag: void 0
-      };
-      setCurrentState((prev) => ({ ...prev, activeDrag: void 0 }));
-      onLayoutMaybeChanged(layout2, oldLayout);
-      if (l) {
-        onResizeStop(layout2, oldResizeItem, l, void 0, e, node);
-      }
-    },
-    []
-  );
-  const onClickSetOnTopFreeMove = useCallback((i, _source) => {
-    const { layout: layout2 } = refState.current;
-    const index = refState.current.zIndexes.indexOf(i);
-    const l = getLayoutItem(layout2, i);
-    if (l && l?.freeMove) {
-      if (index !== refState.current.zIndexes.length - 1 || index === -1) {
-        const newIndexes = [...refState.current.zIndexes];
-        if (index !== -1) {
-          newIndexes.splice(index, 1);
-        }
-        newIndexes.push(i);
-        refState.current.zIndexes = newIndexes;
-        setzIndexes(newIndexes);
-      }
-    }
-  }, []);
-  const placeholder = () => {
-    const { activeDrag } = currentState;
-    if (!activeDrag) return null;
-    return /* @__PURE__ */ jsx(
-      MemonizedGridItem,
-      {
-        type: "placeholder",
-        layoutItemRender,
-        w: activeDrag.w,
-        h: activeDrag.h,
-        x: activeDrag.x,
-        y: activeDrag.y,
-        i: activeDrag.i,
-        className: gridLayoutClasses.gridItemPlaceholder,
-        containerWidth,
-        containerHeight,
-        cols,
-        margin,
-        containerPadding,
-        maxRows,
-        rowHeight,
-        isDraggable: false,
-        isResizable: false,
-        isBounded: false,
-        useCSSTransforms,
-        transformScale,
-        draggableCancel: "",
-        draggableHandle: "",
-        minW: 0,
-        maxW: 0,
-        minH: 0,
-        maxH: 0,
-        maximize: "none",
-        colapsed: activeDrag.colapsed,
-        colapsedHeight
-      }
-    );
-  };
-  const processGridItem = useCallback(
-    (l, isMounted) => {
-      const draggable = typeof l.isDraggable === "boolean" ? l.isDraggable : !l.static && isDraggable;
-      const resizable = typeof l.isResizable === "boolean" ? l.isResizable : !l.static && isResizable;
-      const resizeHandlesOptions = l.resizeHandles || resizeHandles;
-      const bounded = draggable && isBounded && l.isBounded !== false;
-      const mximize = maximizeId ? maximizeId === l.i ? "maximize_me" : "maximize_other" : "none";
-      let zIndex = void 0;
-      let style2;
-      if (l.freeMove) {
-        zIndex = zIndexes.indexOf(l.i);
-        if (zIndex !== -1) {
-          zIndex = zIndex + 1;
-          style2 = { zIndex };
-        }
-      }
-      return /* @__PURE__ */ jsx(
-        MemonizedGridItem,
-        {
-          type: "layoutItem",
-          layoutItemRender,
-          containerWidth,
-          containerHeight,
-          cols,
-          margin,
-          containerPadding: containerPadding || margin,
-          maxRows,
-          rowHeight,
-          draggableCancel,
-          draggableHandle,
-          onDragStart: localOnDragStart,
-          onDrag: localOnDrag,
-          onDragStop: localOnDragStop,
-          onResizeStart: localOnResizeStart,
-          onResize: localOnResize,
-          onResizeStop: localOnResizeStop,
-          onFreeMoveClick: l.freeMove ? onClickSetOnTopFreeMove : void 0,
-          isDraggable: draggable,
-          isResizable: resizable,
-          isBounded: bounded,
-          useCSSTransforms: useCSSTransforms && isMounted,
-          usePercentages: !isMounted,
-          transformScale,
-          w: l.w,
-          h: l.h,
-          x: l.x,
-          y: l.y,
-          i: l.i,
-          minH: l.minH,
-          minW: l.minW,
-          maxH: l.maxH,
-          maxW: l.maxW,
-          static: l.static,
-          resizeHandles: resizeHandlesOptions,
-          resizeHandle,
-          maximize: mximize,
-          freeMove: l.freeMove,
-          colapsed: l.colapsed,
-          visible: l.visible,
-          colapsedHeight,
-          style: style2
-        },
-        l.i
-      );
-    },
-    [
-      containerWidth,
-      containerHeight,
-      cols,
-      margin,
-      containerPadding,
-      maxRows,
-      rowHeight,
-      draggableCancel,
-      draggableHandle,
-      isDraggable,
-      isResizable,
-      isBounded,
-      useCSSTransforms,
-      transformScale,
-      resizeHandles,
-      resizeHandle,
-      maximizeId,
-      zIndexes,
-      colapsedHeight,
-      rowHeight
-    ]
-  );
-  const containerAutoSizeHeight = useCallback(() => {
-    if (!autoSize) return;
-    const nbRow = bottom(finalLayoutRender, colapsedHeight, rowHeight);
-    const containerPaddingY = containerPadding ? containerPadding[1] : margin[1];
-    return nbRow * rowHeight + (nbRow - 1) * margin[1] + containerPaddingY * 2 + "px";
-  }, [autoSize, containerPadding, margin, finalLayoutRender, colapsedHeight]);
-  const mergedStyle = {
-    height: containerAutoSizeHeight(),
-    ...style
-  };
-  return /* @__PURE__ */ jsxs(
-    GridLayoutRoot,
-    {
-      className: clsx(gridLayoutClasses.root, className),
-      style: mergedStyle,
-      ref: innerRef,
-      children: [
-        finalLayoutRender.map((li) => processGridItem(li, !!currentState.mounted)),
-        placeholder()
-      ]
-    }
-  );
-}
-export {
-  GridLayout as G
-};