@m4l/layouts 0.1.14 → 0.1.15

package/contexts/AuthContext/index.59755369.js

@@ -0,0 +1,130 @@
+import { createContext as T, useReducer as y, useEffect as d } from "react";
+import { useHostTools as E, useNetwork as S, useEnvironment as v, useLocalStorageWithListener as N, EmitEvents as O, getLocalStorage as w, setLocalStorage as r } from "@m4l/core";
+import { jsx as D } from "react/jsx-runtime";
+var n = /* @__PURE__ */ ((e) => (e.Initial = "INITIALIZE", e.Login = "LOGIN", e.Logout = "LOGOUT", e))(n || {});
+const _ = {
+  isAuthenticated: !1,
+  isInitialized: !1,
+  user: null
+}, P = (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;
+  }
+}, x = T(null);
+function z(e) {
+  e({
+    type: n.Initial,
+    payload: {
+      isAuthenticated: !1,
+      user: null
+    }
+  });
+}
+function R(e) {
+  const {
+    children: t
+  } = e, [h, s] = y(P, _), {
+    events_add_listener: I
+  } = E(), {
+    networkOperation: u
+  } = S(), {
+    domain_token: m
+  } = v(), [f, l] = N(
+    "vSession",
+    new Date().getTime() + ""
+  );
+  d(() => {
+    (async () => {
+      u({
+        method: "GET",
+        endPoint: "auth/login",
+        parms: {
+          user_data: !0
+        },
+        checkUnAuthorized: !1
+      }).then((a) => {
+        s({
+          type: n.Initial,
+          payload: {
+            isAuthenticated: !0,
+            user: a.user
+          }
+        }), w("userData", {
+          email: a.user.email,
+          remember: !0
+        })?.email !== a.user.email && r("userData", {
+          email: a.user.email
+        }, !0);
+      }).catch(() => {
+        z(s);
+      });
+    })();
+  }, [f]);
+  const g = async (i, a, o) => {
+    await u({
+      endPoint: "auth/login",
+      method: "POST",
+      data: {
+        email: i,
+        password: a,
+        domain_token: m
+      }
+    }).then((A) => {
+      const L = A.data;
+      o ? r("userData", {
+        email: i,
+        remember: o
+      }) : r("userData", {
+        email: "",
+        remember: o
+      }), s({
+        type: n.Login,
+        payload: {
+          user: L
+        }
+      }), l(new Date().getTime() + "");
+    });
+  }, c = async (i) => {
+    i && await u({
+      endPoint: "auth/logout",
+      method: "POST"
+    }), s({
+      type: n.Logout
+    }), l(new Date().getTime() + "");
+  }, p = () => {
+    c(!1);
+  };
+  return d(() => {
+    I(O.EMMIT_EVENT_NET_SERVICE_UNAUTHORIZED, p);
+  }, []), /* @__PURE__ */ D(x.Provider, {
+    value: {
+      ...h,
+      login: g,
+      logout: c
+    },
+    children: t
+  });
+}
+export {
+  x as A,
+  R as a
+};

package/contexts/AuthContext/index.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import type { AuthProviderProps, SessionContextType } from './types';
+declare const AuthContext: import("react").Context<SessionContextType | null>;
+declare function AuthProvider(props: AuthProviderProps): JSX.Element;
+export { AuthContext, AuthProvider };

package/contexts/AuthContext/types.d.ts

@@ -0,0 +1,54 @@
+import { Maybe } from '@m4l/core';
+import { ReactNode } from 'react';
+export declare enum EnumTypes {
+    Initial = "INITIALIZE",
+    Login = "LOGIN",
+    Logout = "LOGOUT"
+}
+export declare type AuthProviderProps = {
+    children: ReactNode;
+};
+export declare type ActionMap<M extends {
+    [index: string]: any;
+}> = {
+    [Key in keyof M]: M[Key] extends undefined ? {
+        type: Key;
+    } : {
+        type: Key;
+        payload: M[Key];
+    };
+};
+export declare type SessionAuthPayload = {
+    [EnumTypes.Initial]: {
+        isAuthenticated: boolean;
+        user: AuthUser;
+    };
+    [EnumTypes.Login]: {
+        user: AuthUser;
+    };
+    [EnumTypes.Logout]: undefined;
+};
+export declare type SessionActions = ActionMap<SessionAuthPayload>[keyof ActionMap<SessionAuthPayload>];
+export declare type AuthStoreState = {
+    user: User;
+    remember?: boolean;
+};
+export interface User {
+    email: string;
+    id: number;
+    first_name: string;
+    last_name: string;
+    account_id: number;
+    domain_country_id: number;
+    avatar_url?: Maybe<string>;
+}
+export declare type AuthUser = Maybe<User>;
+export declare type AuthState = {
+    isAuthenticated: boolean;
+    isInitialized: boolean;
+    user: AuthUser;
+};
+export interface SessionContextType extends AuthState {
+    login: (email: string, password: string, remember: boolean) => object | undefined;
+    logout: (isAuthenticated: boolean) => Promise<void>;
+}

package/contexts/index.d.ts

@@ -0,0 +1 @@
+export * from './AuthContext';

package/hooks/index.d.ts

@@ -1,2 +1,3 @@
 export * from './useMasterDetail';
+export * from './useAuth';
 export * from './useModule';

package/hooks/useAuth/index.ae68bf71.js

@@ -0,0 +1,11 @@
+import { useContext as o } from "react";
+import { A as e } from "../../contexts/AuthContext/index.59755369.js";
+const n = () => {
+  const t = o(e);
+  if (!t)
+    throw new Error("Auth context must be use inside AuthProvider");
+  return t;
+};
+export {
+  n as u
+};

package/hooks/useAuth/index.d.ts

@@ -0,0 +1,2 @@
+export declare const useAuth: () => import("../../contexts/AuthContext/types").SessionContextType;
+export default useAuth;

package/index.d.ts

@@ -1,2 +1,3 @@
+export * from './contexts';
 export * from './layouts';
 export * from './hooks';

package/index.js

@@ -1,25 +1,30 @@
-import { a as p, d as l, g as y } from "./layouts/ModuleLayout/index.842072c5.js";
+import { A as p, a as d } from "./contexts/AuthContext/index.59755369.js";
+import { a as y, d as n, g as M } from "./layouts/ModuleLayout/index.842072c5.js";
 import "@m4l/components";
 import "react";
 import "@m4l/core";
-import { a as n, d as M, g as D } from "./layouts/MasterDetailLayout/index.71de0dc7.js";
+import { a as D, d as x, g as L } from "./layouts/MasterDetailLayout/index.71de0dc7.js";
 import "@m4l/graphics";
 import "@mui/material";
 import "react/jsx-runtime";
-import { N as L, d as c, g } from "./layouts/NoAuthModuleLayout/index.5d1098ef.js";
+import { N as c, d as g, g as h } from "./layouts/NoAuthModuleLayout/index.5d1098ef.js";
 import { u as N } from "./hooks/useMasterDetail/index.8e9e900b.js";
-import { u as A } from "./hooks/useModule/index.096d7d13.js";
+import { u as P } from "./hooks/useAuth/index.ae68bf71.js";
+import { u as j } from "./hooks/useModule/index.096d7d13.js";
 import "@mui/material/styles";
 export {
-  n as MasterDetailLayout,
-  p as ModuleLayout,
-  L as NoAuthModuleLayout,
-  M as defaultMasterDetailDictionary,
-  l as defaultModuleLayoutDictionary,
-  c as defaultNoAuthModuleLayoutDictionary,
-  D as getMasterDetailLayoutComponentsDictionary,
-  y as getModuleLayoutComponentsDictionary,
-  g as getNoAuthModuleLayoutComponentsDictionary,
+  p as AuthContext,
+  d as AuthProvider,
+  D as MasterDetailLayout,
+  y as ModuleLayout,
+  c as NoAuthModuleLayout,
+  x as defaultMasterDetailDictionary,
+  n as defaultModuleLayoutDictionary,
+  g as defaultNoAuthModuleLayoutDictionary,
+  L as getMasterDetailLayoutComponentsDictionary,
+  M as getModuleLayoutComponentsDictionary,
+  h as getNoAuthModuleLayoutComponentsDictionary,
+  P as useAuth,
   N as useMasterDetail,
-  A as useModule
+  j as useModule
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m4l/layouts",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "license": "UNLICENSED",
   "dependencies": {
     "@m4l/components": "*",