@ph-cms/client-sdk 0.1.4 → 0.1.6

package/dist/auth/firebase-provider.js

@@ -14,6 +14,9 @@ class FirebaseAuthProvider {
             this.refreshToken = localStorage.getItem(`${this.storageKeyPrefix}refresh_token`);
         }
     }
+    hasToken() {
+        return this.accessToken !== null || this.refreshToken !== null;
+    }
     setTokens(accessToken, refreshToken) {
         this.accessToken = accessToken;
         this.refreshToken = refreshToken;

package/dist/auth/interfaces.d.ts

@@ -5,6 +5,12 @@ export interface AuthProvider {
      * Should handle refreshing if necessary (or return null/throw if expired and can't refresh).
      */
     getToken(): Promise<string | null>;
+    /**
+     * Returns true if the provider currently holds a token (access or refresh).
+     * This is a synchronous check used to decide whether to attempt API calls
+     * that require authentication (e.g. /auth/me).
+     */
+    hasToken(): boolean;
     /**
      * Sets a callback to be called when the token is known to be expired by the external world (e.g. 401 response).
      */

package/dist/auth/local-provider.d.ts

@@ -11,6 +11,7 @@ export declare class LocalAuthProvider implements AuthProvider {
         refreshToken: string;
     }>) | undefined);
     setTokens(accessToken: string, refreshToken: string): void;
+    hasToken(): boolean;
     getToken(): Promise<string | null>;
     onTokenExpired(callback: () => Promise<void>): void;
     logout(): Promise<void>;

package/dist/auth/local-provider.js

@@ -22,6 +22,9 @@ class LocalAuthProvider {
             localStorage.setItem(`${this.storageKeyPrefix}refresh_token`, refreshToken);
         }
     }
+    hasToken() {
+        return this.accessToken !== null || this.refreshToken !== null;
+    }
     async getToken() {
         // Ideally check expiration here using jwt-decode, but for now return what we have.
         // If it's expired, the API will return 401, triggering the interceptor which calls onTokenExpired.

package/dist/client.d.ts

@@ -1,10 +1,10 @@
 import { AxiosInstance } from 'axios';
 import { AuthProvider } from './auth/interfaces';
 import { AuthModule } from './modules/auth';
-import { ContentModule } from './modules/content';
 import { ChannelModule } from './modules/channel';
-import { TermsModule } from './modules/terms';
+import { ContentModule } from './modules/content';
 import { MediaModule } from './modules/media';
+import { TermsModule } from './modules/terms';
 export interface PHCMSClientConfig {
     baseURL: string;
     apiPrefix?: string;
@@ -19,5 +19,7 @@ export declare class PHCMSClient {
     readonly channel: ChannelModule;
     readonly terms: TermsModule;
     readonly media: MediaModule;
+    /** Exposes the auth provider so UI layers can check token state synchronously. */
+    get authProvider(): AuthProvider | undefined;
     constructor(config: PHCMSClientConfig);
 }

package/dist/client.js

@@ -7,11 +7,15 @@ exports.PHCMSClient = void 0;
 const axios_1 = __importDefault(require("axios"));
 const errors_1 = require("./errors");
 const auth_1 = require("./modules/auth");
-const content_1 = require("./modules/content");
 const channel_1 = require("./modules/channel");
-const terms_1 = require("./modules/terms");
+const content_1 = require("./modules/content");
 const media_1 = require("./modules/media");
+const terms_1 = require("./modules/terms");
 class PHCMSClient {
+    /** Exposes the auth provider so UI layers can check token state synchronously. */
+    get authProvider() {
+        return this.config.auth;
+    }
     constructor(config) {
         this.config = config;
         const normalizedApiPrefix = `/${(config.apiPrefix || '/api').replace(/^\/+|\/+$/g, '')}`;

package/dist/context.d.ts

@@ -1,12 +1,14 @@
-import React, { ReactNode } from 'react';
+import { UserDto } from '@ph-cms/api-contract';
 import { QueryClient } from '@tanstack/react-query';
+import React, { ReactNode } from 'react';
 import { PHCMSClient } from './client';
-import { UserDto } from '@ph-cms/api-contract';
 export interface PHCMSContextType {
     client: PHCMSClient;
     user: UserDto | null;
     isAuthenticated: boolean;
     isLoading: boolean;
+    /** Manually trigger a refetch of the current user profile. */
+    refreshUser: () => Promise<void>;
 }
 export interface PHCMSProviderProps {
     client: PHCMSClient;

package/dist/context.js

@@ -34,40 +34,71 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.usePHCMS = exports.usePHCMSContext = exports.PHCMSProvider = void 0;
-const react_1 = __importStar(require("react"));
 const react_query_1 = require("@tanstack/react-query");
+const react_1 = __importStar(require("react"));
 const PHCMSContext = (0, react_1.createContext)(null);
+const AUTH_ME_QUERY_KEY = ['auth', 'me'];
 /**
  * Internal component to handle auth state and provide to context
  */
 const PHCMSInternalProvider = ({ client, children }) => {
-    const { data: user, isLoading, isError } = (0, react_query_1.useQuery)({
-        queryKey: ['auth', 'me'],
+    const queryClient = (0, react_query_1.useQueryClient)();
+    // Track token presence in state to trigger re-renders when it changes.
+    // Initial value from provider.
+    const [hasToken, setHasToken] = (0, react_1.useState)(() => client.authProvider?.hasToken() ?? false);
+    // The 'me' query is only enabled if we have a token.
+    const { data: user, isLoading, isError, refetch } = (0, react_query_1.useQuery)({
+        queryKey: [...AUTH_ME_QUERY_KEY],
         queryFn: () => client.auth.me(),
+        enabled: hasToken,
         retry: false,
         staleTime: 1000 * 60 * 5,
     });
+    // Function to update token state and optionally refetch
+    const refreshUser = (0, react_1.useCallback)(async () => {
+        const currentHasToken = client.authProvider?.hasToken() ?? false;
+        setHasToken(currentHasToken);
+        if (currentHasToken) {
+            await refetch();
+        }
+        else {
+            // If no token, clear the query data
+            queryClient.setQueryData([...AUTH_ME_QUERY_KEY], null);
+        }
+    }, [client.authProvider, refetch, queryClient]);
+    // Effect to sync state if provider changes externally (rare but possible)
+    (0, react_1.useEffect)(() => {
+        const interval = setInterval(() => {
+            const currentHasToken = client.authProvider?.hasToken() ?? false;
+            if (currentHasToken !== hasToken) {
+                setHasToken(currentHasToken);
+            }
+        }, 2000); // Check every 2s as a fallback
+        return () => clearInterval(interval);
+    }, [client.authProvider, hasToken]);
     const value = (0, react_1.useMemo)(() => ({
         client,
         user: user || null,
-        isAuthenticated: !!user && !isError,
-        isLoading,
-    }), [client, user, isError, isLoading]);
-    return (react_1.default.createElement(PHCMSContext.Provider, { value: value }, children));
+        isAuthenticated: !!user && !isError && hasToken,
+        isLoading: hasToken ? isLoading : false,
+        refreshUser,
+    }), [client, user, isError, isLoading, hasToken, refreshUser]);
+    return react_1.default.createElement(PHCMSContext.Provider, { value: value }, children);
 };
 /**
  * Root Provider for PH-CMS
  * Automatically includes QueryClientProvider
  */
 const PHCMSProvider = ({ client, queryClient, children }) => {
-    const internalQueryClient = (0, react_1.useMemo)(() => queryClient ?? new react_query_1.QueryClient({
-        defaultOptions: {
-            queries: {
-                refetchOnWindowFocus: false,
-                retry: false,
+    const internalQueryClient = (0, react_1.useMemo)(() => queryClient ??
+        new react_query_1.QueryClient({
+            defaultOptions: {
+                queries: {
+                    refetchOnWindowFocus: false,
+                    retry: false,
+                },
             },
-        },
-    }), [queryClient]);
+        }), [queryClient]);
     return (react_1.default.createElement(react_query_1.QueryClientProvider, { client: internalQueryClient },
         react_1.default.createElement(PHCMSInternalProvider, { client: client }, children)));
 };

package/dist/hooks/useAuth.d.ts

@@ -1,6 +1,6 @@
 /**
  * Unified Auth Hook
- * Returns both the current auth status and the actions
+ * Returns both the current auth status and the actions.
  */
 export declare const useAuth: () => {
     user: {
@@ -128,6 +128,30 @@ export declare const useAuth: () => {
         email: string;
         password: string;
     }, unknown>;
+    loginWithFirebaseStatus: import("@tanstack/react-query").UseMutationResult<{
+        refreshToken: string;
+        user: {
+            uid: string;
+            email: string;
+            username: string | null;
+            display_name: string;
+            avatar_url: string | null;
+            phone_number: string | null;
+            email_verified_at: string | null;
+            phone_verified_at: string | null;
+            locale: string;
+            timezone: string;
+            status: string;
+            role: string[];
+            profile_data: Record<string, any>;
+            last_login_at: string | null;
+            created_at: string;
+            updated_at: string;
+        };
+        accessToken: string;
+    }, Error, {
+        idToken: string;
+    }, unknown>;
     registerStatus: import("@tanstack/react-query").UseMutationResult<{
         refreshToken: string;
         user: {

package/dist/hooks/useAuth.js

@@ -3,36 +3,37 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.useLogout = exports.useLogin = exports.useUser = exports.useAuth = void 0;
 const react_query_1 = require("@tanstack/react-query");
 const context_1 = require("../context");
+const AUTH_ME_QUERY_KEY = ['auth', 'me'];
 /**
  * Unified Auth Hook
- * Returns both the current auth status and the actions
+ * Returns both the current auth status and the actions.
  */
 const useAuth = () => {
-    const { user, isAuthenticated, isLoading } = (0, context_1.usePHCMSContext)();
+    const { user, isAuthenticated, isLoading, refreshUser } = (0, context_1.usePHCMSContext)();
     const client = (0, context_1.usePHCMS)();
     const queryClient = (0, react_query_1.useQueryClient)();
     const loginMutation = (0, react_query_1.useMutation)({
         mutationFn: (data) => client.auth.login(data),
-        onSuccess: () => {
-            queryClient.invalidateQueries({ queryKey: ['auth', 'me'] });
+        onSuccess: async () => {
+            await refreshUser();
         },
     });
     const loginWithFirebaseMutation = (0, react_query_1.useMutation)({
         mutationFn: (data) => client.auth.loginWithFirebase(data),
-        onSuccess: () => {
-            queryClient.invalidateQueries({ queryKey: ['auth', 'me'] });
+        onSuccess: async () => {
+            await refreshUser();
         },
     });
     const registerMutation = (0, react_query_1.useMutation)({
         mutationFn: (data) => client.auth.register(data),
-        onSuccess: () => {
-            queryClient.invalidateQueries({ queryKey: ['auth', 'me'] });
+        onSuccess: async () => {
+            await refreshUser();
         },
     });
     const logoutMutation = (0, react_query_1.useMutation)({
         mutationFn: () => client.auth.logout(),
-        onSuccess: () => {
-            queryClient.setQueryData(['auth', 'me'], null);
+        onSuccess: async () => {
+            await refreshUser(); // This will clear state since hasToken will be false
             queryClient.invalidateQueries();
         },
     });
@@ -46,6 +47,7 @@ const useAuth = () => {
         logout: logoutMutation.mutateAsync,
         // Access to mutation objects for loading/error states if needed
         loginStatus: loginMutation,
+        loginWithFirebaseStatus: loginWithFirebaseMutation,
         registerStatus: registerMutation,
         logoutStatus: logoutMutation,
     };

package/dist/hooks/useFirebaseAuthSync.d.ts

@@ -0,0 +1,108 @@
+import type { Auth } from 'firebase/auth';
+import React from 'react';
+export interface UseFirebaseAuthSyncOptions {
+    /**
+     * Firebase Auth instance.
+     * Must be provided so the hook can subscribe to `onAuthStateChanged`.
+     */
+    firebaseAuth: Auth;
+    /**
+     * If true, automatically call `logout()` on the PH-CMS side
+     * when the Firebase user signs out.
+     * @default true
+     */
+    logoutOnFirebaseSignOut?: boolean;
+    /**
+     * Called when the sync exchange succeeds.
+     */
+    onSyncSuccess?: () => void;
+    /**
+     * Called when the sync exchange fails.
+     */
+    onSyncError?: (error: unknown) => void;
+}
+export interface UseFirebaseAuthSyncReturn {
+    /** Whether a token-exchange request is currently in flight. */
+    isSyncing: boolean;
+}
+/**
+ * `useFirebaseAuthSync`
+ *
+ * Subscribes to Firebase `onAuthStateChanged` and automatically synchronizes
+ * the Firebase authentication state with the PH-CMS backend:
+ *
+ * - **Firebase user signs in** and PH-CMS is not yet authenticated →
+ *   obtains a Firebase ID token and calls `loginWithFirebase({ idToken })`
+ *   which exchanges the token for PH-CMS access/refresh tokens and then
+ *   fetches the user profile via `/auth/me`.
+ *
+ * - **Firebase user signs out** and PH-CMS is still authenticated →
+ *   calls `logout()` on PH-CMS (configurable via `logoutOnFirebaseSignOut`).
+ *
+ * The hook must be rendered **inside** `<PHCMSProvider>` because it relies
+ * on context values (`isAuthenticated`, `isLoading`) and the `loginWithFirebase`
+ * / `logout` actions exposed by the auth module.
+ *
+ * ### Example
+ *
+ * ```tsx
+ * import { useFirebaseAuthSync } from '@ph-cms/client-sdk';
+ * import { getAuth } from 'firebase/auth';
+ *
+ * const firebaseAuth = getAuth(firebaseApp);
+ *
+ * function App() {
+ *   useFirebaseAuthSync({ firebaseAuth });
+ *   return <MainContent />;
+ * }
+ * ```
+ */
+export declare const useFirebaseAuthSync: (options: UseFirebaseAuthSyncOptions) => UseFirebaseAuthSyncReturn;
+export interface FirebaseAuthSyncProps {
+    /**
+     * Firebase Auth instance.
+     */
+    firebaseAuth: Auth;
+    /**
+     * If true, automatically call `logout()` on the PH-CMS side
+     * when the Firebase user signs out.
+     * @default true
+     */
+    logoutOnFirebaseSignOut?: boolean;
+    /**
+     * Called when the sync exchange succeeds.
+     */
+    onSyncSuccess?: () => void;
+    /**
+     * Called when the sync exchange fails.
+     */
+    onSyncError?: (error: unknown) => void;
+    children: React.ReactNode;
+}
+/**
+ * `<FirebaseAuthSync>`
+ *
+ * A convenience wrapper component that calls `useFirebaseAuthSync` internally.
+ * Place it **inside** `<PHCMSProvider>` and wrap the part of the tree that
+ * should wait for or react to Firebase↔PH-CMS auth synchronization.
+ *
+ * ### Example
+ *
+ * ```tsx
+ * import { PHCMSProvider, FirebaseAuthSync } from '@ph-cms/client-sdk';
+ * import { getAuth } from 'firebase/auth';
+ *
+ * const firebaseAuth = getAuth(firebaseApp);
+ *
+ * function App() {
+ *   return (
+ *     <PHCMSProvider client={client}>
+ *       <FirebaseAuthSync firebaseAuth={firebaseAuth}>
+ *         <MainContent />
+ *       </FirebaseAuthSync>
+ *     </PHCMSProvider>
+ *   );
+ * }
+ * ```
+ */
+export declare const FirebaseAuthSync: React.FC<FirebaseAuthSyncProps>;

package/dist/hooks/useFirebaseAuthSync.js

@@ -0,0 +1,221 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirebaseAuthSync = exports.useFirebaseAuthSync = void 0;
+const react_1 = __importStar(require("react"));
+const context_1 = require("../context");
+/**
+ * `useFirebaseAuthSync`
+ *
+ * Subscribes to Firebase `onAuthStateChanged` and automatically synchronizes
+ * the Firebase authentication state with the PH-CMS backend:
+ *
+ * - **Firebase user signs in** and PH-CMS is not yet authenticated →
+ *   obtains a Firebase ID token and calls `loginWithFirebase({ idToken })`
+ *   which exchanges the token for PH-CMS access/refresh tokens and then
+ *   fetches the user profile via `/auth/me`.
+ *
+ * - **Firebase user signs out** and PH-CMS is still authenticated →
+ *   calls `logout()` on PH-CMS (configurable via `logoutOnFirebaseSignOut`).
+ *
+ * The hook must be rendered **inside** `<PHCMSProvider>` because it relies
+ * on context values (`isAuthenticated`, `isLoading`) and the `loginWithFirebase`
+ * / `logout` actions exposed by the auth module.
+ *
+ * ### Example
+ *
+ * ```tsx
+ * import { useFirebaseAuthSync } from '@ph-cms/client-sdk';
+ * import { getAuth } from 'firebase/auth';
+ *
+ * const firebaseAuth = getAuth(firebaseApp);
+ *
+ * function App() {
+ *   useFirebaseAuthSync({ firebaseAuth });
+ *   return <MainContent />;
+ * }
+ * ```
+ */
+const useFirebaseAuthSync = (options) => {
+    const { firebaseAuth, logoutOnFirebaseSignOut = true, onSyncSuccess, onSyncError, } = options;
+    const { client, isAuthenticated, isLoading, refreshUser } = (0, context_1.usePHCMSContext)();
+    // Use refs for values that change frequently but should not re-trigger
+    // the effect (which would tear down and re-create the Firebase listener).
+    const isAuthenticatedRef = (0, react_1.useRef)(isAuthenticated);
+    const isLoadingRef = (0, react_1.useRef)(isLoading);
+    const syncInProgressRef = (0, react_1.useRef)(false);
+    const isSyncingStateRef = (0, react_1.useRef)(false);
+    const [isSyncing, setIsSyncing] = react_1.default.useState(false);
+    // Keep refs up to date.
+    (0, react_1.useEffect)(() => {
+        isAuthenticatedRef.current = isAuthenticated;
+    }, [isAuthenticated]);
+    (0, react_1.useEffect)(() => {
+        isLoadingRef.current = isLoading;
+    }, [isLoading]);
+    // Stable callback refs so the effect closure doesn't go stale.
+    const onSyncSuccessRef = (0, react_1.useRef)(onSyncSuccess);
+    const onSyncErrorRef = (0, react_1.useRef)(onSyncError);
+    (0, react_1.useEffect)(() => {
+        onSyncSuccessRef.current = onSyncSuccess;
+    }, [onSyncSuccess]);
+    (0, react_1.useEffect)(() => {
+        onSyncErrorRef.current = onSyncError;
+    }, [onSyncError]);
+    const handleFirebaseUser = (0, react_1.useCallback)(async (fbUser) => {
+        if (fbUser) {
+            // Firebase user is signed in.
+            // Only exchange if PH-CMS is not already authenticated and not loading.
+            if (!isAuthenticatedRef.current &&
+                !isLoadingRef.current &&
+                !syncInProgressRef.current) {
+                syncInProgressRef.current = true;
+                isSyncingStateRef.current = true;
+                setIsSyncing(true);
+                try {
+                    const idToken = await fbUser.getIdToken();
+                    await client.auth.loginWithFirebase({ idToken });
+                    // loginWithFirebase stores the tokens in the provider.
+                    // Now refresh the context so `isAuthenticated` and `user` update.
+                    await refreshUser();
+                    onSyncSuccessRef.current?.();
+                }
+                catch (error) {
+                    console.error('[useFirebaseAuthSync] Token exchange failed:', error);
+                    onSyncErrorRef.current?.(error);
+                }
+                finally {
+                    syncInProgressRef.current = false;
+                    isSyncingStateRef.current = false;
+                    setIsSyncing(false);
+                }
+            }
+        }
+        else {
+            // Firebase user signed out.
+            if (logoutOnFirebaseSignOut && isAuthenticatedRef.current) {
+                try {
+                    await client.auth.logout();
+                    await refreshUser();
+                }
+                catch (error) {
+                    console.error('[useFirebaseAuthSync] Logout failed:', error);
+                }
+            }
+        }
+    }, 
+    // `client`, `refreshUser`, and `logoutOnFirebaseSignOut` are stable
+    // across renders (client is a singleton, refreshUser is memoized,
+    // logoutOnFirebaseSignOut is typically a constant).
+    [client, refreshUser, logoutOnFirebaseSignOut]);
+    (0, react_1.useEffect)(() => {
+        // Dynamically import the listener so that this file has zero runtime
+        // dependency on firebase/auth at the module level. The `Auth` object
+        // passed in already carries the implementation; we just need the
+        // `onAuthStateChanged` function reference from it.
+        //
+        // Firebase Auth's `onAuthStateChanged` is available on the Auth object
+        // via the modular API through the standalone function, but we can also
+        // call it as `firebaseAuth.onAuthStateChanged(...)` which works on the
+        // Auth instance directly (compat style). However, the recommended
+        // modular approach is to use the standalone function.
+        //
+        // To avoid directly importing from 'firebase/auth' at the top level
+        // (since it's an optional peer dep), we use a dynamic import wrapped
+        // in a try-catch. If the import fails, we fall back to a noop.
+        let unsubscribe = null;
+        let cancelled = false;
+        const setup = async () => {
+            try {
+                // Dynamic import so builds without firebase don't break.
+                const firebaseAuthModule = await Promise.resolve().then(() => __importStar(require('firebase/auth')));
+                if (cancelled)
+                    return;
+                unsubscribe = firebaseAuthModule.onAuthStateChanged(firebaseAuth, (fbUser) => {
+                    // Fire and forget; errors are caught inside handleFirebaseUser.
+                    void handleFirebaseUser(fbUser);
+                });
+            }
+            catch {
+                // firebase/auth is not installed — this is fine, it's optional.
+                console.warn('[useFirebaseAuthSync] firebase/auth could not be imported. ' +
+                    'Make sure it is installed if you intend to use Firebase auth sync.');
+            }
+        };
+        void setup();
+        return () => {
+            cancelled = true;
+            unsubscribe?.();
+        };
+    }, [firebaseAuth, handleFirebaseUser]);
+    return { isSyncing };
+};
+exports.useFirebaseAuthSync = useFirebaseAuthSync;
+/**
+ * `<FirebaseAuthSync>`
+ *
+ * A convenience wrapper component that calls `useFirebaseAuthSync` internally.
+ * Place it **inside** `<PHCMSProvider>` and wrap the part of the tree that
+ * should wait for or react to Firebase↔PH-CMS auth synchronization.
+ *
+ * ### Example
+ *
+ * ```tsx
+ * import { PHCMSProvider, FirebaseAuthSync } from '@ph-cms/client-sdk';
+ * import { getAuth } from 'firebase/auth';
+ *
+ * const firebaseAuth = getAuth(firebaseApp);
+ *
+ * function App() {
+ *   return (
+ *     <PHCMSProvider client={client}>
+ *       <FirebaseAuthSync firebaseAuth={firebaseAuth}>
+ *         <MainContent />
+ *       </FirebaseAuthSync>
+ *     </PHCMSProvider>
+ *   );
+ * }
+ * ```
+ */
+const FirebaseAuthSync = ({ firebaseAuth, logoutOnFirebaseSignOut, onSyncSuccess, onSyncError, children, }) => {
+    (0, exports.useFirebaseAuthSync)({
+        firebaseAuth,
+        logoutOnFirebaseSignOut,
+        onSyncSuccess,
+        onSyncError,
+    });
+    return react_1.default.createElement(react_1.default.Fragment, null, children);
+};
+exports.FirebaseAuthSync = FirebaseAuthSync;

package/dist/index.d.ts

@@ -1,17 +1,18 @@
+export * from './auth/firebase-provider';
 export * from './auth/interfaces';
 export * from './auth/local-provider';
-export * from './auth/firebase-provider';
-export * from './errors';
 export * from './client';
+export * from './errors';
 export * from './modules/auth';
-export * from './modules/content';
 export * from './modules/channel';
-export * from './modules/terms';
+export * from './modules/content';
 export * from './modules/media';
+export * from './modules/terms';
 export * from './context';
 export * from './hooks/useAuth';
-export * from './hooks/useContent';
 export * from './hooks/useChannel';
-export * from './hooks/useTerms';
+export * from './hooks/useContent';
+export * from './hooks/useFirebaseAuthSync';
 export * from './hooks/useMedia';
+export * from './hooks/useTerms';
 export * from './types';

package/dist/index.js

@@ -14,20 +14,21 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./auth/firebase-provider"), exports);
 __exportStar(require("./auth/interfaces"), exports);
 __exportStar(require("./auth/local-provider"), exports);
-__exportStar(require("./auth/firebase-provider"), exports);
-__exportStar(require("./errors"), exports);
 __exportStar(require("./client"), exports);
+__exportStar(require("./errors"), exports);
 __exportStar(require("./modules/auth"), exports);
-__exportStar(require("./modules/content"), exports);
 __exportStar(require("./modules/channel"), exports);
-__exportStar(require("./modules/terms"), exports);
+__exportStar(require("./modules/content"), exports);
 __exportStar(require("./modules/media"), exports);
+__exportStar(require("./modules/terms"), exports);
 __exportStar(require("./context"), exports);
 __exportStar(require("./hooks/useAuth"), exports);
-__exportStar(require("./hooks/useContent"), exports);
 __exportStar(require("./hooks/useChannel"), exports);
-__exportStar(require("./hooks/useTerms"), exports);
+__exportStar(require("./hooks/useContent"), exports);
+__exportStar(require("./hooks/useFirebaseAuthSync"), exports);
 __exportStar(require("./hooks/useMedia"), exports);
+__exportStar(require("./hooks/useTerms"), exports);
 __exportStar(require("./types"), exports);