analytica-frontend-lib 1.1.92 → 1.1.94

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,528 @@ var QuizListResultByMateria = ({
     ] })
   ] });
 };
+
+// src/components/BreadcrumbMenu/BreadcrumbMenu.tsx
+import { useNavigate } from "react-router-dom";
+import { jsx as jsx53 } from "react/jsx-runtime";
+var BreadcrumbMenu = ({
+  breadcrumbs,
+  onBreadcrumbClick,
+  className = "!px-0 py-4 flex-wrap w-full"
+}) => {
+  const navigate = useNavigate();
+  const handleClick = (breadcrumb, index) => {
+    if (onBreadcrumbClick) {
+      onBreadcrumbClick(breadcrumb, index);
+    }
+    navigate(breadcrumb.url);
+  };
+  return /* @__PURE__ */ jsx53(
+    Menu,
+    {
+      value: `breadcrumb-${breadcrumbs.length - 1}`,
+      defaultValue: "breadcrumb-0",
+      variant: "breadcrumb",
+      className,
+      children: /* @__PURE__ */ jsx53(MenuContent, { className: "w-full flex flex-row flex-wrap gap-2 !px-0", children: breadcrumbs.map((breadcrumb, index) => {
+        const isLast = index === breadcrumbs.length - 1;
+        const hasSeparator = !isLast;
+        return /* @__PURE__ */ jsx53(
+          MenuItem,
+          {
+            variant: "breadcrumb",
+            value: `breadcrumb-${index}`,
+            className: "!p-0 whitespace-nowrap",
+            onClick: () => handleClick(breadcrumb, index),
+            separator: hasSeparator,
+            children: breadcrumb.name
+          },
+          breadcrumb.id
+        );
+      }) })
+    }
+  );
+};
+
+// src/components/BreadcrumbMenu/useBreadcrumbBuilder.ts
+import { useEffect as useEffect22 } from "react";
+
+// src/components/BreadcrumbMenu/breadcrumbStore.ts
+import { create as create10 } from "zustand";
+var useBreadcrumbStore = create10((set, get) => ({
+  breadcrumbs: {},
+  setBreadcrumbs: (namespace, items) => {
+    set((state) => ({
+      breadcrumbs: {
+        ...state.breadcrumbs,
+        [namespace]: items
+      }
+    }));
+  },
+  addBreadcrumb: (namespace, item) => {
+    set((state) => {
+      const current = state.breadcrumbs[namespace] || [];
+      return {
+        breadcrumbs: {
+          ...state.breadcrumbs,
+          [namespace]: [...current, item]
+        }
+      };
+    });
+  },
+  updateBreadcrumb: (namespace, itemId, updates) => {
+    set((state) => {
+      const current = state.breadcrumbs[namespace] || [];
+      return {
+        breadcrumbs: {
+          ...state.breadcrumbs,
+          [namespace]: current.map(
+            (item) => item.id === itemId ? { ...item, ...updates } : item
+          )
+        }
+      };
+    });
+  },
+  removeBreadcrumbFrom: (namespace, itemId) => {
+    set((state) => {
+      const current = state.breadcrumbs[namespace] || [];
+      const index = current.findIndex((item) => item.id === itemId);
+      if (index === -1) return state;
+      return {
+        breadcrumbs: {
+          ...state.breadcrumbs,
+          [namespace]: current.slice(0, index)
+        }
+      };
+    });
+  },
+  sliceBreadcrumbs: (namespace, index) => {
+    set((state) => {
+      const current = state.breadcrumbs[namespace] || [];
+      return {
+        breadcrumbs: {
+          ...state.breadcrumbs,
+          [namespace]: current.slice(0, index + 1)
+        }
+      };
+    });
+  },
+  clearBreadcrumbs: (namespace) => {
+    set((state) => {
+      const { [namespace]: _, ...rest } = state.breadcrumbs;
+      return {
+        breadcrumbs: rest
+      };
+    });
+  },
+  getBreadcrumbs: (namespace) => {
+    return get().breadcrumbs[namespace] || [];
+  }
+}));
+var useBreadcrumb = (namespace) => {
+  const store = useBreadcrumbStore();
+  const breadcrumbs = store.breadcrumbs[namespace] || [];
+  return {
+    breadcrumbs,
+    /**
+     * Define todos os breadcrumbs de uma vez
+     */
+    setBreadcrumbs: (items) => {
+      store.setBreadcrumbs(namespace, items);
+    },
+    /**
+     * Adiciona um novo breadcrumb ao final
+     */
+    addBreadcrumb: (item) => {
+      store.addBreadcrumb(namespace, item);
+    },
+    /**
+     * Atualiza um breadcrumb existente
+     */
+    updateBreadcrumb: (itemId, updates) => {
+      store.updateBreadcrumb(namespace, itemId, updates);
+    },
+    /**
+     * Remove um breadcrumb e todos os seguintes
+     */
+    removeBreadcrumbFrom: (itemId) => {
+      store.removeBreadcrumbFrom(namespace, itemId);
+    },
+    /**
+     * Mantém apenas os breadcrumbs até o índice especificado (inclusivo)
+     */
+    sliceBreadcrumbs: (index) => {
+      store.sliceBreadcrumbs(namespace, index);
+    },
+    /**
+     * Limpa todos os breadcrumbs
+     */
+    clearBreadcrumbs: () => {
+      store.clearBreadcrumbs(namespace);
+    }
+  };
+};
+
+// src/components/BreadcrumbMenu/useBreadcrumbBuilder.ts
+var isBreadcrumbWithData = (level) => {
+  return "data" in level;
+};
+var useBreadcrumbBuilder = (config) => {
+  const { namespace, root, levels } = config;
+  const { breadcrumbs, setBreadcrumbs, sliceBreadcrumbs } = useBreadcrumb(namespace);
+  const levelDependencies = levels.map(
+    (level) => isBreadcrumbWithData(level) ? level.data : null
+  );
+  const levelUrlIds = levels.map((level) => level.urlId);
+  useEffect22(() => {
+    const newBreadcrumbs = [root];
+    const previousIds = [];
+    for (const level of levels) {
+      const { urlId } = level;
+      if (isBreadcrumbWithData(level)) {
+        const { data, getId, getName, getUrl } = level;
+        if (!data) break;
+        const dataId = getId(data);
+        if (urlId === void 0 || dataId !== urlId) break;
+        newBreadcrumbs.push({
+          id: dataId,
+          name: getName(data),
+          url: getUrl(data, previousIds)
+        });
+        previousIds.push(dataId);
+      } else {
+        const { breadcrumb } = level;
+        if (urlId === void 0) break;
+        newBreadcrumbs.push(breadcrumb);
+        previousIds.push(breadcrumb.id);
+      }
+    }
+    setBreadcrumbs(newBreadcrumbs);
+  }, [namespace, ...levelDependencies, ...levelUrlIds, root.id]);
+  return {
+    breadcrumbs,
+    sliceBreadcrumbs
+  };
+};
+
+// src/components/BreadcrumbMenu/useUrlParams.ts
+import { useMemo as useMemo7 } from "react";
+import { useLocation as useLocation3 } from "react-router-dom";
+var useUrlParams = (config) => {
+  const location = useLocation3();
+  return useMemo7(() => {
+    const segments = location.pathname.split("/").filter(Boolean);
+    const params = {};
+    for (const [key, index] of Object.entries(config)) {
+      params[key] = segments[index];
+    }
+    return params;
+  }, [location.pathname, config]);
+};
+
+// src/hooks/useAppInitialization.ts
+import { useMemo as useMemo8 } from "react";
+
+// src/hooks/useInstitution.ts
+import { useEffect as useEffect23, useState as useState23 } from "react";
+function useInstitutionId() {
+  const [institutionId, setInstitutionId] = useState23(() => {
+    return document.querySelector('meta[name="institution-id"]')?.getAttribute("content") ?? null;
+  });
+  useEffect23(() => {
+    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 create11 } from "zustand";
+import { createJSONStorage, persist as persist2 } from "zustand/middleware";
+var useAppStore = create11()(
+  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 create12 } from "zustand";
+import { createJSONStorage as createJSONStorage2, persist as persist3 } from "zustand/middleware";
+var useAuthStore = create12()(
+  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 = useMemo8(
+    () => ({
+      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 useEffect24, useMemo as useMemo9 } from "react";
+import { useNavigate as useNavigate2 } from "react-router-dom";
+function useAppContent(config) {
+  const navigate = useNavigate2();
+  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 = useMemo9(
+    () => ({
+      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 = useMemo9(() => {
+    return sessionInfo?.institutionId || getInstitutionId;
+  }, [sessionInfo?.institutionId, getInstitutionId]);
+  useEffect24(() => {
+    if (institutionIdToUse && !initialized) {
+      initialize(institutionIdToUse);
+    }
+  }, [institutionIdToUse, initialize, initialized]);
+  return {
+    handleNotFoundNavigation,
+    urlAuthConfig,
+    institutionIdToUse
+  };
+}
 export {
   ANSWER_STATUS,
   Alert_default as Alert,
@@ -12492,6 +13014,7 @@ export {
   AlternativesList,
   AuthProvider,
   Badge_default as Badge,
+  BreadcrumbMenu,
   Button_default as Button,
   Calendar_default as Calendar,
   CardAccordation,
@@ -12611,8 +13134,15 @@ export {
   getSubjectName,
   syncDropdownState,
   useApiConfig,
+  useAppContent,
+  useAppInitialization,
+  useAppStore,
   useAuth,
   useAuthGuard,
+  useAuthStore,
+  useBreadcrumb,
+  useBreadcrumbBuilder,
+  useInstitutionId,
   useMobile,
   useQuizStore,
   useRouteAuth,
@@ -12620,6 +13150,7 @@ export {
   useThemeStore,
   ToastStore_default as useToastStore,
   useUrlAuthentication,
+  useUrlParams,
   withAuth
 };
 //# sourceMappingURL=index.mjs.map