@jmruthers/pace-core 0.5.72 → 0.5.74

package/dist/chunk-B5LK25HV.js

@@ -0,0 +1,953 @@
+import {
+  init_UnifiedAuthProvider,
+  useUnifiedAuth
+} from "./chunk-IHMMNKNA.js";
+import {
+  init_organisationContext,
+  setOrganisationContext
+} from "./chunk-3SP4P7NS.js";
+import {
+  DebugLogger,
+  init_debugLogger
+} from "./chunk-CDDYJCYU.js";
+import {
+  applyPalette,
+  clearPalette,
+  init_runtime
+} from "./chunk-SMJZMKYN.js";
+import {
+  __esm,
+  __export
+} from "./chunk-PLDDJCW6.js";
+
+// src/providers/OrganisationProvider.tsx
+var OrganisationProvider_exports = {};
+__export(OrganisationProvider_exports, {
+  OrganisationProvider: () => OrganisationProvider,
+  useOrganisations: () => useOrganisations
+});
+import { createContext, useContext, useState, useEffect, useCallback, useMemo, useRef } from "react";
+import { useNavigate } from "react-router-dom";
+import { jsx, jsxs } from "react/jsx-runtime";
+function OrganisationProvider({ children }) {
+  const [selectedOrganisation, setSelectedOrganisation] = useState(null);
+  const [organisations, setOrganisations] = useState([]);
+  const [userMemberships, setUserMemberships] = useState([]);
+  const [roleMapState, setRoleMapState] = useState(/* @__PURE__ */ new Map());
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const [isContextReady, setIsContextReady] = useState(false);
+  const [retryCount, setRetryCount] = useState(0);
+  const isLoadingRef = useRef(false);
+  const lastLoadTimeRef = useRef(0);
+  const hasFailedRef = useRef(false);
+  const abortControllerRef = useRef(null);
+  const { user, session, supabase, signOut } = useUnifiedAuth();
+  let navigate = null;
+  try {
+    navigate = useNavigate();
+  } catch (error2) {
+    navigate = null;
+  }
+  const clearAllCachedData = useCallback(() => {
+    localStorage.removeItem(STORAGE_KEYS.SELECTED_ORGANISATION);
+    localStorage.removeItem(STORAGE_KEYS.ORGANISATION_CONTEXT);
+    setSelectedOrganisation(null);
+    setOrganisations([]);
+    setUserMemberships([]);
+    setRoleMapState(/* @__PURE__ */ new Map());
+    setError(null);
+    setRetryCount(0);
+    setIsContextReady(false);
+  }, []);
+  const setDatabaseOrganisationContext = useCallback(async (organisation) => {
+    if (!supabase || !session) {
+      console.warn("[OrganisationProvider] No Supabase client or session available for setting organisation context");
+      setIsContextReady(false);
+      return;
+    }
+    try {
+      await setOrganisationContext(supabase, organisation.id);
+      DebugLogger.log("OrganisationProvider", "Database organisation context set to:", organisation.display_name);
+      setIsContextReady(true);
+    } catch (error2) {
+      console.error("[OrganisationProvider] Failed to set database organisation context:", error2);
+      setIsContextReady(false);
+    }
+  }, [supabase, session]);
+  useEffect(() => {
+    if (selectedOrganisation && supabase && session) {
+      setIsContextReady(false);
+      (async () => {
+        await setDatabaseOrganisationContext(selectedOrganisation);
+      })();
+    } else {
+      setIsContextReady(false);
+    }
+  }, [selectedOrganisation, setDatabaseOrganisationContext, supabase, session]);
+  const loadUserOrganisations = useCallback(async () => {
+    const callId = Math.random().toString(36).substr(2, 9);
+    console.log(`[OrganisationProvider] Starting loadUserOrganisations call ${callId}`);
+    if (!user || !session || !supabase) {
+      DebugLogger.log("OrganisationProvider", "Clearing organisation state - no user, session, or supabase client");
+      setSelectedOrganisation(null);
+      setOrganisations([]);
+      setUserMemberships([]);
+      setIsLoading(false);
+      setError(null);
+      return;
+    }
+    if (isLoadingRef.current) {
+      console.log("OrganisationProvider", "Already loading, skipping duplicate load");
+      return;
+    }
+    const now = Date.now();
+    if (now - lastLoadTimeRef.current < 2e3) {
+      console.log("OrganisationProvider", "Too soon since last load, skipping");
+      return;
+    }
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+    }
+    abortControllerRef.current = new AbortController();
+    const abortSignal = abortControllerRef.current.signal;
+    lastLoadTimeRef.current = now;
+    isLoadingRef.current = true;
+    setIsLoading(true);
+    setError(null);
+    try {
+      DebugLogger.log("OrganisationProvider", "Loading organisations for user:", user.id);
+      console.log("[OrganisationProvider] Supabase client ready:", {
+        isConnected: !!supabase,
+        hasAuth: !!supabase.auth,
+        hasRpc: !!supabase.rpc
+      });
+      let memberships, membershipError;
+      try {
+        console.log("[OrganisationProvider] Making RPC call to data_user_organisation_roles_get...");
+        const timeoutPromise = new Promise((_, reject) => {
+          const timeoutId = setTimeout(() => reject(new Error("RPC call timeout after 10 seconds")), 1e4);
+          abortSignal.addEventListener("abort", () => {
+            clearTimeout(timeoutId);
+            reject(new Error("Request aborted"));
+          });
+        });
+        const rpcPromise = supabase.rpc("data_user_organisation_roles_get", {
+          p_user_id: user.id,
+          p_organisation_id: null
+        });
+        if (abortSignal.aborted) {
+          throw new Error("Request aborted");
+        }
+        const result = await Promise.race([rpcPromise, timeoutPromise]);
+        console.log("[OrganisationProvider] RPC call completed:", {
+          hasData: !!result.data,
+          hasError: !!result.error,
+          dataLength: result.data?.length || 0,
+          errorMessage: result.error?.message || "No error"
+        });
+        memberships = result.data?.filter(
+          (role) => ["org_admin", "leader", "member"].includes(role.role)
+        ) || [];
+        membershipError = result.error;
+      } catch (queryError) {
+        membershipError = queryError;
+      }
+      if (membershipError) {
+        console.error("[OrganisationProvider] Error loading memberships:", membershipError);
+        if (membershipError.message?.includes("timeout")) {
+          console.log("[OrganisationProvider] RPC timed out, trying direct database query as fallback...");
+          try {
+            if (abortSignal.aborted) {
+              throw new Error("Request aborted");
+            }
+            const { data: fallbackData, error: fallbackError } = await supabase.from("rbac_organisation_roles").select(`
+                  id,
+                  user_id,
+                  organisation_id,
+                  role,
+                  status,
+                  granted_at,
+                  granted_by,
+                  revoked_at,
+                  revoked_by,
+                  notes,
+                  created_at,
+                  updated_at,
+                  organisations!inner(
+                    id,
+                    name,
+                    display_name,
+                    subscription_tier,
+                    settings,
+                    is_active,
+                    parent_id,
+                    created_at,
+                    updated_at
+                  )
+                `).eq("user_id", user.id).eq("status", "active").is("revoked_at", null).in("role", ["org_admin", "leader", "member"]);
+            if (fallbackError) {
+              console.error("[OrganisationProvider] Fallback query also failed:", fallbackError);
+              throw membershipError;
+            }
+            console.log("[OrganisationProvider] Fallback query successful, got", fallbackData?.length || 0, "memberships");
+            memberships = fallbackData || [];
+            membershipError = null;
+          } catch (fallbackErr) {
+            console.error("[OrganisationProvider] Fallback query failed:", fallbackErr);
+            throw membershipError;
+          }
+        } else {
+          throw membershipError;
+        }
+      }
+      DebugLogger.log("OrganisationProvider", "Raw memberships data:", memberships);
+      if (!memberships || memberships.length === 0) {
+        throw new Error("User has no active organisation memberships");
+      }
+      console.log("[OrganisationProvider] All memberships data:", memberships);
+      memberships.forEach((membership, index) => {
+        console.log(`[OrganisationProvider] Membership ${index}:`, {
+          organisation_id: membership.organisation_id,
+          type: typeof membership.organisation_id,
+          length: membership.organisation_id ? membership.organisation_id.length : "null/undefined",
+          trimmed: membership.organisation_id ? membership.organisation_id.trim() : "null/undefined"
+        });
+        if (!membership.organisation_id || membership.organisation_id.trim() === "") {
+          console.warn(`[OrganisationProvider] Membership ${index} has invalid organisation_id:`, membership);
+        }
+      });
+      const organisationIds = memberships.map((m) => m.organisation_id).filter((id) => {
+        if (!id || typeof id !== "string") {
+          console.warn("[OrganisationProvider] Invalid organisation ID (not string):", id);
+          return false;
+        }
+        const trimmedId = id.trim();
+        if (trimmedId === "") {
+          console.warn("[OrganisationProvider] Empty organisation ID found");
+          return false;
+        }
+        const isValidUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(trimmedId);
+        if (!isValidUuid) {
+          console.warn("[OrganisationProvider] Invalid UUID format:", trimmedId);
+        }
+        return isValidUuid;
+      });
+      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);
+      console.log("[OrganisationProvider] Raw organisation IDs before cleaning:", organisationIds);
+      console.log("[OrganisationProvider] Raw organisation IDs types:", organisationIds.map((id) => typeof id));
+      console.log("[OrganisationProvider] Raw organisation IDs lengths:", organisationIds.map((id) => id ? id.length : "null/undefined"));
+      const cleanOrganisationIds = organisationIds.filter((id) => {
+        const isValid = id && typeof id === "string" && id.trim() !== "";
+        if (!isValid) {
+          console.warn("[OrganisationProvider] Filtering out invalid ID:", { id, type: typeof id, length: id ? id.length : "null/undefined" });
+        }
+        return isValid;
+      }).map((id) => id.trim());
+      console.log("[OrganisationProvider] Clean organisation IDs after filtering:", cleanOrganisationIds);
+      if (cleanOrganisationIds.length === 0) {
+        console.warn("[OrganisationProvider] No clean organisation IDs after filtering:", organisationIds);
+        throw new Error("No valid organisation IDs found after cleaning");
+      }
+      DebugLogger.log("OrganisationProvider", "Clean organisation IDs for query:", cleanOrganisationIds);
+      const finalOrganisationIds = cleanOrganisationIds.filter((id) => {
+        const isEmpty = !id || id.trim() === "";
+        if (isEmpty) {
+          console.error("[OrganisationProvider] CRITICAL: Empty string found in final array:", { id, type: typeof id });
+        }
+        return !isEmpty;
+      });
+      if (finalOrganisationIds.length !== cleanOrganisationIds.length) {
+        console.error("[OrganisationProvider] CRITICAL: Empty strings were filtered out in final validation!");
+        console.error("Original:", cleanOrganisationIds);
+        console.error("Final:", finalOrganisationIds);
+      }
+      console.log("[OrganisationProvider] FINAL QUERY ARRAY:", {
+        array: finalOrganisationIds,
+        length: finalOrganisationIds.length,
+        types: finalOrganisationIds.map((id) => typeof id),
+        hasEmpty: finalOrganisationIds.some((id) => !id || id.trim() === ""),
+        stringified: JSON.stringify(finalOrganisationIds)
+      });
+      if (finalOrganisationIds.some((id) => !id || id.trim() === "")) {
+        console.error("[OrganisationProvider] ABORTING QUERY - Empty string detected in final array!");
+        throw new Error("Empty string detected in organisation IDs array - aborting query");
+      }
+      const safeOrganisationIds = [...finalOrganisationIds].filter((id) => {
+        const isValid = id && typeof id === "string" && id.trim() !== "";
+        if (!isValid) {
+          console.error("[OrganisationProvider] SAFETY FILTER: Removing invalid ID:", { id, type: typeof id });
+        }
+        return isValid;
+      });
+      console.log("[OrganisationProvider] SAFE ARRAY FOR QUERY:", {
+        original: finalOrganisationIds,
+        safe: safeOrganisationIds,
+        lengths: { original: finalOrganisationIds.length, safe: safeOrganisationIds.length }
+      });
+      console.log("[OrganisationProvider] Using direct table query with manual filtering");
+      if (abortSignal.aborted) {
+        throw new Error("Request aborted");
+      }
+      const { data: allOrganisations, error: orgError } = await supabase.from("organisations").select("id, name, display_name, subscription_tier, settings, is_active, parent_id, created_at, updated_at");
+      if (orgError) {
+        console.error("[OrganisationProvider] Error loading organisations:", orgError);
+        throw orgError;
+      }
+      const organisations2 = allOrganisations?.filter(
+        (org) => safeOrganisationIds.includes(org.id)
+      ) || [];
+      const roleMap = /* @__PURE__ */ new Map();
+      memberships?.forEach((membership) => {
+        roleMap.set(membership.organisation_id, membership.role);
+      });
+      const orgs = organisations2;
+      const activeOrgs = orgs.filter((org) => org.is_active);
+      if (activeOrgs.length === 0) {
+        throw new Error("User has no access to active organisations");
+      }
+      DebugLogger.log("OrganisationProvider", "Active organisations:", activeOrgs);
+      setOrganisations(activeOrgs);
+      setUserMemberships(memberships);
+      setRoleMapState(roleMap);
+      let initialOrg = null;
+      try {
+        const persistedOrgString = localStorage.getItem(STORAGE_KEYS.SELECTED_ORGANISATION);
+        if (persistedOrgString) {
+          const persistedOrg = JSON.parse(persistedOrgString);
+          if (persistedOrg.id && typeof persistedOrg.id === "string" && persistedOrg.id.trim() !== "") {
+            const validPersistedOrg = activeOrgs.find((org) => org.id === persistedOrg.id);
+            if (validPersistedOrg) {
+              initialOrg = validPersistedOrg;
+              DebugLogger.log("OrganisationProvider", "Restored persisted organisation:", initialOrg.display_name);
+            } else {
+              console.warn("[OrganisationProvider] Persisted organisation not found in active orgs, clearing cache");
+              localStorage.removeItem(STORAGE_KEYS.SELECTED_ORGANISATION);
+            }
+          } else {
+            console.warn("[OrganisationProvider] Invalid persisted organisation ID, clearing cache");
+            localStorage.removeItem(STORAGE_KEYS.SELECTED_ORGANISATION);
+          }
+        }
+      } catch (storageError) {
+        console.warn("[OrganisationProvider] Failed to restore persisted organisation:", storageError);
+        localStorage.removeItem(STORAGE_KEYS.SELECTED_ORGANISATION);
+      }
+      if (!initialOrg) {
+        const adminMembership = memberships.find((m) => m.role === "org_admin");
+        if (adminMembership) {
+          const foundOrg = organisations2.find((org) => org.id === adminMembership.organisation_id);
+          if (foundOrg) {
+            initialOrg = foundOrg;
+            DebugLogger.log("OrganisationProvider", "Selected org_admin organisation:", initialOrg.display_name);
+          }
+        }
+      }
+      if (!initialOrg) {
+        initialOrg = activeOrgs[0];
+        DebugLogger.log("OrganisationProvider", "Selected first organisation:", initialOrg.display_name);
+      }
+      if (!initialOrg) {
+        throw new Error("No valid organisation found for user");
+      }
+      setSelectedOrganisation(initialOrg);
+      localStorage.setItem(STORAGE_KEYS.SELECTED_ORGANISATION, JSON.stringify(initialOrg));
+      DebugLogger.log("OrganisationProvider", "Organisation context established:", {
+        selectedOrganisation: initialOrg.display_name,
+        totalOrganisations: activeOrgs.length,
+        userRole: roleMap.get(initialOrg.id)
+      });
+      setRetryCount(0);
+      hasFailedRef.current = false;
+    } catch (err) {
+      console.error("[OrganisationProvider] Failed to load organisations:", err);
+      setError(err);
+      setRetryCount((prev) => prev + 1);
+      hasFailedRef.current = true;
+      clearAllCachedData();
+    } finally {
+      isLoadingRef.current = false;
+      setIsLoading(false);
+      abortControllerRef.current = null;
+    }
+  }, [user, session, supabase, clearAllCachedData]);
+  useEffect(() => {
+    if (user && session && supabase && !isLoading && !isLoadingRef.current) {
+      if (retryCount >= 3 || hasFailedRef.current) {
+        console.error("[OrganisationProvider] Max retry count reached or failed flag set, stopping organisation loading");
+        setError(new Error("Failed to load organisations after multiple attempts"));
+        setIsLoading(false);
+        return;
+      }
+      if (retryCount > 0 && Date.now() - lastLoadTimeRef.current < 5e3) {
+        console.log("[OrganisationProvider] Circuit breaker active - too soon since last attempt");
+        return;
+      }
+      console.log("[OrganisationProvider] Authentication stable, loading organizations... (retry:", retryCount, ")");
+      loadUserOrganisations();
+    } else if (!user && !session) {
+      console.log("[OrganisationProvider] No authentication, clearing organization state");
+      setSelectedOrganisation(null);
+      setOrganisations([]);
+      setUserMemberships([]);
+      setRoleMapState(/* @__PURE__ */ new Map());
+      setIsLoading(false);
+      setError(null);
+      setRetryCount(0);
+      isLoadingRef.current = false;
+      hasFailedRef.current = false;
+      localStorage.removeItem(STORAGE_KEYS.SELECTED_ORGANISATION);
+      localStorage.removeItem(STORAGE_KEYS.ORGANISATION_CONTEXT);
+    }
+  }, [user, session, supabase, loadUserOrganisations]);
+  useEffect(() => {
+    return () => {
+      isLoadingRef.current = false;
+      hasFailedRef.current = false;
+      lastLoadTimeRef.current = 0;
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+        abortControllerRef.current = null;
+      }
+    };
+  }, []);
+  const handleLogoutAndRedirect = useCallback(async () => {
+    try {
+      await signOut();
+      if (navigate) {
+        navigate("/login", { replace: true });
+      } else {
+        window.location.href = "/login";
+      }
+    } catch (error2) {
+      console.error("[OrganisationProvider] Error during logout:", error2);
+      if (navigate) {
+        navigate("/login", { replace: true });
+      } else {
+        window.location.href = "/login";
+      }
+    }
+  }, [signOut, navigate]);
+  const ensureOrganisationContext = useCallback(() => {
+    if (!selectedOrganisation) {
+      throw new Error("Organisation context is required but not available");
+    }
+    return selectedOrganisation;
+  }, [selectedOrganisation]);
+  const getUserRole = useCallback((orgId) => {
+    const targetOrgId = orgId || selectedOrganisation?.id;
+    if (!targetOrgId) return "no_access";
+    return roleMapState.get(targetOrgId) || "no_access";
+  }, [roleMapState, selectedOrganisation]);
+  const validateOrganisationAccess = useCallback((orgId) => {
+    return userMemberships.some(
+      (m) => m.organisation_id === orgId && m.status === "active" && m.revoked_at === null
+    );
+  }, [userMemberships]);
+  const switchOrganisation = useCallback(async (orgId) => {
+    DebugLogger.log("OrganisationProvider", "Switching to organisation:", orgId);
+    if (!validateOrganisationAccess(orgId)) {
+      throw new Error(`User does not have access to organisation ${orgId}`);
+    }
+    const targetOrg = organisations.find((org) => org.id === orgId);
+    if (!targetOrg) {
+      throw new Error(`Organisation ${orgId} not found in user's organisations`);
+    }
+    setSelectedOrganisation(targetOrg);
+    localStorage.setItem(STORAGE_KEYS.SELECTED_ORGANISATION, JSON.stringify(targetOrg));
+    await setDatabaseOrganisationContext(targetOrg);
+    DebugLogger.log("OrganisationProvider", "Switched to organisation:", targetOrg.display_name);
+  }, [organisations, validateOrganisationAccess, setDatabaseOrganisationContext]);
+  const refreshOrganisations = useCallback(async () => {
+    if (!user || !session || !supabase) return;
+    setIsLoading(true);
+  }, [user, session, supabase]);
+  const getPrimaryOrganisation = useCallback(() => {
+    const rolePriority = ["org_admin", "leader", "member"];
+    for (const role of rolePriority) {
+      const membership = userMemberships.find((m) => m.role === role);
+      if (membership) {
+        return organisations.find((org) => org.id === membership.organisation_id) || null;
+      }
+    }
+    return null;
+  }, [userMemberships, organisations]);
+  const isOrganisationSecure = useCallback(() => {
+    return !!(selectedOrganisation && user);
+  }, [selectedOrganisation, user]);
+  const buildOrganisationHierarchy = useCallback((orgs) => {
+    const orgMap = /* @__PURE__ */ new Map();
+    orgs.forEach((org) => orgMap.set(org.id, org));
+    const roots = [];
+    orgs.forEach((org) => {
+      if (!org.parent_id) {
+        roots.push({
+          organisation: org,
+          children: [],
+          depth: 0
+        });
+      }
+    });
+    return roots;
+  }, []);
+  const hasValidOrganisationContext = useMemo(() => {
+    return !!(selectedOrganisation && !isLoading && !error && isContextReady);
+  }, [selectedOrganisation, isLoading, error, isContextReady]);
+  const contextValue = useMemo(() => {
+    if (!selectedOrganisation) {
+      const placeholderOrg = {
+        id: "",
+        name: "",
+        display_name: "",
+        subscription_tier: "standard",
+        settings: {},
+        is_active: false,
+        created_at: "",
+        updated_at: ""
+      };
+      return {
+        selectedOrganisation: placeholderOrg,
+        organisations: [],
+        userMemberships: [],
+        isLoading,
+        error,
+        hasValidOrganisationContext: false,
+        setSelectedOrganisation: () => {
+        },
+        switchOrganisation: async () => {
+        },
+        getUserRole: () => "no_access",
+        validateOrganisationAccess: () => false,
+        refreshOrganisations: async () => {
+        },
+        ensureOrganisationContext: () => {
+          throw new Error("No organisation context");
+        },
+        isOrganisationSecure: () => false,
+        getPrimaryOrganisation: () => null
+      };
+    }
+    return {
+      selectedOrganisation,
+      organisations,
+      userMemberships,
+      isLoading,
+      error,
+      hasValidOrganisationContext,
+      setSelectedOrganisation,
+      switchOrganisation,
+      getUserRole,
+      validateOrganisationAccess,
+      refreshOrganisations,
+      ensureOrganisationContext,
+      isOrganisationSecure,
+      getPrimaryOrganisation
+    };
+  }, [
+    selectedOrganisation,
+    organisations,
+    userMemberships,
+    isLoading,
+    error,
+    hasValidOrganisationContext,
+    switchOrganisation,
+    getUserRole,
+    validateOrganisationAccess,
+    refreshOrganisations,
+    ensureOrganisationContext,
+    isOrganisationSecure,
+    getPrimaryOrganisation
+  ]);
+  if (isLoading || selectedOrganisation && !isContextReady) {
+    return /* @__PURE__ */ jsx("div", { className: "organisation-loading", role: "status", "aria-label": "Loading organisation context", children: /* @__PURE__ */ jsx("div", { className: "flex items-center justify-center min-h-screen", children: /* @__PURE__ */ jsxs("div", { className: "text-center", children: [
+      /* @__PURE__ */ jsx("div", { className: "animate-spin rounded-full h-8 w-8 border-b-2 border-primary mx-auto mb-4" }),
+      /* @__PURE__ */ jsx("p", { className: "text-muted-foreground", children: isLoading ? "Loading organisation context..." : "Setting up organisation context..." })
+    ] }) }) });
+  }
+  if (error || user && !selectedOrganisation) {
+    return /* @__PURE__ */ jsx("div", { className: "organisation-error", role: "alert", children: /* @__PURE__ */ jsx("div", { className: "flex items-center justify-center min-h-screen", children: /* @__PURE__ */ jsxs("div", { className: "text-center max-w-md mx-auto p-6", children: [
+      /* @__PURE__ */ jsx("div", { className: "text-destructive mb-4", children: /* @__PURE__ */ jsx("svg", { className: "h-12 w-12 mx-auto", fill: "none", viewBox: "0 0 24 24", stroke: "currentColor", children: /* @__PURE__ */ jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", strokeWidth: 2, d: "M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-2.5L13.732 4c-.77-.833-1.732-.833-2.464 0L4.35 16.5c-.77.833.192 2.5 1.732 2.5z" }) }) }),
+      /* @__PURE__ */ jsx("h2", { className: "text-xl font-semibold text-foreground mb-2", children: "Organisation Access Required" }),
+      /* @__PURE__ */ jsx("p", { className: "text-muted-foreground mb-4", children: error?.message || "No valid organisation context available. Please contact your administrator to be added to an organisation." }),
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          onClick: handleLogoutAndRedirect,
+          className: "px-4 py-2 bg-primary text-primary-foreground rounded-md hover:bg-primary/90",
+          children: "Sign Out"
+        }
+      )
+    ] }) }) });
+  }
+  return /* @__PURE__ */ jsx(OrganisationContext.Provider, { value: contextValue, children });
+}
+var OrganisationContext, STORAGE_KEYS, useOrganisations;
+var init_OrganisationProvider = __esm({
+  "src/providers/OrganisationProvider.tsx"() {
+    "use strict";
+    init_UnifiedAuthProvider();
+    init_organisationContext();
+    init_debugLogger();
+    OrganisationContext = createContext(void 0);
+    STORAGE_KEYS = {
+      SELECTED_ORGANISATION: "pace-core-selected-organisation",
+      ORGANISATION_CONTEXT: "pace-core-organisation-context"
+    };
+    useOrganisations = () => {
+      const context = useContext(OrganisationContext);
+      if (!context) {
+        throw new Error("useOrganisations must be used within an OrganisationProvider");
+      }
+      return context;
+    };
+  }
+});
+
+// src/providers/EventProvider.tsx
+var EventProvider_exports = {};
+__export(EventProvider_exports, {
+  EventProvider: () => EventProvider,
+  useEvents: () => useEvents
+});
+import {
+  createContext as createContext2,
+  useContext as useContext2,
+  useState as useState2,
+  useEffect as useEffect2,
+  useLayoutEffect,
+  useCallback as useCallback2,
+  useRef as useRef2,
+  useMemo as useMemo2
+} from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+function getNextEventByDate(events) {
+  if (!events || events.length === 0) {
+    return null;
+  }
+  const now = /* @__PURE__ */ new Date();
+  const futureEvents = events.filter((event) => {
+    if (!event.event_date) return false;
+    const eventDate = new Date(event.event_date);
+    return eventDate >= now;
+  });
+  if (futureEvents.length === 0) {
+    return null;
+  }
+  const sortedFutureEvents = futureEvents.sort((a, b) => {
+    const dateA = new Date(a.event_date);
+    const dateB = new Date(b.event_date);
+    return dateA.getTime() - dateB.getTime();
+  });
+  return sortedFutureEvents[0];
+}
+function EventProvider({ children }) {
+  const [events, setEvents] = useState2([]);
+  const [selectedEvent, setSelectedEventState] = useState2(null);
+  const [isLoading, setIsLoading] = useState2(true);
+  const [error, setError] = useState2(null);
+  const { user, session, supabase, appName, setSelectedEventId } = useUnifiedAuth();
+  const isInitializedRef = useRef2(false);
+  const isFetchingRef = useRef2(false);
+  const hasAutoSelectedRef = useRef2(false);
+  const userClearedEventRef = useRef2(false);
+  const setSelectedEventIdRef = useRef2(setSelectedEventId);
+  let selectedOrganisation = null;
+  let ensureOrganisationContext = null;
+  try {
+    const orgContext = useOrganisations();
+    selectedOrganisation = orgContext.selectedOrganisation;
+    ensureOrganisationContext = orgContext.ensureOrganisationContext;
+  } catch (error2) {
+    console.warn("[EventProvider] Organisation context not available:", error2);
+  }
+  const loadPersistedEvent = useCallback2(async (events2) => {
+    try {
+      let persistedEventId = sessionStorage.getItem("pace-core-selected-event");
+      if (!persistedEventId) {
+        persistedEventId = localStorage.getItem("pace-core-selected-event");
+        if (persistedEventId) {
+          sessionStorage.setItem("pace-core-selected-event", persistedEventId);
+        }
+      }
+      if (persistedEventId && events2.length > 0) {
+        const persistedEvent = events2.find((event) => event.event_id === persistedEventId);
+        if (persistedEvent) {
+          DebugLogger.log("EventProvider", "Restoring persisted event:", persistedEvent.event_name);
+          setSelectedEventState(persistedEvent);
+          setSelectedEventId(persistedEventId);
+          return true;
+        } else {
+          DebugLogger.log("EventProvider", "Persisted event not found in current events, clearing storage");
+          sessionStorage.removeItem("pace-core-selected-event");
+          localStorage.removeItem("pace-core-selected-event");
+        }
+      }
+    } catch (error2) {
+      console.warn("[EventProvider] Failed to load persisted event:", error2);
+    }
+    return false;
+  }, [setSelectedEventId]);
+  const persistEventSelection = useCallback2((eventId) => {
+    try {
+      sessionStorage.setItem("pace-core-selected-event", eventId);
+      localStorage.setItem("pace-core-selected-event", eventId);
+    } catch (error2) {
+      console.warn("[EventProvider] Failed to persist event selection:", error2);
+    }
+  }, []);
+  const autoSelectNextEvent = useCallback2((events2) => {
+    const nextEvent = getNextEventByDate(events2);
+    if (nextEvent) {
+      DebugLogger.log("EventProvider", "Auto-selecting next event:", nextEvent.event_name);
+      setSelectedEventState(nextEvent);
+      setSelectedEventId(nextEvent.event_id);
+      persistEventSelection(nextEvent.event_id);
+    }
+  }, [setSelectedEventId, persistEventSelection]);
+  const fetchEvents = useCallback2(async () => {
+    if (!user || !session || !supabase || !appName || !selectedOrganisation) {
+      DebugLogger.log("EventProvider", "Missing required dependencies, skipping fetch");
+      setIsLoading(false);
+      return;
+    }
+    if (isFetchingRef.current) {
+      DebugLogger.log("EventProvider", "Already fetching events, skipping");
+      return;
+    }
+    DebugLogger.log("EventProvider", "User and organisation found, fetching events for:", {
+      userId: user.id,
+      appName,
+      organisationId: selectedOrganisation.id,
+      organisationName: selectedOrganisation.display_name
+    });
+    isFetchingRef.current = true;
+    let isMounted = true;
+    try {
+      if (ensureOrganisationContext) {
+        await ensureOrganisationContext();
+        await setOrganisationContext(supabase, selectedOrganisation.id);
+      }
+      DebugLogger.log("EventProvider", "Calling data_user_events_get RPC with:", {
+        user_id: user.id,
+        organisation_id: selectedOrganisation.id,
+        app_name: appName
+      });
+      const { data, error: rpcError } = await supabase.rpc("data_user_events_get", {
+        p_user_id: user.id,
+        p_organisation_id: selectedOrganisation.id,
+        p_app_name: appName
+      });
+      DebugLogger.log("EventProvider", "RPC response:", {
+        data,
+        error: rpcError,
+        dataLength: data?.length || 0,
+        organisationId: selectedOrganisation.id
+      });
+      if (rpcError) {
+        throw new Error(rpcError.message || "Failed to fetch events");
+      }
+      if (isMounted) {
+        const eventsData = data || [];
+        console.log("[EventProvider] Loaded events:", eventsData.map((event) => ({
+          eventId: event.event_id,
+          eventName: event.event_name,
+          organisationId: event.organisation_id,
+          selectedOrganisationId: selectedOrganisation?.id
+        })));
+        const transformedEvents = eventsData.map((event) => ({
+          id: event.event_id,
+          // Use event_id as the primary id
+          event_id: event.event_id,
+          event_name: event.event_name,
+          event_date: event.event_date,
+          event_venue: event.event_venue,
+          event_participants: event.event_participants,
+          event_colours: event.event_colours,
+          event_logo: "",
+          // No logo field in event table
+          organisation_id: event.organisation_id,
+          is_visible: event.is_visible,
+          // Legacy compatibility
+          name: event.event_name,
+          start_date: event.event_date
+        }));
+        setEvents(transformedEvents);
+        setError(null);
+        hasAutoSelectedRef.current = false;
+        const persistedEventLoaded = await loadPersistedEvent(transformedEvents);
+        if (!persistedEventLoaded) {
+          const nextEvent = getNextEventByDate(transformedEvents);
+          if (nextEvent) {
+            DebugLogger.log("EventProvider", "Auto-selecting next event after no persisted event found:", nextEvent.event_name);
+            hasAutoSelectedRef.current = true;
+            setSelectedEventState(nextEvent);
+            setSelectedEventIdRef.current(nextEvent.event_id);
+            persistEventSelection(nextEvent.event_id);
+          }
+        }
+      }
+    } catch (err) {
+      console.error("[EventProvider] Error fetching events:", err);
+      const _error = err instanceof Error ? err : new Error("Unknown error occurred");
+      if (isMounted) {
+        setError(_error);
+        setEvents([]);
+      }
+    } finally {
+      if (isMounted) {
+        setIsLoading(false);
+      }
+      isFetchingRef.current = false;
+    }
+    return () => {
+      isMounted = false;
+    };
+  }, [user, session, supabase, appName, selectedOrganisation, ensureOrganisationContext, loadPersistedEvent, autoSelectNextEvent]);
+  useEffect2(() => {
+    if (!isInitializedRef.current) {
+      isInitializedRef.current = true;
+      fetchEvents();
+    }
+  }, [fetchEvents]);
+  useEffect2(() => {
+    setSelectedEventIdRef.current = setSelectedEventId;
+  }, [setSelectedEventId]);
+  useLayoutEffect(() => {
+    if (events.length > 0 && !selectedEvent && !hasAutoSelectedRef.current && !userClearedEventRef.current) {
+      const nextEvent = getNextEventByDate(events);
+      if (nextEvent) {
+        DebugLogger.log("EventProvider", "Auto-selecting next event:", nextEvent.event_name);
+        hasAutoSelectedRef.current = true;
+        setSelectedEventState(nextEvent);
+        setSelectedEventIdRef.current(nextEvent.event_id);
+        persistEventSelection(nextEvent.event_id);
+      }
+    }
+  }, [events, selectedEvent]);
+  useEffect2(() => {
+    console.log("[EventProvider] Event theming useEffect triggered, selectedEvent:", selectedEvent?.event_name, selectedEvent?.event_colours);
+    if (!selectedEvent) {
+      console.log("[EventProvider] No selected event, clearing palette");
+      clearPalette();
+      return;
+    }
+    const eventColours = selectedEvent.event_colours;
+    console.log("[EventProvider] Event colours:", eventColours);
+    console.log("[EventProvider] Event colours keys:", Object.keys(eventColours || {}));
+    if (!eventColours || typeof eventColours !== "object") {
+      console.log("[EventProvider] No valid event_colours, clearing palette");
+      clearPalette();
+      return;
+    }
+    const evMainPalette = eventColours["ev-main"] || eventColours.main || {};
+    const evSecPalette = eventColours["ev-sec"] || eventColours.sec || {};
+    const evAccPalette = eventColours["ev-acc"] || eventColours.acc || {};
+    console.log("[EventProvider] Mapped palettes:", {
+      "ev-main": Object.keys(evMainPalette),
+      "ev-sec": Object.keys(evSecPalette),
+      "ev-acc": Object.keys(evAccPalette)
+    });
+    const fullPalette = {
+      main: evMainPalette,
+      sec: evSecPalette,
+      acc: evAccPalette
+    };
+    if (!fullPalette.main && !fullPalette.sec && !fullPalette.acc) {
+      console.log("[EventProvider] No valid palettes found in event_colours, clearing palette");
+      clearPalette();
+      return;
+    }
+    console.log("[EventProvider] Applying full palette:", fullPalette);
+    try {
+      applyPalette(fullPalette);
+      console.log("[EventProvider] Palette applied successfully");
+    } catch (error2) {
+      console.error("[EventProvider] Failed to apply event palette:", error2);
+    }
+  }, [selectedEvent]);
+  const setSelectedEvent = useCallback2((event) => {
+    if (event) {
+      try {
+        console.log("[EventProvider] Event selection validation:", {
+          eventId: event.event_id,
+          eventName: event.event_name,
+          eventOrganisationId: event.organisation_id,
+          selectedOrganisationId: selectedOrganisation?.id,
+          selectedOrganisationName: selectedOrganisation?.display_name,
+          match: event.organisation_id === selectedOrganisation?.id
+        });
+        if (selectedOrganisation && event.organisation_id !== selectedOrganisation.id) {
+          console.error("[EventProvider] Event organisation_id does not match selected organisation", {
+            eventOrganisationId: event.organisation_id,
+            selectedOrganisationId: selectedOrganisation.id,
+            eventName: event.event_name
+          });
+          return;
+        }
+      } catch (error2) {
+        console.error("[EventProvider] Error during event validation:", error2);
+      }
+      setSelectedEventState(event);
+      setSelectedEventId(event.event_id);
+      persistEventSelection(event.event_id);
+      userClearedEventRef.current = false;
+    } else {
+      setSelectedEventState(null);
+      setSelectedEventId(null);
+      sessionStorage.removeItem("pace-core-selected-event");
+      localStorage.removeItem("pace-core-selected-event");
+      hasAutoSelectedRef.current = false;
+      userClearedEventRef.current = true;
+    }
+  }, [selectedOrganisation, setSelectedEventId, persistEventSelection]);
+  const refreshEvents = useCallback2(async () => {
+    isInitializedRef.current = false;
+    isFetchingRef.current = false;
+    userClearedEventRef.current = false;
+    await fetchEvents();
+  }, [fetchEvents]);
+  const contextValue = useMemo2(() => ({
+    events,
+    selectedEvent,
+    isLoading,
+    error,
+    setSelectedEvent,
+    refreshEvents
+  }), [events, selectedEvent, isLoading, error, setSelectedEvent, refreshEvents]);
+  return /* @__PURE__ */ jsx2(EventContext.Provider, { value: contextValue, children });
+}
+var EventContext, useEvents;
+var init_EventProvider = __esm({
+  "src/providers/EventProvider.tsx"() {
+    "use strict";
+    init_UnifiedAuthProvider();
+    init_OrganisationProvider();
+    init_organisationContext();
+    init_debugLogger();
+    init_runtime();
+    EventContext = createContext2(void 0);
+    useEvents = () => {
+      const context = useContext2(EventContext);
+      if (context === void 0) {
+        throw new Error("useEvents must be used within an EventProvider");
+      }
+      return context;
+    };
+  }
+});
+
+export {
+  OrganisationProvider,
+  useOrganisations,
+  OrganisationProvider_exports,
+  init_OrganisationProvider,
+  useEvents,
+  EventProvider,
+  EventProvider_exports,
+  init_EventProvider
+};
+//# sourceMappingURL=chunk-B5LK25HV.js.map