react-redux-django-auth 1.4.5 → 1.4.6

package/dist/auth-core/setup/setupAuth.js

@@ -0,0 +1,137 @@
+// import axios from 'axios';
+// import { AuthStorage } from '../actions/types';
+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 };
+    }
+};
+// export const setupAuth = (storage: AuthStorage) => {
+//     const initialize = async () => {
+//         const token = await storage.getAccessToken();
+//         if (token) {
+//             axios.defaults.headers.common['Authorization'] = `JWT ${token}`;
+//         }
+//     };
+//     // const setAuthToken = (token: string) => {
+//     //     axios.defaults.headers.common['Authorization'] = `JWT ${token}`;
+//     // };
+//     // const clearAuthToken = () => {
+//     //     delete axios.defaults.headers.common['Authorization'];
+//     // };
+//     return {
+//         initialize,
+//         // setAuthToken,
+//         // clearAuthToken,
+//     };
+// };
+import { createApi } from "../apis/apis";
+import { getBaseURL } from "../apis/config";
+export var setupAuth = function (storage) {
+    var isRefreshing = false;
+    var failedQueue = [];
+    var api = createApi(getBaseURL());
+    var processQueue = function (error, token) {
+        if (token === void 0) { token = null; }
+        failedQueue.forEach(function (prom) {
+            error ? prom.reject(error) : prom.resolve(token);
+        });
+        failedQueue = [];
+    };
+    var initialize = function () {
+        api.interceptors.request.use(function (config) { 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)
+                            config.headers.Authorization = "JWT ".concat(token);
+                        return [2 /*return*/, config];
+                }
+            });
+        }); });
+        api.interceptors.response.use(function (res) { return res; }, function (error) { return __awaiter(void 0, void 0, void 0, function () {
+            var originalRequest, refresh, res, newAccess, err_1;
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        originalRequest = error.config;
+                        if (!(((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 401 && !originalRequest._retry)) return [3 /*break*/, 8];
+                        if (isRefreshing) {
+                            return [2 /*return*/, new Promise(function (resolve, reject) {
+                                    failedQueue.push({ resolve: resolve, reject: reject });
+                                }).then(function (token) {
+                                    originalRequest.headers.Authorization = "JWT ".concat(token);
+                                    return api(originalRequest);
+                                })];
+                        }
+                        originalRequest._retry = true;
+                        isRefreshing = true;
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 5, 7, 8]);
+                        return [4 /*yield*/, ((_b = storage.getRefreshToken) === null || _b === void 0 ? void 0 : _b.call(storage))];
+                    case 2:
+                        refresh = _c.sent();
+                        if (!refresh)
+                            throw new Error("NO_REFRESH_TOKEN");
+                        return [4 /*yield*/, api.post("/auth/jwt/refresh/", { refresh: refresh })];
+                    case 3:
+                        res = _c.sent();
+                        newAccess = res.data.access;
+                        return [4 /*yield*/, storage.setTokens(newAccess, refresh)];
+                    case 4:
+                        _c.sent();
+                        processQueue(null, newAccess);
+                        originalRequest.headers.Authorization = "JWT ".concat(newAccess);
+                        return [2 /*return*/, api(originalRequest)];
+                    case 5:
+                        err_1 = _c.sent();
+                        processQueue(err_1, null);
+                        return [4 /*yield*/, storage.clearTokens()];
+                    case 6:
+                        _c.sent();
+                        return [2 /*return*/, Promise.reject(err_1)];
+                    case 7:
+                        isRefreshing = false;
+                        return [7 /*endfinally*/];
+                    case 8: return [2 /*return*/, Promise.reject(error)];
+                }
+            });
+        }); });
+    };
+    return { initialize: initialize };
+};

package/dist/auth-core/utils/ExtractErrorMsg.d.ts

@@ -0,0 +1,33 @@
+/**
+ * A type representing a single error message string.
+ */
+type ErrorMessage = string;
+/**
+ * A type representing an array of error messages.
+ */
+type ErrorMessageArray = string[];
+/**
+ * A type representing an object where keys map to either a single error message
+ * or an array of error messages.
+ */
+type ErrorMessageObject = {
+    [key: string]: ErrorMessage | ErrorMessageArray;
+};
+/**
+ * A union type for all possible error message inputs.
+ */
+type ErrorMessageType = ErrorMessage | ErrorMessageArray | ErrorMessageObject;
+/**
+ * Extracts and flattens various error message formats into a single array of strings.
+ *
+ * This function can handle:
+ * - A single string: Returns an array with that string.
+ * - An array of strings: Returns the array as is.
+ * - An object: Iterates through the object's values and extracts all strings
+ * and strings from arrays into a single flattened array.
+ *
+ * @param errorMsg The error message(s) to extract, which can be a string, array, or object.
+ * @returns A flattened array of error message strings.
+ */
+export declare const extractErrorMessages: (errorMsg: ErrorMessageType) => string[];
+export {};

package/dist/auth-core/utils/ExtractErrorMsg.js

@@ -0,0 +1,38 @@
+/**
+ * Extracts and flattens various error message formats into a single array of strings.
+ *
+ * This function can handle:
+ * - A single string: Returns an array with that string.
+ * - An array of strings: Returns the array as is.
+ * - An object: Iterates through the object's values and extracts all strings
+ * and strings from arrays into a single flattened array.
+ *
+ * @param errorMsg The error message(s) to extract, which can be a string, array, or object.
+ * @returns A flattened array of error message strings.
+ */
+export var extractErrorMessages = function (errorMsg) {
+    // If the error message is already a string, wrap it in an array and return it.
+    if (typeof errorMsg === "string") {
+        return [errorMsg];
+    }
+    // If the error message is already an array of strings, return it directly.
+    if (Array.isArray(errorMsg)) {
+        return errorMsg;
+    }
+    // If the error message is an object, iterate through its keys to extract messages.
+    if (typeof errorMsg === "object" && errorMsg !== null) {
+        var extractedMessages_1 = [];
+        Object.keys(errorMsg).forEach(function (key) {
+            var value = errorMsg[key];
+            if (Array.isArray(value)) {
+                extractedMessages_1.push.apply(extractedMessages_1, value);
+            }
+            else if (typeof value === "string") {
+                extractedMessages_1.push(value);
+            }
+        });
+        return extractedMessages_1;
+    }
+    // For any other type, return an empty array.
+    return [];
+};

package/dist/auth-native/AuthProvider.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+type AuthProviderProps = {
+    children: React.ReactNode;
+    apiUrl: string;
+};
+declare const AuthProviderNative: ({ children, apiUrl }: AuthProviderProps) => React.JSX.Element;
+export default AuthProviderNative;

package/dist/auth-native/AuthProvider.js

@@ -0,0 +1,14 @@
+import React, { useEffect } from "react";
+import { Provider } from "react-redux";
+import store from "./store";
+import { setBaseURL } from "../auth-core/apis/config";
+import { auth } from "./index";
+var AuthProviderNative = function (_a) {
+    var children = _a.children, apiUrl = _a.apiUrl;
+    useEffect(function () {
+        setBaseURL(apiUrl);
+        auth.initialize(); // 🔥 attach token to axios on app load
+    }, [apiUrl]);
+    return React.createElement(Provider, { store: store }, children);
+};
+export default AuthProviderNative;

package/dist/auth-native/biometrics/biometricService.d.ts

@@ -0,0 +1,4 @@
+export declare const biometricService: {
+    isAvailable(): Promise<boolean>;
+    authenticate(): Promise<boolean>;
+};

package/dist/auth-native/biometrics/biometricService.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 };
+    }
+};
+import * as LocalAuthentication from "expo-local-authentication";
+export var biometricService = {
+    isAvailable: function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var hasHardware, isEnrolled;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, LocalAuthentication.hasHardwareAsync()];
+                    case 1:
+                        hasHardware = _a.sent();
+                        return [4 /*yield*/, LocalAuthentication.isEnrolledAsync()];
+                    case 2:
+                        isEnrolled = _a.sent();
+                        return [2 /*return*/, hasHardware && isEnrolled];
+                }
+            });
+        });
+    },
+    authenticate: function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, LocalAuthentication.authenticateAsync({
+                            promptMessage: "Authenticate to continue",
+                            fallbackLabel: "Use Passcode",
+                        })];
+                    case 1:
+                        result = _a.sent();
+                        if (!result.success) {
+                            throw new Error("BIOMETRIC_FAILED");
+                        }
+                        return [2 /*return*/, true];
+                }
+            });
+        });
+    },
+};

package/dist/auth-native/hooks/useBiometricAuth.d.ts

@@ -0,0 +1,9 @@
+import { AuthStorage } from "../../auth-core/actions/types";
+interface Props {
+    storage: AuthStorage;
+}
+declare const useBiometricAuth: ({ storage }: Props) => {
+    authenticate: () => Promise<any>;
+    loading: boolean;
+};
+export default useBiometricAuth;

package/dist/auth-native/hooks/useBiometricAuth.js

@@ -0,0 +1,87 @@
+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 { useState, useCallback } from "react";
+import { useDispatch } from "react-redux";
+import { biometricService } from "../biometrics/biometricService";
+import { refreshAccessToken } from "../../auth-core/actions/authActions";
+var useBiometricAuth = function (_a) {
+    var storage = _a.storage;
+    var _b = useState(false), loading = _b[0], setLoading = _b[1];
+    var dispatch = useDispatch();
+    var authenticate = useCallback(function () { return __awaiter(void 0, void 0, void 0, function () {
+        var available, access, newAccess, err_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    setLoading(true);
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 6, 7, 8]);
+                    return [4 /*yield*/, biometricService.isAvailable()];
+                case 2:
+                    available = _a.sent();
+                    if (!available)
+                        throw new Error("BIOMETRIC_NOT_AVAILABLE");
+                    // Prompt user for biometric
+                    return [4 /*yield*/, biometricService.authenticate()];
+                case 3:
+                    // Prompt user for biometric
+                    _a.sent();
+                    return [4 /*yield*/, storage.getAccessToken()];
+                case 4:
+                    access = _a.sent();
+                    if (access)
+                        return [2 /*return*/, access];
+                    return [4 /*yield*/, dispatch(refreshAccessToken(storage))];
+                case 5:
+                    newAccess = _a.sent();
+                    if (!newAccess)
+                        throw new Error("REFRESH_FAILED: please login");
+                    return [2 /*return*/, newAccess];
+                case 6:
+                    err_1 = _a.sent();
+                    throw err_1;
+                case 7:
+                    setLoading(false);
+                    return [7 /*endfinally*/];
+                case 8: return [2 /*return*/];
+            }
+        });
+    }); }, [storage, dispatch]);
+    return { authenticate: authenticate, loading: loading };
+};
+export default useBiometricAuth;

package/dist/auth-native/hooks/useGoogleAuth.d.ts

@@ -0,0 +1,13 @@
+import { AuthStorage } from "../../auth-core/actions/types";
+interface UseGoogleAuthProps {
+    storage: AuthStorage;
+}
+declare const useGoogleAuthNative: ({ storage }: UseGoogleAuthProps) => {
+    loginWithGoogle: (payload?: Record<string, any>) => Promise<{
+        user: any;
+        tokens: any;
+    }>;
+    loading: boolean;
+    error: any;
+};
+export default useGoogleAuthNative;

package/dist/auth-native/hooks/useGoogleAuth.js

@@ -0,0 +1,145 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 { useState, useCallback } from "react";
+import { GoogleSignin, statusCodes, } from "@react-native-google-signin/google-signin";
+import { useDispatch } from "react-redux";
+import axios from "axios";
+import { getBaseURL } from "../../auth-core/apis/config";
+var useGoogleAuthNative = function (_a) {
+    var storage = _a.storage;
+    var dispatch = useDispatch();
+    var _b = useState(false), loading = _b[0], setLoading = _b[1];
+    var _c = useState(null), error = _c[0], setError = _c[1];
+    var signInWithGoogle = function () { return __awaiter(void 0, void 0, void 0, function () {
+        var userInfo, idToken, err_1;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 3, , 4]);
+                    return [4 /*yield*/, GoogleSignin.hasPlayServices()];
+                case 1:
+                    _b.sent();
+                    return [4 /*yield*/, GoogleSignin.signIn()];
+                case 2:
+                    userInfo = _b.sent();
+                    idToken = (_a = userInfo === null || userInfo === void 0 ? void 0 : userInfo.data) === null || _a === void 0 ? void 0 : _a.idToken;
+                    if (!idToken)
+                        throw new Error("NO_ID_TOKEN");
+                    return [2 /*return*/, idToken];
+                case 3:
+                    err_1 = _b.sent();
+                    if (err_1.code === statusCodes.SIGN_IN_CANCELLED) {
+                        throw new Error("SIGN_IN_CANCELLED");
+                    }
+                    if (err_1.code === statusCodes.IN_PROGRESS) {
+                        throw new Error("IN_PROGRESS");
+                    }
+                    if (err_1.code === statusCodes.PLAY_SERVICES_NOT_AVAILABLE) {
+                        throw new Error("PLAY_SERVICES_NOT_AVAILABLE");
+                    }
+                    throw new Error("GOOGLE_SIGN_IN_FAILED");
+                case 4: return [2 /*return*/];
+            }
+        });
+    }); };
+    var loginWithGoogle = useCallback(function (payload) { return __awaiter(void 0, void 0, void 0, function () {
+        var idToken, res, _a, user, tokens, err_2;
+        var _b, _c, _d;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    setLoading(true);
+                    setError(null);
+                    _e.label = 1;
+                case 1:
+                    _e.trys.push([1, 5, 6, 7]);
+                    return [4 /*yield*/, signInWithGoogle()];
+                case 2:
+                    idToken = _e.sent();
+                    return [4 /*yield*/, axios.post("".concat(getBaseURL(), "/auth/o/google-oauth2/"), __assign({ access_token: idToken }, payload))];
+                case 3:
+                    res = _e.sent();
+                    _a = ((_b = res.data) === null || _b === void 0 ? void 0 : _b.data) || {}, user = _a.user, tokens = _a.tokens;
+                    if (!(tokens === null || tokens === void 0 ? void 0 : tokens.access) || !user) {
+                        throw new Error("INVALID_RESPONSE");
+                    }
+                    return [4 /*yield*/, storage.setTokens(tokens.access, tokens.refresh)];
+                case 4:
+                    _e.sent();
+                    dispatch({
+                        type: "GOOGLE_AUTH_SUCCESS",
+                        payload: {
+                            access: tokens.access,
+                            refresh: tokens.refresh,
+                            status: res.status,
+                        },
+                    });
+                    return [2 /*return*/, { user: user, tokens: tokens }];
+                case 5:
+                    err_2 = _e.sent();
+                    setError(((_c = err_2 === null || err_2 === void 0 ? void 0 : err_2.response) === null || _c === void 0 ? void 0 : _c.data) || err_2.message);
+                    dispatch({
+                        type: "GOOGLE_AUTH_FAIL",
+                        payload: (_d = err_2 === null || err_2 === void 0 ? void 0 : err_2.response) === null || _d === void 0 ? void 0 : _d.data,
+                    });
+                    throw err_2;
+                case 6:
+                    setLoading(false);
+                    return [7 /*endfinally*/];
+                case 7: return [2 /*return*/];
+            }
+        });
+    }); }, [storage, dispatch]);
+    return {
+        loginWithGoogle: loginWithGoogle,
+        loading: loading,
+        error: error,
+    };
+};
+export default useGoogleAuthNative;

package/dist/auth-native/index.d.ts

@@ -0,0 +1,6 @@
+export declare const auth: {
+    initialize: () => void;
+};
+export { default as AuthProvider } from './AuthProvider';
+export { default as store } from './store';
+export { default as useGoogleAuthNative } from './hooks/useGoogleAuth';

package/dist/auth-native/index.js

@@ -0,0 +1,6 @@
+import { setupAuth } from '../auth-core/setup/setupAuth';
+import { storage } from './storage/nativeStorage';
+export var auth = setupAuth(storage);
+export { default as AuthProvider } from './AuthProvider';
+export { default as store } from './store';
+export { default as useGoogleAuthNative } from './hooks/useGoogleAuth';

package/dist/auth-native/storage/nativeStorage.d.ts

@@ -0,0 +1,18 @@
+export declare const storage: {
+    /**
+     * 🔑 Access token (fast access)
+     */
+    getAccessToken: () => Promise<string | null>;
+    /**
+     * 🔁 Refresh token (SECURED with biometrics)
+     */
+    getRefreshToken: () => Promise<string | null>;
+    /**
+     * 💾 Save tokens
+     */
+    setTokens: (access: string, refresh?: string) => Promise<void>;
+    /**
+     * 🧹 Clear tokens
+     */
+    clearTokens: () => Promise<void>;
+};