@jmruthers/pace-core 0.5.42 → 0.5.44

package/dist/{DataTable-DCW3J4YX.js → DataTable-GU72TTL6.js}

@@ -32,11 +32,11 @@ import {
   useDataTableContext,
   usePluginRegistry,
   useStateManager
-} from "./chunk-ZSXH6L7D.js";
-import "./chunk-CL2MCHIO.js";
+} from "./chunk-KVMIO3BU.js";
+import "./chunk-DZSLRIE2.js";
 import "./chunk-GWSBHC4J.js";
 import "./chunk-7BNPOCLL.js";
-import "./chunk-XC6XWRP6.js";
+import "./chunk-HEYEDETJ.js";
 import {
   DataChunkManager,
   SearchIndex,
@@ -48,7 +48,7 @@ import {
   throttle,
   useDataTablePerformance
 } from "./chunk-SS3E6QLB.js";
-import "./chunk-P27KH7XF.js";
+import "./chunk-6CGBO4IS.js";
 import "./chunk-YDJW5XTN.js";
 import "./chunk-MZBUOP4P.js";
 import "./chunk-WJARTBCT.js";
@@ -97,4 +97,4 @@ export {
   usePluginRegistry,
   useStateManager
 };
-//# sourceMappingURL=DataTable-DCW3J4YX.js.map
+//# sourceMappingURL=DataTable-GU72TTL6.js.map

package/dist/{UnifiedAuthProvider-DGQsy-vY.d.ts → UnifiedAuthProvider-CQNiemcB.d.ts}

@@ -30,12 +30,12 @@ interface AuthContextType {
         error: AuthError | null;
     }>;
 }
-declare const useAuth: () => AuthContextType;
 interface AuthProviderProps {
     children: React__default.ReactNode;
     supabaseClient?: SupabaseClient;
 }
 declare function AuthProvider({ children, supabaseClient }: AuthProviderProps): react_jsx_runtime.JSX.Element;
+declare const useAuth: () => AuthContextType;
 
 interface InactivityContextType {
     showInactivityWarning: boolean;
@@ -100,4 +100,4 @@ declare function UnifiedAuthProvider({ children, supabaseClient, appName, persis
 warnBeforeMs, // 60 seconds
 onIdleLogout, renderInactivityWarning, dangerouslyDisableInactivity }: UnifiedAuthProviderProps): react_jsx_runtime.JSX.Element;
 
-export { type AuthContextType as A, type InactivityContextType as I, UnifiedAuthProvider as U, type UnifiedAuthProviderProps as a, type UnifiedAuthContextType as b, useAuth as c, type AuthProviderProps as d, AuthProvider as e, useInactivity as f, type InactivityProviderProps as g, InactivityProvider as h, useUnifiedAuth as u };
+export { type AuthContextType as A, type InactivityContextType as I, UnifiedAuthProvider as U, type UnifiedAuthProviderProps as a, type UnifiedAuthContextType as b, type AuthProviderProps as c, AuthProvider as d, useAuth as e, useInactivity as f, type InactivityProviderProps as g, InactivityProvider as h, useUnifiedAuth as u };

package/dist/{chunk-P27KH7XF.js → chunk-6CGBO4IS.js}

@@ -49,262 +49,174 @@ function AuthProvider({ children, supabaseClient }) {
     };
   }, []);
   useEffect(() => {
-    if (!supabaseClient) return;
-    const loadInitialUser = async (retryCount = 0) => {
+    if (!supabaseClient) {
+      setAuthLoading(false);
+      return;
+    }
+    let isMounted = true;
+    const initializeAuth = async () => {
       try {
-        DebugLogger.log("AuthProvider", `Loading initial user (attempt ${retryCount + 1})...`);
-        const response = await supabaseClient.auth.getUser();
-        const { data: { user: initialUser }, error } = response || { data: { user: null }, error: null };
-        if (error) {
-          console.warn("Failed to get initial user:", error);
-          if (retryCount === 0 && (error.message?.includes("network") || error.message?.includes("timeout"))) {
-            console.log("AuthProvider: Retrying initial user load due to network error...");
-            setTimeout(() => loadInitialUser(1), 1e3);
-            return;
+        DebugLogger.log("AuthProvider", "Initializing authentication...");
+        const { data: { session: currentSession }, error: sessionError } = await supabaseClient.auth.getSession();
+        if (sessionError) {
+          console.warn("[AuthProvider] Error getting current session:", sessionError);
+        }
+        if (currentSession && isMounted) {
+          DebugLogger.log("AuthProvider", "Session restored from storage:", currentSession.user?.email);
+          setSession(currentSession);
+          setUser(currentSession.user);
+          setAuthError(null);
+        } else if (isMounted) {
+          DebugLogger.log("AuthProvider", "No session found in storage");
+          const { data: { user: currentUser }, error: userError } = await supabaseClient.auth.getUser();
+          if (userError) {
+            DebugLogger.log("AuthProvider", "No user found:", userError.message);
+          } else if (currentUser && isMounted) {
+            DebugLogger.log("AuthProvider", "User found without session:", currentUser.email);
+            setUser(currentUser);
           }
-          setAuthLoading(false);
-          return;
         }
-        if (initialUser) {
-          DebugLogger.log("AuthProvider", "Initial user loaded successfully:", initialUser.email);
-          setUser(initialUser);
-        } else {
-          DebugLogger.log("AuthProvider", "No initial user found");
+        if (isMounted) {
+          setAuthLoading(false);
         }
-        setAuthLoading(false);
       } catch (error) {
-        console.error("Error loading initial user:", error);
-        if (retryCount === 0 && (error instanceof Error && (error.message.includes("network") || error.message.includes("timeout")))) {
-          console.log("AuthProvider: Retrying initial user load due to network error...");
-          setTimeout(() => loadInitialUser(1), 1e3);
-          return;
+        console.error("[AuthProvider] Error during auth initialization:", error);
+        if (isMounted) {
+          setAuthLoading(false);
         }
-        setAuthLoading(false);
       }
     };
-    const timeoutId = setTimeout(() => {
-      if (authLoading && !user && !session) {
-        loadInitialUser();
-      }
-    }, 100);
-    return () => clearTimeout(timeoutId);
-  }, [supabaseClient, authLoading, user, session]);
-  useEffect(() => {
-    if (!supabaseClient) {
-      setAuthLoading(false);
-      return;
-    }
-    const timeoutId = setTimeout(() => {
-      if (authLoading) {
-        console.warn("AuthProvider: Auth loading timeout reached - this may indicate a network issue or slow auth response");
-        setAuthLoading(false);
-        setAuthError(new AuthError("Authentication timeout - please try refreshing the page"));
-      }
-    }, 1e4);
-    try {
-      DebugLogger.log("AuthProvider", "Setting up auth state change listener...");
-      const authStateChange = supabaseClient.auth.onAuthStateChange(
-        (event, session2) => {
-          try {
-            DebugLogger.log("AuthProvider", "Auth state changed:", event, session2?.user?.email);
-            clearTimeout(timeoutId);
-            if (event === "SIGNED_OUT") {
-              DebugLogger.log("AuthProvider", "User signed out, clearing all state");
-              setSession(null);
-              setUser(null);
-              setAuthLoading(false);
+    const { data: { subscription } } = supabaseClient.auth.onAuthStateChange(
+      (event, session2) => {
+        if (!isMounted) return;
+        try {
+          DebugLogger.log("AuthProvider", "Auth state changed:", event, session2?.user?.email);
+          if (event === "SIGNED_OUT") {
+            DebugLogger.log("AuthProvider", "User signed out, clearing all state");
+            setSession(null);
+            setUser(null);
+            setAuthError(null);
+          } else if (event === "SIGNED_IN" || event === "TOKEN_REFRESHED") {
+            DebugLogger.log("AuthProvider", "User signed in or token refreshed");
+            setSession(session2);
+            setUser(session2?.user ?? null);
+            if (session2) {
               setAuthError(null);
-            } else if (event === "SIGNED_IN" || event === "TOKEN_REFRESHED") {
-              DebugLogger.log("AuthProvider", "User signed in or token refreshed");
+            }
+          } else if (event === "INITIAL_SESSION") {
+            DebugLogger.log("AuthProvider", "Initial session event");
+            if (session2) {
               setSession(session2);
-              setUser(session2?.user ?? null);
-              setAuthLoading(false);
-              if (session2) {
-                setAuthError(null);
-              }
-            } else {
-              if (session2) {
-                setSession(session2);
-                setUser(session2.user ?? null);
-                setAuthLoading(false);
-                if (session2) {
-                  setAuthError(null);
-                }
-              }
+              setUser(session2.user ?? null);
+              setAuthError(null);
             }
-          } catch (error) {
-            console.warn("[AuthProvider] Error in auth state change handler:", error);
+          }
+          setAuthLoading(false);
+        } catch (error) {
+          console.warn("[AuthProvider] Error in auth state change handler:", error);
+          if (isMounted) {
             setAuthLoading(false);
           }
         }
-      );
-      const subscription = authStateChange?.data?.subscription || authStateChange;
-      return () => {
-        clearTimeout(timeoutId);
-        if (subscription && typeof subscription.unsubscribe === "function") {
-          DebugLogger.log("AuthProvider", "Cleaning up auth state listener");
-          subscription.unsubscribe();
-        }
-      };
-    } catch (error) {
-      console.error("AuthProvider: Error setting up auth state change listener:", error);
-      if (error instanceof Error && !error.message.includes("No API key found") && !error.message.includes("AuthSessionMissingError") && !error.message.includes("Auth session missing")) {
-        setAuthError(error);
       }
-      setAuthLoading(false);
-      clearTimeout(timeoutId);
-      return () => {
-      };
-    }
+    );
+    initializeAuth();
+    return () => {
+      isMounted = false;
+      subscription?.unsubscribe();
+    };
   }, [supabaseClient]);
   const signIn = useCallback(async (email, password) => {
     if (!supabaseClient) {
-      const error = new Error("No Supabase client provided");
-      setAuthError(error);
-      return { error };
+      return { error: new AuthError("Supabase client not available") };
     }
-    setAuthLoading(true);
-    setAuthError(null);
     try {
-      const { error } = await supabaseClient.auth.signInWithPassword({ email, password: password || "" });
-      if (error) {
-        setAuthError(error);
-      }
+      const { error } = await supabaseClient.auth.signInWithPassword({
+        email,
+        password: password || ""
+      });
+      return { error };
+    } catch (error) {
       return { error };
-    } catch (err) {
-      const authError2 = err;
-      setAuthError(authError2);
-      return { error: authError2 };
-    } finally {
-      setAuthLoading(false);
     }
   }, [supabaseClient]);
   const signUp = useCallback(async (email, password) => {
     if (!supabaseClient) {
-      const error = new Error("No Supabase client provided");
-      setAuthError(error);
-      return { error };
+      return { error: new AuthError("Supabase client not available") };
     }
-    setAuthError(null);
     try {
-      const { error } = await supabaseClient.auth.signUp({ email, password });
-      if (error) {
-        setAuthError(error);
-      }
+      const { error } = await supabaseClient.auth.signUp({
+        email,
+        password
+      });
+      return { error };
+    } catch (error) {
       return { error };
-    } catch (err) {
-      const authError2 = err;
-      setAuthError(authError2);
-      return { error: authError2 };
     }
   }, [supabaseClient]);
   const signOut = useCallback(async () => {
-    DebugLogger.log("AuthProvider", "signOut called");
-    setAuthLoading(false);
     if (!supabaseClient) {
-      DebugLogger.log("AuthProvider", "No supabase client, clearing state manually");
-      setUser(null);
-      setSession(null);
-      setAuthError(null);
-      return { error: null };
+      return { error: new AuthError("Supabase client not available") };
     }
-    DebugLogger.log("AuthProvider", "Pre-clearing state before signOut call");
-    setUser(null);
-    setSession(null);
-    setAuthError(null);
     try {
-      DebugLogger.log("AuthProvider", "Calling supabase signOut");
-      const signOutPromise = supabaseClient.auth.signOut();
-      const timeoutPromise = new Promise(
-        (_, reject) => setTimeout(() => reject(new Error("SignOut timeout")), 3e3)
-      );
-      const { error } = await Promise.race([signOutPromise, timeoutPromise]);
-      if (error && !error.message?.includes("SignOut timeout")) {
-        console.error("[AuthProvider] signOut error:", error);
-      }
-      DebugLogger.log("AuthProvider", "signOut process completed");
-      return { error: null };
-    } catch (err) {
-      console.warn("[AuthProvider] signOut exception (ignored):", err);
-      return { error: null };
+      const { error } = await supabaseClient.auth.signOut();
+      return { error };
+    } catch (error) {
+      return { error };
     }
   }, [supabaseClient]);
   const resetPassword = useCallback(async (email) => {
     if (!supabaseClient) {
-      const error = new Error("No Supabase client provided");
-      setAuthError(error);
-      return { error };
+      return { error: new AuthError("Supabase client not available") };
     }
-    setAuthError(null);
     try {
       const { error } = await supabaseClient.auth.resetPasswordForEmail(email);
-      if (error) {
-        setAuthError(error);
-      }
       return { error };
-    } catch (err) {
-      const authError2 = err;
-      setAuthError(authError2);
-      return { error: authError2 };
+    } catch (error) {
+      return { error };
     }
   }, [supabaseClient]);
   const updatePassword = useCallback(async (password) => {
-    if (!supabaseClient) return { error: new AuthError("Supabase client not available.", 500) };
-    const { error } = await supabaseClient.auth.updateUser({ password });
-    if (error) {
-      setAuthError(error);
+    if (!supabaseClient) {
+      return { error: new AuthError("Supabase client not available") };
+    }
+    try {
+      const { error } = await supabaseClient.auth.updateUser({
+        password
+      });
+      return { error };
+    } catch (error) {
+      return { error };
     }
-    return { error };
   }, [supabaseClient]);
   const refreshSession = useCallback(async () => {
     if (!supabaseClient) {
-      const error = new Error("No Supabase client provided");
-      setAuthError(error);
-      return { error };
+      return { error: new AuthError("Supabase client not available") };
     }
-    setAuthError(null);
     try {
       const { error } = await supabaseClient.auth.refreshSession();
-      if (error) {
-        setAuthError(error);
-      }
       return { error };
-    } catch (err) {
-      const authError2 = err;
-      setAuthError(authError2);
-      return { error: authError2 };
+    } catch (error) {
+      return { error };
     }
   }, [supabaseClient]);
-  const isAuthenticated = !!user;
   const contextValue = useMemo(() => ({
     user,
     session,
-    isAuthenticated,
+    isAuthenticated: !!user && !!session,
     authLoading,
     authError,
     error: authError,
     // Alias for backward compatibility
     supabase: supabaseClient || null,
+    // Ensure null instead of undefined
     signIn,
     signUp,
     signOut,
     resetPassword,
     updatePassword,
     refreshSession
-  }), [
-    user,
-    session,
-    isAuthenticated,
-    authLoading,
-    authError,
-    supabaseClient,
-    signIn,
-    signUp,
-    signOut,
-    resetPassword,
-    updatePassword,
-    refreshSession
-  ]);
+  }), [user, session, authLoading, authError, supabaseClient, signIn, signUp, signOut, resetPassword, updatePassword, refreshSession]);
   return /* @__PURE__ */ jsx(AuthContext.Provider, { value: contextValue, children });
 }
 var AuthContext, useAuth;
@@ -7430,6 +7342,10 @@ function OrganisationProvider({ children }) {
       setError(null);
       return;
     }
+    if (isLoading) {
+      DebugLogger.log("OrganisationProvider", "Already loading, skipping duplicate load");
+      return;
+    }
     setIsLoading(true);
     setError(null);
     try {
@@ -7463,10 +7379,17 @@ function OrganisationProvider({ children }) {
       if (!memberships || memberships.length === 0) {
         throw new Error("User has no active organisation memberships");
       }
-      const organisationIds = memberships.map((m) => m.organisation_id).filter((id) => id && id.trim() !== "" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id));
+      const organisationIds = memberships.map((m) => m.organisation_id).filter((id) => {
+        if (!id || typeof id !== "string") return false;
+        const trimmedId = id.trim();
+        if (trimmedId === "") return false;
+        return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(trimmedId);
+      });
       if (organisationIds.length === 0) {
+        console.warn("[OrganisationProvider] No valid organisation IDs found in memberships:", memberships);
         throw new Error("No valid organisation IDs found in memberships");
       }
+      DebugLogger.log("OrganisationProvider", "Valid organisation IDs:", organisationIds);
       const { data: organisations2, error: orgError } = await supabase.from("organisations").select("id, name, display_name, subscription_tier, settings, is_active, parent_id, created_at, updated_at").in("id", organisationIds);
       if (orgError) {
         console.error("[OrganisationProvider] Error loading organisations:", orgError);
@@ -7535,8 +7458,19 @@ function OrganisationProvider({ children }) {
     }
   }, [user, session, supabase]);
   useEffect7(() => {
-    loadUserOrganisations();
-  }, [loadUserOrganisations]);
+    if (user && session && supabase && !isLoading) {
+      DebugLogger.log("OrganisationProvider", "Authentication stable, loading organizations...");
+      loadUserOrganisations();
+    } else if (!user && !session) {
+      DebugLogger.log("OrganisationProvider", "No authentication, clearing organization state");
+      setSelectedOrganisation(null);
+      setOrganisations([]);
+      setUserMemberships([]);
+      setRoleMapState(/* @__PURE__ */ new Map());
+      setIsLoading(false);
+      setError(null);
+    }
+  }, [user, session, supabase, isLoading, loadUserOrganisations]);
   const handleLogoutAndRedirect = useCallback7(async () => {
     try {
       await signOut();
@@ -7730,8 +7664,8 @@ var init_OrganisationProvider = __esm({
 });
 
 export {
-  useAuth,
   AuthProvider,
+  useAuth,
   init_AuthProvider,
   useRBAC,
   RBACProvider,
@@ -7785,4 +7719,4 @@ lodash/lodash.js:
    * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
    *)
 */
-//# sourceMappingURL=chunk-P27KH7XF.js.map
+//# sourceMappingURL=chunk-6CGBO4IS.js.map