@m4l/components 3.1.9 → 4.0.0

package/components/maps/components/Map/subcomponents/Controls/subcomponents/TopLeftTools/subcomponents/PopoverToolButton/subcomponentes/MapSourcesTool/sourceTypes/utils-_uVZP84b.js

@@ -0,0 +1,19 @@
+function toQuadKey(x, y, z) {
+  let quadKey = "";
+  for (let i = z; i > 0; i--) {
+    let digit = 0;
+    const mask = 1 << i - 1;
+    if ((x & mask) !== 0) {
+      digit++;
+    }
+    if ((y & mask) !== 0) {
+      digit++;
+      digit++;
+    }
+    quadKey += digit.toString();
+  }
+  return quadKey;
+}
+export {
+  toQuadKey as t
+};

package/components/maps/components/Map/subcomponents/Controls/subcomponents/TopRigthTools/index-B32XOyuj.js

@@ -0,0 +1,101 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { useEnvironment, useModuleDictionary } from "@m4l/core";
+import { useMap } from "react-leaflet";
+import { shallow } from "zustand/shallow";
+import { C as Control } from "../../../../external/Control/index-B9L3AeDC.js";
+import { M as MeasureTool } from "./subcomponents/MeasureTool/index-DNg8v3Sm.js";
+import { Z as ZoomButtons } from "./subcomponents/ZoomButtons/index-CFr3XeB5.js";
+import { M as MAP_ICONS } from "../../../../icons-CSYh7uR4.js";
+import { M as MAP_DICCTIONARY } from "../../../../dictionary-BNALtcTf.js";
+import { m as mapClasses } from "../../../../classes/index-DHIpfj2O.js";
+import { G as GPS_TOOLS_POPUP_ID, c as GPS_TOOLS_POPUP_DEFAULT_POSITION, d as MESURE_POPUP_DEFAULT_POSITION } from "../../../../constants-B0E5r9Iy.js";
+import { u as usePopupsStore } from "../../../../../../../popups/components/PopupsProvider/hooks/usePopupsStore/index-DBMhBXk-.js";
+import { T as ToggleIconButton } from "../../../../../../../mui_extended/ToggleIconButton/ToggleIconButton-BgjBFujZ.js";
+function TopRightTools(props) {
+  const { gpsTools } = props;
+  const { addPopup, closePopup } = usePopupsStore((state) => state.popupsActions);
+  const { host_static_assets, environment_assets } = useEnvironment();
+  const { getLabel } = useModuleDictionary();
+  const openPopupsIds = usePopupsStore(
+    (state) => state.popupsIds.filter((pId) => {
+      return state.hashPopups[pId].status === "init";
+    }),
+    shallow
+  );
+  const popupsIds = usePopupsStore((state) => state.popupsIds, shallow);
+  const map = useMap();
+  const isToggledGpsTools = openPopupsIds.indexOf("gpsTools") > -1;
+  const isDisabledGpsTools = popupsIds.indexOf("gpsTools") > -1 && openPopupsIds.indexOf("gpsTools") === -1;
+  const isToggledMeasureTool = openPopupsIds.indexOf("measureTool") > -1;
+  const isDisabledMeasureTool = popupsIds.indexOf("measureTool") > -1 && openPopupsIds.indexOf("measureTool") === -1;
+  const onMouseDown = (e) => {
+    map.dragging.disable();
+    e.stopPropagation();
+    document.addEventListener("mouseup", onMouseUp);
+  };
+  const onMouseUp = (e) => {
+    map.dragging.enable();
+    e.stopPropagation();
+    document.removeEventListener("mouseup", onMouseUp);
+  };
+  const onGpsToolsClick = (e) => {
+    if (!isToggledGpsTools) {
+      addPopup(
+        {
+          popupId: GPS_TOOLS_POPUP_ID,
+          title: getLabel(MAP_DICCTIONARY.LABEL_GPSTOOLS_NAME),
+          iconUrl: `${host_static_assets}/${environment_assets}/frontend/components/map_gpstools/assets/icons/${MAP_ICONS.MAP_GPS_TOOLS_TOOL}`,
+          functionComponent: gpsTools,
+          onMouseDown,
+          defaultPosition: GPS_TOOLS_POPUP_DEFAULT_POSITION
+        },
+        { closeOthers: true }
+      );
+    } else {
+      closePopup(GPS_TOOLS_POPUP_ID);
+    }
+    e.stopPropagation();
+  };
+  const onMeasureToolClick = (e) => {
+    if (!isToggledMeasureTool) {
+      addPopup(
+        {
+          popupId: "measureTool",
+          iconUrl: `${host_static_assets}/${environment_assets}/frontend/components/map/assets/icons/${MAP_ICONS.MAP_MEASURE_TOOL}`,
+          title: "Measure Tool",
+          functionComponent: MeasureTool,
+          onMouseDown,
+          defaultPosition: MESURE_POPUP_DEFAULT_POSITION
+        },
+        { closeOthers: true }
+      );
+    } else {
+      closePopup("measureTool");
+    }
+    e.stopPropagation();
+  };
+  return /* @__PURE__ */ jsxs(Control, { position: "topright", prepend: true, className: mapClasses.topRigthToolsRoot, children: [
+    /* @__PURE__ */ jsx(
+      ToggleIconButton,
+      {
+        isToggled: isToggledGpsTools,
+        disabled: isDisabledGpsTools,
+        onToggle: onGpsToolsClick,
+        src: `${host_static_assets}/${environment_assets}/frontend/components/map_gpstools/assets/icons/${MAP_ICONS.MAP_GPS_TOOLS_TOOL}`
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      ToggleIconButton,
+      {
+        isToggled: isToggledMeasureTool,
+        disabled: isDisabledMeasureTool,
+        onToggle: onMeasureToolClick,
+        src: `${host_static_assets}/${environment_assets}/frontend/components/map/assets/icons/${MAP_ICONS.MAP_MEASURE_TOOL}`
+      }
+    ),
+    /* @__PURE__ */ jsx(ZoomButtons, {})
+  ] });
+}
+export {
+  TopRightTools as T
+};

package/components/maps/components/Map/subcomponents/Controls/subcomponents/TopRigthTools/subcomponents/MeasureTool/constants-DxjFRbA_.js

@@ -0,0 +1,34 @@
+const INITIAL_FORM_VALUES = {
+  /** General Data */
+  statusLoad: "ready",
+  reInits: 0,
+  value: "0",
+  measureTypeId: "distance",
+  magnitudFactor: {
+    id: "m_kilometers",
+    name: "Kilometers",
+    symbol: "k",
+    factor_x0: 0,
+    factor_x1: 1,
+    factor_x2: 0
+  },
+  unitArea: null,
+  /** Config Data */
+  /** de Apoyo */
+  statusEdition: "initial"
+  // geometry: null ,
+};
+const STYLE_MEASURE_OPTIONS = {
+  strokeLineColor: "#1E96DC",
+  strokeLineWeight: 5,
+  markerHeight: 37,
+  markerWidth: 26,
+  labelMarkerHeight: 0,
+  labelMarkerWidth: 0,
+  labelMarkerAnchorY: 0,
+  labelMarkerAnchorX: 0
+};
+export {
+  INITIAL_FORM_VALUES as I,
+  STYLE_MEASURE_OPTIONS as S
+};

package/components/maps/components/Map/subcomponents/Controls/subcomponents/TopRigthTools/subcomponents/MeasureTool/hooks/useMeasure/helpers-FT0mJBnO.js

@@ -0,0 +1,45 @@
+import { S as STYLE_MEASURE_OPTIONS } from "../../constants-DxjFRbA_.js";
+import { m as mapClasses } from "../../../../../../../../classes/index-DHIpfj2O.js";
+import { M as MAP_DICCTIONARY } from "../../../../../../../../dictionary-BNALtcTf.js";
+import L__default from "leaflet";
+const getMarkerPointIcon = (position) => {
+  return L__default.divIcon({
+    className: mapClasses.measureMarkerRoot,
+    html: `<div  class="${mapClasses.measureMarkerContainer}">
+            <div  class="${mapClasses.measureMarkerContainerRhomb}">
+            </div>
+            <div  class="${mapClasses.measureMarkerContainerSlot}">
+                <div  class="${mapClasses.measureMarkerContainerSlotNumber}">
+                    ${position}
+                </div>
+            </div>
+        </div>
+        `,
+    iconSize: [STYLE_MEASURE_OPTIONS.markerWidth, STYLE_MEASURE_OPTIONS.markerHeight],
+    // tamaño del icono
+    iconAnchor: [STYLE_MEASURE_OPTIONS.markerWidth / 2, STYLE_MEASURE_OPTIONS.markerHeight]
+    // punto de anclaje, el mismo que el de la imagen
+  });
+};
+const getMarkerPointLabel = (distance, getLabel) => {
+  return L__default.divIcon({
+    className: mapClasses.measureLabelMarkerRoot,
+    html: `<div  class="${mapClasses.measureLabelMarkerContainer}">
+        ${distance ? `<span class="${mapClasses.measureLabelMarkerDistance}">${distance}</span>` : ""}
+        <div class="${mapClasses.measureLabelMarkerRemove}">${getLabel(
+      MAP_DICCTIONARY.LABEL_MEASURE_REMOVE_POINT
+    )}</div>
+        </div>`,
+    iconSize: [STYLE_MEASURE_OPTIONS.labelMarkerWidth, STYLE_MEASURE_OPTIONS.labelMarkerHeight],
+    // tamaño del label
+    iconAnchor: [
+      STYLE_MEASURE_OPTIONS.labelMarkerAnchorX,
+      STYLE_MEASURE_OPTIONS.labelMarkerAnchorY
+    ]
+    //
+  });
+};
+export {
+  getMarkerPointLabel as a,
+  getMarkerPointIcon as g
+};

package/components/maps/components/Map/subcomponents/Controls/subcomponents/TopRigthTools/subcomponents/MeasureTool/hooks/useMeasure/index-_uxJUZCW.js

@@ -0,0 +1,243 @@
+import { useState, useRef, useCallback, useEffect } from "react";
+import { useMap } from "react-leaflet";
+import * as L from "leaflet";
+import { useFormContext, useWatch } from "react-hook-form";
+import { u as useFormReadyForUpdate } from "../../../../../../../../../../../../hooks/useFormReadyForUpdate/index-B3HygFCM.js";
+import { useModuleDictionary } from "@m4l/core";
+import { S as STYLE_MEASURE_OPTIONS } from "../../constants-DxjFRbA_.js";
+import { e as MAP_ZINDEX_DEFAULT } from "../../../../../../../../constants-B0E5r9Iy.js";
+import { g as getMarkerPointIcon, a as getMarkerPointLabel } from "./helpers-FT0mJBnO.js";
+import { m as mapClasses } from "../../../../../../../../classes/index-DHIpfj2O.js";
+function useMeasure() {
+  const { getLabel } = useModuleDictionary();
+  const map = useMap();
+  const readyToUpdate = useFormReadyForUpdate();
+  const { control, setValue } = useFormContext();
+  const fieldsWatch = useWatch({
+    control,
+    name: ["statusEdition", "value", "magnitudFactor"]
+  });
+  const statusEdition = fieldsWatch[0];
+  const value = fieldsWatch[1];
+  const magnitudFactor = fieldsWatch[2];
+  const [magnitudFactorCached, setMagnitudFactorCached] = useState(magnitudFactor);
+  const currentMeasure = useRef({
+    measurePoints: [],
+    addMarker: false,
+    magnitudFactor,
+    dragging: false
+  });
+  const clearMeasure = useCallback(() => {
+    currentMeasure.current.measurePoints.forEach((measurePoint) => {
+      measurePoint.marker.remove();
+      measurePoint.labelMarker.remove();
+    });
+    currentMeasure.current.measurePoints = [];
+    setValue("value", measureDistante());
+  }, []);
+  const getFormatFactorDistance = useCallback(
+    (distance, withSymbol = false) => {
+      if (distance === void 0) {
+        return void 0;
+      }
+      const cMagnitudeFactor = currentMeasure.current.magnitudFactor;
+      return (cMagnitudeFactor.factor_x0 + distance * cMagnitudeFactor.factor_x1 + (distance ^ 2 * cMagnitudeFactor.factor_x2)).toFixed(2) + (withSymbol ? ` ${cMagnitudeFactor.symbol}` : "");
+    },
+    []
+  );
+  const measureDistante = useCallback(() => {
+    let totalDistance = 0;
+    const measurePoints = currentMeasure.current.measurePoints;
+    if (currentMeasure.current.layerLine) {
+      if (measurePoints.length < 2) {
+        currentMeasure.current.layerLine.remove();
+        currentMeasure.current.layerLine = void 0;
+      } else {
+        currentMeasure.current.layerLine.setLatLngs(
+          measurePoints.map((measurePoint) => measurePoint.marker.getLatLng())
+        );
+      }
+    } else {
+      if (measurePoints.length > 1) {
+        currentMeasure.current.layerLine = L.polyline(
+          measurePoints.map((measurePoint) => measurePoint.marker.getLatLng()),
+          {
+            color: STYLE_MEASURE_OPTIONS.strokeLineColor,
+            weight: STYLE_MEASURE_OPTIONS.strokeLineWeight,
+            interactive: false
+            //No se puede editar
+          }
+        ).addTo(map);
+      }
+    }
+    for (let i = 0; i < measurePoints.length - 1; i++) {
+      totalDistance += measurePoints[i].marker.getLatLng().distanceTo(measurePoints[i + 1].marker.getLatLng());
+    }
+    if (measurePoints.length > 0 && measurePoints[0].formatDistanceFromPrevious !== void 0) {
+      measurePoints[0].formatDistanceFromPrevious = void 0;
+      measurePoints[0].labelMarker.setIcon(getMarkerPointLabelMemo(void 0, getLabel));
+      addClickListenerForRemove(measurePoints[0].labelMarker);
+    }
+    for (let i = 1; i < measurePoints.length; i++) {
+      const formatDistanceFromPrevious = getFormatFactorDistance(
+        measurePoints[i - 1].marker.getLatLng().distanceTo(measurePoints[i].marker.getLatLng()),
+        true
+      );
+      if (measurePoints[i].formatDistanceFromPrevious !== formatDistanceFromPrevious) {
+        measurePoints[i].formatDistanceFromPrevious = formatDistanceFromPrevious;
+        measurePoints[i].labelMarker.setIcon(
+          getMarkerPointLabelMemo(formatDistanceFromPrevious, getLabel)
+        );
+        addClickListenerForRemove(measurePoints[i].labelMarker);
+      }
+    }
+    return getFormatFactorDistance(totalDistance);
+  }, [map, getLabel]);
+  const getMarkerPointIconMemo = useCallback(getMarkerPointIcon, []);
+  const getMarkerPointLabelMemo = useCallback(getMarkerPointLabel, [getLabel]);
+  const onClickRemovePoint = useCallback((labelMarker) => {
+    return (e) => {
+      e.stopPropagation();
+      if (!currentMeasure.current.dragging) {
+        const markIndex = currentMeasure.current.measurePoints.findIndex(
+          (searchElement) => {
+            return searchElement.labelMarker === labelMarker;
+          }
+        );
+        if (markIndex !== -1) {
+          const measurePoint = currentMeasure.current.measurePoints[markIndex];
+          measurePoint.marker.remove();
+          measurePoint.labelMarker.remove();
+          currentMeasure.current.measurePoints.splice(markIndex, 1);
+          setValue("value", measureDistante());
+          currentMeasure.current.addMarker = true;
+        }
+        currentMeasure.current.measurePoints.forEach((measurePoint, index) => {
+          measurePoint.marker.setIcon(getMarkerPointIconMemo(index + 1));
+        });
+      }
+    };
+  }, []);
+  const addClickListenerForRemove = useCallback((labelMarker) => {
+    let element = labelMarker.getElement();
+    if (element) {
+      const elements = element.getElementsByClassName(
+        mapClasses.measureLabelMarkerRemove
+      );
+      element = elements[0];
+      if (element) {
+        element.addEventListener("click", onClickRemovePoint(labelMarker));
+      }
+    }
+  }, []);
+  const onClickMap = useCallback(
+    (e) => {
+      const lat = e.latlng.lat;
+      const lng = e.latlng.lng;
+      let formatDistanceFromPrevious = void 0;
+      if (currentMeasure.current.addMarker === false) {
+        return;
+      }
+      if (currentMeasure.current.measurePoints.length > 0) {
+        formatDistanceFromPrevious = getFormatFactorDistance(
+          currentMeasure.current.measurePoints[currentMeasure.current.measurePoints.length - 1].marker.getLatLng().distanceTo(e.latlng)
+        );
+      }
+      const marker = L.marker([lat, lng], {
+        draggable: true,
+        riseOnHover: true,
+        //Se pone la marca encima de las otras cuando se hace over
+        autoPan: true,
+        //Se corre el mapa si llega al extremo, solo para las marcas
+        icon: getMarkerPointIconMemo(currentMeasure.current.measurePoints.length + 1),
+        zIndexOffset: MAP_ZINDEX_DEFAULT
+      }).addTo(map);
+      marker.on("moveend", function(_e) {
+        const latlng = marker.getLatLng();
+        labelMarker.setLatLng(latlng);
+        setValue("value", measureDistante());
+      });
+      marker.on("mouseover", function() {
+        currentMeasure.current.addMarker = false;
+      });
+      marker.on("mouseout", function() {
+        currentMeasure.current.addMarker = true;
+      });
+      var labelMarker = L.marker([lat, lng], {
+        draggable: true,
+        riseOnHover: true,
+        //Se pone la marca encima de las otras cuando se hace over
+        icon: getMarkerPointLabelMemo(formatDistanceFromPrevious, getLabel),
+        zIndexOffset: MAP_ZINDEX_DEFAULT
+      }).addTo(map);
+      labelMarker.on("moveend", function(_e) {
+        const latlng = labelMarker.getLatLng();
+        marker.setLatLng(latlng);
+        setValue("value", measureDistante());
+      });
+      labelMarker.on("mouseover", function(_e) {
+        currentMeasure.current.addMarker = false;
+      });
+      labelMarker.on("mouseout", function(_e) {
+        currentMeasure.current.addMarker = true;
+      });
+      labelMarker.on("dragstart", function(_e) {
+        currentMeasure.current.dragging = true;
+      });
+      labelMarker.on("dragend", function(_e) {
+        setTimeout(function() {
+          currentMeasure.current.dragging = false;
+        }, 10);
+      });
+      addClickListenerForRemove(labelMarker);
+      currentMeasure.current.measurePoints.push({
+        marker,
+        labelMarker,
+        formatDistanceFromPrevious
+      });
+      setValue("value", measureDistante());
+    },
+    [map, measureDistante, setValue, getLabel]
+  );
+  const onMouseMoveMap = useCallback(() => {
+    map.getContainer().style.cursor = "crosshair";
+  }, [map]);
+  const onMouseOutMap = useCallback(() => {
+    map.getContainer().style.cursor = "default";
+  }, [map]);
+  useEffect(() => {
+    if (map) {
+      if (statusEdition === "initial") {
+        map.off("click", onClickMap);
+        clearMeasure();
+        map.getContainer().style.cursor = "default";
+        return;
+      } else {
+        currentMeasure.current.addMarker = true;
+        map.getContainer().style.cursor = "crosshair";
+        map.on("click", onClickMap);
+      }
+    }
+  }, [map, statusEdition]);
+  useEffect(() => {
+    if (!readyToUpdate) return;
+    if (magnitudFactor.id !== magnitudFactorCached.id) {
+      setMagnitudFactorCached({ ...magnitudFactor });
+      currentMeasure.current.magnitudFactor = magnitudFactor;
+      setValue("value", measureDistante());
+    }
+  }, [magnitudFactor]);
+  useEffect(() => {
+    return () => {
+      map.off("mousemove", onMouseMoveMap);
+      map.off("mouseout", onMouseOutMap);
+      map.off("click", onClickMap);
+      map.getContainer().style.cursor = "default";
+      clearMeasure();
+    };
+  }, []);
+  return { statusEdition, magnitudFactor, value };
+}
+export {
+  useMeasure as u
+};

package/components/maps/components/Map/subcomponents/Controls/subcomponents/TopRigthTools/subcomponents/MeasureTool/hooks/useValidation-DiK7VJqP.js

@@ -0,0 +1,17 @@
+import { useMemo } from "react";
+import { useModuleDictionary } from "@m4l/core";
+import * as Yup from "yup";
+import { M as MeasureDataValidation } from "../subcomponents/MeasureData/validations-C99vbJmF.js";
+function useValidation() {
+  const { getLabel } = useModuleDictionary();
+  const validationSchema = useMemo(
+    () => Yup.object().shape({
+      ...MeasureDataValidation()
+    }),
+    [getLabel]
+  );
+  return { validationSchema };
+}
+export {
+  useValidation as u
+};

package/components/maps/components/Map/subcomponents/Controls/subcomponents/TopRigthTools/subcomponents/MeasureTool/index-DNg8v3Sm.js

@@ -0,0 +1,41 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { M as MyActions } from "./subcomponents/MyActions/index-BKEadPSt.js";
+import { u as useValidation } from "./hooks/useValidation-DiK7VJqP.js";
+import { I as INITIAL_FORM_VALUES } from "./constants-DxjFRbA_.js";
+import { M as MeasureData } from "./subcomponents/MeasureData/index-8JEW46YS.js";
+import { useModuleDictionary } from "@m4l/core";
+import { M as MAP_DICCTIONARY } from "../../../../../../dictionary-BNALtcTf.js";
+import { m as mapClasses } from "../../../../../../classes/index-DHIpfj2O.js";
+import { R as RHFormProvider } from "../../../../../../../../../../contexts/RHFormContext/index-DE-wmCBw.js";
+import { S as Stack } from "../../../../../../../../../mui_extended/Stack/Stack-C79qEBpg.js";
+function MeasureTool() {
+  const { getLabel } = useModuleDictionary();
+  const finalInitalValues = {
+    ...INITIAL_FORM_VALUES
+  };
+  if (finalInitalValues?.magnitudFactor?.name) {
+    finalInitalValues.magnitudFactor.name = getLabel(
+      MAP_DICCTIONARY.LABEL_MEASURE_UNIT_BASE_KILOMETERS
+    );
+  }
+  const { validationSchema } = useValidation();
+  const onSubmit = () => {
+  };
+  return /* @__PURE__ */ jsxs(
+    RHFormProvider,
+    {
+      className: mapClasses.meaureToolRoot,
+      statusLoad: INITIAL_FORM_VALUES.statusLoad,
+      onSubmit,
+      values: finalInitalValues,
+      validationSchema,
+      children: [
+        /* @__PURE__ */ jsx(Stack, { direction: "column", children: /* @__PURE__ */ jsx(MeasureData, {}) }),
+        /* @__PURE__ */ jsx(MyActions, {})
+      ]
+    }
+  );
+}
+export {
+  MeasureTool as M
+};

package/components/maps/components/Map/subcomponents/Controls/subcomponents/TopRigthTools/subcomponents/MeasureTool/subcomponents/MeasureData/index-8JEW46YS.js

@@ -0,0 +1,33 @@
+import { jsxs, Fragment, jsx } from "react/jsx-runtime";
+import { useModuleDictionary } from "@m4l/core";
+import { M as MAP_DICCTIONARY } from "../../../../../../../../dictionary-BNALtcTf.js";
+import { u as useMeasure } from "../../hooks/useMeasure/index-_uxJUZCW.js";
+import { m as mapClasses } from "../../../../../../../../classes/index-DHIpfj2O.js";
+import { R as RHFAutocompleteAsync } from "../../../../../../../../../../../hook-form/RHFAutocompleteAsync/RHFAutocompleteAsync-J_KBBOLP.js";
+import { S as Stack } from "../../../../../../../../../../../mui_extended/Stack/Stack-C79qEBpg.js";
+function MeasureData() {
+  const { getLabel } = useModuleDictionary();
+  const { value, magnitudFactor } = useMeasure();
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      RHFAutocompleteAsync,
+      {
+        type: "text",
+        endPoint: "magnitudes/factors?origin_unit_reference_id=m_kilometers",
+        name: "magnitudFactor",
+        autoComplete: "off",
+        getOptionLabel: (option) => option.name,
+        isOptionEqualToValue: (option, measureItemValue) => option.id === measureItemValue.id,
+        label: getLabel(MAP_DICCTIONARY.LABEL_MEASURE_UNIT),
+        isRemote: false
+      }
+    ),
+    /* @__PURE__ */ jsxs(Stack, { direction: "row", spacing: 2, className: mapClasses.measureToolFormValue, children: [
+      /* @__PURE__ */ jsx("span", { className: mapClasses.measureToolFormValueDistance, children: value }),
+      /* @__PURE__ */ jsx("span", { className: mapClasses.measureToolFormValueSymbol, children: magnitudFactor.symbol })
+    ] })
+  ] });
+}
+export {
+  MeasureData as M
+};

package/components/maps/components/Map/subcomponents/Controls/subcomponents/TopRigthTools/subcomponents/MeasureTool/subcomponents/MeasureData/validations-C99vbJmF.js

@@ -0,0 +1,6 @@
+function MeasureDataValidation(_getLabel) {
+  return {};
+}
+export {
+  MeasureDataValidation as M
+};

package/components/maps/components/Map/subcomponents/Controls/subcomponents/TopRigthTools/subcomponents/MeasureTool/subcomponents/MyActions/index-BKEadPSt.js

@@ -0,0 +1,26 @@
+import { jsx } from "react/jsx-runtime";
+import { useFormContext, useWatch } from "react-hook-form";
+import { useModuleDictionary } from "@m4l/core";
+import { M as MAP_DICCTIONARY } from "../../../../../../../../dictionary-BNALtcTf.js";
+import { A as Actions } from "../../../../../../../../../../../CommonActions/components/Actions/index-B4L6Y4pL.js";
+import { B as Button } from "../../../../../../../../../../../mui_extended/Button/Button-BdusSjEV.js";
+function MyActions() {
+  const { control, setValue } = useFormContext();
+  const { getLabel } = useModuleDictionary();
+  const fieldsWatch = useWatch({
+    control,
+    name: ["statusEdition", "reInits"]
+  });
+  const statusEdition = fieldsWatch[0];
+  const initCancelDraw = () => {
+    if (statusEdition === "initial") {
+      setValue("statusEdition", "draw");
+    } else if (statusEdition === "draw") {
+      setValue("statusEdition", "initial");
+    }
+  };
+  return /* @__PURE__ */ jsx(Actions, { children: /* @__PURE__ */ jsx(Button, { onClick: initCancelDraw, children: statusEdition === "initial" ? getLabel(MAP_DICCTIONARY.LABEL_MEASURE_START) : getLabel(MAP_DICCTIONARY.LABEL_MEASURE_CANCEL) }) });
+}
+export {
+  MyActions as M
+};

package/components/maps/components/Map/subcomponents/Controls/subcomponents/TopRigthTools/subcomponents/ZoomButtons/index-CFr3XeB5.js

@@ -0,0 +1,52 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { useState, useEffect } from "react";
+import { useMap } from "react-leaflet";
+import { M as MAP_ICONS } from "../../../../../../icons-CSYh7uR4.js";
+import { useEnvironment } from "@m4l/core";
+import { m as mapClasses } from "../../../../../../classes/index-DHIpfj2O.js";
+import { I as IconButton } from "../../../../../../../../../mui_extended/IconButton/IconButton-1jvQBFbH.js";
+function ZoomButtons() {
+  const map = useMap();
+  const { host_static_assets, environment_assets } = useEnvironment();
+  const [, setZoomInDisabled] = useState(false);
+  const [, setZoomOutDisabled] = useState(false);
+  useEffect(() => {
+    const updateButtonState = () => {
+      const currentZoom = map.getZoom();
+      const maxZoom = map.getMaxZoom();
+      const minZoom = map.getMinZoom();
+      setZoomInDisabled(currentZoom === maxZoom);
+      setZoomOutDisabled(currentZoom === minZoom);
+    };
+    map.on("zoomend", updateButtonState);
+    updateButtonState();
+    return () => {
+      map.off("zoomend", updateButtonState);
+    };
+  }, [map]);
+  const handleZoomIn = () => {
+    map.zoomIn();
+  };
+  const handleZoomOut = () => {
+    map.zoomOut();
+  };
+  return /* @__PURE__ */ jsxs("div", { className: mapClasses.zoomButtons, children: [
+    /* @__PURE__ */ jsx(
+      IconButton,
+      {
+        onClick: handleZoomIn,
+        src: `${host_static_assets}/${environment_assets}/frontend/components/map/assets/icons/${MAP_ICONS.MAP_ZOOM_IN}`
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      IconButton,
+      {
+        onClick: handleZoomOut,
+        src: `${host_static_assets}/${environment_assets}/frontend/components/map/assets/icons/${MAP_ICONS.MAP_ZOOM_OUT}`
+      }
+    )
+  ] });
+}
+export {
+  ZoomButtons as Z
+};

package/components/maps/components/Map/subcomponents/LayersContainer/index-DQItXTgO.js

@@ -0,0 +1,33 @@
+import { jsx } from "react/jsx-runtime";
+import { shallow } from "zustand/shallow";
+import { M as MyLayer } from "./subcomponents/MyLayer/index-CfurUH1f.js";
+import L__default from "leaflet";
+import React__default, { useEffect } from "react";
+import { useMap } from "react-leaflet";
+import { u as useAutoFocus } from "../../hooks/useAutoFocus/index-B5V3HGJv.js";
+import { u as useMapStore } from "../../hooks/useMapStore/index-Dvztupfk.js";
+const LayersContainer = () => {
+  const layersId = useMapStore((state) => state.layersIds, shallow);
+  const isSkeleton = useMapStore((state) => state.ownerState.isSkeleton, shallow);
+  const map = useMap();
+  useAutoFocus();
+  useEffect(() => {
+    if (!map) {
+      return;
+    }
+    L__default.control.scale().addTo(map);
+    return () => {
+      L__default.control.scale().remove();
+    };
+  }, [map]);
+  if (isSkeleton) {
+    return null;
+  }
+  if (!map) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(React__default.Fragment, { children: layersId.map((l) => /* @__PURE__ */ jsx(MyLayer, { layerId: l }, l)) });
+};
+export {
+  LayersContainer as L
+};