@m4l/components 7.1.2 → 7.2.0

package/src/components/maps/components/Map/featureRenders/CommonFeatureRender/subcomponents/MarkerIconLabel/types.ts

@@ -0,0 +1,16 @@
+import { MarkerProps } from 'react-leaflet';
+import { DivIconFeatureDescriptionProps } from '../FeatureDivIconLabel/types';
+import { MapPopupComponent } from '../../../../popups/types';
+import { GeoJsonProperties } from '../../../../contexts/MapContext/types';
+import { PopupOptions } from 'leaflet';
+
+export interface FeatureDescriptionProps
+  extends DivIconFeatureDescriptionProps,
+    Omit<MarkerProps, 'children'> {
+  withPoint?: boolean;
+  popupRender?: MapPopupComponent | undefined;
+  properties?: GeoJsonProperties;
+  popupOptions?: Omit<PopupOptions, 'content'>;
+
+  [name: string]: any;
+}

package/src/components/maps/components/Map/featureRenders/MarkerFeatureRender/IconMarker.tsx

@@ -0,0 +1,30 @@
+//react
+import { GruaIconMarker } from './IconMarkerGrua';
+import { IconMarkerTaxi } from './IconMarkerTaxi';
+
+export type IconForm = 'grua' | 'taxi';
+export interface IconMarkerProps {
+  iconForm: string;
+  bearing: number;
+}
+/**
+ * TODO: Documentar
+ */
+export function IconMarker(props: IconMarkerProps) {
+  const { iconForm, bearing } = props;
+
+  let iconMarker;
+  if (iconForm === 'grua') {
+    iconMarker = <GruaIconMarker />;
+  } else if (iconForm === 'taxi') {
+    iconMarker = <IconMarkerTaxi />;
+  } else {
+    iconMarker = <div>no icon</div>;
+  }
+  const adjustedBearing = (bearing + 90) % 360;
+  return (
+    <div style={{ transform: `rotate(${adjustedBearing}deg); transform-origin: center center` }}>
+      {iconMarker}
+    </div>
+  );
+}

package/src/components/maps/components/Map/featureRenders/MarkerFeatureRender/IconMarkerGrua.tsx

@@ -0,0 +1,14 @@
+//react
+
+/**
+ * TODO: Documentar
+ */
+export function GruaIconMarker() {
+  return (
+    <img
+      src="data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<!-- Creator: CorelDRAW X8 -->
<svg xmlns="http://www.w3.org/2000/svg" xml:space="preserve" width="33.8982mm" height="12.7mm" version="1.1" style="shape-rendering:geometricPrecision; text-rendering:geometricPrecision; image-rendering:optimizeQuality; fill-rule:evenodd; clip-rule:evenodd"
viewBox="0 0 250 93"
 xmlns:xlink="http://www.w3.org/1999/xlink">
 <defs>
  <style type="text/css">
   <![CDATA[
    .fil3 {fill:black}
    .fil4 {fill:#1E96DC}
    .fil1 {fill:#333333}
    .fil5 {fill:white}
    .fil8 {fill:url(#id18)}
    .fil7 {fill:url(#id19)}
    .fil0 {fill:url(#id20)}
    .fil2 {fill:url(#id21)}
    .fil6 {fill:url(#id22)}
   ]]>
  </style>
     <mask id="id0">
  <linearGradient id="id1" gradientUnits="userSpaceOnUse" x1="7.16034" y1="45.2563" x2="16.0142" y2="45.2545">
   <stop offset="0" style="stop-opacity:0; stop-color:white"/>
   <stop offset="1" style="stop-opacity:1; stop-color:white"/>
  </linearGradient>
      <rect style="fill:url(#id1)" x="8" y="28" width="4.26632" height="31.9812"/>
     </mask>
    <mask id="id2">
  <linearGradient id="id3" gradientUnits="userSpaceOnUse" x1="198.662" y1="56.1868" x2="214.072" y2="121.384">
   <stop offset="0" style="stop-opacity:0; stop-color:white"/>
   <stop offset="1" style="stop-opacity:1; stop-color:white"/>
  </linearGradient>
     <rect style="fill:url(#id3)" x="170" y="77" width="75.9281" height="9.62572"/>
    </mask>
    <mask id="id4">
  <linearGradient id="id5" gradientUnits="userSpaceOnUse" x1="190.367" y1="-14.641" x2="241.636" y2="121.088">
   <stop offset="0" style="stop-opacity:0; stop-color:white"/>
   <stop offset="1" style="stop-opacity:1; stop-color:white"/>
  </linearGradient>
     <rect style="fill:url(#id5)" x="147" y="7" width="102.824" height="41.1807"/>
    </mask>
    <mask id="id6">
  <linearGradient id="id7" gradientUnits="userSpaceOnUse" x1="117.633" y1="39.5157" x2="181.496" y2="79.8192">
   <stop offset="0" style="stop-opacity:0; stop-color:white"/>
   <stop offset="1" style="stop-opacity:1; stop-color:white"/>
  </linearGradient>
     <rect style="fill:url(#id7)" x="129" y="56" width="37.334" height="32.3301"/>
    </mask>
    <mask id="id8">
  <linearGradient id="id9" gradientUnits="userSpaceOnUse" x1="156.01" y1="73.5957" x2="180.459" y2="71.5213">
   <stop offset="0" style="stop-opacity:0; stop-color:white"/>
   <stop offset="1" style="stop-opacity:1; stop-color:white"/>
  </linearGradient>
     <rect style="fill:url(#id9)" x="165" y="56" width="6.28907" height="32.3301"/>
    </mask>
    <mask id="id10">
  <linearGradient id="id11" gradientUnits="userSpaceOnUse" x1="134.381" y1="44.2227" x2="187.87" y2="44.2209">
   <stop offset="0" style="stop-opacity:0; stop-color:white"/>
   <stop offset="1" style="stop-opacity:1; stop-color:white"/>
  </linearGradient>
     <rect style="fill:url(#id11)" x="134" y="31" width="37.4113" height="27.3284"/>
    </mask>
    <mask id="id12">
  <linearGradient id="id13" gradientUnits="userSpaceOnUse" x1="85.4823" y1="44.2205" x2="165.941" y2="44.2187">
   <stop offset="0" style="stop-opacity:0; stop-color:white"/>
   <stop offset="1" style="stop-opacity:1; stop-color:white"/>
  </linearGradient>
     <rect style="fill:url(#id13)" x="91" y="36" width="44.443" height="17.3273"/>
    </mask>
    <mask id="id14">
  <linearGradient id="id15" gradientUnits="userSpaceOnUse" x1="30.2623" y1="43.815" x2="94.6691" y2="44.259">
   <stop offset="0" style="stop-opacity:0; stop-color:white"/>
   <stop offset="1" style="stop-opacity:1; stop-color:white"/>
  </linearGradient>
     <rect style="fill:url(#id15)" x="35" y="36" width="34.5148" height="17.3273"/>
    </mask>
    <mask id="id16">
  <linearGradient id="id17" gradientUnits="userSpaceOnUse" x1="147.093" y1="50.6098" x2="166.059" y2="107.418">
   <stop offset="0" style="stop-opacity:0; stop-color:white"/>
   <stop offset="1" style="stop-opacity:1; stop-color:white"/>
  </linearGradient>
     <rect style="fill:url(#id17)" x="134" y="61" width="32.3691" height="15.8081"/>
    </mask>
  <linearGradient id="id18" gradientUnits="userSpaceOnUse" x1="30.576" y1="45.2748" x2="29.9496" y2="42.3548">
   <stop offset="0" style="stop-opacity:1; stop-color:#666666"/>
   <stop offset="1" style="stop-opacity:1; stop-color:#999999"/>
  </linearGradient>
  <linearGradient id="id19" gradientUnits="userSpaceOnUse" xlink:href="#id18" x1="97.4702" y1="46.0867" x2="96.8843" y2="41.9845">
  </linearGradient>
  <linearGradient id="id20" gradientUnits="userSpaceOnUse" xlink:href="#id18" x1="176.269" y1="91.879" x2="175.075" y2="70.5334">
  </linearGradient>
  <linearGradient id="id21" gradientUnits="userSpaceOnUse" xlink:href="#id18" x1="176.269" y1="22.948" x2="175.075" y2="1.60245">
  </linearGradient>
  <linearGradient id="id22" gradientUnits="userSpaceOnUse" xlink:href="#id18" x1="226.47" y1="64.3945" x2="221.119" y2="51.8311">
  </linearGradient>
 </defs>
 <g id="sloy_x0020_1">
  <metadata id="CorelCorpID_0Corel-Layer"/>
  <g id="_2348770985792">
   <g>
    <rect class="fil0" x="110" y="71" width="131.802" height="19.7085" rx="2" ry="2"/>
    <rect class="fil1" x="232" y="69" width="6.33158" height="24.5513" rx="2" ry="2"/>
    <rect class="fil1" x="223" y="69" width="6.33158" height="24.5513" rx="2" ry="2"/>
    <rect class="fil1" x="214" y="69" width="6.33158" height="24.5513" rx="2" ry="2"/>
    <rect class="fil1" x="205" y="69" width="6.33158" height="24.5513" rx="2" ry="2"/>
    <rect class="fil1" x="195" y="69" width="6.33158" height="24.5513" rx="2" ry="2"/>
    <rect class="fil1" x="186" y="69" width="6.33158" height="24.5513" rx="2" ry="2"/>
    <rect class="fil1" x="177" y="69" width="6.33158" height="24.5513" rx="2" ry="2"/>
    <rect class="fil1" x="168" y="69" width="6.33158" height="24.5513" rx="2" ry="2"/>
    <rect class="fil1" x="159" y="69" width="6.33158" height="24.5513" rx="2" ry="2"/>
    <rect class="fil1" x="149" y="69" width="6.33158" height="24.5513" rx="2" ry="2"/>
    <rect class="fil1" x="140" y="69" width="6.33158" height="24.5513" rx="2" ry="2"/>
    <rect class="fil1" x="131" y="69" width="6.33158" height="24.5513" rx="2" ry="2"/>
    <rect class="fil1" x="122" y="69" width="6.33158" height="24.5513" rx="2" ry="2"/>
    <rect class="fil1" x="113" y="69" width="6.33158" height="24.5513" rx="2" ry="2"/>
   </g>
   <g>
    <rect class="fil2" x="110" y="2" width="131.802" height="19.7085" rx="2" ry="2"/>
    <rect class="fil1" x="232" width="6.33158" height="24.5513" rx="2" ry="2"/>
    <rect class="fil1" x="223" width="6.33158" height="24.5513" rx="2" ry="2"/>
    <rect class="fil1" x="214" width="6.33158" height="24.5513" rx="2" ry="2"/>
    <rect class="fil1" x="205" width="6.33158" height="24.5513" rx="2" ry="2"/>
    <rect class="fil1" x="195" width="6.33158" height="24.5513" rx="2" ry="2"/>
    <rect class="fil1" x="186" width="6.33158" height="24.5513" rx="2" ry="2"/>
    <rect class="fil1" x="177" width="6.33158" height="24.5513" rx="2" ry="2"/>
    <rect class="fil1" x="168" width="6.33158" height="24.5513" rx="2" ry="2"/>
    <rect class="fil1" x="159" width="6.33158" height="24.5513" rx="2" ry="2"/>
    <rect class="fil1" x="149" width="6.33158" height="24.5513" rx="2" ry="2"/>
    <rect class="fil1" x="140" width="6.33158" height="24.5513" rx="2" ry="2"/>
    <rect class="fil1" x="131" width="6.33158" height="24.5513" rx="2" ry="2"/>
    <rect class="fil1" x="122" width="6.33158" height="24.5513" rx="2" ry="2"/>
    <rect class="fil1" x="113" width="6.33158" height="24.5513" rx="2" ry="2"/>
   </g>
   <g>
    <polygon class="fil1" points="9,31 0,32 0,56 9,57 9,59 23,61 23,28 9,29 "/>
    <polygon class="fil3" style="mask:url(#id0)" points="9,57 9,59 12,59 12,29 9,29 9,31 "/>
   </g>
   <path class="fil4" d="M150 8l93 0c1,0 2,1 2,2l0 9 1 0c2,0 4,2 4,3l0 49c0,2 -2,3 -4,3l-1 0 0 10c0,1 -1,1 -2,1l-76 0 0 1c0,1 -1,2 -1,2l-33 0c-2,0 -3,-1 -3,-3l0 -25c0,-1 0,-2 1,-2l17 0 0 -4 -14 0 0 -2 -43 0 0 2 -22 0 0 -2 -33 0 0 2 -17 -2 0 -16 17 -2 0 2 33 0 0 -2 22 0 0 2 43 0 0 -2 14 0 0 -24c0,-1 1,-2 2,-2z"/>
   <path class="fil3" style="mask:url(#id2)" d="M245 77l0 7c0,1 -1,1 -2,1l-73 0c0,-3 0,-5 0,-5 45,0 68,0 68,0 3,0 6,-1 7,-3z"/>
   <path class="fil5" style="mask:url(#id4)" d="M150 8l93 0c1,0 2,1 2,2l0 9 1 0c2,0 4,2 4,3l0 11c-3,0 -6,0 -8,0 -1,4 -2,8 -5,14 -8,1 -16,1 -25,0 0,0 -5,0 -14,0 0,0 -4,-2 -12,-7 -4,-2 -9,-5 -16,-9 -7,0 -14,0 -22,0l0 -21c0,-1 1,-2 2,-2z"/>
   <path class="fil3" style="mask:url(#id6)" d="M135 88l-2 0c-2,0 -3,-1 -3,-3l0 -25c0,-1 0,-2 1,-2l17 0 0 -1 18 0 0 4 -31 0 0 27z"/>
   <path class="fil3" style="mask:url(#id8)" d="M170 85l-3 0 0 1c0,1 -1,2 -1,2l0 0 0 -31 4 0 0 28z"/>
   <polygon class="fil3" style="mask:url(#id10)" points="148,57 148,54 134,54 134,52 134,36 134,34 148,34 148,31 170,31 170,57 "/>
   <circle class="fil1" cx="224" cy="58" r="3"/>
   <path class="fil6" d="M224 51c4,0 7,3 7,7 0,4 -3,7 -7,7 -4,0 -7,-3 -7,-7 0,-4 3,-7 7,-7zm0 2c3,0 5,2 5,5 0,3 -2,5 -5,5 -3,0 -5,-2 -5,-5 0,-3 2,-5 5,-5z"/>
   <rect class="fil1" x="237" y="29" width="4.44531" height="34.0809" rx="1" ry="2"/>
   <rect class="fil1" transform="matrix(6.95834E-15 0.201405 -0.818684 1.66213E-14 207.566 69.3757)" width="16.9195" height="41.629" rx="3" ry="3"/>
   <rect class="fil1" transform="matrix(6.95834E-15 0.201405 -0.818684 1.66213E-14 207.566 20.3296)" width="16.9195" height="41.629" rx="3" ry="3"/>
   <polygon class="fil1" points="134,62 134,86 131,84 131,60 "/>
   <polygon class="fil1" points="165,59 134,59 136,61 165,61 "/>
   <rect class="fil1" x="36" y="42" width="32.7905" height="2.74146"/>
   <rect class="fil1" x="91" y="41" width="42.941" height="1.5558"/>
   <rect class="fil1" x="91" y="46" width="42.941" height="1.5558"/>
   <rect class="fil7" x="91" y="42" width="11.4757" height="3.85212"/>
   <polygon class="fil1" points="69,41 91,39 91,41 69,42 "/>
   <polygon class="fil1" points="69,47 91,48 91,47 69,45 "/>
   <rect class="fil8" x="24" y="42" width="12.2611" height="2.74146"/>
   <rect class="fil1" x="21" y="41" width="2.96369" height="5.92737"/>
   <rect class="fil1" x="143" y="38" width="26.7458" height="1.5558"/>
   <rect class="fil1" x="143" y="49" width="26.7458" height="1.5558"/>
   <rect class="fil1" transform="matrix(1.27618E-14 0.234249 -0.34542 4.44733E-15 145.004 37.6076)" width="55.5056" height="4.50407"/>
   <rect class="fil1" transform="matrix(1.27618E-14 0.234249 -0.34542 4.44733E-15 152.56 37.6076)" width="55.5056" height="4.50407"/>
   <rect class="fil1" transform="matrix(1.27618E-14 0.234249 -0.34542 4.44733E-15 164.451 37.6076)" width="55.5056" height="4.50407"/>
   <rect class="fil1" transform="matrix(1.27618E-14 0.121136 -0.34542 2.29983E-15 139.113 40.6271)" width="55.5056" height="4.50407"/>
   <rect class="fil1" x="138" y="41" width="7.44663" height="1.5558"/>
   <rect class="fil1" x="138" y="46" width="7.44663" height="1.5558"/>
   <rect class="fil1" x="134" y="43" width="4.73249" height="1.5558"/>
   <rect class="fil1" transform="matrix(1.30863E-15 0.131181 -0.153967 1.08259E-14 164.485 52.4834)" width="16.9195" height="41.629" rx="3" ry="3"/>
   <rect class="fil1" transform="matrix(1.30863E-15 0.131181 -0.153967 1.08259E-14 164.485 33.1829)" width="16.9195" height="41.629" rx="3" ry="3"/>
   <polygon class="fil3" style="mask:url(#id12)" points="91,36 134,36 134,52 91,52 "/>
   <polygon class="fil3" style="mask:url(#id14)" points="69,36 36,36 36,52 69,52 "/>
   <path class="fil5" style="mask:url(#id16)" d="M135 61l31 0 0 10c-10,2 -21,4 -31,5l0 -15z"/>
  </g>
 </g>
</svg>
"
+      alt=""
+      style={{ height: '32px', width: '32px' }}
+    />
+  );
+}

package/src/components/maps/components/Map/featureRenders/MarkerFeatureRender/IconMarkerTaxi.tsx

@@ -0,0 +1,14 @@
+//react
+
+/**
+ * TODO: Documentar
+ */
+export function IconMarkerTaxi() {
+  return (
+    <img
+      src="data:image/svg+xml;base64,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"
+      alt=""
+      style={{ height: '32px', width: '32px' }}
+    />
+  );
+}

package/src/components/maps/components/Map/featureRenders/MarkerFeatureRender/index.tsx

@@ -0,0 +1,112 @@
+//react
+import { Marker, MarkerProps } from 'react-leaflet';
+//external libraries
+import { shallow } from 'zustand/shallow';
+
+import { ComponentRenderPropFeature, RendePropFeatureArgs } from '../../contexts/MapContext';
+import { DivIcon, LatLngLiteral } from 'leaflet';
+import { IconForm } from './IconMarker';
+import { useMemo } from 'react';
+import L from 'leaflet';
+import useMapStore from '../../hooks/useMapStore';
+
+interface CustomMarkerProps extends MarkerProps {
+  id: string | number;
+  iconForm: IconForm | string;
+  position: LatLngLiteral;
+  width: number;
+  height: number;
+  bearing: number;
+}
+
+/**
+ * TODO: Documentar
+ */
+function CustomMarker(props: CustomMarkerProps) {
+
+  const { position, width, height, iconForm, bearing, ...other } = props;
+
+  const html = useMemo(() => {
+    // return ReactDOMServer.renderToString(<IconMarker iconForm={iconForm} bearing={bearing} />);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [bearing]);
+
+  const customIcon: DivIcon = useMemo(() => {
+    return L.divIcon({
+      className: 'custom-icon',
+      iconSize: [width, height],
+      html: `<div>Hola</div>`,
+    });
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [html]);
+
+  return (
+    <Marker
+      position={position}
+      icon={customIcon}
+      // eventHandlers={{
+      //     click: (e) => {
+      //     }
+      // }}
+      {...other}
+      ></Marker>
+  );
+}
+
+/**
+ * TODO: Documentar
+ */
+export const MarkerFeatureRender: ComponentRenderPropFeature = (props: RendePropFeatureArgs) => {
+  const { id, layerId } = props;
+
+  const feature = useMapStore(state => {
+    const gObject = state.hashLayers[layerId].geoJsonObject;
+
+    if (!gObject) {
+      return null;
+    }
+    if (gObject.object.type === 'Feature') {
+      return {
+        id: gObject.object.id,
+        geometry: gObject.object.geometry,
+        properties: gObject.object.properties,
+      };
+    } else {
+      const feat = gObject.object.features.find(f => f.id === id);
+      if (feat) {
+        return {
+          id: feat.id,
+          geometry: feat.geometry,
+          properties: feat.properties,
+        };
+      }
+      return null;
+    }
+  }, shallow);
+
+  if (!feature) {
+    return null;
+  }
+
+  if (feature.geometry.type === 'Point') {
+    const [lat, lng] = feature.geometry.coordinates;
+
+    const bearing = feature.properties?.iconRotate ?? 0;
+    return (
+      // <Marker position={{ lat, lng }}>
+      // ddd
+      // </Marker>
+      <CustomMarker
+        position={{ lat, lng }}
+        width={32}
+        height={32}
+        bearing={bearing}
+        iconForm={'grua'}
+        id={feature.id}
+      />
+    );
+  }
+
+  return null;
+  // const transform = `translate3d(${lat}px, ${lng}px, 0)`;
+};

package/src/components/maps/components/Map/featureRenders/index.ts

@@ -0,0 +1,3 @@
+export { MarkerFeatureRender } from './MarkerFeatureRender';
+
+export { CommonFeatureRender } from './CommonFeatureRender';

package/src/components/maps/components/Map/hooks/useAutoFocus/index.tsx

@@ -0,0 +1,124 @@
+// react
+import { useEffect } from 'react';
+import { useMap } from 'react-leaflet';
+// m4l
+// external libraries
+import  throttle  from 'lodash.throttle';
+import { shallow } from 'zustand/shallow';
+import L from 'leaflet';
+// componentes estilados
+// internal components
+// sub components
+// utils
+// hooks
+import useMapStore from '../useMapStore';
+
+// types
+import type { Feature, FeatureCollection } from '../../contexts/MapContext/types';
+import { FeatureData, LayerForBound, LayerWithFeatures } from './types';
+
+/**
+ * "useAutoFocus" esta pendiente de que las capas que tiene auto foucus y son visible o cuando cambien su features.
+ * en cambios su propiedad de autoFocus o visible, el Efecto de autonEnfoque se activa, haciendo
+ * que el mapa se ajuste a los límites de las capas que tienen auto focus.
+ * @author Juan Escobar
+ */
+export function useAutoFocus() {
+  const map = useMap();
+
+  const layerWithAutoFocus: LayerWithFeatures[] = useMapStore(state => {
+    return state.layersIds
+      .filter(lId => {
+        if (state.hashLayers[lId].autoFocus && state.hashLayers[lId].visible) {
+          return true;
+        }
+        return false;
+      })
+      .map(layerId => ({
+        layerId,
+        features: (function (): FeatureData[] {
+          if (state.hashLayers[layerId].geoJsonObject?.object.type === 'FeatureCollection') {
+            //Remove feature from featureCollection
+            const layer = state.hashLayers[layerId].geoJsonObject?.object as FeatureCollection;
+
+            return layer.features
+              .filter(feature => feature.layerData !== undefined)
+              .map(feature => ({ featureId: feature.id, layerData: feature.layerData }));
+          } else {
+            const feature = state.hashLayers[layerId].geoJsonObject?.object as Feature;
+
+            if (feature.layerData !== undefined) {
+              return [{ featureId: feature.id, layerData: feature.layerData }];
+            }
+          }
+
+          return [];
+        })(),
+      }));
+  }, shallow);
+
+  /** Efecto qe esta pendiente de los cambios de las capas con autofocus */
+  useEffect(() => {
+    /**
+     * Procesa las capas que tienen auto focus, y ajusta los límites del mapa
+     */
+    const proccesLayerWithAutoFocus = (layersFoucus: LayerWithFeatures[]) => {
+      const layersToFitBounds: LayerForBound[] = [];
+
+      for (const layerWhitFeatures of layersFoucus) {
+        const features = layerWhitFeatures?.features;
+
+        for (let i = 0; i < features.length; i++) {
+          const feature = features[i];
+
+          if (feature.layerData !== undefined) {
+            const featureForBounds = {
+              layerId: layerWhitFeatures.layerId,
+              featureId: feature.featureId,
+              layerData: feature.layerData,
+            };
+            layersToFitBounds.push(featureForBounds);
+            // Haz algo con los límites aquí
+          } else {
+            console.error(`La capa ${layerWhitFeatures.layerId} no tiene un método getBounds`);
+          }
+        }
+      }
+
+      if (layersToFitBounds.length > 0) {
+        let featureForBounds = layersToFitBounds[0];
+
+        let bounds: L.LatLngBounds = L.latLngBounds(
+          featureForBounds.layerData.boundsNW,
+          featureForBounds.layerData.boundsSE,
+        );
+
+        // Amplía los límites para incluir todas las capas
+        for (let i = 1; i < layersToFitBounds.length; i++) {
+          featureForBounds = layersToFitBounds[i];
+          const newBounds: L.LatLngBounds = L.latLngBounds(
+            featureForBounds.layerData.boundsNW,
+            featureForBounds.layerData.boundsSE,
+          );
+          bounds = bounds.extend(newBounds);
+        }
+
+        //Hay un bug con animate:true, no carga bien aunque los bounds son correctos.
+        //TODO: maxZoom, alineado con el TileLayer Actual
+        map.fitBounds(bounds, { animate: false, maxZoom: 22, padding: [50, 50] });
+      }
+    };
+
+    /**
+     * Funcion encargada de solo llamar proccesLayerWithAutoFocus cada cierto timeout, para evitar sobrecarga
+     * de toda la aplicación cuando son muchas figuras que cargan en el mapa
+     */
+    const throttleBounds = throttle(proccesLayerWithAutoFocus, 300, {
+      leading: false, // No enviar el primer evento de fitBounds
+      trailing: true, // Incluir siempre el ultimo evento en la cola, para que no quede se quedee a la mitad del fitBounds
+    });
+
+    throttleBounds(layerWithAutoFocus);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [layerWithAutoFocus]);
+}

package/src/components/maps/components/Map/hooks/useAutoFocus/types.ts

@@ -0,0 +1,18 @@
+import { FeatureId } from '../../contexts/MapContext';
+import { FeatureLayerData } from '../../contexts/MapContext/types';
+
+export type FeatureData = {
+  featureId: FeatureId;
+  layerData: FeatureLayerData | undefined;
+};
+
+export type LayerWithFeatures = {
+  layerId: string;
+  features: FeatureData[];
+};
+
+export type LayerForBound = {
+  layerId: string;
+  featureId: FeatureId;
+  layerData: FeatureLayerData;
+};

package/src/components/maps/components/Map/hooks/useDisableClickEvents/index.tsx

@@ -0,0 +1,47 @@
+// react
+import { useEffect, useRef } from 'react';
+import { useMap } from 'react-leaflet';
+import type { LeafletMouseEvent } from 'leaflet';
+
+// m4l
+
+// external libraries
+// componentes estilados
+
+// internal components
+// sub components
+// utils
+// hooks
+// types
+
+/**
+ * "useDisableClickEvents" se encarga de desactivar el click cuando se esta sobre
+ * el div que recibe como parámetro.
+ * @param nodeElement
+ */
+export function useDisableClickEvents(nodeElement: HTMLDivElement | null) {
+  const map = useMap();
+  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const clickHandlers = useRef<((event: LeafletMouseEvent) => void)[]>([]); // Guardar una referencia a los manejadores de eventos de click
+
+  // const cursorRef = useRef<string>('default'); // Guardar una referencia a los manejadores de eventos de click
+
+  useEffect(() => {
+    if (!map || !nodeElement) {return;}
+
+    // clickHandlers.current = (map as any)._events.click ? [...(map as any)._events.click.map((handler: any) => handler.fn)] : [];
+    // Desactivar el arrastre del mapa cuando el mouse está sobre el div
+    nodeElement.addEventListener('mouseover', function () {
+      // cursorRef.current = map.getContainer().style.cursor;
+      // map.off('click');
+    });
+
+    // Reactivar el arrastre del mapa cuando el mouse sale del div
+    nodeElement.addEventListener('mouseleave', function () {
+      // clickHandlers.current.forEach(handler => {
+      //   map.on('click', handler);
+      // });
+    });
+  }, [map, nodeElement]);
+}

package/src/components/maps/components/Map/hooks/useDisableZoomEvents/index.tsx

@@ -0,0 +1,38 @@
+// react
+import { useEffect } from 'react';
+import { useMap } from 'react-leaflet';
+// m4l
+
+// external libraries
+// componentes estilados
+
+// internal components
+// sub components
+// utils
+// hooks
+// types
+
+/**
+ * "useDisableZoomEvents" se encarga de desactivar el zoom por doble click y por scroll
+ * cuando se está sobre el div que recibe como parámetro.
+ * @param nodeElement
+ */
+export function useDisableZoomEvents(nodeElement: HTMLDivElement | null) {
+  const map = useMap();
+
+  useEffect(() => {
+    if (!map || !nodeElement) {return;}
+
+    // Desactivar el arrastre del mapa cuando el mouse está sobre el div
+    nodeElement.addEventListener('mouseover', function () {
+      map.doubleClickZoom.disable();
+      map.scrollWheelZoom.disable();
+    });
+
+    // Reactivar el arrastre del mapa cuando el mouse sale del div
+    nodeElement.addEventListener('mouseleave', function () {
+      map.scrollWheelZoom.enable();
+      map.doubleClickZoom.enable();
+    });
+  }, [map, nodeElement]);
+}

package/src/components/maps/components/Map/hooks/useMapStore/index.ts

@@ -0,0 +1,30 @@
+import { useContext } from 'react';
+import { useStore } from 'zustand';
+
+import { MapContext } from '../../contexts/MapContext/MapContext';
+import { MapStateWithActions } from '../../contexts/MapContext/types';
+
+// // ----------------------------------------------------------------------
+// export function useMapContext() {
+//     const context = useContext(MapContext);
+
+//     if (!context) throw new Error('useMap context must be use inside MapContext');
+
+//     return context;
+// }
+
+// ----------------------------------------------------------------------
+/**
+ * TODO: Documentar
+ */
+export function useMapStore<T>(
+  selector: (state: MapStateWithActions) => T,
+  equalityFn?: (left: T, right: T) => boolean,
+): T {
+  const context = useContext(MapContext);
+  if (!context) {throw new Error('useMapStore context must be use inside MapContext');}
+
+  return useStore(context, selector, equalityFn);
+}
+
+export default useMapStore;

package/src/components/maps/components/Map/icons.ts

@@ -0,0 +1,72 @@
+export const MAP_ICONS = {
+  /**
+   * Map en general
+   */
+
+  MAP_ZOOM_IN: 'cmp_map_zoom_in.svg',
+  MAP_ZOOM_OUT: 'cmp_map_zoom_out.svg',
+
+  /**
+   * Map sources
+   */
+
+  MAP_SOURCES_TOOL: 'cmp_map_mapsources_tool.svg',
+  MAP_SOURCE_OSM: 'cmp_map_mapsources_osm.svg',
+  MAP_SOURCE_GOOGLE_ROADS: 'cmp_map_mapsources_google.svg',
+  MAP_SOURCE_GOOGLE_HYBRID: 'cmp_map_mapsources_googlehybrid.svg',
+  MAP_SOURCE_GOOGLE_SATELLITE: 'cmp_map_mapsources_googlesatelite.svg',
+  MAP_SOURCE_BING: 'cmp_map_mapsources_bing.svg',
+
+  /**
+   * Map sources road options+
+   */
+
+  MAP_SOURCE_ROAD_TRAFFIC: 'cmp_map_mapsources_layer-traffic.svg',
+  MAP_SOURCE_ROAD_TRANSIT: 'cmp_map_mapsources_layer-transit.svg',
+  MAP_SOURCE_ROAD_BICYCLING: 'cmp_map_mapsources_layer-bicycle.svg',
+
+  /**
+   * Layers
+   */
+
+  MAP_LAYERS_TOOL: 'cmp_map_layers_tool.svg',
+  MAP_LAYER_VISIBLE: 'cmp_map_layers_view.svg',
+  MAP_LAYER_AUTOFOCUS: 'cmp_map_layers_zoom_fit.svg',
+  MAP_LAYER_CLUSTER: 'cmp_map_layers_cluster.svg',
+  MAP_LAYER_DELETE: 'cmp_map_layers_delete.svg',
+
+  ADD: 'add.svg',
+
+  /**
+   * Measure Tool *
+   *
+   */
+
+  MAP_GPS_TOOLS_TOOL: 'cmp_map_gpstools_tool.svg',
+
+  MAP_MEASURE_TOOL: 'cmp_map_measure_tool.svg',
+
+  GENERAL: 'general.svg',
+  CONFIG: 'config.svg',
+  STROKE: 'stroke.svg',
+  FILL: 'fill.svg',
+  // REFRESH: 'refresh.svg',
+
+  // ENABLED: 'enabled.svg',
+  // DISABLED: 'disabled.svg',
+  EDIT: 'edit.svg',
+  DELETE: 'delete.svg',
+  ACTIVE: 'active.svg',
+  NAME: 'name.svg',
+  // EMAIL: 'email.svg',
+  // USER: 'users.svg',
+  // FIRSTNAME: 'first_name.svg',
+  // LASTNAME: 'last_name.svg',
+  // MAIN_PHONE: 'fixed_phone.svg',
+  // SECONDARY_PHONE: 'fixed_phone.svg',
+  // CREATED_AT: 'created_at.svg',
+  // UPDATED_AT: 'updated_at.svg',
+  // VIEW_DETAIL: 'view_detail.svg',
+
+  // USERS: 'users.svg',
+};

package/src/components/maps/components/Map/index.ts

@@ -0,0 +1,25 @@
+export { MyMap as Map } from './Map';
+
+export type { MapProps } from './types';
+export { MapProvider, MapContext } from './contexts/MapContext/MapContext';
+export { useMapStore } from './hooks/useMapStore';
+
+export type {
+  RendePropFeatureArgs,
+  ComponentRenderPropFeature,
+  FeatureId,
+  FeatureCollection,
+  Feature,
+  Geometry,
+} from './contexts/MapContext';
+
+export * from './featureRenders';
+
+export * from './popups';
+
+export { getMapComponentsDictionary } from './dictionary';
+
+//Plugin layers
+export * from './pluginLayers';
+
+// export type { LatLngBoundsLiteral, LatLngLiteral, LatLng } from 'leaflet';