@m4l/gclick 0.3.1-beta.0 → 0.3.1-beta.1

package/components/maps/components/GpsMapTools/subcomponents/GeofencesTool/subcomponents/GeofenceAddEdit/hooks/useDrawing.js

@@ -1,30 +1,26 @@
-import { useState, useRef, useEffect, useCallback, useMemo } from "react";
-import { useFormContext } from "react-hook-form";
-import { useModuleDictionary } from "@m4l/core";
-import { useMap } from "react-leaflet";
-import * as L from "leaflet";
-import { g as getLayerFromGeometry } from "../helpers.js";
-import { useFormReadyForUpdate, useWatchTyped } from "@m4l/components";
-import { M as MAP_GPSTOOLS_DICCTIONARY } from "../../../../../dictionary.js";
-import { g as getStyleFromProperties } from "../../../helpers.js";
-function useDrawing() {
-  const { getLabel } = useModuleDictionary();
-  const readyToUpdate = useFormReadyForUpdate();
-  const map = useMap();
-  const { control, setValue } = useFormContext();
-  const [
-    geofenceTypeId,
-    inEdition,
-    strokeColor,
-    strokeOpacity,
-    strokeWeight,
-    strokeDashArray,
-    fillColor,
-    fillOpacity,
-    geometry,
-    radius
-  ] = useWatchTyped({
-    control,
+import { useState as S, useRef as D, useEffect as d, useCallback as F, useMemo as w } from "react";
+import { useFormContext as x } from "react-hook-form";
+import { useModuleDictionary as B } from "@m4l/core";
+import { useMap as V } from "react-leaflet";
+import * as v from "leaflet";
+import { getLayerFromGeometry as H } from "../helpers.js";
+import { useFormReadyForUpdate as J, useWatchTyped as U } from "@m4l/components";
+import { MAP_GPSTOOLS_DICCTIONARY as u } from "../../../../../dictionary.js";
+import { getStyleFromProperties as T } from "../../../helpers.js";
+function Z() {
+  const { getLabel: i } = B(), y = J(), r = V(), { control: G, setValue: t } = x(), [
+    a,
+    A,
+    m,
+    g,
+    f,
+    L,
+    h,
+    E,
+    I,
+    b
+  ] = U({
+    control: G,
     name: [
       "geofenceTypeId",
       "inEdition",
@@ -37,203 +33,112 @@ function useDrawing() {
       "geometry",
       "properties.radius"
     ]
-  });
-  const [isDrawing, setIsDrawing] = useState(false);
-  const currentLayer = useRef(null);
-  const refProperties = useRef(getStyleFromProperties({
-    strokeColor,
-    strokeOpacity,
-    strokeWeight,
-    strokeDashArray,
-    fillColor,
-    fillOpacity
+  }), [O, N] = S(!1), e = D(null), p = D(T({
+    strokeColor: m,
+    strokeOpacity: g,
+    strokeWeight: f,
+    strokeDashArray: L,
+    fillColor: h,
+    fillOpacity: E
   }));
-  refProperties.current = getStyleFromProperties({
-    strokeColor,
-    strokeOpacity,
-    strokeWeight,
-    strokeDashArray,
-    fillColor,
-    fillOpacity
+  p.current = T({
+    strokeColor: m,
+    strokeOpacity: g,
+    strokeWeight: f,
+    strokeDashArray: L,
+    fillColor: h,
+    fillOpacity: E
   });
-  const radiusValue = radius ?? null;
-  const [geometrTypeIdCached, setGeofenceTypeIdCached] = useState(geofenceTypeId);
-  useEffect(() => {
-    if (!readyToUpdate) {
-      return;
-    }
-    if (geometry) {
-      currentLayer.current = getLayerFromGeometry(geometry, geofenceTypeId, radiusValue, {
-        ...refProperties.current
-      });
-      if (currentLayer.current) {
-        map.addLayer(currentLayer.current);
-        map.fitBounds(currentLayer.current.getBounds());
-      }
-    }
-    return () => {
-      if (currentLayer.current) {
-        currentLayer.current.remove();
-      }
-    };
-  }, [map, readyToUpdate]);
-  useEffect(() => {
-    if (!readyToUpdate) {
-      if (geometrTypeIdCached !== geofenceTypeId) {
-        setGeofenceTypeIdCached(geofenceTypeId);
-      }
+  const k = b ?? null, [l, M] = S(a);
+  d(() => {
+    if (y)
+      return I && (e.current = H(I, a, k, {
+        ...p.current
+      }), e.current && (r.addLayer(e.current), r.fitBounds(e.current.getBounds()))), () => {
+        e.current && e.current.remove();
+      };
+  }, [r, y]), d(() => {
+    if (!y) {
+      l !== a && M(a);
       return;
     }
-    if (geofenceTypeId !== geometrTypeIdCached) {
-      setGeofenceTypeIdCached(geofenceTypeId);
-      if (geometrTypeIdCached !== "gt_circle") {
-        setValue("properties.radius", null, { shouldDirty: true });
-        setValue("lat", null, { shouldDirty: true });
-        setValue("lng", null, { shouldDirty: true });
-      }
-      setValue("geometry", null, { shouldDirty: true });
-      if (currentLayer.current) {
-        currentLayer.current.remove();
-        currentLayer.current = null;
-      }
-    }
-  }, [readyToUpdate, geofenceTypeId]);
-  useEffect(() => {
-    if (currentLayer.current) {
-      currentLayer.current.setStyle(refProperties.current);
-    }
-  }, [strokeColor, strokeOpacity, strokeWeight, strokeDashArray, fillColor, fillOpacity]);
-  useEffect(() => {
-    map.pm.setLang("en", {
+    a !== l && (M(a), l !== "gt_circle" && (t("properties.radius", null, { shouldDirty: !0 }), t("lat", null, { shouldDirty: !0 }), t("lng", null, { shouldDirty: !0 })), t("geometry", null, { shouldDirty: !0 }), e.current && (e.current.remove(), e.current = null));
+  }, [y, a]), d(() => {
+    e.current && e.current.setStyle(p.current);
+  }, [m, g, f, L, h, E]), d(() => {
+    r.pm.setLang("en", {
       tooltips: {
         placeMarker: void 0,
-        firstVertex: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_GEOMAN_FIRST_VERTEX),
-        continueLine: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_GEOMAN_CONTINUE_LINE),
-        finishLine: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_GEOMAN_FINISH_LINE),
-        finishPoly: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_GEOMAN_FINISH_POLYLINE),
-        finishRect: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_GEOMAN_FINISH_RECT),
-        startCircle: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_GEOMAN_START_CIRCLE),
-        finishCircle: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_GEOMAN_FINISH_CIRCLE),
-        placeCircleMarker: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_GEOMAN_PLACE_CIRCLE_MARKER)
+        firstVertex: i(u.LABEL_GEOMAN_FIRST_VERTEX),
+        continueLine: i(u.LABEL_GEOMAN_CONTINUE_LINE),
+        finishLine: i(u.LABEL_GEOMAN_FINISH_LINE),
+        finishPoly: i(u.LABEL_GEOMAN_FINISH_POLYLINE),
+        finishRect: i(u.LABEL_GEOMAN_FINISH_RECT),
+        startCircle: i(u.LABEL_GEOMAN_START_CIRCLE),
+        finishCircle: i(u.LABEL_GEOMAN_FINISH_CIRCLE),
+        placeCircleMarker: i(u.LABEL_GEOMAN_PLACE_CIRCLE_MARKER)
       }
     });
-  }, [map, getLabel]);
-  useEffect(() => {
-    if (map) {
-      let shape = "Circle";
-      let pmShape = "Circle";
-      if (geometrTypeIdCached === "gt_polygon") {
-        shape = "Polygon";
-        pmShape = "Polygon";
-      } else if (geometrTypeIdCached === "gt_multipolygon") {
-        shape = "MultiPolygon";
-        pmShape = "Polygon";
-      } else if (geometrTypeIdCached === "gt_rectangle") {
-        shape = "Rectangle";
-        pmShape = "Rectangle";
-      }
-      if (isDrawing) {
-        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)));
-                });
-              });
-            });
-          } else if (shape === "Polygon" || shape === "MultiPolygon") {
-            map.on("pm:drawstart", ({ workingLayer }) => {
-              workingLayer.on("pm:vertexadded", (e) => {
-                const layer = e.workingLayer;
-                layer.setStyle(refProperties.current);
-              });
-            });
-          }
-          map.pm.enableDraw(pmShape);
-          map.pm.setPathOptions(refProperties.current);
-          map.on("pm:create", (e) => {
-            const layer = e.layer;
-            const geoJSONgeometry = layer.toGeoJSON()?.geometry;
-            if (shape === "MultiPolygon" && geoJSONgeometry?.type === "Polygon") {
-              const multiPolygonGeometry = {
-                type: "MultiPolygon",
-                coordinates: [geoJSONgeometry.coordinates]
-              };
-              map.removeLayer(layer);
-              currentLayer.current = L.geoJSON(multiPolygonGeometry, {
-                style: refProperties.current
-              });
-              map.addLayer(currentLayer.current);
-              setValue("geometry", multiPolygonGeometry, {
-                shouldTouch: true,
-                shouldValidate: true,
-                shouldDirty: true
-              });
-            } else {
-              currentLayer.current = layer;
-              setValue("geometry", geoJSONgeometry, {
-                shouldTouch: true,
-                shouldValidate: true,
-                shouldDirty: true
-              });
-            }
-            setValue("inEdition", false);
-            setIsDrawing(false);
+  }, [r, i]), d(() => {
+    if (r) {
+      let s = "Circle", _ = "Circle";
+      l === "gt_polygon" ? (s = "Polygon", _ = "Polygon") : l === "gt_multipolygon" ? (s = "MultiPolygon", _ = "Polygon") : l === "gt_rectangle" && (s = "Rectangle", _ = "Rectangle"), O ? e.current ? (e.current.pm.enable(), t("inEdition", !0), e.current.on("pm:disable", (n) => {
+        e.current = n.layer, t("geometry", e.current.toGeoJSON()?.geometry, {
+          shouldTouch: !0,
+          shouldValidate: !0,
+          shouldDirty: !0
+        }), t("inEdition", !1), N(!1);
+      }), s === "Circle" && e.current.on("pm:change", (n) => {
+        e.current = n.layer, t("lat", Number(e.current.getLatLng().lat.toFixed(8))), t("lng", Number(e.current.getLatLng().lng.toFixed(8))), t("properties.radius", e.current.getRadius()), t("properties.radius", Number(e.current.getRadius().toFixed(1)));
+      })) : (t("inEdition", !0), s === "Circle" ? r.on("pm:drawstart", ({ workingLayer: n }) => {
+        n.on("pm:centerplaced", (c) => {
+          const o = c.workingLayer;
+          o.setStyle({
+            color: m,
+            opacity: g,
+            weight: f,
+            dashArray: L,
+            fillColor: h,
+            fillOpacity: E
+          }), t("lat", Number(o.getLatLng().lat.toFixed(8))), t("lng", Number(o.getLatLng().lng.toFixed(8))), o.on("pm:change", (C) => {
+            t("properties.radius", Number(o.getRadius().toFixed(1)));
           });
-        } 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: true,
-              shouldValidate: true,
-              shouldDirty: true
-            });
-            setValue("inEdition", false);
-            setIsDrawing(false);
+        });
+      }) : (s === "Polygon" || s === "MultiPolygon") && r.on("pm:drawstart", ({ workingLayer: n }) => {
+        n.on("pm:vertexadded", (c) => {
+          c.workingLayer.setStyle(p.current);
+        });
+      }), r.pm.enableDraw(_), r.pm.setPathOptions(p.current), r.on("pm:create", (n) => {
+        const c = n.layer, o = c.toGeoJSON()?.geometry;
+        if (s === "MultiPolygon" && o?.type === "Polygon") {
+          const C = {
+            type: "MultiPolygon",
+            coordinates: [o.coordinates]
+          };
+          r.removeLayer(c), e.current = v.geoJSON(C, {
+            style: p.current
+          }), r.addLayer(e.current), t("geometry", C, {
+            shouldTouch: !0,
+            shouldValidate: !0,
+            shouldDirty: !0
           });
-          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, isDrawing]);
-  const handleDraw = useCallback(() => {
-    setIsDrawing(true);
-  }, []);
-  const handleFinish = useCallback(() => {
-    if (currentLayer.current) {
-      currentLayer.current.pm.disable();
+        } else
+          e.current = c, t("geometry", o, {
+            shouldTouch: !0,
+            shouldValidate: !0,
+            shouldDirty: !0
+          });
+        t("inEdition", !1), N(!1);
+      })) : (r.pm.disableDraw("Polygon"), r.off("pm:create"), r.off("pm:edit"), r.off("pm:drawstart"));
     }
+  }, [r, O]);
+  const P = F(() => {
+    N(!0);
+  }, []), R = F(() => {
+    e.current && e.current.pm.disable();
   }, []);
-  return useMemo(() => ({ inEdition, handleDraw, handleFinish, geometrTypeIdCached }), [inEdition, handleDraw, handleFinish, geometrTypeIdCached]);
+  return w(() => ({ inEdition: A, handleDraw: P, handleFinish: R, geometrTypeIdCached: l }), [A, P, R, l]);
 }
 export {
-  useDrawing as u
+  Z as useDrawing
 };

package/components/maps/components/GpsMapTools/subcomponents/GeofencesTool/subcomponents/GeofenceAddEdit/hooks/useForm.d.ts

@@ -9,3 +9,4 @@ declare const useForm: (props: GeofenceAddEditProps) => {
     validationSchema: import('@m4l/components').ValidationSchema<FormAddEditValues>;
 };
 export default useForm;
+//# sourceMappingURL=useForm.d.ts.map

package/components/maps/components/GpsMapTools/subcomponents/GeofencesTool/subcomponents/GeofenceAddEdit/hooks/useForm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useForm.d.ts","sourceRoot":"","sources":["../../../../../../../../../../../../../packages/gclick/src/components/maps/components/GpsMapTools/subcomponents/GeofencesTool/subcomponents/GeofenceAddEdit/hooks/useForm.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAe,MAAM,UAAU,CAAC;AAahF;;GAEG;AACH,QAAA,MAAM,OAAO,GAAI,OAAO,oBAAoB;;;;;CA+G3C,CAAC;AAEF,eAAe,OAAO,CAAC"}

package/components/maps/components/GpsMapTools/subcomponents/GeofencesTool/subcomponents/GeofenceAddEdit/hooks/useForm.js

@@ -1,108 +1,96 @@
-import { useEffect, useMemo } from "react";
-import { useWindowToolsMF, deepShallow, getStepsAndValidationSchema } from "@m4l/components";
-import { useModuleDictionary, useEnvironment } from "@m4l/core";
-import { useFormAddEdit } from "@m4l/layouts";
-import { u as useGpsMapToolsStore } from "../../../../../hooks/useGpsMapToolsStore/index.js";
-import { f as formatDataEndpoint } from "../helpers.js";
-import { E as ENDPOINT_GEOFENCES_GET } from "../../../constants.js";
-import { i as initialValues } from "../constants.js";
-import { M as MAP_GPSTOOLS_DICCTIONARY } from "../../../../../dictionary.js";
-import { G as GeneralDataValidation } from "../subcomponents/GeneralData/validations.js";
-import { M as MAP_GPSTOOLS_ICONS } from "../../../../../icons.js";
-import { G as GPS_TOOLS_COMPONENT_PATH_ID } from "../../../../../constants.js";
-import { shallow } from "zustand/shallow";
-import { A as AssignmentDataValidation } from "../subcomponents/AssignmentData/validations.js";
-const useForm = (props) => {
-  const { geofenceId } = props;
-  const { getLabel } = useModuleDictionary();
-  const { host_static_assets, environment_assets } = useEnvironment();
-  const { startProgress, stopProgress } = useWindowToolsMF();
-  const { addOrReplaceGeofence } = useGpsMapToolsStore((state) => state.geofenceActions, shallow);
-  const [finalInitalValues, omitCallEnpoint] = useGpsMapToolsStore((state) => {
-    if (geofenceId === void 0) {
-      return [initialValues, false];
-    }
-    const geofence = state.geofenceState.hashGeofences[geofenceId];
-    if (geofence?.geometry && geofence?.assignmentDevices && geofence?.assignmentDepartments) {
-      const emulateResponse = {
+import { useEffect as N, useMemo as g } from "react";
+import { useWindowToolsMF as v, deepShallow as C, getStepsAndValidationSchema as D } from "@m4l/components";
+import { useModuleDictionary as G, useEnvironment as y } from "@m4l/core";
+import { useFormAddEdit as M } from "@m4l/layouts";
+import { useGpsMapToolsStore as p } from "../../../../../hooks/useGpsMapToolsStore/index.js";
+import { formatDataEndpoint as l } from "../helpers.js";
+import { ENDPOINT_GEOFENCES_GET as $ } from "../../../constants.js";
+import { initialValues as E } from "../constants.js";
+import { MAP_GPSTOOLS_DICCTIONARY as s } from "../../../../../dictionary.js";
+import { GeneralDataValidation as F } from "../subcomponents/GeneralData/validations.js";
+import { MAP_GPSTOOLS_ICONS as c } from "../../../../../icons.js";
+import { GPS_TOOLS_COMPONENT_PATH_ID as d } from "../../../../../constants.js";
+import { shallow as R } from "zustand/shallow";
+import { AssignmentDataValidation as h } from "../subcomponents/AssignmentData/validations.js";
+const K = (S) => {
+  const { geofenceId: o } = S, { getLabel: t } = G(), { host_static_assets: i, environment_assets: a } = y(), { startProgress: f, stopProgress: u } = v(), { addOrReplaceGeofence: T } = p((n) => n.geofenceActions, R), [_, A] = p((n) => {
+    if (o === void 0)
+      return [E, !1];
+    const e = n.geofenceState.hashGeofences[o];
+    if (e?.geometry && e?.assignmentDevices && e?.assignmentDepartments) {
+      const O = {
         data: {
-          type: geofence.type,
-          name: geofence.name,
-          id: geofence.id,
-          active: false,
-          geometry: geofence.geometry,
-          properties: geofence.properties,
-          createdAt: geofence.createdAt,
-          updatedAt: geofence.updatedAt,
-          timeMinInSeconds: geofence.timeMinInSeconds,
-          timeMinOutSeconds: geofence.timeMinOutSeconds,
-          bounds: geofence.bounds,
-          alias: geofence.alias,
-          customerId: geofence.customerId,
-          devicesAssignmentType: geofence.devicesAssignmentType,
-          assignmentDevices: geofence.assignmentDevices,
-          assignmentDepartments: geofence.assignmentDepartments
+          type: e.type,
+          name: e.name,
+          id: e.id,
+          active: !1,
+          geometry: e.geometry,
+          properties: e.properties,
+          createdAt: e.createdAt,
+          updatedAt: e.updatedAt,
+          timeMinInSeconds: e.timeMinInSeconds,
+          timeMinOutSeconds: e.timeMinOutSeconds,
+          bounds: e.bounds,
+          alias: e.alias,
+          customerId: e.customerId,
+          devicesAssignmentType: e.devicesAssignmentType,
+          assignmentDevices: e.assignmentDevices,
+          assignmentDepartments: e.assignmentDepartments
         }
       };
-      return [formatDataEndpoint(emulateResponse), true];
-    } else {
-      return [initialValues, false];
-    }
-  }, deepShallow);
-  const { formValues, statusLoad } = useFormAddEdit({
-    objectId: geofenceId,
-    formatDataEndpoint,
-    initialValues: finalInitalValues,
+      return [l(O), !0];
+    } else
+      return [E, !1];
+  }, C), { formValues: r, statusLoad: m } = M({
+    objectId: o,
+    formatDataEndpoint: l,
+    initialValues: _,
     networkProps: {
-      endPoint: `${ENDPOINT_GEOFENCES_GET}/${geofenceId}`,
-      responseToCamelCase: true,
+      endPoint: `${$}/${o}`,
+      responseToCamelCase: !0,
       method: "GET",
       options: {
-        startProgress,
-        stopProgress
+        startProgress: f,
+        stopProgress: u
       }
     },
-    omitCallEnpoint
+    omitCallEnpoint: A
   });
-  useEffect(() => {
-    if (statusLoad === "ready" && geofenceId && formValues.createdAt) {
-      addOrReplaceGeofence(geofenceId, formValues);
-    }
-  }, [statusLoad, geofenceId, formValues]);
-  const { steps, validationSchema } = useMemo(() => getStepsAndValidationSchema({
+  N(() => {
+    m === "ready" && o && r.createdAt && T(o, r);
+  }, [m, o, r]);
+  const { steps: I, validationSchema: P } = g(() => D({
     visibilityData: void 0,
     steps: [
       {
         key: "basic-information",
-        title: getLabel(MAP_GPSTOOLS_DICCTIONARY.STEP_BASIC_INFORMATION),
-        description: getLabel(MAP_GPSTOOLS_DICCTIONARY.STEP_BASIC_INFORMATION_DESCRIPTION),
-        icon: `${host_static_assets}/${environment_assets}/frontend/components/${GPS_TOOLS_COMPONENT_PATH_ID}/assets/icons/${MAP_GPSTOOLS_ICONS.GEOFENCES_PAPER_GENERAL}`,
-        validationFunction: () => GeneralDataValidation(getLabel)
+        title: t(s.STEP_BASIC_INFORMATION),
+        description: t(s.STEP_BASIC_INFORMATION_DESCRIPTION),
+        icon: `${i}/${a}/frontend/components/${d}/assets/icons/${c.GEOFENCES_PAPER_GENERAL}`,
+        validationFunction: () => F(t)
       },
       {
         key: "assignment",
-        title: getLabel(MAP_GPSTOOLS_DICCTIONARY.STEP_ASSIGNMENT),
-        description: getLabel(MAP_GPSTOOLS_DICCTIONARY.STEP_ASSIGNMENT_DESCRIPTION),
-        icon: `${host_static_assets}/${environment_assets}/frontend/components/${GPS_TOOLS_COMPONENT_PATH_ID}/assets/icons/${MAP_GPSTOOLS_ICONS.GEOFENCES_PAPER_ASSIGNMENT}`,
-        validationFunction: () => AssignmentDataValidation(getLabel),
+        title: t(s.STEP_ASSIGNMENT),
+        description: t(s.STEP_ASSIGNMENT_DESCRIPTION),
+        icon: `${i}/${a}/frontend/components/${d}/assets/icons/${c.GEOFENCES_PAPER_ASSIGNMENT}`,
+        validationFunction: () => h(t),
         /**
          * Visibility condition for the parts information, only show if the objectId and accountId are defined
          */
-        visibilityCondition: (formData) => {
-          return formData.chooseAssignmentType === "discriminate";
-        }
+        visibilityCondition: (n) => n.chooseAssignmentType === "discriminate"
       },
       {
         key: "style-information",
-        title: getLabel(MAP_GPSTOOLS_DICCTIONARY.STEP_STYLE),
-        description: getLabel(MAP_GPSTOOLS_DICCTIONARY.STEP_STYLE_DESCRIPTION),
-        icon: `${host_static_assets}/${environment_assets}/frontend/components/${GPS_TOOLS_COMPONENT_PATH_ID}/assets/icons/${MAP_GPSTOOLS_ICONS.GEOFENCES_PAPER_STYLE}`,
+        title: t(s.STEP_STYLE),
+        description: t(s.STEP_STYLE_DESCRIPTION),
+        icon: `${i}/${a}/frontend/components/${d}/assets/icons/${c.GEOFENCES_PAPER_STYLE}`,
         validationFunction: void 0
       }
     ]
-  }), [getLabel, host_static_assets, environment_assets]);
-  return { steps, formValues, statusLoad, validationSchema };
+  }), [t, i, a]);
+  return { steps: I, formValues: r, statusLoad: m, validationSchema: P };
 };
 export {
-  useForm as u
+  K as default
 };

package/components/maps/components/GpsMapTools/subcomponents/GeofencesTool/subcomponents/GeofenceAddEdit/hooks/useSubmit.d.ts

@@ -7,3 +7,4 @@ export type UseSubmitProps = Pick<GeofenceAddEditProps, 'fullRefresh' | 'geofenc
 export declare function useSubmit(props: UseSubmitProps): {
     onSubmit: (data: FormAddEditValues | FieldValues) => Promise<void>;
 };
+//# sourceMappingURL=useSubmit.d.ts.map

package/components/maps/components/GpsMapTools/subcomponents/GeofencesTool/subcomponents/GeofenceAddEdit/hooks/useSubmit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSubmit.d.ts","sourceRoot":"","sources":["../../../../../../../../../../../../../packages/gclick/src/components/maps/components/GpsMapTools/subcomponents/GeofencesTool/subcomponents/GeofenceAddEdit/hooks/useSubmit.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAgBnE,MAAM,MAAM,cAAc,GAAG,IAAI,CAAC,oBAAoB,EAAE,aAAa,GAAG,YAAY,CAAC,CAAA;AAgCrF;;GAEG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,cAAc;qBAaF,iBAAiB,GAAG,WAAW;EAwB3E"}