@m4l/components 4.1.4 → 4.1.6

package/components/maps/components/Map/subcomponents/TileLayers/subcomponents/TileLayerGoogle/index-U7WlXaRk.js

@@ -0,0 +1,100 @@
+import React__default from "react";
+import { useMap } from "react-leaflet";
+import L__default from "leaflet";
+import { u as useMapStore } from "../../../../hooks/useMapStore/index-1eqb58ec.js";
+import { shallow } from "zustand/shallow";
+import { Loader } from "@googlemaps/js-api-loader";
+function TileLayerGoogle() {
+  const map = useMap();
+  const mutantRefLayer = React__default.useRef(null);
+  const { options, sourceType, mapTypeTile } = useMapStore(
+    (state) => state.hashMapSources[state.currentMapSourceId],
+    shallow
+  );
+  const roadOptions = useMapStore(
+    (state) => state.hashMapSources[state.currentMapSourceId].roadSelectedOptions,
+    shallow
+  );
+  const [googleApiKey, googleMapVersion] = useMapStore(
+    (state) => [state.googleApiKey, state.googleMapVersion],
+    shallow
+  );
+  React__default.useEffect(() => {
+    if (sourceType !== "Google") {
+      return;
+    }
+    let googleMutantLayer;
+    const loader = new Loader({
+      apiKey: googleApiKey,
+      version: googleMapVersion
+    });
+    loader.importLibrary("maps").then(() => {
+      googleMutantLayer = L__default.gridLayer.googleMutant({
+        type: mapTypeTile,
+        // map type, can be 'roadmap', 'satellite', etc.
+        maxZoom: 20,
+        // styles: [
+        //   // Google Maps styles array, can be generated here: https://mapstyle.withgoogle.coxm/
+        // ],
+        ...options
+      });
+      mutantRefLayer.current = googleMutantLayer;
+      if (roadOptions.trafficLayer) {
+        googleMutantLayer.addGoogleLayer("TrafficLayer");
+      }
+      if (roadOptions.transitLayer) {
+        googleMutantLayer.addGoogleLayer("TransitLayer");
+      }
+      if (roadOptions.bicyclingLayer) {
+        googleMutantLayer.addGoogleLayer("BicyclingLayer");
+      }
+      map.addLayer(googleMutantLayer);
+    });
+    return () => {
+      if (googleMutantLayer) {
+        map.removeLayer(googleMutantLayer);
+        mutantRefLayer.current = null;
+      }
+    };
+  }, [map, sourceType, mapTypeTile]);
+  React__default.useEffect(() => {
+    if (sourceType !== "Google") {
+      return;
+    }
+    if (mutantRefLayer.current && roadOptions) {
+      if (roadOptions.trafficLayer) {
+        mutantRefLayer.current.addGoogleLayer("TrafficLayer");
+      } else if (roadOptions.trafficLayer === false) {
+        mutantRefLayer.current.removeGoogleLayer("TrafficLayer");
+      }
+    }
+  }, [roadOptions.trafficLayer]);
+  React__default.useEffect(() => {
+    if (sourceType !== "Google") {
+      return;
+    }
+    if (mutantRefLayer.current && roadOptions) {
+      if (roadOptions.transitLayer) {
+        mutantRefLayer.current.addGoogleLayer("TransitLayer");
+      } else if (roadOptions.transitLayer === false) {
+        mutantRefLayer.current.removeGoogleLayer("TransitLayer");
+      }
+    }
+  }, [roadOptions.transitLayer]);
+  React__default.useEffect(() => {
+    if (sourceType !== "Google") {
+      return;
+    }
+    if (mutantRefLayer.current && roadOptions) {
+      if (roadOptions.bicyclingLayer) {
+        mutantRefLayer.current.addGoogleLayer("BicyclingLayer");
+      } else if (roadOptions.bicyclingLayer === false) {
+        mutantRefLayer.current.removeGoogleLayer("BicyclingLayer");
+      }
+    }
+  }, [roadOptions.bicyclingLayer]);
+  return null;
+}
+export {
+  TileLayerGoogle as T
+};

package/components/maps/components/Map/subcomponents/TileLayers/subcomponents/TileLayerOthers/index-Cf5Y2Nr4.js

@@ -0,0 +1,35 @@
+import { useMap } from "react-leaflet";
+import { shallow } from "zustand/shallow";
+import { u as useMapStore } from "../../../../hooks/useMapStore/index-1eqb58ec.js";
+import { useEffect } from "react";
+import L__default from "leaflet";
+const TileLayerOthers = () => {
+  const map = useMap();
+  const { urlTemplate, dictionaryId, options, getTileUrl, sourceType } = useMapStore(
+    (state) => state.hashMapSources[state.currentMapSourceId],
+    shallow
+  );
+  useEffect(() => {
+    let layer;
+    if (sourceType === "Google") {
+      return;
+    }
+    layer = L__default.tileLayer(urlTemplate, options);
+    if (getTileUrl) {
+      layer.getTileUrl = getTileUrl;
+    }
+    map.addLayer(layer);
+    if (options && options.maxZoom) {
+      map.setMaxZoom(options.maxZoom);
+    }
+    return () => {
+      if (layer) {
+        map.removeLayer(layer);
+      }
+    };
+  }, [dictionaryId, urlTemplate, options, getTileUrl, sourceType]);
+  return null;
+};
+export {
+  TileLayerOthers as T
+};

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

@@ -1,5 +1,9 @@
+import { OverridesStyleRules } from '@mui/material/styles/overrides';
 import { LatLngExpression } from 'leaflet';
 import { FC } from 'react';
+import { Theme } from '@mui/material/styles';
+import { MapSlots } from './slots/slots';
+import { COMPONET_KEY_COMPONENT } from './constants';
 export declare type Localization = {
     /**
      *  "lat" Posición en del eje "Y" en grados.
@@ -34,7 +38,19 @@ export interface MapProps {
      */
     maxZoom?: number;
     /**
-     * "gpsTools" Componente que gestiona la herramienta de guardian GPS, geocercas, puntos de interes, etc.
+     * "mapGpsTools" Componente que gestiona la herramienta de guardian GPS, geocercas, puntos de interes, etc.
      */
-    gpsTools?: FC;
+    mapGpsTools?: FC;
 }
+export declare type MapSlotsType = keyof typeof MapSlots;
+export declare type MapOwnerState = {
+    /**
+     *  "isMobile" cuando el navegador está corriendo en dispositivo móvil
+     */
+    isMobile?: boolean;
+    /**
+     * "hidden" permite definir si la ventana está oculta o no. Por defecto es "false
+     */
+    hidden?: boolean;
+};
+export declare type MapStyles = Partial<OverridesStyleRules<MapSlotsType, typeof COMPONET_KEY_COMPONENT, Theme> | undefined> | undefined;

package/components/maps/components/MapGpsTools/MapGpsTools-BHZ23ZvC.js

@@ -0,0 +1,10 @@
+import { jsx } from "react/jsx-runtime";
+import { useModuleSkeleton } from "@m4l/core";
+import { T as TabsGpsTools } from "./subcomponents/TabsGpsTools/index-DLtn2VwY.js";
+function MapGpsTools() {
+  const isSkeleton = useModuleSkeleton();
+  return !isSkeleton && /* @__PURE__ */ jsx(TabsGpsTools, {});
+}
+export {
+  MapGpsTools as M
+};

package/components/maps/components/MapGpsTools/classes/index-oE5Q9Oa0.js

@@ -0,0 +1,21 @@
+import { generateUtilityClasses } from "@mui/material";
+import "@mui/base";
+import { C as COMPONENT_CLASS_NAME } from "../constants-BtQVGkL6.js";
+const gpsToolsClasses = generateUtilityClasses(COMPONENT_CLASS_NAME, [
+  /* elements */
+  "gpsToolsRoot",
+  "gpsToolsTab",
+  "gpsToolsTabContent",
+  "gpsToolsGeofencesList",
+  "gpsToolsGeofencesAddEdit",
+  "gpsToolsGeofencesAddEditContent",
+  "gpsToolsGeofencesAddEditDrawFinishContainer",
+  "toolGeofencesAddEditGeneral",
+  "toolGeofencesAddEditStyle",
+  /* states or variants of elements */
+  "visible",
+  "hidden"
+]);
+export {
+  gpsToolsClasses as g
+};

package/components/maps/components/MapGpsTools/constants-BtQVGkL6.js

@@ -0,0 +1,71 @@
+const COMPONENT_CLASS_NAME = "M4LMapGpsTools";
+const COMPONENT_MAP_TOOLS_ID = "gps_tools";
+const STYLE_OPACITIES = [
+  {
+    value: 0,
+    label: "0%"
+  },
+  {
+    value: 0.1,
+    label: "10%"
+  },
+  {
+    value: 0.2,
+    label: "20%"
+  },
+  {
+    value: 0.3,
+    label: "30%"
+  },
+  {
+    value: 0.4,
+    label: "40%"
+  },
+  {
+    value: 0.5,
+    label: "50%"
+  },
+  {
+    value: 1,
+    label: "100%"
+  }
+];
+const STYLE_WHEIGHTS = [
+  {
+    value: 0,
+    label: "0px"
+  },
+  {
+    value: 1,
+    label: "1px"
+  },
+  {
+    value: 2,
+    label: "2px"
+  },
+  {
+    value: 3,
+    label: "3px"
+  },
+  {
+    value: 4,
+    label: "4px"
+  }
+];
+const STYLE_PATTERNS = [
+  {
+    value: "",
+    label: "------"
+  },
+  {
+    value: "4 1 2",
+    label: "-- - - --"
+  }
+];
+export {
+  COMPONENT_CLASS_NAME as C,
+  STYLE_OPACITIES as S,
+  STYLE_WHEIGHTS as a,
+  STYLE_PATTERNS as b,
+  COMPONENT_MAP_TOOLS_ID as c
+};

package/components/maps/components/MapGpsTools/contexts/MapGpsToolsContext/index-DtJv8-7m.js

@@ -0,0 +1,48 @@
+import { jsx } from "react/jsx-runtime";
+import { createContext, useRef, useEffect } from "react";
+import { useStore } from "zustand";
+import { shallow } from "zustand/shallow";
+import { useResponsiveDesktop, useFirstRender } from "@m4l/graphics";
+import { useModuleDictionary, useModuleSkeleton } from "@m4l/core";
+import { c as createMapGpsToolsStore } from "./store-CnVI1yPl.js";
+const MapGpsToolsContext = createContext(null);
+function MapGpsToolsProvider(props) {
+  const { children } = props;
+  const { getLabel } = useModuleDictionary();
+  const isDesktop = useResponsiveDesktop();
+  const isSkeleton = useModuleSkeleton();
+  const isFirstRender = useFirstRender([getLabel]);
+  const mapStoreRef = useRef();
+  if (!mapStoreRef.current) {
+    mapStoreRef.current = createMapGpsToolsStore({
+      getLabel,
+      ownerState: {
+        status: "init",
+        isMobile: !isDesktop,
+        isSkeleton,
+        focus: false
+      }
+    });
+  }
+  const { setHandlerGetLabel, setExternalState } = useStore(
+    mapStoreRef.current,
+    (state) => state.gpsToolsActions,
+    shallow
+  );
+  useEffect(() => {
+    if (!isFirstRender) {
+      setHandlerGetLabel(getLabel);
+    }
+  }, [getLabel]);
+  useEffect(() => {
+    if (isFirstRender) {
+      return;
+    }
+    setExternalState({ isMobile: !isDesktop, isSkeleton });
+  }, [isDesktop, isSkeleton]);
+  return /* @__PURE__ */ jsx(MapGpsToolsContext.Provider, { value: mapStoreRef.current, children });
+}
+export {
+  MapGpsToolsContext as M,
+  MapGpsToolsProvider as a
+};

package/components/maps/components/MapGpsTools/contexts/MapGpsToolsContext/index.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="react" />
+import type { MapGpsToolsProviderProps } from './types';
+declare const MapGpsToolsContext: import("react").Context<(Omit<Omit<import("zustand").StoreApi<import("./types").MapGpsToolsStateWithActions>, "setState"> & {
+    setState<A extends string | {
+        type: unknown;
+    }>(partial: import("./types").MapGpsToolsStateWithActions | Partial<import("./types").MapGpsToolsStateWithActions> | ((state: import("./types").MapGpsToolsStateWithActions) => import("./types").MapGpsToolsStateWithActions | Partial<import("./types").MapGpsToolsStateWithActions>), replace?: boolean | undefined, action?: A | undefined): void;
+}, "setState"> & {
+    setState(nextStateOrUpdater: import("./types").MapGpsToolsStateWithActions | Partial<import("./types").MapGpsToolsStateWithActions> | ((state: import("immer/dist/internal").WritableDraft<import("./types").MapGpsToolsStateWithActions>) => void), shouldReplace?: boolean | undefined, action?: string | {
+        type: unknown;
+    } | undefined): void;
+}) | null>;
+/**
+ * @description Provedor del contexto de los mapas
+ * Expone el store (MapStore) encargado de gestionar la creación, modificación y borrado de capas.
+ * @param props
+ * @returns
+ */
+declare function MapGpsToolsProvider(props: MapGpsToolsProviderProps): import("react/jsx-runtime").JSX.Element;
+export { MapGpsToolsProvider, MapGpsToolsContext };

package/components/maps/components/MapGpsTools/contexts/MapGpsToolsContext/store-CnVI1yPl.js

@@ -0,0 +1,116 @@
+import { createStore } from "zustand";
+import { devtools } from "zustand/middleware";
+import { immer } from "zustand/middleware/immer";
+import { enableMapSet } from "immer";
+enableMapSet();
+const createMapGpsToolsStore = (initProps) => {
+  const startProps = {
+    currentTabGpsTool: "geofences",
+    geofenceState: {
+      // currentGeofenceTool: 'list',
+      rows: [],
+      checkedGeofences: /* @__PURE__ */ new Set(),
+      checkedCrossingFeatures: /* @__PURE__ */ new Set(),
+      checkedInternalFeatures: /* @__PURE__ */ new Set(),
+      hashGeofences: {}
+    },
+    ...initProps
+  };
+  return createStore(
+    devtools(
+      immer((set, _get) => ({
+        ...startProps,
+        gpsToolsActions: {
+          init: () => {
+            set((state) => {
+              state.ownerState.status = "ready";
+            });
+          },
+          setGpsToolsState: (status) => {
+            set((state) => {
+              state.ownerState.status = status;
+            });
+          },
+          setHandlerGetLabel: (newHandler) => {
+            set((state) => {
+              state.getLabel = newHandler;
+            });
+          },
+          setExternalState: (newExternalState) => {
+            set((state) => {
+              state.ownerState = { ...state.ownerState, ...newExternalState };
+            });
+          },
+          setCurrentTabTool: (newTabTool) => {
+            set((state) => {
+              state.currentTabGpsTool = newTabTool;
+            });
+          }
+        },
+        geofenceActions: {
+          // goToAddEdit: (geofenceId?: GeofenceId) => {
+          //     set(state => {
+          //         state.geofenceState.currentGeofenceTool = 'add_edit';
+          //         state.geofenceState.geofenceId = geofenceId;
+          //     });
+          // },
+          // goToList: (geofenceId?: GeofenceId) => {
+          //     set(state => {
+          //         state.geofenceState.currentGeofenceTool = 'list';
+          //         state.geofenceState.geofenceId = geofenceId;
+          //     });
+          // },
+          addGeofence: (geofenceId, geofence) => {
+            set((state) => {
+              state.geofenceState.hashGeofences[geofenceId] = geofence;
+            });
+          },
+          updatePartialGeofence: (geofenceId, geofence) => {
+            set((state) => {
+              state.geofenceState.hashGeofences[geofenceId] = {
+                ...state.geofenceState.hashGeofences[geofenceId],
+                ...geofence
+              };
+            });
+          },
+          updateRows: (newRows) => {
+            set((state) => {
+              state.geofenceState.rows = newRows;
+            });
+          },
+          addCheckedGeofence: (geofenceId) => {
+            set((state) => {
+              state.geofenceState.checkedGeofences.add(geofenceId);
+              state.geofenceState.checkedGeofences = new Set(state.geofenceState.checkedGeofences);
+            });
+          },
+          removeCheckedGeofence: (geofenceId) => {
+            set((state) => {
+              state.geofenceState.checkedGeofences.delete(geofenceId);
+              state.geofenceState.checkedGeofences = new Set(state.geofenceState.checkedGeofences);
+            });
+          },
+          setCheckedGeofences: (newGeofences) => {
+            set((state) => {
+              state.geofenceState.checkedGeofences = new Set(newGeofences);
+            });
+          },
+          setCheckedCrossingFeatures: (newFeatures) => {
+            set((state) => {
+              state.geofenceState.checkedCrossingFeatures = new Set(newFeatures);
+            });
+          },
+          setCheckedInternalFeatures: (newFeatures) => {
+            set((state) => {
+              state.geofenceState.checkedInternalFeatures = new Set(newFeatures);
+            });
+          }
+        }
+      })),
+      { name: `Map Tools Store` }
+    )
+  );
+};
+export {
+  createMapGpsToolsStore as c
+};

package/components/maps/components/MapGpsTools/contexts/MapGpsToolsContext/store.d.ts

@@ -0,0 +1,16 @@
+import type { MapGpsToolsStateWithActions, InitialMapGpsToolsStoreProps } from './types';
+/**
+ * @description Crea el Store, por defecto inicia en estado 'init'
+ * @param initProps propiedades iniciales del store
+ * @returns
+ */
+export declare const createMapGpsToolsStore: (initProps: InitialMapGpsToolsStoreProps) => Omit<Omit<import("zustand").StoreApi<MapGpsToolsStateWithActions>, "setState"> & {
+    setState<A extends string | {
+        type: unknown;
+    }>(partial: MapGpsToolsStateWithActions | Partial<MapGpsToolsStateWithActions> | ((state: MapGpsToolsStateWithActions) => MapGpsToolsStateWithActions | Partial<MapGpsToolsStateWithActions>), replace?: boolean | undefined, action?: A | undefined): void;
+}, "setState"> & {
+    setState(nextStateOrUpdater: MapGpsToolsStateWithActions | Partial<MapGpsToolsStateWithActions> | ((state: import("immer/dist/internal").WritableDraft<MapGpsToolsStateWithActions>) => void), shouldReplace?: boolean | undefined, action?: string | {
+        type: unknown;
+    } | undefined): void;
+};
+export declare type MapGpsToolsStore = ReturnType<typeof createMapGpsToolsStore>;

package/components/maps/components/MapGpsTools/contexts/{GpsToolsContext → MapGpsToolsContext}/types.d.ts

@@ -78,7 +78,7 @@ export declare type GeofenceId = number;
  * @interface
  * @description Interface que define el estado del componente (variables y funciones )
  */
-export interface GpsToolsState {
+export interface MapGpsToolsState {
     ownerState: OwnerState;
     /**
      * "currentTabTool" indica la pestaña actual en uso
@@ -93,7 +93,7 @@ export interface GpsToolsState {
      */
     getLabel: GetLabelType;
 }
-export interface GpsToolsStateWithActions extends GpsToolsState {
+export interface MapGpsToolsStateWithActions extends MapGpsToolsState {
     gpsToolsActions: {
         /**
          * @description
@@ -158,8 +158,8 @@ export interface GpsToolsStateWithActions extends GpsToolsState {
         setCheckedInternalFeatures: (newFeatures: ReadonlySet<GeofenceId>) => void;
     };
 }
-export declare type DefaultMapGpsToolsStoreProps = Omit<GpsToolsState, 'currentLayer'>;
-export declare type InitialMapGpsToolsStoreProps = Pick<GpsToolsState, 'getLabel' | 'ownerState'> & Partial<DefaultMapGpsToolsStoreProps>;
+export declare type DefaultMapGpsToolsStoreProps = Omit<MapGpsToolsState, 'currentLayer'>;
+export declare type InitialMapGpsToolsStoreProps = Pick<MapGpsToolsState, 'getLabel' | 'ownerState'> & Partial<DefaultMapGpsToolsStoreProps>;
 export interface MapGpsToolsProviderProps {
     children: ReactNode;
 }

package/components/maps/components/MapGpsTools/dictionary-BOXSG1O8.js

@@ -0,0 +1,73 @@
+import { g as getDataGridComponentsDictionary } from "../../../DataGrid/dictionary-AjA8KM_q.js";
+import { a as getDynamicFilterComponentsDictionary } from "../../../DynamicFilter/dictionary-CNZO5wD-.js";
+import { g as getRHFAutocompleteComponentsDictionary } from "../../../hook-form/RHFAutocomplete/dictionary-C5ATeyRM.js";
+const MAPGPSTOOLS_DICTIONARY_ID = "gps_tools";
+function getMapGpsToolsComponentsDictionary() {
+  return [MAPGPSTOOLS_DICTIONARY_ID].concat(
+    getDataGridComponentsDictionary().concat(getRHFAutocompleteComponentsDictionary()).concat(getDynamicFilterComponentsDictionary())
+  );
+}
+const MAP_GPSTOOLS_DICCTIONARY = {
+  /** Common */
+  /** GeofenceList */
+  MODULE_NAME_GEOFENCE_ADD: "module_name_geofence_add",
+  MODULE_NAME_GEOFENCE_EDIT: "module_name_geofence_edit",
+  // Row Actions
+  ROW_ACTION_GEO_EDIT: "row_action_geo_edit",
+  // ROW_ACTION_GEO_ENABLE: 'row_action_geo_enable',
+  // ROW_ACTION_GEO_DISABLE: 'row_action_geo_disable',
+  ROW_ACTION_GEO_DELETE: "row_action_geo_delete",
+  /** GeofenceAddEdit */
+  LABEL_TAB_GEO: "label_tab_geo",
+  TAB_GENERAL_CONFIG_TOOLTIP: "tab_general_config_tooltip",
+  PAPER_GENERAL: "paper_general",
+  LABEL_ID: "label_id",
+  LABEL_NAME: "label_name",
+  LABEL_ALIAS: "label_alias",
+  LABEL_CUSTOMER_ID: "label_customer_id",
+  LABEL_GEOMETRY_TYPE: "label_geometry_type",
+  LABEL_GEOMETRY_CIRCLE: "label_geometry_circle",
+  LABEL_GEOMETRY_RECTANGLE: "label_geometry_rectangle",
+  LABEL_GEOMETRY_POLYGON: "label_geometry_polygon",
+  LABEL_DRAW: "label_draw",
+  LABEL_FINISH: "label_finish",
+  PAPER_CONFIG: "paper_config",
+  LABEL_TIME_MIN_IN_SECONDS: "label_time_min_in_seconds",
+  LABEL_TIME_MIN_OUT_SECONDS: "label_time_min_out_seconds",
+  TAB_STYLE_CONFIG_TOOLTIP: "tab_style_tooltip",
+  PAPER_STROKE: "paper_stroke",
+  LABEL_COLOR: "label_color",
+  LABEL_OPACITY: "label_opacity",
+  LABEL_WEIGHT: "label_weight",
+  LABEL_DASH_ARRAY: "label_dash_array",
+  PAPER_FILL: "paper_fill",
+  LABEL_RADIUS: "label_radius",
+  LABEL_LAT: "label_lat",
+  LABEL_LON: "label_lon",
+  LABEL_PLACE_MARKER: "label_place_marker",
+  LABEL_FIRST_VERTEX: "label_first_vertex",
+  LABEL_CONTINUE_LINE: "label_continue_line",
+  LABEL_FINISH_LINE: "label_finish_line",
+  LABEL_FINISH_POLY: "label_finish_poly",
+  LABEL_FINISH_RECT: "label_finish_rect",
+  LABEL_START_CIRCLE: "label_start_circle",
+  LABEL_FINISH_CIRCLE: "label_finish_circle",
+  LABEL_PLACE_CIRCLE_MARKER: "label_place_circle_marker",
+  VALIDATION_GEOMETRY_REQUIRED: "validation_geometry_required",
+  VALIDATION_FIELD_REQUIRED: "validation_field_required",
+  VALIDATION_FIELD_TYPE_NUMBER_ERROR: "validation_field_type_number_error",
+  VALIDATION_FIELD_MIN_NUMBER_ERROR: "validation_field_min_number_error",
+  LABEL_VIEW_TRANSIT_FEATURES: "label_view_crossing_features",
+  LABEL_VIEW_INTERNAL_FEATURES: "label_view_internal_features",
+  LABEL_CREATED_AT: "label_created_at",
+  LABEL_UPDATED_AT: "label_updated_at",
+  MODAL_DELETE_GEO_TITLE: "modal_delete_geo_title",
+  MODAL_DELETE_GEO_MESSAGE: "modal_delete_geo_message",
+  MODAL_DISABLE_GEO_TITLE: "modal_disable_geo_title",
+  MODAL_DISABLE_MESSAGE: "modal_disable_geo_message",
+  ACTION_CANCEL: "action_cancel"
+};
+export {
+  MAP_GPSTOOLS_DICCTIONARY as M,
+  getMapGpsToolsComponentsDictionary as g
+};

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

@@ -1,16 +1,11 @@
 export declare const MAPGPSTOOLS_DICTIONARY_ID = "gps_tools";
+export declare function getMapGpsToolsComponentsDictionary(): string[];
 export declare const MAP_GPSTOOLS_DICCTIONARY: {
-    /**
-     * GPSTools
-     */
-    readonly LABEL_GPSTOOLS_NAME: "label_gpstools_name";
     /** Common */
     /** GeofenceList */
-    readonly ACTION_GEOFENCE_ADD: "action_geofence_add";
-    readonly ACTION_GEOFENCE_EDIT: "action_geofence_edit";
+    readonly MODULE_NAME_GEOFENCE_ADD: "module_name_geofence_add";
+    readonly MODULE_NAME_GEOFENCE_EDIT: "module_name_geofence_edit";
     readonly ROW_ACTION_GEO_EDIT: "row_action_geo_edit";
-    readonly ROW_ACTION_GEO_ENABLE: "row_action_geo_enable";
-    readonly ROW_ACTION_GEO_DISABLE: "row_action_geo_disable";
     readonly ROW_ACTION_GEO_DELETE: "row_action_geo_delete";
     /** GeofenceAddEdit */
     readonly LABEL_TAB_GEO: "label_tab_geo";
@@ -18,6 +13,8 @@ export declare const MAP_GPSTOOLS_DICCTIONARY: {
     readonly PAPER_GENERAL: "paper_general";
     readonly LABEL_ID: "label_id";
     readonly LABEL_NAME: "label_name";
+    readonly LABEL_ALIAS: "label_alias";
+    readonly LABEL_CUSTOMER_ID: "label_customer_id";
     readonly LABEL_GEOMETRY_TYPE: "label_geometry_type";
     readonly LABEL_GEOMETRY_CIRCLE: "label_geometry_circle";
     readonly LABEL_GEOMETRY_RECTANGLE: "label_geometry_rectangle";
@@ -25,8 +22,6 @@ export declare const MAP_GPSTOOLS_DICCTIONARY: {
     readonly LABEL_DRAW: "label_draw";
     readonly LABEL_FINISH: "label_finish";
     readonly PAPER_CONFIG: "paper_config";
-    readonly LABEL_ALIAS: "label_alias";
-    readonly LABEL_CUSTOMER_ID: "label_customer_id";
     readonly LABEL_TIME_MIN_IN_SECONDS: "label_time_min_in_seconds";
     readonly LABEL_TIME_MIN_OUT_SECONDS: "label_time_min_out_seconds";
     readonly TAB_STYLE_CONFIG_TOOLTIP: "tab_style_tooltip";
@@ -35,7 +30,6 @@ export declare const MAP_GPSTOOLS_DICCTIONARY: {
     readonly LABEL_OPACITY: "label_opacity";
     readonly LABEL_WEIGHT: "label_weight";
     readonly LABEL_DASH_ARRAY: "label_dash_array";
-    readonly LABEL_DASH_OFFSET: "label_dash_offset";
     readonly PAPER_FILL: "paper_fill";
     readonly LABEL_RADIUS: "label_radius";
     readonly LABEL_LAT: "label_lat";
@@ -63,5 +57,3 @@ export declare const MAP_GPSTOOLS_DICCTIONARY: {
     readonly MODAL_DISABLE_MESSAGE: "modal_disable_geo_message";
     readonly ACTION_CANCEL: "action_cancel";
 };
-export declare type TypeDictionary = typeof MAP_GPSTOOLS_DICCTIONARY;
-export declare const getMapToolsDictionary: (key: keyof TypeDictionary) => string;