@m4l/core 2.0.25 → 2.0.26

package/contexts/AuthContext/AuthContext.js

@@ -1,122 +1,94 @@
-import { jsx as I } from "react/jsx-runtime";
-import { createContext as A, useReducer as D, useEffect as d } from "react";
-import { E as r } from "./constants.js";
-import { E as L } from "../../types/index.js";
-import { u as S } from "../../hooks/useHostTools/index.js";
-import { u as v } from "../../hooks/useNetwork/index.js";
-import { u as w } from "../../hooks/useEnvironment/index.js";
+import { jsx as C } from "react/jsx-runtime";
+import { createContext as U, useReducer as _, useEffect as f, useCallback as l } from "react";
+import { i as p, E as n } from "./constants.js";
+import { E as w } from "../../types/index.js";
+import { J as I } from "./helpers.js";
+import { u as L } from "../../hooks/useHostTools/index.js";
+import { u as P } from "../../hooks/useNetwork/index.js";
+import { u as x } from "../../hooks/useEnvironment/index.js";
 import { u as N } from "../../hooks/useLocalStorageWithListener/index.js";
-import { g as U } from "../../utils/getLocalStorage/index.js";
-import { s as u } from "../../utils/setLocalStorage/index.js";
-const _ = {
-  isAuthenticated: !1,
-  isInitialized: !1,
-  user: null
-}, C = (e, t) => {
-  switch (t.type) {
-    case "INITIALIZE":
-      return {
-        isAuthenticated: t.payload.isAuthenticated,
-        isInitialized: !0,
-        user: t.payload.user
-      };
-    case "LOGIN":
-      return {
-        ...e,
-        isAuthenticated: !0,
-        user: t.payload.user
-      };
-    case "LOGOUT":
-      return {
-        ...e,
-        isAuthenticated: !1,
-        user: null
-      };
-    default:
-      return e;
-  }
-}, O = A(null);
-function P(e) {
-  e({
-    type: r.Initial,
-    payload: {
-      isAuthenticated: !1,
-      user: null
-    }
-  });
-}
-function j(e) {
-  const { children: t } = e, [m, i] = D(C, _), { events_add_listener: f } = S(), { networkOperation: o } = v(), { domain_token: p } = w(), [h, l] = N(
+import { s as m } from "../../utils/setLocalStorage/index.js";
+import { g as k } from "../../utils/getLocalStorage/index.js";
+const z = U(null);
+function b(g) {
+  const { children: h, isMicroFrontEnd: o = !1, loggedUser: c } = g, [E, s] = _(I, o ? { ...p, user: c, isAuthenticated: !0, isInitialized: !0 } : p), { events_add_listener: T } = L(), { networkOperation: t } = P(), { domain_token: d } = x(), [y, r] = N(
     // Variable para saber si ha cambiado la session en otro navegador
     "vSession",
     (/* @__PURE__ */ new Date()).getTime() + ""
   );
-  d(() => {
-    (async () => {
-      o({
+  f(() => {
+    const e = async () => {
+      t({
         method: "GET",
         endPoint: "auth/login",
         parms: { user_data: !0 },
         checkUnAuthorized: !1,
         responseToCamelCase: !0
-      }).then((s) => {
-        i({
-          type: r.Initial,
+      }).then((a) => {
+        s({
+          type: n.Initial,
           payload: {
             isAuthenticated: !0,
-            user: s.user
+            user: a.user
           }
-        }), U("userData", {
-          email: s.user.email,
+        }), k("userData", {
+          email: a.user.email,
           remember: !0
-        })?.email !== s.user.email && u("userData", { email: s.user.email }, !0);
+        })?.email !== a.user.email && m("userData", { email: a.user.email }, !0);
       }).catch(() => {
-        P(i);
+        s({
+          type: n.Initial,
+          payload: {
+            isAuthenticated: !1,
+            user: null
+          }
+        });
       });
-    })();
-  }, [o, h]);
-  const g = async (a, s, n) => {
-    await o({
+    };
+    o || e();
+  }, [t, y, o, c]);
+  const D = l(async (e, a, i) => {
+    await t({
       endPoint: "auth/login",
       method: "POST",
       data: {
-        email: a,
-        password: s,
-        domain_token: p
+        email: e,
+        password: a,
+        domain_token: d
       },
       responseToCamelCase: !0
-    }).then((y) => {
-      const E = y.data;
-      n ? u("userData", { email: a, remember: n }) : u("userData", { email: "", remember: n }), i({
-        type: r.Login,
+    }).then((v) => {
+      const A = v.data;
+      i ? m("userData", { email: e, remember: i }) : m("userData", { email: "", remember: i }), s({
+        type: n.Login,
         payload: {
-          user: E
+          user: A
         }
-      }), l((/* @__PURE__ */ new Date()).getTime() + "");
+      }), r((/* @__PURE__ */ new Date()).getTime() + "");
     });
-  }, c = async (a) => {
-    a && await o({
+  }, [t, r, d]), u = l(async (e) => {
+    e && await t({
       endPoint: "auth/logout",
       method: "POST"
-    }), i({ type: r.Logout }), l((/* @__PURE__ */ new Date()).getTime() + "");
-  }, T = () => {
-    c(!1);
-  };
-  return d(function() {
-    f(L.EMMIT_EVENT_NET_SERVICE_UNAUTHORIZED, T);
-  }, []), /* @__PURE__ */ I(
-    O.Provider,
+    }), s({ type: n.Logout }), r((/* @__PURE__ */ new Date()).getTime() + "");
+  }, [t, r]), S = l(() => {
+    u(!1);
+  }, [u]);
+  return f(function() {
+    o || T(w.EMMIT_EVENT_NET_SERVICE_UNAUTHORIZED, S);
+  }, [o]), /* @__PURE__ */ C(
+    z.Provider,
     {
       value: {
-        ...m,
-        login: g,
-        logout: c
+        ...E,
+        login: D,
+        logout: u
       },
-      children: t
+      children: h
     }
   );
 }
 export {
-  O as A,
-  j as a
+  z as A,
+  b as a
 };

package/contexts/AuthContext/constants.d.ts

@@ -1,5 +1,7 @@
+import { AuthState } from './types';
 export declare enum EnumTypes {
     Initial = "INITIALIZE",
     Login = "LOGIN",
     Logout = "LOGOUT"
 }
+export declare const initialState: AuthState;

package/contexts/AuthContext/constants.js

@@ -1,4 +1,10 @@
-var L = /* @__PURE__ */ ((I) => (I.Initial = "INITIALIZE", I.Login = "LOGIN", I.Logout = "LOGOUT", I))(L || {});
+var t = /* @__PURE__ */ ((i) => (i.Initial = "INITIALIZE", i.Login = "LOGIN", i.Logout = "LOGOUT", i))(t || {});
+const a = {
+  isAuthenticated: !1,
+  isInitialized: !1,
+  user: null
+};
 export {
-  L as E
+  t as E,
+  a as i
 };

package/contexts/AuthContext/helpers.d.ts

@@ -0,0 +1,5 @@
+import { AuthState, SessionActions } from './types';
+/**
+ * Reducer para el contexto de autenticación
+ */
+export declare const JWTReducer: (state: AuthState, action: SessionActions) => AuthState;

package/contexts/AuthContext/helpers.js

@@ -0,0 +1,27 @@
+const r = (u, e) => {
+  switch (e.type) {
+    case "INITIALIZE":
+      return {
+        isAuthenticated: e.payload.isAuthenticated,
+        isInitialized: !0,
+        user: e.payload.user
+      };
+    case "LOGIN":
+      return {
+        ...u,
+        isAuthenticated: !0,
+        user: e.payload.user
+      };
+    case "LOGOUT":
+      return {
+        ...u,
+        isAuthenticated: !1,
+        user: null
+      };
+    default:
+      return u;
+  }
+};
+export {
+  r as J
+};

package/contexts/AuthContext/index.d.ts

@@ -1,2 +1,2 @@
 export * from './AuthContext';
-export type { UserAuth, AuthState } from './types';
+export type { UserAuth, AuthState, AuthUserType } from './types';

package/contexts/AuthContext/types.d.ts

@@ -21,6 +21,18 @@ export interface UserAuth {
 }
 export type AuthUserType = Maybe<UserAuth>;
 export type AuthProviderProps = {
+    /**
+     * isMicroFrontEnd: indica si la aplicación es un microfrontend
+     * default: false
+     */
+    isMicroFrontEnd?: boolean;
+    /**
+     * loggedUser: usuario de la aplicación, solo aplica para Microfrontends, porque se pasa la información del usuario directamente desde el host
+     */
+    loggedUser?: AuthUserType;
+    /**
+     * children: hijos del componente
+     */
     children: ReactNode;
 };
 export type ActionMap<M extends {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m4l/core",
-  "version": "2.0.25",
+  "version": "2.0.26",
   "license": "UNLICENSED",
   "author": "M4L Team",
   "publishConfig": {