@m4l/gclick 0.0.2

package/components/maps/components/GpsMap/contexts/MapContext/types.d.ts

@@ -0,0 +1,569 @@
+import { GetLabelType } from '@m4l/core';
+import { ReactNode } from 'react';
+import { MapClasses } from '../../classes/types';
+import { default as L, Layer, LeafletEvent, PopupOptions } from 'leaflet';
+import { MapPopupComponent } from '../../popups/types';
+export type FeatureId = string | number;
+/**
+ * The valid values for the "type" property of GeoJSON* geometry objects.
+ * https://tools.ietf.org/html/rfc7946#section-1.4
+ */
+export type GeoJsonGeometryTypes = Geometry['type'];
+/**
+ * The value values for the "type" property of GeoJSON* Objects.
+ * https://tools.ietf.org/html/rfc7946#section-1.4
+ */
+export type GeoJsonTypes = GeoJSON['type'];
+/**
+ * Bounding box
+ * https://tools.ietf.org/html/rfc7946#section-5
+ */
+export type BBox = [number, number, number, number] | [number, number, number, number, number, number];
+/**
+ * A Position is an array of coordinates.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.1
+ * Array should contain between two and three elements.
+ * The previous GeoJSON specification allowed more elements (e.g., which could be used to represent M values),
+ * but the current specification only allows X, Y, and (optionally) Z to be defined.
+ */
+export type Position = number[];
+/**
+ * The base GeoJSON object.
+ * https://tools.ietf.org/html/rfc7946#section-3
+ * The GeoJSON specification also allows foreign members
+ * (https://tools.ietf.org/html/rfc7946#section-6.1)
+ * Developers should use "&" type in TypeScript or extend the interface
+ * to add these foreign members.
+ */
+export interface GeoJsonObject {
+    /**
+     * Specifies the type of GeoJSON object.
+     */
+    type: GeoJsonTypes;
+    /**
+     * Bounding box of the coordinate range of the object's Geometries, Features, or Feature Collections.
+     * The value of the bbox member is an array of length 2*n where n is the number of dimensions
+     * represented in the contained geometries, with all axes of the most southwesterly point
+     * followed by all axes of the more northeasterly point.
+     * The axes order of a bbox follows the axes order of geometries.
+     * https://tools.ietf.org/html/rfc7946#section-5
+     */
+    bbox?: BBox | undefined;
+}
+/**
+ * Union of GeoJSON objects.
+ */
+export type GeoJSON = Geometry | Feature | FeatureCollection;
+/**
+ * Geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3
+ */
+export type Geometry = Point | MultiPoint | LineString | MultiLineString | Polygon | MultiPolygon | GeometryCollection;
+export type GeometryObject = Geometry;
+/**
+ * Point geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.2
+ */
+export interface Point extends GeoJsonObject {
+    type: 'Point';
+    coordinates: Position;
+}
+/**
+ * MultiPoint geometry object.
+ *  https://tools.ietf.org/html/rfc7946#section-3.1.3
+ */
+export interface MultiPoint extends GeoJsonObject {
+    type: 'MultiPoint';
+    coordinates: Position[];
+}
+/**
+ * LineString geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.4
+ */
+export interface LineString extends GeoJsonObject {
+    type: 'LineString';
+    coordinates: Position[];
+}
+/**
+ * MultiLineString geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.5
+ */
+export interface MultiLineString extends GeoJsonObject {
+    type: 'MultiLineString';
+    coordinates: Position[][];
+}
+/**
+ * Polygon geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.6
+ */
+export interface Polygon extends GeoJsonObject {
+    type: 'Polygon';
+    coordinates: Position[][];
+}
+/**
+ * MultiPolygon geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.7
+ */
+export interface MultiPolygon extends GeoJsonObject {
+    type: 'MultiPolygon';
+    coordinates: Position[][][];
+}
+/**
+ * Geometry Collection
+ * https://tools.ietf.org/html/rfc7946#section-3.1.8
+ */
+export interface GeometryCollection<G extends Geometry = Geometry> extends GeoJsonObject {
+    type: 'GeometryCollection';
+    geometries: G[];
+}
+export type SubTypeType = 'Marker' | 'CustomMarker' | 'Circle' | 'Rectangle' | 'Polyline' | 'PolylineWithArrows';
+export type GeoJsonBaseProperties = {
+    /**
+     * "className" Clase del icono de la marca
+     */
+    className?: string;
+    /**
+     * propiedad generica
+     */
+    [name: string]: any;
+};
+export interface FeatureIconLabel {
+    label?: string;
+    labelColor?: string;
+    labelBkColor?: string;
+    iconWidth?: number;
+    iconHeight?: number;
+    offsetLeftTop?: [number, number];
+    [name: string]: any;
+}
+export type GeoJsonMarkerProperties = GeoJsonBaseProperties & {
+    subType: 'Marker';
+    [name: string]: any;
+};
+export type GeoJsonPolylineWithArrowsProperties = GeoJsonBaseProperties & {
+    subType: 'PolylineWithArrows';
+};
+export type GeoJsonCircleProperties = GeoJsonBaseProperties & {
+    subType: 'Circle';
+    radius: number;
+};
+export type GeoJsonProperties = GeoJsonMarkerProperties | GeoJsonCircleProperties | GeoJsonPolylineWithArrowsProperties;
+export type LayerWithBounds = Layer;
+export type FeatureLayerData = {
+    boundsNW: L.LatLng;
+    boundsSE: L.LatLng;
+    getTarget: () => Layer;
+};
+/**
+ * A feature object which contains a geometry and associated properties.
+ * https://tools.ietf.org/html/rfc7946#section-3.2
+ */
+export interface Feature<G extends Geometry | null = Geometry, P = GeoJsonProperties> extends GeoJsonObject {
+    type: 'Feature';
+    /**
+     * The feature's geometry
+     */
+    geometry: G;
+    /**
+     * A value that uniquely identifies this feature in a
+     * https://tools.ietf.org/html/rfc7946#section-3.2.
+     */
+    id: FeatureId;
+    /**
+     * Properties associated with this feature.
+     */
+    properties: P;
+    /**
+     * "getLeafletLayer" es una función que retorna la capa de leaflet que creo renderFeature
+     * set usa esta metodología, porque guarda toda la capa en zustand, es muy pesado, al guardar
+     * solo funciones, se ahorra memoria.
+     */
+    layerData?: FeatureLayerData;
+    /**
+     * "featureLabel" Etiqueta de la geometria, undenfined si no se quiere mostrar
+     */
+    featureLabel?: FeatureIconLabel;
+    juan?: string;
+}
+/**
+ * A collection of feature objects.
+ *  https://tools.ietf.org/html/rfc7946#section-3.3
+ */
+export interface FeatureCollection<G extends Geometry | null = Geometry, P = GeoJsonProperties> extends GeoJsonObject {
+    type: 'FeatureCollection';
+    features: Array<Feature<G, P>>;
+}
+export type RealTimeConfig = {
+    /**
+     *  "active" si está activa la funcionalidad de tiempo real
+     */
+    active: boolean;
+    /**
+     *  "userCanDeactivateTail" El usario puede temporalmente desactivar la cola de un punto de tipo tiemo real.
+     */
+    userCanDeactivateTail: boolean;
+    /**
+     * "maxZoom" Maximo zoom donde se muestra la cola.
+     */
+    maxZoom: number;
+    /**
+     * qtyTailPointsMax Cantidad de puntos de la cola de tiempo real.
+     */
+    qtyTailPointsMax: number;
+    /**
+     * "windowTailTime" Ventana de tiempo para no generar una cola retrasa en el mapa. ejemplo 30 segundos.
+     * Eventos fuera de este tiempo con respecto al primer punto no se deberían visualizaar evitando colas fantasma por  tanto no confiables.
+     */
+    windowTailTime: number;
+};
+export type PointType = 'point' | 'cluster';
+/**
+ * Argumentos que recibe una Render Prop cuando se renderiza por renderFeature
+ */
+export interface RendePropFeatureArgs {
+    id: FeatureId;
+    /**
+     *  "layerId" si está activa la funcionalidad de tiempo real
+     */
+    layerId: string;
+}
+/**
+ * Argumentos que recibe una Render Prop cuando se renderiza por renderFeature
+ */
+export interface RendePropFeaturesCollectionArgs extends FeatureCollection {
+    /**
+     * "id" identificado unico del feature
+     * En la capa multipoints clusteable:
+     *        el id se forma con el patron: device_device_id O cluster_CRCDevicesIds_count
+     * Si la capa es multilines
+     *        el id normalmente es el indice del array de multilines
+     *
+     * TODO: Se debe hacer el esfuerzo de memonizar los ids
+     */
+    id: string;
+    /**
+     *  "layerId" si está activa la funcionalidad de tiempo real
+     */
+    layerId: string;
+}
+export interface GeoJsonImplementedObject {
+    /**
+     * Specifies the type of GeoJSON object.
+     */
+    object: Feature | FeatureCollection;
+    /**
+     * TODO: Documentar
+     */
+    bbox?: BBox | undefined;
+}
+export type CheckedNameSet = 'visible' | 'autoFocus' | 'cluster';
+export type LayerStore = {
+    /**
+     * "layerId" Indetificador unico entre todas las capas
+     */
+    layerId: string;
+    /**
+     * "name" Como se va a ver el listado de capas
+     */
+    name?: string;
+    /**
+     * "visible" si es visible o no
+     */
+    visible?: boolean;
+    /**
+     * "autoFocus" Cuando cambia el contedido de las capas, tener esta capa para incluir en el foco global
+     * del mapa. Por defecto es false
+     */
+    autoFocus: boolean;
+    /**
+     * "clusterAble" indica si la capa es clusterizable. (Solo aplica capa tipo multipoints)
+     */
+    clusterAble?: boolean;
+    /**
+     * "deleteAble" indica si la capa es borrable por el usuario
+     */
+    deleteAble?: boolean;
+    /**
+     * "cluster" Cuando la capa es ta enmodo cluster, indica que si las marcas se intersectan
+     * debe se grupadas en un icono en indicar cuantas maras hay en el cluster
+     */
+    cluster?: boolean;
+    /**
+     * "geoJsonObject" inidica cual es objeto as rederizas (Un sola capa Feature o FeatureCollection)
+     * y los bounds del objeto TODO: depront bounds debe ir directamene en el feature.
+     * TODO: Incluir el bounds en la capa de leaftLayer para dar mayor velocidad al mapa CREO.
+     */
+    geoJsonObject?: GeoJsonImplementedObject;
+    /**
+     * "renderFeature" render prop encarga de renderizar cada feature
+     */
+    renderFeature?: ComponentRenderPropFeature;
+    /**
+     * "popupComponent" componente que se renderiza en el popup, en la capa tipo Point o Multipoints
+     */
+    popupComponent?: MapPopupComponent;
+    /**
+     * "popupOptions" opciones del popup
+     */
+    popupOptions?: Omit<PopupOptions, 'content'>;
+    onClick?: (e: LeafletEvent) => void;
+};
+export type ComponentRenderPropFeature = React.FC<RendePropFeatureArgs>;
+export type ComponentRenderPropFeaturesCollection = React.FC<RendePropFeaturesCollectionArgs>;
+/**
+ * Interface usada para inicializar una capa tipo Multipoints desde el MapProvider
+ */
+export type InitialLayer = LayerStore;
+/**
+ * interfaz usada para actualizar un feature especifico de la capa
+ */
+export interface ForSetSingleFeatureData extends Feature {
+    featureId?: string;
+    jsonUri?: string;
+}
+export type MapStatus = 'init' | 'ready';
+export type OwnerState = {
+    status: MapStatus;
+    /**
+     *  "isMobile" cuando el navegador está en modo celular
+     */
+    isMobile: boolean;
+    /**
+     *  "isSkeleton" indica si el componente está en skeleton.
+     */
+    isSkeleton: boolean;
+    /**
+     * focus: Estado de selección asignado por el usuario.
+     *
+     */
+    focus: boolean;
+};
+/**
+ * Estados que se actulizan por fuera del store, a través de hooks
+ */
+export type ExternalOwnerState = Pick<OwnerState, 'isMobile' | 'isSkeleton'>;
+export type AreaMapType = {
+    leftLowerLatitudeOffset: number;
+    leftLowerLengthOffset: number;
+    rigthUpperLatitudeOffset: number;
+    rigthUpperLengthOffset: number;
+    mapLengthDelta: number;
+    leftLowerLength: number;
+    mapLatBottomDegree: number;
+};
+export type SourceTypeTile = 'OSM' | 'Google' | 'Bing' | 'GoogleNoKey';
+export type mapTypeTile = 'roadmap' | 'satellite' | 'terrain' | 'hybrid';
+export type MapSourceId = 'osm_roadmap' | 'google_rodmap' | 'google_satellite' | 'google_hybrid' | 'bing_rodmap' | string;
+export type RoadOptionsType = {
+    bicyclingLayer: boolean;
+    trafficLayer: boolean;
+    transitLayer: boolean;
+};
+export type TileLayerSource = {
+    /**
+     * "id" identificador unico de la fuente de capas
+     */
+    id: MapSourceId;
+    /**
+     * "dictionaryId" identificador del diccionario
+     */
+    dictionaryId: string;
+    /**
+     * "iconUrl" url del icono de la fuente de capas
+     */
+    iconUrl: string;
+    /**
+     * "sourceType" Tipo de fuente de capas
+     */
+    sourceType: SourceTypeTile;
+    /**
+     * "mapTypeTile" Tipo de mapa
+     */
+    mapTypeTile: mapTypeTile;
+    /**
+     * "urlTemplate" url de la fuente de capas, de donde se salen los tiles,
+     * los subdominios se deben indicar con {s}
+     */
+    urlTemplate: string;
+    /**
+     * "options" opciones de la fuente de capas, para definir limitaciones de zoom, subdominios, atribuciones, etc.
+     */
+    options: L.TileLayerOptions;
+    /**
+     * "hasTrafficLayer" si la fuente de capas tiene capa de tráfico
+     */
+    hasTrafficLayer?: boolean;
+    /**
+     * "hasTransitLayer" si la fuente de capas tiene capa de transporte público
+     */
+    hasTransitLayer?: boolean;
+    /**
+     * "hasBicyclingLayer" si la fuente de capas tiene capa de ciclovías
+     */
+    hasBicyclingLayer?: boolean;
+    /**
+     * "roadSelectedOptions" opcione de via (bicyclingLayer, trafficLayer, transitLayer) de cada una de las fuentes de capas
+     */
+    roadSelectedOptions: RoadOptionsType;
+    /**
+     * "getTileUrl" función que retorna la url de un tile, se usa cuando se necesita hacer un "tile server" que  no
+     * usa el estand x,y,x por ejemplo bing que usa QuadKey
+     * @param coords
+     * @returns
+     */
+    getTileUrl?: (coords: L.Coords) => string;
+};
+/**
+ * Interface que define las propidades necesarias para utilizar las capas de google.
+ */
+export interface GoogleMapState {
+    /**
+     * "googleMapsApiKey" Clave de la API de mapas.
+     */
+    googleMapsApiKey: string;
+    /**
+     * "googleMapVersion" Versión de la API de Google Maps cuando se usa fuentes de mapa tipo google. valor por defecto weekly
+     */
+    googleMapVersion?: string;
+}
+/**
+ * Interface que define el estado del componente (variables y funciones )
+ */
+export interface MapState extends GoogleMapState {
+    /**
+     * "storeId" identificador unico del map store
+     */
+    storeId: string;
+    /**
+     * "ownerState" estado del componente, "status" puede ser "init" o "ready
+     */
+    ownerState: OwnerState;
+    /**
+     *  "classes" enfocado al funcionamiento de las clases a nivel de map
+     */
+    classes: MapClasses;
+    /**
+     * "currentMapSourceId" ud fuente de mapas actual, por defecto "OSM"
+     */
+    currentMapSourceId: MapSourceId;
+    /**
+     *  "Ids" de las fuentes de mapas cargados
+     */
+    mapSourcesIds: MapSourceId[];
+    /**
+     *  "hashMapSources" Layers de trabajo
+     */
+    hashMapSources: Record<MapSourceId, TileLayerSource>;
+    /**
+     *  "LayersIds" Layers de trabajo para saber en que orden se muestran en el LayersAdmin
+     */
+    layersIds: string[];
+    /**
+     *  "hashLayers" Layers de trabajo
+     */
+    hashLayers: Record<string, LayerStore>;
+    /**
+     * "visibleCheckedLayers" set de capas checkead que coresponden a la capas visibles, usado en el componente de mapa Viewer, para el grid
+     */
+    visibleCheckedLayers: ReadonlySet<string>;
+    /**
+     * "checkedAutoFocusLayers" Si la capa participa del autofocus global
+     */
+    autoFocusCheckedLayers: ReadonlySet<string>;
+    /**
+     * "checkedClusterLayers" Si la capa es clusterizable
+     */
+    clusterCheckedLayers: ReadonlySet<string>;
+    /**
+     *  "getLabel" funcion que usará para traducir las etiquetas de diccionario
+     */
+    getLabel: GetLabelType;
+}
+export interface MapStateWithActions extends MapState {
+    mapActions: {
+        /**
+         * @description
+         */
+        init(layersStore: LayerStore[]): void;
+        /**
+         * Cambia el estado del map
+         */
+        setMapState: (state: MapStatus) => void;
+        /**
+         * Modifica toda la capa, reemplanzando todo el geoJson
+         */
+        setDataLayer: (layerId: string, geoJson: GeoJsonImplementedObject) => void;
+        /**
+         * Agrega o modifica un feature especifico de la capa, mezclando las propiedades actuales, con las nuevas que llegan.
+         */
+        setFeatureData: (layerId: string, featureId: FeatureId, geometry: GeometryObject, properties: GeoJsonProperties, featureLabel?: FeatureIconLabel) => void;
+        /**
+         * Remueve un feature especifico de la capa
+         */
+        removeFeature: (layerId: string, featureId: FeatureId) => void;
+        /**
+         * Retorna el vector de featureIds para saber que que está renderizado en el mapa
+         */
+        getFeatureIds: (layerId: string) => FeatureId[];
+        /**
+         * Actualizar instancia la render prop de una capa
+         */
+        setLayerRenderProp: (layerId: string, value: ComponentRenderPropFeature) => void;
+        /**
+         * Agrega una capa nueva,
+         */
+        addLayer: (layer: LayerStore) => void;
+        /**
+         * Agrega una capa nueva a un feature especifico,
+         */
+        addLayerDataToFeature: (layerId: string, featureId: FeatureId, layerData: FeatureLayerData) => void;
+        /**
+         * Remueve un feature especifico de la capa
+         */
+        removeLayer: (layerId: string) => void;
+        /**
+         * Abre un popup en un feature especifico
+         */
+        featureOpenPoup: (layerId: string, featureId: FeatureId) => void;
+        /**
+         * Cambia las capas la propieda (visible,autoFous,cluser) que estan visibles o no
+         */
+        setCheckedLayers: (checkedNameSet: CheckedNameSet, newCheckedSet: ReadonlySet<string>) => void;
+        /**
+         * Actualiza el map source que se visualiza en el mapa.
+         * Solo puede haber uno al tiempo.
+         * @param newTileLayerSource
+         * @returns
+         */
+        setCurrentMapSource: (newId: MapSourceId) => void;
+        /**
+         * Actualiza las opciones de la fuente de capas de tipo Road de la fuente de mapas actual
+         * @param partialRoadOptions
+         * @returns
+         */
+        setMapSourceRoadOptions: (partialRoadOptions: Partial<RoadOptionsType>) => void;
+        /**
+         * Actualiza la variable de estado "getLabel"
+         * @param newHandler handle o función que va a traducir las etiquetas, esto es necesario debido que getLabel de useModuleDictionary
+         * cambia por el useCallback, cuando el diccionario se carga.
+         * @returns void
+         */
+        setHandlerGetLabel: (newHandler: GetLabelType) => void;
+        /**
+         * Modifica los estados que se actualizan externamente al Store
+         * @param newIsMobile
+         * @returns
+         */
+        setExternalState: (newExternalState: ExternalOwnerState) => void;
+    };
+}
+export type DefaultMapStoreProps = Omit<MapState, 'currentLayer'>;
+export type InitialMapStoreProps = Pick<MapState, 'getLabel' | 'ownerState' | 'googleMapsApiKey' | 'googleMapVersion' | 'storeId'> & Partial<DefaultMapStoreProps>;
+export interface MapProviderProps extends Pick<MapState, 'storeId' | 'googleMapsApiKey' | 'googleMapVersion'> {
+    storeDevtoolsEnabled?: boolean;
+    /**
+     * Capas iniciales del mapa
+     */
+    initialLayers?: InitialLayer[];
+    children: ReactNode;
+}

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

@@ -0,0 +1,32 @@
+export declare const MAP_DICTIONARY_ID = "map";
+export declare function getMapComponentsDictionary(): string[];
+export declare const MAP_DICCTIONARY: {
+    /**
+     * Generales
+     */
+    readonly LABEL_GPSTOOLS_NAME: "map.label_gpstools_name";
+    readonly LABEL_POPUP_MEASURE: "map.label_tab_measure";
+    readonly LABEL_MEASURE_START: "map.label_measure_start";
+    readonly LABEL_MEASURE_CANCEL: "map.label_measure_cancel";
+    readonly LABEL_MEASURE_DISTANCE: "map.label_measure_distance";
+    readonly LABEL_MEASURE_AREA: "map.label_measure_area";
+    readonly LABEL_MEASURE_UNIT: "map.label_measure_unit";
+    readonly LABEL_MEASURE_UNIT_BASE_KILOMETERS: "map.label_measure_unit_base_kilometers";
+    readonly LABEL_MEASURE_REMOVE_POINT: "map.label_measure_remove_point";
+    /** Layers */
+    readonly LABEL_LAYERS: "map.label_layes";
+    readonly LABEL_LAYER_NAME: "map.label_layer_name";
+    readonly LABEL_LAYER_VISIBLE: "map.label_layer_visible";
+    readonly LABEL_LAYER_AUTOFOCUS: "map.label_layer_autofocus";
+    readonly LABEL_LAYER_CLUSTER: "map.label_layer_cluster";
+    readonly ROW_ACTION_LAYER_DELETE: "map.row_action_layer_delete";
+    /** Map Sources */
+    readonly LABEL_MAP_SOURCES: "map.label_map_sources";
+    readonly LABEL_TILE_OSM: "map.label_tile_osm";
+    readonly LABEL_TILE_GOOGLE_ROADS: "map.label_tile_google_roads";
+    readonly LABEL_TILE_GOOGLE_SATELLITE: "map.label_tile_google_satellite";
+    readonly LABEL_TILE_GOOGLE_HYBRID: "map.label_tile_google_hybrid";
+    readonly LABEL_TILE_BING: "map.label_tile_bing";
+};
+export type TypeDictionary = typeof MAP_DICCTIONARY;
+export declare const getMapToolsDictionary: (key: keyof TypeDictionary) => string;

package/components/maps/components/GpsMap/dictionary.js

@@ -0,0 +1,32 @@
+import { getRHFAutocompleteComponentsDictionary } from "@m4l/components";
+const MAP_DICTIONARY_ID = "map";
+function getMapComponentsDictionary() {
+  return [MAP_DICTIONARY_ID].concat(getRHFAutocompleteComponentsDictionary());
+}
+const MAP_DICCTIONARY = {
+  /**
+   * Generales
+   */
+  LABEL_GPSTOOLS_NAME: "map.label_gpstools_name",
+  LABEL_POPUP_MEASURE: "map.label_tab_measure",
+  LABEL_MEASURE_START: "map.label_measure_start",
+  LABEL_MEASURE_CANCEL: "map.label_measure_cancel",
+  LABEL_MEASURE_UNIT: "map.label_measure_unit",
+  LABEL_MEASURE_UNIT_BASE_KILOMETERS: "map.label_measure_unit_base_kilometers",
+  LABEL_MEASURE_REMOVE_POINT: "map.label_measure_remove_point",
+  LABEL_LAYER_NAME: "map.label_layer_name",
+  LABEL_LAYER_VISIBLE: "map.label_layer_visible",
+  LABEL_LAYER_AUTOFOCUS: "map.label_layer_autofocus",
+  LABEL_LAYER_CLUSTER: "map.label_layer_cluster",
+  ROW_ACTION_LAYER_DELETE: "map.row_action_layer_delete",
+  LABEL_TILE_OSM: "map.label_tile_osm",
+  LABEL_TILE_GOOGLE_ROADS: "map.label_tile_google_roads",
+  LABEL_TILE_GOOGLE_SATELLITE: "map.label_tile_google_satellite",
+  LABEL_TILE_GOOGLE_HYBRID: "map.label_tile_google_hybrid",
+  LABEL_TILE_BING: "map.label_tile_bing"
+  /** Popups */
+};
+export {
+  MAP_DICCTIONARY as M,
+  getMapComponentsDictionary as g
+};

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

@@ -0,0 +1,9 @@
+import { ControlProps } from './types';
+/**
+ * crea un componente react dentro de un control de leaflet, utilizando una tecnica e portal diferente a createPortal
+ * Dependiendo de la posicion del control, este se agrega en la parte correspondiente del mapa, por defecto es topright
+ * @param props
+ * @returns
+ */
+export declare const Control: (props: ControlProps) => JSX.Element;
+export default Control;

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

@@ -0,0 +1,42 @@
+import { jsx } from "react/jsx-runtime";
+import React from "react";
+import L__default from "leaflet";
+import { useMap } from "react-leaflet";
+import clsx from "clsx";
+const POSITION_CLASSES = {
+  bottomleft: "leaflet-bottom leaflet-left",
+  bottomright: "leaflet-bottom leaflet-right",
+  topleft: "leaflet-top leaflet-left",
+  topright: "leaflet-top leaflet-right"
+};
+const Control = (props) => {
+  const [portalRoot, setPortalRoot] = React.useState(document.createElement("div"));
+  const positionClass = props.position && POSITION_CLASSES[props.position] || POSITION_CLASSES.topright;
+  const controlContainerRef = React.createRef();
+  const map = useMap();
+  React.useEffect(() => {
+    if (controlContainerRef.current !== null) {
+      L__default.DomEvent.disableClickPropagation(controlContainerRef.current);
+      L__default.DomEvent.disableScrollPropagation(controlContainerRef.current);
+    }
+  }, [controlContainerRef]);
+  React.useEffect(() => {
+    const mapContainer = map.getContainer();
+    const targetDiv = mapContainer.getElementsByClassName(positionClass);
+    setPortalRoot(targetDiv[0]);
+  }, [positionClass]);
+  React.useEffect(() => {
+    if (portalRoot !== null) {
+      if (props.prepend !== void 0 && props.prepend === true) {
+        portalRoot.prepend(controlContainerRef.current);
+      } else {
+        portalRoot.append(controlContainerRef.current);
+      }
+    }
+  }, [portalRoot, props.prepend, controlContainerRef]);
+  const className = clsx(props.container?.className, "leaflet-control", props.className);
+  return /* @__PURE__ */ jsx("div", { ...props.container, ref: controlContainerRef, className, children: props.children });
+};
+export {
+  Control as C
+};

package/components/maps/components/GpsMap/external/Control/types.d.ts

@@ -0,0 +1,7 @@
+export interface ControlProps {
+    position: L.ControlPosition;
+    children?: React.ReactNode;
+    container?: React.HTMLAttributes<HTMLDivElement>;
+    prepend?: boolean;
+    className?: string;
+}