@m4l/gclick 0.2.0 → 0.2.1

package/components/maps/components/GpsMapTools/dictionary.js

@@ -1,64 +1,72 @@
-import { getDataGridComponentsDictionary, getRHFAutocompleteComponentsDictionary, getDynamicFilterComponentsDictionary } from "@m4l/components";
-const MAPGPSTOOLS_DICTIONARY_ID = "gps_tools";
+import { getDataGridComponentsDictionary, getRHFAutocompleteComponentsDictionary, getDynamicFilterComponentsDictionary, getDynamicSortComponentsDictionary } from "@m4l/components";
+const MAPGPSTOOLS_DICTIONARY_ID = "map_gps_tools";
 function getGpsMapToolsComponentsDictionary() {
   return [MAPGPSTOOLS_DICTIONARY_ID].concat(
-    getDataGridComponentsDictionary().concat(getRHFAutocompleteComponentsDictionary()).concat(getDynamicFilterComponentsDictionary())
+    getDataGridComponentsDictionary().concat(getRHFAutocompleteComponentsDictionary()).concat(getDynamicFilterComponentsDictionary()).concat(getDynamicSortComponentsDictionary())
   );
 }
 const MAP_GPSTOOLS_DICCTIONARY = {
   /** Common */
+  STEP_BASIC_INFORMATION: `${MAPGPSTOOLS_DICTIONARY_ID}.step_basic_information`,
+  STEP_BASIC_INFORMATION_DESCRIPTION: `${MAPGPSTOOLS_DICTIONARY_ID}.step_basic_information_description`,
+  STEP_STYLE: `${MAPGPSTOOLS_DICTIONARY_ID}.step_style`,
+  STEP_STYLE_DESCRIPTION: `${MAPGPSTOOLS_DICTIONARY_ID}.step_style_description`,
   /** GeofenceList */
-  MODULE_NAME_GEOFENCE_ADD: "module_name_geofence_add",
-  MODULE_NAME_GEOFENCE_EDIT: "module_name_geofence_edit",
+  MODULE_NAME_GEOFENCE_ADD: `${MAPGPSTOOLS_DICTIONARY_ID}.module_name_geofence_add`,
+  MODULE_NAME_GEOFENCE_EDIT: `${MAPGPSTOOLS_DICTIONARY_ID}.module_name_geofence_edit`,
   // Row Actions
-  ROW_ACTION_GEO_EDIT: "row_action_geo_edit",
+  ROW_ACTION_GEO_EDIT: `${MAPGPSTOOLS_DICTIONARY_ID}.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",
+  ROW_ACTION_GEO_DELETE: `${MAPGPSTOOLS_DICTIONARY_ID}.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_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_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",
-  ACTION_CANCEL: "action_cancel"
+  LABEL_GEOFENCES: `${MAPGPSTOOLS_DICTIONARY_ID}.label_geofences`,
+  LABEL_TAB_FILTERED: `${MAPGPSTOOLS_DICTIONARY_ID}.label_tab_filtered`,
+  LABEL_TAB_SELECTED: `${MAPGPSTOOLS_DICTIONARY_ID}.label_tab_selected`,
+  PAPER_GENERAL: `${MAPGPSTOOLS_DICTIONARY_ID}.paper_general`,
+  LABEL_ID: `${MAPGPSTOOLS_DICTIONARY_ID}.label_id`,
+  LABEL_NAME: `${MAPGPSTOOLS_DICTIONARY_ID}.label_name`,
+  LABEL_ALIAS: `${MAPGPSTOOLS_DICTIONARY_ID}.label_alias`,
+  LABEL_CUSTOMER_ID: `${MAPGPSTOOLS_DICTIONARY_ID}.label_customer_id`,
+  LABEL_GEOMETRY_TYPE: `${MAPGPSTOOLS_DICTIONARY_ID}.label_geometry_type`,
+  LABEL_GEOMETRY_CIRCLE: `${MAPGPSTOOLS_DICTIONARY_ID}.label_geometry_circle`,
+  LABEL_GEOMETRY_RECTANGLE: `${MAPGPSTOOLS_DICTIONARY_ID}.label_geometry_rectangle`,
+  LABEL_GEOMETRY_POLYGON: `${MAPGPSTOOLS_DICTIONARY_ID}.label_geometry_polygon`,
+  LABEL_GEOMETRY_MULTIPOLYGON: `${MAPGPSTOOLS_DICTIONARY_ID}.label_geometry_multipolygon`,
+  LABEL_DRAW: `${MAPGPSTOOLS_DICTIONARY_ID}.label_draw`,
+  LABEL_FINISH: `${MAPGPSTOOLS_DICTIONARY_ID}.label_finish`,
+  PAPER_CONFIG: `${MAPGPSTOOLS_DICTIONARY_ID}.paper_config`,
+  LABEL_TIME_MIN_IN: `${MAPGPSTOOLS_DICTIONARY_ID}.label_time_min_in`,
+  LABEL_TIME_MIN_OUT: `${MAPGPSTOOLS_DICTIONARY_ID}.label_time_min_out`,
+  LABEL_TIME_UNIT_SECONDS: `${MAPGPSTOOLS_DICTIONARY_ID}.label_time_unit_seconds`,
+  PAPER_STROKE: `${MAPGPSTOOLS_DICTIONARY_ID}.paper_stroke`,
+  LABEL_COLOR: `${MAPGPSTOOLS_DICTIONARY_ID}.label_color`,
+  LABEL_OPACITY: `${MAPGPSTOOLS_DICTIONARY_ID}.label_opacity`,
+  LABEL_WEIGHT: `${MAPGPSTOOLS_DICTIONARY_ID}.label_weight`,
+  LABEL_DASH_ARRAY: `${MAPGPSTOOLS_DICTIONARY_ID}.label_dash_array`,
+  PAPER_FILL: `${MAPGPSTOOLS_DICTIONARY_ID}.paper_fill`,
+  LABEL_RADIUS: `${MAPGPSTOOLS_DICTIONARY_ID}.label_radius`,
+  LABEL_LAT: `${MAPGPSTOOLS_DICTIONARY_ID}.label_lat`,
+  LABEL_LON: `${MAPGPSTOOLS_DICTIONARY_ID}.label_lon`,
+  LABEL_GEOMAN_FIRST_VERTEX: `${MAPGPSTOOLS_DICTIONARY_ID}.label_geoman_first_vertex`,
+  LABEL_GEOMAN_CONTINUE_LINE: `${MAPGPSTOOLS_DICTIONARY_ID}.label_geoman_continue_line`,
+  LABEL_GEOMAN_FINISH_LINE: `${MAPGPSTOOLS_DICTIONARY_ID}.label_geoman_finish_line`,
+  LABEL_GEOMAN_FINISH_POLYLINE: `${MAPGPSTOOLS_DICTIONARY_ID}.label_geoman_finish_polyline`,
+  LABEL_GEOMAN_FINISH_RECT: `${MAPGPSTOOLS_DICTIONARY_ID}.label_geoman_finish_rect`,
+  LABEL_GEOMAN_START_CIRCLE: `${MAPGPSTOOLS_DICTIONARY_ID}.label_geoman_start_circle`,
+  LABEL_GEOMAN_FINISH_CIRCLE: `${MAPGPSTOOLS_DICTIONARY_ID}.label_geoman_finish_circle`,
+  LABEL_GEOMAN_PLACE_CIRCLE_MARKER: `${MAPGPSTOOLS_DICTIONARY_ID}.label_geoman_place_circle_marker`,
+  LABEL_STROKE_PATTERN_SOLID: `${MAPGPSTOOLS_DICTIONARY_ID}.label_stroke_pattern_solid`,
+  LABEL_STROKE_PATTERN_DASH: `${MAPGPSTOOLS_DICTIONARY_ID}.label_stroke_pattern_dash`,
+  VALIDATION_GEOMETRY_REQUIRED: `${MAPGPSTOOLS_DICTIONARY_ID}.validation_geometry_required`,
+  VALIDATION_FIELD_REQUIRED: `${MAPGPSTOOLS_DICTIONARY_ID}.validation_field_required`,
+  VALIDATION_IS_IN_EDITION: `${MAPGPSTOOLS_DICTIONARY_ID}.validation_is_in_edition`,
+  VALIDATION_FIELD_TYPE_NUMBER_ERROR: `${MAPGPSTOOLS_DICTIONARY_ID}.validation_field_type_number_error`,
+  VALIDATION_FIELD_MIN_NUMBER_ERROR: `${MAPGPSTOOLS_DICTIONARY_ID}.validation_field_min_number_error`,
+  LABEL_CREATED_AT: `${MAPGPSTOOLS_DICTIONARY_ID}.label_created_at`,
+  LABEL_UPDATED_AT: `${MAPGPSTOOLS_DICTIONARY_ID}.label_updated_at`,
+  MODAL_DELETE_GEO_TITLE: `${MAPGPSTOOLS_DICTIONARY_ID}.modal_delete_geo_title`,
+  MODAL_DELETE_GEO_MESSAGE: `${MAPGPSTOOLS_DICTIONARY_ID}.modal_delete_geo_message`
 };
 export {
   MAP_GPSTOOLS_DICCTIONARY as M,

package/components/maps/components/GpsMapTools/hooks/useGpsMapToolsStore/index.js

@@ -1,6 +1,6 @@
 import { useContext } from "react";
 import { useStore } from "zustand";
-import { G as GpsMapToolsContext } from "../../contexts/GpsMapToolsContext/index.js";
+import { G as GpsMapToolsContext } from "../../contexts/GpsMapToolsContext/GpsMapToolsContext.js";
 function useGpsMapToolsStore(selector, equalityFn) {
   const context = useContext(GpsMapToolsContext);
   if (!context) {

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

@@ -1,23 +1,64 @@
 export declare const MAP_GPSTOOLS_ICONS: {
+    GEOFENCES_PAPER_GENERAL: string;
+    GEOFENCES_PAPER_STYLE: string;
+    GEOFENCES_PAPER_ASSIGNMENT: string;
     /**
      * GpsTools
      */
-    MAP_GPS_TOOLS_TOOL: string;
+    GEOFENCES_TOOL: string;
     GEOFENCES: string;
-    GEOFENCE_ID: string;
-    GEOFENCE_NAME: string;
-    GEOFENCE_ADD: string;
-    GEOFENCE_EDIT: string;
-    GEOFENCE_DELETE: string;
-    GENERAL: string;
-    DATA: string;
-    STYLE: string;
-    GEOFENCE_DRAW: string;
-    GEOFENCE_FINISH: string;
-    GEOFENCE_TYPE_CIRCLE: string;
-    GEOFENCE_TYPE_RECTANGLE: string;
-    GEOFENCE_TYPE_POLYGON: string;
-    CONFIG: string;
-    STROKE: string;
-    FILL: string;
+    GEOFENCES_ID: string;
+    GEOFENCES_NAME: string;
+    GEOFENCES_ADD: string;
+    GEOFENCES_EDIT: string;
+    GEOFENCES_DELETE: string;
+    GEOFENCES_GENERAL: string;
+    GEOFENCES_DATA: string;
+    GEOFENCES_STYLE: string;
+    GEOFENCES_DRAW: string;
+    GEOFENCES_FINISH: string;
+    GEOFENCES_TYPE_CIRCLE: string;
+    GEOFENCES_TYPE_RECTANGLE: string;
+    GEOFENCES_TYPE_POLYGON: string;
+    GEOFENCES_TYPE_MULTIPOLYGON: string;
+    GEOFENCES_TYPE_NOT_RECOGNIZED: string;
+    GEOFENCES_TIME_MIN_IN: string;
+    GEOFENCES_TIME_MIN_OUT: string;
+    GEOFENCES_STROKE_WEIGHT_1: string;
+    GEOFENCES_STROKE_WEIGHT_2: string;
+    GEOFENCES_STROKE_WEIGHT_4: string;
+    GEOFENCES_STROKE_PATTERN_SOLID: string;
+    GEOFENCES_STROKE_PATTERN_DASH: string;
+    GEOFENCES_CONFIG: string;
+    GEOFENCES_STROKE: string;
+    GEOFENCES_FILL: string;
+};
+export declare const GEOFENCES_TYPE_ID: {
+    POLYGON: string;
+    CIRCLE: string;
+    RECTANGLE: string;
+    MULTIPOLYGON: string;
+    NOT_RECOGNIZED: string;
+};
+export declare const GEOFENCES_TYPE_ICONS: {
+    [GEOFENCES_TYPE_ID.POLYGON]: {
+        icon: string;
+        dictionaryId: "map_gps_tools.label_geometry_polygon";
+    };
+    [GEOFENCES_TYPE_ID.MULTIPOLYGON]: {
+        icon: string;
+        dictionaryId: "map_gps_tools.label_geometry_multipolygon";
+    };
+    [GEOFENCES_TYPE_ID.CIRCLE]: {
+        icon: string;
+        dictionaryId: "map_gps_tools.label_geometry_circle";
+    };
+    [GEOFENCES_TYPE_ID.RECTANGLE]: {
+        icon: string;
+        dictionaryId: "map_gps_tools.label_geometry_rectangle";
+    };
+    [GEOFENCES_TYPE_ID.NOT_RECOGNIZED]: {
+        icon: string;
+        dictionaryId: undefined;
+    };
 };

package/components/maps/components/GpsMapTools/icons.js

@@ -1,22 +1,49 @@
+import { M as MAP_GPSTOOLS_DICCTIONARY } from "./dictionary.js";
 const MAP_GPSTOOLS_ICONS = {
-  GEOFENCES: "cmp_map_gpstools_geofences.svg",
-  GEOFENCE_ID: "cmp_map_gpstools_geofence_id.svg",
-  GEOFENCE_NAME: "cmp_map_gpstools_geofence_name.svg",
-  GEOFENCE_ADD: "cmp_map_gpstools_add-geofence.svg",
-  GEOFENCE_EDIT: "cmp_map_gpstools_edit-geofence.svg",
-  GEOFENCE_DELETE: "cmp_map_gpstools_delete-geofence.svg",
-  GENERAL: "cmp_map_gpstools_general.svg",
-  DATA: "cmp_map_gpstools_data.svg",
-  STYLE: "cmp_map_gpstools_style.svg",
-  GEOFENCE_DRAW: "cmp_map_gpstools_draw.svg",
-  GEOFENCE_FINISH: "cmp_map_gpstools_finish.svg",
-  GEOFENCE_TYPE_CIRCLE: "cmp_map_gpstools_circle.svg",
-  GEOFENCE_TYPE_RECTANGLE: "cmp_map_gpstools_rectangle.svg",
-  GEOFENCE_TYPE_POLYGON: "cmp_map_gpstools_polygon.svg",
-  CONFIG: "cmp_map_gpstools_config.svg",
-  STROKE: "cmp_map_gpstools_stroke.svg",
-  FILL: "cmp_map_gpstools_fill.svg"
+  GEOFENCES_PAPER_GENERAL: "geofences_general_information.svg",
+  GEOFENCES_PAPER_STYLE: "geofences_style.svg",
+  /**
+   * GpsTools
+   */
+  GEOFENCES_TOOL: "geofences_geofence.svg",
+  GEOFENCES_ID: "geofences_id.svg",
+  GEOFENCES_NAME: "geofences_name.svg",
+  GEOFENCES_ADD: "geofences_add.svg",
+  GEOFENCES_EDIT: "geofences_edit.svg",
+  GEOFENCES_DELETE: "geofences_delete.svg",
+  GEOFENCES_GENERAL: "geofences_general.svg",
+  GEOFENCES_TYPE_CIRCLE: "geofences_circle.svg",
+  GEOFENCES_TYPE_RECTANGLE: "geofences_rectangle.svg",
+  GEOFENCES_TYPE_POLYGON: "geofences_polygon.svg",
+  GEOFENCES_TYPE_MULTIPOLYGON: "geofences_multiple_polygon.svg",
+  GEOFENCES_TYPE_NOT_RECOGNIZED: "geofences_not_recognized.svg",
+  GEOFENCES_TIME_MIN_IN: "geofences_entry.svg",
+  GEOFENCES_TIME_MIN_OUT: "geofences_exit.svg",
+  GEOFENCES_STROKE_WEIGHT_1: "geofences_weight_1px.svg",
+  GEOFENCES_STROKE_WEIGHT_2: "geofences_weight_2px.svg",
+  GEOFENCES_STROKE_WEIGHT_4: "geofences_weight_4px.svg",
+  GEOFENCES_STROKE_PATTERN_SOLID: "geofences_stroke_solid.svg",
+  GEOFENCES_STROKE_PATTERN_DASH: "geofences_stroke_dash.svg",
+  GEOFENCES_CONFIG: "geofences_configuration.svg",
+  GEOFENCES_STROKE: "geofences_stroke.svg",
+  GEOFENCES_FILL: "geofences_fill.svg"
+};
+const GEOFENCES_TYPE_ID = {
+  POLYGON: "gt_polygon",
+  CIRCLE: "gt_circle",
+  RECTANGLE: "gt_rectangle",
+  MULTIPOLYGON: "gt_multipolygon",
+  NOT_RECOGNIZED: "not_recognized"
+};
+const GEOFENCES_TYPE_ICONS = {
+  [GEOFENCES_TYPE_ID.POLYGON]: { icon: MAP_GPSTOOLS_ICONS.GEOFENCES_TYPE_POLYGON, dictionaryId: MAP_GPSTOOLS_DICCTIONARY.LABEL_GEOMETRY_POLYGON },
+  [GEOFENCES_TYPE_ID.MULTIPOLYGON]: { icon: MAP_GPSTOOLS_ICONS.GEOFENCES_TYPE_MULTIPOLYGON, dictionaryId: MAP_GPSTOOLS_DICCTIONARY.LABEL_GEOMETRY_MULTIPOLYGON },
+  [GEOFENCES_TYPE_ID.CIRCLE]: { icon: MAP_GPSTOOLS_ICONS.GEOFENCES_TYPE_CIRCLE, dictionaryId: MAP_GPSTOOLS_DICCTIONARY.LABEL_GEOMETRY_CIRCLE },
+  [GEOFENCES_TYPE_ID.RECTANGLE]: { icon: MAP_GPSTOOLS_ICONS.GEOFENCES_TYPE_RECTANGLE, dictionaryId: MAP_GPSTOOLS_DICCTIONARY.LABEL_GEOMETRY_RECTANGLE },
+  [GEOFENCES_TYPE_ID.NOT_RECOGNIZED]: { icon: MAP_GPSTOOLS_ICONS.GEOFENCES_TYPE_NOT_RECOGNIZED, dictionaryId: void 0 }
 };
 export {
-  MAP_GPSTOOLS_ICONS as M
+  GEOFENCES_TYPE_ICONS as G,
+  MAP_GPSTOOLS_ICONS as M,
+  GEOFENCES_TYPE_ID as a
 };

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

@@ -1,5 +1,4 @@
-export { GpsMapTools } from './GpsMapTools';
-export { GpsMapToolsProvider } from './contexts/GpsMapToolsContext';
-export { getGpsMapToolsComponentsDictionary as getGpsMapToolsComponentsDictionary } from './dictionary';
-export { useGpsMapToolsStore } from './hooks/useGpsMapToolsStore';
-export type { GpsMapToolsType } from './GpsMapTools';
+export { GeofencesTool } from './subcomponents/GeofencesTool/GeofencesTool';
+export * from './contexts/GpsMapToolsContext';
+export { GEOFENCES_TOOL } from './subcomponents/GeofencesTool/constants';
+export { getGpsMapToolsComponentsDictionary } from './dictionary';

package/components/maps/components/GpsMapTools/subcomponents/GeofencesTool/GeofencesTool.d.ts

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

package/components/maps/components/GpsMapTools/subcomponents/GeofencesTool/GeofencesTool.js

@@ -0,0 +1,16 @@
+import { jsx } from "react/jsx-runtime";
+import { u as useMaster } from "./hooks/useMaster.js";
+import { DynamicTabs } from "@m4l/layouts";
+function GeofencesTool() {
+  const { tabs, defaultTab } = useMaster();
+  return /* @__PURE__ */ jsx(
+    DynamicTabs,
+    {
+      tabs,
+      defaultTab
+    }
+  );
+}
+export {
+  GeofencesTool as G
+};

package/components/maps/components/GpsMapTools/subcomponents/GeofencesTool/constants.d.ts

@@ -0,0 +1,12 @@
+import { PositionMapTool } from '../../../GpsMap/types';
+import { RNDDefaultPosition } from '@m4l/components';
+import { StyleDashArray } from './model';
+export declare const ENDPOINT_GEOFENCES_GET = "geofences";
+export declare const ENDPOINT_GEOFENCES_NEW_EDIT = "geofences";
+export declare const GEOFENCES_TOOL_LIST_POPUP_ID = "geofences";
+export declare enum GeofencesLayers {
+    LAYER_GEOFENCES = "geofences"
+}
+export declare const GEOFENCES_TOOL: PositionMapTool;
+export declare const GEOFENCES_TOOL_DEFAULT_POSITION: RNDDefaultPosition;
+export declare const STYLE_PATTERNS: StyleDashArray[];

package/components/maps/components/GpsMapTools/subcomponents/GeofencesTool/constants.js

@@ -0,0 +1,52 @@
+import { G as GPS_TOOLS_COMPONENT_PATH_ID } from "../../constants.js";
+import { M as MAP_GPSTOOLS_DICCTIONARY } from "../../dictionary.js";
+import { M as MAP_GPSTOOLS_ICONS } from "../../icons.js";
+import { G as GeofencesTool } from "./GeofencesTool.js";
+const ENDPOINT_GEOFENCES_GET = "geofences";
+const ENDPOINT_GEOFENCES_NEW_EDIT = "geofences";
+const GEOFENCES_TOOL_LIST_POPUP_ID = "geofences";
+var GeofencesLayers = /* @__PURE__ */ ((GeofencesLayers2) => {
+  GeofencesLayers2[GeofencesLayers2["LAYER_GEOFENCES"] = GEOFENCES_TOOL_LIST_POPUP_ID] = "LAYER_GEOFENCES";
+  return GeofencesLayers2;
+})(GeofencesLayers || {});
+const GEOFENCES_TOOL = {
+  position: "topright",
+  type: "popup",
+  isInternal: true,
+  componentPathId: GPS_TOOLS_COMPONENT_PATH_ID,
+  iconId: MAP_GPSTOOLS_ICONS.GEOFENCES_TOOL,
+  id: GEOFENCES_TOOL_LIST_POPUP_ID,
+  dictionaryId: MAP_GPSTOOLS_DICCTIONARY.LABEL_GEOFENCES,
+  popupDefaultPosition: {
+    vertical: { top: 16, bottom: 50 },
+    horizontal: { right: -55, width: 380, magnetize: true }
+  },
+  PopupContentComponent: GeofencesTool
+};
+const GEOFENCES_TOOL_DEFAULT_POSITION = {
+  vertical: { top: 16, bottom: 50 },
+  horizontal: { right: -55, width: 380, magnetize: true }
+};
+const STYLE_PATTERNS = [
+  {
+    id: "solid",
+    dictionaryId: MAP_GPSTOOLS_DICCTIONARY.LABEL_STROKE_PATTERN_SOLID,
+    iconId: MAP_GPSTOOLS_ICONS.GEOFENCES_STROKE_PATTERN_SOLID,
+    style: ""
+  },
+  {
+    id: "dash",
+    dictionaryId: MAP_GPSTOOLS_DICCTIONARY.LABEL_STROKE_PATTERN_DASH,
+    iconId: MAP_GPSTOOLS_ICONS.GEOFENCES_STROKE_PATTERN_DASH,
+    style: "4 8"
+  }
+];
+export {
+  ENDPOINT_GEOFENCES_GET as E,
+  GeofencesLayers as G,
+  STYLE_PATTERNS as S,
+  GEOFENCES_TOOL_DEFAULT_POSITION as a,
+  ENDPOINT_GEOFENCES_NEW_EDIT as b,
+  GEOFENCES_TOOL_LIST_POPUP_ID as c,
+  GEOFENCES_TOOL as d
+};

package/components/maps/components/GpsMapTools/subcomponents/GeofencesTool/helpers.d.ts

@@ -0,0 +1,9 @@
+import { GeofenceStyleProperties, StyleProperties } from './model';
+/**
+ * Retorna el estilo de la patrón de trazo
+ */
+export declare const getStylePatternFromId: (id: string) => string;
+/**
+ * Retorna el estilo para Leaflet basado en las propiedades de la geocerca, que vienen de la base de datos
+ */
+export declare const getStyleFromProperties: (properties: GeofenceStyleProperties) => StyleProperties;

package/components/maps/components/GpsMapTools/subcomponents/GeofencesTool/helpers.js

@@ -0,0 +1,17 @@
+import { S as STYLE_PATTERNS } from "./constants.js";
+const getStylePatternFromId = (id) => {
+  return STYLE_PATTERNS.find((style) => style.id === id)?.style || STYLE_PATTERNS[0].style;
+};
+const getStyleFromProperties = (properties) => {
+  return {
+    fillColor: properties.fillColor,
+    fillOpacity: properties.fillOpacity,
+    color: properties.strokeColor,
+    opacity: properties.strokeOpacity,
+    weight: properties.strokeWeight,
+    dashArray: getStylePatternFromId(properties.strokeDashArray)
+  };
+};
+export {
+  getStyleFromProperties as g
+};

package/components/maps/components/GpsMapTools/subcomponents/GeofencesTool/hooks/useColumns.d.ts

@@ -0,0 +1,8 @@
+import { GeofenceListColumns } from '../model';
+import { Column } from 'react-data-grid';
+/**
+ * columnas del grid de geofences
+ */
+export declare function useColumns(): {
+    columns: Column<GeofenceListColumns, unknown>[];
+};

package/components/maps/components/GpsMapTools/subcomponents/GeofencesTool/hooks/useColumns.js

@@ -0,0 +1,88 @@
+import { useModuleDictionary, useEnvironment } from "@m4l/core";
+import { useCallback, useMemo } from "react";
+import { M as MAP_GPSTOOLS_DICCTIONARY } from "../../../dictionary.js";
+import { useColumnDate, useColumnIcon, DATAGRID_SEMANTIC_WIDTHS } from "@m4l/components";
+import { G as GEOFENCES_TYPE_ICONS, a as GEOFENCES_TYPE_ID } from "../../../icons.js";
+import { G as GPS_TOOLS_COMPONENT_PATH_ID } from "../../../constants.js";
+function useColumns() {
+  const { getLabel } = useModuleDictionary();
+  const { host_static_assets, environment_assets } = useEnvironment();
+  const createdAtColumn = useColumnDate({ fieldValue: "createdAt", presentationType: "datetime" });
+  const updatedAtColumn = useColumnDate({ fieldValue: "updatedAt", presentationType: "datetime" });
+  const geometryTypeColumn = useColumnIcon(
+    {
+      getIconProps: useCallback((row) => {
+        if (!row) {
+          return {
+            iconUrl: "",
+            tooltip: "",
+            dataTestId: ""
+          };
+        }
+        const type = GEOFENCES_TYPE_ICONS[row.type.id] ? GEOFENCES_TYPE_ICONS[row.type.id] : GEOFENCES_TYPE_ICONS[GEOFENCES_TYPE_ID.NOT_RECOGNIZED];
+        const tooltip = type?.dictionaryId ? getLabel(type.dictionaryId) : void 0;
+        return {
+          iconUrl: `${host_static_assets}/${environment_assets}/frontend/components/${GPS_TOOLS_COMPONENT_PATH_ID}/assets/icons/${type.icon}`,
+          tooltip,
+          dataTestId: `geofence-type-${row.type.id}`
+        };
+      }, [getLabel, host_static_assets, environment_assets])
+    }
+  );
+  const columns = useMemo(
+    () => [
+      {
+        key: "id",
+        name: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_ID),
+        type: "number",
+        width: 40,
+        visible: false
+      },
+      {
+        key: "geometryTypeId",
+        name: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_GEOMETRY_TYPE),
+        type: "string",
+        width: 40,
+        visible: true,
+        align: "center",
+        ...geometryTypeColumn
+      },
+      {
+        key: "name",
+        name: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_NAME),
+        type: "string",
+        width: 220
+      },
+      {
+        key: "customerId",
+        name: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_CUSTOMER_ID),
+        type: "string",
+        width: 40,
+        visible: false
+      },
+      {
+        key: "createdAt",
+        name: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_CREATED_AT),
+        type: "date",
+        align: "center",
+        width: DATAGRID_SEMANTIC_WIDTHS.date,
+        visible: false,
+        ...createdAtColumn
+      },
+      {
+        key: "updatedAt",
+        name: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_UPDATED_AT),
+        type: "date",
+        align: "center",
+        visible: false,
+        width: DATAGRID_SEMANTIC_WIDTHS.date,
+        ...updatedAtColumn
+      }
+    ],
+    [createdAtColumn, geometryTypeColumn, getLabel, updatedAtColumn]
+  );
+  return { columns };
+}
+export {
+  useColumns as u
+};

package/components/maps/components/GpsMapTools/subcomponents/GeofencesTool/hooks/useDatagridFiltered.d.ts

@@ -0,0 +1,27 @@
+import { GeofenceListModel } from '../model';
+import { GeofenceId } from '../../../contexts/GpsMapToolsContext/types';
+export type UseDatagridFilteredProps = {
+    goAdd: () => void;
+    labelAdd: string;
+    enableAdd: boolean;
+    refreshCount: number;
+};
+/**
+ * useDatagrid" hook encargado de gestionar el DataGridn de las geocercas filtradas a traves del endpoint
+ */
+export declare function useDatagridFiltered(props: UseDatagridFilteredProps): {
+    pagerState: import('@m4l/graphics/src/hooks/usePaginate/types').PagerState;
+    onPageChange: (newPage: number) => void;
+    onRowsPerPageChange: (newRowsPerPage: number) => void;
+    rows: GeofenceListModel[];
+    defaultUserColumns: import('@m4l/components').IGridConfigExtended;
+    onChangeUserColumns: (newProps: import('@m4l/components').ChangeUserColumn) => void;
+    leftActions: import("react/jsx-runtime").JSX.Element;
+    rightActions: import("react/jsx-runtime").JSX.Element;
+    visibleCustomHeader: boolean;
+    customHeaderComponent: import("react/jsx-runtime").JSX.Element;
+    checkedGeofencesFiltered: Set<number>;
+    setCheckedGeofencesFiltered: (filteredCheckedGeofences: ReadonlySet<GeofenceId>) => void;
+    externalFilterSettings: import('@m4l/components/src/components/DataGrid/types').FilterSettings | undefined;
+    externalSortSettings: import('@m4l/components/src/components/DataGrid/types').SortSettings | undefined;
+};

package/components/maps/components/GpsMapTools/subcomponents/GeofencesTool/hooks/useDatagridFiltered.js

@@ -0,0 +1,79 @@
+import { useState, useEffect, useMemo, useCallback } from "react";
+import { useWindowToolsMF, useDataGridPersistence } from "@m4l/components";
+import { usePaginate } from "@m4l/graphics";
+import { u as useGpsMapToolsStore } from "../../../hooks/useGpsMapToolsStore/index.js";
+import { shallow } from "zustand/shallow";
+import { u as useFilterAndSort } from "./useFilterAndSort/useFilterAndSort.js";
+function useDatagridFiltered(props) {
+  const { goAdd, labelAdd, refreshCount } = props;
+  const { startProgress, stopProgress } = useWindowToolsMF();
+  const [checkedGeofences] = useGpsMapToolsStore(
+    (state) => [
+      state.geofenceState.checkedGeofences
+    ],
+    shallow
+  );
+  const { verifyAddOrChangedGeofenceFromList: verifyAddOrChangedGeofence, setCheckedGeofences } = useGpsMapToolsStore(
+    (state) => state.geofenceActions,
+    shallow
+  );
+  const [backendQueryParams, setBackendQueryParams] = useState({});
+  const { pagerState, rows, onPageChange, onRowsPerPageChange, Refresh: refresh } = usePaginate(
+    {
+      endPoint: "geofences",
+      fireOnChangeParms: false,
+      fireOnFirstLoad: false,
+      queryParams: backendQueryParams,
+      responseToCamelCase: true,
+      startProgress,
+      stopProgress
+    }
+  );
+  useEffect(() => {
+    if (refreshCount > 0) {
+      refresh();
+    }
+  }, [refreshCount, refresh]);
+  const checkedGeofencesFiltered = useMemo(() => {
+    return new Set(Array.from(checkedGeofences).filter((id) => rows.some((row) => row.id === id)));
+  }, [checkedGeofences, rows]);
+  const setCheckedGeofencesFiltered = useCallback((filteredCheckedGeofences) => {
+    const totalCheckedGeofences = new Set(checkedGeofences);
+    rows.forEach((row) => {
+      if (!filteredCheckedGeofences.has(row.id)) {
+        totalCheckedGeofences.delete(row.id);
+      } else {
+        if (!totalCheckedGeofences.has(row.id)) {
+          totalCheckedGeofences.add(row.id);
+        }
+      }
+    });
+    setCheckedGeofences(totalCheckedGeofences);
+  }, [checkedGeofences, rows, setCheckedGeofences]);
+  useEffect(() => {
+    rows.forEach((row) => {
+      verifyAddOrChangedGeofence(row.id, row);
+    });
+  }, [rows]);
+  const { onChangeUserColumns, defaultUserColumns } = useDataGridPersistence({ prefixCookie: `master_all` });
+  const { leftActions, rightActions, visibleCustomHeader, customHeaderComponent, externalFilterSettings, externalSortSettings } = useFilterAndSort({ labelAdd, goAdd, setBackendQueryParams, refresh });
+  return {
+    pagerState,
+    onPageChange,
+    onRowsPerPageChange,
+    rows,
+    defaultUserColumns,
+    onChangeUserColumns,
+    leftActions,
+    rightActions,
+    visibleCustomHeader,
+    customHeaderComponent,
+    checkedGeofencesFiltered,
+    setCheckedGeofencesFiltered,
+    externalFilterSettings,
+    externalSortSettings
+  };
+}
+export {
+  useDatagridFiltered as u
+};

package/components/maps/components/GpsMapTools/subcomponents/GeofencesTool/hooks/useDatagridSelected.d.ts

@@ -0,0 +1,16 @@
+import { GeofenceListColumns } from '../model';
+export type UseDatagridSelectedProps = {
+    labelAdd: string;
+    enableAdd: boolean;
+    goAdd: () => void;
+};
+export type UseGpsMapToolsStoreSelected = {
+    rows: GeofenceListColumns[];
+};
+/**
+ * useDatagrid" hook encargado de gestionar el DataGrid
+ */
+export declare function useDatagridSelected(props: UseDatagridSelectedProps): {
+    rows: GeofenceListColumns[];
+    rightActions: import("react/jsx-runtime").JSX.Element;
+};