@m4l/gclick 0.0.2

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

@@ -0,0 +1,113 @@
+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 { useModal, usePopupsStore, WindowConfirm } from "@m4l/components";
+import { shallow } from "zustand/shallow";
+import { G as GeofenceAddEdit } from "../../GeofenceAddEdit/index.js";
+import { u as useGpsMapToolsStore } from "../../../../../hooks/useGpsMapToolsStore/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 { addPopup } = usePopupsStore((state) => state.popupsActions, shallow);
+  const { hide } = usePopupsStore((state) => state.popupActions, shallow);
+  const { removeCheckedGeofence } = useGpsMapToolsStore((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) => {
+    hide("gpsTools");
+    addPopup({
+      winType: "component",
+      popupId: "geofencesAddEdit",
+      title: getLabel(MAP_GPSTOOLS_DICCTIONARY.MODULE_NAME_GEOFENCE_EDIT),
+      editionInfo: `${getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_ID)}:${objectId} - ${name} `,
+      componentProps: { fullRefresh, geofenceId: objectId },
+      component: 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,
+        initialHeight: 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({
+        type: "menuItem",
+        startIcon: urlIconEdit,
+        label: 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({
+        type: "menuItem",
+        startIcon: urlIconDelete,
+        label: MAP_GPSTOOLS_DICCTIONARY.ROW_ACTION_GEO_DELETE,
+        onClick: () => {
+          onDelete(row);
+        },
+        error: true,
+        // 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/GpsMapTools/subcomponents/TabsGpsTools/subcomponents/GeofencesList/index.d.ts

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

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

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

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

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

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

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

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

@@ -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/components/GpsMapTools/subcomponents/TabsGpsTools/subcomponents/model.d.ts

@@ -0,0 +1,114 @@
+import { GeofenceId } from '../../../contexts/GpsMapToolsContext/types';
+import { Feature, GeoJsonProperties, LineString, MultiLineString, MultiPoint, MultiPolygon, Point, Polygon } from '../../../../GpsMap/contexts/MapContext/types';
+/**
+ * Tipos de geometría compatibles con las geocercas
+ */
+export type GeofenceGeometry = Point | Polygon | MultiPolygon;
+/**
+ * Tipos de geometría Compatibles con las geocercas
+ */
+export type CrossingGeometry = Polygon | Point;
+/**
+ * Tipos de features de transtio soportados
+ */
+export type CrossingFeature = Feature<CrossingGeometry>;
+export type InternalGeometry = Point | Polygon | MultiPolygon | MultiPoint | LineString | MultiLineString;
+/**
+ * Tipos de features de transtio soportados
+ */
+export type InternalFeature = Feature<InternalGeometry>;
+export type GeofenceTypeId = 'gt_polygon' | 'gt_circle' | 'gt_rectangle';
+export type GeofenceType = {
+    id: GeofenceTypeId;
+    name: string;
+};
+/**
+ * Modelo de datos proveniente del endpoint get de geocercas
+ */
+export interface GeofenceGetModel {
+    /**
+     * id de la geocerca
+     */
+    id: GeofenceId;
+    /**
+     * "name" nombre dado por el cliente a la geocerca
+     */
+    name: string;
+    /**
+     * "active" si está activa o no lo geocerca
+     */
+    active: boolean;
+    /**
+     * "type" tipo de geocerca con idioma
+     */
+    type: GeofenceType;
+    /**
+     * "geometry" geometría de la geocerca compatible con GeoJSON
+     */
+    geometry: GeofenceGeometry;
+    /**
+     * "properties" propiedades de la geometria
+     */
+    properties: GeoJsonProperties;
+    /**
+     * timeMinInSeconds indica el tiempo mínimo para ingresar a una geocerca
+     */
+    timeMinInSeconds: number;
+    /**
+     * timeMinOutSeconds indica el tiempo mínimo para salir de una geocerca
+     */
+    timeMinOutSeconds: number;
+    /**
+     * "countCrossingFeatures" indica si la cantidad de features de cruce
+     */
+    countCrossingFeatures: number;
+    /**
+     * "countInternalFeatures" indica la cantidad de features internos que tiene la geocerca
+     */
+    countInternalFeatures: number;
+    /**
+     * "alias" alias de la geocerca, si no tiene es null y si tiene, es un string unico en todas las geocercas
+     */
+    alias?: string | null;
+    /**
+     * customerId indica el id del cliente al que pertenece la geocerca, si no tiene es null,
+     * si es de un cliente es un string unico en todas las geocercas
+     */
+    customerId?: string | null;
+    createdAt: string;
+    updatedAt: string | null;
+}
+interface AuthUserOptionsType {
+    activation: boolean;
+    delete: boolean;
+    edit: boolean;
+}
+/**
+ * Modelo de datos proveniente del endpoint list de geocercas
+ */
+export interface GeofenceListModel extends Omit<GeofenceGetModel, 'geometry'> {
+    /**
+     * "geometry" geometría de la geocerca compatible con GeoJSON
+     */
+    geometry: GeofenceGeometry | null;
+    authUserOptions: AuthUserOptionsType;
+}
+/**
+ * Modelo de datos para enviar al endpoint de creacion de geocercas
+ */
+export interface GeofenceNewModel extends Pick<GeofenceGetModel, 'name' | 'geometry' | 'properties' | 'timeMinInSeconds' | 'timeMinOutSeconds' | 'alias' | 'customerId'> {
+    /**
+     * "type" tipo de geocerca con idioma
+     */
+    typeId: GeofenceTypeId;
+}
+/**
+ * Modelo de datos para enviar al endpoint de creacion de geocercas
+ */
+export interface GeofenceEditModel extends GeofenceNewModel {
+    /**
+     * id de la geocerca
+     */
+    geofenceId: GeofenceId;
+}
+export {};

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

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

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

@@ -0,0 +1,34 @@
+import { GeofenceTypeId } from './subcomponents/TabsGpsTools/subcomponents/model';
+/**
+ * Por ahora solo distancia.
+ */
+export type MeasureTypeId = 'distance';
+export interface MeasureTypeItem {
+    id: MeasureTypeId;
+    name: string;
+}
+export interface MagnitudeFactorItem {
+    id: string;
+    name: string;
+    symbol: string;
+    factor_x0: number;
+    factor_x1: number;
+    factor_x2: number;
+}
+export interface GeofenceTypeItem {
+    id: GeofenceTypeId;
+    name: string;
+    url: string;
+}
+export interface StyleOpacity {
+    value: number;
+    label: string;
+}
+export interface StyleWheight {
+    value: number;
+    label: string;
+}
+export interface StyleDashArray {
+    value: string;
+    label: string;
+}

package/components/maps/index.d.ts

@@ -0,0 +1,4 @@
+export * from './components/GpsMap';
+export * from './utils';
+export type { MapProps, RendePropFeatureArgs, ComponentRenderPropFeature, FeatureId, FeatureCollection, Feature, Geometry, } from './components/GpsMap';
+export { GpsMapTools, useGpsMapToolsStore, GpsMapToolsProvider, getGpsMapToolsComponentsDictionary, } from './components/GpsMapTools';

package/components/maps/index.js

@@ -0,0 +1 @@
+

package/components/maps/utils/courseToCartesianAngle.d.ts

@@ -0,0 +1,6 @@
+/**
+ * "courseToCartesianAngle" convierte el rumbo del GPS a una rotación en grados cartesianos, recibiendo el rumbo
+ * en RAW sin transofrmaciones por parte de minitracker.
+ * Importante: NO ES compatible con minitracker v1.0 el cual  desplaza la medición 90 grados en complemento así: (450 - propiedadesEquipo->ultima_direccion) % 360
+ */
+export declare function courseToCartesianAngle(course: number): number;

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.d.ts

@@ -0,0 +1,9 @@
+/**
+ * "courseToCssAngle" convierte el rumbo del GPS a una rotación CSS, recibiendo el rumbo
+ * en RAW sin transofrmaciones por parte de minitracker.
+ * Importante: NO ES compatible con minitracker v1.0 el cual  desplaza la medición 90 grados en complemento así: (450 - propiedadesEquipo->ultima_direccion) % 360
+ * @param course
+ * @param offsetRotate (offset del icono como viene de la fuente con respecto al Norte (0 = grados) )
+ * @returns
+ */
+export declare function courseToCssAngle(course: number, offsetRotate: number): number;

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.d.ts

@@ -0,0 +1,6 @@
+export * from './courseToCartesianAngle';
+export * from './courseToCssAngle';
+export * from './isFeature';
+export * from './isFeatureCollection';
+export * from './isFeatureCollectionDraft';
+export * from './isGeometry';

package/components/maps/utils/index.js

@@ -0,0 +1 @@
+

package/components/maps/utils/isFeature.d.ts

@@ -0,0 +1,2 @@
+import { Feature } from '../components/GpsMap/contexts/MapContext/types';
+export declare function isFeature(obj: any): obj is Feature;

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.d.ts

@@ -0,0 +1,2 @@
+import { FeatureCollection } from '../components/GpsMap/contexts/MapContext/types';
+export declare function isFeatureCollection(obj: any): obj is FeatureCollection;

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.d.ts

@@ -0,0 +1,6 @@
+import { WritableDraft } from 'immer/dist/internal';
+import { FeatureCollection } from '../components/GpsMap/contexts/MapContext/types';
+/**
+ * TODO: Documentar
+ */
+export declare function isFeatureCollectionDraft(obj: any): obj is WritableDraft<FeatureCollection>;

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.d.ts

@@ -0,0 +1,2 @@
+import { Geometry } from '../components/GpsMap/contexts/MapContext/types';
+export declare function isGeometry(obj: any): obj is Geometry;

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/contexts/RealTimeConsumerContext/RealTimeConsumerContext.d.ts

@@ -0,0 +1,11 @@
+import { RealTimeProviderProps } from './types';
+declare const RealTimeConsumerContext: import('react').Context<import('zustand').StoreApi<import('./types').RealTimeConsumerStoreStateWithActions> | null>;
+/**
+ * Provedor del contexto de los realTimeas
+ * @returns
+ */
+/**
+ * TODO: Documentar
+ */
+declare function RealTimeConsumerProvider(props: RealTimeProviderProps): import("react/jsx-runtime").JSX.Element;
+export { RealTimeConsumerProvider, RealTimeConsumerContext };

package/contexts/RealTimeConsumerContext/RealTimeConsumerContext.js

@@ -0,0 +1,39 @@
+import { jsx } from "react/jsx-runtime";
+import { createContext, useRef, useEffect } from "react";
+import { c as createRealTimeStore } from "./store.js";
+import { useWindowToolsMF } from "@m4l/components";
+import { u as useRealTimeProducer } from "../../hooks/useRealTimeProducer/index.js";
+import { shallow } from "zustand/shallow";
+import { R as RESOURCE_TYPE_DEVICES } from "./constants.js";
+const RealTimeConsumerContext = createContext(null);
+function RealTimeConsumerProvider(props) {
+  const { children, onMessagesCallbacks = [], onSuscribeCallbacks = [], hasResourcesTypesDecorators = {}, storeDevtoolsEnabled = false, ...other } = props;
+  const { suscribe, unsuscribe } = useRealTimeProducer((state) => state.realTimeProducerActions, shallow);
+  const { getWindowId } = useWindowToolsMF();
+  const realTimeStoreRef = useRef();
+  if (!realTimeStoreRef.current) {
+    realTimeStoreRef.current = createRealTimeStore({
+      ...other,
+      storeId: getWindowId(),
+      hasResourcesTypesDecorators
+    }, storeDevtoolsEnabled);
+  }
+  useEffect(() => {
+    if (realTimeStoreRef.current) {
+      const { onMessages, loadResourceType } = realTimeStoreRef.current.getState().realTimeConsumerActions;
+      suscribe(RESOURCE_TYPE_DEVICES, {
+        clientId: getWindowId(),
+        onMessageCallbacks: [onMessages, ...onMessagesCallbacks],
+        onSuscribeCallbacks: [loadResourceType, ...onSuscribeCallbacks]
+      });
+      return () => {
+        unsuscribe("rt_devices", getWindowId());
+      };
+    }
+  }, [getWindowId, suscribe, unsuscribe, onMessagesCallbacks, onSuscribeCallbacks]);
+  return /* @__PURE__ */ jsx(RealTimeConsumerContext.Provider, { value: realTimeStoreRef.current, children });
+}
+export {
+  RealTimeConsumerContext as R,
+  RealTimeConsumerProvider as a
+};

package/contexts/RealTimeConsumerContext/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const PROCCESS_MESSAGES_INTERVAL = 1;
+export declare const RESOURCE_TYPE_DEVICES = "rt_devices";
+export declare const REALTIME_CONSUMER_SOTORE_ID = "M4LRealTimeConsumerStore";

package/contexts/RealTimeConsumerContext/constants.js

@@ -0,0 +1,8 @@
+const PROCCESS_MESSAGES_INTERVAL = 1;
+const RESOURCE_TYPE_DEVICES = "rt_devices";
+const REALTIME_CONSUMER_SOTORE_ID = "M4LRealTimeConsumerStore";
+export {
+  PROCCESS_MESSAGES_INTERVAL as P,
+  RESOURCE_TYPE_DEVICES as R,
+  REALTIME_CONSUMER_SOTORE_ID as a
+};

package/contexts/RealTimeConsumerContext/index.d.ts

@@ -0,0 +1,3 @@
+export * from './RealTimeConsumerContext';
+export type { RealTimeMessageDecorator } from './types';
+export { RESOURCE_TYPE_DEVICES } from './constants';

package/contexts/RealTimeConsumerContext/index.js

@@ -0,0 +1 @@
+

package/contexts/RealTimeConsumerContext/store.d.ts

@@ -0,0 +1,6 @@
+import { RealTimeConsumerStoreStateWithActions, InitialRealTimeStoreProps } from './types';
+/**
+ * TODO: Documentar
+ */
+export declare function createRealTimeStore(initProps: InitialRealTimeStoreProps, storeDevtoolsEnabled?: boolean): import('zustand').StoreApi<RealTimeConsumerStoreStateWithActions>;
+export type RealTimeStoreType = ReturnType<typeof createRealTimeStore>;