@elevasis/ui 2.65.0 → 2.66.0

package/dist/chunk-L7BZZ4SI.js

@@ -0,0 +1,56 @@
+import { computeInitializationState } from './chunk-P45GQ3ZW.js';
+import { useUserProfile } from './chunk-RT4KRGZT.js';
+import { useAuthContext } from './chunk-BRJ3QZ4E.js';
+import { useMemo, useCallback } from 'react';
+
+function createUseAppInitialization(useOrgInitialization) {
+  return function useAppInitialization() {
+    const { user, isLoading: authLoading } = useAuthContext();
+    const { profile, loading: profileLoading, error: profileError, refetch } = useUserProfile();
+    const {
+      isInitializing: orgInitializing,
+      isLoading: orgLoading,
+      error: orgErrorMsg,
+      currentOrganization,
+      memberships,
+      retry: orgRetry
+    } = useOrgInitialization();
+    const state = useMemo(
+      () => computeInitializationState({
+        user,
+        authLoading,
+        profile,
+        profileLoading,
+        profileError,
+        orgInitializing,
+        orgLoading,
+        hasCurrentOrganization: !!currentOrganization,
+        orgErrorMessage: orgErrorMsg,
+        membershipsCount: memberships.length
+      }),
+      [
+        user,
+        authLoading,
+        profile,
+        profileLoading,
+        profileError,
+        orgInitializing,
+        orgLoading,
+        currentOrganization,
+        orgErrorMsg,
+        memberships.length
+      ]
+    );
+    const retry = useCallback(() => {
+      if (profileError && refetch) {
+        refetch();
+      }
+      if (orgErrorMsg && orgRetry) {
+        orgRetry();
+      }
+    }, [profileError, refetch, orgErrorMsg, orgRetry]);
+    return { ...state, retry };
+  };
+}
+
+export { createUseAppInitialization };

package/dist/chunk-P45GQ3ZW.js

@@ -0,0 +1,104 @@
+import { useOrganization } from './chunk-DD3CCMCZ.js';
+import { useProfile } from './chunk-RT4KRGZT.js';
+import { useAuthContext } from './chunk-BRJ3QZ4E.js';
+import { createContext, useContext, useMemo, useCallback, createElement } from 'react';
+
+// src/initialization/computeInitializationState.ts
+function computeInitializationState(input) {
+  const {
+    user,
+    authLoading,
+    profile,
+    profileLoading,
+    profileError,
+    orgInitializing,
+    orgLoading,
+    hasCurrentOrganization,
+    orgErrorMessage,
+    membershipsCount
+  } = input;
+  const isInitializing = authLoading || profileLoading || orgInitializing || orgLoading;
+  const userReady = !authLoading && !profileLoading && !!user && !!profile && !profileError;
+  const organizationReady = userReady && !orgInitializing && !orgLoading && hasCurrentOrganization && !orgErrorMessage;
+  const allReady = organizationReady;
+  let error = null;
+  if (profileError) {
+    error = {
+      layer: "profile",
+      message: "Failed to load user profile",
+      originalError: profileError
+    };
+  } else if (orgErrorMessage) {
+    error = {
+      layer: "organization",
+      message: orgErrorMessage,
+      originalError: new Error(orgErrorMessage)
+    };
+  } else if (userReady && !orgInitializing && !orgLoading && !hasCurrentOrganization && membershipsCount > 0) {
+    error = {
+      layer: "organization",
+      message: "No organization membership found. Please contact your administrator for an invitation."
+    };
+  }
+  return { userReady, organizationReady, allReady, isInitializing, error, profile };
+}
+
+// src/initialization/InitializationProvider.tsx
+var InitializationContext = createContext(null);
+function useInitialization() {
+  const ctx = useContext(InitializationContext);
+  if (!ctx) {
+    throw new Error(
+      "useInitialization must be used within an InitializationProvider. Wrap your app (or the relevant subtree) with <InitializationProvider>."
+    );
+  }
+  return ctx;
+}
+function InitializationProvider({ children }) {
+  const { user, isLoading: authLoading } = useAuthContext();
+  const { profile, loading: profileLoading, error: profileError, refetch } = useProfile();
+  const {
+    isInitializing: orgInitializing,
+    isOrgRefreshing: orgLoading,
+    error: orgErrorMsg,
+    currentWorkOSOrganizationId,
+    memberships,
+    retry: orgRetry
+  } = useOrganization();
+  const state = useMemo(
+    () => computeInitializationState({
+      user,
+      authLoading,
+      profile,
+      profileLoading,
+      profileError,
+      orgInitializing,
+      orgLoading,
+      hasCurrentOrganization: !!currentWorkOSOrganizationId,
+      orgErrorMessage: orgErrorMsg,
+      membershipsCount: memberships.length
+    }),
+    [
+      user,
+      authLoading,
+      profile,
+      profileLoading,
+      profileError,
+      orgInitializing,
+      orgLoading,
+      currentWorkOSOrganizationId,
+      orgErrorMsg,
+      memberships.length
+    ]
+  );
+  const retry = useCallback(async () => {
+    if (profileError && refetch) {
+      await refetch();
+    }
+    await orgRetry();
+  }, [profileError, refetch, orgRetry]);
+  const value = useMemo(() => ({ ...state, retry }), [state, retry]);
+  return createElement(InitializationContext.Provider, { value }, children);
+}
+
+export { InitializationContext, InitializationProvider, computeInitializationState, useInitialization };

package/dist/{chunk-EIXSQONC.js → chunk-RT4KRGZT.js}

@@ -1,6 +1,7 @@
 import { ElevasisServiceContext } from './chunk-BI5VDO2K.js';
 import { useAuthContext } from './chunk-BRJ3QZ4E.js';
-import { createContext, useContext, useState, useEffect, createElement } from 'react';
+import { createContext, useContext, createElement } from 'react';
+import { useQuery } from '@tanstack/react-query';
 
 // src/profile/services/UserProfileService.ts
 var UserProfileService = class {
@@ -65,6 +66,7 @@ var UserProfileService = class {
     }
   }
 };
+var USER_PROFILE_QUERY_KEY = ["profile", "me"];
 var useUserProfile = (options) => {
   const { user, isLoading: authLoading } = useAuthContext();
   const serviceCtx = useContext(ElevasisServiceContext);
@@ -74,66 +76,42 @@ var useUserProfile = (options) => {
       "useUserProfile: no apiRequest available. Either pass it via options or use within ElevasisServiceProvider."
     );
   }
-  const [profile, setProfile] = useState(null);
-  const [loading, setLoading] = useState(true);
-  const [error, setError] = useState(null);
-  const syncAndFetchProfile = async () => {
-    if (!user || authLoading) {
-      return;
-    }
-    try {
-      setLoading(true);
-      setError(null);
-      const profileService = new UserProfileService(apiRequest);
-      const syncedProfile = await profileService.syncUserProfile();
-      if (syncedProfile) {
-        setProfile(syncedProfile);
-      } else {
-        console.warn("Failed to sync user profile");
-      }
-    } catch (err) {
-      const error2 = err instanceof Error ? err : new Error("Unknown error occurred");
-      if (options?.onError) {
-        options.onError(
-          {
-            phase: "profile-sync",
-            userId: user?.id
-          },
-          error2
-        );
-      }
-      setError(error2);
-      console.error("User profile sync failed:", error2);
-    } finally {
-      setLoading(false);
-    }
-  };
-  useEffect(() => {
-    if (!authLoading) {
-      if (user) {
-        syncAndFetchProfile();
-      } else {
-        setProfile(null);
-        setLoading(false);
-        setError(null);
+  const query = useQuery({
+    queryKey: USER_PROFILE_QUERY_KEY,
+    queryFn: async () => {
+      try {
+        const profileService = new UserProfileService(apiRequest);
+        const syncedProfile = await profileService.syncUserProfile();
+        if (!syncedProfile) {
+          throw new Error("Failed to sync user profile");
+        }
+        return syncedProfile;
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error("Unknown error occurred");
+        options?.onError?.({ phase: "profile-sync", userId: user?.id }, error2);
+        console.error("User profile sync failed:", error2);
+        throw error2;
       }
-    }
-  }, [user, authLoading]);
+    },
+    // Enabled only once auth has resolved to a real user. When the user signs
+    // out, `enabled` flips false and `profile` below resolves to null.
+    enabled: !!user && !authLoading,
+    // The profile only changes in response to explicit mutations this hook's
+    // consumers already know about (onboarding completion, account edits),
+    // each of which calls refetch()/invalidateQueries itself. Without this,
+    // every new mount of a second/third consumer would kick off a background
+    // refetch under a host app's default staleTime, reintroducing the
+    // multiple-sync-calls problem this hook exists to fix.
+    staleTime: Infinity,
+    retry: false
+  });
+  const profile = query.data ?? null;
+  const loading = authLoading || !!user && !profile && !query.isError;
+  const error = query.error ?? null;
   const refetch = async () => {
-    await syncAndFetchProfile();
-  };
-  return {
-    profile,
-    // Treat as loading whenever a user is present but profile hasn't synced yet.
-    // Prevents a render window after re-login where `loading` is still false
-    // (from a prior logout) while `user` has just become defined and the sync
-    // effect has not yet fired. Without this, ProtectedRoute briefly sees
-    // !isInitializing && !userReady, marks the user unauthenticated, and
-    // bounces back to /auth-redirect in a loop.
-    loading: loading || authLoading || !!user && !profile && !error,
-    error,
-    refetch
+    await query.refetch();
   };
+  return { profile, loading, error, refetch };
 };
 var ProfileContext = createContext(null);
 function useProfile() {
@@ -150,4 +128,4 @@ function ProfileProvider({ apiRequest, children }) {
   return createElement(ProfileContext.Provider, { value }, children);
 }
 
-export { ProfileProvider, UserProfileService, useProfile, useUserProfile };
+export { ProfileProvider, USER_PROFILE_QUERY_KEY, UserProfileService, useProfile, useUserProfile };