@q2devel/q2-storybook 1.0.13 → 1.0.15

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

package/dist/auth/components/AuthenticatedFactory.js

@@ -0,0 +1,21 @@
+// src/auth/components/AuthenticatedFactory.tsx
+import React, { useContext } from 'react';
+var createAuthenticatedComponent = function (AuthContext) {
+    var Authenticated = function (_a) {
+        var children = _a.children, middleware = _a.middleware;
+        var _b = useContext(AuthContext), isLogged = _b.isLogged, isReady = _b.isReady;
+        if (!isReady) {
+            return null;
+        }
+        if (middleware === 'only-logged' && !isLogged) {
+            return null;
+        }
+        if (middleware === 'only-guest' && isLogged) {
+            return null;
+        }
+        return React.createElement(React.Fragment, null, 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
+var config = {
+    tokenStorageType: 'localStorage',
+    tokenStorageKey: 'auth-token',
+    logoutWhenFailedLoadUser: true,
+    getDataFromRequest: function (data) { return data.data; },
+    getTokenFromRequest: function (data) { return 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,4 @@
+import React from 'react';
+import { AuthContextState } from '../Auth.types';
+declare const createAuthContext: <UserType>() => React.Context<AuthContextState<UserType>>;
+export default createAuthContext;

package/dist/auth/context/AuthContextFactory.js

@@ -0,0 +1,19 @@
+// src/auth/context/AuthContextFactory.tsx
+import { createContext } from 'react';
+var createAuthContext = function () {
+    var defaultState = {
+        config: {},
+        axiosInstance: {},
+        loading: [],
+        isLogged: false,
+        isReady: false,
+        setAccessToken: function () { },
+        setCurrentUser: function () { },
+        refetchCurrentUser: function () { },
+        addLoading: function () { },
+        removeLoading: function () { },
+        destroyAccessToken: function () { },
+    };
+    return createContext(defaultState);
+};
+export default createAuthContext;

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

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

package/dist/auth/hooks/useCurrentUserHookFactory.js

@@ -0,0 +1,18 @@
+// src/auth/hooks/UseCurrentUserHookFactory.tsx
+import { useContext } from 'react';
+var createUseCurrentUserHook = function (AuthContext) {
+    return function () {
+        var _a = useContext(AuthContext), currentUser = _a.currentUser, setCurrentUser = _a.setCurrentUser, refetchCurrentUser = _a.refetchCurrentUser, setAccessToken = _a.setAccessToken, loading = _a.loading, isLogged = _a.isLogged, isReady = _a.isReady;
+        var isLoading = loading.includes('CURRENT_USER');
+        return {
+            isLogged: isLogged,
+            isReady: isReady,
+            user: currentUser,
+            setUser: setCurrentUser,
+            refetchCurrentUser: refetchCurrentUser,
+            setAccessToken: setAccessToken,
+            isLoading: 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,73 @@
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+// src/auth/hooks/UseCurrentUserUpdateHookFactory.tsx
+import { useContext, useCallback } from 'react';
+import { updateCurrentUser } from '../service/AuthService';
+var createUseCurrentUserUpdateHook = function (AuthContext) {
+    return function () {
+        var _a = useContext(AuthContext), axiosInstance = _a.axiosInstance, config = _a.config, addLoading = _a.addLoading, removeLoading = _a.removeLoading, setCurrentUser = _a.setCurrentUser;
+        var loading = useContext(AuthContext).loading;
+        var isLoading = loading.includes('UPDATE_CURRENT_USER');
+        var updateCallback = useCallback(function (data) { return __awaiter(void 0, void 0, void 0, function () {
+            var response, e_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, 3, 4]);
+                        addLoading('UPDATE_CURRENT_USER');
+                        return [4 /*yield*/, updateCurrentUser(axiosInstance, config, data)];
+                    case 1:
+                        response = _a.sent();
+                        setCurrentUser(response);
+                        return [2 /*return*/, response];
+                    case 2:
+                        e_1 = _a.sent();
+                        return [2 /*return*/, undefined];
+                    case 3:
+                        removeLoading('UPDATE_CURRENT_USER');
+                        return [7 /*endfinally*/];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); }, [axiosInstance, config, addLoading, removeLoading, setCurrentUser]);
+        return {
+            updateCurrentUser: updateCallback,
+            isLoading: 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,76 @@
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+// src/auth/hooks/UseCurrentUserUpdatePasswordHookFactory.tsx
+import { useContext, useCallback } from 'react';
+import { updateCurrentUserPassword } from '../service/AuthService';
+var createUseCurrentUserUpdatePasswordHook = function (AuthContext) {
+    return function () {
+        var _a = useContext(AuthContext), axiosInstance = _a.axiosInstance, config = _a.config, addLoading = _a.addLoading, removeLoading = _a.removeLoading, setAccessToken = _a.setAccessToken, setCurrentUser = _a.setCurrentUser;
+        var loading = useContext(AuthContext).loading;
+        var isLoading = loading.includes('UPDATE_CURRENT_USER_PASSWORD');
+        var updatePasswordCallback = useCallback(function (data) { return __awaiter(void 0, void 0, void 0, function () {
+            var response, e_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, 3, 4]);
+                        addLoading('UPDATE_CURRENT_USER_PASSWORD');
+                        return [4 /*yield*/, updateCurrentUserPassword(axiosInstance, config, data)];
+                    case 1:
+                        response = _a.sent();
+                        if (response.token) {
+                            setAccessToken(response.token);
+                        }
+                        setCurrentUser(response);
+                        return [2 /*return*/, response];
+                    case 2:
+                        e_1 = _a.sent();
+                        return [2 /*return*/, undefined];
+                    case 3:
+                        removeLoading('UPDATE_CURRENT_USER_PASSWORD');
+                        return [7 /*endfinally*/];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); }, [axiosInstance, config, addLoading, removeLoading, setAccessToken, setCurrentUser]);
+        return {
+            updateCurrentUserPassword: updatePasswordCallback,
+            isLoading: 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,70 @@
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+// src/auth/hooks/UseForgotPasswordHookFactory.tsx
+import { useContext, useCallback } from 'react';
+import { forgotPassword } from '../service/AuthService';
+var createUseForgotPasswordHook = function (AuthContext) {
+    return function () {
+        var _a = useContext(AuthContext), axiosInstance = _a.axiosInstance, config = _a.config, addLoading = _a.addLoading, removeLoading = _a.removeLoading;
+        var loading = useContext(AuthContext).loading;
+        var isLoading = loading.includes('FORGOT_PASSWORD');
+        var forgotPasswordCallback = useCallback(function (data) { return __awaiter(void 0, void 0, void 0, function () {
+            var e_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, 3, 4]);
+                        addLoading('FORGOT_PASSWORD');
+                        return [4 /*yield*/, forgotPassword(axiosInstance, config, data)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2:
+                        e_1 = _a.sent();
+                        return [2 /*return*/, undefined];
+                    case 3:
+                        removeLoading('FORGOT_PASSWORD');
+                        return [7 /*endfinally*/];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); }, [axiosInstance, config, addLoading, removeLoading]);
+        return {
+            forgotPassword: forgotPasswordCallback,
+            isLoading: 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,74 @@
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+// src/auth/hooks/UseResetPasswordHookFactory.tsx
+import { useContext, useCallback } from 'react';
+import { resetPassword } from '../service/AuthService';
+var createUseResetPasswordHook = function (AuthContext) {
+    return function () {
+        var _a = useContext(AuthContext), axiosInstance = _a.axiosInstance, config = _a.config, setAccessToken = _a.setAccessToken, setCurrentUser = _a.setCurrentUser, addLoading = _a.addLoading, removeLoading = _a.removeLoading;
+        var loading = useContext(AuthContext).loading;
+        var isLoading = loading.includes('RESET_PASSWORD');
+        var resetPasswordCallback = useCallback(function (data) { return __awaiter(void 0, void 0, void 0, function () {
+            var response, e_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, 3, 4]);
+                        addLoading('RESET_PASSWORD');
+                        return [4 /*yield*/, resetPassword(axiosInstance, config, data)];
+                    case 1:
+                        response = _a.sent();
+                        setAccessToken(response.token);
+                        setCurrentUser(response);
+                        return [2 /*return*/, response];
+                    case 2:
+                        e_1 = _a.sent();
+                        return [2 /*return*/, undefined];
+                    case 3:
+                        removeLoading('RESET_PASSWORD');
+                        return [7 /*endfinally*/];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); }, [axiosInstance, config, setAccessToken, setCurrentUser, addLoading, removeLoading]);
+        return {
+            resetPassword: resetPasswordCallback,
+            isLoading: 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,74 @@
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+// src/auth/hooks/UseSignInHookFactory.tsx
+import { useContext, useCallback } from 'react';
+import { signIn } from '../service/AuthService';
+var createUseSignInHook = function (AuthContext) {
+    return function () {
+        var _a = useContext(AuthContext), axiosInstance = _a.axiosInstance, config = _a.config, setAccessToken = _a.setAccessToken, setCurrentUser = _a.setCurrentUser, addLoading = _a.addLoading, removeLoading = _a.removeLoading;
+        var loading = useContext(AuthContext).loading;
+        var isLoading = loading.includes('SIGN_IN');
+        var signInCallback = useCallback(function (data, customApiUrl) { return __awaiter(void 0, void 0, void 0, function () {
+            var response, e_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, 3, 4]);
+                        addLoading('SIGN_IN');
+                        return [4 /*yield*/, signIn(axiosInstance, config, data)];
+                    case 1:
+                        response = _a.sent();
+                        setAccessToken(response.token);
+                        setCurrentUser(response);
+                        return [2 /*return*/, response];
+                    case 2:
+                        e_1 = _a.sent();
+                        return [2 /*return*/, undefined];
+                    case 3:
+                        removeLoading('SIGN_IN');
+                        return [7 /*endfinally*/];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); }, [axiosInstance, config, setAccessToken, setCurrentUser, addLoading, removeLoading]);
+        return {
+            signIn: signInCallback,
+            isLoading: 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;