analytica-frontend-lib 1.1.92 → 1.1.93

package/dist/index.js

@@ -155,8 +155,13 @@ __export(src_exports, {
   getSubjectName: () => getSubjectName,
   syncDropdownState: () => syncDropdownState,
   useApiConfig: () => useApiConfig,
+  useAppContent: () => useAppContent,
+  useAppInitialization: () => useAppInitialization,
+  useAppStore: () => useAppStore,
   useAuth: () => useAuth,
   useAuthGuard: () => useAuthGuard,
+  useAuthStore: () => useAuthStore,
+  useInstitutionId: () => useInstitutionId,
   useMobile: () => useMobile,
   useQuizStore: () => useQuizStore,
   useRouteAuth: () => useRouteAuth,
@@ -9926,7 +9931,7 @@ var HeaderAlternative = (0, import_react31.forwardRef)(
 );
 
 // src/components/Auth/zustandAuthAdapter.ts
-function createZustandAuthAdapter(useAuthStore) {
+function createZustandAuthAdapter(useAuthStore2) {
   return {
     /**
      * Check if the user is authenticated based on sessionInfo and tokens
@@ -9934,7 +9939,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);
     },
     /**
@@ -9942,26 +9947,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();
     }
   };
@@ -12514,6 +12519,310 @@ var QuizListResultByMateria = ({
     ] })
   ] });
 };
+
+// src/hooks/useAppInitialization.ts
+var import_react39 = require("react");
+
+// src/hooks/useInstitution.ts
+var import_react38 = require("react");
+function useInstitutionId() {
+  const [institutionId, setInstitutionId] = (0, import_react38.useState)(() => {
+    return document.querySelector('meta[name="institution-id"]')?.getAttribute("content") ?? null;
+  });
+  (0, import_react38.useEffect)(() => {
+    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
+var import_zustand10 = require("zustand");
+var import_middleware4 = require("zustand/middleware");
+var useAppStore = (0, import_zustand10.create)()(
+  (0, import_middleware4.persist)(
+    (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: (0, import_middleware4.createJSONStorage)(() => localStorage)
+    }
+  )
+);
+
+// src/store/authStore.ts
+var import_zustand11 = require("zustand");
+var import_middleware5 = require("zustand/middleware");
+var useAuthStore = (0, import_zustand11.create)()(
+  (0, import_middleware5.persist)(
+    (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: (0, import_middleware5.createJSONStorage)(() => localStorage)
+    }
+  )
+);
+
+// src/hooks/useAppInitialization.ts
+function useAppInitialization() {
+  const getInstitutionId = useInstitutionId();
+  const { initialize, initialized, institutionId } = useAppStore();
+  const authFunctions = (0, import_react39.useMemo)(
+    () => ({
+      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
+var import_react40 = require("react");
+var import_react_router_dom3 = require("react-router-dom");
+function useAppContent(config) {
+  const navigate = (0, import_react_router_dom3.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 = (0, import_react40.useCallback)(
+    (profile) => {
+      setSelectedProfile(profile);
+    },
+    [setSelectedProfile]
+  );
+  const handleClearParamsFromURL = (0, import_react40.useCallback)(() => {
+    if (onClearParamsFromURL) {
+      onClearParamsFromURL();
+    } else {
+      globalThis.location.replace("/painel");
+    }
+  }, [onClearParamsFromURL]);
+  const handleError = (0, import_react40.useCallback)(
+    (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 = (0, import_react40.useMemo)(
+    () => ({
+      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 = (0, import_react40.useMemo)(() => {
+    return sessionInfo?.institutionId || getInstitutionId;
+  }, [sessionInfo?.institutionId, getInstitutionId]);
+  (0, import_react40.useEffect)(() => {
+    if (institutionIdToUse && !initialized) {
+      initialize(institutionIdToUse);
+    }
+  }, [institutionIdToUse, initialize, initialized]);
+  return {
+    handleNotFoundNavigation,
+    urlAuthConfig,
+    institutionIdToUse
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ANSWER_STATUS,
@@ -12641,8 +12950,13 @@ var QuizListResultByMateria = ({
   getSubjectName,
   syncDropdownState,
   useApiConfig,
+  useAppContent,
+  useAppInitialization,
+  useAppStore,
   useAuth,
   useAuthGuard,
+  useAuthStore,
+  useInstitutionId,
   useMobile,
   useQuizStore,
   useRouteAuth,