@m4l/components 7.0.0 → 7.1.2

package/components/maps/components/Map/featureRenders/CommonFeatureRender/subcomponents/MarkerIconLabel/index.js

@@ -0,0 +1,76 @@
+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 onPopupOpen = useCallback((_e) => {
+    setIsOpen(true);
+  }, []);
+  const onPopupClose = useCallback((_e) => {
+    setIsOpen(false);
+  }, []);
+  return /* @__PURE__ */ jsx(
+    Marker,
+    {
+      ref: markerRef,
+      position,
+      draggable,
+      riseOnHover: true,
+      icon: makerIcon,
+      eventHandlers: {
+        ...eventHandlers,
+        click: (_e) => {
+        },
+        popupopen: onPopupOpen,
+        popupclose: onPopupClose
+      },
+      ...others,
+      children: PopupRender && properties && /* @__PURE__ */ jsx(
+        PopupRender,
+        {
+          isOpen,
+          properties,
+          position,
+          popupOptions
+        }
+      )
+    }
+  );
+};
+export {
+  MarkerIconLabel as M
+};

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

@@ -1,6 +1,9 @@
-export declare type IconForm = 'grua' | 'taxi';
+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/Map/featureRenders/MarkerFeatureRender/IconMarkerGrua.d.ts

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

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

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

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

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

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

@@ -0,0 +1,79 @@
+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,
+      ...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/Map/featureRenders/index.js

@@ -0,0 +1 @@
+

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

@@ -2,7 +2,6 @@
  * "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/Map/hooks/useAutoFocus/index.js

@@ -0,0 +1,78 @@
+import { useEffect } from "react";
+import { useMap } from "react-leaflet";
+import throttle from "lodash.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/Map/hooks/useAutoFocus/types.d.ts

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

package/components/maps/components/Map/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/Map/hooks/useDisableZoomEvents/index.d.ts

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

package/components/maps/components/Map/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/Map/hooks/useMapStore/index.d.ts

@@ -1,3 +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/Map/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/Map/icons.d.ts

@@ -28,7 +28,8 @@ export declare const MAP_ICONS: {
     MAP_LAYER_CLUSTER: string;
     MAP_LAYER_DELETE: string;
     ADD: string;
-    /** Measure Tool *
+    /**
+     * Measure Tool *
      *
      */
     MAP_GPS_TOOLS_TOOL: string;

package/components/maps/components/Map/icons.js

@@ -0,0 +1,61 @@
+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',
+};
+export {
+  MAP_ICONS as M
+};

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

@@ -1,4 +1,4 @@
-export { Map } from './Map';
+export { MyMap as Map } from './Map';
 export type { MapProps } from './types';
 export { MapProvider, MapContext } from './contexts/MapContext/MapContext';
 export { useMapStore } from './hooks/useMapStore';

package/components/maps/components/Map/index.js

@@ -0,0 +1 @@
+

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

@@ -1,9 +1,11 @@
-/// <reference types="react" />
 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;

package/components/maps/components/Map/pluginLayers/PolylineWithArrows/index.js

@@ -0,0 +1,74 @@
+import { jsx } from "react/jsx-runtime";
+import L__default from "leaflet";
+import "leaflet-polylinedecorator";
+import { useRef, useEffect } from "react";
+import { useMap, Polyline } from "react-leaflet";
+const PolylineWithArrows = ({
+  positions,
+  enableEdit,
+  ...other
+}) => {
+  const map = useMap();
+  const polylineRef = useRef(null);
+  const decoratorRef = useRef(null);
+  useEffect(() => {
+    if (polylineRef.current) {
+      const decorator = L__default.polylineDecorator(polylineRef.current, {
+        patterns: [
+          {
+            // offset: '20%',
+            repeat: 50,
+            symbol: L__default.Symbol.arrowHead({
+              pixelSize: 4,
+              polygon: false,
+              pathOptions: {
+                stroke: true,
+                color: "#ffffff",
+                weight: 2
+              }
+            })
+          }
+        ]
+      }).addTo(map);
+      decoratorRef.current = decorator;
+      if (enableEdit) {
+        polylineRef.current.pm.enable();
+      } else {
+        polylineRef.current.pm.disable();
+      }
+      polylineRef.current.on("pm:change", () => {
+        if (decoratorRef.current) {
+          map.removeLayer(decoratorRef.current);
+        }
+        if (polylineRef.current) {
+          decoratorRef.current = L__default.polylineDecorator(polylineRef.current, {
+            patterns: [
+              {
+                // offset: '20%',
+                repeat: 40,
+                symbol: L__default.Symbol.arrowHead({
+                  pixelSize: 4,
+                  polygon: false,
+                  pathOptions: {
+                    stroke: true,
+                    color: "#cc0000",
+                    weight: 2
+                  }
+                })
+              }
+            ]
+          }).addTo(map);
+        }
+      });
+      return () => {
+        if (decoratorRef.current) {
+          map.removeLayer(decoratorRef.current);
+        }
+      };
+    }
+  }, [map, enableEdit]);
+  return /* @__PURE__ */ jsx(Polyline, { positions, ref: polylineRef, ...other });
+};
+export {
+  PolylineWithArrows as P
+};

package/components/maps/components/Map/pluginLayers/index.js

@@ -0,0 +1 @@
+

package/components/maps/components/Map/popups/MapPopupMyGps/MapPopupMyGps.d.ts

@@ -3,5 +3,5 @@ import { MapPopupProps } from '../types';
  * "MapPopupMyGps" componente encargado de visualizar la información de un dispositivo
  * dentro de un popup.
  *
- **/
+ */
 export declare const MapPopupMyGps: (props: MapPopupProps) => import("react/jsx-runtime").JSX.Element;

package/components/maps/components/Map/popups/MapPopupMyGps/MapPopupMyGps.js

@@ -0,0 +1,97 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useMap, Popup } from "react-leaflet";
+import { useModuleDictionary } from "@m4l/core";
+import { M as MapPopupMyGpsRootStyled, a as MapPopupMyGpsHeaderStyled, b as MapPopupMyGpsContentStyled } from "./slots/ MapPopupMyGpsSlots.js";
+import { M as MAP_POPUP_MYGPS_DICCTIONARY } from "./dictionary.js";
+import { P as PropertyValue } from "./subcomponents/PropertyValue/index.js";
+import { useCallback } from "react";
+import { D as DistanceToNowFormatter } from "../../../../../formatters/DistanceToNowFormatter/DistanceToNowFormatter.js";
+import { L as LAT_LON_FIXED_DIGITS } from "./constants.js";
+import { M as MyDevice } from "../../../../../gclick/MyDevice/MyDevice.js";
+import { M as MyDeviceStatus } from "../../../../../gclick/MyDeviceStatus/MyDeviceStatus.js";
+import { C as CourseFormatter } from "../../../../../formatters/CourseFormatter/CourseFormatter.js";
+import { I as IconButton } from "../../../../../mui_extended/IconButton/IconButton.js";
+const MapPopupMyGps = (props) => {
+  const { properties, isOpen, popupOptions } = props;
+  const { keepInView = true, autoPan = true, ...others } = popupOptions || {};
+  const { getLabel } = useModuleDictionary();
+  const map = useMap();
+  const onClose = useCallback(() => {
+    map.closePopup();
+  }, [map]);
+  return /* @__PURE__ */ jsx(
+    Popup,
+    {
+      closeButton: false,
+      keepInView,
+      autoPan,
+      autoPanPaddingTopLeft: [40, 40],
+      autoPanPaddingBottomRight: [40, 40],
+      ...others,
+      children: isOpen && /* @__PURE__ */ jsxs(MapPopupMyGpsRootStyled, { children: [
+        /* @__PURE__ */ jsxs(MapPopupMyGpsHeaderStyled, { children: [
+          /* @__PURE__ */ jsx(MyDevice, { deviceData: { ...properties?.deviceData } }),
+          /* @__PURE__ */ jsx(IconButton, { src: "close", onClick: onClose })
+        ] }),
+        /* @__PURE__ */ jsxs(MapPopupMyGpsContentStyled, { children: [
+          /* @__PURE__ */ jsx("span", { children: properties?.deviceData?.current?.vpts?.vpt_gnss?.address?.value }),
+          /* @__PURE__ */ jsx(
+            PropertyValue,
+            {
+              property: getLabel(MAP_POPUP_MYGPS_DICCTIONARY.LABEL_MAP_POPUP_MYGPS_LAST_REPORT),
+              value: /* @__PURE__ */ jsx(
+                DistanceToNowFormatter,
+                {
+                  presentationTime: "past",
+                  date: properties?.deviceData?.current?.vpts?.vpt_modem?.last_connection,
+                  delay: 1e3 * 1
+                }
+              )
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            PropertyValue,
+            {
+              property: getLabel(MAP_POPUP_MYGPS_DICCTIONARY.LABEL_MAP_POPUP_MYGPS_STATUS),
+              value: /* @__PURE__ */ jsx(MyDeviceStatus, { deviceData: properties?.deviceData })
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            PropertyValue,
+            {
+              property: getLabel(MAP_POPUP_MYGPS_DICCTIONARY.LABEL_MAP_POPUP_MYGPS_SPEED),
+              value: `${properties?.deviceData?.current?.vpts?.vpt_gnss?.speed?.value} Kms/s`
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            PropertyValue,
+            {
+              property: getLabel(MAP_POPUP_MYGPS_DICCTIONARY.LABEL_MAP_POPUP_MYGPS_COURSE),
+              value: /* @__PURE__ */ jsx(
+                CourseFormatter,
+                {
+                  course: properties?.deviceData?.current?.vpts?.vpt_gnss?.course?.value
+                }
+              )
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            PropertyValue,
+            {
+              property: getLabel(MAP_POPUP_MYGPS_DICCTIONARY.LABEL_MAP_POPUP_MYGPS_LOCATION),
+              value: `${Number(properties?.deviceData?.current?.vpts?.vpt_gnss?.lat?.value).toFixed(
+                LAT_LON_FIXED_DIGITS
+              )},${Number(properties?.deviceData?.current?.vpts?.vpt_gnss?.lon?.value).toFixed(
+                LAT_LON_FIXED_DIGITS
+              )}`
+            }
+          ),
+          /* @__PURE__ */ jsx("span", { children: getLabel(MAP_POPUP_MYGPS_DICCTIONARY.LABEL_MAP_POPUP_MYGPS_VIEW_MORE) })
+        ] })
+      ] })
+    }
+  );
+};
+export {
+  MapPopupMyGps as M
+};

package/components/maps/components/Map/popups/MapPopupMyGps/MapPopupMyGps.styles.d.ts

@@ -1,2 +1,2 @@
-import type { MapPopupMyGpsStyles } from './types';
+import { MapPopupMyGpsStyles } from './types';
 export declare const mapPopupMyGpsStyles: MapPopupMyGpsStyles;