@explita/cloud-auth-client 0.0.1

package/dist/contexts/auth-provider.js

@@ -0,0 +1,208 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthProvider = AuthProvider;
+exports.useAuth = useAuth;
+const react_1 = __importStar(require("react"));
+const utils_1 = require("../lib/utils");
+const api_1 = require("../lib/api");
+const loader_1 = require("../components/loader");
+const error_1 = require("../lib/error");
+const use_token_refresher_1 = require("../hooks/use-token-refresher");
+const optional_otp_wrapper_1 = require("../components/optional-otp-wrapper");
+const refresh_helper_1 = require("../lib/refresh-helper");
+const AuthContext = (0, react_1.createContext)(undefined);
+function AuthProvider({ children, config }) {
+    const [twoFAData, setTwoFAData] = (0, react_1.useState)(null);
+    const [user, setUser] = (0, react_1.useState)(null);
+    const [loading, setLoading] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    const [isAuthenticated, setIsAuthenticated] = (0, react_1.useState)(false);
+    const [transition, startTransition] = (0, react_1.useTransition)();
+    const withFullObject = (0, utils_1.shouldPassFullUserObject)();
+    const computedRouteContext = (0, utils_1.buildRouteContext)(config);
+    const { loginUrl, resetPasswordUrl, dashboardUrl, returnPath, isExcluded } = computedRouteContext;
+    const { disableLoading = false } = config || {};
+    async function redirectAfterLogin(authToken, tempRefreshToken) {
+        var _a;
+        await ((_a = config === null || config === void 0 ? void 0 : config.cookieOverride) === null || _a === void 0 ? void 0 : _a.call(config, tempRefreshToken));
+        localStorage.setItem(refresh_helper_1.AUTH_TOKEN_KEY, authToken);
+        const returnPath = new URLSearchParams(window.location.search).get("returnPath");
+        window.location.href = returnPath ? returnPath : dashboardUrl;
+    }
+    const fetchCurrentUser = (0, react_1.useCallback)(async () => {
+        const token = (0, utils_1.getClientToken)();
+        if (!token && !isExcluded) {
+            return await logout("session_expired");
+        }
+        if (!token)
+            return;
+        if (!navigator.onLine) {
+            try {
+                const payload = (0, utils_1.parseJwt)(token);
+                setUser(payload === null || payload === void 0 ? void 0 : payload.user);
+                setIsAuthenticated(true);
+            }
+            catch (e) {
+                console.warn("[ecp-auth] Invalid token format:", e);
+            }
+            console.warn("[ecp-auth] Offline — skipping fetchCurrentUser()");
+            return;
+        }
+        setLoading(true);
+        try {
+            const res = await (0, api_1.apiFactory)("/me", { method: "GET" });
+            setUser(res.user);
+            setIsAuthenticated(true);
+        }
+        catch (err) {
+            console.warn("[ecp-auth] Failed to fetch user:", err);
+            await logout("session_expired");
+        }
+        finally {
+            setLoading(false);
+        }
+    }, []);
+    (0, react_1.useEffect)(() => {
+        fetchCurrentUser();
+    }, []);
+    async function login(credentials) {
+        setError(null);
+        setLoading(true);
+        try {
+            const res = await (0, api_1.apiFactory)("/login", {
+                body: {
+                    ...credentials,
+                    withFullObject,
+                },
+            });
+            const { authToken, user, with2fa } = res;
+            if (authToken && !with2fa) {
+                setIsAuthenticated(true);
+                await redirectAfterLogin(authToken, res.tempRefreshToken);
+                return null;
+            }
+            setTwoFAData(user);
+            return null;
+        }
+        catch (err) {
+            if ((0, error_1.isAPIError)(err)) {
+                setError(err.data);
+                return err.data;
+            }
+            return { message: err.message, status: "failure" };
+        }
+        finally {
+            setLoading(false);
+        }
+    }
+    async function sendPasswordResetRequest(email) {
+        try {
+            const res = await (0, api_1.apiFactory)("/reset-password", {
+                body: { email, passwordResetLink: resetPasswordUrl },
+            });
+            return res;
+        }
+        catch (err) {
+            if ((0, error_1.isAPIError)(err)) {
+                return err.data;
+            }
+            return { message: err.message, status: "failure" };
+        }
+    }
+    async function logout(reason = "", params) {
+        var _a;
+        try {
+            await (0, api_1.apiFactory)("/logout");
+        }
+        catch (err) {
+            console.log(err);
+        }
+        finally {
+            localStorage.removeItem(refresh_helper_1.AUTH_TOKEN_KEY);
+            localStorage.removeItem(refresh_helper_1.LEADING_TAB_KEY);
+            localStorage.removeItem(refresh_helper_1.AUTH_RETRY_STATE_KEY);
+            await ((_a = config === null || config === void 0 ? void 0 : config.cookieOverride) === null || _a === void 0 ? void 0 : _a.call(config, ""));
+            const fullParams = new URLSearchParams({
+                reason,
+                ...params,
+            }).toString();
+            if (typeof window !== "undefined") {
+                window.location.href = `${loginUrl}?${returnPath}&${fullParams}`;
+            }
+        }
+    }
+    (0, use_token_refresher_1.useTokenRefresher)({
+        config,
+        refreshTokenRequest: async () => {
+            const res = await (0, api_1.apiFactory)("/refresh", {
+                body: {
+                    withFullObject,
+                },
+            });
+            return res;
+        },
+        onTokenRefreshed: (authToken, tempRefreshToken) => {
+            var _a;
+            localStorage.setItem(refresh_helper_1.AUTH_TOKEN_KEY, authToken);
+            (_a = config === null || config === void 0 ? void 0 : config.cookieOverride) === null || _a === void 0 ? void 0 : _a.call(config, tempRefreshToken);
+        },
+        revalidateUserWhenOnline: fetchCurrentUser,
+        onRefreshFailed: async () => await logout("session_expired"),
+    });
+    return (react_1.default.createElement(react_1.default.Fragment, null,
+        react_1.default.createElement(optional_otp_wrapper_1.OptionalOTPWrapper, { user: twoFAData, onVerified: redirectAfterLogin, onCanceled: () => {
+                setTwoFAData(null);
+            } }),
+        !disableLoading && loading && react_1.default.createElement(loader_1.Loader, null),
+        react_1.default.createElement(AuthContext.Provider, { value: {
+                user,
+                authLoading: loading,
+                isAuthenticated,
+                error,
+                computedRouteContext,
+                login,
+                sendPasswordResetRequest,
+                logout: (params) => logout("user_logout", params),
+                hasPermission: (permission) => (0, utils_1.hasPermission)(user, permission),
+                revalidate: () => startTransition(fetchCurrentUser),
+            } }, children)));
+}
+function useAuth() {
+    const ctx = (0, react_1.useContext)(AuthContext);
+    if (!ctx)
+        throw new Error("useAuth must be used inside AuthProvider");
+    return ctx;
+}

package/dist/hooks/use-token-refresher.d.ts

@@ -0,0 +1,2 @@
+import { UseTokenRefresherOptions } from "../types";
+export declare function useTokenRefresher({ refreshTokenRequest, onRefreshFailed, onTokenRefreshed, revalidateUserWhenOnline, config, }: UseTokenRefresherOptions): void;

package/dist/hooks/use-token-refresher.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTokenRefresher = useTokenRefresher;
+const utils_1 = require("../lib/utils");
+const react_1 = require("react");
+const refresh_helper_1 = require("../lib/refresh-helper");
+function useTokenRefresher({ refreshTokenRequest, onRefreshFailed, onTokenRefreshed, revalidateUserWhenOnline, config, }) {
+    const refreshing = (0, react_1.useRef)(false);
+    const interval = (0, react_1.useRef)(null);
+    const { isExcluded } = (0, utils_1.buildRouteContext)(config);
+    async function refreshIfNeeded() {
+        if (!navigator.onLine) {
+            console.debug("[ecp-auth] Skipping token refresh: offline");
+            return;
+        }
+        // Only the leader should perform refresh
+        if (!(0, refresh_helper_1.isLeader)()) {
+            // Try to become leader if leader is stale
+            if (!(0, refresh_helper_1.tryToBecomeLeader)())
+                return;
+        }
+        // Leadership renewal (keep-alive)
+        (0, refresh_helper_1.renewLeadership)();
+        if (refreshing.current)
+            return;
+        refreshing.current = true;
+        const token = (0, utils_1.getClientToken)();
+        if (!token && !isExcluded) {
+            onRefreshFailed === null || onRefreshFailed === void 0 ? void 0 : onRefreshFailed();
+            refreshing.current = false;
+            return;
+        }
+        if (!token) {
+            refreshing.current = false;
+            return;
+        }
+        try {
+            let shouldRefresh = false;
+            try {
+                const payload = (0, utils_1.parseJwt)(token);
+                const expiresAt = payload.exp * 1000;
+                const timeLeft = expiresAt - Date.now();
+                if (timeLeft < refresh_helper_1.thresholdMs) {
+                    shouldRefresh = true;
+                }
+                else {
+                    console.debug(`[ecp-auth] Token still valid: ${Math.floor(timeLeft / 1000)}s left`);
+                }
+            }
+            catch (e) {
+                console.warn("[ecp-auth] Invalid token format, skipping refresh.");
+                onRefreshFailed === null || onRefreshFailed === void 0 ? void 0 : onRefreshFailed();
+            }
+            if (shouldRefresh) {
+                const { authToken, tempRefreshToken } = await refreshTokenRequest();
+                if (!authToken) {
+                    onRefreshFailed === null || onRefreshFailed === void 0 ? void 0 : onRefreshFailed();
+                }
+                else {
+                    onTokenRefreshed === null || onTokenRefreshed === void 0 ? void 0 : onTokenRefreshed(authToken, tempRefreshToken);
+                }
+            }
+        }
+        catch (err) {
+            const success = await (0, refresh_helper_1.tryRefreshWithRetry)(refreshTokenRequest);
+            if (!success) {
+                onRefreshFailed === null || onRefreshFailed === void 0 ? void 0 : onRefreshFailed();
+                console.warn("[ecp-auth] All retry attempts failed, triggering logout.");
+            }
+        }
+        finally {
+            refreshing.current = false;
+        }
+    }
+    (0, react_1.useEffect)(() => {
+        refreshIfNeeded(); // run once on mount
+        interval.current = setInterval(refreshIfNeeded, refresh_helper_1.intervalMs);
+        function onVisible() {
+            if (document.visibilityState === "visible") {
+                refreshIfNeeded();
+            }
+        }
+        function onOnline() {
+            refreshIfNeeded();
+            if (typeof revalidateUserWhenOnline === "function") {
+                revalidateUserWhenOnline();
+            }
+        }
+        document.addEventListener("visibilitychange", onVisible);
+        window.addEventListener("online", onOnline);
+        return () => {
+            clearInterval(interval.current);
+            document.removeEventListener("visibilitychange", onVisible);
+            window.removeEventListener("online", onOnline);
+        };
+    }, []);
+    (0, react_1.useEffect)(() => {
+        function onStorage(e) {
+            if (e.key === refresh_helper_1.LEADING_TAB_KEY) {
+                // If leader changes, check if we need to act
+                // Optionally, you can trigger a refresh of local state here
+            }
+            if (e.key === refresh_helper_1.AUTH_RETRY_STATE_KEY) {
+                // Optionally, react to retry state changes
+            }
+        }
+        window.addEventListener("storage", onStorage);
+        return () => window.removeEventListener("storage", onStorage);
+    }, []);
+    (0, react_1.useEffect)(() => {
+        if (!(0, refresh_helper_1.isLeader)())
+            return;
+        const renewInterval = setInterval(() => {
+            (0, refresh_helper_1.renewLeadership)();
+        }, refresh_helper_1.LEADER_TIMEOUT / 2); // Renew halfway before timeout
+        return () => clearInterval(renewInterval);
+    }, [refresh_helper_1.isLeader]);
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./contexts/auth-provider";
+export * from "./components/message";
+export { buildRouteContext } from "./lib/utils";
+export type { AuthConfig, Project, Service, ServiceType, User, Role, Status, NewRole, UpdateUser, GeneralResponse, FormResponse, VerifyUser, VerifyUserResponse, ResetPasswordWithToken, ResetPasswordWithUserId, Signup, Login, Otp, } from "./types";

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRouteContext = void 0;
+__exportStar(require("./contexts/auth-provider"), exports);
+__exportStar(require("./components/message"), exports);
+var utils_1 = require("./lib/utils");
+Object.defineProperty(exports, "buildRouteContext", { enumerable: true, get: function () { return utils_1.buildRouteContext; } });

package/dist/lib/api-client.d.ts

@@ -0,0 +1,2 @@
+import { ApiOptions } from "../types";
+export declare function apiClient<T = any>(path: string, options?: ApiOptions): Promise<T>;

package/dist/lib/api-client.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiClient = apiClient;
+const error_1 = require("./error");
+const utils_1 = require("./utils");
+// CLIENT: browser-side calls using public token
+async function apiClient(path, options) {
+    const [apiUrl, apiKey] = atob((0, utils_1.getPublicTokenEnv)()).split("$");
+    if (!apiUrl || !apiKey) {
+        throw new Error("Invalid API URL or API key. Please set ECP_AUTH_PUBLIC_TOKEN (or the VITE_/NEXT_PUBLIC_ equivalent) in your .env file. Check admin dashboard for env variables.");
+    }
+    const token = (0, utils_1.getClientToken)(); // from localStorage
+    const { method = "POST", body, headers, ...rest } = options !== null && options !== void 0 ? options : {};
+    const res = await fetch(`${apiUrl}${path}`, {
+        method,
+        body: body ? JSON.stringify(body) : undefined,
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`,
+            "x-api-key": apiKey,
+            "x-is-global": process.env.NEXT_PUBLIC_ECP_GLOBAL === "true" ? "true" : "false",
+            ...headers,
+        },
+        credentials: "include",
+        ...rest,
+    });
+    if (!res.ok) {
+        let errorData;
+        try {
+            errorData = await res.json();
+        }
+        catch {
+            errorData = { message: "Something went wrong." };
+        }
+        throw new error_1.APIError(errorData.message || "Unexpected error occurred.", errorData, res.status);
+    }
+    return (await res.json());
+}

package/dist/lib/api-server.d.ts

@@ -0,0 +1,2 @@
+import { ApiOptions } from "../types";
+export declare function apiServer<T = any>(apiPath: string, options?: ApiOptions): Promise<T>;

package/dist/lib/api-server.js

@@ -0,0 +1,39 @@
+"use server";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiServer = apiServer;
+const error_1 = require("./error");
+const server_token_1 = require("../server/server-token");
+// SERVER: secure-only calls using private key
+async function apiServer(apiPath, options) {
+    var _a;
+    let [apiUrl, apiKey] = atob((_a = process.env.ECP_AUTH_PRIVATE_TOKEN) !== null && _a !== void 0 ? _a : "").split("$");
+    if ((!apiUrl || !apiKey) && !(options === null || options === void 0 ? void 0 : options.adminCall)) {
+        throw new Error("Invalid API URL or API key, please set ECP_AUTH_PRIVATE_TOKEN in your .env file. Check admin dashboard for env variables.");
+    }
+    let token = await (0, server_token_1.getServerToken)();
+    const { method = "POST", body, headers, adminCall, ...rest } = options !== null && options !== void 0 ? options : {};
+    const res = await fetch(`${apiUrl}${apiPath}`, {
+        method,
+        body: body ? JSON.stringify(body) : undefined,
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`,
+            "x-api-key": apiKey,
+            "x-is-global": process.env.NEXT_PUBLIC_ECP_GLOBAL === "true" ? "true" : "false",
+            ...headers,
+        },
+        ...rest,
+    });
+    if (!res.ok) {
+        let errorData;
+        try {
+            errorData = await res.json();
+        }
+        catch {
+            errorData = { message: "Something went wrong." };
+        }
+        throw new error_1.APIError(errorData.message || "Unexpected error occurred.", errorData, res.status);
+    }
+    return (await res.json());
+}

package/dist/lib/api.d.ts

@@ -0,0 +1,2 @@
+import { ApiOptions } from "../types";
+export declare function apiFactory<T extends any = any>(path: string, options?: ApiOptions): Promise<T>;

package/dist/lib/api.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiFactory = apiFactory;
+const api_server_1 = require("./api-server");
+const api_client_1 = require("./api-client");
+// Auto-switcher: picks correct one
+function apiFactory(path, options) {
+    const isServer = typeof window === "undefined";
+    return isServer ? (0, api_server_1.apiServer)(path, options) : (0, api_client_1.apiClient)(path, options);
+}

package/dist/lib/error.d.ts

@@ -0,0 +1,6 @@
+export declare class APIError extends Error {
+    data: any;
+    status: number;
+    constructor(message: string, data: any, status: number);
+}
+export declare function isAPIError(err: any): err is APIError;

package/dist/lib/error.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIError = void 0;
+exports.isAPIError = isAPIError;
+class APIError extends Error {
+    constructor(message, data, status) {
+        super(message);
+        this.data = data;
+        this.status = status;
+    }
+}
+exports.APIError = APIError;
+function isAPIError(err) {
+    return (err === null || err === void 0 ? void 0 : err.data) !== undefined;
+}

package/dist/lib/refresh-helper.d.ts

@@ -0,0 +1,12 @@
+import { UseTokenRefresherOptions } from "../types";
+export declare const AUTH_TOKEN_KEY = "_ecp_auth_token";
+export declare const AUTH_RETRY_STATE_KEY = "_ecp_auth_retry_state";
+export declare const LEADING_TAB_KEY = "_ecp_leading_tab";
+export declare const LEADER_TIMEOUT: number;
+export declare const thresholdMs: number;
+export declare const intervalMs: number;
+export declare function tryRefreshWithRetry(refreshTokenRequest: UseTokenRefresherOptions["refreshTokenRequest"]): Promise<boolean>;
+export declare function isLeader(): boolean | undefined;
+export declare function becomeLeader(): void;
+export declare function renewLeadership(): void;
+export declare function tryToBecomeLeader(): boolean | undefined;

package/dist/lib/refresh-helper.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.intervalMs = exports.thresholdMs = exports.LEADER_TIMEOUT = exports.LEADING_TAB_KEY = exports.AUTH_RETRY_STATE_KEY = exports.AUTH_TOKEN_KEY = void 0;
+exports.tryRefreshWithRetry = tryRefreshWithRetry;
+exports.isLeader = isLeader;
+exports.becomeLeader = becomeLeader;
+exports.renewLeadership = renewLeadership;
+exports.tryToBecomeLeader = tryToBecomeLeader;
+const utils_1 = require("./utils");
+exports.AUTH_TOKEN_KEY = "_ecp_auth_token";
+exports.AUTH_RETRY_STATE_KEY = "_ecp_auth_retry_state";
+exports.LEADING_TAB_KEY = "_ecp_leading_tab";
+exports.LEADER_TIMEOUT = 2 * 60 * 1000;
+exports.thresholdMs = 2 * 60000;
+exports.intervalMs = 1 * 60000;
+const retryDelayMs = 60000;
+const maxRetries = 5;
+const backoffFactor = 2;
+async function tryRefreshWithRetry(refreshTokenRequest) {
+    var _a;
+    const savedState = JSON.parse(localStorage.getItem(exports.AUTH_RETRY_STATE_KEY) || "{}");
+    for (let attempt = (_a = savedState === null || savedState === void 0 ? void 0 : savedState.attemptNumber) !== null && _a !== void 0 ? _a : 1; attempt <= maxRetries; attempt++) {
+        try {
+            await refreshTokenRequest();
+            localStorage.removeItem(exports.AUTH_RETRY_STATE_KEY);
+            return true; // ✅ success!
+        }
+        catch (err) {
+            console.warn(`[ecp-auth] Silent refresh attempt ${attempt} failed`, err);
+            if (attempt < maxRetries) {
+                localStorage.setItem(exports.AUTH_RETRY_STATE_KEY, JSON.stringify({
+                    lastAttempt: Date.now(),
+                    attemptNumber: attempt,
+                }));
+                const delay = retryDelayMs * Math.pow(backoffFactor, attempt - 1);
+                console.info(`[ecp-auth] Retrying in ${delay}ms...`);
+                await new Promise((res) => setTimeout(res, delay));
+            }
+        }
+    }
+    return false; // ❌ All retries failed
+}
+const TAB_ID = (() => {
+    // Use crypto if available, fallback to timestamp+random
+    if (typeof crypto !== "undefined" && crypto.randomUUID) {
+        return crypto.randomUUID();
+    }
+    return `${Date.now()}-${Math.random()}`;
+})();
+function isLeader() {
+    if (typeof localStorage === "undefined")
+        return;
+    const leaderData = JSON.parse(localStorage.getItem(exports.LEADING_TAB_KEY) || "{}");
+    if (!leaderData.id || !leaderData.timestamp)
+        return false;
+    // If leader is stale, allow takeover
+    if (Date.now() - leaderData.timestamp > exports.LEADER_TIMEOUT)
+        return false;
+    return leaderData.id === TAB_ID;
+}
+function becomeLeader() {
+    const authToken = (0, utils_1.getClientToken)();
+    if (!authToken)
+        return;
+    localStorage.setItem(exports.LEADING_TAB_KEY, JSON.stringify({ id: TAB_ID, timestamp: Date.now() }));
+}
+function renewLeadership() {
+    // Called periodically by leader to keep leadership
+    if (isLeader()) {
+        becomeLeader();
+    }
+}
+function tryToBecomeLeader() {
+    if (typeof localStorage === "undefined")
+        return;
+    const leaderData = JSON.parse(localStorage.getItem(exports.LEADING_TAB_KEY) || "{}");
+    if (!leaderData.id || Date.now() - leaderData.timestamp > exports.LEADER_TIMEOUT) {
+        becomeLeader();
+        return true;
+    }
+    return false;
+}

package/dist/lib/utils.d.ts

@@ -0,0 +1,21 @@
+import { AuthConfig, User } from "../types";
+export declare function cn(...classes: (string | false | null | undefined)[]): string;
+export declare function unstuckPointerEvents(): void;
+export declare function buildRouteContext(config?: AuthConfig, currentPath?: string): {
+    loginUrl: string;
+    signupUrl: string;
+    dashboardUrl: string;
+    resetPasswordUrl: string;
+    returnPath: string;
+    currentPath: string;
+    excludedPaths: string[];
+    isExcluded: boolean;
+};
+export declare function getClientToken(): string;
+export declare function hasPermission(user: User | null, permission: string): boolean;
+export declare function parseMessage(message: string): string;
+export declare function parseJwt(token: string): any;
+export declare function isOtpAvailable(): boolean;
+export declare function shouldPassFullUserObject(): boolean;
+export declare function getPublicTokenEnv(): string;
+export declare function getPrivateTokenEnv(): string;