@m4l/gclick 0.0.2

package/components/maps/components/GpsMap/featureRenders/DeviceFeatureRender/index.js

@@ -0,0 +1,112 @@
+import { jsx } from "react/jsx-runtime";
+import { shallow } from "zustand/shallow";
+import { u as useMapStore } from "../../hooks/useMapStore/index.js";
+import { useCallback } from "react";
+import { a as LABEL_COLOR_DEFAULT, L as LABEL_BK_COLOR_DEFAULT } from "../../constants.js";
+import { M as MarkerIconLabel } from "../MarkerIconLabel/index.js";
+import { F as FALLBACK_SVG } from "./constants.js";
+import { useSvgColor, SKELETON_SVG_ICON } from "@m4l/components";
+import { u as useDeviceStatus } from "../../../../../DeviceStatus/hooks/useDeviceStatus.js";
+import { useEnvironment, getPropertyByString } from "@m4l/core";
+import { c as courseToCssAngle } from "../../../../utils/courseToCssAngle.js";
+const DeviceFeatureRender = (props) => {
+  const { id, layerId } = props;
+  const feature = useMapStore((state) => {
+    const gObject = state.hashLayers[layerId].geoJsonObject;
+    if (!gObject) {
+      return null;
+    }
+    if (gObject.object.type === "Feature") {
+      return null;
+    }
+    const feat = gObject.object.features.find((f) => f.id === id);
+    if (feat) {
+      if (!(feat.geometry.type === "Point" && feat.properties?.subType === "Marker")) {
+        return null;
+      }
+      return {
+        id: feat.id,
+        geometry: feat.geometry,
+        properties: feat.properties,
+        featureLabel: feat.featureLabel,
+        popupRender: state.hashLayers[layerId].popupComponent,
+        popupOptions: state.hashLayers[layerId].popupOptions
+      };
+    }
+    return null;
+  }, shallow);
+  const { host_static_assets, environment_assets } = useEnvironment();
+  const propFeature = {
+    featureId: feature?.id
+  };
+  const {
+    deviceData
+  } = feature?.properties || { deviceData: void 0 };
+  const { iconKey, filteredCourse, label: statusLabel, palletColor: statusPalletColor, speed } = useDeviceStatus({ deviceData, withLabel: true });
+  const iconRotate = courseToCssAngle(filteredCourse || 0, 0);
+  const color = deviceData?.settings?.group?.color || LABEL_COLOR_DEFAULT;
+  const bgColor = deviceData?.settings?.group?.bgColor || LABEL_BK_COLOR_DEFAULT;
+  const src = `${host_static_assets}/${environment_assets}/frontend/components/device_status/assets/icons/${iconKey}_contained.svg`;
+  const markerLabel = deviceData?.settings?.name || "name";
+  const reportTime = new Date(getPropertyByString(deviceData, "current.vpts.vptModem.lastConnection.value", (/* @__PURE__ */ new Date()).toISOString()));
+  const reportStatus = new Date(getPropertyByString(deviceData, "current.vpts.vptGnss.status.udaptedAt", (/* @__PURE__ */ new Date()).toISOString()));
+  const [lng, lat] = feature?.geometry?.coordinates || [0, 0];
+  const svg = useSvgColor({
+    src,
+    cacheKey: iconKey,
+    //Id del icono
+    primaryColor: bgColor,
+    secondaryColor: color,
+    skeletonIcon: SKELETON_SVG_ICON,
+    fallBackIcon: FALLBACK_SVG
+  });
+  const { addLayerDataToFeature } = useMapStore((state) => state.mapActions, shallow);
+  const onAddPointLayer = useCallback((e) => {
+    if (!feature) {
+      return;
+    }
+    const layerData = {
+      // visible: true,
+      boundsNW: e.target?._latlng,
+      boundsSE: e.target?._latlng,
+      getTarget: () => e.target
+      // {
+      //   id: e.target?._leaflet_id,
+      //   openPopup: e.target?.openPopup,
+      // },
+      // target: e.target,
+    };
+    addLayerDataToFeature(layerId, feature.id, layerData);
+  }, [feature]);
+  if (!feature || !svg) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(
+    MarkerIconLabel,
+    {
+      position: { lat, lng },
+      ...{
+        label: markerLabel,
+        iconSrc: svg.dataWithColor,
+        iconScale: 1,
+        iconRotate,
+        iconWidth: 38,
+        iconHeight: 38,
+        labelBkColor: bgColor,
+        labelColor: color,
+        offsetLeftTop: [42, 0]
+      },
+      draggable: false,
+      eventHandlers: {
+        add: onAddPointLayer
+      },
+      popupRender: feature.popupRender,
+      properties: { ...feature.properties, statusLabel, statusPalletColor, reportTime, reportStatus, speed, iconKey },
+      popupOptions: feature.popupOptions,
+      ...propFeature
+    }
+  );
+};
+export {
+  DeviceFeatureRender as D
+};

package/components/maps/components/GpsMap/featureRenders/FeatureDivIconLabel/index.d.ts

@@ -0,0 +1,6 @@
+import { default as L } from 'leaflet';
+import { DivIconFeatureDescriptionProps } from './types';
+/**
+ * TODO: Documentar
+ */
+export declare const FeatureDivIconLabel: (props: DivIconFeatureDescriptionProps) => L.DivIcon;

package/components/maps/components/GpsMap/featureRenders/FeatureDivIconLabel/index.js

@@ -0,0 +1,33 @@
+import L__default from "leaflet";
+import { L as LABEL_BK_COLOR_DEFAULT, a as LABEL_COLOR_DEFAULT } from "../../constants.js";
+import { m as mapClasses } from "../../classes/index.js";
+import clsx from "clsx";
+const FeatureDivIconLabel = (props) => {
+  const {
+    label,
+    iconSrc,
+    iconScale: scale = 1,
+    iconRotate,
+    labelBkColor: bkColor = LABEL_BK_COLOR_DEFAULT,
+    labelColor: color = LABEL_COLOR_DEFAULT,
+    iconWidth = 24,
+    iconHeight = 24,
+    offsetLeftTop = [24, 0]
+  } = props;
+  let html = label ? `<div class="${mapClasses.featureLabel}" 
+                style="background-color:${bkColor}; color:${color};left:${offsetLeftTop[0]}px;top:${offsetLeftTop[1]}px;">${label}</div>` : "";
+  if (iconSrc) {
+    html = `<div class="${mapClasses.markerLayerIcon}" style="transform: rotate(${iconRotate}deg) scale(${scale}); transform-origin: center center;">
+                    <img src=${iconSrc}></img>
+                </div>` + html;
+  }
+  return L__default.divIcon({
+    className: clsx(mapClasses.markerLayerRoot, ""),
+    iconSize: [iconWidth, iconHeight],
+    // iconAnchor: [-width, height/2],
+    html
+  });
+};
+export {
+  FeatureDivIconLabel as F
+};

package/components/maps/components/GpsMap/featureRenders/FeatureDivIconLabel/types.d.ts

@@ -0,0 +1,7 @@
+import { FeatureIconLabel } from '../../contexts/MapContext/types';
+export interface DivIconFeatureDescriptionProps extends FeatureIconLabel {
+    withPoint?: boolean;
+    iconSrc?: string;
+    iconRotate?: number;
+    iconScale?: number;
+}

package/components/maps/components/GpsMap/featureRenders/MarkerFeatureRender/IconMarker.d.ts

@@ -0,0 +1,9 @@
+export type IconForm = 'grua' | 'taxi';
+export interface IconMarkerProps {
+    iconForm: string;
+    bearing: number;
+}
+/**
+ * TODO: Documentar
+ */
+export declare function IconMarker(props: IconMarkerProps): import("react/jsx-runtime").JSX.Element;

package/components/maps/components/GpsMap/featureRenders/MarkerFeatureRender/IconMarkerGrua.d.ts

@@ -0,0 +1,4 @@
+/**
+ * TODO: Documentar
+ */
+export declare function GruaIconMarker(): import("react/jsx-runtime").JSX.Element;

package/components/maps/components/GpsMap/featureRenders/MarkerFeatureRender/IconMarkerTaxi.d.ts

@@ -0,0 +1,4 @@
+/**
+ * TODO: Documentar
+ */
+export declare function IconMarkerTaxi(): import("react/jsx-runtime").JSX.Element;

package/components/maps/components/GpsMap/featureRenders/MarkerFeatureRender/index.d.ts

@@ -0,0 +1,5 @@
+import { ComponentRenderPropFeature } from '../../contexts/MapContext';
+/**
+ * TODO: Documentar
+ */
+export declare const MarkerFeatureRender: ComponentRenderPropFeature;

package/components/maps/components/GpsMap/featureRenders/MarkerFeatureRender/index.js

@@ -0,0 +1,80 @@
+import { jsx } from "react/jsx-runtime";
+import { Marker } from "react-leaflet";
+import { shallow } from "zustand/shallow";
+import { useMemo } from "react";
+import L__default from "leaflet";
+import { u as useMapStore } from "../../hooks/useMapStore/index.js";
+function CustomMarker(props) {
+  const { position, width, height, iconForm, bearing, ...other } = props;
+  const html = useMemo(() => {
+  }, [bearing]);
+  const customIcon = useMemo(() => {
+    return L__default.divIcon({
+      className: "custom-icon",
+      iconSize: [width, height],
+      html: `<div>Hola</div>`
+    });
+  }, [html]);
+  return /* @__PURE__ */ jsx(
+    Marker,
+    {
+      position,
+      icon: customIcon,
+      autoPan: true,
+      ...other
+    }
+  );
+}
+const MarkerFeatureRender = (props) => {
+  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>
+      /* @__PURE__ */ jsx(
+        CustomMarker,
+        {
+          position: { lat, lng },
+          width: 32,
+          height: 32,
+          bearing,
+          iconForm: "grua",
+          id: feature.id
+        }
+      )
+    );
+  }
+  return null;
+};
+export {
+  MarkerFeatureRender as M
+};

package/components/maps/components/GpsMap/featureRenders/MarkerIconLabel/index.d.ts

@@ -0,0 +1,5 @@
+import { FeatureDescriptionProps } from './types';
+/**
+ * TODO: Documentar
+ */
+export declare const MarkerIconLabel: (props: FeatureDescriptionProps) => import("react/jsx-runtime").JSX.Element;

package/components/maps/components/GpsMap/featureRenders/MarkerIconLabel/index.js

@@ -0,0 +1,83 @@
+import { jsx } from "react/jsx-runtime";
+import { Marker } from "react-leaflet";
+import { F as FeatureDivIconLabel } from "../FeatureDivIconLabel/index.js";
+import { useState, useRef, useCallback } from "react";
+const MarkerIconLabel = (props) => {
+  const {
+    position,
+    draggable = true,
+    iconSrc,
+    iconRotate,
+    iconScale: scale,
+    className,
+    label,
+    markerColor,
+    labelBkColor: bkColor,
+    labelColor: color,
+    iconWidth,
+    iconHeight,
+    offsetLeftTop,
+    eventHandlers,
+    popupRender,
+    properties,
+    popupOptions,
+    ...others
+  } = props;
+  const [isOpen, setIsOpen] = useState(false);
+  const markerRef = useRef(null);
+  const makerIcon = FeatureDivIconLabel({
+    iconSrc,
+    iconRotate,
+    iconScale: scale,
+    label,
+    iconWidth,
+    iconHeight,
+    labelBkColor: bkColor,
+    labelColor: color,
+    offsetLeftTop
+  });
+  const PopupRender = popupRender;
+  const { onOpenPopup, onClosePopup } = properties || { onOpenPopup: void 0, onClosePopup: void 0 };
+  const onPopupOpenLocal = useCallback((_e) => {
+    if (onOpenPopup && properties) {
+      onOpenPopup(properties);
+    }
+    setIsOpen(true);
+  }, [onOpenPopup, properties]);
+  const onPopupCloseLocal = useCallback((_e) => {
+    if (onClosePopup && properties) {
+      onClosePopup(properties);
+    }
+    setIsOpen(false);
+  }, [onClosePopup, properties]);
+  return /* @__PURE__ */ jsx(
+    Marker,
+    {
+      ref: markerRef,
+      position,
+      draggable,
+      riseOnHover: true,
+      icon: makerIcon,
+      eventHandlers: {
+        ...eventHandlers,
+        click: (_e) => {
+        },
+        popupopen: onPopupOpenLocal,
+        popupclose: onPopupCloseLocal
+      },
+      ...others,
+      children: PopupRender && properties && /* @__PURE__ */ jsx(
+        PopupRender,
+        {
+          isOpen,
+          properties,
+          position,
+          popupOptions
+        }
+      )
+    }
+  );
+};
+export {
+  MarkerIconLabel as M
+};

package/components/maps/components/GpsMap/featureRenders/MarkerIconLabel/types.d.ts

@@ -0,0 +1,15 @@
+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 MyPopupProps extends PopupOptions {
+    onOpen?: (properties: GeoJsonProperties) => void;
+}
+export interface FeatureDescriptionProps extends DivIconFeatureDescriptionProps, Omit<MarkerProps, 'children'> {
+    withPoint?: boolean;
+    popupRender?: MapPopupComponent | undefined;
+    properties?: GeoJsonProperties;
+    popupOptions?: Omit<MyPopupProps, 'content'>;
+    [name: string]: any;
+}

package/components/maps/components/GpsMap/featureRenders/index.d.ts

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

package/components/maps/components/GpsMap/featureRenders/index.js

@@ -0,0 +1 @@
+

package/components/maps/components/GpsMap/hooks/useAutoFocus/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * "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 declare function useAutoFocus(): void;

package/components/maps/components/GpsMap/hooks/useAutoFocus/index.js

@@ -0,0 +1,78 @@
+import { useEffect } from "react";
+import { useMap } from "react-leaflet";
+import throttle from "lodash-es/throttle";
+import { shallow } from "zustand/shallow";
+import L__default from "leaflet";
+import { u as useMapStore } from "../useMapStore/index.js";
+function useAutoFocus() {
+  const map = useMap();
+  const layerWithAutoFocus = 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() {
+        if (state.hashLayers[layerId].geoJsonObject?.object.type === "FeatureCollection") {
+          const layer = state.hashLayers[layerId].geoJsonObject?.object;
+          return layer.features.filter((feature) => feature.layerData !== void 0).map((feature) => ({ featureId: feature.id, layerData: feature.layerData }));
+        } else {
+          const feature = state.hashLayers[layerId].geoJsonObject?.object;
+          if (feature.layerData !== void 0) {
+            return [{ featureId: feature.id, layerData: feature.layerData }];
+          }
+        }
+        return [];
+      }()
+    }));
+  }, shallow);
+  useEffect(() => {
+    const proccesLayerWithAutoFocus = (layersFoucus) => {
+      const layersToFitBounds = [];
+      for (const layerWhitFeatures of layersFoucus) {
+        const features = layerWhitFeatures?.features;
+        for (let i = 0; i < features.length; i++) {
+          const feature = features[i];
+          if (feature.layerData !== void 0) {
+            const featureForBounds = {
+              layerId: layerWhitFeatures.layerId,
+              featureId: feature.featureId,
+              layerData: feature.layerData
+            };
+            layersToFitBounds.push(featureForBounds);
+          } else {
+            console.error(`La capa ${layerWhitFeatures.layerId} no tiene un método getBounds`);
+          }
+        }
+      }
+      if (layersToFitBounds.length > 0) {
+        let featureForBounds = layersToFitBounds[0];
+        let bounds = L__default.latLngBounds(
+          featureForBounds.layerData.boundsNW,
+          featureForBounds.layerData.boundsSE
+        );
+        for (let i = 1; i < layersToFitBounds.length; i++) {
+          featureForBounds = layersToFitBounds[i];
+          const newBounds = L__default.latLngBounds(
+            featureForBounds.layerData.boundsNW,
+            featureForBounds.layerData.boundsSE
+          );
+          bounds = bounds.extend(newBounds);
+        }
+        map.fitBounds(bounds, { animate: false, maxZoom: 22, padding: [50, 50] });
+      }
+    };
+    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);
+  }, [layerWithAutoFocus]);
+}
+export {
+  useAutoFocus as u
+};

package/components/maps/components/GpsMap/hooks/useAutoFocus/types.d.ts

@@ -0,0 +1,15 @@
+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/components/maps/components/GpsMap/hooks/useDisableClickEvents/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * "useDisableClickEvents" se encarga de desactivar el click cuando se esta sobre
+ * el div que recibe como parámetro.
+ * @param nodeElement
+ */
+export declare function useDisableClickEvents(nodeElement: HTMLDivElement | null): void;

package/components/maps/components/GpsMap/hooks/useDisableZoomEvents/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * "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 declare function useDisableZoomEvents(nodeElement: HTMLDivElement | null): void;

package/components/maps/components/GpsMap/hooks/useDisableZoomEvents/index.js

@@ -0,0 +1,21 @@
+import { useEffect } from "react";
+import { useMap } from "react-leaflet";
+function useDisableZoomEvents(nodeElement) {
+  const map = useMap();
+  useEffect(() => {
+    if (!map || !nodeElement) {
+      return;
+    }
+    nodeElement.addEventListener("mouseover", function() {
+      map.doubleClickZoom.disable();
+      map.scrollWheelZoom.disable();
+    });
+    nodeElement.addEventListener("mouseleave", function() {
+      map.scrollWheelZoom.enable();
+      map.doubleClickZoom.enable();
+    });
+  }, [map, nodeElement]);
+}
+export {
+  useDisableZoomEvents as u
+};

package/components/maps/components/GpsMap/hooks/useMapStore/index.d.ts

@@ -0,0 +1,6 @@
+import { MapStateWithActions } from '../../contexts/MapContext/types';
+/**
+ * TODO: Documentar
+ */
+export declare function useMapStore<T>(selector: (state: MapStateWithActions) => T, equalityFn?: (left: T, right: T) => boolean): T;
+export default useMapStore;

package/components/maps/components/GpsMap/hooks/useMapStore/index.js

@@ -0,0 +1,13 @@
+import { useContext } from "react";
+import { useStore } from "zustand";
+import { M as MapContext } from "../../contexts/MapContext/MapContext.js";
+function useMapStore(selector, equalityFn) {
+  const context = useContext(MapContext);
+  if (!context) {
+    throw new Error("useMapStore context must be use inside MapContext");
+  }
+  return useStore(context, selector, equalityFn);
+}
+export {
+  useMapStore as u
+};

package/components/maps/components/GpsMap/icons.d.ts

@@ -0,0 +1,45 @@
+export declare const MAP_ICONS: {
+    /**
+     * Map en general
+     */
+    MAP_ZOOM_IN: string;
+    MAP_ZOOM_OUT: string;
+    /**
+     * Map sources
+     */
+    MAP_SOURCES_TOOL: string;
+    MAP_SOURCE_OSM: string;
+    MAP_SOURCE_GOOGLE_ROADS: string;
+    MAP_SOURCE_GOOGLE_HYBRID: string;
+    MAP_SOURCE_GOOGLE_SATELLITE: string;
+    MAP_SOURCE_BING: string;
+    /**
+     * Map sources road options+
+     */
+    MAP_SOURCE_ROAD_TRAFFIC: string;
+    MAP_SOURCE_ROAD_TRANSIT: string;
+    MAP_SOURCE_ROAD_BICYCLING: string;
+    /**
+     * Layers
+     */
+    MAP_LAYERS_TOOL: string;
+    MAP_LAYER_VISIBLE: string;
+    MAP_LAYER_AUTOFOCUS: string;
+    MAP_LAYER_CLUSTER: string;
+    MAP_LAYER_DELETE: string;
+    ADD: string;
+    /**
+     * Measure Tool *
+     *
+     */
+    MAP_GPS_TOOLS_TOOL: string;
+    MAP_MEASURE_TOOL: string;
+    GENERAL: string;
+    CONFIG: string;
+    STROKE: string;
+    FILL: string;
+    EDIT: string;
+    DELETE: string;
+    ACTIVE: string;
+    NAME: string;
+};

package/components/maps/components/GpsMap/icons.js

@@ -0,0 +1,39 @@
+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",
+  /**
+   * Measure Tool *
+   *
+   */
+  MAP_GPS_TOOLS_TOOL: "cmp_map_gpstools_tool.svg",
+  MAP_MEASURE_TOOL: "cmp_map_measure_tool.svg"
+};
+export {
+  MAP_ICONS as M
+};

package/components/maps/components/GpsMap/index.d.ts

@@ -0,0 +1,9 @@
+export { GpsMap } from './GpsMap';
+export type { MapProps } from './types';
+export { MapProvider, MapContext } from './contexts/MapContext/MapContext';
+export { useMapStore } from './hooks/useMapStore';
+export * from './contexts/MapContext';
+export * from './featureRenders';
+export * from './popups';
+export { getMapComponentsDictionary } from './dictionary';
+export * from './pluginLayers';

package/components/maps/components/GpsMap/index.js

@@ -0,0 +1 @@
+

package/components/maps/components/GpsMap/pluginLayers/PolylineWithArrows/index.d.ts

@@ -0,0 +1,11 @@
+import { LatLngExpression } from 'leaflet';
+import { PolylineProps } from 'react-leaflet';
+interface PolylineWithArrowsProps extends PolylineProps {
+    positions: LatLngExpression[];
+    enableEdit?: boolean;
+}
+/**
+ * TODO: Documentar
+ */
+export declare const PolylineWithArrows: React.FC<PolylineWithArrowsProps>;
+export default PolylineWithArrows;