analytica-frontend-lib 1.1.92 → 1.1.93

package/dist/index.mjs

@@ -9879,7 +9879,7 @@ var HeaderAlternative = forwardRef19(
 );
 
 // src/components/Auth/zustandAuthAdapter.ts
-function createZustandAuthAdapter(useAuthStore) {
+function createZustandAuthAdapter(useAuthStore2) {
   return {
     /**
      * Check if the user is authenticated based on sessionInfo and tokens
@@ -9887,7 +9887,7 @@ function createZustandAuthAdapter(useAuthStore) {
      * @returns {Promise<boolean>} Promise that resolves to authentication status
      */
     checkAuth: async () => {
-      const { sessionInfo, tokens } = useAuthStore.getState();
+      const { sessionInfo, tokens } = useAuthStore2.getState();
       return Boolean(sessionInfo && tokens);
     },
     /**
@@ -9895,26 +9895,26 @@ function createZustandAuthAdapter(useAuthStore) {
      *
      * @returns {unknown} Current user data from the store
      */
-    getUser: () => useAuthStore.getState().user,
+    getUser: () => useAuthStore2.getState().user,
     /**
      * Get the current session information from the store
      *
      * @returns {unknown} Current session info from the store
      */
-    getSessionInfo: () => useAuthStore.getState().sessionInfo,
+    getSessionInfo: () => useAuthStore2.getState().sessionInfo,
     /**
      * Get the current authentication tokens from the store
      *
      * @returns {unknown} Current tokens from the store
      */
-    getTokens: () => useAuthStore.getState().tokens,
+    getTokens: () => useAuthStore2.getState().tokens,
     /**
      * Sign out the user by calling the store's signOut function if available
      *
      * @returns {void}
      */
     signOut: () => {
-      const signOutFn = useAuthStore.getState().signOut;
+      const signOutFn = useAuthStore2.getState().signOut;
       if (typeof signOutFn === "function") signOutFn();
     }
   };
@@ -12485,6 +12485,310 @@ var QuizListResultByMateria = ({
     ] })
   ] });
 };
+
+// src/hooks/useAppInitialization.ts
+import { useMemo as useMemo7 } from "react";
+
+// src/hooks/useInstitution.ts
+import { useEffect as useEffect22, useState as useState23 } from "react";
+function useInstitutionId() {
+  const [institutionId, setInstitutionId] = useState23(() => {
+    return document.querySelector('meta[name="institution-id"]')?.getAttribute("content") ?? null;
+  });
+  useEffect22(() => {
+    const metaTag = document.querySelector('meta[name="institution-id"]');
+    if (!metaTag) return;
+    const observer = new MutationObserver(() => {
+      const newValue = metaTag.getAttribute("content");
+      setInstitutionId(newValue);
+    });
+    observer.observe(metaTag, {
+      attributes: true,
+      attributeFilter: ["content"]
+    });
+    return () => observer.disconnect();
+  }, []);
+  return institutionId;
+}
+
+// src/store/appStore.ts
+import { create as create10 } from "zustand";
+import { createJSONStorage, persist as persist2 } from "zustand/middleware";
+var useAppStore = create10()(
+  persist2(
+    (set, get) => ({
+      institutionId: null,
+      initialized: false,
+      /**
+       * Set the institution ID
+       * @param {string | null} institutionId - The institution ID from meta tag
+       * @returns {void}
+       */
+      setInstitutionId: (institutionId) => {
+        set({ institutionId });
+      },
+      /**
+       * Set the initialized state
+       * @param {boolean} initialized - Whether the app has been initialized
+       * @returns {void}
+       */
+      setInitialized: (initialized) => {
+        set({ initialized });
+      },
+      /**
+       * Initialize the app by reading the institution ID from meta tag
+       * @returns {void}
+       */
+      initialize: (id) => {
+        const { initialized } = get();
+        if (initialized) {
+          return;
+        }
+        set({
+          institutionId: id,
+          initialized: true
+        });
+      }
+    }),
+    {
+      name: "@app-storage:analytica:v2" /* APP_STORAGE */,
+      storage: createJSONStorage(() => localStorage)
+    }
+  )
+);
+
+// src/store/authStore.ts
+import { create as create11 } from "zustand";
+import { createJSONStorage as createJSONStorage2, persist as persist3 } from "zustand/middleware";
+var useAuthStore = create11()(
+  persist3(
+    (set, get) => ({
+      user: null,
+      tokens: null,
+      isAuthenticated: false,
+      profiles: [],
+      selectedProfile: null,
+      sessionInfo: null,
+      /**
+       * Set the current user
+       * @param {User | null} user - The user object or null to clear
+       * @returns {void}
+       */
+      setUser: (user) => {
+        set({ user, isAuthenticated: !!user });
+      },
+      /**
+       * Set the authentication tokens
+       * @param {AuthTokens | null} tokens - The authentication tokens or null to clear
+       * @returns {void}
+       */
+      setTokens: (tokens) => {
+        set({ tokens });
+      },
+      /**
+       * Set user profiles
+       * @param {UserProfile[]} profiles - Array of user profiles
+       * @returns {void}
+       */
+      setProfiles: (profiles) => {
+        set({ profiles });
+      },
+      /**
+       * Set the selected profile
+       * @param {UserProfile | null} profile - The selected profile or null to clear
+       * @returns {void}
+       */
+      setSelectedProfile: (profile) => {
+        set({ selectedProfile: profile });
+      },
+      /**
+       * Set the session info
+       * @param {SessionInfo | null} sessionInfo - The session info or null to clear
+       * @returns {void}
+       */
+      setSessionInfo: (sessionInfo) => {
+        set({ sessionInfo });
+      },
+      /**
+       * Sign in user with complete auth data
+       * @param {User} user - The user object
+       * @param {AuthTokens} tokens - The authentication tokens
+       * @param {UserProfile[]} profiles - Array of user profiles
+       * @returns {void}
+       */
+      signIn: (user, tokens, profiles) => {
+        set({
+          user,
+          tokens,
+          profiles,
+          isAuthenticated: true
+        });
+      },
+      /**
+       * Sign out user and clear all auth data
+       * @returns {void}
+       */
+      signOut: () => {
+        set({
+          user: null,
+          tokens: null,
+          isAuthenticated: false,
+          profiles: [],
+          selectedProfile: null,
+          sessionInfo: null
+        });
+      },
+      /**
+       * Update user session data (after login completion)
+       * @param {Partial<User>} sessionData - Partial user data to update
+       * @returns {void}
+       */
+      updateUserSession: (sessionData) => {
+        const { user } = get();
+        if (user) {
+          const updatedUser = { ...user, ...sessionData };
+          set({ user: updatedUser });
+        }
+      }
+    }),
+    {
+      name: "@auth-storage:analytica:v2" /* AUTH_STORAGE */,
+      storage: createJSONStorage2(() => localStorage)
+    }
+  )
+);
+
+// src/hooks/useAppInitialization.ts
+function useAppInitialization() {
+  const getInstitutionId = useInstitutionId();
+  const { initialize, initialized, institutionId } = useAppStore();
+  const authFunctions = useMemo7(
+    () => ({
+      checkAuth: async () => {
+        const { sessionInfo, tokens } = useAuthStore.getState();
+        return Boolean(sessionInfo && tokens);
+      },
+      signOut: () => {
+        const { signOut } = useAuthStore.getState();
+        signOut();
+      },
+      getUser: () => {
+        const { user } = useAuthStore.getState();
+        return user;
+      },
+      getSessionInfo: () => {
+        const { sessionInfo } = useAuthStore.getState();
+        return sessionInfo;
+      },
+      getTokens: () => {
+        const { tokens } = useAuthStore.getState();
+        return tokens;
+      }
+    }),
+    []
+  );
+  return {
+    // Estado da inicialização
+    getInstitutionId,
+    initialize,
+    initialized,
+    institutionId,
+    // Funções de autenticação
+    authFunctions
+  };
+}
+
+// src/hooks/useAppContent.ts
+import { useCallback as useCallback7, useEffect as useEffect23, useMemo as useMemo8 } from "react";
+import { useNavigate } from "react-router-dom";
+function useAppContent(config) {
+  const navigate = useNavigate();
+  const { setTokens, setSessionInfo, setSelectedProfile } = useAuthStore();
+  const {
+    api,
+    getInstitutionId,
+    initialize,
+    initialized,
+    endpoint = "/auth/session-info",
+    maxRetries = 1,
+    retryDelay = 2e3,
+    onClearParamsFromURL,
+    onError,
+    onNotFoundNavigation
+  } = config;
+  const apiConfig = useApiConfig(api);
+  useTheme();
+  const handleNotFoundNavigation = () => {
+    if (onNotFoundNavigation) {
+      onNotFoundNavigation();
+    } else {
+      navigate("/painel");
+    }
+  };
+  const handleSetSelectedProfile = useCallback7(
+    (profile) => {
+      setSelectedProfile(profile);
+    },
+    [setSelectedProfile]
+  );
+  const handleClearParamsFromURL = useCallback7(() => {
+    if (onClearParamsFromURL) {
+      onClearParamsFromURL();
+    } else {
+      globalThis.location.replace("/painel");
+    }
+  }, [onClearParamsFromURL]);
+  const handleError = useCallback7(
+    (error) => {
+      if (onError) {
+        onError(error);
+      } else {
+        console.error("Erro ao obter informa\xE7\xF5es da sess\xE3o:", error);
+        navigate("/", { replace: true });
+      }
+    },
+    [navigate, onError]
+  );
+  const urlAuthConfig = useMemo8(
+    () => ({
+      setTokens,
+      setSessionInfo,
+      setSelectedProfile: handleSetSelectedProfile,
+      api: apiConfig,
+      endpoint,
+      clearParamsFromURL: handleClearParamsFromURL,
+      maxRetries,
+      retryDelay,
+      onError: handleError
+    }),
+    [
+      setTokens,
+      setSessionInfo,
+      handleSetSelectedProfile,
+      apiConfig,
+      endpoint,
+      handleClearParamsFromURL,
+      maxRetries,
+      retryDelay,
+      handleError
+    ]
+  );
+  useUrlAuthentication(urlAuthConfig);
+  const { sessionInfo } = useAuth();
+  const institutionIdToUse = useMemo8(() => {
+    return sessionInfo?.institutionId || getInstitutionId;
+  }, [sessionInfo?.institutionId, getInstitutionId]);
+  useEffect23(() => {
+    if (institutionIdToUse && !initialized) {
+      initialize(institutionIdToUse);
+    }
+  }, [institutionIdToUse, initialize, initialized]);
+  return {
+    handleNotFoundNavigation,
+    urlAuthConfig,
+    institutionIdToUse
+  };
+}
 export {
   ANSWER_STATUS,
   Alert_default as Alert,
@@ -12611,8 +12915,13 @@ export {
   getSubjectName,
   syncDropdownState,
   useApiConfig,
+  useAppContent,
+  useAppInitialization,
+  useAppStore,
   useAuth,
   useAuthGuard,
+  useAuthStore,
+  useInstitutionId,
   useMobile,
   useQuizStore,
   useRouteAuth,