@m4l/components 4.0.0 → 4.1.1

package/components/maps/components/MapGpsTools/subcomponents/TabsGpsTools/subcomponents/GeofenceAddEdit/constants-D0Z5Tw8t.js

@@ -1,40 +0,0 @@
-const STROKE_COLOR_DEFAULT = "#aaccaa";
-const STROKE_OPACITY_DEFAULT = { value: 1, label: "100%" };
-const STROKE_WHEIGTH_DEFAULT = { value: 1, label: "1 px" };
-const STROKE_DASH_ARRAY_DEFAULT = { value: "", label: "-----" };
-const FILL_COLOR_DEFAULT = "#aa3000";
-const FILL_OPACITY_DEFAULT = { value: 0.2, label: "20%" };
-const initialValues = {
-  /** General Data */
-  name: "",
-  geofenceType: null,
-  /** Config Data */
-  alias: null,
-  customerId: null,
-  timeMinInSeconds: 5,
-  timeMinOutSeconds: 5,
-  /** de Apoyo */
-  inEdition: false,
-  geometry: null,
-  lat: null,
-  lng: null,
-  properties: {
-    radius: null,
-    /** Style Data */
-    strokeColor: STROKE_COLOR_DEFAULT,
-    strokeOpacity: STROKE_OPACITY_DEFAULT,
-    strokeWeight: STROKE_WHEIGTH_DEFAULT,
-    strokeDashArray: STROKE_DASH_ARRAY_DEFAULT,
-    fillColor: FILL_COLOR_DEFAULT,
-    fillOpacity: FILL_OPACITY_DEFAULT
-  }
-};
-export {
-  FILL_COLOR_DEFAULT as F,
-  STROKE_COLOR_DEFAULT as S,
-  STROKE_OPACITY_DEFAULT as a,
-  STROKE_WHEIGTH_DEFAULT as b,
-  STROKE_DASH_ARRAY_DEFAULT as c,
-  FILL_OPACITY_DEFAULT as d,
-  initialValues as i
-};

package/components/maps/components/MapGpsTools/subcomponents/TabsGpsTools/subcomponents/GeofenceAddEdit/helpers-B76zvEoG.js

@@ -1,77 +0,0 @@
-import { i as initialValues, S as STROKE_COLOR_DEFAULT, a as STROKE_OPACITY_DEFAULT, b as STROKE_WHEIGTH_DEFAULT, c as STROKE_DASH_ARRAY_DEFAULT, F as FILL_COLOR_DEFAULT, d as FILL_OPACITY_DEFAULT } from "./constants-D0Z5Tw8t.js";
-import * as L from "leaflet";
-const formatDataEnpoint = (response) => {
-  try {
-    const { data } = response;
-    const obRet = {
-      ...initialValues,
-      inEdition: false,
-      name: data.name,
-      geometry: data.geometry,
-      geofenceType: { id: data.type.id, name: data.type.name, url: "" },
-      properties: {
-        strokeColor: data.properties.strokeColor || STROKE_COLOR_DEFAULT,
-        strokeOpacity: STROKE_OPACITY_DEFAULT,
-        //getFormStrokeOpacityFromData(data.properties.strokeOpacity),
-        strokeWeight: STROKE_WHEIGTH_DEFAULT,
-        //,getFormStrokeWeightFromData(data.properties.strokeWeight) ,
-        strokeDashArray: STROKE_DASH_ARRAY_DEFAULT,
-        // getFormstrokeDashArrayFromData(data.properties.strokeDashArray) ,
-        fillColor: data.properties.fillColor || FILL_COLOR_DEFAULT,
-        fillOpacity: FILL_OPACITY_DEFAULT
-        //data.properties.fillOpacity || FILL_OPACITY_DEFAULT,
-      }
-    };
-    if (obRet.geofenceType?.id === "gt_circle") {
-      if (data.properties.radius) {
-        obRet.properties.radius = data.properties.radius;
-      }
-      if (data.geometry && data.geometry.type === "Point") {
-        obRet.lng = data.geometry.coordinates[0];
-        obRet.lat = data.geometry.coordinates[1];
-      }
-    }
-    return obRet;
-  } catch (error) {
-    return { ...initialValues };
-  }
-};
-const getLayerFromGeometry = (geometry, geofenceTypeId, radius, options) => {
-  if (geometry) {
-    if (geofenceTypeId === "gt_circle" && geometry.type === "Point") {
-      return L.circle([geometry.coordinates[1], geometry.coordinates[0]], {
-        ...options,
-        radius: radius || 0
-      });
-    } else if (geofenceTypeId === "gt_polygon" && geometry.type === "Polygon") {
-      const coordinates = geometry.coordinates.map(
-        (ring) => ring.map((position) => [position[1], position[0]])
-      );
-      return L.polygon(coordinates, options);
-    } else if (geofenceTypeId === "gt_rectangle" && geometry.type === "Polygon") {
-      const latLngs = geometry.coordinates[0].map(
-        (coord) => [coord[1], coord[0]]
-      );
-      const lats = latLngs.map((coord) => {
-        if (Array.isArray(coord)) {
-          return coord[0];
-        }
-        return 0;
-      });
-      const lngs = latLngs.map((coord) => {
-        if (Array.isArray(coord)) {
-          return coord[1];
-        }
-        return 0;
-      });
-      const southWest = [Math.min(...lats), Math.min(...lngs)];
-      const northEast = [Math.max(...lats), Math.max(...lngs)];
-      return L.rectangle([southWest, northEast], options);
-    }
-  }
-  return null;
-};
-export {
-  formatDataEnpoint as f,
-  getLayerFromGeometry as g
-};

package/components/maps/components/MapGpsTools/subcomponents/TabsGpsTools/subcomponents/GeofenceAddEdit/hooks/useDrawing-D34tJeeW.js

@@ -1,214 +0,0 @@
-import { useState, useRef, useEffect, useCallback } from "react";
-import { useFormContext, useWatch } from "react-hook-form";
-import { useModuleDictionary } from "@m4l/core";
-import { useMap } from "react-leaflet";
-import { g as getLayerFromGeometry } from "../helpers-B76zvEoG.js";
-import { u as useFormReadyForUpdate } from "../../../../../../../../../hooks/useFormReadyForUpdate/index-B3HygFCM.js";
-import { M as MAP_GPSTOOLS_DICCTIONARY } from "../../../../../dictionary-BZWDA1RN.js";
-function useDrawing() {
-  const { getLabel } = useModuleDictionary();
-  const readyToUpdate = useFormReadyForUpdate();
-  const map = useMap();
-  const { control, setValue } = useFormContext();
-  const fieldsWatch = useWatch({
-    control,
-    name: [
-      "geofenceType",
-      "inEdition",
-      "properties.strokeColor",
-      "properties.strokeOpacity",
-      "properties.strokeWeight",
-      "properties.strokeDashArray",
-      "properties.fillColor",
-      "properties.fillOpacity",
-      "geometry",
-      "properties.radius"
-    ]
-  });
-  const geofenceTypeId = fieldsWatch[0]?.id;
-  const inEdition = fieldsWatch[1];
-  const strokeColor = fieldsWatch[2];
-  const strokeOpacity = fieldsWatch[3].value;
-  const strokeWeight = fieldsWatch[4].value;
-  const strokeDashArray = fieldsWatch[5].value;
-  const fillColor = fieldsWatch[6];
-  const fillOpacity = fieldsWatch[7].value;
-  const geometry = fieldsWatch[8];
-  const radius = fieldsWatch[9];
-  const [drawing, setDrawing] = useState(false);
-  const currentLayer = useRef(null);
-  const [geometrTypeIdCached, setgeofenceTypeIdCached] = useState(geofenceTypeId);
-  useEffect(() => {
-    if (geometry) {
-      currentLayer.current = getLayerFromGeometry(geometry, geofenceTypeId, radius, {
-        color: strokeColor,
-        opacity: strokeOpacity,
-        weight: strokeWeight,
-        dashArray: strokeDashArray,
-        fillColor,
-        fillOpacity
-      });
-      if (currentLayer.current) {
-        map.addLayer(currentLayer.current);
-        map.fitBounds(currentLayer.current.getBounds());
-      }
-    }
-    return () => {
-      if (currentLayer.current) {
-        currentLayer.current.remove();
-      }
-    };
-  }, [map]);
-  useEffect(() => {
-    if (currentLayer.current) {
-      currentLayer.current.setStyle({
-        color: strokeColor,
-        opacity: strokeOpacity,
-        weight: strokeWeight,
-        dashArray: strokeDashArray,
-        fillColor,
-        fillOpacity
-      });
-    }
-  }, [strokeColor, strokeOpacity, strokeWeight, strokeDashArray, fillColor, fillOpacity]);
-  useEffect(() => {
-    map.pm.setLang("en", {
-      tooltips: {
-        placeMarker: void 0,
-        firstVertex: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_FIRST_VERTEX),
-        continueLine: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_CONTINUE_LINE),
-        finishLine: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_FINISH_LINE),
-        finishPoly: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_FINISH_POLY),
-        finishRect: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_FINISH_RECT),
-        startCircle: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_START_CIRCLE),
-        finishCircle: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_FINISH_CIRCLE),
-        placeCircleMarker: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_PLACE_CIRCLE_MARKER)
-      }
-    });
-  }, [map, getLabel]);
-  useEffect(() => {
-    if (map) {
-      let shape = "Circle";
-      if (geometrTypeIdCached === "gt_polygon") {
-        shape = "Polygon";
-      } else if (geometrTypeIdCached === "gt_rectangle") {
-        shape = "Rectangle";
-      }
-      if (drawing) {
-        if (!currentLayer.current) {
-          setValue("inEdition", true);
-          if (shape === "Circle") {
-            map.on("pm:drawstart", ({ workingLayer }) => {
-              workingLayer.on("pm:centerplaced", (e) => {
-                const layer = e.workingLayer;
-                layer.setStyle({
-                  color: strokeColor,
-                  opacity: strokeOpacity,
-                  weight: strokeWeight,
-                  dashArray: strokeDashArray,
-                  fillColor,
-                  fillOpacity
-                });
-                setValue("lat", Number(layer.getLatLng().lat.toFixed(8)));
-                setValue("lng", Number(layer.getLatLng().lng.toFixed(8)));
-                layer.on("pm:change", (_e) => {
-                  setValue("properties.radius", Number(layer.getRadius().toFixed(1)));
-                });
-              });
-            });
-            setValue("properties.subType", shape);
-          } else if (shape === "Polygon") {
-            map.on("pm:drawstart", ({ workingLayer }) => {
-              workingLayer.on("pm:vertexadded", (e) => {
-                const layer = e.workingLayer;
-                layer.setStyle({
-                  color: strokeColor,
-                  opacity: strokeOpacity,
-                  weight: strokeWeight,
-                  dashArray: strokeDashArray,
-                  fillColor,
-                  fillOpacity
-                });
-              });
-            });
-          }
-          map.pm.enableDraw(shape);
-          map.pm.setPathOptions({
-            color: strokeColor,
-            opacity: strokeOpacity,
-            weight: strokeWeight,
-            dashArray: strokeDashArray,
-            fillColor,
-            fillOpacity
-          });
-          map.on("pm:create", (e) => {
-            currentLayer.current = e.layer;
-            setValue("geometry", currentLayer.current.toGeoJSON()?.geometry, {
-              shouldTouch: false,
-              shouldValidate: true
-            });
-            setValue("inEdition", false);
-            setDrawing(false);
-          });
-        } else {
-          currentLayer.current.pm.enable();
-          setValue("inEdition", true);
-          currentLayer.current.on("pm:disable", (e) => {
-            currentLayer.current = e.layer;
-            setValue("geometry", currentLayer.current.toGeoJSON()?.geometry, {
-              shouldTouch: false,
-              shouldValidate: true
-            });
-            setValue("inEdition", false);
-            setDrawing(false);
-          });
-          if (shape === "Circle") {
-            currentLayer.current.on("pm:change", (e) => {
-              currentLayer.current = e.layer;
-              setValue("lat", Number(currentLayer.current.getLatLng().lat.toFixed(8)));
-              setValue("lng", Number(currentLayer.current.getLatLng().lng.toFixed(8)));
-              setValue("properties.radius", currentLayer.current.getRadius());
-              setValue("properties.radius", Number(currentLayer.current.getRadius().toFixed(1)));
-            });
-          }
-        }
-      } else {
-        map.pm.disableDraw("Polygon");
-        map.off("pm:create");
-        map.off("pm:edit");
-        map.off("pm:drawstart");
-      }
-    }
-  }, [map, drawing]);
-  const handleDraw = useCallback(() => {
-    setDrawing(true);
-  }, []);
-  const handleFinish = useCallback(() => {
-    if (currentLayer.current) {
-      currentLayer.current.pm.disable();
-      currentLayer.current.setStyle({ color: "#ff0000", fillColor: "#ff0000" });
-    }
-  }, []);
-  useEffect(() => {
-    if (!readyToUpdate) return;
-    if (geofenceTypeId) {
-      if (geofenceTypeId !== geometrTypeIdCached) {
-        setgeofenceTypeIdCached(geofenceTypeId);
-        if (geometrTypeIdCached !== "gt_circle") {
-          setValue("properties.radius", null);
-          setValue("lat", null);
-          setValue("lng", null);
-        }
-        setValue("geometry", null);
-        if (currentLayer.current) {
-          currentLayer.current.remove();
-          currentLayer.current = null;
-        }
-      }
-    }
-  }, [geofenceTypeId]);
-  return { inEdition, handleDraw, handleFinish, geometrTypeIdCached };
-}
-export {
-  useDrawing as u
-};

package/components/maps/components/MapGpsTools/subcomponents/TabsGpsTools/subcomponents/GeofenceAddEdit/hooks/useSubmit-CXwCD5g0.js

@@ -1,63 +0,0 @@
-import { useHostTools, useNetwork } from "@m4l/core";
-import { E as ENDPOINT_GEOFENCE_NEW_EDIT } from "../../constants-BruLA0T6.js";
-import { shallow } from "zustand/shallow";
-import { u as usePopupsStore } from "../../../../../../../../popups/components/PopupsProvider/hooks/usePopupsStore/index-DBMhBXk-.js";
-import { u as useGpsToolsStore } from "../../../../../hooks/useGpsToolsStore/index-BCw7XNS9.js";
-const getSummitData = (values, geofenceId) => {
-  const newEditObj = {
-    name: values.name,
-    typeId: values.geofenceType.id,
-    geometry: values.geometry,
-    properties: {
-      subType: values.properties.subType,
-      strokeColor: values.properties.fillColor,
-      strokeOpacity: values.properties.strokeOpacity.value,
-      strokeWeight: values.properties.strokeWeight.value,
-      strokeDashArray: values.properties.strokeDashArray.value,
-      fillColor: values.properties.fillColor,
-      fillOpacity: values.properties.fillOpacity.value
-    },
-    timeMinInSeconds: values.timeMinInSeconds,
-    timeMinOutSeconds: values.timeMinOutSeconds,
-    alias: values.alias,
-    customerId: values.customerId,
-    ...geofenceId ? { geofenceId } : {}
-  };
-  if (values.geofenceType.id === "gt_circle") {
-    newEditObj.properties.radius = values.properties.radius;
-  }
-  return newEditObj;
-};
-function useSubmit(props) {
-  const { objectId, fullRefresh } = props;
-  const { toast } = useHostTools();
-  const { networkOperation } = useNetwork();
-  const { closePopup, showPopup } = usePopupsStore((state) => state.popupsActions);
-  const { addCheckedGeofence } = useGpsToolsStore((state) => state.geofenceActions, shallow);
-  const onSubmit = async (data) => {
-    await networkOperation({
-      method: objectId ? "PUT" : "POST",
-      endPoint: `${ENDPOINT_GEOFENCE_NEW_EDIT}${objectId ? `/${objectId}` : ""}`,
-      data: getSummitData(data, objectId),
-      toastError: true,
-      toastSuccess: false,
-      bodyToSnakeCase: true,
-      isRemote: false
-    }).then((response) => {
-      toast({ title: response.message }, { type: "success" });
-      closePopup("geofencesAddEdit");
-      showPopup("gpsTools");
-      if (objectId !== void 0) {
-        addCheckedGeofence(objectId);
-      }
-      if (fullRefresh) {
-        fullRefresh();
-      }
-    }).catch(() => {
-    });
-  };
-  return { onSubmit };
-}
-export {
-  useSubmit as u
-};

package/components/maps/components/MapGpsTools/subcomponents/TabsGpsTools/subcomponents/GeofenceAddEdit/hooks/useSumbitErrorsFocus-CwqFUFOe.js

@@ -1,36 +0,0 @@
-import { useEffect } from "react";
-import { useFormContext } from "react-hook-form";
-import { u as useTab } from "../../../../../../../../../hooks/useTab/index-CRVh_6kE.js";
-function useSumbitErrorsFocus() {
-  const {
-    setFocus,
-    formState: { isSubmitted, errors }
-  } = useFormContext();
-  const { handleChange } = useTab();
-  useEffect(() => {
-    if (isSubmitted) {
-      const firstError = Object.keys(errors).reduce((field, a) => {
-        const fieldKey = field;
-        return errors[fieldKey] ? fieldKey : a;
-      }, null);
-      if (firstError) {
-        const found = [
-          "name",
-          "geometry",
-          "geofenceType",
-          "timeMinInSeconds",
-          "timeMinOutSeconds"
-        ].some((field) => field.includes(firstError));
-        if (found) {
-          handleChange(null, "general");
-        }
-        if (firstError) {
-          setFocus(firstError);
-        }
-      }
-    }
-  }, [isSubmitted, errors]);
-}
-export {
-  useSumbitErrorsFocus as u
-};

package/components/maps/components/MapGpsTools/subcomponents/TabsGpsTools/subcomponents/GeofenceAddEdit/hooks/useValidation-C96AKUO1.js

@@ -1,19 +0,0 @@
-import { useMemo } from "react";
-import { useModuleDictionary } from "@m4l/core";
-import * as Yup from "yup";
-import { G as GeneralDataValidation } from "../subcomponents/GeneralData/validations-KeFtG-AL.js";
-import { C as ConfigDataValidation } from "../subcomponents/ConfigData/validations-BVCUuvYM.js";
-function useValidation() {
-  const { getLabel } = useModuleDictionary();
-  const validationSchema = useMemo(
-    () => Yup.object().shape({
-      ...GeneralDataValidation(getLabel),
-      ...ConfigDataValidation(getLabel)
-    }),
-    [getLabel]
-  );
-  return { validationSchema };
-}
-export {
-  useValidation as u
-};

package/components/maps/components/MapGpsTools/subcomponents/TabsGpsTools/subcomponents/GeofenceAddEdit/index-CGozDl-s.js

@@ -1,73 +0,0 @@
-import { jsx, jsxs } from "react/jsx-runtime";
-import { R as RHFormProviderStyled } from "./styles-G3zCBsBA.js";
-import { M as MyActions } from "./subcomponents/MyActions/index-C9CEt334.js";
-import { M as MyTabs } from "./subcomponents/MyTabs/index-Drbg_LwU.js";
-import { f as formatDataEnpoint } from "./helpers-B76zvEoG.js";
-import { u as useValidation } from "./hooks/useValidation-C96AKUO1.js";
-import { u as useSubmit } from "./hooks/useSubmit-CXwCD5g0.js";
-import { i as initialValues } from "./constants-D0Z5Tw8t.js";
-import { a as ENDPOINT_GEOFENCE_GET } from "../constants-BruLA0T6.js";
-import { g as gpsToolsClasses } from "../../../../classes/index-oE5Q9Oa0.js";
-import { u as useGpsToolsStore } from "../../../../hooks/useGpsToolsStore/index-BCw7XNS9.js";
-import { u as useFormAddEdit } from "../../../../../../../../hooks/useFormAddEdit/index-BNAXqhmd.js";
-import { T as TabProvider } from "../../../../../../../mui_extended/TabContext/index-fsl0KiAB.js";
-import { S as Stack } from "../../../../../../../mui_extended/Stack/Stack-C79qEBpg.js";
-function GeofenceAddEdit(props) {
-  const { geofenceId } = props;
-  const [finalInitalValues, omitCallEnpoint] = useGpsToolsStore((state) => {
-    if (geofenceId === void 0) {
-      return [initialValues, false];
-    }
-    const geofence = state.geofenceState.hashGeofences[geofenceId];
-    if (geofence?.geometry) {
-      const emulateResponse = {
-        data: {
-          type: geofence.type,
-          name: geofence.name,
-          id: geofence.id,
-          active: false,
-          geometry: geofence.geometry,
-          properties: geofence.properties,
-          countCrossingFeatures: geofence.countCrossingFeatures,
-          countInternalFeatures: geofence.countInternalFeatures,
-          createdAt: geofence.createdAt,
-          updatedAt: geofence.updatedAt,
-          timeMinInSeconds: geofence.timeMinInSeconds,
-          timeMinOutSeconds: geofence.timeMinOutSeconds,
-          alias: geofence.alias,
-          customerId: geofence.customerId
-        }
-      };
-      return [formatDataEnpoint(emulateResponse), true];
-    } else {
-      return [initialValues, false];
-    }
-  });
-  const { formValues, statusLoad } = useFormAddEdit({
-    objectId: geofenceId,
-    formatDataEnpoint,
-    initialValues: finalInitalValues,
-    endPoint: ENDPOINT_GEOFENCE_GET,
-    isRemote: false,
-    omitCallEnpoint
-  });
-  const { validationSchema } = useValidation();
-  const { onSubmit } = useSubmit({ objectId: geofenceId });
-  return /* @__PURE__ */ jsx(
-    RHFormProviderStyled,
-    {
-      statusLoad,
-      onSubmit,
-      values: formValues,
-      validationSchema,
-      className: gpsToolsClasses.gpsToolsGeofencesAddEdit,
-      children: /* @__PURE__ */ jsxs(Stack, { direction: "column", gap: "8px", children: [
-        /* @__PURE__ */ jsx(TabProvider, { initialValue: "general", children: /* @__PURE__ */ jsx(MyTabs, {}) }),
-        /* @__PURE__ */ jsx(MyActions, { ...props })
-      ] })
-    }
-  );
-}
-export {
-  GeofenceAddEdit as G
-};

package/components/maps/components/MapGpsTools/subcomponents/TabsGpsTools/subcomponents/GeofenceAddEdit/styles-G3zCBsBA.js

@@ -1,8 +0,0 @@
-import { styled } from "@mui/material/styles";
-import { R as RHFormProvider } from "../../../../../../../../contexts/RHFormContext/index-DE-wmCBw.js";
-const RHFormProviderStyled = styled(RHFormProvider)`
-  ${(props) => props.theme.components?.M4LMapGpsToolsGeofencesAddEdit?.styleOverrides}
-`;
-export {
-  RHFormProviderStyled as R
-};

package/components/maps/components/MapGpsTools/subcomponents/TabsGpsTools/subcomponents/GeofenceAddEdit/subcomponents/ConfigData/index-_uBDfWzl.js

@@ -1,52 +0,0 @@
-import { jsxs, jsx } from "react/jsx-runtime";
-import { useModuleDictionary, useEnvironment } from "@m4l/core";
-import { M as MAP_GPSTOOLS_DICCTIONARY } from "../../../../../../dictionary-BZWDA1RN.js";
-import { M as MAP_GPSTOOLS_ICONS } from "../../../../../../icons-BXKX8nl1.js";
-import { P as PaperForm } from "../../../../../../../../../PaperForm/PaperForm-DiHt7C4n.js";
-import { R as RHFTextField } from "../../../../../../../../../hook-form/RHFTextField/RHFTextField-B2nYzR3E.js";
-function ConfigData() {
-  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.CONFIG}`;
-  return /* @__PURE__ */ jsxs(PaperForm, { urlIcon, title: getLabel(MAP_GPSTOOLS_DICCTIONARY.PAPER_CONFIG), children: [
-    /* @__PURE__ */ jsx(
-      RHFTextField,
-      {
-        name: "alias",
-        disabled: false,
-        type: "text",
-        label: getLabel(`${MAP_GPSTOOLS_DICCTIONARY.LABEL_ALIAS}`)
-      }
-    ),
-    /* @__PURE__ */ jsx(
-      RHFTextField,
-      {
-        name: "customerId",
-        disabled: false,
-        type: "text",
-        label: getLabel(`${MAP_GPSTOOLS_DICCTIONARY.LABEL_CUSTOMER_ID}`)
-      }
-    ),
-    /* @__PURE__ */ jsx(
-      RHFTextField,
-      {
-        name: "timeMinInSeconds",
-        disabled: false,
-        type: "number",
-        label: getLabel(`${MAP_GPSTOOLS_DICCTIONARY.LABEL_TIME_MIN_IN_SECONDS}`)
-      }
-    ),
-    /* @__PURE__ */ jsx(
-      RHFTextField,
-      {
-        name: "timeMinOutSeconds",
-        disabled: false,
-        type: "number",
-        label: getLabel(`${MAP_GPSTOOLS_DICCTIONARY.LABEL_TIME_MIN_OUT_SECONDS}`)
-      }
-    )
-  ] });
-}
-export {
-  ConfigData as C
-};

package/components/maps/components/MapGpsTools/subcomponents/TabsGpsTools/subcomponents/GeofenceAddEdit/subcomponents/ConfigData/validations-BVCUuvYM.js

@@ -1,11 +0,0 @@
-import * as Yup from "yup";
-import { M as MAP_GPSTOOLS_DICCTIONARY } from "../../../../../../dictionary-BZWDA1RN.js";
-function ConfigDataValidation(getLabel) {
-  return {
-    timeMinInSeconds: Yup.number().nullable().required(getLabel(MAP_GPSTOOLS_DICCTIONARY.VALIDATION_FIELD_REQUIRED)).typeError(getLabel(MAP_GPSTOOLS_DICCTIONARY.VALIDATION_FIELD_TYPE_NUMBER_ERROR)).min(0, getLabel(MAP_GPSTOOLS_DICCTIONARY.VALIDATION_FIELD_MIN_NUMBER_ERROR)),
-    timeMinOutSeconds: Yup.number().nullable().required(getLabel(MAP_GPSTOOLS_DICCTIONARY.VALIDATION_FIELD_REQUIRED)).typeError(getLabel(MAP_GPSTOOLS_DICCTIONARY.VALIDATION_FIELD_TYPE_NUMBER_ERROR)).min(0, getLabel(MAP_GPSTOOLS_DICCTIONARY.VALIDATION_FIELD_MIN_NUMBER_ERROR))
-  };
-}
-export {
-  ConfigDataValidation as C
-};