@q2devel/q2-storybook 1.0.159 → 1.0.162

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

@@ -1,9 +1,9 @@
-import { AxiosInstance } from 'axios';
-import { Context, PropsWithChildren } from 'react';
-import { AccessToken, DeepNonRequired } from './types';
-import { AuthenticationSettings } from './config/config.types';
+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 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;

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

@@ -1,5 +1,5 @@
-import { AuthContextType } from '../Auth.types';
-import { AuthenticatedProps } from './AuthenticatedFactory.types';
+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;

package/dist/auth/components/AuthenticatedFactory.js

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

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

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

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

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

package/dist/auth/config/Config.js

@@ -1,19 +1,19 @@
 // Defaultní konfigurace
 const config = {
-    tokenStorageType: 'localStorage',
-    tokenStorageKey: 'auth-token',
+    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',
+    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

@@ -1,6 +1,6 @@
-import { AccessToken, TokenStorageProvider } from '../types';
-export type TokenStorageType = 'localStorage' | 'cookie' | 'memory';
-export type RequestDataType = 'json' | 'form-data';
+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;

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

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

package/dist/auth/context/AuthContextFactory.js

@@ -1,5 +1,5 @@
-'use client';
-import { createContext } from 'react';
+"use client";
+import { createContext } from "react";
 const createAuthContext = () => {
     const defaultState = {
         config: {},

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

@@ -1,4 +1,4 @@
-import { AuthContextType } from '../Auth.types';
+import { AuthContextType } from "../Auth.types";
 declare const createUseCurrentUserHook: <UserType>(AuthContext: AuthContextType<UserType>) => () => {
     isLogged: boolean;
     isReady: boolean;

package/dist/auth/hooks/useCurrentUserHookFactory.js

@@ -1,8 +1,8 @@
-import { useContext } from 'react';
+import { useContext } from "react";
 const createUseCurrentUserHook = (AuthContext) => {
     return () => {
         const { currentUser, setCurrentUser, refetchCurrentUser, setAccessToken, loading, isLogged, isReady, } = useContext(AuthContext);
-        const isLoading = loading.includes('CURRENT_USER');
+        const isLoading = loading.includes("CURRENT_USER");
         return {
             isLogged,
             isReady,

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

@@ -1,5 +1,5 @@
-import { AuthContextType } from '../Auth.types';
-import { DefaultUpdateCurrentUserRequestData } from '../service';
+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;

package/dist/auth/hooks/useCurrentUserUpdateHookFactory.js

@@ -1,13 +1,13 @@
-import { useContext, useCallback } from 'react';
-import { updateCurrentUser } from '../service/AuthService';
+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 isLoading = loading.includes("UPDATE_CURRENT_USER");
         const updateCallback = useCallback(async (data) => {
             try {
-                addLoading('UPDATE_CURRENT_USER');
+                addLoading("UPDATE_CURRENT_USER");
                 const response = await updateCurrentUser(axiosInstance, config, data);
                 setCurrentUser(response);
                 return response;
@@ -16,7 +16,7 @@ const createUseCurrentUserUpdateHook = (AuthContext) => {
                 return undefined;
             }
             finally {
-                removeLoading('UPDATE_CURRENT_USER');
+                removeLoading("UPDATE_CURRENT_USER");
             }
         }, [axiosInstance, config, addLoading, removeLoading, setCurrentUser]);
         return {

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

@@ -1,5 +1,5 @@
-import { AuthContextType } from '../Auth.types';
-import { DefaultUpdateCurrentUserPasswordRequestData } from '../service';
+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;

package/dist/auth/hooks/useCurrentUserUpdatePasswordHookFactory.js

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

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

@@ -1,5 +1,5 @@
-import { AuthContextType } from '../Auth.types';
-import { DefaultForgotPasswordRequestData } from '../service';
+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;

package/dist/auth/hooks/useForgotPasswordHookFactory.js

@@ -1,20 +1,20 @@
-import { useContext, useCallback } from 'react';
-import { forgotPassword } from '../service/AuthService';
+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 isLoading = loading.includes("FORGOT_PASSWORD");
         const forgotPasswordCallback = useCallback(async (data) => {
             try {
-                addLoading('FORGOT_PASSWORD');
+                addLoading("FORGOT_PASSWORD");
                 return await forgotPassword(axiosInstance, config, data);
             }
             catch (e) {
                 return undefined;
             }
             finally {
-                removeLoading('FORGOT_PASSWORD');
+                removeLoading("FORGOT_PASSWORD");
             }
         }, [axiosInstance, config, addLoading, removeLoading]);
         return {

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

@@ -1,5 +1,5 @@
-import { AuthContextType } from '../Auth.types';
-import { DefaultResetPasswordRequestData } from '../service';
+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;

package/dist/auth/hooks/useResetPasswordHookFactory.js

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

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

@@ -1,5 +1,5 @@
-import { AuthContextType } from '../Auth.types';
-import { DefaultSignInRequestData } from '../service';
+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;

package/dist/auth/hooks/useSignInHookFactory.js

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

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

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

package/dist/auth/hooks/useSignOutHookFactory.js

@@ -1,14 +1,14 @@
 // src/auth/hooks/UseSignOutHookFactory.tsx
-import { useContext, useCallback } from 'react';
-import { signOut } from '../service/AuthService';
+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 isLoading = loading.includes("SIGN_OUT");
         const signOutCallback = useCallback(async () => {
             try {
-                addLoading('SIGN_OUT');
+                addLoading("SIGN_OUT");
                 const response = await signOut(axiosInstance, config);
                 destroyAccessToken();
                 setCurrentUser(undefined);
@@ -18,9 +18,16 @@ const createUseSignOutHook = (AuthContext) => {
                 return undefined;
             }
             finally {
-                removeLoading('SIGN_OUT');
+                removeLoading("SIGN_OUT");
             }
-        }, [axiosInstance, config, destroyAccessToken, setCurrentUser, addLoading, removeLoading]);
+        }, [
+            axiosInstance,
+            config,
+            destroyAccessToken,
+            setCurrentUser,
+            addLoading,
+            removeLoading,
+        ]);
         return {
             signOut: signOutCallback,
             isLoading,

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

@@ -1,5 +1,5 @@
-import { AuthContextType } from '../Auth.types';
-import { DefaultSignUpRequestData } from '../service';
+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;

package/dist/auth/hooks/useSignUpHookFactory.js

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

package/dist/auth/index.d.ts

@@ -48,6 +48,6 @@ declare const createAuthentication: <UserType extends unknown>() => {
     };
 };
 export default createAuthentication;
-export * from './service/AuthService.types';
-export * from './config/config.types';
-export * from './types';
+export * from "./service/AuthService.types";
+export * from "./config/config.types";
+export * from "./types";

package/dist/auth/index.js

@@ -1,14 +1,14 @@
-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';
+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 {
@@ -25,6 +25,6 @@ const createAuthentication = () => {
     };
 };
 export default createAuthentication;
-export * from './service/AuthService.types';
-export * from './config/config.types';
-export * from './types';
+export * from "./service/AuthService.types";
+export * from "./config/config.types";
+export * from "./types";

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

@@ -1,4 +1,4 @@
-import { AuthContextType, AuthProviderProps } from '../Auth.types';
+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;

package/dist/auth/provider/AuthContextProviderFactory.js

@@ -1,6 +1,6 @@
-'use client';
+"use client";
 import { jsx as _jsx } from "react/jsx-runtime";
-import { useEffect, useMemo, useState } from 'react';
+import { useEffect, useMemo, useState } from "react";
 const createAuthContextProvider = (AuthContext) => {
     const Provider = ({ children, config, axiosInstance, initialAccessToken, initialCurrentUser, }) => {
         const [accessToken, setAccessToken] = useState(initialAccessToken);
@@ -38,9 +38,9 @@ const createAuthContextProvider = (AuthContext) => {
         useEffect(() => {
             setIsReady(true);
         }, []);
-        return _jsx(AuthContext.Provider, { value: authContextValue, children: children });
+        return (_jsx(AuthContext.Provider, { value: authContextValue, children: children }));
     };
-    Provider.displayName = 'AuthContextProvider';
+    Provider.displayName = "AuthContextProvider";
     return Provider;
 };
 export default createAuthContextProvider;

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

@@ -1,7 +1,7 @@
-import { AuthenticationSettings } from '../config/config.types';
-import { AxiosInstance } from 'axios';
-import { DefaultForgotPasswordRequestData, DefaultResetPasswordRequestData, DefaultSignInRequestData, DefaultSignUpRequestData, DefaultUpdateCurrentUserPasswordRequestData, DefaultUpdateCurrentUserRequestData } from './AuthService.types';
-import { MakeUserWithAccessToken } from '../types';
+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>>;