@jmruthers/pace-core 0.5.78 → 0.5.80

package/dist/{DataTable-ETGVF4Y5.js → DataTable-OOZS7YTJ.js}

@@ -53,8 +53,8 @@ import {
   sortHierarchicalDataWithSorting,
   validateHierarchicalData,
   validatePaginationConfig
-} from "./chunk-ZMNXIJP4.js";
-import "./chunk-LRQ6RBJC.js";
+} from "./chunk-MVFZYTIZ.js";
+import "./chunk-YVUZWLQG.js";
 import "./chunk-S63MFSY6.js";
 import "./chunk-Q7APDV6H.js";
 import {
@@ -75,9 +75,9 @@ import {
   throttle,
   useDataTablePerformance
 } from "./chunk-YCKPEMJA.js";
-import "./chunk-FT2M4R4F.js";
-import "./chunk-FL4ZCQLD.js";
-import "./chunk-MNJXXD6C.js";
+import "./chunk-CBSD3BZ3.js";
+import "./chunk-RIXPZJUB.js";
+import "./chunk-5BN3YGNK.js";
 import "./chunk-PYUXFQJ3.js";
 import "./chunk-JCQZ6LA7.js";
 import "./chunk-CVMVPYAL.js";
@@ -154,4 +154,4 @@ export {
   validateHierarchicalData,
   validatePaginationConfig
 };
-//# sourceMappingURL=DataTable-ETGVF4Y5.js.map
+//# sourceMappingURL=DataTable-OOZS7YTJ.js.map

package/dist/{UnifiedAuthProvider-P5SOJAQ6.js → UnifiedAuthProvider-K2IZAY5F.js}

@@ -1,10 +1,10 @@
 import {
   init_UnifiedAuthProvider
-} from "./chunk-FL4ZCQLD.js";
+} from "./chunk-RIXPZJUB.js";
 import {
   UnifiedAuthProvider,
   useUnifiedAuth
-} from "./chunk-MNJXXD6C.js";
+} from "./chunk-5BN3YGNK.js";
 import "./chunk-CVMVPYAL.js";
 import "./chunk-PLDDJCW6.js";
 init_UnifiedAuthProvider();
@@ -12,4 +12,4 @@ export {
   UnifiedAuthProvider,
   useUnifiedAuth
 };
-//# sourceMappingURL=UnifiedAuthProvider-P5SOJAQ6.js.map
+//# sourceMappingURL=UnifiedAuthProvider-K2IZAY5F.js.map

package/dist/{chunk-MNJXXD6C.js → chunk-5BN3YGNK.js}

@@ -1001,6 +1001,10 @@ var init_EventService = __esm({
       }
       // Event state getters
       getEvents() {
+        console.log("[EventService] getEvents() called, returning:", {
+          count: this.events.length,
+          events: this.events.map((e) => ({ id: e.event_id, name: e.event_name }))
+        });
         return this.events;
       }
       getSelectedEvent() {
@@ -1165,6 +1169,10 @@ var init_EventService = __esm({
               start_date: event.event_date
             }));
             this.events = transformedEvents;
+            console.log("[EventService] Set events in service:", {
+              count: transformedEvents.length,
+              events: transformedEvents.map((e) => ({ id: e.event_id, name: e.event_name }))
+            });
             this.error = null;
             this.hasAutoSelectedRef = false;
             const persistedEventLoaded = await this.loadPersistedEvent(transformedEvents);
@@ -1713,8 +1721,8 @@ var init_useInactivityService = __esm({
 });
 
 // src/providers/services/UnifiedAuthProvider.tsx
-import { createContext as createContext5, useContext as useContext9, useMemo as useMemo5 } from "react";
-import { Fragment, jsx as jsx5 } from "react/jsx-runtime";
+import { createContext as createContext5, useContext as useContext9, useMemo as useMemo5, useCallback, useRef as useRef4 } from "react";
+import { jsx as jsx5 } from "react/jsx-runtime";
 function UnifiedAuthContextProvider({
   children,
   appName,
@@ -1747,16 +1755,68 @@ function UnifiedAuthContextProvider({
   const orgLoading = organisationService.isLoading();
   const eventLoading = eventService.isLoading();
   const totalLoading = authLoading || orgLoading || eventLoading;
-  console.log("[UnifiedAuthContext] Auth state:", {
-    isAuthenticated: isAuth,
-    user: currentUser?.email,
-    session: currentSession ? "exists" : "null",
-    totalLoading,
-    authLoading,
-    orgLoading,
-    eventLoading,
-    orgContextReady: organisationService.isContextReady()
-  });
+  const authError = authService.getError();
+  const supabase = authService.getSupabaseClient();
+  const selectedOrganisation = organisationService.getSelectedOrganisation();
+  const organisations = organisationService.getOrganisations();
+  const userMemberships = organisationService.getUserMemberships();
+  const organisationError = organisationService.getError();
+  const hasValidOrganisationContext = organisationService.hasValidOrganisationContext();
+  const isContextReady = organisationService.isContextReady();
+  const events = eventService.getEvents();
+  const selectedEvent = eventService.getSelectedEvent();
+  const eventError = eventService.getError();
+  const showInactivityWarning = inactivityService.getShowInactivityWarning();
+  const inactivityTimeRemaining = inactivityService.getInactivityTimeRemaining();
+  const isIdle = inactivityService.isIdle();
+  const timeRemaining = inactivityService.getTimeRemaining();
+  const showWarning = inactivityService.isWarningShown();
+  const isTracking = inactivityService.isTracking();
+  const hasErrors = !!(authError || organisationError || eventError);
+  const signIn = useCallback((email, password) => authService.signIn(email, password), [authService]);
+  const signUp = useCallback((email, password) => authService.signUp(email, password), [authService]);
+  const signOut = useCallback(() => authService.signOut(), [authService]);
+  const resetPassword = useCallback((email) => authService.resetPassword(email), [authService]);
+  const updatePassword = useCallback((password) => authService.updatePassword(password), [authService]);
+  const refreshSession = useCallback(() => authService.refreshSession(), [authService]);
+  const switchOrganisation = useCallback((orgId) => organisationService.switchOrganisation(orgId), [organisationService]);
+  const getUserRole = useCallback((orgId) => organisationService.getUserRole(orgId), [organisationService]);
+  const validateOrganisationAccess = useCallback((orgId) => organisationService.validateOrganisationAccess(orgId), [organisationService]);
+  const refreshOrganisations = useCallback(() => organisationService.refreshOrganisations(), [organisationService]);
+  const ensureOrganisationContext = useCallback(() => organisationService.ensureOrganisationContext(), [organisationService]);
+  const isOrganisationSecure = useCallback(() => organisationService.isOrganisationSecure(), [organisationService]);
+  const getPrimaryOrganisation = useCallback(() => organisationService.getPrimaryOrganisation(), [organisationService]);
+  const setSelectedEvent = useCallback((event) => eventService.setSelectedEvent(event), [eventService]);
+  const refreshEvents = useCallback(() => eventService.refreshEvents(), [eventService]);
+  const resetActivity = useCallback(() => inactivityService.resetActivity(), [inactivityService]);
+  const startTracking = useCallback(() => inactivityService.startTracking(), [inactivityService]);
+  const stopTracking = useCallback(() => inactivityService.stopTracking(), [inactivityService]);
+  const handleIdleLogout = useCallback(() => inactivityService.handleIdleLogout(), [inactivityService]);
+  const handleStaySignedIn = useCallback(() => inactivityService.handleStaySignedIn(), [inactivityService]);
+  const handleSignOutNow = useCallback(() => inactivityService.handleSignOutNow(), [inactivityService]);
+  const prevStateRef = useRef4(null);
+  const isDev = import.meta.env.DEV || import.meta.env.MODE === "development";
+  if (isDev) {
+    const currentState = {
+      isAuthenticated: isAuth,
+      userEmail: currentUser?.email,
+      totalLoading
+    };
+    const prevState = prevStateRef.current;
+    if (!prevState || prevState.isAuthenticated !== currentState.isAuthenticated || prevState.userEmail !== currentState.userEmail || prevState.totalLoading !== currentState.totalLoading) {
+      console.log("[UnifiedAuthContext] Auth state changed:", {
+        isAuthenticated: isAuth,
+        user: currentUser?.email,
+        session: currentSession ? "exists" : "null",
+        totalLoading,
+        authLoading,
+        orgLoading,
+        eventLoading,
+        orgContextReady: isContextReady
+      });
+      prevStateRef.current = currentState;
+    }
+  }
   const contextValue = useMemo5(() => {
     return {
       // Auth state
@@ -1764,62 +1824,114 @@ function UnifiedAuthContextProvider({
       session: currentSession,
       isAuthenticated: isAuth,
       authLoading,
-      authError: authService.getError(),
-      error: authService.getError(),
+      authError,
+      error: authError,
       // Alias for backward compatibility
-      supabase: authService.getSupabaseClient(),
+      supabase,
       // Auth methods
-      signIn: authService.signIn.bind(authService),
-      signUp: authService.signUp.bind(authService),
-      signOut: authService.signOut.bind(authService),
-      resetPassword: authService.resetPassword.bind(authService),
-      updatePassword: authService.updatePassword.bind(authService),
-      refreshSession: authService.refreshSession.bind(authService),
+      signIn,
+      signUp,
+      signOut,
+      resetPassword,
+      updatePassword,
+      refreshSession,
       // Organisation state
-      selectedOrganisation: organisationService.getSelectedOrganisation(),
-      organisations: organisationService.getOrganisations(),
-      userMemberships: organisationService.getUserMemberships(),
+      selectedOrganisation,
+      organisations,
+      userMemberships,
       organisationLoading: orgLoading,
-      organisationError: organisationService.getError(),
-      hasValidOrganisationContext: organisationService.hasValidOrganisationContext(),
-      isContextReady: organisationService.isContextReady(),
+      organisationError,
+      hasValidOrganisationContext,
+      isContextReady,
       // Organisation methods
-      switchOrganisation: organisationService.switchOrganisation.bind(organisationService),
-      getUserRole: organisationService.getUserRole.bind(organisationService),
-      validateOrganisationAccess: organisationService.validateOrganisationAccess.bind(organisationService),
-      refreshOrganisations: organisationService.refreshOrganisations.bind(organisationService),
-      ensureOrganisationContext: organisationService.ensureOrganisationContext.bind(organisationService),
-      isOrganisationSecure: organisationService.isOrganisationSecure.bind(organisationService),
-      getPrimaryOrganisation: organisationService.getPrimaryOrganisation.bind(organisationService),
+      switchOrganisation,
+      getUserRole,
+      validateOrganisationAccess,
+      refreshOrganisations,
+      ensureOrganisationContext,
+      isOrganisationSecure,
+      getPrimaryOrganisation,
       // Event state
-      events: eventService.getEvents(),
-      selectedEvent: eventService.getSelectedEvent(),
+      events,
+      selectedEvent,
       eventLoading,
-      eventError: eventService.getError(),
+      eventError,
       // Event methods
-      setSelectedEvent: eventService.setSelectedEvent.bind(eventService),
-      refreshEvents: eventService.refreshEvents.bind(eventService),
+      setSelectedEvent,
+      refreshEvents,
       // Inactivity state
-      showInactivityWarning: inactivityService.getShowInactivityWarning(),
-      inactivityTimeRemaining: inactivityService.getInactivityTimeRemaining(),
-      isIdle: inactivityService.isIdle(),
-      timeRemaining: inactivityService.getTimeRemaining(),
-      showWarning: inactivityService.isWarningShown(),
-      isTracking: inactivityService.isTracking(),
+      showInactivityWarning,
+      inactivityTimeRemaining,
+      isIdle,
+      timeRemaining,
+      showWarning,
+      isTracking,
       // Inactivity methods
-      resetActivity: inactivityService.resetActivity.bind(inactivityService),
-      startTracking: inactivityService.startTracking.bind(inactivityService),
-      stopTracking: inactivityService.stopTracking.bind(inactivityService),
-      handleIdleLogout: inactivityService.handleIdleLogout.bind(inactivityService),
-      handleStaySignedIn: inactivityService.handleStaySignedIn.bind(inactivityService),
-      handleSignOutNow: inactivityService.handleSignOutNow.bind(inactivityService),
+      resetActivity,
+      startTracking,
+      stopTracking,
+      handleIdleLogout,
+      handleStaySignedIn,
+      handleSignOutNow,
       // Additional unified properties
       appName,
       appConfig,
       isLoading: totalLoading,
-      hasErrors: !!(authService.getError() || organisationService.getError() || eventService.getError())
+      hasErrors
     };
-  }, [authService, organisationService, eventService, inactivityService, appName, appConfig, currentUser, currentSession, isAuth, authLoading, orgLoading, eventLoading, totalLoading]);
+  }, [
+    // All primitive values extracted from services
+    // Note: Arrays/objects from services are stable references (same reference unless data changes)
+    currentUser,
+    currentSession,
+    isAuth,
+    authLoading,
+    authError,
+    supabase,
+    selectedOrganisation,
+    organisations,
+    userMemberships,
+    orgLoading,
+    organisationError,
+    hasValidOrganisationContext,
+    isContextReady,
+    events,
+    selectedEvent,
+    eventLoading,
+    eventError,
+    showInactivityWarning,
+    inactivityTimeRemaining,
+    isIdle,
+    timeRemaining,
+    showWarning,
+    isTracking,
+    totalLoading,
+    hasErrors,
+    appName,
+    appConfig,
+    // Stable function references from useCallback (services are stable, so callbacks are too)
+    signIn,
+    signUp,
+    signOut,
+    resetPassword,
+    updatePassword,
+    refreshSession,
+    switchOrganisation,
+    getUserRole,
+    validateOrganisationAccess,
+    refreshOrganisations,
+    ensureOrganisationContext,
+    isOrganisationSecure,
+    getPrimaryOrganisation,
+    setSelectedEvent,
+    refreshEvents,
+    resetActivity,
+    startTracking,
+    stopTracking,
+    handleIdleLogout,
+    handleStaySignedIn,
+    handleSignOutNow
+  ]);
   return /* @__PURE__ */ jsx5(UnifiedAuthContext.Provider, { value: contextValue, children });
 }
 function EventServiceProviderWrapper({
@@ -1831,9 +1943,6 @@ function EventServiceProviderWrapper({
 }) {
   const organisationService = useOrganisationService2();
   const selectedOrganisation = organisationService.getSelectedOrganisation();
-  if (!user || !session) {
-    return /* @__PURE__ */ jsx5(Fragment, { children });
-  }
   return /* @__PURE__ */ jsx5(
     EventServiceProvider,
     {
@@ -1996,4 +2105,4 @@ export {
   UnifiedAuthProvider,
   init_UnifiedAuthProvider
 };
-//# sourceMappingURL=chunk-MNJXXD6C.js.map
+//# sourceMappingURL=chunk-5BN3YGNK.js.map