@q2devel/q2-storybook 1.0.26 → 1.0.28

package/dist/auth/Auth.types.d.ts

@@ -0,0 +1,32 @@
+import { AxiosInstance } from 'axios';
+import { Context, PropsWithChildren } from 'react';
+import { AccessToken, DeepNonRequired } from './types';
+import { AuthenticationSettings } from './config/config.types';
+export type AuthContextType<UserType> = Context<AuthContextState<UserType>>;
+export type LoadingType = 'SIGN_IN' | 'SIGN_UP' | 'SIGN_OUT' | 'FORGOT_PASSWORD' | 'RESET_PASSWORD' | 'CURRENT_USER' | 'UPDATE_CURRENT_USER' | 'UPDATE_CURRENT_USER_PASSWORD';
+export type TokenStorage = {
+    get: () => AccessToken | undefined;
+    set: (accessToken?: AccessToken) => void;
+};
+export type AuthContextState<UserType> = {
+    config: AuthenticationSettings;
+    axiosInstance: AxiosInstance;
+    tokenStorage?: TokenStorage;
+    accessToken?: AccessToken;
+    currentUser?: UserType;
+    loading: LoadingType[];
+    isLogged: boolean;
+    isReady: boolean;
+    setAccessToken: (value?: AccessToken) => void;
+    setCurrentUser: (value?: UserType) => void;
+    refetchCurrentUser: () => void;
+    addLoading: (value: LoadingType) => void;
+    removeLoading: (value: LoadingType) => void;
+    destroyAccessToken: () => void;
+};
+export type AuthProviderProps<UserType = unknown> = PropsWithChildren<{
+    config?: DeepNonRequired<AuthenticationSettings>;
+    axiosInstance: AxiosInstance;
+    initialAccessToken?: AccessToken;
+    initialCurrentUser?: UserType;
+}>;

package/dist/auth/Auth.types.js

@@ -0,0 +1 @@
+export {};

package/dist/auth/components/AuthenticatedFactory.d.ts

@@ -0,0 +1,7 @@
+import { AuthContextType } from '../Auth.types';
+import { AuthenticatedProps } from './AuthenticatedFactory.types';
+declare const createAuthenticatedComponent: <UserType extends unknown>(AuthContext: AuthContextType<UserType>) => {
+    ({ children, middleware }: AuthenticatedProps): import("react/jsx-runtime").JSX.Element | null;
+    displayName: string;
+};
+export default createAuthenticatedComponent;

package/dist/auth/components/AuthenticatedFactory.js

@@ -0,0 +1,21 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+// src/auth/components/AuthenticatedFactory.tsx
+import { useContext } from 'react';
+const createAuthenticatedComponent = (AuthContext) => {
+    const Authenticated = ({ children, middleware }) => {
+        const { isLogged, isReady } = useContext(AuthContext);
+        if (!isReady) {
+            return null;
+        }
+        if (middleware === 'only-logged' && !isLogged) {
+            return null;
+        }
+        if (middleware === 'only-guest' && isLogged) {
+            return null;
+        }
+        return _jsx(_Fragment, { children: children });
+    };
+    Authenticated.displayName = 'Authenticated';
+    return Authenticated;
+};
+export default createAuthenticatedComponent;

package/dist/auth/components/AuthenticatedFactory.types.d.ts

@@ -0,0 +1,4 @@
+import { PropsWithChildren } from 'react';
+export type AuthenticatedProps = PropsWithChildren<{
+    middleware?: 'only-logged' | 'only-guest';
+}>;

package/dist/auth/components/AuthenticatedFactory.types.js

@@ -0,0 +1 @@
+export {};

package/dist/auth/config/Config.d.ts

@@ -0,0 +1,3 @@
+import { AuthenticationSettings } from './config.types';
+declare const config: AuthenticationSettings;
+export default config;

package/dist/auth/config/Config.js

@@ -0,0 +1,19 @@
+// Defaultní konfigurace
+const config = {
+    tokenStorageType: 'localStorage',
+    tokenStorageKey: 'auth-token',
+    logoutWhenFailedLoadUser: true,
+    getDataFromRequest: (data) => data.data,
+    getTokenFromRequest: (data) => data.token,
+    signInRoute: '/api/auth/login',
+    defaultRequestType: 'json',
+    signOutRoute: '/api/auth/logout',
+    signUpRoute: '/api/auth/register',
+    currentUserRoute: '/api/auth/user',
+    currentUserUpdateRoute: '/api/auth/user',
+    currentUserChangePasswordRoute: '/api/auth/user/password',
+    currentUserChangeAvatarRoute: '/api/auth/user/avatar',
+    forgotPasswordRoute: '/api/auth/forgot-password',
+    resetPasswordRoute: '/api/auth/reset-password',
+};
+export default config;

package/dist/auth/config/config.types.d.ts

@@ -0,0 +1,27 @@
+import { AccessToken, TokenStorageProvider } from '../types';
+export type TokenStorageType = 'localStorage' | 'cookie' | 'memory';
+export type RequestDataType = 'json' | 'form-data';
+export type AuthenticationSettings = {
+    tokenStorageType: TokenStorageType | TokenStorageProvider;
+    tokenStorageKey: string;
+    logoutWhenFailedLoadUser: boolean;
+    getDataFromRequest: (data: any) => unknown;
+    getTokenFromRequest: (data: any) => AccessToken;
+    signInRoute: string;
+    defaultRequestType: RequestDataType;
+    signInRouteRequestType?: RequestDataType;
+    signOutRoute: string;
+    signOutRouteRequestType?: RequestDataType;
+    signUpRoute: string;
+    signUpRouteRequestType?: RequestDataType;
+    currentUserRoute: string;
+    currentUserUpdateRoute: string;
+    currentUserUpdateRouteRequestDataType?: RequestDataType;
+    currentUserChangePasswordRoute: string;
+    currentUserChangePasswordRouteRequestDataType?: RequestDataType;
+    currentUserChangeAvatarRoute: string;
+    forgotPasswordRoute: string;
+    forgotPasswordRouteRequestDataType?: RequestDataType;
+    resetPasswordRoute: string;
+    resetPasswordRouteRequestDataType?: RequestDataType;
+};

package/dist/auth/config/config.types.js

@@ -0,0 +1 @@
+export {};

package/dist/auth/context/AuthContextFactory.d.ts

@@ -0,0 +1,3 @@
+import { AuthContextState } from '../Auth.types';
+declare const createAuthContext: <UserType>() => import("react").Context<AuthContextState<UserType>>;
+export default createAuthContext;

package/dist/auth/context/AuthContextFactory.js

@@ -0,0 +1,19 @@
+'use client';
+import { createContext } from 'react';
+const createAuthContext = () => {
+    const defaultState = {
+        config: {},
+        axiosInstance: {},
+        loading: [],
+        isLogged: false,
+        isReady: false,
+        setAccessToken: () => { },
+        setCurrentUser: () => { },
+        refetchCurrentUser: () => { },
+        addLoading: () => { },
+        removeLoading: () => { },
+        destroyAccessToken: () => { },
+    };
+    return createContext(defaultState);
+};
+export default createAuthContext;

package/dist/auth/hooks/useCurrentUserHookFactory.d.ts

@@ -0,0 +1,11 @@
+import { AuthContextType } from '../Auth.types';
+declare const createUseCurrentUserHook: <UserType>(AuthContext: AuthContextType<UserType>) => () => {
+    isLogged: boolean;
+    isReady: boolean;
+    user: UserType | undefined;
+    setUser: (value?: UserType | undefined) => void;
+    refetchCurrentUser: () => void;
+    setAccessToken: (value?: import("..").AccessToken) => void;
+    isLoading: boolean;
+};
+export default createUseCurrentUserHook;

package/dist/auth/hooks/useCurrentUserHookFactory.js

@@ -0,0 +1,17 @@
+import { useContext } from 'react';
+const createUseCurrentUserHook = (AuthContext) => {
+    return () => {
+        const { currentUser, setCurrentUser, refetchCurrentUser, setAccessToken, loading, isLogged, isReady, } = useContext(AuthContext);
+        const isLoading = loading.includes('CURRENT_USER');
+        return {
+            isLogged,
+            isReady,
+            user: currentUser,
+            setUser: setCurrentUser,
+            refetchCurrentUser,
+            setAccessToken,
+            isLoading,
+        };
+    };
+};
+export default createUseCurrentUserHook;

package/dist/auth/hooks/useCurrentUserUpdateHookFactory.d.ts

@@ -0,0 +1,9 @@
+import { AuthContextType } from '../Auth.types';
+import { DefaultUpdateCurrentUserRequestData } from '../service';
+declare const createUseCurrentUserUpdateHook: <UserType>(AuthContext: AuthContextType<UserType>) => <UpdateCurrentUserRequestData = DefaultUpdateCurrentUserRequestData>() => {
+    updateCurrentUser: (data: UpdateCurrentUserRequestData) => Promise<(UserType & {
+        token: import("..").AccessToken;
+    }) | undefined>;
+    isLoading: boolean;
+};
+export default createUseCurrentUserUpdateHook;

package/dist/auth/hooks/useCurrentUserUpdateHookFactory.js

@@ -0,0 +1,28 @@
+import { useContext, useCallback } from 'react';
+import { updateCurrentUser } from '../service/AuthService';
+const createUseCurrentUserUpdateHook = (AuthContext) => {
+    return () => {
+        const { axiosInstance, config, addLoading, removeLoading, setCurrentUser } = useContext(AuthContext);
+        const loading = useContext(AuthContext).loading;
+        const isLoading = loading.includes('UPDATE_CURRENT_USER');
+        const updateCallback = useCallback(async (data) => {
+            try {
+                addLoading('UPDATE_CURRENT_USER');
+                const response = await updateCurrentUser(axiosInstance, config, data);
+                setCurrentUser(response);
+                return response;
+            }
+            catch (e) {
+                return undefined;
+            }
+            finally {
+                removeLoading('UPDATE_CURRENT_USER');
+            }
+        }, [axiosInstance, config, addLoading, removeLoading, setCurrentUser]);
+        return {
+            updateCurrentUser: updateCallback,
+            isLoading,
+        };
+    };
+};
+export default createUseCurrentUserUpdateHook;

package/dist/auth/hooks/useCurrentUserUpdatePasswordHookFactory.d.ts

@@ -0,0 +1,7 @@
+import { AuthContextType } from '../Auth.types';
+import { DefaultUpdateCurrentUserPasswordRequestData } from '../service';
+declare const createUseCurrentUserUpdatePasswordHook: <UserType>(AuthContext: AuthContextType<UserType>) => <UpdateCurrentUserPasswordRequestData = DefaultUpdateCurrentUserPasswordRequestData>() => {
+    updateCurrentUserPassword: (data: UpdateCurrentUserPasswordRequestData) => Promise<import("..").MakeUserWithAccessToken<UserType> | undefined>;
+    isLoading: boolean;
+};
+export default createUseCurrentUserUpdatePasswordHook;

package/dist/auth/hooks/useCurrentUserUpdatePasswordHookFactory.js

@@ -0,0 +1,31 @@
+import { useContext, useCallback } from 'react';
+import { updateCurrentUserPassword } from '../service/AuthService';
+const createUseCurrentUserUpdatePasswordHook = (AuthContext) => {
+    return () => {
+        const { axiosInstance, config, addLoading, removeLoading, setAccessToken, setCurrentUser } = useContext(AuthContext);
+        const loading = useContext(AuthContext).loading;
+        const isLoading = loading.includes('UPDATE_CURRENT_USER_PASSWORD');
+        const updatePasswordCallback = useCallback(async (data) => {
+            try {
+                addLoading('UPDATE_CURRENT_USER_PASSWORD');
+                const response = await updateCurrentUserPassword(axiosInstance, config, data);
+                if (response.token) {
+                    setAccessToken(response.token);
+                }
+                setCurrentUser(response);
+                return response;
+            }
+            catch (e) {
+                return undefined;
+            }
+            finally {
+                removeLoading('UPDATE_CURRENT_USER_PASSWORD');
+            }
+        }, [axiosInstance, config, addLoading, removeLoading, setAccessToken, setCurrentUser]);
+        return {
+            updateCurrentUserPassword: updatePasswordCallback,
+            isLoading,
+        };
+    };
+};
+export default createUseCurrentUserUpdatePasswordHook;

package/dist/auth/hooks/useForgotPasswordHookFactory.d.ts

@@ -0,0 +1,7 @@
+import { AuthContextType } from '../Auth.types';
+import { DefaultForgotPasswordRequestData } from '../service';
+declare const createUseForgotPasswordHook: <UserType>(AuthContext: AuthContextType<UserType>) => <ForgotPasswordRequestData = DefaultForgotPasswordRequestData>() => {
+    forgotPassword: (data: ForgotPasswordRequestData) => Promise<any>;
+    isLoading: boolean;
+};
+export default createUseForgotPasswordHook;

package/dist/auth/hooks/useForgotPasswordHookFactory.js

@@ -0,0 +1,26 @@
+import { useContext, useCallback } from 'react';
+import { forgotPassword } from '../service/AuthService';
+const createUseForgotPasswordHook = (AuthContext) => {
+    return () => {
+        const { axiosInstance, config, addLoading, removeLoading } = useContext(AuthContext);
+        const loading = useContext(AuthContext).loading;
+        const isLoading = loading.includes('FORGOT_PASSWORD');
+        const forgotPasswordCallback = useCallback(async (data) => {
+            try {
+                addLoading('FORGOT_PASSWORD');
+                return await forgotPassword(axiosInstance, config, data);
+            }
+            catch (e) {
+                return undefined;
+            }
+            finally {
+                removeLoading('FORGOT_PASSWORD');
+            }
+        }, [axiosInstance, config, addLoading, removeLoading]);
+        return {
+            forgotPassword: forgotPasswordCallback,
+            isLoading,
+        };
+    };
+};
+export default createUseForgotPasswordHook;

package/dist/auth/hooks/useResetPasswordHookFactory.d.ts

@@ -0,0 +1,7 @@
+import { AuthContextType } from '../Auth.types';
+import { DefaultResetPasswordRequestData } from '../service';
+declare const createUseResetPasswordHook: <UserType>(AuthContext: AuthContextType<UserType>) => <PasswordResetRequestData = DefaultResetPasswordRequestData>() => {
+    resetPassword: (data: PasswordResetRequestData) => Promise<import("..").MakeUserWithAccessToken<UserType> | undefined>;
+    isLoading: boolean;
+};
+export default createUseResetPasswordHook;

package/dist/auth/hooks/useResetPasswordHookFactory.js

@@ -0,0 +1,29 @@
+import { useContext, useCallback } from 'react';
+import { resetPassword } from '../service/AuthService';
+const createUseResetPasswordHook = (AuthContext) => {
+    return () => {
+        const { axiosInstance, config, setAccessToken, setCurrentUser, addLoading, removeLoading } = useContext(AuthContext);
+        const loading = useContext(AuthContext).loading;
+        const isLoading = loading.includes('RESET_PASSWORD');
+        const resetPasswordCallback = useCallback(async (data) => {
+            try {
+                addLoading('RESET_PASSWORD');
+                const response = await resetPassword(axiosInstance, config, data);
+                setAccessToken(response.token);
+                setCurrentUser(response);
+                return response;
+            }
+            catch (e) {
+                return undefined;
+            }
+            finally {
+                removeLoading('RESET_PASSWORD');
+            }
+        }, [axiosInstance, config, setAccessToken, setCurrentUser, addLoading, removeLoading]);
+        return {
+            resetPassword: resetPasswordCallback,
+            isLoading,
+        };
+    };
+};
+export default createUseResetPasswordHook;

package/dist/auth/hooks/useSignInHookFactory.d.ts

@@ -0,0 +1,7 @@
+import { AuthContextType } from '../Auth.types';
+import { DefaultSignInRequestData } from '../service';
+declare const createUseSignInHook: <UserType>(AuthContext: AuthContextType<UserType>) => <SignInRequestData = DefaultSignInRequestData>() => {
+    signIn: (data: SignInRequestData, customApiUrl?: string) => Promise<import("..").MakeUserWithAccessToken<UserType> | undefined>;
+    isLoading: boolean;
+};
+export default createUseSignInHook;

package/dist/auth/hooks/useSignInHookFactory.js

@@ -0,0 +1,30 @@
+// src/auth/hooks/UseSignInHookFactory.tsx
+import { useContext, useCallback } from 'react';
+import { signIn } from '../service/AuthService';
+const createUseSignInHook = (AuthContext) => {
+    return () => {
+        const { axiosInstance, config, setAccessToken, setCurrentUser, addLoading, removeLoading } = useContext(AuthContext);
+        const loading = useContext(AuthContext).loading;
+        const isLoading = loading.includes('SIGN_IN');
+        const signInCallback = useCallback(async (data, customApiUrl) => {
+            try {
+                addLoading('SIGN_IN');
+                const response = await signIn(axiosInstance, config, data);
+                setAccessToken(response.token);
+                setCurrentUser(response);
+                return response;
+            }
+            catch (e) {
+                return undefined;
+            }
+            finally {
+                removeLoading('SIGN_IN');
+            }
+        }, [axiosInstance, config, setAccessToken, setCurrentUser, addLoading, removeLoading]);
+        return {
+            signIn: signInCallback,
+            isLoading,
+        };
+    };
+};
+export default createUseSignInHook;

package/dist/auth/hooks/useSignOutHookFactory.d.ts

@@ -0,0 +1,6 @@
+import { AuthContextType } from '../Auth.types';
+declare const createUseSignOutHook: <UserType>(AuthContext: AuthContextType<UserType>) => () => {
+    signOut: () => Promise<any>;
+    isLoading: boolean;
+};
+export default createUseSignOutHook;

package/dist/auth/hooks/useSignOutHookFactory.js

@@ -0,0 +1,30 @@
+// src/auth/hooks/UseSignOutHookFactory.tsx
+import { useContext, useCallback } from 'react';
+import { signOut } from '../service/AuthService';
+const createUseSignOutHook = (AuthContext) => {
+    return () => {
+        const { axiosInstance, config, destroyAccessToken, setCurrentUser, addLoading, removeLoading, } = useContext(AuthContext);
+        const loading = useContext(AuthContext).loading;
+        const isLoading = loading.includes('SIGN_OUT');
+        const signOutCallback = useCallback(async () => {
+            try {
+                addLoading('SIGN_OUT');
+                const response = await signOut(axiosInstance, config);
+                destroyAccessToken();
+                setCurrentUser(undefined);
+                return response;
+            }
+            catch (e) {
+                return undefined;
+            }
+            finally {
+                removeLoading('SIGN_OUT');
+            }
+        }, [axiosInstance, config, destroyAccessToken, setCurrentUser, addLoading, removeLoading]);
+        return {
+            signOut: signOutCallback,
+            isLoading,
+        };
+    };
+};
+export default createUseSignOutHook;

package/dist/auth/hooks/useSignUpHookFactory.d.ts

@@ -0,0 +1,7 @@
+import { AuthContextType } from '../Auth.types';
+import { DefaultSignUpRequestData } from '../service';
+declare const createUseSignUpHook: <UserType>(AuthContext: AuthContextType<UserType>) => <SignUpRequestData = DefaultSignUpRequestData>() => {
+    signUp: (data: SignUpRequestData) => Promise<import("..").MakeUserWithAccessToken<UserType> | undefined>;
+    isLoading: boolean;
+};
+export default createUseSignUpHook;

package/dist/auth/hooks/useSignUpHookFactory.js

@@ -0,0 +1,30 @@
+// src/auth/hooks/UseSignUpHookFactory.tsx
+import { useContext, useCallback } from 'react';
+import { signUp } from '../service/AuthService';
+const createUseSignUpHook = (AuthContext) => {
+    return () => {
+        const { axiosInstance, config, setAccessToken, setCurrentUser, addLoading, removeLoading } = useContext(AuthContext);
+        const loading = useContext(AuthContext).loading;
+        const isLoading = loading.includes('SIGN_UP');
+        const signUpCallback = useCallback(async (data) => {
+            try {
+                addLoading('SIGN_UP');
+                const response = await signUp(axiosInstance, config, data);
+                setAccessToken(response.token);
+                setCurrentUser(response);
+                return response;
+            }
+            catch (e) {
+                return undefined;
+            }
+            finally {
+                removeLoading('SIGN_UP');
+            }
+        }, [axiosInstance, config, setAccessToken, setCurrentUser, addLoading, removeLoading]);
+        return {
+            signUp: signUpCallback,
+            isLoading,
+        };
+    };
+};
+export default createUseSignUpHook;

package/dist/auth/index.d.ts

@@ -0,0 +1,53 @@
+declare const createAuthentication: <UserType extends unknown>() => {
+    AuthContextProvider: {
+        ({ children, config, axiosInstance, initialAccessToken, initialCurrentUser, }: import("./Auth.types").AuthProviderProps<UserType>): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    useCurrentUser: () => {
+        isLogged: boolean;
+        isReady: boolean;
+        user: UserType | undefined;
+        setUser: (value?: UserType | undefined) => void;
+        refetchCurrentUser: () => void;
+        setAccessToken: (value?: import("./types").AccessToken) => void;
+        isLoading: boolean;
+    };
+    useCurrentUserUpdate: <UpdateCurrentUserRequestData = import("./service/AuthService.types").DefaultUpdateCurrentUserRequestData>() => {
+        updateCurrentUser: (data: UpdateCurrentUserRequestData) => Promise<(UserType & {
+            token: import("./types").AccessToken;
+        }) | undefined>;
+        isLoading: boolean;
+    };
+    useCurrentUserUpdatePassword: <UpdateCurrentUserPasswordRequestData = import("./service/AuthService.types").DefaultUpdateCurrentUserPasswordRequestData>() => {
+        updateCurrentUserPassword: (data: UpdateCurrentUserPasswordRequestData) => Promise<import("./types").MakeUserWithAccessToken<UserType> | undefined>;
+        isLoading: boolean;
+    };
+    useSignIn: <SignInRequestData = import("./service/AuthService.types").DefaultSignInRequestData>() => {
+        signIn: (data: SignInRequestData, customApiUrl?: string) => Promise<import("./types").MakeUserWithAccessToken<UserType> | undefined>;
+        isLoading: boolean;
+    };
+    useSignOut: () => {
+        signOut: () => Promise<any>;
+        isLoading: boolean;
+    };
+    useSignUp: <SignUpRequestData = import("./service/AuthService.types").DefaultSignUpRequestData>() => {
+        signUp: (data: SignUpRequestData) => Promise<import("./types").MakeUserWithAccessToken<UserType> | undefined>;
+        isLoading: boolean;
+    };
+    useForgotPassword: <ForgotPasswordRequestData = import("./service/AuthService.types").DefaultForgotPasswordRequestData>() => {
+        forgotPassword: (data: ForgotPasswordRequestData) => Promise<any>;
+        isLoading: boolean;
+    };
+    useResetPassword: <PasswordResetRequestData = import("./service/AuthService.types").DefaultResetPasswordRequestData>() => {
+        resetPassword: (data: PasswordResetRequestData) => Promise<import("./types").MakeUserWithAccessToken<UserType> | undefined>;
+        isLoading: boolean;
+    };
+    Authenticated: {
+        ({ children, middleware }: import("./components/AuthenticatedFactory.types").AuthenticatedProps): import("react/jsx-runtime").JSX.Element | null;
+        displayName: string;
+    };
+};
+export default createAuthentication;
+export * from './service/AuthService.types';
+export * from './config/config.types';
+export * from './types';

package/dist/auth/index.js

@@ -0,0 +1,30 @@
+import createAuthContext from './context/AuthContextFactory';
+import createAuthContextProvider from './provider/AuthContextProviderFactory';
+import createUseCurrentUserHook from './hooks/useCurrentUserHookFactory';
+import createUseCurrentUserUpdateHook from './hooks/useCurrentUserUpdateHookFactory';
+import createUseCurrentUserUpdatePasswordHook from './hooks/useCurrentUserUpdatePasswordHookFactory';
+import createUseSignInHook from './hooks/useSignInHookFactory';
+import createUseSignOutHook from './hooks/useSignOutHookFactory';
+import createUseSignUpHook from './hooks/useSignUpHookFactory';
+import createUseForgotPasswordHook from './hooks/useForgotPasswordHookFactory';
+import createUseResetPasswordHook from './hooks/useResetPasswordHookFactory';
+import createAuthenticatedComponent from './components/AuthenticatedFactory';
+const createAuthentication = () => {
+    const AuthContext = createAuthContext();
+    return {
+        AuthContextProvider: createAuthContextProvider(AuthContext),
+        useCurrentUser: createUseCurrentUserHook(AuthContext),
+        useCurrentUserUpdate: createUseCurrentUserUpdateHook(AuthContext),
+        useCurrentUserUpdatePassword: createUseCurrentUserUpdatePasswordHook(AuthContext),
+        useSignIn: createUseSignInHook(AuthContext),
+        useSignOut: createUseSignOutHook(AuthContext),
+        useSignUp: createUseSignUpHook(AuthContext),
+        useForgotPassword: createUseForgotPasswordHook(AuthContext),
+        useResetPassword: createUseResetPasswordHook(AuthContext),
+        Authenticated: createAuthenticatedComponent(AuthContext),
+    };
+};
+export default createAuthentication;
+export * from './service/AuthService.types';
+export * from './config/config.types';
+export * from './types';

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

@@ -0,0 +1,6 @@
+import { AuthContextType, AuthProviderProps } from '../Auth.types';
+declare const createAuthContextProvider: <UserType extends unknown>(AuthContext: AuthContextType<UserType>) => {
+    ({ children, config, axiosInstance, initialAccessToken, initialCurrentUser, }: AuthProviderProps<UserType>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default createAuthContextProvider;

package/dist/auth/provider/AuthContextProviderFactory.js

@@ -0,0 +1,46 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useMemo, useState } from 'react';
+const createAuthContextProvider = (AuthContext) => {
+    const Provider = ({ children, config, axiosInstance, initialAccessToken, initialCurrentUser, }) => {
+        const [accessToken, setAccessToken] = useState(initialAccessToken);
+        const [currentUser, setCurrentUser] = useState(initialCurrentUser);
+        const [loading, setLoading] = useState([]);
+        const [isReady, setIsReady] = useState(false);
+        const addLoading = (value) => {
+            setLoading((prev) => [...prev, value]);
+        };
+        const removeLoading = (value) => {
+            setLoading((prev) => prev.filter((item) => item !== value));
+        };
+        const destroyAccessToken = () => {
+            setAccessToken(undefined);
+        };
+        const refetchCurrentUser = () => {
+            // Implementace by zde volala getCurrentUser
+        };
+        const isLogged = useMemo(() => !!accessToken && !!currentUser, [accessToken, currentUser]);
+        const authContextValue = useMemo(() => ({
+            config: config,
+            axiosInstance,
+            accessToken,
+            currentUser,
+            loading,
+            isLogged,
+            isReady,
+            setAccessToken,
+            setCurrentUser,
+            refetchCurrentUser,
+            addLoading,
+            removeLoading,
+            destroyAccessToken,
+        }), [accessToken, currentUser, loading, isLogged, isReady, axiosInstance]);
+        useEffect(() => {
+            setIsReady(true);
+        }, []);
+        return _jsx(AuthContext.Provider, { value: authContextValue, children: children });
+    };
+    Provider.displayName = 'AuthContextProvider';
+    return Provider;
+};
+export default createAuthContextProvider;

package/dist/auth/service/AuthService.d.ts

@@ -0,0 +1,15 @@
+import { AuthenticationSettings } from '../config/config.types';
+import { AxiosInstance } from 'axios';
+import { DefaultForgotPasswordRequestData, DefaultResetPasswordRequestData, DefaultSignInRequestData, DefaultSignUpRequestData, DefaultUpdateCurrentUserPasswordRequestData, DefaultUpdateCurrentUserRequestData } from './AuthService.types';
+import { MakeUserWithAccessToken } from '../types';
+export declare const signIn: <UserType, SignInRequest = DefaultSignInRequestData>(axios: AxiosInstance, config: AuthenticationSettings, requestData: SignInRequest) => Promise<MakeUserWithAccessToken<UserType>>;
+export declare const signOut: (axios: AxiosInstance, config: AuthenticationSettings) => Promise<any>;
+export declare const signUp: <UserType, SignUpRequest = DefaultSignUpRequestData>(axios: AxiosInstance, config: AuthenticationSettings, requestData: SignUpRequest) => Promise<MakeUserWithAccessToken<UserType>>;
+export declare const forgotPassword: <ForgotPasswordRequest = DefaultForgotPasswordRequestData>(axios: AxiosInstance, config: AuthenticationSettings, requestData: ForgotPasswordRequest) => Promise<any>;
+export declare const resetPassword: <UserType, ResetPasswordRequest = DefaultResetPasswordRequestData>(axios: AxiosInstance, config: AuthenticationSettings, requestData: ResetPasswordRequest) => Promise<MakeUserWithAccessToken<UserType>>;
+export declare const getCurrentUser: <UserType>(axios: AxiosInstance, config: AuthenticationSettings) => Promise<UserType>;
+export declare const updateCurrentUser: <UserType, UpdateCurrentUserRequest = DefaultUpdateCurrentUserRequestData>(axios: AxiosInstance, config: AuthenticationSettings, requestData: UpdateCurrentUserRequest) => Promise<UserType & {
+    token: import("../types").AccessToken;
+}>;
+export declare const updateCurrentUserPassword: <UpdateCurrentUserPasswordRequest = DefaultUpdateCurrentUserPasswordRequestData, User = {}>(axios: AxiosInstance, config: AuthenticationSettings, requestData: UpdateCurrentUserPasswordRequest) => Promise<MakeUserWithAccessToken<User>>;
+export declare const updateCurrentUserAvatar: <UserType>(axios: AxiosInstance, config: AuthenticationSettings, requestFile?: File) => Promise<UserType>;