@m4l/components 7.2.0 → 7.2.2

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

@@ -0,0 +1,116 @@
+import { useModuleDictionary, useEnvironment } from "@m4l/core";
+import { useMemo } from "react";
+import { M as MAP_GPSTOOLS_DICCTIONARY } from "../../../../../dictionary.js";
+import { C as ColumnIconFormatter } from "../../../../../../../../DataGrid/formatters/ColumnIconFormatter/index.js";
+import { M as MAP_GPSTOOLS_ICONS } from "../../../../../icons.js";
+import { C as ColumnDateFormatter } from "../../../../../../../../DataGrid/formatters/ColumnDateFormatter/index.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
+           */
+          getIconUrl: (formatterRowProps) => {
+            const { row } = formatterRowProps;
+            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/MapGpsTools/subcomponents/TabsGpsTools/subcomponents/GeofencesList/hooks/useMaster.js

@@ -0,0 +1,162 @@
+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 { 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 usePopupsStore } from "../../../../../../../../popups/components/PopupsProvider/hooks/usePopupsStore/index.js";
+import { u as useMapGpsToolsStore } from "../../../../../hooks/useMapGpsToolsStore/index.js";
+function useMaster() {
+  const { getLabel } = useModuleDictionary();
+  const { host_static_assets, environment_assets } = useEnvironment();
+  const { hidePopup, addPopup } = usePopupsStore((state) => state.popupsActions, shallow);
+  const goToAdd = () => {
+    hidePopup("gpsTools");
+    addPopup({
+      popupId: "geofencesAddEdit",
+      title: getLabel(MAP_GPSTOOLS_DICCTIONARY.MODULE_NAME_GEOFENCE_ADD),
+      functionComponent: () => /* @__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] = useMapGpsToolsStore(
+    (state) => [
+      state.geofenceState.checkedGeofences,
+      state.geofenceState.hashGeofences,
+      state.geofenceState.rows
+    ],
+    shallow
+  );
+  const { setCheckedGeofences, addGeofence, updatePartialGeofence, updateRows } = useMapGpsToolsStore(
+    (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/MapGpsTools/subcomponents/TabsGpsTools/subcomponents/GeofencesList/hooks/useRowActionsGetter.js

@@ -0,0 +1,111 @@
+import { jsx } from "react/jsx-runtime";
+import { useNetwork, useModuleDictionary, useModulePrivileges, useEnvironment, useHostTools } from "@m4l/core";
+import { useState, useCallback } from "react";
+import { M as MAP_GPSTOOLS_ICONS } from "../../../../../icons.js";
+import { useResponsiveDesktop } from "@m4l/graphics";
+import { M as MAP_GPSTOOLS_DICCTIONARY } from "../../../../../dictionary.js";
+import { u as useModal } from "../../../../../../../../../hooks/useModal/index.js";
+import { shallow } from "zustand/shallow";
+import { G as GeofenceAddEdit } from "../../GeofenceAddEdit/index.js";
+import { u as usePopupsStore } from "../../../../../../../../popups/components/PopupsProvider/hooks/usePopupsStore/index.js";
+import { u as useMapGpsToolsStore } from "../../../../../hooks/useMapGpsToolsStore/index.js";
+import { W as WindowConfirm } from "../../../../../../../../modal/WindowConfirm/index.js";
+function useRowActionsGetter(props) {
+  const { fullRefresh } = props;
+  const { networkOperation } = useNetwork();
+  const { openModal, closeModal } = useModal();
+  const { getLabel } = useModuleDictionary();
+  const { hasPrivilege } = useModulePrivileges();
+  const { host_static_assets, environment_assets } = useEnvironment();
+  const { hidePopup, addPopup } = usePopupsStore((state) => state.popupsActions, shallow);
+  const { removeCheckedGeofence } = useMapGpsToolsStore((state) => state.geofenceActions, shallow);
+  const { toast } = useHostTools();
+  const isDesktop = useResponsiveDesktop();
+  const [urlIconEdit] = useState(
+    `${host_static_assets}/${environment_assets}/frontend/components/map_gpstools/assets/icons/${MAP_GPSTOOLS_ICONS.GEOFENCE_EDIT}`
+  );
+  const [urlIconDelete] = useState(
+    `${host_static_assets}/${environment_assets}/frontend/components/map_gpstools/assets/icons/${MAP_GPSTOOLS_ICONS.GEOFENCE_DELETE}`
+  );
+  const goEdit = (objectId, name) => {
+    hidePopup("gpsTools");
+    addPopup({
+      popupId: "geofencesAddEdit",
+      title: getLabel(MAP_GPSTOOLS_DICCTIONARY.MODULE_NAME_GEOFENCE_EDIT),
+      editionInfo: `${getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_ID)}:${objectId} - ${name} `,
+      componentProps: { fullRefresh, geofenceId: objectId },
+      functionComponent: 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: urlIconEdit
+    });
+    removeCheckedGeofence(objectId);
+  };
+  const onDelete = useCallback(
+    (row) => {
+      openModal({
+        window: /* @__PURE__ */ jsx(
+          WindowConfirm,
+          {
+            title: getLabel(MAP_GPSTOOLS_DICCTIONARY.MODAL_DELETE_GEO_TITLE),
+            msg: getLabel(MAP_GPSTOOLS_DICCTIONARY.MODAL_DELETE_GEO_MESSAGE),
+            onClickIntro: () => onConfirmDelete(row)
+          }
+        ),
+        variant: "delete",
+        initialWidth: 300,
+        initialHeigth: 350
+      });
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [getLabel]
+  );
+  const onConfirmDelete = useCallback((row) => {
+    networkOperation({
+      method: "DELETE",
+      endPoint: `geofences/${row.id}`
+    }).then((response) => {
+      toast({ title: response.message }, { type: "success" });
+      fullRefresh();
+    });
+    closeModal();
+  }, []);
+  const rowActionsGetter = useCallback(
+    (row) => {
+      const conditionalItems = [];
+      conditionalItems.push({
+        urlIcon: urlIconEdit,
+        dictionaryId: MAP_GPSTOOLS_DICCTIONARY.ROW_ACTION_GEO_EDIT,
+        onClick: () => {
+          goEdit(row.id, row.name);
+        },
+        // Solo se habilita si intenta editarse a él mismo, o si tiene permisos pero está en un nivel superior al usuario a editar
+        // disabled: !(itsMe || (hasPrivilege(PRIVILEGE_EDIT) && (loggedUserType > row.user_type.id)))
+        disabled: !row.authUserOptions.edit
+      });
+      conditionalItems.push({
+        urlIcon: urlIconDelete,
+        dictionaryId: MAP_GPSTOOLS_DICCTIONARY.ROW_ACTION_GEO_DELETE,
+        onClick: () => {
+          onDelete(row);
+        },
+        variant: "delete",
+        // Solo se habilita si intenta editarse a él mismo, o si tiene permisos pero está en un nivel superior al usuario a editar
+        // disabled: !(itsMe || (hasPrivilege(PRIVILEGE_EDIT) && (loggedUserType > row.user_type.id)))
+        disabled: !row.authUserOptions.edit
+      });
+      return conditionalItems;
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [hasPrivilege, goEdit, onDelete, urlIconDelete, urlIconEdit, isDesktop]
+  );
+  return { rowActionsGetter };
+}
+export {
+  useRowActionsGetter as u
+};

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

@@ -0,0 +1,75 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+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";
+import { D as DataGrid } from "../../../../../../../DataGrid/index.js";
+import { A as Actions } from "../../../../../../../CommonActions/components/Actions/index.js";
+import { B as Button } from "../../../../../../../mui_extended/Button/Button.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(Actions, { children: /* @__PURE__ */ jsx(Button, { onClick: () => goToAdd(), children: getLabel(MAP_GPSTOOLS_DICCTIONARY.MODULE_NAME_GEOFENCE_ADD) }) })
+      ]
+    }
+  );
+}
+export {
+  GeofencesList as G
+};

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

@@ -0,0 +1,8 @@
+import { styled } from "@mui/material/styles";
+import { S as Stack } from "../../../../../../../mui_extended/Stack/Stack.js";
+const StackGeofenceListRoot = styled(Stack)`
+  ${(props) => props.theme.components?.M4LMapGpsToolsGeofencesList?.styleOverrides}
+`;
+export {
+  StackGeofenceListRoot as S
+};

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

@@ -0,0 +1,49 @@
+import { jsx } from "react/jsx-runtime";
+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";
+import { D as DynamicFilter } from "../../../../../../../../../DynamicFilter/DynamicFilter.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/MapGpsTools/subcomponents/TabsGpsTools/subcomponents/constants.js

@@ -0,0 +1,13 @@
+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/index.js

@@ -0,0 +1 @@
+

package/components/maps/utils/courseToCartesianAngle.js

@@ -0,0 +1,8 @@
+function courseToCartesianAngle(course) {
+  let cartesianAngle = (90 - course) % 360;
+  cartesianAngle = (cartesianAngle + 360) % 360;
+  return cartesianAngle;
+}
+export {
+  courseToCartesianAngle as c
+};

package/components/maps/utils/courseToCssAngle.js

@@ -0,0 +1,13 @@
+const getPostiveAngle = (angle) => {
+  const newAngle = angle % 360;
+  return newAngle < 0 ? newAngle + 360 : newAngle;
+};
+function courseToCssAngle(course, offsetRotate) {
+  const newCourse = course - 90;
+  const newOffset = offsetRotate - 90;
+  const rotation = getPostiveAngle(newCourse - newOffset);
+  return rotation;
+}
+export {
+  courseToCssAngle as c
+};

package/components/maps/utils/index.js

@@ -0,0 +1 @@
+

package/components/maps/utils/isFeature.js

@@ -0,0 +1,6 @@
+function isFeature(obj) {
+  return "geometry" in obj && "type" in obj && obj.type === "Feature" && "properties" in obj;
+}
+export {
+  isFeature as i
+};

package/components/maps/utils/isFeatureCollection.js

@@ -0,0 +1,6 @@
+function isFeatureCollection(obj) {
+  return "features" in obj && "type" in obj && obj.type === "FeatureCollection";
+}
+export {
+  isFeatureCollection as i
+};

package/components/maps/utils/isFeatureCollectionDraft.js

@@ -0,0 +1,6 @@
+function isFeatureCollectionDraft(obj) {
+  return "features" in obj && Array.isArray(obj["features"]) && "type" in obj && obj.type === "FeatureCollection";
+}
+export {
+  isFeatureCollectionDraft as i
+};

package/components/maps/utils/isGeometry.js

@@ -0,0 +1,6 @@
+function isGeometry(obj) {
+  return "geometry" in obj && "type" in obj && obj.type === "Feature" && "properties" in obj;
+}
+export {
+  isGeometry as i
+};

package/components/modal/ModalDialog/dictionary.js

@@ -0,0 +1,11 @@
+import { g as getCommonActionsDictionary } from "../../CommonActions/dictionary.js";
+function getModalDialogComponentsDictionary() {
+  return ["modal_dialog"].concat(getCommonActionsDictionary());
+}
+const defaultModalDialogDictionary = {
+  modal_dialog: {}
+};
+export {
+  defaultModalDialogDictionary as d,
+  getModalDialogComponentsDictionary as g
+};

package/components/modal/ModalDialog/index.js

@@ -0,0 +1,60 @@
+import { jsx } from "react/jsx-runtime";
+import { useTheme, Dialog, Paper } from "@mui/material";
+import Draggable from "react-draggable";
+import { u as useModal } from "../../../hooks/useModal/index.js";
+import { R as ResizableBox } from "../../extended/react-resizable/ResizableBox/ResizableBox.js";
+import { useIsMobile } from "@m4l/graphics";
+import { m as modalUtilityClasses } from "../classes/index.js";
+import { useState, useEffect } from "react";
+const DragabblePaperComponent = (props) => {
+  return /* @__PURE__ */ jsx(Draggable, { handle: ".m4l_draggable_handle", cancel: '[class*="MuiDialogContent-root"]', children: /* @__PURE__ */ jsx(Paper, { sx: { maxHeight: "unset", maxWidth: "unset" }, ...props }) });
+};
+function PaperComponent(props) {
+  return /* @__PURE__ */ jsx(Paper, { sx: { maxHeight: "unset", maxWidth: "unset", height: "100%" }, ...props });
+}
+const ModalDialog = () => {
+  const {
+    open,
+    initialWidth = 600,
+    initialHeigth = 400,
+    maxWidth,
+    maxHeigth,
+    window,
+    fullScreen,
+    variant
+  } = useModal();
+  const isMobile = useIsMobile();
+  const [fullScreenState, setFullScreenState] = useState(fullScreen);
+  useEffect(() => {
+    setFullScreenState(isMobile);
+  }, [isMobile]);
+  const theme = useTheme();
+  const classes = modalUtilityClasses({ variant });
+  const contentComnponent = /* @__PURE__ */ jsx("div", { className: classes.containerWindow, children: typeof window === "function" ? window() : window });
+  return /* @__PURE__ */ jsx(
+    Dialog,
+    {
+      open,
+      className: classes.root,
+      sx: { ...theme.components?.M4LModalDialog?.styleOverrides },
+      "aria-labelledby": "child-modal-title",
+      "aria-describedby": "child-modal-description",
+      PaperComponent: !isMobile ? DragabblePaperComponent : PaperComponent,
+      fullScreen: fullScreenState,
+      disableEnforceFocus: true,
+      children: !isMobile ? /* @__PURE__ */ jsx(
+        ResizableBox,
+        {
+          width: initialWidth,
+          height: initialHeigth,
+          maxWidth,
+          maxHeigth,
+          children: contentComnponent
+        }
+      ) : contentComnponent
+    }
+  );
+};
+export {
+  ModalDialog as M
+};