@m4l/gclick 0.2.0 → 0.2.1

package/components/maps/components/GpsMapTools/contexts/GpsMapToolsContext/index.d.ts

@@ -1,21 +1 @@
-import { GpsMapToolsProviderProps } from './types';
-declare const GpsMapToolsContext: import('react').Context<(Omit<Omit<import('zustand').StoreApi<import('./types').GpsMapToolsStateWithActions>, "setState"> & {
-    setState<A extends string | {
-        type: unknown;
-    }>(partial: import('./types').GpsMapToolsStateWithActions | Partial<import('./types').GpsMapToolsStateWithActions> | ((state: import('./types').GpsMapToolsStateWithActions) => import('./types').GpsMapToolsStateWithActions | Partial<import('./types').GpsMapToolsStateWithActions>), replace?: boolean | undefined, action?: A | undefined): void;
-}, "setState"> & {
-    setState(nextStateOrUpdater: import('./types').GpsMapToolsStateWithActions | Partial<import('./types').GpsMapToolsStateWithActions> | ((state: import('immer/dist/internal').WritableDraft<import('./types').GpsMapToolsStateWithActions>) => void), shouldReplace?: boolean | undefined, action?: string | {
-        type: unknown;
-    } | undefined): void;
-}) | null>;
-/**
- * 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
- */
-/**
- * TODO: Documentar
- */
-declare function GpsMapToolsProvider(props: GpsMapToolsProviderProps): import("react/jsx-runtime").JSX.Element;
-export { GpsMapToolsProvider, GpsMapToolsContext };
+export { GpsMapToolsContext, GpsMapToolsProvider } from './GpsMapToolsContext';

package/components/maps/components/GpsMapTools/contexts/GpsMapToolsContext/index.js

@@ -1,48 +1 @@
-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 createGpsMapToolsStore } from "./store.js";
-const GpsMapToolsContext = createContext(null);
-function GpsMapToolsProvider(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 = createGpsMapToolsStore({
-      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(GpsMapToolsContext.Provider, { value: mapStoreRef.current, children });
-}
-export {
-  GpsMapToolsContext as G,
-  GpsMapToolsProvider as a
-};
+

package/components/maps/components/GpsMapTools/contexts/GpsMapToolsContext/store.d.ts

@@ -5,7 +5,7 @@ import { GpsMapToolsStateWithActions, InitialGpsMapToolsStoreProps } from './typ
  * @returns
  */
 /**
- * TODO: Documentar
+ * crea el store de las herramientas de gps
  */
 export declare const createGpsMapToolsStore: (initProps: InitialGpsMapToolsStoreProps) => Omit<Omit<import('zustand').StoreApi<GpsMapToolsStateWithActions>, "setState"> & {
     setState<A extends string | {

package/components/maps/components/GpsMapTools/contexts/GpsMapToolsContext/store.js

@@ -5,20 +5,16 @@ import { enableMapSet } from "immer";
 enableMapSet();
 const createGpsMapToolsStore = (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) => ({
+      immer((set, get) => ({
         ...startProps,
         gpsToolsActions: {
           /**
@@ -36,70 +32,71 @@ const createGpsMapToolsStore = (initProps) => {
             set((state) => {
               state.ownerState.status = status;
             });
-          },
-          /**
-           * TODO: Documentar
-           */
-          setHandlerGetLabel: (newHandler) => {
-            set((state) => {
-              state.getLabel = newHandler;
-            });
-          },
-          /**
-           * TODO: Documentar
-           */
-          setExternalState: (newExternalState) => {
-            set((state) => {
-              state.ownerState = { ...state.ownerState, ...newExternalState };
-            });
-          },
-          /**
-           * TODO: Documentar
-           */
-          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;
-          //     });
-          // },
           /**
-           * TODO: Documentar
+           * Esta función carga en el store la nueva geocerca proveniente del backend,
+           * Si ya existe solicita pintarla de nuevo por si tuvo algún cambio o es nueva.
+           * Esto se da cuando se intenta editar una geocerca sin haberla checkeado o cuando se da guardar en el add/edit geofence
            */
-          addGeofence: (geofenceId, geofence) => {
+          addOrReplaceGeofence: (geofenceId, newGeofence, ensureChecked = false) => {
+            let geofence = get().geofenceState.hashGeofences[geofenceId];
+            geofence = {
+              ...geofence ? geofence : {},
+              ...newGeofence,
+              mustPaintGeometry: geofence ? false : true
+            };
             set((state) => {
               state.geofenceState.hashGeofences[geofenceId] = geofence;
+              if (ensureChecked) {
+                if (!state.geofenceState.checkedGeofences.has(geofenceId)) {
+                  state.geofenceState.checkedGeofences.add(geofenceId);
+                  state.geofenceState.checkedGeofences = new Set(state.geofenceState.checkedGeofences);
+                }
+              }
             });
           },
           /**
-           * TODO: Documentar
+           * Veririfica si la geocerca ha cambiado con respecto al store, o si debe agregarse a el.
+           * Esto se da cuando llegan rows de la grilla, previniendo tener un falsa geocerca cargada.
            */
-          updatePartialGeofence: (geofenceId, geofence) => {
-            set((state) => {
-              state.geofenceState.hashGeofences[geofenceId] = {
-                ...state.geofenceState.hashGeofences[geofenceId],
-                ...geofence
+          verifyAddOrChangedGeofenceFromList: (geofenceId, geofenceFromRow) => {
+            let geoToAddOrReplace = get().geofenceState.hashGeofences[geofenceId];
+            if (!geoToAddOrReplace) {
+              geoToAddOrReplace = {
+                ...geofenceFromRow,
+                mustPaintGeometry: true
+                //Importante, si la geocerca es circulo o rectangulo, en el row viene ya la geometría, por lo tanto no necesita ser cargada desde el backend.
               };
+            } else {
+              if (geofenceFromRow.updatedAt && geofenceFromRow.updatedAt !== geoToAddOrReplace.updatedAt) {
+                geoToAddOrReplace = {
+                  ...geoToAddOrReplace,
+                  ...geofenceFromRow,
+                  geometry: geofenceFromRow.type.id === "gt_circle" || geofenceFromRow.type.id === "gt_rectangle" ? geofenceFromRow.geometry : null,
+                  mustPaintGeometry: true
+                };
+              } else {
+                geoToAddOrReplace = void 0;
+              }
+            }
+            if (!geoToAddOrReplace) {
+              return;
+            }
+            set((state) => {
+              state.geofenceState.hashGeofences[geofenceId] = geoToAddOrReplace;
             });
           },
           /**
-           * TODO: Documentar
+           * Actualizar parcialmente una geocerca, se pierde la anidación de los objetos por el spread operator
            */
-          updateRows: (newRows) => {
+          setPartialValue: (geofenceId, geofence) => {
             set((state) => {
-              state.geofenceState.rows = newRows;
+              state.geofenceState.hashGeofences[geofenceId] = {
+                ...state.geofenceState.hashGeofences[geofenceId],
+                ...geofence
+              };
             });
           },
           /**
@@ -131,17 +128,16 @@ const createGpsMapToolsStore = (initProps) => {
           /**
            * TODO: Documentar
            */
-          setCheckedCrossingFeatures: (newFeatures) => {
-            set((state) => {
-              state.geofenceState.checkedCrossingFeatures = new Set(newFeatures);
-            });
+          getGeofenceById: (geofenceId) => {
+            return get().geofenceState.hashGeofences[geofenceId];
           },
           /**
            * TODO: Documentar
            */
-          setCheckedInternalFeatures: (newFeatures) => {
+          flushGeofences: () => {
             set((state) => {
-              state.geofenceState.checkedInternalFeatures = new Set(newFeatures);
+              state.geofenceState.hashGeofences = {};
+              state.geofenceState.checkedGeofences = /* @__PURE__ */ new Set();
             });
           }
         }

package/components/maps/components/GpsMapTools/contexts/GpsMapToolsContext/types.d.ts

@@ -1,54 +1,27 @@
-import { GetLabelType } from '@m4l/core';
 import { ReactNode } from 'react';
 import { FeatureId } from '../../../GpsMap';
-import { CrossingFeature, GeofenceListModel, InternalFeature } from '../../subcomponents/TabsGpsTools/subcomponents/model';
+import { GeofenceListModel } from '../../subcomponents/GeofencesTool/model';
 export type GpsToolsStatus = 'init' | 'ready';
 export type CurrentTabGpsTool = 'geofences' | 'pois';
-export interface GeofenceFeature extends Pick<GeofenceListModel, 'id' | 'name' | 'type' | 'geometry' | 'properties' | 'createdAt' | 'updatedAt' | 'countCrossingFeatures' | 'countInternalFeatures' | 'timeMinInSeconds' | 'timeMinOutSeconds' | 'alias' | 'customerId'> {
-    hasRenderizedGeofence: boolean;
+export interface GeofenceFeature extends Pick<GeofenceListModel, 'id' | 'name' | 'type' | 'geometry' | 'properties' | 'createdAt' | 'updatedAt' | 'timeMinInSeconds' | 'timeMinOutSeconds' | 'alias' | 'customerId' | 'bounds'> {
     /**
-     * "renderizedCrossingFeatures" indica si está renderizado los features de cruce
+     * Indica si la geocerca debe ser pintada en el mapa
+     * Puede que la geocerca haya cambiado, este cargada en el store, pero no concuerda con la geometría pintada en el mapa,
+     * debe ser pintada nuevamente.
      */
-    hasRenderizedCrossingFeatures: boolean;
-    /**
-     * "loadedCrossingFeatures" features cargados, mas no necesariamente visibles (incremental)
-     */
-    loadedCrossingFeatures: CrossingFeature[] | null;
-    /**
-     * "loadedInternalFeatures" features internos cargados, mas no necesariamente visibles (incremental)
-     */
-    loadedInternalFeatures: InternalFeature[] | null;
-    /**
-     * "renderizedInternalFeatures" indica si está renderizado los features internos
-     */
-    hasRenderizedInternalFeatures: boolean;
+    mustPaintGeometry: boolean;
 }
 export type OwnerState = {
     status: GpsToolsStatus;
-    /**
-     *  "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 CurrentGeofenceTool = 'list' | 'add_edit';
 /**
  * Tipo de dato del Id de la geocerca
  */
 export interface GeofenceState {
-    rows: GeofenceListModel[];
     /**
      * "checkedGeofences" indica las geocercas visibles en el mapa
      */
@@ -57,14 +30,6 @@ export interface GeofenceState {
      * "hashGeofences" Almacena las geocercas que se han cargado alguna vez, no necesariamente visibles
      */
     hashGeofences: Record<FeatureId, GeofenceFeature>;
-    /**
-     * "checkedCrossingFeatures" indica los crossing features visibles en el mapa
-     */
-    checkedCrossingFeatures: ReadonlySet<GeofenceId>;
-    /**
-     * "checkedInternalFeatures" indica los features internos visibles en el mapa
-     */
-    checkedInternalFeatures: ReadonlySet<GeofenceId>;
 }
 /**
  * Tipo de dato del Id de la geocerca
@@ -75,18 +40,10 @@ export type GeofenceId = number;
  */
 export interface GpsMapToolsState {
     ownerState: OwnerState;
-    /**
-     * "currentTabTool" indica la pestaña actual en uso
-     */
-    currentTabGpsTool: CurrentTabGpsTool;
     /**
      * "geofenceState" manejo del estado lo relacionado con geocercas
      */
     geofenceState: GeofenceState;
-    /**
-     *  "getLabel" funcion que usará para traducir las etiquetas de diccionario
-     */
-    getLabel: GetLabelType;
 }
 export interface GpsMapToolsStateWithActions extends GpsMapToolsState {
     gpsToolsActions: {
@@ -98,39 +55,23 @@ export interface GpsMapToolsStateWithActions extends GpsMapToolsState {
          * Cambia el estado del las herramientas de gps
          */
         setGpsToolsState: (state: GpsToolsStatus) => 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;
-        /**
-         * Modifica los estados que se actualizan externamente al Store
-         * @param newIsMobile
-         * @returns
-         */
-        setCurrentTabTool: (newTabTool: CurrentTabGpsTool) => void;
     };
     geofenceActions: {
         /**
-         * Agrega una geocerca al store
+         * Esta función carga en el store la nueva geocerca proveniente del backend,
+         * Si ya existe solicita pintarla de nuevo por si tuvo algún cambio o es nueva.
+         * Esto se da cuando se intenta editar una geocerca sin haberla checkeado o cuando se da guardar en el add/edit geofence
          */
-        addGeofence: (geofenceId: GeofenceId, geofence: GeofenceFeature) => void;
+        addOrReplaceGeofence: (geofenceId: GeofenceId, newGeofence: GeofenceFeature, ensureChecked?: boolean) => void;
         /**
-         * Actualizar parcialmente una geocerca
+         * Veririfica si la geocerca ha cambiado con respecto al store, o si debe agregarse a el.
+         * Esto se da cuando llegan rows de la grilla, previniendo tener un falsa geocerca cargada.
          */
-        updatePartialGeofence: (geofenceId: GeofenceId, geofence: Partial<GeofenceFeature>) => void;
+        verifyAddOrChangedGeofenceFromList: (geofenceId: GeofenceId, geofence: GeofenceFeature) => void;
         /**
-         * Actualizar la filas que son mostradas en el grid de geocercas
+         * Actualizar parcialmente una geocerca, se pierde la anidación de los objetos por el spread operator
          */
-        updateRows: (newRows: GeofenceListModel[]) => void;
+        setPartialValue: (geofenceId: GeofenceId, geofence: Partial<GeofenceFeature>) => void;
         /**
          * Agrega una geocerca del set de chequeo
          */
@@ -144,17 +85,17 @@ export interface GpsMapToolsStateWithActions extends GpsMapToolsState {
          */
         removeCheckedGeofence: (geofenceId: GeofenceId) => void;
         /**
-         * Cambia el set de chequeo de los crossing features
+         * Obtiene las geocerca cargada, para evitar re-renders por suscribirse al hasGeofences
          */
-        setCheckedCrossingFeatures: (newFeatures: ReadonlySet<GeofenceId>) => void;
+        getGeofenceById: (geofenceId: GeofenceId) => GeofenceFeature | undefined;
         /**
-         * Cambia el set de chequeo de los internal features
+         * Flush el store de las geocercas
          */
-        setCheckedInternalFeatures: (newFeatures: ReadonlySet<GeofenceId>) => void;
+        flushGeofences: () => void;
     };
 }
 export type DefaultGpsMapToolsStoreProps = Omit<GpsMapToolsState, 'currentLayer'>;
-export type InitialGpsMapToolsStoreProps = Pick<GpsMapToolsState, 'getLabel' | 'ownerState'> & Partial<DefaultGpsMapToolsStoreProps>;
+export type InitialGpsMapToolsStoreProps = Pick<GpsMapToolsState, 'ownerState'> & Partial<DefaultGpsMapToolsStoreProps>;
 export interface GpsMapToolsProviderProps {
     children: ReactNode;
 }

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

@@ -1,62 +1,76 @@
-export declare const MAPGPSTOOLS_DICTIONARY_ID = "gps_tools";
+export declare const MAPGPSTOOLS_DICTIONARY_ID = "map_gps_tools";
 /**
  * TODO: Documentar
  */
 export declare function getGpsMapToolsComponentsDictionary(): string[];
 export declare const MAP_GPSTOOLS_DICCTIONARY: {
     /** Common */
+    readonly STEP_BASIC_INFORMATION: "map_gps_tools.step_basic_information";
+    readonly STEP_BASIC_INFORMATION_DESCRIPTION: "map_gps_tools.step_basic_information_description";
+    readonly STEP_STYLE: "map_gps_tools.step_style";
+    readonly STEP_STYLE_DESCRIPTION: "map_gps_tools.step_style_description";
+    readonly STEP_ASSIGNMENT: "map_gps_tools.step_assignment";
+    readonly STEP_ASSIGNMENT_DESCRIPTION: "map_gps_tools.step_assignment_description";
     /** GeofenceList */
-    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_DELETE: "row_action_geo_delete";
+    readonly MODULE_NAME_GEOFENCE_ADD: "map_gps_tools.module_name_geofence_add";
+    readonly MODULE_NAME_GEOFENCE_EDIT: "map_gps_tools.module_name_geofence_edit";
+    readonly ROW_ACTION_GEO_EDIT: "map_gps_tools.row_action_geo_edit";
+    readonly ROW_ACTION_GEO_DELETE: "map_gps_tools.row_action_geo_delete";
     /** GeofenceAddEdit */
-    readonly LABEL_TAB_GEO: "label_tab_geo";
-    readonly TAB_GENERAL_CONFIG_TOOLTIP: "tab_general_config_tooltip";
-    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";
-    readonly LABEL_GEOMETRY_POLYGON: "label_geometry_polygon";
-    readonly LABEL_DRAW: "label_draw";
-    readonly LABEL_FINISH: "label_finish";
-    readonly PAPER_CONFIG: "paper_config";
-    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";
-    readonly PAPER_STROKE: "paper_stroke";
-    readonly LABEL_COLOR: "label_color";
-    readonly LABEL_OPACITY: "label_opacity";
-    readonly LABEL_WEIGHT: "label_weight";
-    readonly LABEL_DASH_ARRAY: "label_dash_array";
-    readonly PAPER_FILL: "paper_fill";
-    readonly LABEL_RADIUS: "label_radius";
-    readonly LABEL_LAT: "label_lat";
-    readonly LABEL_LON: "label_lon";
-    readonly LABEL_PLACE_MARKER: "label_place_marker";
-    readonly LABEL_FIRST_VERTEX: "label_first_vertex";
-    readonly LABEL_CONTINUE_LINE: "label_continue_line";
-    readonly LABEL_FINISH_LINE: "label_finish_line";
-    readonly LABEL_FINISH_POLY: "label_finish_poly";
-    readonly LABEL_FINISH_RECT: "label_finish_rect";
-    readonly LABEL_START_CIRCLE: "label_start_circle";
-    readonly LABEL_FINISH_CIRCLE: "label_finish_circle";
-    readonly LABEL_PLACE_CIRCLE_MARKER: "label_place_circle_marker";
-    readonly VALIDATION_GEOMETRY_REQUIRED: "validation_geometry_required";
-    readonly VALIDATION_FIELD_REQUIRED: "validation_field_required";
-    readonly VALIDATION_FIELD_TYPE_NUMBER_ERROR: "validation_field_type_number_error";
-    readonly VALIDATION_FIELD_MIN_NUMBER_ERROR: "validation_field_min_number_error";
-    readonly LABEL_VIEW_TRANSIT_FEATURES: "label_view_crossing_features";
-    readonly LABEL_VIEW_INTERNAL_FEATURES: "label_view_internal_features";
-    readonly LABEL_CREATED_AT: "label_created_at";
-    readonly LABEL_UPDATED_AT: "label_updated_at";
-    readonly MODAL_DELETE_GEO_TITLE: "modal_delete_geo_title";
-    readonly MODAL_DELETE_GEO_MESSAGE: "modal_delete_geo_message";
-    readonly MODAL_DISABLE_GEO_TITLE: "modal_disable_geo_title";
-    readonly MODAL_DISABLE_MESSAGE: "modal_disable_geo_message";
-    readonly ACTION_CANCEL: "action_cancel";
+    readonly LABEL_GEOFENCES: "map_gps_tools.label_geofences";
+    readonly LABEL_TAB_FILTERED: "map_gps_tools.label_tab_filtered";
+    readonly LABEL_TAB_SELECTED: "map_gps_tools.label_tab_selected";
+    readonly TAB_GENERAL_CONFIG_TOOLTIP: "map_gps_tools.tab_general_config_tooltip";
+    readonly PAPER_GENERAL: "map_gps_tools.paper_general";
+    readonly LABEL_ID: "map_gps_tools.label_id";
+    readonly LABEL_NAME: "map_gps_tools.label_name";
+    readonly LABEL_ALIAS: "map_gps_tools.label_alias";
+    readonly LABEL_CUSTOMER_ID: "map_gps_tools.label_customer_id";
+    readonly LABEL_GEOMETRY_TYPE: "map_gps_tools.label_geometry_type";
+    readonly LABEL_GEOMETRY_CIRCLE: "map_gps_tools.label_geometry_circle";
+    readonly LABEL_GEOMETRY_RECTANGLE: "map_gps_tools.label_geometry_rectangle";
+    readonly LABEL_GEOMETRY_POLYGON: "map_gps_tools.label_geometry_polygon";
+    readonly LABEL_GEOMETRY_MULTIPOLYGON: "map_gps_tools.label_geometry_multipolygon";
+    readonly LABEL_DRAW: "map_gps_tools.label_draw";
+    readonly LABEL_DRAW_EDIT: "map_gps_tools.label_draw_edit";
+    readonly LABEL_FINISH: "map_gps_tools.label_finish";
+    readonly PAPER_CONFIG: "map_gps_tools.paper_config";
+    readonly LABEL_TIME_MIN_IN: "map_gps_tools.label_time_min_in";
+    readonly LABEL_TIME_MIN_OUT: "map_gps_tools.label_time_min_out";
+    readonly LABEL_TIME_UNIT_SECONDS: "map_gps_tools.label_time_unit_seconds";
+    readonly TAB_STYLE_CONFIG_TOOLTIP: "map_gps_tools.tab_style_tooltip";
+    readonly PAPER_STROKE: "map_gps_tools.paper_stroke";
+    readonly LABEL_COLOR: "map_gps_tools.label_color";
+    readonly LABEL_OPACITY: "map_gps_tools.label_opacity";
+    readonly LABEL_WEIGHT: "map_gps_tools.label_weight";
+    readonly LABEL_DASH_ARRAY: "map_gps_tools.label_dash_array";
+    readonly PAPER_FILL: "map_gps_tools.paper_fill";
+    readonly LABEL_RADIUS: "map_gps_tools.label_radius";
+    readonly LABEL_LAT: "map_gps_tools.label_lat";
+    readonly LABEL_LON: "map_gps_tools.label_lon";
+    readonly LABEL_GEOMAN_PLACE_MARKER: "map_gps_tools.label_geoman_place_marker";
+    readonly LABEL_GEOMAN_FIRST_VERTEX: "map_gps_tools.label_geoman_first_vertex";
+    readonly LABEL_GEOMAN_CONTINUE_LINE: "map_gps_tools.label_geoman_continue_line";
+    readonly LABEL_GEOMAN_FINISH_LINE: "map_gps_tools.label_geoman_finish_line";
+    readonly LABEL_GEOMAN_FINISH_POLYLINE: "map_gps_tools.label_geoman_finish_polyline";
+    readonly LABEL_GEOMAN_FINISH_RECT: "map_gps_tools.label_geoman_finish_rect";
+    readonly LABEL_GEOMAN_START_CIRCLE: "map_gps_tools.label_geoman_start_circle";
+    readonly LABEL_GEOMAN_FINISH_CIRCLE: "map_gps_tools.label_geoman_finish_circle";
+    readonly LABEL_GEOMAN_PLACE_CIRCLE_MARKER: "map_gps_tools.label_geoman_place_circle_marker";
+    readonly LABEL_STROKE_PATTERN_SOLID: "map_gps_tools.label_stroke_pattern_solid";
+    readonly LABEL_STROKE_PATTERN_DASH: "map_gps_tools.label_stroke_pattern_dash";
+    readonly VALIDATION_GEOMETRY_REQUIRED: "map_gps_tools.validation_geometry_required";
+    readonly VALIDATION_FIELD_REQUIRED: "map_gps_tools.validation_field_required";
+    readonly VALIDATION_IS_IN_EDITION: "map_gps_tools.validation_is_in_edition";
+    readonly VALIDATION_FIELD_TYPE_NUMBER_ERROR: "map_gps_tools.validation_field_type_number_error";
+    readonly VALIDATION_FIELD_MIN_NUMBER_ERROR: "map_gps_tools.validation_field_min_number_error";
+    readonly LABEL_VIEW_TRANSIT_FEATURES: "map_gps_tools.label_view_crossing_features";
+    readonly LABEL_VIEW_INTERNAL_FEATURES: "map_gps_tools.label_view_internal_features";
+    readonly LABEL_CREATED_AT: "map_gps_tools.label_created_at";
+    readonly LABEL_UPDATED_AT: "map_gps_tools.label_updated_at";
+    readonly MODAL_DELETE_GEO_TITLE: "map_gps_tools.modal_delete_geo_title";
+    readonly MODAL_DELETE_GEO_MESSAGE: "map_gps_tools.modal_delete_geo_message";
+    readonly MODAL_DISABLE_GEO_TITLE: "map_gps_tools.modal_disable_geo_title";
+    readonly MODAL_DISABLE_MESSAGE: "map_gps_tools.modal_disable_geo_message";
+    readonly ACTION_CANCEL: "map_gps_tools.action_cancel";
 };