@m4l/gclick 0.0.2

package/components/maps/components/GpsMapTools/subcomponents/TabsGpsTools/subcomponents/GeofenceAddEdit/subcomponents/StyleData/subcomponents/StrokeData/index.js

@@ -0,0 +1,86 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { useModuleDictionary, useEnvironment } from "@m4l/core";
+import { PaperForm, PropertyValue, RHFColorPicker, RHFAutocomplete } from "@m4l/components";
+import { M as MAP_GPSTOOLS_DICCTIONARY } from "../../../../../../../../dictionary.js";
+import { M as MAP_GPSTOOLS_ICONS } from "../../../../../../../../icons.js";
+import { S as STYLE_OPACITIES, a as STYLE_WHEIGHTS, b as STYLE_PATTERNS } from "../../../../../../../../constants.js";
+function StrokeData() {
+  const { getLabel } = useModuleDictionary();
+  const { host_static_assets, environment_assets } = useEnvironment();
+  const urlIcon = `${host_static_assets}/${environment_assets}/frontend/components/map_gpstools/assets/icons/${MAP_GPSTOOLS_ICONS.STROKE}`;
+  return /* @__PURE__ */ jsxs(PaperForm, { urlIcon, title: getLabel(MAP_GPSTOOLS_DICCTIONARY.PAPER_STROKE), children: [
+    /* @__PURE__ */ jsx(
+      PropertyValue,
+      {
+        property: getLabel(`${MAP_GPSTOOLS_DICCTIONARY.LABEL_COLOR}`),
+        isForm: true,
+        propertyWidth: 150,
+        value: /* @__PURE__ */ jsx(RHFColorPicker, { name: "properties.strokeColor" })
+      },
+      "properties.strokeColor"
+    ),
+    /* @__PURE__ */ jsx(
+      PropertyValue,
+      {
+        property: getLabel(`${MAP_GPSTOOLS_DICCTIONARY.LABEL_OPACITY}`),
+        isForm: true,
+        propertyWidth: 150,
+        value: /* @__PURE__ */ jsx(
+          RHFAutocomplete,
+          {
+            type: "text",
+            name: "properties.strokeOpacity",
+            autoComplete: "off",
+            options: STYLE_OPACITIES,
+            getOptionLabel: (option) => option.label,
+            isOptionEqualToValue: (option, value) => option.value === value.value
+          }
+        )
+      },
+      "properties.strokeOpacity"
+    ),
+    /* @__PURE__ */ jsx(
+      PropertyValue,
+      {
+        property: getLabel(`${MAP_GPSTOOLS_DICCTIONARY.LABEL_WEIGHT}`),
+        isForm: true,
+        propertyWidth: 150,
+        value: /* @__PURE__ */ jsx(
+          RHFAutocomplete,
+          {
+            type: "text",
+            name: "properties.strokeWeight",
+            autoComplete: "off",
+            options: STYLE_WHEIGHTS,
+            getOptionLabel: (option) => option.label,
+            isOptionEqualToValue: (option, value) => option.value === value.value
+          }
+        )
+      },
+      "properties.strokeWeight"
+    ),
+    /* @__PURE__ */ jsx(
+      PropertyValue,
+      {
+        property: getLabel(`${MAP_GPSTOOLS_DICCTIONARY.LABEL_DASH_ARRAY}`),
+        isForm: true,
+        propertyWidth: 150,
+        value: /* @__PURE__ */ jsx(
+          RHFAutocomplete,
+          {
+            type: "text",
+            name: "properties.strokeDashArray",
+            autoComplete: "off",
+            options: STYLE_PATTERNS,
+            getOptionLabel: (option) => option.label,
+            isOptionEqualToValue: (option, value) => option.value === value.value
+          }
+        )
+      },
+      "properties.strokeDashArray"
+    )
+  ] });
+}
+export {
+  StrokeData as S
+};

package/components/maps/components/GpsMapTools/subcomponents/TabsGpsTools/subcomponents/GeofenceAddEdit/subcomponents/StyleData/types.d.ts

@@ -0,0 +1,10 @@
+import { Maybe } from '@m4l/core';
+import { StyleOpacity, StyleDashArray, StyleWheight } from '../../../../../../types';
+export interface FormStyleDataValues {
+    strokeColor?: string;
+    strokeOpacity?: Maybe<StyleOpacity>;
+    strokeWeight?: Maybe<StyleWheight>;
+    strokeDashArray?: Maybe<StyleDashArray>;
+    fillColor?: string;
+    fillOpacity?: Maybe<StyleOpacity>;
+}

package/components/maps/components/GpsMapTools/subcomponents/TabsGpsTools/subcomponents/GeofenceAddEdit/types.d.ts

@@ -0,0 +1,27 @@
+import { StyleOpacity, StyleDashArray, StyleWheight } from '../../../../types';
+import { GeofenceGetModel } from '../model';
+import { FormConfigDataValues } from './subcomponents/ConfigData/types';
+import { FormGeneralDataValues } from './subcomponents/GeneralData/types';
+import { FormStyleDataValues } from './subcomponents/StyleData/types';
+export type ResponseGet = {
+    data: GeofenceGetModel;
+};
+export type FormAddEditValues = FormGeneralDataValues & FormConfigDataValues & FormStyleDataValues & {
+    inEdition: boolean;
+    lat?: number | null;
+    lng?: number | null;
+    properties: {
+        radius?: number | null;
+        strokeColor: string;
+        strokeOpacity: StyleOpacity;
+        strokeWeight: StyleWheight;
+        strokeDashArray: StyleDashArray;
+        fillColor: string;
+        fillOpacity: StyleOpacity;
+    };
+};
+export interface GeofenceAddEditProps {
+    geofenceId?: number;
+    fullRefresh?: (id?: number) => void;
+    [key: string]: any;
+}

package/components/maps/components/GpsMapTools/subcomponents/TabsGpsTools/subcomponents/GeofencesList/hooks/useCheckedFeatures.d.ts

@@ -0,0 +1,9 @@
+import { GeofencesFeaturesLayers } from '../../constants';
+/**
+ * Hook encargado de cargar los features y pintarlos cuando los seleccionen
+ * @param layerId
+ * @param featuresType
+ * @param endpoint
+ * @returns
+ */
+export declare function useCheckedFeatures(layerId: GeofencesFeaturesLayers, featuresType: 'CrossingFeatures' | 'InternalFeatures', endpoint: string): [ReadonlySet<number>, (newFeatures: ReadonlySet<number>) => void];

package/components/maps/components/GpsMapTools/subcomponents/TabsGpsTools/subcomponents/GeofencesList/hooks/useCheckedFeatures.js

@@ -0,0 +1,86 @@
+import { useEffect } from "react";
+import { shallow } from "zustand/shallow";
+import { useNetwork } from "@m4l/core";
+import { u as useGpsMapToolsStore } from "../../../../../hooks/useGpsMapToolsStore/index.js";
+import { u as useMapStore } from "../../../../../../GpsMap/hooks/useMapStore/index.js";
+function useCheckedFeatures(layerId, featuresType, endpoint) {
+  const layersIds = useMapStore((state) => state.layersIds, shallow);
+  const [checkedFeatures, setCheckedFeatures, hashGeofences] = useGpsMapToolsStore((state) => {
+    return featuresType === "CrossingFeatures" ? [
+      state.geofenceState.checkedCrossingFeatures,
+      state.geofenceActions.setCheckedCrossingFeatures,
+      state.geofenceState.hashGeofences
+    ] : [
+      state.geofenceState.checkedInternalFeatures,
+      state.geofenceActions.setCheckedInternalFeatures,
+      state.geofenceState.hashGeofences
+    ];
+  }, shallow);
+  const { setFeatureData, removeFeature, getFeatureIds } = useMapStore(
+    (state) => state.mapActions,
+    shallow
+  );
+  const { networkOperation } = useNetwork();
+  useEffect(() => {
+    if (!layersIds.includes(layerId)) {
+      return;
+    }
+    const mapFeatureIds = getFeatureIds(layerId);
+    checkedFeatures.forEach((chkRow) => {
+      const geofence = hashGeofences[chkRow];
+      if (!geofence) {
+        return;
+      }
+      if (!mapFeatureIds.find((fId) => fId.toString().includes(`geo_${geofence.id}_fid`)) || !geofence[`hasRenderized${featuresType}`]) {
+        const currentGeofenceLoadedFeatures = geofence[`loaded${featuresType}`];
+        if (!currentGeofenceLoadedFeatures) {
+          networkOperation({
+            method: "GET",
+            endPoint: `geofences/${geofence.id}/${endpoint}`,
+            isRemote: false,
+            responseToCamelCase: true
+          }).then((response) => {
+            geofence[`loaded${featuresType}`] = response.data;
+            const newGeofenceLoadedFeatures = geofence[`loaded${featuresType}`];
+            if (newGeofenceLoadedFeatures && Array.isArray(geofence[`loaded${featuresType}`])) {
+              if (checkedFeatures.has(geofence.id)) {
+                newGeofenceLoadedFeatures.forEach((feature) => {
+                  setFeatureData(
+                    layerId,
+                    `geo_${geofence.id}_fid_${feature.id}`,
+                    feature.geometry,
+                    feature.properties
+                  );
+                });
+                geofence[`hasRenderized${featuresType}`] = true;
+              }
+            }
+          }).catch(() => {
+          });
+        } else {
+          currentGeofenceLoadedFeatures.forEach((feature) => {
+            setFeatureData(
+              layerId,
+              `geo_${geofence.id}_fid_${feature.id}`,
+              feature.geometry,
+              feature.properties
+            );
+          });
+          geofence[`hasRenderized${featuresType}`] = true;
+        }
+      }
+    });
+    mapFeatureIds.forEach((mapFeatureId) => {
+      const featureId = Number(mapFeatureId.toString().split("_")[1]);
+      if (!checkedFeatures.has(featureId)) {
+        removeFeature(layerId, mapFeatureId);
+      }
+    });
+    return () => {
+    };
+  }, [checkedFeatures, layersIds]);
+  return [checkedFeatures, setCheckedFeatures];
+}
+export {
+  useCheckedFeatures as u
+};

package/components/maps/components/GpsMapTools/subcomponents/TabsGpsTools/subcomponents/GeofencesList/hooks/useCheckedGeofences.d.ts

@@ -0,0 +1,7 @@
+/**
+ * TODO: Documentar
+ */
+export declare function useCheckedGeofences(): {
+    checkedGeofences: ReadonlySet<number>;
+    setCheckedGeofences: (newGeofences: ReadonlySet<import('../../../../../contexts/GpsMapToolsContext/types').GeofenceId>) => void;
+};

package/components/maps/components/GpsMapTools/subcomponents/TabsGpsTools/subcomponents/GeofencesList/hooks/useCheckedGeofences.js

@@ -0,0 +1,85 @@
+import { useEffect } from "react";
+import { shallow } from "zustand/shallow";
+import { useNetwork } from "@m4l/core";
+import { G as GeofencesFeaturesLayers } from "../../constants.js";
+import { u as useGpsMapToolsStore } from "../../../../../hooks/useGpsMapToolsStore/index.js";
+import { u as useMapStore } from "../../../../../../GpsMap/hooks/useMapStore/index.js";
+function useCheckedGeofences() {
+  const layersIds = useMapStore((state) => state.layersIds, shallow);
+  const [checkedGeofences, hashGeofences] = useGpsMapToolsStore(
+    (state) => [state.geofenceState.checkedGeofences, state.geofenceState.hashGeofences],
+    shallow
+  );
+  const { setCheckedGeofences, updatePartialGeofence } = useGpsMapToolsStore(
+    (state) => state.geofenceActions,
+    shallow
+  );
+  const { setFeatureData, removeFeature, getFeatureIds } = useMapStore(
+    (state) => state.mapActions,
+    shallow
+  );
+  const { networkOperation } = useNetwork();
+  useEffect(() => {
+    if (!layersIds.includes(GeofencesFeaturesLayers.LAYER_GEOFENCES)) {
+      return;
+    }
+    const mapFeatureIds = getFeatureIds(GeofencesFeaturesLayers.LAYER_GEOFENCES);
+    checkedGeofences.forEach((chkRow) => {
+      const geofence = hashGeofences[chkRow];
+      if (!geofence) {
+        return;
+      }
+      if (!mapFeatureIds.includes(chkRow) || !geofence.hasRenderizedGeofence) {
+        if (!geofence.geometry) {
+          networkOperation({
+            method: "GET",
+            endPoint: `geofences/${geofence.id}`,
+            isRemote: false,
+            responseToCamelCase: true
+          }).then((response) => {
+            const geoLoaded = {
+              geometry: response.data.geometry,
+              name: response.data.name,
+              properties: response.data.properties,
+              countCrossingFeatures: response.data.countCrossingFeatures,
+              hasRenderizedGeofence: false
+            };
+            if (geoLoaded.geometry) {
+              if (checkedGeofences.has(geofence.id)) {
+                setFeatureData("geofences", chkRow, geoLoaded.geometry, geoLoaded.properties, {
+                  label: geoLoaded.name,
+                  labelColor: geoLoaded.properties?.color
+                });
+                geoLoaded.hasRenderizedGeofence = true;
+              }
+            }
+            updatePartialGeofence(geofence.id, geoLoaded);
+          });
+        } else {
+          setFeatureData(
+            GeofencesFeaturesLayers.LAYER_GEOFENCES,
+            chkRow,
+            geofence.geometry,
+            geofence.properties,
+            { label: geofence.name }
+          );
+          updatePartialGeofence(geofence.id, { hasRenderizedGeofence: true });
+        }
+      }
+    });
+    mapFeatureIds.forEach((mapFeatureId) => {
+      if (!checkedGeofences.has(Number(mapFeatureId))) {
+        removeFeature(GeofencesFeaturesLayers.LAYER_GEOFENCES, mapFeatureId);
+      }
+    });
+    return () => {
+    };
+  }, [checkedGeofences, layersIds]);
+  return {
+    checkedGeofences,
+    setCheckedGeofences
+  };
+}
+export {
+  useCheckedGeofences as u
+};

package/components/maps/components/GpsMapTools/subcomponents/TabsGpsTools/subcomponents/GeofencesList/hooks/useColumns.d.ts

@@ -0,0 +1,12 @@
+import { GeofenceListModel } from '../../model';
+import { Column } from 'react-data-grid';
+type UseColumnsProps<Row> = {
+    rowKeyGetter: (row: Row) => number;
+};
+/**
+ * TODO: Documentar
+ */
+export declare function useColumns(_props: UseColumnsProps<GeofenceListModel>): {
+    columns: Column<GeofenceListModel, unknown>[];
+};
+export {};

package/components/maps/components/GpsMapTools/subcomponents/TabsGpsTools/subcomponents/GeofencesList/hooks/useColumns.js

@@ -0,0 +1,114 @@
+import { useModuleDictionary, useEnvironment } from "@m4l/core";
+import { useMemo } from "react";
+import { M as MAP_GPSTOOLS_DICCTIONARY } from "../../../../../dictionary.js";
+import { ColumnIconFormatter, ColumnDateFormatter } from "@m4l/components";
+import { M as MAP_GPSTOOLS_ICONS } from "../../../../../icons.js";
+function useColumns(_props) {
+  const { getLabel } = useModuleDictionary();
+  const { host_static_assets, environment_assets } = useEnvironment();
+  const columns = useMemo(
+    () => [
+      {
+        key: "id",
+        name: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_ID),
+        type: "number",
+        width: 40,
+        visible: false
+      },
+      {
+        key: "geometry",
+        name: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_GEOMETRY_TYPE),
+        headerRenderer: () => "",
+        //Para que no salga el nombre de la columna, pero si en el configurador
+        type: "string",
+        formatter: ColumnIconFormatter({
+          /**
+           * TODO: Documentar
+           */
+          getIconProps: (row) => {
+            let iconUrl;
+            if (row.type.id === "gt_polygon") {
+              iconUrl = MAP_GPSTOOLS_ICONS.GEOFENCE_TYPE_POLYGON;
+            } else if (row.type.id === "gt_circle") {
+              iconUrl = MAP_GPSTOOLS_ICONS.GEOFENCE_TYPE_CIRCLE;
+            } else {
+              iconUrl = MAP_GPSTOOLS_ICONS.GEOFENCE_TYPE_RECTANGLE;
+            }
+            return {
+              iconUrl: `${host_static_assets}/${environment_assets}/frontend/components/map_gpstools/assets/icons/${iconUrl}`
+            };
+          }
+        }),
+        width: 30,
+        minWidth: 25
+      },
+      {
+        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: 'checkedCrossingFeatures',
+      //     name: getLabel(DICCTIONARY.LABEL_VIEW_TRANSIT_FEATURES),
+      //     width: 32,
+      //     type: 'boolean',
+      //     // frozen: true,
+      //     // isDraggable: false,
+      //     formatter: ColumnSetCheckFormatter({
+      //         field: 'CrossingFeatures',
+      //         rowKeyGetter,
+      //         useHook,
+      //     }),
+      //     cellClass: 'rdg-cell-align-center',
+      // },
+      // {
+      //     key: 'checkedInternalFeatures',
+      //     name: getLabel(DICCTIONARY.LABEL_VIEW_INTERNAL_FEATURES),
+      //     width: 32,
+      //     type: 'boolean',
+      //     // isDraggable: false,
+      //     // frozen: true,
+      //     formatter: ColumnSetCheckFormatter({
+      //         field: 'InternalFeatures',
+      //         rowKeyGetter,
+      //         useHook,
+      //     }),
+      //     cellClass: 'rdg-cell-align-center',
+      // },
+      {
+        key: "created_at",
+        name: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_CREATED_AT),
+        type: "date",
+        formatter: ColumnDateFormatter({
+          presentationType: "datetime",
+          fieldValue: "row.created_at"
+        }),
+        visible: false
+      },
+      {
+        key: "updated_at",
+        name: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_UPDATED_AT),
+        type: "date",
+        formatter: ColumnDateFormatter({
+          presentationType: "datetime",
+          fieldValue: "row.updated_at"
+        }),
+        visible: false
+      }
+    ],
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [getLabel]
+  );
+  return { columns };
+}
+export {
+  useColumns as u
+};

package/components/maps/components/GpsMapTools/subcomponents/TabsGpsTools/subcomponents/GeofencesList/hooks/useMaster.d.ts

@@ -0,0 +1,22 @@
+import { GeofenceId } from '../../../../../contexts/GpsMapToolsContext/types';
+import { GeofenceListModel } from '../../model';
+/**
+ * TODO: Documentar
+ */
+export declare function useMaster(): {
+    rowKeyGetter: (row: GeofenceListModel) => number;
+    columns: import('react-data-grid').Column<GeofenceListModel, unknown>[];
+    refresh: () => void;
+    setBackendQueryParams: import('react').Dispatch<import('react').SetStateAction<Record<string, unknown>>>;
+    pagerState: import('@m4l/core').PagerState;
+    rows: GeofenceListModel[];
+    onPageChange: (newPage: number) => void;
+    onRowsPerPageChange: (newRowsPerPage: number) => void;
+    rowActionsGetter: (row: GeofenceListModel) => import('@m4l/components').MenuAction[] | [];
+    selectedRows: ReadonlySet<number>;
+    onSelectedRowsChange: (newRowsSelectSet: ReadonlySet<GeofenceId>) => void;
+    checkedRows: ReadonlySet<number>;
+    onCheckedRowsChange: (newGeofences: ReadonlySet<GeofenceId>) => void;
+    setRows: import('react').Dispatch<import('react').SetStateAction<GeofenceListModel[]>>;
+    goToAdd: () => void;
+};

package/components/maps/components/GpsMapTools/subcomponents/TabsGpsTools/subcomponents/GeofencesList/hooks/useMaster.js

@@ -0,0 +1,164 @@
+import { jsx } from "react/jsx-runtime";
+import { useCallback, useState, useEffect } from "react";
+import { useModuleDictionary, useEnvironment, usePaginate } from "@m4l/core";
+import { u as useColumns } from "./useColumns.js";
+import { u as useRowActionsGetter } from "./useRowActionsGetter.js";
+import { u as useCheckedGeofences } from "./useCheckedGeofences.js";
+import { u as useCheckedFeatures } from "./useCheckedFeatures.js";
+import { G as GeofencesFeaturesLayers } from "../../constants.js";
+import { shallow } from "zustand/shallow";
+import { usePopupsStore } from "@m4l/components";
+import { G as GeofenceAddEdit } from "../../GeofenceAddEdit/index.js";
+import { M as MAP_GPSTOOLS_DICCTIONARY } from "../../../../../dictionary.js";
+import { M as MAP_GPSTOOLS_ICONS } from "../../../../../icons.js";
+import { u as useGpsMapToolsStore } from "../../../../../hooks/useGpsMapToolsStore/index.js";
+function useMaster() {
+  const { getLabel } = useModuleDictionary();
+  const { host_static_assets, environment_assets } = useEnvironment();
+  const { addPopup } = usePopupsStore((state) => state.popupsActions, shallow);
+  const { hide } = usePopupsStore((state) => state.popupActions, shallow);
+  const goToAdd = () => {
+    hide("gpsTools");
+    addPopup({
+      popupId: "geofencesAddEdit",
+      winType: "component",
+      title: getLabel(MAP_GPSTOOLS_DICCTIONARY.MODULE_NAME_GEOFENCE_ADD),
+      component: () => /* @__PURE__ */ jsx(GeofenceAddEdit, {}),
+      //   onMouseDown,
+      defaultPosition: {
+        vertical: { top: 50, bottom: 50 },
+        horizontal: { right: 50, width: 380 }
+        // left:490,top:50,width:360, height:420},
+        // bounds:{top:5, left:5, right:-5, bottom:-5}
+      },
+      iconUrl: `${host_static_assets}/${environment_assets}/frontend/components/map_gpstools/assets/icons/${MAP_GPSTOOLS_ICONS.GEOFENCE_ADD}`
+    });
+  };
+  const [checkedGeofences, hashGeofences, initialRows] = useGpsMapToolsStore(
+    (state) => [
+      state.geofenceState.checkedGeofences,
+      state.geofenceState.hashGeofences,
+      state.geofenceState.rows
+    ],
+    shallow
+  );
+  const { setCheckedGeofences, addGeofence, updatePartialGeofence, updateRows } = useGpsMapToolsStore(
+    (state) => state.geofenceActions,
+    shallow
+  );
+  useCheckedGeofences();
+  const [checkedCrossingFeatures, setCheckedCrossingFeatures] = useCheckedFeatures(
+    GeofencesFeaturesLayers.LAYER_GEOFENCES_TRANSIT_FEATURES,
+    "CrossingFeatures",
+    "crossing_features"
+  );
+  const [checkedInternalFeatures, setCheckedInternalFeatures] = useCheckedFeatures(
+    GeofencesFeaturesLayers.LAYER_GEOFENCES_INTERNAL_FEATURES,
+    "InternalFeatures",
+    "internal_features"
+  );
+  const rowKeyGetter = useCallback((row) => row.id, []);
+  const [selectedRows, setSelectedRows] = useState(/* @__PURE__ */ new Set());
+  const [backendQueryParams, setBackendQueryParams] = useState({});
+  const { columns } = useColumns();
+  const { pagerState, rows, onPageChange, onRowsPerPageChange, Refresh, setRows } = usePaginate({
+    endPoint: "geofences",
+    fireOnChangeParms: false,
+    fireOnFirstLoad: false,
+    queryParams: backendQueryParams,
+    isRemote: false,
+    responseToCamelCase: true,
+    initialRows
+  });
+  const onSelectedRowsChange = (newRowsSelectSet) => {
+    setSelectedRows(newRowsSelectSet);
+  };
+  const fullRefresh = useCallback((_id) => {
+    Refresh();
+  }, []);
+  useEffect(() => {
+    const newCheckedGeofences = new Set(checkedGeofences);
+    const newCheckedCrossingFeatures = new Set(checkedCrossingFeatures);
+    const newCheckedInternalFeatures = new Set(checkedInternalFeatures);
+    let updatedCheckedGeofences = false;
+    let updatedCheckedCrossingFeatures = false;
+    let updatedCheckedInternalFeatures = false;
+    newCheckedGeofences.forEach((chkRow) => {
+      if (rows.findIndex((row) => row.id === chkRow) === -1) {
+        newCheckedGeofences.delete(chkRow);
+      }
+    });
+    newCheckedCrossingFeatures.forEach((chkTF) => {
+      if (rows.findIndex((row) => row.id === chkTF) === -1) {
+        newCheckedCrossingFeatures.delete(chkTF);
+      }
+    });
+    newCheckedInternalFeatures.forEach((chkIF) => {
+      if (rows.findIndex((row) => row.id === chkIF) === -1) {
+        newCheckedInternalFeatures.delete(chkIF);
+      }
+    });
+    rows.forEach((row) => {
+      let hasGeo = hashGeofences[row.id];
+      if (!hasGeo) {
+        hasGeo = {
+          ...row,
+          hasRenderizedGeofence: false,
+          loadedCrossingFeatures: null,
+          loadedInternalFeatures: null,
+          hasRenderizedCrossingFeatures: false,
+          hasRenderizedInternalFeatures: false,
+          createdAt: row.createdAt
+        };
+        addGeofence(row.id, hasGeo);
+        return;
+      }
+      if (row.updatedAt && row.updatedAt !== hasGeo.updatedAt) {
+        updatePartialGeofence(row.id, {
+          updatedAt: row.updatedAt,
+          geometry: null,
+          hasRenderizedGeofence: false,
+          hasRenderizedCrossingFeatures: false,
+          hasRenderizedInternalFeatures: false,
+          loadedCrossingFeatures: null,
+          loadedInternalFeatures: null
+        });
+        updatedCheckedGeofences = true;
+        updatedCheckedCrossingFeatures = true;
+        updatedCheckedInternalFeatures = true;
+      }
+    });
+    if (newCheckedGeofences.size !== checkedGeofences.size || updatedCheckedGeofences) {
+      setCheckedGeofences(newCheckedGeofences);
+    }
+    if (newCheckedCrossingFeatures.size !== checkedCrossingFeatures.size || updatedCheckedCrossingFeatures) {
+      setCheckedCrossingFeatures(newCheckedCrossingFeatures);
+    }
+    if (newCheckedInternalFeatures.size !== checkedInternalFeatures.size || updatedCheckedInternalFeatures) {
+      setCheckedInternalFeatures(newCheckedInternalFeatures);
+    }
+    onSelectedRowsChange(selectedRows);
+    updateRows(rows);
+  }, [rows]);
+  const { rowActionsGetter } = useRowActionsGetter({ fullRefresh });
+  return {
+    rowKeyGetter,
+    columns,
+    refresh: Refresh,
+    setBackendQueryParams,
+    pagerState,
+    rows,
+    onPageChange,
+    onRowsPerPageChange,
+    rowActionsGetter,
+    selectedRows,
+    onSelectedRowsChange,
+    checkedRows: checkedGeofences,
+    onCheckedRowsChange: setCheckedGeofences,
+    setRows,
+    goToAdd
+  };
+}
+export {
+  useMaster as u
+};

package/components/maps/components/GpsMapTools/subcomponents/TabsGpsTools/subcomponents/GeofencesList/hooks/useRowActionsGetter.d.ts

@@ -0,0 +1,12 @@
+import { MenuAction } from '@m4l/components';
+import { GeofenceListModel } from '../../model';
+interface UseRowActionsProps {
+    fullRefresh: (id?: number) => void;
+}
+/**
+ * TODO: Documentar
+ */
+export declare function useRowActionsGetter(props: UseRowActionsProps): {
+    rowActionsGetter: (row: GeofenceListModel) => MenuAction[] | [];
+};
+export {};