@dashadmin/dash-admin 1.3.24 → 1.3.26

package/dist/contexts/auth/AuthContext.js

@@ -1 +1,396 @@
-var z=Object.defineProperty;var D=(r,i,e)=>i in r?z(r,i,{enumerable:!0,configurable:!0,writable:!0,value:e}):r[i]=e;var b=(r,i,e)=>D(r,typeof i!="symbol"?i+"":i,e);import{jsx as Q}from"react/jsx-runtime";import{useDispatch as J,useSelector as M}from"react-redux";import g,{useCallback as l,useContext as K,useRef as m}from"react";import{DASH_REDUX_ACTIONS as h}from"@dashadmin/dash-admin-state";import{ACTION_UPDATE_AUTH as A}from"@dashadmin/dash-admin-state/src/redux/reducers/Auth";import q from"../../hooks/axios";import{getEnv as G}from"@dashadmin/dash-constants/src/DASHAdminSystemConstants";import{useDashThemeContext as $}from"../../../src/default-theme/DashThemeContext";import f from"../../theme/AppLayoutSetting";import B from"./DASHAuthenticationService";import{AuthPersistenceService as o,clearDeviceStoreAuth as W}from"@dashadmin/dash-auth";import{dashStorage as I}from"@dashadmin/dash-utils";class X{}b(X,"values");const S=g.createContext(null),vt=r=>{const{children:i}=r,e=M(t=>t.auth),u=J(),{axios:C}=q(),{recreateTheme:F}=$(),v=m(!1),T=m(""),V=m(""),E=m(""),k=m(""),Z=m(!1),[n,p]=g.useState(()=>{const t=o.getUser(),s=o.getToken(),a=o.getSystemValues(),c=JSON.parse(I.getItem("authenticated")||"false");return{authenticated:e.authenticated||c,user:e.user||t,auth:e.auth,token:e.user?.token||s,roles:e.user?.roles,systemValues:a}}),d=l(async()=>{console.log("Making GET request to:",G("APP_GETAUTH_ENDPOINT"));try{const{data:t}=await C.get(G("APP_GETAUTH_ENDPOINT"));return console.log("Received complete auth data:",t),o.saveAuth({auth:t.auth,systemValues:t.systemValues}),u(h.updateAuth(A,{user:t.user,authenticated:!0,auth:t.auth})),p(s=>({...s,systemValues:t.systemValues})),t}catch(t){throw console.error("Error fetching complete auth data:",t),o.markAsLoggedOut(),t}},[C,u]),tt=l(async()=>{const t=o.getToken(),s=o.getUser(),a=JSON.parse(I.getItem("authenticated")||"false");if(console.log("Initializing auth from token:",{hasToken:!!t,hasStoredUser:!!s,isAuthenticated:a,reduxAuthenticated:e.authenticated}),t&&!e.authenticated)try{console.log("Token found but not fully authenticated, fetching complete auth data..."),await d()}catch(c){console.error("Failed to initialize auth from token:",c),o.markAsLoggedOut()}else if(a&&s&&t&&!e.authenticated){console.log("Restoring auth session from localStorage");const c=o.getAuth();u(h.updateAuth(A,{user:s,authenticated:!0,auth:c?.auth||null}))}},[e.authenticated,u,d]),_=l(async t=>{if(!t||e.authenticated||v.current)return;const s=JSON.stringify(t);if(T.current!==s){v.current=!0,T.current=s,console.log("Handling react-admin identity:",t);try{u(h.updateAuth(A,{user:t.user||t,authenticated:t?.user?!0:!!t?.id,auth:t.auth})),await d()}catch{console.error("Failed to fetch complete auth data after identity load")}finally{v.current=!1}}},[e.authenticated,u,d]),U=async t=>{o.markAsLoggedOut(),await W(),B.setPendingRedirect(window.location.pathname),p({authenticated:!1,user:null,auth:null,token:null,roles:null,systemValues:null}),u(h.updateAuth(A,{user:null,authenticated:!1,auth:null})),j({authenticated:!1,user:null,auth:null,token:null,roles:null,systemValues:null}),document.body.classList.remove(f.LAYOUT_TYPE_FULL,f.LAYOUT_TYPE_BOXED,f.LAYOUT_TYPE_FRAMED,f.THEME_TYPE_DARK,f.THEME_TYPE_LIGHT),t&&t()},O=l(t=>{if(t&&(console.log("\u{1F504} AuthContext: Updating auth context with:",t),p(s=>{const a={...s,...t};return console.log("\u2705 AuthContext: Local context updated:",a),a}),(t.authenticated!==void 0||t.user||t.auth)&&t.authenticated!==!1)){console.log("\u{1F504} AuthContext: Dispatching to Redux state...");const s={user:t.user||e.user,authenticated:t.authenticated??e.authenticated,auth:t.auth||e.auth};console.log("\u{1F504} AuthContext: Redux payload:",s),u(h.updateAuth(A,s)),console.log("\u2705 AuthContext: Redux dispatch completed")}},[u,e.user,e.authenticated,e.auth]),R=l(t=>{console.log("Manual update values called with:",t),p(s=>({...s,...t}))},[]),w=l(()=>{try{if(n.roles==="guest")return Promise.resolve("guest");if(n.roles&&Array.isArray(n.roles)){const t={roles:n.roles.map(s=>typeof s=="string"?s:s.name)};return Promise.resolve(t)}if(e.user?.roles&&Array.isArray(e.user.roles)){const t={roles:e.user.roles.map(s=>typeof s=="string"?s:s.name)};return Promise.resolve(t)}return o.getPermissions()}catch(t){return console.error("Failed to get permissions from context:",t),Promise.resolve("null")}},[n.roles,e.user?.roles]),y=l(()=>n.systemValues||o.getSystemValues(),[n.systemValues]),P=l(t=>{const s=y();return s?s[t]:null},[y]),L=l(()=>P("point_of_sales"),[P]);g.useEffect(()=>{const t=s=>{console.log("Auth event received:",s.detail),O(s.detail)};return window.addEventListener("authEvent",t),()=>{window.removeEventListener("authEvent",t)}},[O]),g.useEffect(()=>{if(console.log("Redux auth state changed:",{authenticated:e.authenticated,user:!!e.user,auth:!!e.auth}),e.authenticated){let t=e?.auth?.tenantImages,s=e?.auth?.tenantSettings,a=n.systemValues;t||(t=o.getTenantImages()),s||(s=o.getTenantSettings()),a||(a=o.getSystemValues());const c=JSON.stringify(t);if(t&&V.current!==c){console.log("Updating panel settings with tenant images from auth context or persisted data"),V.current=c;const x={...t.horizontal_logo.original&&{horizontalLogo:t.horizontal_logo.original},...t.squared_logo.original&&{squaredLogo:t.squared_logo.original},...t.banner.original&&{loginBackground:t.banner.original}};u(h.setPanelSettings(x))}const H=JSON.stringify(s);s&&E.current!==H&&(console.log("Recreating MUI theme with tenant settings from auth context"),E.current=H,F(s),u(h.updateThemeSettings(s)));const N=JSON.stringify(a);if(a&&k.current!==N&&(console.log("Processing system values from auth context or persisted data"),k.current=N,console.log("Available system values:",Object.keys(a)),console.log("Point of Sales:",a.point_of_sales)),JSON.parse(I.getItem("authenticated")||"false")&&e.user?.tenant_id){const{DashIPCService:x}=window;x&&x.action("start-bg-service",{token:I.getItem("token"),channel:`private-tenant.${e.user.tenant_id}.system`})}}},[e.authenticated,n.systemValues]),g.useEffect(()=>{console.log("Auth context values changed:",{authenticated:n.authenticated,user:n.user?`${n.user.name} (${n.user.id})`:null,auth:n.auth,token:n.token?"present":"missing",systemValues:n.systemValues?Object.keys(n.systemValues):null})},[n]);const Y=g.useMemo(()=>{const t=n.user||e.user||o.getUser(),s=n.authenticated??e.authenticated??!1,a=n.token||e.user?.token||o.getToken();return{user:t,authenticated:s,auth:n.auth||e.auth,token:a,roles:n.roles||e.user?.roles,systemValues:n.systemValues||o.getSystemValues(),updateValues:R,logout:U,handleReactAdminIdentity:_,getPermissions:w,fetchAuth:d,getSystemValues:y,getSystemValue:P,getPointOfSales:L}},[n,e,R,U,_,w,d,y,P,L]);return Q(S.Provider,{value:Y,children:i})},Ct=S.Consumer,Tt=()=>K(S),j=r=>(console.log("Setting auth event:",r),window.dispatchEvent(new CustomEvent("authEvent",{detail:r})),r),Vt=()=>o.getPermissions();var Et=S;export{S as AuthContext,X as AuthContextClass,Ct as AuthContextConsumer,vt as AuthContextProvider,Et as default,Vt as getAuthPermissions,j as setAuthEvent,Tt as useAuthContext};
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { jsx } from "react/jsx-runtime";
+import { useDispatch, useSelector } from "react-redux";
+import React, {
+  useCallback,
+  useContext,
+  useRef
+} from "react";
+import { DASH_REDUX_ACTIONS } from "dash-admin-state";
+import { ACTION_UPDATE_AUTH } from "dash-admin-state/src/redux/reducers/Auth";
+import useAxios from "../../hooks/axios";
+import { getEnv } from "dash-constants/src/DASHAdminSystemConstants";
+import { useDashThemeContext } from "../../default-theme/DashThemeContext";
+import AppLayoutSettings from "../../theme/AppLayoutSetting";
+import DASHAuthenticationService from "./DASHAuthenticationService";
+import { AuthPersistenceService, clearDeviceStoreAuth } from "dash-auth";
+import { dashStorage } from "dash-utils";
+class AuthContextClass {
+}
+__publicField(AuthContextClass, "values");
+const AuthContext = React.createContext(null);
+const AuthContextProvider = (props) => {
+  var _a;
+  const { children } = props;
+  const auth = useSelector((state) => state.auth);
+  const dispatch = useDispatch();
+  const { axios } = useAxios();
+  const { recreateTheme } = useDashThemeContext();
+  const isHandlingIdentityRef = useRef(false);
+  const lastIdentityRef = useRef("");
+  const lastTenantImagesRef = useRef("");
+  const lastTenantSettingsRef = useRef("");
+  const lastSystemValuesRef = useRef("");
+  const hasInitializedRef = useRef(false);
+  const [contextValues, setContextValues] = React.useState(() => {
+    var _a2, _b;
+    const storedUser = AuthPersistenceService.getUser();
+    const storedToken = AuthPersistenceService.getToken();
+    const storedSystemValues = AuthPersistenceService.getSystemValues();
+    const isAuthenticated = JSON.parse(dashStorage.getItem("authenticated") || "false");
+    return {
+      authenticated: auth.authenticated || isAuthenticated,
+      user: auth.user || storedUser,
+      auth: auth.auth,
+      token: ((_a2 = auth.user) == null ? void 0 : _a2.token) || storedToken,
+      roles: (_b = auth.user) == null ? void 0 : _b.roles,
+      systemValues: storedSystemValues
+    };
+  });
+  const fetchCompleteAuth = useCallback(() => __async(null, null, function* () {
+    console.log("Making GET request to:", getEnv("APP_GETAUTH_ENDPOINT"));
+    try {
+      const { data: authResponse } = yield axios.get(getEnv("APP_GETAUTH_ENDPOINT"));
+      console.log("Received complete auth data:", authResponse);
+      AuthPersistenceService.saveAuth({
+        auth: authResponse.auth,
+        systemValues: authResponse.systemValues
+      });
+      dispatch(
+        DASH_REDUX_ACTIONS.updateAuth(ACTION_UPDATE_AUTH, {
+          user: authResponse.user,
+          authenticated: true,
+          auth: authResponse.auth
+        })
+      );
+      setContextValues((prev) => __spreadProps(__spreadValues({}, prev), {
+        systemValues: authResponse.systemValues
+      }));
+      return authResponse;
+    } catch (error) {
+      console.error("Error fetching complete auth data:", error);
+      AuthPersistenceService.markAsLoggedOut();
+      throw error;
+    }
+  }), [axios, dispatch]);
+  const initializeAuthFromToken = useCallback(() => __async(null, null, function* () {
+    const token = AuthPersistenceService.getToken();
+    const storedUser = AuthPersistenceService.getUser();
+    const isAuthenticated = JSON.parse(dashStorage.getItem("authenticated") || "false");
+    console.log("Initializing auth from token:", {
+      hasToken: !!token,
+      hasStoredUser: !!storedUser,
+      isAuthenticated,
+      reduxAuthenticated: auth.authenticated
+    });
+    if (token && !auth.authenticated) {
+      try {
+        console.log("Token found but not fully authenticated, fetching complete auth data...");
+        yield fetchCompleteAuth();
+      } catch (error) {
+        console.error("Failed to initialize auth from token:", error);
+        AuthPersistenceService.markAsLoggedOut();
+      }
+    } else if (isAuthenticated && storedUser && token && !auth.authenticated) {
+      console.log("Restoring auth session from localStorage");
+      const persistedAuth = AuthPersistenceService.getAuth();
+      dispatch(
+        DASH_REDUX_ACTIONS.updateAuth(ACTION_UPDATE_AUTH, {
+          user: storedUser,
+          authenticated: true,
+          auth: (persistedAuth == null ? void 0 : persistedAuth.auth) || null
+        })
+      );
+    }
+  }), [auth.authenticated, dispatch, fetchCompleteAuth]);
+  const handleReactAdminIdentity = useCallback((identity) => __async(null, null, function* () {
+    if (!identity || auth.authenticated || isHandlingIdentityRef.current) {
+      return;
+    }
+    const identityKey = JSON.stringify(identity);
+    if (lastIdentityRef.current === identityKey) {
+      return;
+    }
+    isHandlingIdentityRef.current = true;
+    lastIdentityRef.current = identityKey;
+    console.log("Handling react-admin identity:", identity);
+    try {
+      dispatch(
+        DASH_REDUX_ACTIONS.updateAuth(ACTION_UPDATE_AUTH, {
+          user: identity.user || identity,
+          authenticated: (identity == null ? void 0 : identity.user) ? true : (identity == null ? void 0 : identity.id) ? true : false,
+          auth: identity.auth
+        })
+      );
+      yield fetchCompleteAuth();
+    } catch (error) {
+      console.error("Failed to fetch complete auth data after identity load");
+    } finally {
+      isHandlingIdentityRef.current = false;
+    }
+  }), [auth.authenticated, dispatch, fetchCompleteAuth]);
+  const logout = (callback) => __async(null, null, function* () {
+    AuthPersistenceService.markAsLoggedOut();
+    yield clearDeviceStoreAuth();
+    DASHAuthenticationService.setPendingRedirect(window.location.pathname);
+    setContextValues({
+      authenticated: false,
+      user: null,
+      auth: null,
+      token: null,
+      roles: null,
+      systemValues: null
+    });
+    dispatch(
+      DASH_REDUX_ACTIONS.updateAuth(ACTION_UPDATE_AUTH, {
+        user: null,
+        authenticated: false,
+        auth: null
+      })
+    );
+    setAuthEvent({
+      authenticated: false,
+      user: null,
+      auth: null,
+      token: null,
+      roles: null,
+      systemValues: null
+    });
+    document.body.classList.remove(
+      AppLayoutSettings.LAYOUT_TYPE_FULL,
+      AppLayoutSettings.LAYOUT_TYPE_BOXED,
+      AppLayoutSettings.LAYOUT_TYPE_FRAMED,
+      AppLayoutSettings.THEME_TYPE_DARK,
+      AppLayoutSettings.THEME_TYPE_LIGHT
+    );
+    if (callback) {
+      callback();
+    }
+  });
+  const updateAuth = useCallback((authData) => {
+    var _a2;
+    if (authData) {
+      console.log("\u{1F504} AuthContext: Updating auth context with:", authData);
+      setContextValues((prevValues) => {
+        const newValues = __spreadValues(__spreadValues({}, prevValues), authData);
+        console.log("\u2705 AuthContext: Local context updated:", newValues);
+        return newValues;
+      });
+      if ((authData.authenticated !== void 0 || authData.user || authData.auth) && authData.authenticated !== false) {
+        console.log("\u{1F504} AuthContext: Dispatching to Redux state...");
+        const reduxPayload = {
+          user: authData.user || auth.user,
+          authenticated: (_a2 = authData.authenticated) != null ? _a2 : auth.authenticated,
+          auth: authData.auth || auth.auth
+        };
+        console.log("\u{1F504} AuthContext: Redux payload:", reduxPayload);
+        dispatch(
+          DASH_REDUX_ACTIONS.updateAuth(ACTION_UPDATE_AUTH, reduxPayload)
+        );
+        console.log("\u2705 AuthContext: Redux dispatch completed");
+      }
+    }
+  }, [dispatch, auth.user, auth.authenticated, auth.auth]);
+  const updateValues = useCallback((authData) => {
+    console.log("Manual update values called with:", authData);
+    setContextValues((prevValues) => __spreadValues(__spreadValues({}, prevValues), authData));
+  }, []);
+  const getPermissions = useCallback(() => {
+    var _a2;
+    try {
+      if (contextValues.roles === "guest") {
+        return Promise.resolve("guest");
+      }
+      if (contextValues.roles && Array.isArray(contextValues.roles)) {
+        const processedPermissions = {
+          roles: contextValues.roles.map(
+            (item) => typeof item === "string" ? item : item.name
+          )
+        };
+        return Promise.resolve(processedPermissions);
+      }
+      if (((_a2 = auth.user) == null ? void 0 : _a2.roles) && Array.isArray(auth.user.roles)) {
+        const processedPermissions = {
+          roles: auth.user.roles.map(
+            (item) => typeof item === "string" ? item : item.name
+          )
+        };
+        return Promise.resolve(processedPermissions);
+      }
+      return AuthPersistenceService.getPermissions();
+    } catch (error) {
+      console.error("Failed to get permissions from context:", error);
+      return Promise.resolve("null");
+    }
+  }, [contextValues.roles, (_a = auth.user) == null ? void 0 : _a.roles]);
+  const getSystemValues = useCallback(() => {
+    return contextValues.systemValues || AuthPersistenceService.getSystemValues();
+  }, [contextValues.systemValues]);
+  const getSystemValue = useCallback((key) => {
+    const systemValues = getSystemValues();
+    return systemValues ? systemValues[key] : null;
+  }, [getSystemValues]);
+  const getPointOfSales = useCallback(() => {
+    return getSystemValue("point_of_sales");
+  }, [getSystemValue]);
+  React.useEffect(() => {
+    const handleAuthEvent = (event) => {
+      console.log("Auth event received:", event.detail);
+      updateAuth(event.detail);
+    };
+    window.addEventListener("authEvent", handleAuthEvent);
+    return () => {
+      window.removeEventListener("authEvent", handleAuthEvent);
+    };
+  }, [updateAuth]);
+  React.useEffect(() => {
+    var _a2, _b, _c;
+    console.log("Redux auth state changed:", {
+      authenticated: auth.authenticated,
+      user: !!auth.user,
+      auth: !!auth.auth
+    });
+    if (auth.authenticated) {
+      let tenantImages = (_a2 = auth == null ? void 0 : auth.auth) == null ? void 0 : _a2.tenantImages;
+      let tenantSettings = (_b = auth == null ? void 0 : auth.auth) == null ? void 0 : _b.tenantSettings;
+      let systemValues = contextValues.systemValues;
+      if (!tenantImages) {
+        tenantImages = AuthPersistenceService.getTenantImages();
+      }
+      if (!tenantSettings) {
+        tenantSettings = AuthPersistenceService.getTenantSettings();
+      }
+      if (!systemValues) {
+        systemValues = AuthPersistenceService.getSystemValues();
+      }
+      const tenantImagesKey = JSON.stringify(tenantImages);
+      if (tenantImages && lastTenantImagesRef.current !== tenantImagesKey) {
+        console.log("Updating panel settings with tenant images from auth context or persisted data");
+        lastTenantImagesRef.current = tenantImagesKey;
+        const logos = __spreadValues(__spreadValues(__spreadValues({}, tenantImages.horizontal_logo.original && { horizontalLogo: tenantImages.horizontal_logo.original }), tenantImages.squared_logo.original && { squaredLogo: tenantImages.squared_logo.original }), tenantImages.banner.original && { loginBackground: tenantImages.banner.original });
+        dispatch(
+          DASH_REDUX_ACTIONS.setPanelSettings(logos)
+        );
+      }
+      const tenantSettingsKey = JSON.stringify(tenantSettings);
+      if (tenantSettings && lastTenantSettingsRef.current !== tenantSettingsKey) {
+        console.log("Recreating MUI theme with tenant settings from auth context");
+        lastTenantSettingsRef.current = tenantSettingsKey;
+        recreateTheme(tenantSettings);
+        dispatch(
+          DASH_REDUX_ACTIONS.updateThemeSettings(tenantSettings)
+        );
+      }
+      const systemValuesKey = JSON.stringify(systemValues);
+      if (systemValues && lastSystemValuesRef.current !== systemValuesKey) {
+        console.log("Processing system values from auth context or persisted data");
+        lastSystemValuesRef.current = systemValuesKey;
+        console.log("Available system values:", Object.keys(systemValues));
+        console.log("Point of Sales:", systemValues.point_of_sales);
+      }
+      const storageAuthenticated = JSON.parse(dashStorage.getItem("authenticated") || "false");
+      if (storageAuthenticated && ((_c = auth.user) == null ? void 0 : _c.tenant_id)) {
+        const { DashIPCService } = window;
+        DashIPCService && DashIPCService.action("start-bg-service", {
+          token: dashStorage.getItem("token"),
+          channel: `private-tenant.${auth.user.tenant_id}.system`
+        });
+      }
+    }
+  }, [auth.authenticated, contextValues.systemValues]);
+  React.useEffect(() => {
+    console.log("Auth context values changed:", {
+      authenticated: contextValues.authenticated,
+      user: contextValues.user ? `${contextValues.user.name} (${contextValues.user.id})` : null,
+      auth: contextValues.auth,
+      token: contextValues.token ? "present" : "missing",
+      systemValues: contextValues.systemValues ? Object.keys(contextValues.systemValues) : null
+    });
+  }, [contextValues]);
+  const contextValue = React.useMemo(() => {
+    var _a2, _b, _c, _d;
+    const currentUser = contextValues.user || auth.user || AuthPersistenceService.getUser();
+    const currentAuthenticated = (_b = (_a2 = contextValues.authenticated) != null ? _a2 : auth.authenticated) != null ? _b : false;
+    const currentToken = contextValues.token || ((_c = auth.user) == null ? void 0 : _c.token) || AuthPersistenceService.getToken();
+    return {
+      user: currentUser,
+      authenticated: currentAuthenticated,
+      auth: contextValues.auth || auth.auth,
+      token: currentToken,
+      roles: contextValues.roles || ((_d = auth.user) == null ? void 0 : _d.roles),
+      systemValues: contextValues.systemValues || AuthPersistenceService.getSystemValues(),
+      updateValues,
+      logout,
+      handleReactAdminIdentity,
+      getPermissions,
+      fetchAuth: fetchCompleteAuth,
+      getSystemValues,
+      getSystemValue,
+      getPointOfSales
+    };
+  }, [contextValues, auth, updateValues, logout, handleReactAdminIdentity, getPermissions, fetchCompleteAuth, getSystemValues, getSystemValue, getPointOfSales]);
+  return /* @__PURE__ */ jsx(AuthContext.Provider, { value: contextValue, children });
+};
+const AuthContextConsumer = AuthContext.Consumer;
+const useAuthContext = () => {
+  const authContext = useContext(AuthContext);
+  return authContext;
+};
+const setAuthEvent = (values) => {
+  console.log("Setting auth event:", values);
+  window.dispatchEvent(new CustomEvent("authEvent", { detail: values }));
+  return values;
+};
+const getAuthPermissions = () => {
+  return AuthPersistenceService.getPermissions();
+};
+var AuthContext_default = AuthContext;
+export {
+  AuthContext,
+  AuthContextClass,
+  AuthContextConsumer,
+  AuthContextProvider,
+  AuthContext_default as default,
+  getAuthPermissions,
+  setAuthEvent,
+  useAuthContext
+};

package/dist/contexts/auth/AuthContextLocalStorage.js

@@ -1 +1,118 @@
-var d=Object.defineProperty;var A=(t,e,r)=>e in t?d(t,e,{enumerable:!0,configurable:!0,writable:!0,value:r}):t[e]=r;var h=(t,e,r)=>A(t,typeof e!="symbol"?e+"":e,r);import{jsx as V}from"react/jsx-runtime";import P from"../../hooks/useLocalStorage";import I,{useContext as S,useState as f,useEffect as g}from"react";import{dashStorage as o}from"@dashadmin/dash-utils";class m{}h(m,"values");const n={authenticated:!1,user:null,auth:null,token:null,roles:null},a=I.createContext(null),U=t=>{const{children:e,values:r}=t,[x,u]=f(r||n),[i,c]=P("SerializedAuthContext",JSON.stringify(r||n));g(()=>{try{const s=typeof i=="string"?JSON.parse(i):i;u(s||n)}catch(s){console.error("Error parsing auth context from localStorage:",s),u(n)}},[]);const p=s=>{u(C=>{const l={...C,...s};return c(JSON.stringify(l)),l})};return V(a.Provider,{value:{...x,updateValues:p},children:e})},W=a.Consumer,b=()=>S(a),y=()=>{try{const t=o.getItem("SerializedAuthContext");return t?JSON.parse(t):n}catch(t){return console.error("Error getting auth context:",t),n}},R=t=>{try{const r={...y(),...t};return o.setItem("SerializedAuthContext",JSON.stringify(r)),r}catch(e){return console.error("Error updating auth context:",e),t}},q=t=>{try{return o.setItem("SerializedAuthContext",JSON.stringify(t)),o.setItem("roles",JSON.stringify(t.user.roles)),o.setItem("authenticated","true"),o.setItem("user",JSON.stringify(t.user)),t}catch(e){return console.error("Error setting auth context:",e),t}};var w=a;export{m as AuthContextClass,W as AuthContextConsumer,a as AuthContextLocalStorage,U as AuthContextProvider,w as default,y as getAuthContext,q as setAuthContext,R as updateAuthContext,b as useAuthContext};
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { jsx } from "react/jsx-runtime";
+import useLocalStorage from "../../hooks/useLocalStorage";
+import React, {
+  useContext,
+  useState,
+  useEffect
+} from "react";
+import { dashStorage } from "dash-utils";
+class AuthContextClass {
+}
+__publicField(AuthContextClass, "values");
+const defaultValues = {
+  authenticated: false,
+  user: null,
+  auth: null,
+  token: null,
+  roles: null
+};
+const AuthContextLocalStorage = React.createContext(null);
+const AuthContextProvider = (props) => {
+  const { children, values } = props;
+  const [contextValues, setContextValues] = useState(
+    values || defaultValues
+  );
+  const [serializedValues, setSerializedValues] = useLocalStorage(
+    "SerializedAuthContext",
+    JSON.stringify(values || defaultValues)
+  );
+  useEffect(() => {
+    try {
+      const parsedValues = typeof serializedValues === "string" ? JSON.parse(serializedValues) : serializedValues;
+      setContextValues(parsedValues || defaultValues);
+    } catch (error) {
+      console.error("Error parsing auth context from localStorage:", error);
+      setContextValues(defaultValues);
+    }
+  }, []);
+  const updateValues = (newValues) => {
+    setContextValues((prevValues) => {
+      const updatedValues = __spreadValues(__spreadValues({}, prevValues), newValues);
+      setSerializedValues(JSON.stringify(updatedValues));
+      return updatedValues;
+    });
+  };
+  return /* @__PURE__ */ jsx(AuthContextLocalStorage.Provider, { value: __spreadProps(__spreadValues({}, contextValues), { updateValues }), children });
+};
+const AuthContextConsumer = AuthContextLocalStorage.Consumer;
+const useAuthContext = () => {
+  const authContext = useContext(AuthContextLocalStorage);
+  return authContext;
+};
+const getAuthContext = () => {
+  try {
+    const serialized = dashStorage.getItem("SerializedAuthContext");
+    return serialized ? JSON.parse(serialized) : defaultValues;
+  } catch (error) {
+    console.error("Error getting auth context:", error);
+    return defaultValues;
+  }
+};
+const updateAuthContext = (values) => {
+  try {
+    const prevState = getAuthContext();
+    const updatedState = __spreadValues(__spreadValues({}, prevState), values);
+    dashStorage.setItem(
+      "SerializedAuthContext",
+      JSON.stringify(updatedState)
+    );
+    return updatedState;
+  } catch (error) {
+    console.error("Error updating auth context:", error);
+    return values;
+  }
+};
+const setAuthContext = (values) => {
+  try {
+    dashStorage.setItem("SerializedAuthContext", JSON.stringify(values));
+    dashStorage.setItem("roles", JSON.stringify(values.user.roles));
+    dashStorage.setItem("authenticated", "true");
+    dashStorage.setItem("user", JSON.stringify(values.user));
+    return values;
+  } catch (error) {
+    console.error("Error setting auth context:", error);
+    return values;
+  }
+};
+var AuthContextLocalStorage_default = AuthContextLocalStorage;
+export {
+  AuthContextClass,
+  AuthContextConsumer,
+  AuthContextLocalStorage,
+  AuthContextProvider,
+  AuthContextLocalStorage_default as default,
+  getAuthContext,
+  setAuthContext,
+  updateAuthContext,
+  useAuthContext
+};