@m4l/gclick 0.2.0 → 0.2.3-beta.0

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

@@ -1,86 +0,0 @@
-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

@@ -1,7 +0,0 @@
-/**
- * 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

@@ -1,85 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,111 +0,0 @@
-import { useModuleDictionary } from "@m4l/core";
-import { useMemo } from "react";
-import { M as MAP_GPSTOOLS_DICCTIONARY } from "../../../../../dictionary.js";
-import { ColumnDateFormatter } from "@m4l/components";
-function useColumns(_props) {
-  const { getLabel } = useModuleDictionary();
-  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
-      //      */
-      //     getIconUrl: (formatterRowProps: FormatterProps<GeofenceListModel>) => {
-      //       const { row } = formatterRowProps;
-      //       let iconUrl: string;
-      //       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
-      }
-    ],
-    [getLabel]
-  );
-  return { columns };
-}
-export {
-  useColumns as u
-};

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

@@ -1,22 +0,0 @@
-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

@@ -1,164 +0,0 @@
-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/index.d.ts

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

package/components/maps/components/GpsMapTools/subcomponents/TabsGpsTools/subcomponents/GeofencesList/index.js

@@ -1,73 +0,0 @@
-import { jsxs, jsx } from "react/jsx-runtime";
-import { DataGrid, ActionsContainer, Button } from "@m4l/components";
-import { F as Filter } from "./subcomponents/Filter/index.js";
-import { u as useMaster } from "./hooks/useMaster.js";
-import { g as gpsToolsClasses } from "../../../../classes/index.js";
-import { S as StackGeofenceListRoot } from "./styles.js";
-import { useModuleDictionary } from "@m4l/core";
-import { M as MAP_GPSTOOLS_DICCTIONARY } from "../../../../dictionary.js";
-function GeofencesList() {
-  const { getLabel } = useModuleDictionary();
-  const {
-    refresh,
-    setBackendQueryParams,
-    columns,
-    rows,
-    rowActionsGetter,
-    selectedRows,
-    onSelectedRowsChange,
-    pagerState,
-    onPageChange,
-    onRowsPerPageChange,
-    checkedRows,
-    onCheckedRowsChange,
-    setRows,
-    rowKeyGetter,
-    goToAdd
-  } = useMaster();
-  return /* @__PURE__ */ jsxs(
-    StackGeofenceListRoot,
-    {
-      direction: "column",
-      gap: "8px",
-      className: gpsToolsClasses.gpsToolsGeofencesList,
-      children: [
-        /* @__PURE__ */ jsx(Filter, { refresh, setBackendQueryParams }),
-        /* @__PURE__ */ jsx(
-          DataGrid,
-          {
-            id: "geofences",
-            columns,
-            rows,
-            onRowsChange: setRows,
-            checkedRows,
-            onCheckedRowsChange,
-            rowActionsGetter,
-            rowKeyGetter,
-            selectedRows,
-            onSelectedRowsChange,
-            withActions: true,
-            actionsProps: {
-              withPager: true,
-              withLocalFilters: true,
-              pagerOptions: {
-                records: rows.length,
-                totalRecords: pagerState.totalRecords,
-                rowsPerPageOptions: [1, 2, 3, 4, 5, 10, 25],
-                page: pagerState.page,
-                rowsPerPage: pagerState.rowsPerPage,
-                onPageChange,
-                onRowsPerPageChange
-              }
-            }
-          },
-          "list"
-        ),
-        /* @__PURE__ */ jsx(ActionsContainer, { children: /* @__PURE__ */ jsx(Button, { onClick: () => goToAdd(), label: getLabel(MAP_GPSTOOLS_DICCTIONARY.MODULE_NAME_GEOFENCE_ADD) }) })
-      ]
-    }
-  );
-}
-export {
-  GeofencesList as G
-};

package/components/maps/components/GpsMapTools/subcomponents/TabsGpsTools/subcomponents/GeofencesList/styles.d.ts

@@ -1 +0,0 @@
-export declare const StackGeofenceListRoot: import('@emotion/styled').StyledComponent<import('@m4l/components').StackProps & import('@mui/system').MUIStyledCommonProps<import('@mui/material/styles').Theme>, {}, {}>;

package/components/maps/components/GpsMapTools/subcomponents/TabsGpsTools/subcomponents/GeofencesList/styles.js

@@ -1,8 +0,0 @@
-import { styled } from "@mui/material/styles";
-import { Stack } from "@m4l/components";
-const StackGeofenceListRoot = styled(Stack)`
-  
-`;
-export {
-  StackGeofenceListRoot as S
-};

package/components/maps/components/GpsMapTools/subcomponents/TabsGpsTools/subcomponents/GeofencesList/subcomponents/Filter/index.d.ts

@@ -1,9 +0,0 @@
-interface FilterProps {
-    refresh: () => void;
-    setBackendQueryParams: React.Dispatch<React.SetStateAction<Record<string, unknown>>>;
-}
-/**
- * TODO: Documentar
- */
-export declare function Filter(props: FilterProps): import("react/jsx-runtime").JSX.Element;
-export {};

package/components/maps/components/GpsMapTools/subcomponents/TabsGpsTools/subcomponents/GeofencesList/subcomponents/Filter/index.js

@@ -1,49 +0,0 @@
-import { jsx } from "react/jsx-runtime";
-import { DynamicFilter } from "@m4l/components";
-import { useEnvironment } from "@m4l/core";
-import { M as MAP_GPSTOOLS_DICCTIONARY } from "../../../../../../dictionary.js";
-import { useState } from "react";
-import { c as COMPONENT_MAP_TOOLS_ID } from "../../../../../../constants.js";
-import { M as MAP_GPSTOOLS_ICONS } from "../../../../../../icons.js";
-function Filter(props) {
-  const { refresh, setBackendQueryParams } = props;
-  const { host_static_assets, environment_assets } = useEnvironment();
-  const [initialFilter] = useState(() => {
-    return [];
-  });
-  const onChangeFilter = (_initialFilters, rawFilters) => {
-    setBackendQueryParams({
-      f: rawFilters
-    });
-    refresh();
-  };
-  return /* @__PURE__ */ jsx(
-    DynamicFilter,
-    {
-      withAllField: true,
-      onChangeFilters: onChangeFilter,
-      fields: [
-        {
-          name: "id",
-          dictionaryId: MAP_GPSTOOLS_DICCTIONARY.LABEL_ID,
-          type: "number",
-          multiple: true,
-          presence: "optional",
-          urlIcon: `${host_static_assets}/${environment_assets}/components/${COMPONENT_MAP_TOOLS_ID}/assets/icons/${MAP_GPSTOOLS_ICONS.GEOFENCE_ID}`
-        },
-        {
-          name: "name",
-          dictionaryId: MAP_GPSTOOLS_DICCTIONARY.LABEL_NAME,
-          type: "string",
-          multiple: true,
-          presence: "optional",
-          urlIcon: `${host_static_assets}/${environment_assets}/components/${COMPONENT_MAP_TOOLS_ID}/assets/icons/${MAP_GPSTOOLS_ICONS.GEOFENCE_NAME}`
-        }
-      ],
-      initialAppliedFilters: initialFilter
-    }
-  );
-}
-export {
-  Filter as F
-};

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

@@ -1,7 +0,0 @@
-export declare const ENDPOINT_GEOFENCE_GET = "geofences";
-export declare const ENDPOINT_GEOFENCE_NEW_EDIT = "geofences";
-export declare enum GeofencesFeaturesLayers {
-    LAYER_GEOFENCES = "geofences",
-    LAYER_GEOFENCES_TRANSIT_FEATURES = "geofencesCrossingFeatures",
-    LAYER_GEOFENCES_INTERNAL_FEATURES = "geofencesInternalFeatures"
-}

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

@@ -1,13 +0,0 @@
-const ENDPOINT_GEOFENCE_GET = "geofences";
-const ENDPOINT_GEOFENCE_NEW_EDIT = "geofences";
-var GeofencesFeaturesLayers = /* @__PURE__ */ ((GeofencesFeaturesLayers2) => {
-  GeofencesFeaturesLayers2["LAYER_GEOFENCES"] = "geofences";
-  GeofencesFeaturesLayers2["LAYER_GEOFENCES_TRANSIT_FEATURES"] = "geofencesCrossingFeatures";
-  GeofencesFeaturesLayers2["LAYER_GEOFENCES_INTERNAL_FEATURES"] = "geofencesInternalFeatures";
-  return GeofencesFeaturesLayers2;
-})(GeofencesFeaturesLayers || {});
-export {
-  ENDPOINT_GEOFENCE_NEW_EDIT as E,
-  GeofencesFeaturesLayers as G,
-  ENDPOINT_GEOFENCE_GET as a
-};

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

@@ -1,7 +0,0 @@
-export interface TabAction {
-    id: string;
-    iconUrl: string;
-    component: React.ReactNode;
-    label: string;
-    className?: string;
-}