@joelbarron/react-web-dev-kit 0.1.0

package/dist/auth/fuse/fuseAdapter.js

@@ -0,0 +1,265 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useEffect, useImperativeHandle, useMemo, useState } from 'react';
+const FuseJwtAuthContext = createContext(undefined);
+const asRecord = (value) => (value ?? {});
+const isTokenValid = (token) => {
+    if (!token) {
+        return false;
+    }
+    try {
+        const payload = JSON.parse(atob(token.split('.')[1]));
+        return payload.exp > Date.now() / 1000;
+    }
+    catch {
+        return false;
+    }
+};
+const normalizeUserShape = (userInput) => {
+    const user = asRecord(userInput);
+    const userData = asRecord(user.data);
+    const displayName = user.displayName ||
+        userData.displayName ||
+        [userData.firstName, userData.middleName, userData.lastName].filter(Boolean).join(' ') ||
+        'User';
+    return {
+        id: (user.id || user.user_id || user.pk || userData.id || userData.user_id || userData.pk || '0'),
+        role: (user.role || user.roles || userData.role || userData.roles || ['admin']),
+        displayName,
+        photoURL: (user.photoURL || user.photoUrl || userData.photoURL || userData.photoUrl || ''),
+        email: (user.email || userData.email || ''),
+        shortcuts: (user.shortcuts || userData.shortcuts || []) || [],
+        settings: (user.settings || userData.settings || {}),
+        loginRedirectUrl: (user.loginRedirectUrl || userData.loginRedirectUrl || '/')
+    };
+};
+const getTokens = (data) => {
+    const tokens = asRecord(data.tokens);
+    const accessToken = (data.access_token || tokens.accessToken || tokens.access_token || data.access);
+    const refreshToken = (data.refresh_token || tokens.refreshToken || tokens.refresh_token || data.refresh || null);
+    return { accessToken, refreshToken };
+};
+const normalizeSession = (response) => {
+    const data = asRecord(response);
+    const { accessToken, refreshToken } = getTokens(data);
+    const user = normalizeUserShape(data.user);
+    if (!accessToken) {
+        throw new Error('Invalid auth response: missing access token');
+    }
+    return {
+        user,
+        accessToken,
+        refreshToken
+    };
+};
+export const createFuseJwtAuthProvider = (authClient) => {
+    function FuseJwtAuthProvider(props) {
+        const { ref, children, onAuthStateChanged } = props;
+        const [authState, setAuthState] = useState({
+            authStatus: 'configuring',
+            isAuthenticated: false,
+            user: null
+        });
+        useEffect(() => {
+            if (onAuthStateChanged) {
+                onAuthStateChanged(authState);
+            }
+        }, [authState, onAuthStateChanged]);
+        const signOut = useCallback(() => {
+            authClient.logout();
+            setAuthState({
+                authStatus: 'unauthenticated',
+                isAuthenticated: false,
+                user: null
+            });
+        }, []);
+        const refreshToken = useCallback(async () => {
+            try {
+                const response = await authClient.refreshToken();
+                return response.accessToken || null;
+            }
+            catch {
+                return null;
+            }
+        }, []);
+        useEffect(() => {
+            let isMounted = true;
+            const attemptAutoLogin = async () => {
+                let token = authClient.getAccessToken();
+                if (!isTokenValid(token)) {
+                    token = await refreshToken();
+                }
+                if (!isTokenValid(token)) {
+                    return false;
+                }
+                try {
+                    authClient.setAccessToken(token);
+                    const response = await authClient.getMe();
+                    return normalizeUserShape(response.user);
+                }
+                catch {
+                    return false;
+                }
+            };
+            if (!authState.isAuthenticated) {
+                attemptAutoLogin().then((userData) => {
+                    if (!isMounted) {
+                        return;
+                    }
+                    if (userData) {
+                        setAuthState({
+                            authStatus: 'authenticated',
+                            isAuthenticated: true,
+                            user: userData
+                        });
+                    }
+                    else {
+                        authClient.logout();
+                        setAuthState({
+                            authStatus: 'unauthenticated',
+                            isAuthenticated: false,
+                            user: null
+                        });
+                    }
+                });
+            }
+            return () => {
+                isMounted = false;
+            };
+        }, [authState.isAuthenticated, refreshToken]);
+        const signIn = useCallback(async (credentials) => {
+            const session = normalizeSession(await authClient.loginBasic({
+                login: credentials.login || credentials.username || '',
+                password: credentials.password,
+                client: 'web'
+            }));
+            setAuthState({
+                authStatus: 'authenticated',
+                isAuthenticated: true,
+                user: session.user
+            });
+            return {
+                user: session.user,
+                accessToken: session.accessToken,
+                refreshToken: session.refreshToken,
+                access_token: session.accessToken,
+                refresh_token: session.refreshToken
+            };
+        }, []);
+        const requestOtp = useCallback(async (payload) => authClient.requestOtp(payload), []);
+        const signInSocial = useCallback(async (payload) => {
+            const session = normalizeSession(await authClient.loginSocial({
+                ...payload,
+                client: payload.client ?? 'web'
+            }));
+            setAuthState({
+                authStatus: 'authenticated',
+                isAuthenticated: true,
+                user: session.user
+            });
+            return {
+                user: session.user,
+                accessToken: session.accessToken,
+                refreshToken: session.refreshToken,
+                access_token: session.accessToken,
+                refresh_token: session.refreshToken
+            };
+        }, []);
+        const signInOtp = useCallback(async (payload) => {
+            const session = normalizeSession(await authClient.verifyOtp({
+                ...payload,
+                client: payload.client ?? 'web'
+            }));
+            setAuthState({
+                authStatus: 'authenticated',
+                isAuthenticated: true,
+                user: session.user
+            });
+            return {
+                user: session.user,
+                accessToken: session.accessToken,
+                refreshToken: session.refreshToken,
+                access_token: session.accessToken,
+                refresh_token: session.refreshToken
+            };
+        }, []);
+        const signUp = useCallback(async (payload) => {
+            const response = await authClient.register(payload);
+            return response;
+        }, []);
+        const requestPasswordReset = useCallback(async (payload) => authClient.requestPasswordReset(payload), []);
+        const confirmAccountEmail = useCallback(async (payload) => authClient.confirmAccountEmail(payload), []);
+        const resendAccountConfirmation = useCallback(async (payload) => authClient.resendAccountConfirmation(payload), []);
+        const confirmPasswordReset = useCallback(async (payload) => authClient.confirmPasswordReset(payload), []);
+        const changePassword = useCallback(async (payload) => authClient.changePassword(payload), []);
+        const switchProfile = useCallback(async (profileId) => {
+            const session = normalizeSession(await authClient.switchProfile({
+                profile: profileId,
+                client: 'web'
+            }));
+            setAuthState({
+                authStatus: 'authenticated',
+                isAuthenticated: true,
+                user: session.user
+            });
+            return {
+                user: session.user,
+                accessToken: session.accessToken,
+                refreshToken: session.refreshToken,
+                access_token: session.accessToken,
+                refresh_token: session.refreshToken
+            };
+        }, []);
+        const getProfiles = useCallback(async () => {
+            const response = await authClient.getProfiles();
+            if (Array.isArray(response)) {
+                return response;
+            }
+            return (response.results ?? []);
+        }, []);
+        const contextValue = useMemo(() => ({
+            ...authState,
+            signIn,
+            signInSocial,
+            requestOtp,
+            signInOtp,
+            signUp,
+            confirmAccountEmail,
+            resendAccountConfirmation,
+            requestPasswordReset,
+            confirmPasswordReset,
+            changePassword,
+            switchProfile,
+            getProfiles,
+            signOut,
+            refreshToken
+        }), [
+            authState,
+            signIn,
+            signInSocial,
+            requestOtp,
+            signInOtp,
+            signUp,
+            confirmAccountEmail,
+            resendAccountConfirmation,
+            requestPasswordReset,
+            confirmPasswordReset,
+            changePassword,
+            switchProfile,
+            getProfiles,
+            signOut,
+            refreshToken
+        ]);
+        useImperativeHandle(ref, () => ({
+            signOut
+        }));
+        return _jsx(FuseJwtAuthContext.Provider, { value: contextValue, children: children });
+    }
+    return FuseJwtAuthProvider;
+};
+export const useFuseJwtAuth = () => {
+    const context = useContext(FuseJwtAuthContext);
+    if (!context) {
+        throw new Error('useFuseJwtAuth must be used within createFuseJwtAuthProvider provider');
+    }
+    return context;
+};

package/dist/auth/fuse/fuseIntegration.d.ts

@@ -0,0 +1,59 @@
+import React, { ReactNode } from 'react';
+import { AuthClient } from '../client';
+export type FuseUser = {
+    id: string;
+    role: string[] | string | null;
+    displayName: string;
+    photoURL?: string;
+    email?: string;
+    shortcuts?: string[];
+    settings?: Record<string, unknown>;
+    loginRedirectUrl?: string;
+};
+export declare const fuseAuthRoles: {
+    readonly admin: readonly ["admin"];
+    readonly staff: readonly ["admin", "staff"];
+    readonly user: readonly ["admin", "staff", "user"];
+    readonly onlyGuest: readonly [];
+};
+export declare function createFuseUserModel<TUser extends FuseUser>(): (data?: Partial<TUser>) => TUser;
+type CreateFuseUseUserOptions<TUser extends FuseUser> = {
+    useAuth: () => {
+        authState: {
+            user: TUser | null;
+        } | null;
+        signOut: () => void;
+        updateUser: (updates: Partial<TUser>) => Promise<Response>;
+    };
+    setIn: (obj: unknown, path: string, value: unknown) => unknown;
+};
+export declare function createFuseUseUser<TUser extends FuseUser>(options: CreateFuseUseUserOptions<TUser>): () => {
+    data: TUser;
+    isGuest: boolean;
+    signOut: () => Promise<void>;
+    updateUser: (data: Partial<TUser>) => Promise<TUser>;
+    updateUserSettings: (newSettings: TUser["settings"]) => Promise<Record<string, unknown> | undefined>;
+};
+export declare function createWithUser<TProps extends object, TUserHookReturn>(useUserHook: () => TUserHookReturn): (Component: React.ComponentType<TProps & TUserHookReturn>) => (props: TProps) => import("react/jsx-runtime").JSX.Element;
+type CreateFuseAuthenticationOptions<TUser extends FuseUser> = {
+    authClient: AuthClient;
+    FuseAuthProvider: React.ComponentType<{
+        providers: Array<{
+            name: string;
+            Provider: React.ComponentType<any> | React.ForwardRefExoticComponent<any>;
+        }>;
+        children: (authState: {
+            user?: TUser | null;
+        } | null) => ReactNode;
+    }>;
+    FuseAuthorization: React.ComponentType<{
+        userRole: TUser['role'] | undefined;
+        children: ReactNode;
+    }>;
+    providerName?: string;
+};
+export declare function createFuseAuthentication<TUser extends FuseUser>(options: CreateFuseAuthenticationOptions<TUser>): (props: {
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=fuseIntegration.d.ts.map

package/dist/auth/fuse/fuseIntegration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fuseIntegration.d.ts","sourceRoot":"","sources":["../../../src/auth/fuse/fuseIntegration.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,SAAS,EAAW,MAAM,OAAO,CAAC;AAElD,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAKvC,MAAM,MAAM,QAAQ,GAAG;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,IAAI,CAAC;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF,eAAO,MAAM,aAAa;;;;;CAKhB,CAAC;AAEX,wBAAgB,mBAAmB,CAAC,KAAK,SAAS,QAAQ,MAChD,OAAO,OAAO,CAAC,KAAK,CAAC,KAAG,KAAK,CAetC;AAED,KAAK,wBAAwB,CAAC,KAAK,SAAS,QAAQ,IAAI;IACtD,OAAO,EAAE,MAAM;QACb,SAAS,EAAE;YAAE,IAAI,EAAE,KAAK,GAAG,IAAI,CAAA;SAAE,GAAG,IAAI,CAAC;QACzC,OAAO,EAAE,MAAM,IAAI,CAAC;QACpB,UAAU,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;KAC5D,CAAC;IACF,KAAK,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;CAChE,CAAC;AAEF,wBAAgB,iBAAiB,CAAC,KAAK,SAAS,QAAQ,EAAE,OAAO,EAAE,wBAAwB,CAAC,KAAK,CAAC;;;;uBAQxD,OAAO,CAAC,KAAK,CAAC;sCAWC,KAAK,CAAC,UAAU,CAAC;EAuBzE;AAED,wBAAgB,cAAc,CAAC,MAAM,SAAS,MAAM,EAAE,eAAe,EACnE,WAAW,EAAE,MAAM,eAAe,IAET,WAAW,KAAK,CAAC,aAAa,CAAC,MAAM,GAAG,eAAe,CAAC,MAC9C,OAAO,MAAM,6CAUjD;AAED,KAAK,+BAA+B,CAAC,KAAK,SAAS,QAAQ,IAAI;IAC7D,UAAU,EAAE,UAAU,CAAC;IACvB,gBAAgB,EAAE,KAAK,CAAC,aAAa,CAAC;QACpC,SAAS,EAAE,KAAK,CAAC;YACf,IAAI,EAAE,MAAM,CAAC;YACb,QAAQ,EAAE,KAAK,CAAC,aAAa,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,yBAAyB,CAAC,GAAG,CAAC,CAAC;SAC3E,CAAC,CAAC;QACH,QAAQ,EAAE,CAAC,SAAS,EAAE;YAAE,IAAI,CAAC,EAAE,KAAK,GAAG,IAAI,CAAA;SAAE,GAAG,IAAI,KAAK,SAAS,CAAC;KACpE,CAAC,CAAC;IACH,iBAAiB,EAAE,KAAK,CAAC,aAAa,CAAC;QACrC,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC;QACpC,QAAQ,EAAE,SAAS,CAAC;KACrB,CAAC,CAAC;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,wBAAgB,wBAAwB,CAAC,KAAK,SAAS,QAAQ,EAAE,OAAO,EAAE,+BAA+B,CAAC,KAAK,CAAC,IAW/E,OAAO;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,6CAY9D"}

package/dist/auth/fuse/fuseIntegration.js

@@ -0,0 +1,85 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import { createFuseJwtAuthProvider } from './fuseAdapter';
+const isEqual = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+export const fuseAuthRoles = {
+    admin: ['admin'],
+    staff: ['admin', 'staff'],
+    user: ['admin', 'staff', 'user'],
+    onlyGuest: []
+};
+export function createFuseUserModel() {
+    return (data) => {
+        const userData = data || {};
+        return {
+            id: null,
+            role: null,
+            displayName: null,
+            photoURL: '',
+            email: '',
+            shortcuts: [],
+            settings: {},
+            loginRedirectUrl: '/',
+            ...userData
+        };
+    };
+}
+export function createFuseUseUser(options) {
+    const { useAuth, setIn } = options;
+    return function useUser() {
+        const { authState, signOut, updateUser } = useAuth();
+        const user = authState?.user;
+        const isGuest = useMemo(() => !user?.role || user?.role?.length === 0, [user]);
+        async function handleUpdateUser(data) {
+            const response = await updateUser(data);
+            if (!response.ok) {
+                throw new Error('Failed to update user');
+            }
+            const updatedUser = (await response.json());
+            return updatedUser;
+        }
+        async function handleUpdateUserSettings(newSettings) {
+            const newUser = setIn(user, 'settings', newSettings);
+            if (isEqual(user, newUser)) {
+                return undefined;
+            }
+            const updatedUser = await handleUpdateUser(newUser);
+            return updatedUser?.settings;
+        }
+        async function handleSignOut() {
+            return signOut();
+        }
+        return {
+            data: user,
+            isGuest,
+            signOut: handleSignOut,
+            updateUser: handleUpdateUser,
+            updateUserSettings: handleUpdateUserSettings
+        };
+    };
+}
+export function createWithUser(useUserHook) {
+    return function withUser(Component) {
+        return function WrappedComponent(props) {
+            const userProps = useUserHook();
+            return (_jsx(Component, { ...props, ...userProps }));
+        };
+    };
+}
+export function createFuseAuthentication(options) {
+    const { authClient, FuseAuthProvider, FuseAuthorization, providerName = 'jb-jwt' } = options;
+    const JwtProvider = createFuseJwtAuthProvider(authClient);
+    const providers = [
+        {
+            name: providerName,
+            Provider: JwtProvider
+        }
+    ];
+    return function Authentication(props) {
+        const { children } = props;
+        return (_jsx(FuseAuthProvider, { providers: providers, children: (authState) => {
+                const userRole = authState?.user?.role;
+                return _jsx(FuseAuthorization, { userRole: userRole, children: children });
+            } }));
+    };
+}

package/dist/auth/fuse/index.d.ts

@@ -0,0 +1,4 @@
+export * from './createFuseAuthViews';
+export * from './fuseAdapter';
+export * from './fuseIntegration';
+//# sourceMappingURL=index.d.ts.map

package/dist/auth/fuse/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/auth/fuse/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC"}

package/dist/auth/fuse/index.js

@@ -0,0 +1,3 @@
+export * from './createFuseAuthViews';
+export * from './fuseAdapter';
+export * from './fuseIntegration';

package/dist/auth/index.d.ts

@@ -0,0 +1,11 @@
+export * from './types';
+export * from './storage';
+export * from './client';
+export * from './provider';
+export * from './routes';
+export * from './fuse';
+export * from './ui';
+export * from './query';
+export * from './forms';
+export * from './constants';
+//# sourceMappingURL=index.d.ts.map

package/dist/auth/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/auth/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,cAAc,MAAM,CAAC;AACrB,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC"}

package/dist/auth/index.js

@@ -0,0 +1,10 @@
+export * from './types';
+export * from './storage';
+export * from './client';
+export * from './provider';
+export * from './routes';
+export * from './fuse';
+export * from './ui';
+export * from './query';
+export * from './forms';
+export * from './constants';

package/dist/auth/provider.d.ts

@@ -0,0 +1,35 @@
+import { ReactNode } from 'react';
+import { AuthClient } from './client';
+import { AccountConfirmationPayload, AccountConfirmationResendPayload, ApiDetailResponse, LoginBasicPayload, PasswordChangePayload, PasswordResetConfirmPayload, PasswordResetRequestPayload, ProfilesResponse, RegisterPayload, RequestOtpPayload, SwitchProfilePayload, VerifyOtpPayload } from './types';
+export type JBAuthStatus = 'configuring' | 'authenticated' | 'unauthenticated';
+export type JBAuthContextValue = {
+    authStatus: JBAuthStatus;
+    isAuthenticated: boolean;
+    user: unknown | null;
+    signIn: (payload: LoginBasicPayload) => Promise<unknown>;
+    signUp: (payload: RegisterPayload) => Promise<ApiDetailResponse>;
+    confirmAccountEmail: (payload: AccountConfirmationPayload) => Promise<ApiDetailResponse>;
+    resendAccountConfirmation: (payload: AccountConfirmationResendPayload) => Promise<ApiDetailResponse>;
+    signInOtp: (payload: VerifyOtpPayload) => Promise<unknown>;
+    requestOtp: (payload: RequestOtpPayload) => Promise<Record<string, unknown>>;
+    requestPasswordReset: (payload: PasswordResetRequestPayload) => Promise<Record<string, unknown>>;
+    confirmPasswordReset: (payload: PasswordResetConfirmPayload) => Promise<Record<string, unknown>>;
+    changePassword: (payload: PasswordChangePayload) => Promise<Record<string, unknown>>;
+    getProfiles: () => Promise<ProfilesResponse>;
+    switchProfile: (payload: SwitchProfilePayload) => Promise<unknown>;
+    signOut: () => void;
+    refreshToken: () => Promise<string | null>;
+};
+type JBAuthProviderProps = {
+    authClient: AuthClient;
+    children: ReactNode;
+    onAuthStateChanged?: (state: {
+        authStatus: JBAuthStatus;
+        isAuthenticated: boolean;
+        user: unknown | null;
+    }) => void;
+};
+export declare function JBAuthProvider(props: JBAuthProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useJBAuth(): JBAuthContextValue;
+export {};
+//# sourceMappingURL=provider.d.ts.map

package/dist/auth/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../src/auth/provider.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAiB,SAAS,EAAyD,MAAM,OAAO,CAAC;AAExG,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACtC,OAAO,EACL,0BAA0B,EAC1B,gCAAgC,EAChC,iBAAiB,EACjB,iBAAiB,EACjB,qBAAqB,EACrB,2BAA2B,EAC3B,2BAA2B,EAC3B,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EACjB,oBAAoB,EACpB,gBAAgB,EACjB,MAAM,SAAS,CAAC;AAEjB,MAAM,MAAM,YAAY,GAAG,aAAa,GAAG,eAAe,GAAG,iBAAiB,CAAC;AAE/E,MAAM,MAAM,kBAAkB,GAAG;IAC/B,UAAU,EAAE,YAAY,CAAC;IACzB,eAAe,EAAE,OAAO,CAAC;IACzB,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IACrB,MAAM,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACzD,MAAM,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,OAAO,CAAC,iBAAiB,CAAC,CAAC;IACjE,mBAAmB,EAAE,CAAC,OAAO,EAAE,0BAA0B,KAAK,OAAO,CAAC,iBAAiB,CAAC,CAAC;IACzF,yBAAyB,EAAE,CAAC,OAAO,EAAE,gCAAgC,KAAK,OAAO,CAAC,iBAAiB,CAAC,CAAC;IACrG,SAAS,EAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC3D,UAAU,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC7E,oBAAoB,EAAE,CAAC,OAAO,EAAE,2BAA2B,KAAK,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACjG,oBAAoB,EAAE,CAAC,OAAO,EAAE,2BAA2B,KAAK,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACjG,cAAc,EAAE,CAAC,OAAO,EAAE,qBAAqB,KAAK,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACrF,WAAW,EAAE,MAAM,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAC7C,aAAa,EAAE,CAAC,OAAO,EAAE,oBAAoB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACnE,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,YAAY,EAAE,MAAM,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;CAC5C,CAAC;AAEF,KAAK,mBAAmB,GAAG;IACzB,UAAU,EAAE,UAAU,CAAC;IACvB,QAAQ,EAAE,SAAS,CAAC;IACpB,kBAAkB,CAAC,EAAE,CAAC,KAAK,EAAE;QAC3B,UAAU,EAAE,YAAY,CAAC;QACzB,eAAe,EAAE,OAAO,CAAC;QACzB,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;KACtB,KAAK,IAAI,CAAC;CACZ,CAAC;AAeF,wBAAgB,cAAc,CAAC,KAAK,EAAE,mBAAmB,2CAmKxD;AAED,wBAAgB,SAAS,uBAMxB"}

package/dist/auth/provider.js

@@ -0,0 +1,133 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useEffect, useMemo, useState } from 'react';
+const JBAuthContext = createContext(undefined);
+const isTokenValid = (token) => {
+    if (!token)
+        return false;
+    try {
+        const payload = JSON.parse(atob(token.split('.')[1]));
+        const now = Date.now() / 1000;
+        return payload.exp > now;
+    }
+    catch {
+        return false;
+    }
+};
+export function JBAuthProvider(props) {
+    const { authClient, children, onAuthStateChanged } = props;
+    const [authStatus, setAuthStatus] = useState('configuring');
+    const [user, setUser] = useState(null);
+    useEffect(() => {
+        onAuthStateChanged?.({
+            authStatus,
+            isAuthenticated: authStatus === 'authenticated',
+            user
+        });
+    }, [authStatus, onAuthStateChanged, user]);
+    const setAuthenticatedSession = useCallback((authResponse) => {
+        setUser(authResponse.user ?? null);
+        setAuthStatus('authenticated');
+        return authResponse.user ?? null;
+    }, []);
+    const signIn = useCallback(async (payload) => {
+        const response = await authClient.loginBasic(payload);
+        return setAuthenticatedSession(response);
+    }, [authClient, setAuthenticatedSession]);
+    const signInOtp = useCallback(async (payload) => {
+        const response = await authClient.verifyOtp(payload);
+        return setAuthenticatedSession(response);
+    }, [authClient, setAuthenticatedSession]);
+    const signUp = useCallback(async (payload) => {
+        const response = await authClient.register(payload);
+        return response;
+    }, [authClient]);
+    const confirmAccountEmail = useCallback(async (payload) => authClient.confirmAccountEmail(payload), [authClient]);
+    const resendAccountConfirmation = useCallback(async (payload) => authClient.resendAccountConfirmation(payload), [authClient]);
+    const signOut = useCallback(() => {
+        authClient.logout();
+        setUser(null);
+        setAuthStatus('unauthenticated');
+    }, [authClient]);
+    const refreshToken = useCallback(async () => {
+        const response = await authClient.refreshToken();
+        return response.accessToken || null;
+    }, [authClient]);
+    const requestOtp = useCallback(async (payload) => authClient.requestOtp(payload), [authClient]);
+    const requestPasswordReset = useCallback(async (payload) => authClient.requestPasswordReset(payload), [authClient]);
+    const confirmPasswordReset = useCallback(async (payload) => authClient.confirmPasswordReset(payload), [authClient]);
+    const changePassword = useCallback(async (payload) => authClient.changePassword(payload), [authClient]);
+    const getProfiles = useCallback(async () => authClient.getProfiles(), [authClient]);
+    const switchProfile = useCallback(async (payload) => {
+        const response = await authClient.switchProfile(payload);
+        return setAuthenticatedSession(response);
+    }, [authClient, setAuthenticatedSession]);
+    useEffect(() => {
+        let isMounted = true;
+        const bootstrapAuth = async () => {
+            const accessToken = authClient.getAccessToken();
+            if (!isTokenValid(accessToken)) {
+                setAuthStatus('unauthenticated');
+                return;
+            }
+            try {
+                const response = await authClient.getMe();
+                if (!isMounted)
+                    return;
+                setAuthenticatedSession(response);
+            }
+            catch {
+                if (!isMounted)
+                    return;
+                authClient.logout();
+                setUser(null);
+                setAuthStatus('unauthenticated');
+            }
+        };
+        bootstrapAuth();
+        return () => {
+            isMounted = false;
+        };
+    }, [authClient, setAuthenticatedSession]);
+    const contextValue = useMemo(() => ({
+        authStatus,
+        isAuthenticated: authStatus === 'authenticated',
+        user,
+        signIn,
+        signUp,
+        confirmAccountEmail,
+        resendAccountConfirmation,
+        signInOtp,
+        requestOtp,
+        requestPasswordReset,
+        confirmPasswordReset,
+        changePassword,
+        getProfiles,
+        switchProfile,
+        signOut,
+        refreshToken
+    }), [
+        authStatus,
+        user,
+        signIn,
+        signUp,
+        confirmAccountEmail,
+        resendAccountConfirmation,
+        signInOtp,
+        requestOtp,
+        requestPasswordReset,
+        confirmPasswordReset,
+        changePassword,
+        getProfiles,
+        switchProfile,
+        signOut,
+        refreshToken
+    ]);
+    return _jsx(JBAuthContext.Provider, { value: contextValue, children: children });
+}
+export function useJBAuth() {
+    const context = useContext(JBAuthContext);
+    if (!context) {
+        throw new Error('useJBAuth must be used within JBAuthProvider');
+    }
+    return context;
+}

package/dist/auth/query.d.ts

@@ -0,0 +1,23 @@
+import { AuthClient } from './client';
+import { AccountUpdatePayload, DeleteAccountPayload, JbDrfWebAuthResponse, LinkSocialPayload, LoginBasicPayload, LoginSocialPayload, SwitchProfilePayload, UnlinkSocialPayload } from './types';
+export declare const authQueryKeys: {
+    all: readonly ["auth"];
+    me: () => readonly ["auth", "me"];
+    social: () => readonly ["auth", "social"];
+    account: () => readonly ["auth", "account"];
+};
+export declare const createAuthQueryHooks: (authClient: Pick<AuthClient, "getMe" | "loginBasic" | "loginSocial" | "linkSocial" | "unlinkSocial" | "updateAccount" | "deleteAccount" | "switchProfile" | "logout">) => {
+    useMeQuery: (enabled?: boolean) => import("@tanstack/react-query").UseQueryResult<JbDrfWebAuthResponse, Error>;
+    useLoginMutation: () => import("@tanstack/react-query").UseMutationResult<JbDrfWebAuthResponse, Error, LoginBasicPayload, unknown>;
+    useSocialLoginMutation: () => import("@tanstack/react-query").UseMutationResult<JbDrfWebAuthResponse, Error, LoginSocialPayload, unknown>;
+    useLinkSocialMutation: () => import("@tanstack/react-query").UseMutationResult<Record<string, unknown>, Error, LinkSocialPayload, unknown>;
+    useUnlinkSocialMutation: () => import("@tanstack/react-query").UseMutationResult<Record<string, unknown>, Error, UnlinkSocialPayload, unknown>;
+    useAccountUpdateMutation: () => import("@tanstack/react-query").UseMutationResult<Record<string, unknown>, Error, {
+        payload: AccountUpdatePayload;
+        method?: "PATCH" | "PUT";
+    }, unknown>;
+    useDeleteAccountMutation: () => import("@tanstack/react-query").UseMutationResult<unknown, Error, DeleteAccountPayload, unknown>;
+    useSwitchProfileMutation: () => import("@tanstack/react-query").UseMutationResult<JbDrfWebAuthResponse, Error, SwitchProfilePayload, unknown>;
+    useLogoutMutation: () => import("@tanstack/react-query").UseMutationResult<void, Error, void, unknown>;
+};
+//# sourceMappingURL=query.d.ts.map

package/dist/auth/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/auth/query.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACtC,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,oBAAoB,EACpB,iBAAiB,EACjB,iBAAiB,EACjB,kBAAkB,EAClB,oBAAoB,EACpB,mBAAmB,EACpB,MAAM,SAAS,CAAC;AAEjB,eAAO,MAAM,aAAa;;;;;CAKzB,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,YAAY,IAAI,CACd,UAAU,EACR,OAAO,GACP,YAAY,GACZ,aAAa,GACb,YAAY,GACZ,cAAc,GACd,eAAe,GACf,eAAe,GACf,eAAe,GACf,QAAQ,CACX;;;;;;;iBA8DgD,oBAAoB;iBAAW,OAAO,GAAG,KAAK;;;;;CA6ChG,CAAC"}