@forward-software/react-auth 1.1.0 → 2.0.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2022 ForWarD Software
+Copyright (c) 2025 ForWarD Software (https://forwardsoftware.solutions/)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.

package/README.md

@@ -1,12 +1,8 @@
 # React Auth
 
-<div align="center">
-    <img src="./assets/cover.jpeg" width="100%" />
-</div>
-
 > Simplify your Auth flow when working with React apps
 
-[![license](https://img.shields.io/github/license/Forward-Software/react-auth.svg)](https://github.com/Forward-Software/react-auth/blob/main/LICENSE) [![CI](https://github.com/Forward-Software/react-auth/actions/workflows/main.yml/badge.svg)](https://github.com/Forward-Software/react-auth/actions/workflows/main.yml) [![Language grade: JavaScript](https://img.shields.io/lgtm/grade/javascript/g/Forward-Software/react-auth.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/Forward-Software/react-auth/context:javascript) [![Coverage Status](https://coveralls.io/repos/github/Forward-Software/react-auth/badge.svg?branch=main)](https://coveralls.io/github/Forward-Software/react-auth?branch=main) [![Github Issues](https://img.shields.io/github/issues/Forward-Software/react-auth.svg)](https://github.com/Forward-Software/react-auth/issues)
+[![license](https://img.shields.io/github/license/forwardsoftware/react-auth.svg)](https://github.com/forwardsoftware/react-auth/blob/main/LICENSE) [![Build & Test](https://github.com/forwardsoftware/react-auth/actions/workflows/build-test.yml/badge.svg)](https://github.com/forwardsoftware/react-auth/actions/workflows/build-test.yml) [![Github Issues](https://img.shields.io/github/issues/forwardsoftware/react-auth.svg)](https://github.com/forwardsoftware/react-auth/issues)
 
 [![npm](https://img.shields.io/npm/v/@forward-software/react-auth)](https://npmjs.com/package/@forward-software/react-auth) [![NPM downloads](https://img.shields.io/npm/dm/@forward-software/react-auth.svg)](https://npmjs.com/package/@forward-software/react-auth)
 
@@ -17,86 +13,137 @@ This React package allows you to streamline the integration of user authenticati
 ## Install
 
 ```sh
-yarn add @forward-software/react-auth
+npm install @forward-software/react-auth
 ```
 
 ## Setup
 
-### Define an AuthClient class
-
-Create a new `AuthClient` class which extends the `BaseAuthClient` provided by this library and implements the 4 required methods:
+### Define an AuthClient
 
-- **onInit**, called when the AuthClient gets initialized
-- **onLogin**, invoked when the `login` method of the AuthClient gets called
-- **onRefresh**, invoked when the `refresh` method of the AuthClient gets called
-- **onLogout**, invoked when the `logout` method of the AuthClient gets called
+Create a new object that implements the `AuthClient` interface provided by this library. The interface includes several lifecycle methods, some of which are optional:
 
 ```ts
-import { BaseAuthClient } from '@forward-software/react-auth';
+import type { AuthClient } from '@forward-software/react-auth';
 
 // The type for your credentials
 type AuthCredentials = {
   username: string;
-
   password: string;
 };
 
 // The type for your tokens
 type AuthTokens = {
   authToken: string;
-
   refreshToken: string;
 };
 
-class AuthClient extends BaseAuthClient<AuthTokens, AuthCredentials> {
-  protected onInit(): Promise<void> {
+const authClient: AuthClient<AuthTokens, AuthCredentials> = {
+  // Optional: Called when the AuthClient gets initialized
+  onInit: async (): Promise<AuthTokens | null> => {
     // Implement the initialization logic for your client
-  }
+    return null;
+  },
 
-  protected onLogin(credentials?: AuthCredentials): Promise<AuthTokens> {
-    // Implement the logic required to exchange the provided credentials for user tokens
-  }
+  // Optional: Called after initialization completes
+  onPostInit: async (): Promise<void> => {
+    // Implement any post-initialization logic
+  },
 
-  protected onRefresh(minValidity?: number): Promise<AuthTokens> {
-    // Implement the logic required to refresh the current user tokens
-  }
+  // Optional: Called before login starts
+  onPreLogin: async (): Promise<void> => {
+    // Implement any pre-login logic
+  },
 
-  protected onLogout(): Promise<void> {
+  // Required: Called when login is requested
+  onLogin: async (credentials?: AuthCredentials): Promise<AuthTokens> => {
+    // Implement the logic required to exchange the provided credentials for user tokens
+    return {
+      authToken: '...',
+      refreshToken: '...'
+    };
+  },
+
+  // Optional: Called after login completes
+  onPostLogin: async (isSuccess: boolean): Promise<void> => {
+    // Implement any post-login logic
+  },
+
+  // Optional: Called before refresh starts
+  onPreRefresh: async (): Promise<void> => {
+    // Implement any pre-refresh logic
+  },
+
+  // Optional: Called when refresh is requested
+  // The current tokens are passed as the first argument
+  onRefresh: async (currentTokens: AuthTokens, minValidity?: number): Promise<AuthTokens> => {
+    // Implement the logic required to refresh the current user tokens
+    return {
+      authToken: '...',
+      refreshToken: '...'
+    };
+  },
+
+  // Optional: Called after refresh completes
+  onPostRefresh: async (isSuccess: boolean): Promise<void> => {
+    // Implement any post-refresh logic
+  },
+
+  // Optional: Called before logout starts
+  onPreLogout: async (): Promise<void> => {
+    // Implement any pre-logout logic
+  },
+
+  // Optional: Called when logout is requested
+  onLogout: async (): Promise<void> => {
     // Implement the logic required to invalidate the current user tokens
+  },
+
+  // Optional: Called after logout completes
+  onPostLogout: async (isSuccess: boolean): Promise<void> => {
+    // Implement any post-logout logic
   }
-}
+};
 ```
 
-### Instantiate an AuthClient
+### Use the AuthClient
 
-Create an instance of the `AuthClient` class defined
+The `AuthClient` instance can be used directly with the `createAuth` function:
 
 ```ts
-const authClient = new AuthClient();
+import { createAuth } from '@forward-software/react-auth';
+
+export const { AuthProvider, useAuthClient, authClient: enhancedAuthClient } = createAuth(authClient);
 ```
 
-#### AuthClient Props
+The `createAuth` function returns:
 
-- `isInitialized`, a boolean indicating if the AuthClient has been initialized
-- `isAuthenticated`, a boolean indicating if the login process has been successfull and the user is authenticated
-- `tokens`, the current tokens returned by the `login` or the `refresh` process
+- `AuthProvider`, the context Provider component that should wrap your app and provide access to your AuthClient
+- `useAuthClient`, the hook to retrieve and interact with your AuthClient
+- `authClient`, the enhanced authentication client instance
+
+#### AuthProvider
+
+The context Provider component that should wrap your app and provide access to your AuthClient, this component also accepts 2 additional props
+
+- `ErrorComponent`, displayed when the AuthClient initialization fails
+- `LoadingComponent`, displayed while the AuthClient is being initialized
+
+#### EnhancedAuthClient
 
-#### AuthClient Methods
+The `createAuth` function wraps your `AuthClient` implementation with an `EnhancedAuthClient` that provides additional functionality:
 
-##### Core
+##### Properties
+- `isInitialized`, a boolean indicating if the AuthClient has been initialized
+- `isAuthenticated`, a boolean indicating if the login process has been successful and the user is authenticated
+- `tokens`, the current tokens returned by the `login` or the `refresh` process
 
-- `init()`, initialize the AuthClient (**N.B.** this shouldn't be called if using `AuthProvider` - see below)
+##### Methods
+- `init()`, initialize the AuthClient (**N.B.** this shouldn't be called if using `AuthProvider` - see above)
 - `login(credentials)`, start the login process
 - `refresh()`, refresh the current tokens
 - `logout()`, logout and invalidate the current tokens
-
-##### EventEmitter
-
 - `on(eventName, listenerFn)`, subscribe to `eventName` events emitted by the AuthClient
 - `off(eventName, listenerFn)`, unsubscribe from `eventName` events emitted by the AuthClient
-
-##### Observable
-
 - `subscribe(() => { })`, subscribe to AuthClient state changes
 - `getSnapshot()`, returns the current state of the AuthClient
 
@@ -136,6 +183,6 @@ MIT
 
 ---
 
-Made with ✨ & ❤️ by [ForWarD Software](https://github.com/Forward-Software) and [contributors](https://github.com/Forward-Software/react-auth/graphs/contributors)
+Made with ✨ & ❤️ by [ForWarD Software](https://github.com/forwardsoftware) and [contributors](https://github.com/forwardsoftware/react-auth/graphs/contributors)
 
 If you found this project to be helpful, please consider contacting us to develop your React and React Native projects.

package/dist/auth.d.ts

@@ -0,0 +1,237 @@
+import React from 'react';
+import type { PropsWithChildren } from 'react';
+import { EventReceiver } from "./utils";
+import type { EventKey } from "./utils";
+/**
+ * Represents authentication tokens used for API authorization
+ */
+type AuthTokens = {};
+/**
+ * Represents user credentials used for authentication
+ */
+type AuthCredentials = {};
+/**
+ * Maps authentication events to their corresponding payload types
+ * @template E - The error type used throughout the authentication flow
+ */
+type AuthEventsMap<E extends Error> = {
+    initSuccess: undefined;
+    initFailed: E;
+    loginStarted: undefined;
+    loginSuccess: undefined;
+    loginFailed: E;
+    refreshStarted: undefined;
+    refreshSuccess: undefined;
+    refreshFailed: E;
+    logoutStarted: undefined;
+    logoutSuccess: undefined;
+    logoutFailed: E;
+};
+/**
+ * Function type for subscription callbacks
+ */
+type SubscribeFn = () => void;
+/**
+ * Function type for unsubscribing from events
+ * @returns {boolean} - Returns true if the subscription was successfully removed
+ */
+type UnsubscribeFn = () => boolean;
+/**
+ * Interface defining the core authentication client functionality
+ * @template T - The type of authentication tokens
+ * @template C - The type of authentication credentials
+ */
+export interface AuthClient<T = AuthTokens, C = AuthCredentials> {
+    /**
+     * Optional initialization hook called before authentication
+     * @returns {Promise<T | null>} - Returns authentication tokens if available
+     */
+    onInit?(): Promise<T | null>;
+    /**
+     * Optional post-initialization hook
+     */
+    onPostInit?(): Promise<void>;
+    /**
+     * Optional pre-login hook
+     */
+    onPreLogin?(): Promise<void>;
+    /**
+     * Handles the login process
+     * @param {C} [credentials] - Optional credentials for authentication
+     * @returns {Promise<T>} - Returns authentication tokens upon successful login
+     */
+    onLogin(credentials?: C): Promise<T>;
+    /**
+     * Optional post-login hook
+     * @param {boolean} isSuccess - Indicates whether the login was successful
+     */
+    onPostLogin?(isSuccess: boolean): Promise<void>;
+    /**
+     * Optional pre-refresh hook
+     */
+    onPreRefresh?(): Promise<void>;
+    /**
+     * Optional token refresh handler.
+     * Implement this method to handle token refresh logic.
+     * @param {T} currentTokens - The current authentication tokens.
+     * @param {number} [minValidity] - Optional minimum token validity period in seconds.
+     * @returns {Promise<T>} - A promise that resolves with the refreshed authentication tokens.
+     */
+    onRefresh?(currentTokens: T, minValidity?: number): Promise<T>;
+    /**
+     * Optional post-refresh hook
+     * @param {boolean} isSuccess - Indicates whether the token refresh was successful
+     */
+    onPostRefresh?(isSuccess: boolean): Promise<void>;
+    /**
+     * Optional pre-logout hook
+     */
+    onPreLogout?(): Promise<void>;
+    /**
+     * Optional logout handler
+     */
+    onLogout?(): Promise<void>;
+    /**
+     * Optional post-logout hook
+     * @param {boolean} isSuccess - Indicates whether the logout was successful
+     */
+    onPostLogout?(isSuccess: boolean): Promise<void>;
+}
+/**
+ * Extracts token type from an AuthClient implementation
+ * @template AC - The AuthClient implementation type
+ */
+type AuthClientTokens<AC extends AuthClient> = Partial<Awaited<ReturnType<AC["onLogin"]>>>;
+/**
+ * Extracts credentials type from an AuthClient implementation
+ * @template AC - The AuthClient implementation type
+ */
+type AuthClientCredentials<AC extends AuthClient> = Parameters<AC["onLogin"]>;
+/**
+ * Represents the current state of an AuthClient
+ * @template AC - The AuthClient implementation type
+ */
+type AuthClientState<AC extends AuthClient> = {
+    isAuthenticated: boolean;
+    isInitialized: boolean;
+    tokens: AuthClientTokens<AC>;
+};
+declare class AuthClientEnhancements<AC extends AuthClient, E extends Error> {
+    private _state;
+    private refreshQ;
+    private eventEmitter;
+    private subscribers;
+    private _authClient;
+    constructor(authClient: AC);
+    /**
+     * Indicates whether the authentication client has been initialized
+     * @readonly
+     */
+    get isInitialized(): boolean;
+    /**
+     * Indicates whether the user is currently authenticated
+     * @readonly
+     */
+    get isAuthenticated(): boolean;
+    /**
+     * Current authentication tokens
+     * @readonly
+     */
+    get tokens(): Partial<Awaited<ReturnType<AC["onLogin"]>>>;
+    /**
+     * Initializes the authentication client
+     * @returns {Promise<boolean>} - Returns true if initialization was successful
+     */
+    init(): Promise<boolean>;
+    /**
+     * Attempts to authenticate the user with provided credentials
+     * @param {...AuthClientCredentials<AC>} params - Authentication credentials
+     * @returns {Promise<boolean>} - Returns true if login was successful
+     */
+    login(...params: AuthClientCredentials<AC>): Promise<boolean>;
+    /**
+     * Refreshes the authentication tokens
+     * @param {number} [minValidity] - Minimum token validity period in seconds
+     * @returns {Promise<boolean>} - Returns true if token refresh was successful
+     */
+    refresh(minValidity?: number): Promise<boolean>;
+    /**
+     * Logs out the current user
+     * @returns {Promise<void>}
+     */
+    logout(): Promise<void>;
+    /**
+     * Registers an event listener for authentication events
+     * @template K - The event key type
+     * @param {K} eventName - The name of the event to listen for
+     * @param {EventReceiver<AuthEventsMap<E>[K]>} listener - The event handler function
+     */
+    on<K extends EventKey<AuthEventsMap<E>>>(eventName: K, listener: EventReceiver<AuthEventsMap<E>[K]>): void;
+    /**
+     * Removes an event listener for authentication events
+     * @template K - The event key type
+     * @param {K} eventName - The name of the event to stop listening for
+     * @param {EventReceiver<AuthEventsMap<E>[K]>} listener - The event handler function to remove
+     */
+    off<K extends EventKey<AuthEventsMap<E>>>(eventName: K, listener: EventReceiver<AuthEventsMap<E>[K]>): void;
+    /**
+     * Subscribes to authentication state changes
+     * @param {SubscribeFn} subscription - The callback function to be called on state changes
+     * @returns {UnsubscribeFn} - A function to unsubscribe from state changes
+     */
+    subscribe: (subscription: SubscribeFn) => UnsubscribeFn;
+    /**
+     * Gets the current authentication state
+     * @returns {AuthClientState<AC>} - The current authentication state
+     */
+    getSnapshot: () => AuthClientState<AC>;
+    private setState;
+    private runRefresh;
+    private emit;
+    private notifySubscribers;
+}
+/**
+ * Enhanced authentication client with additional functionality and state management
+ * @template AC - The AuthClient implementation type
+ * @template E - The error type used throughout the authentication flow
+ */
+export type EnhancedAuthClient<AC extends AuthClient, E extends Error> = AC & AuthClientEnhancements<AC, E>;
+/**
+ * Wraps a basic AuthClient implementation with enhanced functionality
+ * @template AC - The AuthClient implementation type
+ * @template E - The error type used throughout the authentication flow
+ * @param {AC} authClient - The base authentication client to enhance
+ * @returns {EnhancedAuthClient<AC, E>} - An enhanced authentication client with additional features
+ */
+export declare function wrapAuthClient<AC extends AuthClient, E extends Error = Error>(authClient: AC): EnhancedAuthClient<AC, E>;
+/**
+ * Props that can be passed to AuthProvider
+ */
+export type AuthProviderProps = PropsWithChildren<{
+    /**
+     * An optional component to display if AuthClient initialization failed.
+     */
+    ErrorComponent?: React.ReactNode;
+    /**
+     * An optional component to display while AuthClient instance is being initialized.
+     */
+    LoadingComponent?: React.ReactNode;
+}>;
+/**
+ * Creates an authentication context and provider for a React application.
+ * It wraps the provided `authClient` with enhanced state management and event handling.
+ *
+ * @template AC - The type of the base `AuthClient` implementation.
+ * @template E - The type of error expected during authentication flows. Defaults to `Error`.
+ * @param {AC} authClient - The base authentication client instance to use.
+ * @returns An object containing:
+ *   - `AuthProvider`: A React component to wrap the application or parts of it.
+ *   - `authClient`: The enhanced authentication client instance.
+ *   - `useAuthClient`: A hook to access the enhanced `authClient` within the `AuthProvider`.
+ */
+export declare function createAuth<AC extends AuthClient, E extends Error = Error>(authClient: AC): {
+    AuthProvider: React.FC<AuthProviderProps>;
+    authClient: EnhancedAuthClient<AC, E>;
+    useAuthClient: () => EnhancedAuthClient<AC, E>;
+};
+export {};

package/dist/auth.js

@@ -0,0 +1,215 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useState } from 'react';
+import { useSyncExternalStore } from 'use-sync-external-store/shim';
+import { createEventEmitter, Deferred } from "./utils";
+class AuthClientEnhancements {
+    constructor(authClient) {
+        this._state = {
+            isAuthenticated: false,
+            isInitialized: false,
+            tokens: {},
+        };
+        this.refreshQ = [];
+        this.eventEmitter = createEventEmitter();
+        this.subscribers = new Set();
+        this.subscribe = (subscription) => {
+            this.subscribers.add(subscription);
+            return () => this.subscribers.delete(subscription);
+        };
+        this.getSnapshot = () => {
+            return this._state;
+        };
+        this._authClient = authClient;
+    }
+    get isInitialized() {
+        return this._state.isInitialized;
+    }
+    get isAuthenticated() {
+        return this._state.isAuthenticated;
+    }
+    get tokens() {
+        return this._state.tokens;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            try {
+                const prevTokens = yield ((_b = (_a = this._authClient).onInit) === null || _b === void 0 ? void 0 : _b.call(_a));
+                this.setState({
+                    isInitialized: true,
+                    isAuthenticated: !!prevTokens,
+                    tokens: prevTokens || {},
+                });
+                this.emit("initSuccess", undefined);
+            }
+            catch (error) {
+                this.setState({
+                    isInitialized: false,
+                });
+                this.emit("initFailed", error);
+            }
+            yield ((_d = (_c = this._authClient).onPostInit) === null || _d === void 0 ? void 0 : _d.call(_c));
+            return this.isInitialized;
+        });
+    }
+    login(...params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            this.emit("loginStarted", undefined);
+            yield ((_b = (_a = this._authClient).onPreLogin) === null || _b === void 0 ? void 0 : _b.call(_a));
+            let isSuccess = false;
+            try {
+                const tokens = yield this._authClient.onLogin(...params);
+                this.setState({
+                    isAuthenticated: !!tokens,
+                    tokens,
+                });
+                this.emit("loginSuccess", undefined);
+                isSuccess = true;
+            }
+            catch (err) {
+                this.setState({
+                    isAuthenticated: false,
+                    tokens: {},
+                });
+                this.emit("loginFailed", err);
+                isSuccess = false;
+            }
+            yield ((_d = (_c = this._authClient).onPostLogin) === null || _d === void 0 ? void 0 : _d.call(_c, isSuccess));
+            return this.isAuthenticated;
+        });
+    }
+    refresh(minValidity) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deferred = new Deferred();
+            this.runRefresh(deferred, minValidity);
+            return deferred.getPromise();
+        });
+    }
+    logout() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f;
+            this.emit("logoutStarted", undefined);
+            yield ((_b = (_a = this._authClient).onPreLogout) === null || _b === void 0 ? void 0 : _b.call(_a));
+            let isSuccess = false;
+            try {
+                yield ((_d = (_c = this._authClient).onLogout) === null || _d === void 0 ? void 0 : _d.call(_c));
+                this.setState({
+                    isAuthenticated: false,
+                    tokens: {},
+                });
+                this.emit("logoutSuccess", undefined);
+                isSuccess = true;
+            }
+            catch (err) {
+                this.emit("logoutFailed", err);
+                isSuccess = false;
+            }
+            yield ((_f = (_e = this._authClient).onPostLogout) === null || _f === void 0 ? void 0 : _f.call(_e, isSuccess));
+        });
+    }
+    on(eventName, listener) {
+        this.eventEmitter.on(eventName, listener);
+    }
+    off(eventName, listener) {
+        this.eventEmitter.off(eventName, listener);
+    }
+    setState(stateUpdate) {
+        this._state = Object.assign(Object.assign({}, this._state), stateUpdate);
+        this.notifySubscribers();
+    }
+    runRefresh(deferred, minValidity) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g;
+            this.refreshQ.push(deferred);
+            if (this.refreshQ.length !== 1) {
+                return;
+            }
+            this.emit("refreshStarted", undefined);
+            yield ((_b = (_a = this._authClient).onPreRefresh) === null || _b === void 0 ? void 0 : _b.call(_a));
+            let isAuthenticated = false;
+            let tokens = {};
+            try {
+                tokens = (_e = (yield ((_d = (_c = this._authClient).onRefresh) === null || _d === void 0 ? void 0 : _d.call(_c, this.tokens, minValidity)))) !== null && _e !== void 0 ? _e : {};
+                isAuthenticated = true;
+                this.emit("refreshSuccess", undefined);
+            }
+            catch (err) {
+                isAuthenticated = false;
+                this.emit("refreshFailed", err);
+            }
+            this.setState({
+                isAuthenticated,
+                tokens,
+            });
+            yield ((_g = (_f = this._authClient).onPostRefresh) === null || _g === void 0 ? void 0 : _g.call(_f, isAuthenticated));
+            for (let p = this.refreshQ.pop(); p != null; p = this.refreshQ.pop()) {
+                p.resolve(isAuthenticated);
+            }
+        });
+    }
+    emit(eventName, error) {
+        this.eventEmitter.emit(eventName, error);
+    }
+    notifySubscribers() {
+        this.subscribers.forEach((s) => {
+            try {
+                s();
+            }
+            catch (_a) { }
+        });
+    }
+}
+export function wrapAuthClient(authClient) {
+    Object.setPrototypeOf(AuthClientEnhancements.prototype, authClient);
+    return new AuthClientEnhancements(authClient);
+}
+export function createAuth(authClient) {
+    const authContext = createContext(null);
+    const enhancedAuthClient = wrapAuthClient(authClient);
+    const AuthProvider = ({ children, ErrorComponent, LoadingComponent }) => {
+        const [isInitFailed, setInitFailed] = useState(false);
+        const { isAuthenticated, isInitialized } = useSyncExternalStore(enhancedAuthClient.subscribe, enhancedAuthClient.getSnapshot);
+        useEffect(() => {
+            function initAuthClient() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const initSuccess = yield enhancedAuthClient.init();
+                    setInitFailed(!initSuccess);
+                });
+            }
+            initAuthClient();
+        }, []);
+        if (!!ErrorComponent && isInitFailed) {
+            return ErrorComponent;
+        }
+        if (!!LoadingComponent && !isInitialized) {
+            return LoadingComponent;
+        }
+        return (_jsx(authContext.Provider, { value: {
+                authClient: enhancedAuthClient,
+                isAuthenticated,
+                isInitialized,
+            }, children: children }));
+    };
+    const useAuthClient = function () {
+        const ctx = useContext(authContext);
+        if (!ctx) {
+            throw new Error('useAuthClient hook should be used inside AuthProvider');
+        }
+        return ctx.authClient;
+    };
+    return {
+        AuthProvider,
+        authClient: enhancedAuthClient,
+        useAuthClient,
+    };
+}