react-redux-django-auth 1.4.5 → 1.4.7

package/README.md

@@ -603,3 +603,96 @@ const DashboardLayout = () => {
   );
 };
 ```
+## React Native Usage
+#### Setting Auth Provider
+
+```
+import { Slot } from "expo-router";
+import AuthProviderNative from "./auth/AuthProviderNative";
+
+export default function RootLayout() {
+  // Replace with your actual backend URL
+  const API_URL = "https://api.yourdomain.com/v1";
+
+  return (
+    <AuthProviderNative apiUrl={API_URL}>
+      <Slot />
+    </AuthProviderNative>
+  );
+}
+```
+
+#### useBiometric hook
+```
+import React, { useEffect } from "react";
+import { View, ActivityIndicator, Text } from "react-native";
+import { useAuthicatedUser } from "../hooks/useAuthicatedUser";
+import useBiometricAuth from "../hooks/useBiometricAuth";
+import { storage } from "../auth-core/storage";
+import { API_URL } from "../config";
+import { useNavigation } from "@react-navigation/native";
+
+const SplashScreen = () => {
+  const navigation = useNavigation();
+
+  const { isAuthenticated, currentUser, isLoading, refreshAuth } =
+    useAuthicatedUser(API_URL, null, storage);
+
+  const { authenticate, loading: bioLoading } = useBiometricAuth({
+    storage,
+    apiUrl: API_URL,
+  });
+
+  useEffect(() => {
+    const initAuth = async () => {
+      try {
+        // 1️⃣ Attempt biometric login if not already authenticated
+        if (!isAuthenticated) {
+          await authenticate(); // this will handle refresh token internally
+          await refreshAuth(); // re-check auth + load user into redux
+        }
+
+        // 2️⃣ Navigate based on user role
+        if (currentUser) {
+          switch (currentUser.role) {
+            case "admin":
+            case "superadmin":
+              navigation.reset({ index: 0, routes: [{ name: "AdminHome" }] });
+              break;
+            case "vendor":
+              navigation.reset({ index: 0, routes: [{ name: "VendorDashboard" }] });
+              break;
+            case "customer":
+              navigation.reset({ index: 0, routes: [{ name: "CustomerMain" }] });
+              break;
+            default:
+              navigation.reset({ index: 0, routes: [{ name: "Login" }] });
+          }
+        } else {
+          navigation.reset({ index: 0, routes: [{ name: "Login" }] });
+        }
+      } catch (err) {
+        console.log("Biometric/Auth failed:", err);
+        navigation.reset({ index: 0, routes: [{ name: "Login" }] });
+      }
+    };
+
+    initAuth();
+  }, [isAuthenticated, currentUser]);
+
+  // Show loading while checking authentication
+  if (isLoading || bioLoading) {
+    return (
+      <View style={{ flex: 1, justifyContent: "center", alignItems: "center" }}>
+        <ActivityIndicator size="large" />
+        <Text>Loading...</Text>
+      </View>
+    );
+  }
+
+  return null; // navigation will replace this
+};
+
+export default SplashScreen;
+
+```

package/dist/auth-core/actions/authActions.d.ts

@@ -0,0 +1,57 @@
+import { Dispatch } from 'redux';
+import { AuthStorage } from './types';
+export type AppDispatch = Dispatch<any>;
+/**
+ * Load Authenticated User
+ */
+export declare const load_user: (storage: AuthStorage) => (dispatch: AppDispatch) => Promise<{
+    type: string;
+} | undefined>;
+/**
+ * Facebook Auth
+ */
+export declare const facebookAuthenticate: (state: any, code: any, storage: AuthStorage) => (dispatch: AppDispatch) => Promise<void>;
+/**
+ * Check Authentication
+ */
+export declare const checkAuthenticated: (storage: AuthStorage) => (dispatch: AppDispatch) => Promise<{
+    type: string;
+} | undefined>;
+/**
+ * Login
+ */
+export declare const login: (formData: any, storage: AuthStorage) => (dispatch: AppDispatch) => Promise<void>;
+/**
+ * Signup
+ */
+export declare const signup: (formData: any) => (dispatch: AppDispatch) => Promise<void>;
+/**
+ * Verify Account
+ */
+export declare const verify: (uid: any, token: any) => (dispatch: AppDispatch) => Promise<void>;
+/**
+ * Reset Password
+ */
+export declare const reset_password: (email: string) => (dispatch: AppDispatch) => Promise<void>;
+/**
+ * Confirm Password Reset
+ */
+export declare const reset_password_confirm: (formData: any) => (dispatch: AppDispatch) => Promise<void>;
+/**
+ * Logout
+ */
+export declare const logout: (storage: AuthStorage) => (dispatch: AppDispatch) => Promise<void>;
+/**
+ * Clear Errors
+ */
+export declare const clearErrors: () => (dispatch: AppDispatch) => void;
+/**
+ * Change Password (Authenticated)
+ */
+export declare const changeLoggedInUserPassword: (formData: any, storage: AuthStorage) => (dispatch: AppDispatch) => Promise<{
+    type: string;
+} | undefined>;
+/**
+ * 🔄 Refresh Access Token
+ */
+export declare const refreshAccessToken: (storage: AuthStorage) => (dispatch: AppDispatch) => Promise<any>;

package/dist/auth-core/actions/authActions.js

@@ -0,0 +1,451 @@
+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 };
+    }
+};
+import axios from 'axios';
+import { LOGIN_SUCCESS, LOGIN_FAIL, USER_LOADED_SUCCESS, USER_LOADED_FAIL, AUTHENTICATED_SUCCESS, AUTHENTICATED_FAIL, PASSWORD_RESET_SUCCESS, PASSWORD_RESET_FAIL, PASSWORD_RESET_CONFIRM_SUCCESS, PASSWORD_RESET_CONFIRM_FAIL, SIGNUP_SUCCESS, SIGNUP_FAIL, ACTIVATION_SUCCESS, ACTIVATION_FAIL, FACEBOOK_AUTH_SUCCESS, FACEBOOK_AUTH_FAIL, LOGOUT, CLEAR_ERRORS } from './types';
+import { getBaseURL } from '../apis/config';
+/**
+ * 🔥 Helper: Get Auth Header
+ */
+var getAuthConfig = function (storage) { return __awaiter(void 0, void 0, void 0, function () {
+    var token;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, storage.getAccessToken()];
+            case 1:
+                token = _a.sent();
+                if (!token)
+                    return [2 /*return*/, null];
+                return [2 /*return*/, {
+                        headers: {
+                            Authorization: "JWT ".concat(token),
+                            'Content-Type': 'application/json'
+                        }
+                    }];
+        }
+    });
+}); };
+/**
+ * Load Authenticated User
+ */
+export var load_user = function (storage) {
+    return function (dispatch) { return __awaiter(void 0, void 0, void 0, function () {
+        var config, res, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, getAuthConfig(storage)];
+                case 1:
+                    config = _b.sent();
+                    if (!config) {
+                        return [2 /*return*/, dispatch({ type: USER_LOADED_FAIL })];
+                    }
+                    _b.label = 2;
+                case 2:
+                    _b.trys.push([2, 4, , 5]);
+                    return [4 /*yield*/, axios.get("".concat(getBaseURL(), "/auth/users/me/"), config)];
+                case 3:
+                    res = _b.sent();
+                    dispatch({
+                        type: USER_LOADED_SUCCESS,
+                        payload: res.data
+                    });
+                    return [3 /*break*/, 5];
+                case 4:
+                    _a = _b.sent();
+                    dispatch({ type: USER_LOADED_FAIL });
+                    return [3 /*break*/, 5];
+                case 5: return [2 /*return*/];
+            }
+        });
+    }); };
+};
+/**
+ * Facebook Auth
+ */
+export var facebookAuthenticate = function (state, code, storage) { return function (dispatch) { return __awaiter(void 0, void 0, void 0, function () {
+    var token, res, _a, access, refresh, err_1;
+    var _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0: return [4 /*yield*/, storage.getAccessToken()];
+            case 1:
+                token = _c.sent();
+                if (!(state && code && !token)) return [3 /*break*/, 6];
+                _c.label = 2;
+            case 2:
+                _c.trys.push([2, 5, , 6]);
+                return [4 /*yield*/, axios.post("".concat(getBaseURL(), "/auth/o/facebook/?state=").concat(state, "&code=").concat(code), {}, {
+                        headers: {
+                            'Content-Type': 'application/x-www-form-urlencoded'
+                        }
+                    })];
+            case 3:
+                res = _c.sent();
+                _a = res.data, access = _a.access, refresh = _a.refresh;
+                return [4 /*yield*/, storage.setTokens(access, refresh)];
+            case 4:
+                _c.sent();
+                dispatch({
+                    type: FACEBOOK_AUTH_SUCCESS,
+                    payload: res.data
+                });
+                dispatch(load_user(storage));
+                return [3 /*break*/, 6];
+            case 5:
+                err_1 = _c.sent();
+                dispatch({
+                    type: FACEBOOK_AUTH_FAIL,
+                    payload: (_b = err_1 === null || err_1 === void 0 ? void 0 : err_1.response) === null || _b === void 0 ? void 0 : _b.data
+                });
+                return [3 /*break*/, 6];
+            case 6: return [2 /*return*/];
+        }
+    });
+}); }; };
+/**
+ * Check Authentication
+ */
+export var checkAuthenticated = function (storage) {
+    return function (dispatch) { return __awaiter(void 0, void 0, void 0, function () {
+        var token, res, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, storage.getAccessToken()];
+                case 1:
+                    token = _b.sent();
+                    if (!token) {
+                        return [2 /*return*/, dispatch({ type: AUTHENTICATED_FAIL })];
+                    }
+                    _b.label = 2;
+                case 2:
+                    _b.trys.push([2, 4, , 5]);
+                    return [4 /*yield*/, axios.post("".concat(getBaseURL(), "/auth/jwt/verify/"), { token: token })];
+                case 3:
+                    res = _b.sent();
+                    dispatch({
+                        type: res.data.code !== 'token_not_valid'
+                            ? AUTHENTICATED_SUCCESS
+                            : AUTHENTICATED_FAIL
+                    });
+                    return [3 /*break*/, 5];
+                case 4:
+                    _a = _b.sent();
+                    dispatch({ type: AUTHENTICATED_FAIL });
+                    return [3 /*break*/, 5];
+                case 5: return [2 /*return*/];
+            }
+        });
+    }); };
+};
+/**
+ * Login
+ */
+export var login = function (formData, storage) { return function (dispatch) { return __awaiter(void 0, void 0, void 0, function () {
+    var res, _a, access, refresh, err_2;
+    var _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _c.trys.push([0, 3, , 4]);
+                return [4 /*yield*/, axios.post("".concat(getBaseURL(), "/auth/jwt/create/"), formData)];
+            case 1:
+                res = _c.sent();
+                _a = res.data, access = _a.access, refresh = _a.refresh;
+                return [4 /*yield*/, storage.setTokens(access, refresh)];
+            case 2:
+                _c.sent();
+                dispatch({
+                    type: LOGIN_SUCCESS,
+                    payload: {
+                        access: access,
+                        refresh: refresh,
+                        status: res.status
+                    }
+                });
+                dispatch(load_user(storage));
+                return [3 /*break*/, 4];
+            case 3:
+                err_2 = _c.sent();
+                dispatch({
+                    type: LOGIN_FAIL,
+                    payload: (_b = err_2 === null || err_2 === void 0 ? void 0 : err_2.response) === null || _b === void 0 ? void 0 : _b.data
+                });
+                return [3 /*break*/, 4];
+            case 4: return [2 /*return*/];
+        }
+    });
+}); }; };
+/**
+ * Signup
+ */
+export var signup = function (formData) {
+    return function (dispatch) { return __awaiter(void 0, void 0, void 0, function () {
+        var res, err_3;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, axios.post("".concat(getBaseURL(), "/auth/users/"), formData, {
+                            headers: {
+                                'Content-Type': 'application/json'
+                            }
+                        })];
+                case 1:
+                    res = _b.sent();
+                    dispatch({
+                        type: SIGNUP_SUCCESS,
+                        payload: res.status
+                    });
+                    return [3 /*break*/, 3];
+                case 2:
+                    err_3 = _b.sent();
+                    dispatch({
+                        type: SIGNUP_FAIL,
+                        payload: (_a = err_3 === null || err_3 === void 0 ? void 0 : err_3.response) === null || _a === void 0 ? void 0 : _a.data
+                    });
+                    return [3 /*break*/, 3];
+                case 3: return [2 /*return*/];
+            }
+        });
+    }); };
+};
+/**
+ * Verify Account
+ */
+export var verify = function (uid, token) {
+    return function (dispatch) { return __awaiter(void 0, void 0, void 0, function () {
+        var res, err_4;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, axios.post("".concat(getBaseURL(), "/auth/users/activation/"), { uid: uid, token: token })];
+                case 1:
+                    res = _b.sent();
+                    dispatch({
+                        type: ACTIVATION_SUCCESS,
+                        payload: res.status
+                    });
+                    return [3 /*break*/, 3];
+                case 2:
+                    err_4 = _b.sent();
+                    dispatch({
+                        type: ACTIVATION_FAIL,
+                        payload: (_a = err_4 === null || err_4 === void 0 ? void 0 : err_4.response) === null || _a === void 0 ? void 0 : _a.data
+                    });
+                    return [3 /*break*/, 3];
+                case 3: return [2 /*return*/];
+            }
+        });
+    }); };
+};
+/**
+ * Reset Password
+ */
+export var reset_password = function (email) {
+    return function (dispatch) { return __awaiter(void 0, void 0, void 0, function () {
+        var res, err_5;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, axios.post("".concat(getBaseURL(), "/auth/users/reset_password/"), { email: email })];
+                case 1:
+                    res = _b.sent();
+                    dispatch({
+                        type: PASSWORD_RESET_SUCCESS,
+                        payload: res.status
+                    });
+                    return [3 /*break*/, 3];
+                case 2:
+                    err_5 = _b.sent();
+                    dispatch({
+                        type: PASSWORD_RESET_FAIL,
+                        payload: (_a = err_5 === null || err_5 === void 0 ? void 0 : err_5.response) === null || _a === void 0 ? void 0 : _a.data
+                    });
+                    return [3 /*break*/, 3];
+                case 3: return [2 /*return*/];
+            }
+        });
+    }); };
+};
+/**
+ * Confirm Password Reset
+ */
+export var reset_password_confirm = function (formData) {
+    return function (dispatch) { return __awaiter(void 0, void 0, void 0, function () {
+        var res, err_6;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, axios.post("".concat(getBaseURL(), "/auth/users/reset_password_confirm/"), formData)];
+                case 1:
+                    res = _b.sent();
+                    dispatch({
+                        type: PASSWORD_RESET_CONFIRM_SUCCESS,
+                        payload: res.status
+                    });
+                    return [3 /*break*/, 3];
+                case 2:
+                    err_6 = _b.sent();
+                    dispatch({
+                        type: PASSWORD_RESET_CONFIRM_FAIL,
+                        payload: (_a = err_6 === null || err_6 === void 0 ? void 0 : err_6.response) === null || _a === void 0 ? void 0 : _a.data
+                    });
+                    return [3 /*break*/, 3];
+                case 3: return [2 /*return*/];
+            }
+        });
+    }); };
+};
+/**
+ * Logout
+ */
+export var logout = function (storage) {
+    return function (dispatch) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, storage.clearTokens()];
+                case 1:
+                    _a.sent();
+                    dispatch({ type: LOGOUT });
+                    return [2 /*return*/];
+            }
+        });
+    }); };
+};
+/**
+ * Clear Errors
+ */
+export var clearErrors = function () { return function (dispatch) {
+    dispatch({ type: CLEAR_ERRORS });
+}; };
+/**
+ * Change Password (Authenticated)
+ */
+export var changeLoggedInUserPassword = function (formData, storage) { return function (dispatch) { return __awaiter(void 0, void 0, void 0, function () {
+    var config, res, err_7;
+    var _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0: return [4 /*yield*/, getAuthConfig(storage)];
+            case 1:
+                config = _b.sent();
+                if (!config) {
+                    return [2 /*return*/, dispatch({ type: AUTHENTICATED_FAIL })];
+                }
+                _b.label = 2;
+            case 2:
+                _b.trys.push([2, 4, , 5]);
+                return [4 /*yield*/, axios.post("".concat(getBaseURL(), "/auth/users/set_password/"), formData, config)];
+            case 3:
+                res = _b.sent();
+                dispatch({
+                    type: PASSWORD_RESET_SUCCESS,
+                    payload: res.data
+                });
+                return [3 /*break*/, 5];
+            case 4:
+                err_7 = _b.sent();
+                dispatch({
+                    type: PASSWORD_RESET_FAIL,
+                    payload: (_a = err_7 === null || err_7 === void 0 ? void 0 : err_7.response) === null || _a === void 0 ? void 0 : _a.data
+                });
+                return [3 /*break*/, 5];
+            case 5: return [2 /*return*/];
+        }
+    });
+}); }; };
+/**
+ * 🔄 Refresh Access Token
+ */
+export var refreshAccessToken = function (storage) { return function (dispatch) { return __awaiter(void 0, void 0, void 0, function () {
+    var refresh, res, access, err_8;
+    var _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                _b.trys.push([0, 6, , 8]);
+                return [4 /*yield*/, ((_a = storage.getRefreshToken) === null || _a === void 0 ? void 0 : _a.call(storage))];
+            case 1:
+                refresh = _b.sent();
+                if (!!refresh) return [3 /*break*/, 3];
+                return [4 /*yield*/, storage.clearTokens()];
+            case 2:
+                _b.sent();
+                return [2 /*return*/, dispatch({
+                        type: AUTHENTICATED_FAIL
+                    })];
+            case 3: return [4 /*yield*/, axios.post("".concat(getBaseURL(), "/auth/jwt/refresh/"), { refresh: refresh })];
+            case 4:
+                res = _b.sent();
+                access = res.data.access;
+                // 💾 Save new access token (keep existing refresh)
+                return [4 /*yield*/, storage.setTokens(access, refresh)];
+            case 5:
+                // 💾 Save new access token (keep existing refresh)
+                _b.sent();
+                dispatch({
+                    type: LOGIN_SUCCESS, // reuse existing flow
+                    payload: {
+                        access: access,
+                        refresh: refresh,
+                        status: res.status
+                    }
+                });
+                // 🔄 Reload user after refresh
+                dispatch(load_user(storage));
+                return [2 /*return*/, access];
+            case 6:
+                err_8 = _b.sent();
+                // ❌ Refresh failed → logout user completely
+                return [4 /*yield*/, storage.clearTokens()];
+            case 7:
+                // ❌ Refresh failed → logout user completely
+                _b.sent();
+                dispatch({
+                    type: AUTHENTICATED_FAIL
+                });
+                return [2 /*return*/, null];
+            case 8: return [2 /*return*/];
+        }
+    });
+}); }; };

package/dist/auth-core/actions/types.d.ts

@@ -0,0 +1,26 @@
+export declare const LOGIN_SUCCESS = "LOGIN_SUCCESS";
+export declare const LOGIN_FAIL = "LOGIN_FAIL";
+export declare const USER_LOADED_SUCCESS = "USER_LOADED_SUCCESS";
+export declare const USER_LOADED_FAIL = "USER_LOADED_FAIL";
+export declare const AUTHENTICATED_SUCCESS = "AUTHENTICATED_SUCCESS";
+export declare const AUTHENTICATED_FAIL = "AUTHENTICATED_FAIL";
+export declare const PASSWORD_RESET_SUCCESS = "PASSWORD_RESET_SUCCESS";
+export declare const PASSWORD_RESET_FAIL = "PASSWORD_RESET_FAIL";
+export declare const PASSWORD_RESET_CONFIRM_SUCCESS = "PASSWORD_RESET_CONFIRM_SUCCESS";
+export declare const PASSWORD_RESET_CONFIRM_FAIL = "PASSWORD_RESET_CONFIRM_FAIL";
+export declare const SIGNUP_SUCCESS = "SIGNUP_SUCCESS";
+export declare const SIGNUP_FAIL = "SIGNUP_FAIL";
+export declare const ACTIVATION_SUCCESS = "ACTIVATION_SUCCESS";
+export declare const ACTIVATION_FAIL = "ACTIVATION_FAIL";
+export declare const GOOGLE_AUTH_SUCCESS = "GOOGLE_AUTH_SUCCESS";
+export declare const GOOGLE_AUTH_FAIL = "GOOGLE_AUTH_FAIL";
+export declare const FACEBOOK_AUTH_SUCCESS = "FACEBOOK_AUTH_SUCCESS";
+export declare const FACEBOOK_AUTH_FAIL = "FACEBOOK_AUTH_FAIL";
+export declare const LOGOUT = "LOGOUT";
+export declare const CLEAR_ERRORS = "CLEAR_ERRORS";
+export interface AuthStorage {
+    getAccessToken: () => Promise<string | null> | string | null;
+    getRefreshToken?: () => Promise<string | null> | string | null;
+    setTokens: (access: string, refresh?: string) => Promise<void> | void;
+    clearTokens: () => Promise<void> | void;
+}

package/dist/auth-core/actions/types.js

@@ -0,0 +1,22 @@
+// The following is an example of what your `types.ts` file should look like.
+// types.ts
+export var LOGIN_SUCCESS = 'LOGIN_SUCCESS';
+export var LOGIN_FAIL = 'LOGIN_FAIL';
+export var USER_LOADED_SUCCESS = 'USER_LOADED_SUCCESS';
+export var USER_LOADED_FAIL = 'USER_LOADED_FAIL';
+export var AUTHENTICATED_SUCCESS = 'AUTHENTICATED_SUCCESS';
+export var AUTHENTICATED_FAIL = 'AUTHENTICATED_FAIL';
+export var PASSWORD_RESET_SUCCESS = 'PASSWORD_RESET_SUCCESS';
+export var PASSWORD_RESET_FAIL = 'PASSWORD_RESET_FAIL';
+export var PASSWORD_RESET_CONFIRM_SUCCESS = 'PASSWORD_RESET_CONFIRM_SUCCESS';
+export var PASSWORD_RESET_CONFIRM_FAIL = 'PASSWORD_RESET_CONFIRM_FAIL';
+export var SIGNUP_SUCCESS = 'SIGNUP_SUCCESS';
+export var SIGNUP_FAIL = 'SIGNUP_FAIL';
+export var ACTIVATION_SUCCESS = 'ACTIVATION_SUCCESS';
+export var ACTIVATION_FAIL = 'ACTIVATION_FAIL';
+export var GOOGLE_AUTH_SUCCESS = 'GOOGLE_AUTH_SUCCESS';
+export var GOOGLE_AUTH_FAIL = 'GOOGLE_AUTH_FAIL';
+export var FACEBOOK_AUTH_SUCCESS = 'FACEBOOK_AUTH_SUCCESS';
+export var FACEBOOK_AUTH_FAIL = 'FACEBOOK_AUTH_FAIL';
+export var LOGOUT = 'LOGOUT';
+export var CLEAR_ERRORS = 'CLEAR_ERRORS';

package/dist/auth-core/apis/apis.d.ts

@@ -0,0 +1 @@
+export declare const createApi: (baseURL: string) => import("axios").AxiosInstance;

package/dist/auth-core/apis/apis.js

@@ -0,0 +1,11 @@
+import axios from "axios";
+export var createApi = function (baseURL) {
+    return axios.create({
+        baseURL: baseURL,
+        timeout: 30000,
+        headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+        },
+    });
+};

package/dist/auth-core/apis/config.d.ts

@@ -0,0 +1,2 @@
+export declare const setBaseURL: (url: string) => void;
+export declare const getBaseURL: () => string;

package/dist/auth-core/apis/config.js

@@ -0,0 +1,10 @@
+var BASE_URL = "";
+export var setBaseURL = function (url) {
+    BASE_URL = url;
+};
+export var getBaseURL = function () {
+    if (!BASE_URL) {
+        throw new Error("API URL not set. Wrap app with AuthProvider.");
+    }
+    return BASE_URL;
+};